Spring的创建和使用

我们先来看一下Spring的创建和使用吧！！

目标一：创建Spring(Core)项目：

创建Maven项目 Name：项目名称（不能有中文）

Location：项目保存路径（不能有中文）

GroupId：组织（公司）标识（到写：com.baidu.www）

ArtifactId：项目标识

Version：项目版本号

添加Spring依赖（出错概率极高）配置Maven国内源（非常重要）

Idea设置文件有两个（需要设置两个配置文件的国内源配置）

一个是当前项目配置文件

另一个是新项目配置文件（如下图所示）然后在根据上面截图进行配置即可~

设置setting.xml 文件：

另外：需要在文件管理器中打开该地址

新建一个Setting.xml文件，如果没有直接用小编的代码即可，

如果有的话，那么，需要手动配置阿里源（其他源也可）

<?xml version="1.0" encoding="UTF-8"?>

<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<!--
 | This is the configuration file for Maven. It can be specified at two levels:
 |
 |  1. User Level. This settings.xml file provides configuration for a single user,
 |                 and is normally provided in ${user.home}/.m2/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -s /path/to/user/settings.xml
 |
 |  2. Global Level. This settings.xml file provides configuration for all Maven
 |                 users on a machine (assuming they're all using the same Maven
 |                 installation). It's normally provided in
 |                 ${maven.conf}/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -gs /path/to/global/settings.xml
 |
 | The sections in this sample file are intended to give you a running start at
 | getting the most out of your Maven installation. Where appropriate, the default
 | values (values used when the setting is not specified) are provided.
 |
 |-->
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->

  <!-- interactiveMode
   | This will determine whether maven prompts you when it needs input. If set to false,
   | maven will use a sensible default value, perhaps based on some other setting, for
   | the parameter in question.
   |
   | Default: true
  <interactiveMode>true</interactiveMode>
  -->

  <!-- offline
   | Determines whether maven should attempt to connect to the network when executing a build.
   | This will have an effect on artifact downloads, artifact deployment, and others.
   |
   | Default: false
  <offline>false</offline>
  -->

  <!-- pluginGroups
   | This is a list of additional group identifiers that will be searched when resolving plugins by their prefix, i.e.
   | when invoking a command line like "mvn prefix:goal". Maven will automatically add the group identifiers
   | "org.apache.maven.plugins" and "org.codehaus.mojo" if these are not already contained in the list.
   |-->
  <pluginGroups>
    <!-- pluginGroup
     | Specifies a further group identifier to use for plugin lookup.
    <pluginGroup>com.your.plugins</pluginGroup>
    -->
  </pluginGroups>

  <!-- proxies
   | This is a list of proxies which can be used on this machine to connect to the network.
   | Unless otherwise specified (by system property or command-line switch), the first proxy
   | specification in this list marked as active will be used.
   |-->
  <proxies>
    <!-- proxy
     | Specification for one proxy, to be used in connecting to the network.
     |
    <proxy>
      <id>optional</id>
      <active>true</active>
      <protocol>http</protocol>
      <username>proxyuser</username>
      <password>proxypass</password>
      <host>proxy.host.net</host>
      <port>80</port>
      <nonProxyHosts>local.net|some.host.com</nonProxyHosts>
    </proxy>
    -->
  </proxies>

  <!-- servers
   | This is a list of authentication profiles, keyed by the server-id used within the system.
   | Authentication profiles can be used whenever maven must make a connection to a remote server.
   |-->
  <servers>
    <!-- server
     | Specifies the authentication information to use when connecting to a particular server, identified by
     | a unique name within the system (referred to by the 'id' attribute below).
     |
     | NOTE: You should either specify username/password OR privateKey/passphrase, since these pairings are
     |       used together.
     |
    <server>
      <id>deploymentRepo</id>
      <username>repouser</username>
      <password>repopwd</password>
    </server>
    -->

    <!-- Another sample, using keys to authenticate.
    <server>
      <id>siteServer</id>
      <privateKey>/path/to/private/key</privateKey>
      <passphrase>optional; leave empty if not used.</passphrase>
    </server>
    -->
  </servers>

  <!-- mirrors
   | This is a list of mirrors to be used in downloading artifacts from remote repositories.
   |
   | It works like this: a POM may declare a repository to use in resolving certain artifacts.
   | However, this repository may have problems with heavy traffic at times, so people have mirrored
   | it to several places.
   |
   | That repository definition will have a unique id, so we can create a mirror reference for that
   | repository, to be used as an alternate download site. The mirror site will be the preferred
   | server for that repository.
   |-->
  <mirrors>
   <mirror>
        <id>alimaven</id>
        <name>aliyun maven</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        <mirrorOf>central</mirrorOf>        
      </mirror>
    <!-- mirror
     | Specifies a repository mirror site to use instead of a given repository. The repository that
     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
     |
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://my.repository.com/repo/path</url>
    </mirror>
     -->
  </mirrors>

  <!-- profiles
   | This is a list of profiles which can be activated in a variety of ways, and which can modify
   | the build process. Profiles provided in the settings.xml are intended to provide local machine-
   | specific paths and repository locations which allow the build to work in the local environment.
   |
   | For example, if you have an integration testing plugin - like cactus - that needs to know where
   | your Tomcat instance is installed, you can provide a variable here such that the variable is
   | dereferenced during the build process to configure the cactus plugin.
   |
   | As noted above, profiles can be activated in a variety of ways. One way - the activeProfiles
   | section of this document (settings.xml) - will be discussed later. Another way essentially
   | relies on the detection of a system property, either matching a particular value for the property,
   | or merely testing its existence. Profiles can also be activated by JDK version prefix, where a
   | value of '1.4' might activate a profile when the build is executed on a JDK version of '1.4.2_07'.
   | Finally, the list of active profiles can be specified directly from the command line.
   |
   | NOTE: For profiles defined in the settings.xml, you are restricted to specifying only artifact
   |       repositories, plugin repositories, and free-form properties to be used as configuration
   |       variables for plugins in the POM.
   |
   |-->
  <profiles>
    <!-- profile
     | Specifies a set of introductions to the build process, to be activated using one or more of the
     | mechanisms described above. For inheritance purposes, and to activate profiles via <activatedProfiles/>
     | or the command line, profiles have to have an ID that is unique.
     |
     | An encouraged best practice for profile identification is to use a consistent naming convention
     | for profiles, such as 'env-dev', 'env-test', 'env-production', 'user-jdcasey', 'user-brett', etc.
     | This will make it more intuitive to understand what the set of introduced profiles is attempting
     | to accomplish, particularly when you only have a list of profile id's for debug.
     |
     | This profile example uses the JDK version to trigger activation, and provides a JDK-specific repo.
    <profile>
      <id>jdk-1.4</id>

      <activation>
        <jdk>1.4</jdk>
      </activation>

      <repositories>
        <repository>
          <id>jdk14</id>
          <name>Repository for JDK 1.4 builds</name>
          <url>http://www.myhost.com/maven/jdk14</url>
          <layout>default</layout>
          <snapshotPolicy>always</snapshotPolicy>
        </repository>
      </repositories>
    </profile>
    -->

    <!--
     | Here is another profile, activated by the system property 'target-env' with a value of 'dev',
     | which provides a specific path to the Tomcat instance. To use this, your plugin configuration
     | might hypothetically look like:
     |
     | ...
     | <plugin>
     |   <groupId>org.myco.myplugins</groupId>
     |   <artifactId>myplugin</artifactId>
     |
     |   <configuration>
     |     <tomcatLocation>${tomcatPath}</tomcatLocation>
     |   </configuration>
     | </plugin>
     | ...
     |
     | NOTE: If you just wanted to inject this configuration whenever someone set 'target-env' to
     |       anything, you could just leave off the <value/> inside the activation-property.
     |
    <profile>
      <id>env-dev</id>

      <activation>
        <property>
          <name>target-env</name>
          <value>dev</value>
        </property>
      </activation>

      <properties>
        <tomcatPath>/path/to/tomcat/instance</tomcatPath>
      </properties>
    </profile>
    -->
  </profiles>

  <!-- activeProfiles
   | List of profiles that are active for all builds.
   |
  <activeProfiles>
    <activeProfile>alwaysActiveProfile</activeProfile>
    <activeProfile>anotherAlwaysActiveProfile</activeProfile>
  </activeProfiles>
  -->
