开发环境

名称	版本
操作系统	Windows 10 X64
JDK	JDK1.8（jdk-8u151-windows-x64）
IntelliJ IDEA	IntelliJ IDEA 2018.3
Maven	Maven 3.6.0
Spring	5.2.4.RELEASE

参考

Spring+SpringMVC+SpringBoot最详细完整版念安小姐姐全套视频教程【IDEA版】由浅入深&全方位讲解，一天学习Spring框架从入门到精通

Spring 框架环境搭建

1.新建 Maven 项目

Maven 配置

名称	说明	配置
Maven Home Directory	Maven 安装包路径	D:\Program Files\apache-maven-3.6.0
User settings file	用户配置文件	D:\Program Files\apache-maven-3.6.0\conf\settings.xml
Local repository	本地仓库	D:\Program Files\Maven\Repository

2.调整项目环境【pom.xml】

(1)修改 JDK 版本

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

(2)修改单元测试 JUnit 版本

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

(3)build 标签中的 pluginManagement 标签

  <!--删除 build 标签中的 pluginManagement 标签-->
  <build>
  </build>

3.添加 Spring 框架的依赖坐标【pom.xml】

<!-- 添加Spring框架的核⼼依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.2.4.RELEASE</version>
</dependency>

4.编写 Bean 对象

package com.demo.spring;
public class UserService {
    public void test(){
        System.out.println("Hello Spring!");
    }
}

5.添加 Spring 配置文件

1.在项目的 src 下创建文件夹 resources（Alt+insert）
2.将 resources 标记为资源目录

3.在 src\main\resources 目录下新建 spring.xml 文件，并拷贝官网文档提供的模板内容到 xml 中。

配置 bean 到 xml 中，把对应 bean 纳入到 Spring 容器来管理 spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--xmlns 即 xml namespace xml使用的命名空间
        xmlns:xsi 即xml schema instance xml 遵守的具体规范
        xsi:schemaLocation 本文档 xml遵守的规范 官方指定-->
    <!--
    id：bean对象的id，唯一标识。一般是Bean对象的名称的首字母小写 class：bean对象的类路径
    -->
    <bean id="userService" class="com.demo.spring.UserService"></bean>
</beans>

6.加载配置文件，获取实例化对象

package com.demo.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
    public static void main(String[] args) {
        // 获取Spring上下文环境(加载配置文件)
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        // 通过getBean方法得到Spring容器中实例化好的Bean对象 （实例化Bean对象）
        // userService代表的是配置文件中bean标签的id属性值
        UserService userService = (UserService) ac.getBean("userService");
        // 调用方法 （使用实例化对象）
        userService.test();
    }
}

运行结果

Hello Spring!

SpringIOC 容器 Bean 对象实例化模拟

1.定义 Bean 属性对象

package com.demo.spring;
/**
 * bean 对象
 *
 */
public class MyBean {
    private String id; // bean对象的id属性值
    private String clazz; // bean对象的类路径
    public MyBean() {
    }
    public MyBean(String id, String clazz) {
        this.id = id;
        this.clazz = clazz;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getClazz() {
        return clazz;
    }
    public void setClazz(String clazz) {
        this.clazz = clazz;
    }
}

2.添加 dom4j 坐标依赖【pom.xml】

<dependency>
  <groupId>dom4j</groupId>
  <artifactId>dom4j</artifactId>
  <version>1.6.1</version>
</dependency>
<!-- XPath -->
<dependency>
  <groupId>jaxen</groupId>
  <artifactId>jaxen</artifactId>
  <version>1.1.6</version>
</dependency>
`

3.准备自定义配置文件

spring.xml

<?xml version="1.0" encoding="utf-8" ?>
<beans>
    <bean id="userService" class="com.demo.spring.service.UserService"></bean>
    <bean id="accountService" class="com.demo.spring.service.AccountService"></bean>
</beans>

4.定义 Bean 工厂接口

package com.demo.spring;
/**
 * Bean 工厂接⼝定义
 */
public interface MyFactory {
    // 通过id值获取对象
    public Object getBean(String id);
}

5.定义 Bean 接口的实现类

package com.demo.spring;
import com.demo.spring.bean.MyBean;
import com.demo.spring.factory.MyFactory;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * 模拟Spring的实现
 * 1、通过构造器得到相关配置文件
 * 2、通过dom4j解析xml文件，得到List 存放id和class
 * 3、通过反射实例化得到对象 Class.forName(类的全路径).newInstance(); 通过
 Map<id,Class>存储
 * 4、得到指定的实例化对象
 */
public class MyClassPathXmlApplicationContext implements MyFactory {
    private Map beans = new HashMap(); // 实例化后的对象放入map
    private List<MyBean> myBeans; // 存放已读取bean 配置信息
    /* 1、通过构造器得到相关配置文件 */
    public MyClassPathXmlApplicationContext(String fileName) {
        /* 2、通过 dom4j 解析 xml 文件，得到 List （存放id 和 class） */
        this.parseXml(fileName);
        /* 3、通过反射实例化得到对象Class.forName(类路径).newInstance(); 通过Map存储
         */
        this.instanceBean();
    }
    /**
     * 通过dom4j解析xml文件，得到List 存放id和class
     * 1、获取解析器
     * 2、得到配置文件的URL
     * 3、通过解析器解析xml文件（spring.xml）
     * 4、通过xpath语法，获取beans标签下的所有bean标签
     * 5、通过指定语法解析文档对象，返回集合
     * 6、判断集合是否为空，遍历集合
     * 7、获取标签元素中的属性
     * 8、得到Bean对象，将Bean对象设置到集合中
     * @param fileName
     */
    private void parseXml(String fileName) {
        // 1、获取解析器
        SAXReader reader = new SAXReader();
        // 2、得到配置文件的URL
        URL url = this.getClass().getClassLoader().getResource(fileName);
        try {
            // 3、通过解析器解析xml文件（spring.xml）
            Document document = reader.read(url);
            // 4、通过xpath语法，获取beans标签下的所有bean标签
            XPath xPath = document.createXPath("beans/bean");
            // 通过指定语法解析文档对象，返回集合
            List<Element> list = xPath.selectNodes(document);
            // 判断集合是否为空，遍历集合
            if (list != null && list.size() > 0){
                myBeans = new ArrayList<>();
                for(Element el : list) {
                    // 获取标签元素中的属性
                    String id = el.attributeValue("id"); // id 属性值
                    String clazz = el.attributeValue("class"); // class 属 性 值
                    System.out.println(el.attributeValue("id"));
                    System.out.println(el.attributeValue("class"));
                    // 得到Bean对象
                    MyBean bean = new MyBean(id, clazz);
                    // 将Bean对象设置到集合中
                    myBeans.add(bean);
                }
            }
        } catch (DocumentException e){
            e.printStackTrace();
        }
    }
    /**
     * 通过反射实例化得到对象
     * Class.forName(类的全路径).newInstance();
     * 通过Map<id,Class>存储
     */
    private void instanceBean() {
        // 判断bean集合是否为空，不为空遍历得到对应Bean对象
        if (myBeans != null && myBeans.size() > 0){
            for (MyBean bean : myBeans){
                try {
                    // 通过类的全路径实例化对象
                    Object object = Class.forName(bean.getClazz()).newInstance();
                    // 将id与实例化对象设置到map对象中
                    beans.put(bean.getId(), object);
                } catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
    /**
     * 通过 key 获取 map 中的指定 value
     * @param id
     * @return
     */
    @Override
    public Object getBean(String id){
        Object object = beans.get(id);
        return object;
    }
}

6.测试自定义 IOC 容器

(1)创建与配置文件中对应的 Bean 对象

UserService.java

package com.demo.spring.service;
public class UserService {
    public void test(){
        System.out.println("UserService Test...");
    }
}

AccountService.java

package com.demo.spring.service;
public class AccountService {
    public void test(){
        System.out.println("AccountService Test...");
    }
}

(2)测试是否可以获取实例化的 Bean 对象

package com.demo.spring;
import com.demo.spring.factory.MyFactory;
import com.demo.spring.service.AccountService;
import com.demo.spring.service.UserService;
public class App {
    public static void main(String[] args) {
        MyFactory factory = new MyClassPathXmlApplicationContext("spring.xml");
        // 得到实例化对象
        UserService userService = (UserService) factory.getBean("userService");
        userService.test();
        UserService userService2 = (UserService)factory.getBean("userService");
        System.out.println(userService+"=====" + userService2);
        AccountService accountService =(AccountService)factory.getBean("accountService");
        accountService.test();
    }
}

运行结果

userService
com.demo.spring.service.UserService
accountService
com.demo.spring.service.AccountService
UserService Test...
com.demo.spring.service.UserService@53e25b76=====com.demo.spring.service.UserService@53e25b76
AccountService Test...

Spring IOC 配置文件加载

1.Spring 配置文件加载

spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userService" class="com.demo.spring.service.UserService"></bean>
</beans>

根据相对路径加载资源

ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");

根据绝对路径加载资源（了解）

ApplicationContext ac = new FileSystemXmlApplicationContext("D:/Java/SpringStudy/src/main/resources/spring.xml");

2.Spring 多配置文件加载

Spring 框架启动时可以加载多个配置文件到环境中。

对于比较复杂的项目，可能对应的配置文件有多个，项目在启动部署时会将多个配置文件同时加载进来。

(1)service.xml

service.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userService" class="com.demo.spring.service.UserService"></bean>
</beans>

(2)dao.xml

dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userDao" class="com.demo.spring.dao.UserDao"></bean>
</beans>

(3)可变参数，传入多个文件名

// 同时加载多个资源文件
ApplicationContext ac = new ClassPathXmlApplicationContext("service.xml","dao.xml");

(4)通过总的配置文件 import 其他配置文件

spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--导入需要包含的资源文件-->
    <import resource="service.xml"/>
    <import resource="dao.xml"/>
</beans>

加载时只需加载总的配置文件即可

// 加载总的资源文件
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");

Spring IOC 容器 Bean 对象实例化

一.构造器实例化

注：通过默认构造器创建 空构造方法必须存在 否则创建失败

1.设置配置文件 spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="userService" class="com.demo.spring.service.UserService"></bean>
  </beans>

2.获取实例化对象

ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
UserService userService = (UserService) ac.getBean("userService");
userService.test();

二.静态工厂实例化（了解）

注：要有该工厂类及工厂方法，工厂方法为静态的

1.定义静态工厂类

package com.demo.spring.factory;
import com.demo.spring.service.UserService;
/**
 * 定义静态工厂类
 */
public class StaticFactory {
    /**
     * 定义对应的静态方法，返回实例化对象
     * @return
     */
    public static UserService createUserService(){
        return new UserService();
    }
}

2.设置配置文件 spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--静态工厂-->
    <bean id="userService"
          class="com.demo.spring.factory.StaticFactory" factory-method="createUserService">
    </bean>
</beans>

3.获取实例化对象

package com.demo.spring;
import com.demo.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) ac.getBean("userService");
        userService.test();
    }
}

运行结果

UserService Test...

当我们指定 Spring 使用静态方法来创建 Bean 实例时，Spring 将先解析配置文件，并根据配置文件指定的信息，通过反射调用静态工厂类的静态工厂方法，并将该静态方法的返回值作为 Bean 实例，在这个过程中，Spring 不再负责创建 Bean 实例，Bean 实例是由用户提供的静态工厂法提供的。

三.实例化工厂实例化（了解）

注：
工厂方法为非静态方法
需要配置工厂 bean，并在业务 bean 中配置 factory-bean，factory-method 属性

1.定义工厂类

package com.demo.spring.factory;
import com.demo.spring.service.UserService;
/**
 * 定义工厂类
 */
public class InstanceFactory {
    /**
     * 定义方法，返回实例化对象
     * @return
     */
    public UserService createUserService(){
        return new UserService();
    }
}

2.设置配置文件 spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        实例化工厂
        1.定义实例化工厂bean
        2.引用工厂bean 指定工厂创建方法(方法为非静态)
    -->
    <bean id="instanceFactory" class="com.demo.spring.factory.InstanceFactory">
    </bean>
    <bean id="userService"
          factory-bean="instanceFactory"
          factory-method="createUserService">
    </bean>
</beans>

3.获取实例化对象

package com.demo.spring;
import com.demo.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) ac.getBean("userService");
        userService.test();
    }
}

运行结果

UserService Test...

Spring 三种实例化 Bean 的方式比较

方式一：通过 bean 的缺省构造函数创建，当各 个bean 的业务逻辑相互比较独⽴的时候或者和外界
关联较少的时候可以使用。
方式二：利用静态 factory 方法创建，可以统一管理各个 bean 的创建，如各个 bean 在创建之前需要
相同的初始化处理，则可用这个 factory 方法险进行统一的处理等等。
方式三：利用实例化 factory 方法创建，即将 factory 方法也作为了业务 bean 来控制，1 可用于集成
其他框架的 bean 创建管理方法，2 能够使 bean 和 factory 的⻆⾊互换。

开发中项目一般使用一种方式实例化 bean，项目开发基本采用第一种方式，交给 Spring 托管，使用
时直接拿来使用即可。另外两种了解。

Spring IOC 注入

手动实例化与外部引入

package com.demo.spring.service;
import com.demo.spring.dao.UserDao;
public class UserService {
    UserDao dao = new UserDao();
}

package com.demo.spring.service;
import com.demo.spring.dao.UserDao;
public class UserService {
    UserDao dao;
    public UserService(UserDao dao){
        this.dao = dao;
    }
}

对比发现：代码二中对于 UserDao 对象的创建并没有像代码一那样主动的去实例化，而是通过带参方法形
式将 UserDao 传入过来，从而实现 UserService 对 UserDao 类的依赖。

而实际创建对象的幕后对象即是交给了外部来创建。

一.Spring IOC 手动装配（注入）

Spring 支持的注入方式共有四种：set 注入、构造器注入、静态工厂注入、实例化工厂注入。

1.set 方法注入

注：
属性字段需要提供 set 方法
四种方式，推荐使用 set 方法注入

(1)业务对象 JavaBean

属性字段提供 set 方法

package com.demo.spring.service;
import com.demo.spring.dao.UserDao;
public class UserService {
    // 业务对象UserDao set注入（提供set方法）
    private UserDao userDao;
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }
}

配置文件的 bean 标签设置 property 标签

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        IOC通过property标签手动装配（注入）：
        Set方法注入
        name：bean对象中属性字段的名称
        ref：指定bean标签的id属性值
    -->
    <bean id="userDao" class="com.demo.spring.dao.UserDao"></bean>
    <bean id="userService" class="com.demo.spring.service.UserService">
        <!--业务对象 注入-->
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

(2)常用对象和基本类型

属性字段提供 set 方法

package com.demo.spring.service;
public class UserService {
    // 常用对象String set注入（提供set方法）
    private String host;
    public void setHost(String host){ 
        this.host = host;
    }
    // 基本类型Integer set注入（提供set方法）
    private Integer port;
    public void setPort(Integer port){ 
        this.port = port;
    }
}

配置文件的 bean 标签设置 property 标签

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        IOC通过property标签手动装配（注入）：
        Set方法注入
        name：bean对象中属性字段的名称
        value:具体的值（基本类型 常用对象|日期 集合）
    -->
    <bean id="userService" class="com.demo.spring.service.UserService">
        <!--常用对象String 注入-->
        <property name="host" value="127.0.0.1"/>
        <!--基本类型注入-->
        <property name="port" value="8080"/>
    </bean>
</beans>

(3)集合类型和属性对象

属性字段提供 set 方法

package com.demo.spring.service;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class UserService {
    // List集合 set注入（提供set方法）
    public List<String> list;
    public void setList(List<String> list){
        this.list = list;
    }
    // Set集合 set注入（提供set方法）
    private Set<String> set;
    public void setSet(Set<String> set){
        this.set = set;
    }
    // Map set注入（提供set方法）
    private Map<String,Object> map;
    public void setMap(Map<String, Object> map){
        this.map = map;
    }
    // Properties set注入（提供set方法）
    private Properties properties;
    public void setProperties(Properties properties){
        this.properties = properties;
    }
}

配置文件的 bean 标签设置 property 标签

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        IOC通过property标签手动装配（注入）： Set方法注入
        name：bean对象中属性字段的名称
        value:具体的值（基本类型 常用对象|日期 集合）
    -->
    <!--List集合 注入-->
    <property name="list">
        <list>
            <value>上海</value>
            <value>北京</value>
            <value>杭州</value>
        </list>
    </property>
    <!--Set集合注入-->
    <property name="set">
        <set>
            <value>上海SH</value>
            <value>北京BJ</value>
            <value>杭州HZ</value>
        </set>
    </property>
    <!--Map注入-->
    <property name="map">
        <map>
            <entry>
                <key><value>周杰伦</value></key>
                <value>我是如此相信</value>
            </entry>
            <entry>
                <key><value>林俊杰</value></key>
                <value>可惜没如果</value>
            </entry>
            <entry>
                <key><value>陈奕迅</value></key>
                <value>十年</value>
            </entry>
        </map>
    </property>
    <!--Properties注入-->
    <property name="properties">
        <props>
            <prop key="上海">东方明珠</prop>
            <prop key="北京">天安门</prop>
            <prop key="杭州">西湖</prop>
        </props>
    </property>
</beans>

测试代码

1.spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
         IOC通过property标签手动装配（注入）：
         Set方法注入
         name：bean对象中属性字段的名称
         ref：指定bean标签的id属性值
         value:具体的值（基本类型 常用对象|日期 集合）
    -->
    <bean id="userDao" class="com.demo.spring.dao.UserDao"></bean>
    <bean id="userService" class="com.demo.spring.service.UserService">
        <!--业务对象 注入-->
        <property name="userDao" ref="userDao"/>
        <!--常用对象String 注入-->
        <property name="host" value="192.168.1.109"/>
        <!--基本类型注入-->
        <property name="port" value="8080"/>
        <!--List集合 注入-->
        <property name="list">
            <list>
                <value>上海</value>
                <value>北京</value>
                <value>杭州</value>
            </list>
        </property>
        <!--Set集合注入-->
        <property name="set">
            <set>
                <value>上海SH</value>
                <value>北京BJ</value>
                <value>杭州HZ</value>
            </set>
        </property>
        <!--Map注入-->
        <property name="map">
            <map>
                <entry>
                    <key><value>周杰伦</value></key>
                    <value>我是如此相信</value>
                </entry>
                <entry>
                    <key><value>林俊杰</value></key>
                    <value>可惜没如果</value>
                </entry>
                <entry>
                    <key><value>陈奕迅</value></key>
                    <value>十年</value>
                </entry>
            </map>
        </property>
        <!--Properties注入-->
        <property name="properties">
            <props>
                <prop key="上海">东方明珠</prop>
                <prop key="北京">天安门</prop>
                <prop key="杭州">西湖</prop>
            </props>
        </property>
    </bean>
</beans>

2.UserService

package com.demo.spring.service;
import com.demo.spring.dao.UserDao;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class UserService {
    // 业务对象UserDao set注入（提供set方法）
    private UserDao userDao;
    public void setUserDao(UserDao userDao) { this.userDao = userDao; }
    // 常用对象String set注入（提供set方法）
    private String host;
    public void setHost(String host) { this.host = host; }
    // 基本类型Integer set注入（提供set方法）
    private Integer port;
    public void setPort(Integer port) { this.port = port; }
    // List集合 set注入（提供set方法）
    public List<String> list;
    public void setList(List<String> list){
        this.list = list;
    }
    // List集合输出
    public void printList() { list.forEach(s -> System.out.println(s)); }
    // Set集合 set注入（提供set方法）
    private Set<String> set;
    public void setSet(Set<String> set){
        this.set = set;
    }
    // Set集合输出
    public void printSet() { set.forEach(s -> System.out.println(s)); }
    // Map set注入（提供set方法）
    private Map<String,Object> map;
    public void setMap(Map<String, Object> map){
        this.map = map;
    }
    // Map输出
    public void printMap() { map.forEach((k,v) -> System.out.println(k + "，" + v)); }
    // Properties set注入（提供set方法）
    private Properties properties;
    public void setProperties(Properties properties){
        this.properties = properties;
    }
    // Properties输出
    public void printProperties(){ properties.forEach((k,v) -> System.out.println(k + "，"+ v )); }
    public void test(){
        System.out.println("UserService Test...");
        userDao.test();
        System.out.println("Host：" + host + "，port：" + port);
        // List集合
        printList();
        // Set集合
        printSet();
        // Map
        printMap();
        // Properties
        printProperties();
    }
}

3.UserDao

package com.demo.spring.dao;
public class UserDao {
    public void test(){
        System.out.println("UserDao Test...");
    }
}

4.App

package com.demo.spring;
import com.demo.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) ac.getBean("userService");
        userService.test();
    }
}

运行结果

UserService Test...
UserDao Test...
Host：192.168.1.109，port：8080
上海
北京
杭州
上海SH
北京BJ
杭州HZ
周杰伦，我是如此相信
林俊杰，可惜没如果
陈奕迅，十年
上海，东方明珠
北京，天安门
杭州，西湖

2.构造器注入

注：提供带参构造器

(1)单个 Bean 对象作为参数

Java 代码

package com.demo.spring.service;
import com.demo.spring.dao.UserDao;
public class UserService {
    private UserDao userDao; // JavaBean 对 象
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
    public void test(){
        System.out.println("UserService Test...");
        userDao.test();
    }
    public UserService(){}
}

Spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
    IOC通过构造器注入：
    通过constructor-arg标签进行注入
    name： 属 性 名 称
    ref：指定bean标签的id属性值
    -->
    <bean id="userDao" class="com.demo.spring.dao.UserDao" ></bean>
    <bean id="userService" class="com.demo.spring.service.UserService">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>
</beans>

App

package com.demo.spring;
import com.demo.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) ac.getBean("userService");
        userService.test();
    }
}

运行结果

UserService Test...
UserDao Test...

(2)多个 Bean 对象作为参数

Java 代码

package com.demo.spring.dao;
public class AccountDao {
    public void test(){
        System.out.println("AccountDao Test...");
    }
}

package com.demo.spring.dao;
public class UserDao {
    public void test(){
        System.out.println("UserDao Test...");
    }
}

package com.demo.spring.service;
import com.demo.spring.dao.AccountDao;
import com.demo.spring.dao.UserDao;
public class UserService {
    private UserDao userDao; // JavaBean 对象
    private AccountDao accountDao;
    public UserService(UserDao userDao, AccountDao accountDao) {
        this.userDao = userDao;
        this.accountDao = accountDao;
    }
    public void test(){
        System.out.println("UserService Test...");
        userDao.test();
        accountDao.test();
    }
    public UserService(){}
}

Spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
    IOC通过构造器注入：
    通过constructor-arg标签进行注入
    name： 属 性 名 称
    ref：指定bean标签的id属性值
    -->
    <bean id="userDao" class="com.demo.spring.dao.UserDao" ></bean>
    <bean id="accountDao" class="com.demo.spring.dao.AccountDao" ></bean>
    <bean id="userService" class="com.demo.spring.service.UserService">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
        <constructor-arg name="accountDao" ref="accountDao"></constructor-arg>
    </bean>
</beans>

package com.demo.spring;
import com.demo.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) ac.getBean("userService");
        userService.test();
    }
}

运行结果

UserService Test...
UserDao Test...
AccountDao Test...

(3)Bean 对象和常用对象作为参数

Java 代码

package com.demo.spring.service;
import com.demo.spring.dao.AccountDao;
import com.demo.spring.dao.UserDao;
public class UserService {
    private UserDao userDao; // JavaBean 对象
    private AccountDao accountDao;
    private String uname; // 字符串类型
    public UserService(UserDao userDao, AccountDao accountDao, String uname) {
        this.userDao = userDao;
        this.accountDao = accountDao;
        this.uname = uname;
    }
    public void test(){
        System.out.println("UserService Test...");
        userDao.test();
        accountDao.test();
        System.out.println("uname：" + uname);
    }
    public UserService(){}
}

Spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
    IOC通过构造器注入：
    通过constructor-arg标签进行注入
    name： 属 性 名 称
    ref：指定bean标签的id属性值
    value：基本类型 常用对象的值
    index：构造器中参数的下标，从0开始-->
    <bean id="userDao" class="com.demo.spring.dao.UserDao" ></bean>
    <bean id="accountDao" class="com.demo.spring.dao.AccountDao" ></bean>
    <bean id="userService" class="com.demo.spring.service.UserService">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
        <constructor-arg name="accountDao" ref="accountDao"></constructor-arg>
        <constructor-arg name="uname" value="admin"></constructor-arg>
    </bean>
</beans>

App.java

package com.demo.spring;
import com.demo.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) ac.getBean("userService");
        userService.test();
    }
}

运行结果

UserService Test...
UserDao Test...
AccountDao Test...
uname：admin

(4)循环依赖问题

循环问题产生的原因：Bean 通过构造器注入，之间彼此相互依赖对方导致 bean 无法实例化。

Java 代码

package com.demo.spring.service;
public class AccountService {
    private RoleService roleService;
    public AccountService(RoleService roleService) {
        this.roleService = roleService;
    }
    public void test(){
        System.out.println("AccountService Test...");
    }
}

package com.demo.spring.service;
public class RoleService {
    private AccountService accountService;
    public RoleService(AccountService accountService) {
        this.accountService = accountService;
    }
    public void test(){
        System.out.println("RoleService Test...");
    }
}

spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        如果多个bean对象中互相注入，则会出现循环依赖的问题
        可以通过set方法注入解决
    -->
    <bean id="accountService" class="com.demo.spring.service.AccountService">
        <constructor-arg name="roleService" ref="roleService"/>
    </bean>
    <bean id="roleService" class="com.demo.spring.service.RoleService">
        <constructor-arg name="accountService" ref="accountService"/>
    </bean>
</beans>

App.java

package com.demo.spring;
import com.demo.spring.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        AccountService userService = (AccountService) ac.getBean("accountService");
        userService.test();
    }
}

运行结果

四月 06, 2021 10:04:35 下午 org.springframework.context.support.AbstractApplicationContext refresh
警告: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'accountService' defined in class path resource [spring.xml]: Cannot resolve reference to bean 'roleService' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'roleService' defined in class path resource [spring.xml]: Cannot resolve reference to bean 'accountService' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'accountService': Requested bean is currently in creation: Is there an unresolvable circular reference?
Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'accountService' defined in class path resource [spring.xml]: Cannot resolve reference to bean 'roleService' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'roleService' defined in class path resource [spring.xml]: Cannot resolve reference to bean 'accountService' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'accountService': Requested bean is currently in creation: Is there an unresolvable circular reference?

(5)如何解决：将构造器注入改为 set 方法注入

Java 代码

package com.demo.spring.service;
public class AccountService {
    private RoleService roleService;
    //public AccountService(RoleService roleService) {
    //    this.roleService = roleService;
    //}
    public void setRoleService(RoleService roleService) {
        this.roleService = roleService; }
    public void test(){
        System.out.println("AccountService Test...");
    }
}

package com.demo.spring.service;
public class RoleService {
    private AccountService accountService;
    //public RoleService(AccountService accountService) {
    //    this.accountService = accountService;
    //}
    public void setAccountService(AccountService accountService) {
        this.accountService = accountService; }
    public void test(){
        System.out.println("RoleService Test...");
    }
}

spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        如果多个bean对象中互相注入，则会出现循环依赖的问题
        可以通过set方法注入解决
    -->
    <!--<bean id="accountService" class="com.demo.spring.service.AccountService">-->
        <!--<constructor-arg name="roleService" ref="roleService"/>-->
    <!--</bean>-->
    <!--<bean id="roleService" class="com.demo.spring.service.RoleService">-->
        <!--<constructor-arg name="accountService" ref="accountService"/>-->
    <!--</bean>-->
    <!--修改为set方法注入-->
    <bean id="accountService" class="com.demo.spring.service.AccountService">
        <property name="roleService" ref="roleService"/>
    </bean>
    <bean id="roleService" class="com.demo.spring.service.RoleService">
        <property name="accountService" ref="accountService"/>
    </bean>
</beans>

App.java

package com.demo.spring;
import com.demo.spring.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        AccountService service = (AccountService) ac.getBean("accountService");
        service.test();
    }
}

运行结果

AccountService Test...

3.静态工厂注入

(1)定义工厂类

package com.demo.spring.dao;
public class TypeDao {
}

package com.demo.spring.factory;
import com.demo.spring.dao.TypeDao;
/**
 * 定义工厂类
 */
public class InstanceFactory {
    public TypeDao createTypeDao()
    {
        return new TypeDao();
    }
}

package com.demo.spring.service;
import com.demo.spring.dao.TypeDao;
public class TypeService {
    private TypeDao typeDao;
    public void setTypeDao(TypeDao typeDao) {
        this.typeDao = typeDao;
    }
    public void test() {
        System.out.println("TypeService Test...");
    }
}

(2)spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="typeService" class="com.xxxx.service.TypeService">
        <property name="typeDao" ref="typeDao"/>
    </bean>
    <!--
        实例化工厂注入：
        实例化工厂注入也是借助set方法注入，只是被注入的bean对象的实例化是通过实例化工厂实例
        化的
    -->
    <bean id="instanceFactory" class="com.demo.spring.factory.InstanceFactory">
    </bean>
    <bean id="typeDao" factory-bean="instanceFactory" factory-method="createTypeDao">
    </bean>
</beans>

重点掌握 set 注入和构造器注入，工厂方式了解即可。实际开发中基本使用 set 方式注入 bean。

注入方式的选择

开发项目中 set 方式注入首选

使用构造注入可以在构建对象的同时一并完成依赖关系的建⽴，对象一建⽴则所有的一切也就准备好了，但如果要建⽴的对象关系很多，使用构造器注入会在构建函数上留下一⻓串的参数,且不易记忆,这时使用 Set 注入会是个不错的选择。

使用Set注入可以有明确的名称，可以了解注入的对象会是什么，像 setXXX()这样的名称会比记忆 Constructor 上某个参数的位置代表某个对象更好。

p 名称空间的使用

spring2.5 以后，为了简化 setter 方法属性注入，引用 p名称空间的概念，可以将⼦元素，简化为元素
属性配置。

1.属性字段提供 set 方法

package com.demo.spring.service;
import com.demo.spring.dao.UserDao;
public class UserService {
    // 业务对象UserDao set注入（提供set方法）
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    // 常用对象String set注入（提供set方法）
    private String host;
    public void setHost(String host) {
        this.host = host;
    }
    public void test(){
        System.out.println("UserService test...");
        System.out.println("host:"+host);
    }
}

2.在配置文件 spring.xml 引入 p 名称空间

xmlns:p="http://www.springframework.org/schema/p"

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userDao" class="com.demo.spring.dao.UserDao"></bean>
    <!--
        p:属性名:="xxx" 引入常量值
        p:属性名-ref:="xxx" 引入其他Bean对象的id属性值
    -->
    <bean id="userService" class="com.demo.spring.service.UserService"
          p:userDao-ref="userDao"
          p:host="127.0.0.1" />
</beans>

3.App

package com.demo.spring;
import com.demo.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        UserService service = (UserService) ac.getBean("userService");
        service.test();
    }
}

运行结果

UserService test...
host:127.0.0.1

二.Spring IOC 自动装配（注入）

注解方式注入 Bean

对于 bean 的注入，除了使用 xml 配置以外，可以使用注解配置。注解的配置，可以简化配置文件，
提⾼开发的速度，使程序看上去更简洁。对于注解的解释，Spring 对于注解有专门的解释器，对定义的
注解进行解析，实现对应 bean 对象的注入。通过反射技术实现。

准备环境

(1)修改配置文件 spring.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

(2)开启自动化注入

<!--开启自动化装配（注入）-->
<context:annotation-config />
<bean id="userDao" class="com.xxxx.dao.UserDao"></bean>
<bean id="userService" class="com.xxxx.service.UserService"></bean>

(3)公共类

package com.demo.spring.dao;
public class UserDao {
    public void test(){
        System.out.println("UserDao Test...");
    }
}

加载类 main 方法

package com.demo.spring;
import com.demo.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        UserService service = (UserService) ac.getBean("userService");
        service.test();
    }
}

(4)给注入的 bean 对象添加注解

@Resource 注解

@Resource 注解实现自动注入（反射）
● 默认根据属性字段名称查找对应的 bean 对象 （属性字段的名称与bean标签的id属性值相等）
● 如果属性字段名称未找到，则会通过类型（Class 类型）查找
● 属性可以提供 set 方法，也可以不提供 set 方法
● 注解可以声明在属性级别 或 set 方法级别
● 可以设置 name 属性，name 属性值必须与 bean 标签的 id 属性值一致；如果设置了 name 属性值，就只会按照 name 属性值查找 bean 对象
● 当注入接⼝时，如果接口只有一个实现则正常实例化；如果接⼝存在多个实现，则需要使用 name 属性指定需要被实例化的 bean 对象

代码示例

(1)默认根据属性字段名称查找对应的 bean 对象

（属性字段的名称与 bean 标签的 id 属性值相等）

package com.demo.spring.service;
import com.demo.spring.dao.UserDao;
import javax.annotation.Resource;
/**
 * @Resource注解实现自动注入（反射）
 * 默认根据属性字段名称查找对应的bean对象 （属性字段的名称与 bean 标签的 id 属性值相等）
 */
public class UserService {
    @Resource
    private UserDao userDao; // 属性字段的名称与bean标签的id属性值相等
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void test() {
        // 调用UserDao的方法
        userDao.test();
    }
}

App main 方法运行结果

UserDao Test...

(2)如果属性字段名称未找到，则会通过类型（Class 类型）查找

/**
 * @Resource注解实现自动注入（反射）
 * 如果属性字段名称未找到，则会通过类型（Class类型）查找
 */
public class UserService {
    @Resource
    private UserDao ud; // 当在配置文件中属性字段名（ud）未找到，则会查找对应的 class（UserDao类型）
    public void setUd(UserDao ud) {
        this.ud = ud;
    }
    public void test() {
        // 调用UserDao的方法
        ud.test();
    }
}

App main 方法运行结果

UserDao Test...

(3)属性可以提供 set 方法，也可以不提供 set 方法

/**
 * @Resource注解实现自动注入（反射）
 * 属性可以提供set方法，也可以不提供set方法
 */
public class UserService {
    @Resource
    private UserDao userDao; // 不提供 set 方法
    public void test() {
        // 调用 UserDao 的方法
        userDao.test();
    }
}

App main 方法运行结果

UserDao Test...

(4)注解可以声明在属性级别或 set 方法级别

/**
* @Resource注解实现自动注入（反射）
* 注解可以声明在属性级别 或 set方法级别
*/
public class UserService {
    private UserDao userDao;
    @Resource // 注解也可设置在set方法上
    public void setUserDao(UserDao userDao) { 
        this.userDao = userDao; 
    }
    public void test() {
        // 调用UserDao的方法
        userDao.test();
    } 
}

App main 方法运行结果

UserDao Test...

(5)可以设置 name 属性

name 属性值必须与 bean 标签的 id 属性值一致；如果设置了 name 属性值，就只会按照 name 属性值查找 bean 对象

/**
* @Resource注解实现自动注入（反射）
* 可以设置name属性，name属性值必须与bean的id属性值一致；
* 如果设置了name属性值，就只会按照name属性值查找bean对象
*/
public class UserService {
    @Resource(name = "userDao") // name属性值与配置文件中bean标签的id属性值一致
    private UserDao ud;
    public void test() {
        // 调用UserDao的方法
        ud.test();
    } 
}

App main 方法运行结果

UserDao Test...

注入接口

当注入接口时，如果接口只有一个实现则正常实例化；

如果接口存在多个实现，则需要使用 name 属性指定需要被实例化的 bean 对象

定义接口类 IUserDao.java

package com.demo.spring.idao;
/**
 * 定义接口类
 */
public interface IUserDao
{
    void test();
}

定义接口实现类 UserDao01.java

package com.demo.spring.dao;
import com.demo.spring.idao.IUserDao;
public class UserDao01 implements IUserDao {
    @Override
    public void test(){
        System.out.println("UserDao01 Test...");
    }
}

定义接口实现类 UserDao02.java

package com.demo.spring.dao;
import com.demo.spring.idao.IUserDao;
public class UserDao02 implements IUserDao {
    @Override
    public void test(){
        System.out.println("UserDao02 Test...");
    }
}

XML 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启自动化装配（注入）-->
    <context:annotation-config />
    <bean id="userService" class="com.demo.spring.service.UserService"></bean>
    <bean id="userDao01" class="com.demo.spring.dao.UserDao01"></bean>
    <bean id="userDao02" class="com.demo.spring.dao.UserDao02"></bean>
</beans>

使用注解 UserService.java

package com.demo.spring.service;
import com.demo.spring.idao.IUserDao;
import javax.annotation.Resource;
/**
 * @Resource注解实现自动注入（反射）
 * 当注入接口时，如果接口只有一个实现则正常实例化；
 * 如果接口存在多个实现，则需要使用 name 属性指定需要被实例化的 bean 对象
 */
public class UserService {
    @Resource(name = "userDao01") // name 属性值与其中一个实现类的 bean 标签的 id 属性值一致
    private IUserDao iUserDao; // 注入接口（接口存在多个实现）
    public void test() {
        iUserDao.test();
    }
}

App main 方法运行结果

UserDao01 Test...

@Autowired 注解

@Autowired注解实现自动化注入：
● 默认通过类型（Class类型）查找bean对象 与属性字段的名称无关
● 属性可以提供 set 方法，也可以不提供 set 方法
● 注解可以声明在属性级别或 set 方法级别
● 可以添加 @Qualifier 结合使用，通过 value 属性值查找 bean 对象（value 属性值必须要设置，且值要与 bean 标签的 id 属性值对应）

(1)默认通过类型（Class类型）查找 bean 对象与属性字段的名称无关

package com.demo.spring.service;
import com.demo.spring.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
/**
 * @Autowired注解实现自动化注入
 * 默认通过类型（Class类型）查找bean对象 与属性字段的名称无关
 */
public class UserService {
    @Autowired
    private UserDao userDao; // 默认通过类型（Class类型）查找bean对象与属性字段的名称无关
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void test() {
        // 调用UserDao的方法
        userDao.test();
    }
}

App main 方法运行结果

UserDao Test...

(2)属性可以提供 set 方法，也可以不提供 set 方法

package com.demo.spring.service;
import com.demo.spring.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
/**
 * @Autowired注解实现自动化注入
 * 属性可以提供set方法，也可以不提供set方法
 */
public class UserService {
    @Autowired
    private UserDao userDao; // 不提供set方法
    public void test() {
        // 调用UserDao的方法
        userDao.test();
    } 
}

App main 方法运行结果

UserDao Test...

(3)注解可以声明在属性级别或 set 方法级别

package com.demo.spring.service;
import com.demo.spring.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
/**
 * @Autowired注解实现自动化注入
 * 注解可以声明在属性级别 或 set方法级别
 */
public class UserService {
    private UserDao userDao;
    @Autowired// 注解可以声明在set方法级别
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void test() {
        // 调用UserDao的方法
        userDao.test();
    }
}

App main 方法运行结果

UserDao Test...

(4)可以添加 @Qualifier 结合使用

通过 value 属性值查找 bean 对象（value 属性值必须要设置，且值要与 bean 标签的 id 属性值对应）

package com.demo.spring.service;
import com.demo.spring.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
/**
 * @Autowired注解实现自动化注入
 * 可以添加 @Qualifier 结合使用，通过 value 属性值查找 bean 对象
    value 属性值必须要设置，且值要与 bean 标签的 id 属性值对应
 */
public class UserService {
    @Autowired
    @Qualifier(value="userDao") // value 属性值必须要设置，且值要与 bean 标签的 id 属性值对应
    private UserDao userDao;
    public void test() {
        userDao.test();
    }
}

App main 方法运行结果

UserDao Test...

推荐使用 @Resource 注解是属于 J2EE 的，减少了与 Spring 的耦合。

Spring IOC 扫描器

实际的开发中，bean 的数量非常多，采用手动配置 bean 的方式已无法满足生产需要，Spring 这时候同样提供了扫描的方式，对扫描到的 bean 对象统一进行管理，简化开发配置，提高开发效率。

SpringIOC 扫描器的配置

Spring IOC 扫描器 
    作用：bean 对象统一进行管理，简化开发配置，提高开发效率
1、设置自动化扫描的范围 
    如果 bean 对象未在指定包范围，即使声明了注解，也无法实例化 
2、使用指定的注解（声明在类级别） 
    bean 对象的 id 属性默认是 类的首字母小写 
Dao层：@Repository 
Service层：@Service 
Controller层：@Controller 
任意类：@Component 
注：开发过程中建议按照指定规则声明注解

(1)设置自动化扫描范围

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 设置自动化扫描的范围 -->
    <context:component-scan base-package="com.demo.spring"/>
</beans>

(2)使用特定的注解

@Repository（Dao层）

@Repository 
public class ResourceDao {
    public void test() { 
        System.out.println("ResourceDao..."); 
    }
}

@Service（Service层 ）

@Service 
public class ResourceService {
    @Resource 
    private ResourceDao resourceDao; // service层注入dao层的bean对象
    public void test() { 
        System.out.println("ResourceService..."); 
        resourceDao.test(); 
    }
}

@Controller（Controller 层 ）

@Controller 
public class ResourceController {
    @Autowired 
    private ResourceService resourceService; // Controller层注入service层的 bean对象
    public void test() { 
        System.out.println("ResourceController..."); 
        resourceService.test(); 
    }
}

@Component（任意层）

@Component 
public class PropertyUtils { 
    public void test(){ 
        System.out.println("PropertyUtils..."); 
    } 
}

Spring 模拟用户登录流程

一.Dao层（查询用户记录）

1.定义 JavaBean User.java

package com.demo.spring.po;
/** *
 * User 用户实体类
 *
 **/
public class User {
    private String userName; // 用户名称
    private String userPwd; // 用户密码
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserPwd() {
        return userPwd;
    }
    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }
}

2.编写 Dao 层 UserDao.java

package com.demo.spring.dao;
import com.demo.spring.po.User;
import org.springframework.stereotype.Repository;
@Repository
public class UserDao {
    private final String USERNAME = "admin";
    private final String USERPWD = "admin";
    /** * 通过用户名称查询用户对象
     * * @param userName
     * * @return
    */
    public User queryUserByUserName(String userName){
        User user = null;
        // 判断用户名称是否正确
        if(!USERNAME.equals(userName)){
            // 如果不正确，返回null
            return null;
        } // 如果正确，将用户名称和密码设置到user对象中
        user = new User();
        user.setUserName(USERNAME);
        user.setUserPwd(USERPWD);
        return user;
    }
}

二.编写 Service 层 UserService.java

package com.demo.spring.model;
public class MessageModel {
    Integer resultCode;
    String resultMsg;
    public void setResultCode(Integer resultCode){
        this.resultCode = resultCode;
    }
    public Integer getResultCode(){
        return resultCode;
    }
    public void setResultMsg(String resultMsg){
        this.resultMsg = resultMsg;
    }
    public String getResultMsg(){
        return resultMsg;
    }
}

package com.demo.spring.service;
import com.demo.spring.dao.UserDao;
import com.demo.spring.model.MessageModel;
import com.demo.spring.po.User;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
 * @Autowired注解实现自动化注入
 * 可以添加 @Qualifier 结合使用，通过 value 属性值查找 bean 对象
    value 属性值必须要设置，且值要与 bean 标签的 id 属性值对应
 */
@Service 
public class UserService {
    @Resource
    private UserDao userDao;
    /** * 验证用户登录
     * @param userName
     * @param userPwd
     * @return
    */
    public MessageModel userLoginCheck(String userName, String userPwd){
        // 定义业务处理返回消息模型
        MessageModel messageModel = new MessageModel();
        // 判断用户名称是否非空
        if(null == userName || "".equals(userName.trim())){
            messageModel.setResultCode(0);
            messageModel.setResultMsg("用户名不能为空！");
            return messageModel;
        }
        // 判断用户密码是否为空
        if(null == userPwd || "".equals(userPwd.trim())){
            messageModel.setResultCode(0);
            messageModel.setResultMsg("密码不能为空！");
            return messageModel;
        }
        // 通过用户名称查询用户对象
        User user = userDao.queryUserByUserName(userName);
        // 判断用户对象是否为空
        if(null == user){
            messageModel.setResultCode(0);
            messageModel.setResultMsg("该用户不存在！");
            return messageModel;
        }
        // 如果用户对象不为空，判断密码是否正确
        if(!user.getUserPwd().equals(userPwd)){
            messageModel.setResultCode(0 );
            messageModel.setResultMsg("用户密码不正确！");
            return messageModel;
        }
        // 登录成功
        messageModel.setResultCode(200);
        messageModel.setResultMsg("登录成功！");
        return messageModel;
    }
}

三.Controller层（接收请求）

package com.demo.spring.controller;
import com.demo.spring.model.MessageModel;
import com.demo.spring.service.UserService;
import org.springframework.stereotype.Controller;
import javax.annotation.Resource;
@Controller
public class UserController {
    @Resource
    private UserService userService;
    /** * 用户登录
     * @param userName
     * @param userPwd
     * @return
     */
    public MessageModel login(String userName, String userPwd){
        // 调用Dao层判断用户登录操作，返回结果
        MessageModel messageModel = userService.userLoginCheck(userName, userPwd);
        return messageModel;
    }
}

四.Controller层（接收请求）

package com.demo.spring;
import com.demo.spring.controller.UserController;
import com.demo.spring.model.MessageModel;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        // 得到UserController实例化对象
        UserController userController = (UserController) ac.getBean("userController");
        // 传入参数调用UserController的方法，返回封装类
        MessageModel messageModel= userController.login("admin", "admin");
        System.out.println("状态码：" + messageModel.getResultCode().toString() + "，提示信息 ：" + messageModel.getResultMsg());
    }
}

运行结果

状态码：200，提示信息 ：登录成功！

Bean 的作用域与生命周期

Bean 的作用域

默认情况下，我们从 Spring 容器中拿到的对象均是单例的，对于 bean 的作用域类型如下

1.singleton 作用域

注意: lazy-init是懒加载,如果等于 true 时作用是指 Spring 容器启动的时候不会去实例化这个bean,而是在程序调用时才去实例化。
默认是 false 即 Spring 容器启动时实例化。

默认情况下，被管理的 bean 只会 IOC 容器中存在一个实例，对于所有获取该 Bean 的操作 Spring 容器 将只返回同一个 Bean。

容器在启动的情况下就实例化所有singleton 的 bean对象，并缓存与容器中

lazy-init属性（懒加载）
如果为 false，则在 IOC 容器启动时会实例化 Bean 对象，默认false
如果为 true，则 IOC 容器启动时不会实例化 Bean 对象，在使用 bean 对象时才会实例化

lazy-init 设置为 false 有什么好处？
1）可以提前发现潜在的配置问题
2）Bean 对象存在于缓存中，使用时不用再去实例化 bean，加快程序运行效率

什么对象适合作为单例对象？
一般来说对于无状态或状态不可改变的对象适合使用单例模式。（不存在会改变对象状态的成员变量）
比如：controller 层、service 层、dao 层

什么是无状态或状态不可改变的对象？
实际上对象状态的变化往往均是由于属性值得变化而引起的，比如 user 类 姓名属性会有变化，属性姓名的变化一般会引起 user 对象状态的变化。对于我们的程序来说，无状态对象没有实例变量的存在，保证了线程的安全性，service 层业务对象即是无状态对象。线程安全的。

2.prototype 作用域

通过 scope=”prototype” 设置 bean 的类型 ，每次向 Spring 容器请求获取 Bean 都返回一个全新的 Bean，相对于 “singleton” 来说就是不缓存 Bean，每次都是一个根据 Bean 定义创建的全新 Bean。

3.Web 应用中的作用域

1.request 作用域表示每个请求需要容器创建一个全新 Bean。比如提交表单的数据必须是对每次请求新建一个 Bean 来保持这些表单数据，请求结束释放这些数据。

2.session 作用域 表示每个会话需要容器创建一个全新 Bean。比如对于每个用户一般会有一个会话，该用户的用户 信息需要存储到会话中，此时可以将该 Bean 作用域配置为 session 级别。

3.globalSession 作用域类似于 session 作用域，其用于 portlet(Portlet是基于 Java 的 Web 组件，由 Portlet 容器管理，并由 容器处理请求，生产动态内容)环境的 web 应用。如果在非 portlet 环境将视为 session 作用域。

配置方式和基本的作用域相同，只是必须要有 web 环境支持，并配置相应的容器监听器或拦截器从而能应用这些作用域，目前先熟悉概念，后续集成 web 时讲解具体使用，大家只需要知道有这些作用域就可以了。

Bean 的生命周期

对比已经学过的 servlet 生命周期（容器启动装载并实例化 servlet 类，初始化 servlet，调用 service 方法，销毁 servlet）。

同样对于 Spring 容器管理的 bean 也存在生命周期的概念。

在 Spring 中，Bean 的生命周期包括 Bean 的定义、初始化、使用和销毁 4 个阶段。

1.Bean 的定义

在 Spring 中，通常是通过配置文档的方式来定义 Bean 的。

在一个配置文档中，可以定义多个 Bean。

2.Bean 的初始化

默认在 IOC 容器加载时，实例化对象。

Spring bean 初始化有两种方式：

方式一：在配置文档中通过指定 init-method 属性来完成。

public class RoleService { 
    // 定义初始化时需要被调用的方法 
    public void init() { 
        System.out.println("RoleService init..."); 
    } 
}

<!-- 通过init-method属性指定方法 --> 
<bean id="roleService" class="com.demo.spring.service.RoleService" init-method="init"></bean>

方式二： 实现 org.springframework.beans.factory.InitializingBean 接口。

public class RoleService implements InitializingBean {
    @Override 
    public void afterPropertiesSet() throws Exception { 
        System.out.println("RoleService init..."); 
    }
}

<bean id="roleService" class="com.demo.spring.service.RoleService" ></bean>

Bean 对象实例化过程是在 Spring 容器初始化时被实例化的，但也不是不可改变的，可以通过 lazyinit=”true” 属性延迟 bean 对象的初始化操作，此时再调用 getBean 方法时才会进行 bean 的初始化操作。

3.Bean 的使用

方式一 ：使用 BeanFactory

// 得到Spring的上下文环境 
BeanFactory factory = new ClassPathXmlApplicationContext("spring.xml"); 
RoleService roleService = (RoleService) factory.getBean("roleService");

方式二：使用 ApplicationContext

// 得到Spring的上下文环境 
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml"); 
RoleService roleService = (RoleService) ac.getBean("roleService");

4.Bean 的销毁

实现销毁方式(Spring 容器会维护 bean 对象的管理，可以指定 bean 对象的销毁所要执行的方法)。

步骤一：实现销毁方式(Spring 容器会维护 bean 对象的管理，可以指定 bean 对象的销毁所要执行的方法)

<bean id="roleService" class="com.demo.spring.service.RoleService" destroymethod="destroy">
</bean>

步骤二：通过 AbstractApplicationContext 对象，调用其 close 方法实现 bean 的销毁过程

AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml"); 
ctx.close();

IOC/DI-控制反转和依赖注人 
将对象实例化的创建过程转交给外部容器（IOC 容器充当工厂角色）去负责；
属性赋值的操作；