</settings>

目标二：将Bean对象存储到Spring容器中

创建一个Bean（在Java中，一个对象如果被多次使用，就称为Bean）

public class Student {
    //创建一个Bean
    public void sayHi(){
        System.out.println("hi student");
    }
}

将Bean存储到Spring容器中
```
 <bean id="student" class="com.spring.demo.Student"></bean>

//student：Bean名称（望文思意）
//com.spring.demo.Student：包名+类名
```
总之：上述内容的大致意思为：将Bean(com.spring.demo.Student)存储到Spring容器中，它的名称叫做student

目标三：从Spring容器中读取到Bean（Spring Bean）

package com.spring.demo;

public class App {
    public static void main(String[] args) {
        //1.得到Spring
        ApplicationContext context=new ClassPathXmlApplicationContext("spring.config.xml");
        //2.从spring容器中获取到Bean对象，
        //这里的student需要保持一致！
        Student student=(Student)context.getBean("student");
        //使用Bean
        student.sayHi();
    }
}

那么，经过上述的几个操作，我们就可以成功的学会Spring的创建和使用了，此时，我们就可以来看一下下面的：得到Spring上下文对象的方法吧！

   ApplicationContent  context = new ClassPathXmlApplicationContext("spring-config.xml");

将xml中所有的对象存储到Spring容器中，特征：比较费内存，一次加载，之后的读取会非常块
2.

   BeanFactory  beanFactory = new XmlBeanFactory(new ClassPathResource("spring-config.xml");
   //即将OUT

只有调用getBean才会去加载对应的Bean，属于懒加载，特征：节省内存，调用时才会加载初始化，效率不怎么高！

那么，我们来看一下经典的面试题吧！

ApplicationContext VS BeanFactory（常见面试题）

继承关系和功能方面来说： Spring容器有两个顶级的接口：BeanFactory和ApplicationContext，其中BeanFactory提供了基础的访问容器的能力，而ApplicationContext属于BeanFactory的子类，它除了继承BeanFactory的所有功能之外，它还拥有独特的功能，还添加了对国际化支持，资源访问支持，以及事件传播等方面的支持！！
从性能方面来说： ApplicationContext是一次加载并初始化所有的Bean对象，而BeanFactory是需要哪个，才会去加载哪个，因此更加轻量！！

有了上述知识的铺垫，我们来看一下：获取Bean的3种方式吧！！

通过名称获取（强制类型转化）

STudent student = (Student)context.getBean("student");

通过类型方式获取
```
STudent student = context.getBean(student.class);
```
如果Spring中一个类型存储了多个类型，那么，使用类型获取Bean的时候就会报错！
```
<bean id = "student" class = "com.spring.config.Student">  </bean>
<bean id = "stu" class = "com.spring.config.Student">  </bean>
```
每一个放到Spring中的Bean，Spring都会为其创建一个单独的对象，不会因为类型相同就不创建了！！
通过名称+类型方式获取只要求外网IP必须唯一的

内网IP在不同的局域网中，是允许重复的！！（同一个局域网里不能重复）

内网IP在咱们办公楼内部（局域网内部），别人的IP一定都不一样！

但是，相对于全国各地，有的就可能会有和我一样的内网IP！

总结：

创建Spring项目 a.创建一个Maven项目

b.添加spring-context依赖

c.创建一个启动类（作用：为后面从spring容器中获取Bean做准备）
存储Bean a.先创建Bean对象

b.通过Spring配置文件spring-config.xml

如：<bean id="bean名称" class="包名+类名"> </bean>
读取Bean a.得到Spring对象（ApplicationContext(官方推荐） BeanFactory(即将OUT)

b.通过Spring对象，getBean方法获取到Bean对象（DI操作）

c.（非必须）使用Bean