【Spring从入门到精通】01-IOC容器

笔记来源：尚硅谷Spring框架视频教程（spring5源码级讲解）

目录

• IOC 容器
  • 1、IOC 的概念原理
    • 1.1、IOC 是什么？
    • 1.2、IOC 底层实现
    • 1.3、图解 IOC 原理
  • 2、IOC 接口
    • 2.1、ApplicationContext
    • 2.2、BeanFactory
  • 3、IOC 操作 Bean 管理
    • 3.1、Bean 管理是什么
    • 3.2、Bean 管理实现方式
  • 4、基于 XML 方式
    • 4.1、创建对象
    • 4.2、注入属性
      • 1）通过 Setter 方式注入
      • 2）通过有参构造注入
      • 3）p 名称空间注入（了解）
    • 4.3、注入其他类型属性
      • 1）字面量
      • 2）外部 Bean
      • 3）内部 Bean
      • 4）级联赋值
    • 4.4、注入集合属性
    • 4.5、自动装配
    • 4.6、外部属性文件
  • 5、FactoryBean
  • 6、Bean 作用域和生命周期
    • 6.1、Bean 作用域
    • 6.2、Bean 生命周期
  • 7、注解方式
    • 7.1、什么是注解
    • 7.2、创建对象
    • 7.3、组件扫描配置
      • 设置扫描
      • 设置不扫描
    • 7.4、属性注入
      • @Autowired
      • @Qualifier
      • @Resource
      • @Value
    • 7.5、完全注解开发

IOC 容器

1、IOC 的概念原理

1.1、IOC 是什么？

• 1）控制反转，把对象的创建和对象之间的调用过程，都交给 Spring 进行管理
• 2）使用 IOC 的目的：降低耦合性

1.2、IOC 底层实现

• 1）xml 解析
• 2）工厂模式
• 3）反射技术

1.3、图解 IOC 原理

原始方法

代码示例

public class UserDao {
    public void add(){
        // ...
    }
}
public class UserService {
    public void execute(){
        UserDao dao = new UserDao();
        dao.add();
    }
}

工厂模式

代码示例

public class UserDao {
    public void add(){
        // ...
    }
}
public class UserFactory{
    public static UserDao getDao(){
        return new UserDao();
    }
}
public class UserService {
    public void execute(){
        UserDao dao = UserFactory.getDao();
        dao.add();
    }
}

IOC 过程

代码示例

public class UserFactory{
	public static UserDao getDao(){
        // 1、xml解析
        String classValue = class属性值;
        // 2、通过反射创建对象
        Class clazz = Class.forName(classValue);
        return (UserDao)clazz.newInstance();
	}
}

2、IOC 接口

1）IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂

2）Spring 提供了IOC 容器实现的两种方式（即两个接口）

• BeanFactory
  • IOC 容器基本实现，是 Spring 的内部接口，不提供给开发人员使用
  • 加载配置文件时不会创建对象，使用对象时才会创建对象
• ApplicationContext
  • BeanFactory的子接口，提供更多功能，提供给开发人员使用
  • 加载配置文件就创建对象

2.1、ApplicationContext

ApplicationContext接口的实现类

• FileSystemXmlApplicationContext：xml 配置文件在系统盘中的文件全路径名

  new FileSystemXmlApplicationContext("D:\workspace\NOTE_Spring\Spring5_HelloWorld\src\bean1.xml");
  

• ClassPathXmlApplicationContext：xml 配置文件在项目 src 下的相对路径名

  new ClassPathXmlApplicationContext("bean1.xml");
  

2.2、BeanFactory

BeanFactory接口的子接口和实现类

• ConfigurableApplicationContext：包含一些相关的扩展功能

3、IOC 操作 Bean 管理

3.1、Bean 管理是什么

Bean 管理指的是两个操作

• 1）Spring 创建对象
• 2）Spring 注入属性

public class User{
    private String userName;

    public void setUserName(String userName){
        this.userName = userName;
    }
}

3.2、Bean 管理实现方式

• 1）基于 XML 配置文件方式实现
• 2）基于注解方式实现

4、基于 XML 方式

4.1、创建对象

<!--配置User对象-->
<bean id="user" class="com.vectorx.spring5.User"></bean>

1）在 Spring 配置文件中，使用bean标签，标签里添加对应属性，就可以实现对象的创建

2）bean标签中有很多属性，介绍常用的属性

• id属性：唯一标识
• class属性：类全限定名、类全路径
• name属性：了解即可，早期为Struts框架服务，现已“退役”，作用跟id属性一样
• 其他属性：后面再做介绍...

3）创建对象时，默认执行无参构造方法

如果只提供一个有参构造方法，如下

public class User {
    private String userName;

    public User(String userName) {
        this.userName = userName;
    }

    // ...
}

仍然按照之前获取 User 对象创建方式，即

// 1、加载自定义的Spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
// 2、获取配置的User对象
User user = context.getBean("user", User.class);

则会报错

警告: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'user' defined in class path resource [bean1.xml]: Instantiation of bean failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.vectorx.spring5.User]: No default constructor found; nested exception is java.lang.NoSuchMethodException: com.vectorx.spring5.User.<init>()

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'user' defined in class path resource [bean1.xml]: Instantiation of bean failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.vectorx.spring5.User]: No default constructor found; nested exception is java.lang.NoSuchMethodException: com.vectorx.spring5.User.<init>()

	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.instantiateBean(AbstractAutowireCapableBeanFactory.java:1334)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:1232)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:582)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:542)
	at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:335)
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:333)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:208)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:953)
	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:918)
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:583)
	at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:144)
	at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:85)
	at com.vectorx.spring5.testdemo.TestSpring5.testAdd(TestSpring5.java:13)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:59)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:56)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
	at org.junit.runners.BlockJUnit4ClassRunner$1.evaluate(BlockJUnit4ClassRunner.java:100)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:366)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:103)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:63)
	at org.junit.runners.ParentRunner$4.run(ParentRunner.java:331)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:79)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:329)
	at org.junit.runners.ParentRunner.access$100(ParentRunner.java:66)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:293)
	at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:413)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:69)
	at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33)
	at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:221)
	at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:54)
Caused by: org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.vectorx.spring5.User]: No default constructor found; nested exception is java.lang.NoSuchMethodException: com.vectorx.spring5.User.<init>()
	at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:83)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.instantiateBean(AbstractAutowireCapableBeanFactory.java:1326)
	... 38 more
Caused by: java.lang.NoSuchMethodException: com.vectorx.spring5.User.<init>()
	at java.lang.Class.getConstructor0(Class.java:3082)
	at java.lang.Class.getDeclaredConstructor(Class.java:2178)
	at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:78)
	... 39 more

其中主要报错信息

Failed to instantiate [com.vectorx.spring5.User]: No default constructor found
...
Caused by: java.lang.NoSuchMethodException: com.vectorx.spring5.User.<init>()

就是说：初始化 User 对象失败，因为没有找到默认构造，所以抛出了一个NoSuchMethodException异常，即 User 中没有<init>()方法

4.2、注入属性

DI：依赖注入，就是注入属性（但需要在创建对象基础上进行）

IOC和DI的区别：DI是IOC的一种具体实现

两种注入方式：Setter 方式、有参构造方法

• 第一种注入方式：通过 Setter 方式进行注入

  public class Book{
      private String bname;
      
      // Setter 方法注入
      public void setBname(String bname){
          this.bname = bname;
      }
      
      public static void main(String[] args){
          Book book = new Book();
          book.setBname("book1");
      }
  }
  

• 第二种注入方式：通过有参构造方法进行注入

  public class Book{
      private String bname;
      
      // 有参构造注入
      public Book(String bname){
          this.bname = bname;
      }
      
      public static void main(String[] args){
          Book book = new Book("book1");
      }
  }
  

1）通过 Setter 方式注入

① 创建类，定义属性和 Setter 方法

public class Book {
    private String bname;
    private String bauthor;

    public void setBname(String bname) {
        this.bname = bname;
    }
    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }
}

② 在 Spring 配置文件中配置对象创建，配置属性注入

<!-- 2、Setter方法注入属性 -->
<bean id="book" class="com.vectorx.spring5.s1_xml.setter.Book">
    <!-- 使用property完成属性注入
            name: 类中属性名称
            value: 向属性中注入的值
    -->
    <property name="bname" value="Spring实战 第5版"></property>
    <property name="bauthor" value="克雷格·沃斯（Craig Walls）"></property>
</bean>

2）通过有参构造注入

① 创建类，定义属性，创建属性对应有参构造方法

public class Orders {
    private String oname;
    private String address;

    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
}

② 在 Spring 配置文件中配置对象创建，配置有参构造注入

<!-- 3、有参构造注入属性 -->
<bean id="order" class="com.vectorx.spring5.s2_xml.constructor.Orders">
    <constructor-arg name="oname" value="Spring微服务实战"></constructor-arg>
    <constructor-arg name="address" value="[美]约翰·卡内尔（John Carnell）"></constructor-arg>
</bean>

或者使用index属性代替name属性，索引值大小是几就表示有参构造中的第几个参数（索引从0开始）

<!-- 3、有参构造注入属性 -->
<bean id="order" class="com.vectorx.spring5.s2_xml.constructor.Orders">
    <constructor-arg index="0" value="冰墩墩"></constructor-arg>
    <constructor-arg index="1" value="Peking"></constructor-arg>
</bean>

3）p 名称空间注入（了解）

① 基于 p 名称空间注入，可以简化基于 xml 的配置方式

在bean1.xml配置文件中添加 p 名称空间：xmlns:p="http://www.springframework.org/schema/p"，如下

<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 http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

在bean标签中进行属性注入操作

<!-- 4、p名称空间注入属性 -->
<bean id="book1" class="com.vectorx.spring5.s1_xml.setter.Book" p:bname="SpringBoot实战" p:bauthor="[美]克雷格·沃斯"></bean>

需要注意的是：p 名称空间只能进行属性注入

4.3、注入其他类型属性

1）字面量

• null值：使用<null>

  <bean id="book2" class="com.vectorx.spring5.s1_xml.setter.Book">
      <property name="bname" value="Spring实战 第5版"></property>
      <property name="bauthor">
          <null></null>
      </property>
  </bean>
  

• 属性值包含特殊符号：有两种方式

  • 使用转义字符，如<>标识<>

    <!-- 字面量：property方式注入含有特殊符号的属性 -->
    <bean id="book3" class="com.vectorx.spring5.s1_xml.setter.Book">
        <property name="bname" value="Spring实战 第5版"></property>
        <property name="bauthor" value="&lt;Test&gt;"</property>
    </bean>
    

  • 使用CDATA结构，如<![CDATA[<Test>]]>

    <!-- 字面量：property方式注入含有特殊符号的属性 -->
    <bean id="book4" class="com.vectorx.spring5.s1_xml.setter.Book">
        <property name="bname" value="Spring实战 第5版"></property>
        <property name="bauthor">
            <value><![CDATA[<Test>]]></value>
        </property>
    </bean>
    

2）外部 Bean

① 创建两个类：Service类和Dao类

public interface UserDao {
    void update();
}
public class UserDaoImpl implements UserDao{
    @Override
    public void update() {
        System.out.println("dao update...");
    }
}

② 在Service中调用Dao中的方法

public class UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void updateUser(){
        System.out.println("service update...");
        userDao.update();
    }
}

③ 在 Spring 配置文件中进行配置

<!--  1、配置service和dao创建  -->
<bean id="userService" class="com.vectorx.spring5.s3_xml.outerbean.service.UserService">
    <!-- 2、注入userDao对象
               name属性：类里面属性名称
               ref属性：创建userDao对象bean标签id值
       -->
    <property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.vectorx.spring5.s3_xml.outerbean.dao.UserDaoImpl"></bean>

3）内部 Bean

① 一对多关系：部门和员工。部门里有多个员工，一个员工属于一个部门。部门是一的一方，员工是多的一方

② 在实体类之间表示一对多关系。在员工类中使用对象类型表示所属部门

public class Dept {
    private String dname;
    
    public String getDname() {
        return dname;
    }
    public void setDname(String dname) {
        this.dname = dname;
	}
}
public class Emp {
    private String ename;
    private String gender;
    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
}

③ 在 Spring 配置文件中进行配置

<bean id="emp1" class="com.vectorx.spring5.s4_xml.innerbean.Emp">
    <property name="ename" value="Lucy"></property>
    <property name="gender" value="female"></property>
    <property name="dept">
        <bean id="dept1" class="com.vectorx.spring5.s4_xml.innerbean.Dept">
            <property name="dname" value="Develop Department"></property>
        </bean>
    </property>
</bean>

4）级联赋值

第一种写法

<!-- 级联赋值 -->
<bean id="emp2" class="com.vectorx.spring5.s4_xml.innerbean.Emp">
    <property name="ename" value="Nancy"></property>
    <property name="gender" value="female"></property>
    <property name="dept" ref="dept2"></property>
</bean>
<bean id="dept2" class="com.vectorx.spring5.s4_xml.innerbean.Dept">
    <property name="dname" value="Sallery Department"></property>
</bean>

第二种写法<property name="dept.dname" value="Manage Department"></property>

<!-- 级联赋值 -->
<bean id="emp2" class="com.vectorx.spring5.s4_xml.innerbean.Emp">
    <property name="ename" value="Nancy"></property>
    <property name="gender" value="female"></property>
    <property name="dept" ref="dept2"></property>
    <property name="dept.dname" value="Manage Department"></property>
</bean>
<bean id="dept2" class="com.vectorx.spring5.s4_xml.innerbean.Dept">
    <property name="dname" value="Sallery Department"></property>
</bean>

这种写法可以对外部Bean的属性值进行覆盖，但前提是要有dept的Getter方法

public Dept getDept() {
    return dept;
}

否则 XML 文件就会爆红

强行使用就会报如下错误

Caused by: org.springframework.beans.NotWritablePropertyException: Invalid property 'dept.dname' of bean class [com.vectorx.spring5.s4_xml.innerbean.Emp]: Nested property in path 'dept.dname' does not exist; nested exception is org.springframework.beans.NotReadablePropertyException: Invalid property 'dept' of bean class [com.vectorx.spring5.s4_xml.innerbean.Emp]: Bean property 'dept' is not readable or has an invalid getter method: Does the return type of the getter match the parameter type of the setter?

4.4、注入集合属性

• 1）注入数组类型属性
• 2）注入 List 集合类型属性
• 3）注入 Map 集合类型属性

① 创建类，定义数组、list、map、set 类型属性，生成对应 setter 方法

public class Stu {
    private String[] arrs;
    private List<String> lists;
    private Map<String, String> maps;
    private Set<String> sets;
    public void setArrs(String[] arrs){
        this.arrs = arrs;
    }
    public void setLists(List<String> lists){
        this.lists = lists;
    }
    public void setMaps(Map<String, String> maps){
        this.maps = maps;
    }
    public void setSets(Set<String> sets){
        this.sets = sets;
    }
}

② 在 Spring 配置文件中进行配置

<!-- 集合类型属性注入 -->
<bean id="stu" class="com.vectorx.spring5.s5_xml.collection.Stu">
    <!--  1 数组属性注入  -->
    <property name="arrs">
        <array>
            <value>数组</value>
            <value>属性</value>
            <value>注入</value>
        </array>
    </property>
    <!--  2 list属性注入  -->
    <property name="lists">
        <list>
            <value>list</value>
            <value>属性</value>
            <value>注入</value>
        </list>
    </property>
    <!--  3 map属性注入  -->
    <property name="maps">
        <map>
            <entry key="k1" value="v1"></entry>
            <entry key="k2" value="v2"></entry>
            <entry key="k3" value="v3"></entry>
        </map>
    </property>
    <!--  4 set属性注入  -->
    <property name="sets">
        <set>
            <value>set</value>
            <value>属性</value>
            <value>注入</value>
        </set>
    </property>
</bean>

• 4）注入 List 类型属性值，值为对象

<bean id="stu" class="com.vectorx.spring5.s5_xml.collection.Stu">
    <!--注入 List 类型属性值，值为对象-->
    <property name="lists2">
        <list>
            <ref bean="course1"></ref>
            <ref bean="course2"></ref>
            <ref bean="course3"></ref>
        </list>
    </property>
</bean>
<bean id="course1" class="com.vectorx.spring5.s5_xml.collection.Course">
    <property name="cname" value="c1"></property>
</bean>
<bean id="course2" class="com.vectorx.spring5.s5_xml.collection.Course">
    <property name="cname" value="c2"></property>
</bean>
<bean id="course3" class="com.vectorx.spring5.s5_xml.collection.Course">
    <property name="cname" value="c3"></property>
</bean>

• 5）把集合注入部分提取出来

① 在 Spring 配置文件中引入util命名空间

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

② 使用util标签完成 list 集合注入提取

<!--提取属性注入-->
<util:list id="utilList">
    <value>111</value>
    <value>222</value>
    <value>333</value>
</util:list>
<!--提取属性注入使用-->
<bean id="stu2" class="com.vectorx.spring5.s5_xml.collection.Stu">
    <property name="lists" ref="utilList"></property>
</bean>

4.5、自动装配

自动装配：根据指定装配规则（属性名称或属性类型），Spring 自动将匹配的属性值进行注入

XML 实现自动装配：bean标签中有个属性autowire，里面有两个常用的属性值

• byName根据属性名称注入，要求注入值bean的id值和类中属性名称一致
• byType根据属性类型注入，要求注入值bean的类型在配置文件中只存在一份

1）根据属性名称进行自动注入

<bean id="emp" class="com.vectorx.spring5.s9_xml.autowire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.vectorx.spring5.s9_xml.autowire.Dept"></bean>

2）根据属性类型进行自动注入

<bean id="emp" class="com.vectorx.spring5.s9_xml.autowire.Emp" autowire="byType"></bean>
<bean id="dept" class="com.vectorx.spring5.s9_xml.autowire.Dept"></bean>

4.6、外部属性文件

1、直接配置数据库信息

• 1）引入Druid连接池依赖jar包
• 2）配置Druid连接池

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
</bean>

2、引入外部属性文件配置数据库连接池

• 1）创建properties格式的外部属性文件，配置数据库连接信息

  mysql.driverClassName=com.mysql.jdbc.Driver
  mysql.url=jdbc:mysql://localhost:3306
  mysql.username=root
  mysql.password=root
  

• 2）将外部properties属性文件引入到 Spring 配置文件中

<!--引入context名称空间-->
<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 
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd">
    <!--引入外部属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--使用Spring表达式配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${mysql.driverClassName}"></property>
        <property name="url" value="${mysql.url}"></property>
        <property name="username" value="${mysql.username}"></property>
        <property name="password" value="${mysql.password}"></property>
    </bean>
</beans>

5、FactoryBean

Spring 有两种类型 Bean，一种是普通 Bean，另外一种是工厂 Bean（FactoryBean）

• 普通 Bean：在配置文件中定义的 Bean 类型就是返回类型
• 工厂 Bean：在配置文件中定义的 Bean 类型可以和返回类型不一致

上述的例子都是普通 Bean 的类型，那么工厂 Bean 该怎么实现呢？

• 1）创建类，实现 FactoryBean 接口，使其作为一个工厂 Bean
• 2）实现接口中的方法，在实现方法中定义返回的 Bean 类型

public class MyFactoryBean implements FactoryBean<Course> {
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("CourseName");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }
}

• 3）在 Spring 配置文件中进行配置

<bean id="myFactoryBean" class="com.vectorx.spring5.s6_xml.factorybean.MyFactoryBean"></bean>

由于是 FactoryBean，所以再通过上下文获取时，需要使用实现 FactoryBean 时传入的泛型类型进行接收

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean5.xml");
Course course = applicationContext.getBean("myFactoryBean", Course.class);

如果仍然使用配置文件中定义的 Bean 类型，则会报错

Exception in thread "main" org.springframework.beans.factory.BeanNotOfRequiredTypeException: Bean named 'myFactoryBean' is expected to be of type 'com.vectorx.spring5.s6_xml.factorybean.MyFactoryBean' but was actually of type 'com.vectorx.spring5.s6_xml.factorybean.Course'
	at org.springframework.beans.factory.support.AbstractBeanFactory.adaptBeanInstance(AbstractBeanFactory.java:417)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:398)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:213)
	at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1160)
	at com.vectorx.spring5.s6_xml.factorybean.TestFactoryBean.main(TestFactoryBean.java:11)

6、Bean 作用域和生命周期

6.1、Bean 作用域

在 Spring 里面，可以设置创建 Bean 的实例是单实例还是多实例，默认情况下是单实例

<bean id="book" class="com.vectorx.spring5.s7_xml.setter.Book"></bean>

测试

ApplicationContext context = new ClassPathXmlApplicationContext("bean6.xml");
Book book1 = context.getBean("book", Book.class);
Book book2 = context.getBean("book", Book.class);
System.out.println(book1 == book2); // true 表示是同一个对象，证明默认情况下是单实例

如何设置单实例多实例？

在 Spring 配置文件中 bean 标签里scope属性用于设置单实例还是多实例

• 1）singleton，单实例，默认情况下不写也是它
• 2）prototype，多实例

<bean id="book2" class="com.vectorx.spring5.s7_xml.setter.Book" scope="prototype"></bean>

测试

Book book3 = context.getBean("book2", Book.class);
Book book4 = context.getBean("book2", Book.class);
System.out.println(book3 == book4); // false 表示不是同一个对象，证明scope为prototype时是多实例

singleton和prototype的区别

singleton和prototype除了单实例和多实例的差别之外，还有以下区别

• 1）设置scope值是singleton时，加载 Spring 配置文件时就会创建单实例对象
• 2）设置scope值是prototype时，加载 Spring 配置文件时不会创建对象，而是在调用getBean方法时创建多实例对象

scope的其他值

scope的属性值除了singleton和prototype之外，其实还有一些属性值，如

• request，每个request创建一个新的 bean
• session，同一session中的 bean 是一样的

不过这两个属性值使用非常少，了解即可

6.2、Bean 生命周期

生命周期：从对象创建到对象销毁的过程

Bean 生命周期

• 1）通过构造器创建 Bean 实例（无参构造）
• 2）为 Bean 属性设置值和对其他 Bean 引用（调用 setter 方法）
• 3）调用 Bean 的初始化方法（需要进行配置初始化方法）
• 4）Bean 就可以使用了（对象获取到了）
• 5）当容器关闭时，调用 Bean 的销毁方法（需要进行配置销毁方法）

代码演示

public class Orders {
    public Orders() {
        System.out.println("Step1.执行无参构造创建Bean实例.");
    }

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("Step2.通过setter方法设置属性值.");
    }

    public void initMethod(){
        System.out.println("Step3.执行初始化方法.");
    }

    public void destoryMethod(){
        System.out.println("Step5.执行销毁方法.");
    }
}

Spring 配置文件中的配置

<bean id="orders" class="com.vectorx.spring5.s8_xml.lifecycle.Orders" init-method="initMethod"
      destroy-method="destoryMethod">
    <property name="oname" value="Phone"></property>
</bean>

测试

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean7.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println("Step4.获取创建Bean实例对象.");
System.out.println(orders);
// 手动销毁Bean实例
context.close();

执行结果

Step1.执行无参构造创建Bean实例.
Step2.通过setter方法设置属性值.
Step3.执行初始化方法.
Step4.获取创建Bean实例对象.
com.vectorx.spring5.s8_xml.lifecycle.Orders@210366b4
Step5.执行销毁方法.

Spring 中 Bean 更加完整的生命周期其实不止上述 5 步，另外还有 2 步操作叫做 Bean 的后置处理器

Bean 后置处理器

加上 Bean 后置处理器，Bean 生命周期如下

• 1）通过构造器创建 Bean 实例（无参构造）
• 2）为 Bean 属性设置值和对其他 Bean 引用（调用 setter 方法）
• 3）把 Bean 的实例传递给 Bean 后置处理器的postProcessBeforeInitialization方法
• 4）调用 Bean 的初始化方法（需要进行配置初始化方法）
• 5）把 Bean 的实例传递给 Bean 后置处理器的postProcessAfterInitialization方法
• 6）Bean 就可以使用了（对象获取到了）
• 7）当容器关闭时，调用 Bean 的销毁方法（需要进行配置销毁方法）

代码演示

• 1）创建类，实现接口BeanPostProcessor，创建后置处理器

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Step.初始化之前执行的方法");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Step.初始化之后执行的方法");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

• 2）Spring 配置文件中配置后置处理器

<!--配置后置处理器，会为当前配置文件中所有bean添加后置处理器-->
<bean id="myBeanPost" class="com.vectorx.spring5.s8_xml.lifecycle.MyBeanPost"></bean>

执行结果

Step1.执行无参构造创建Bean实例.
Step2.通过setter方法设置属性值.
Step.初始化之前执行的方法
Step3.执行初始化方法.
Step.初始化之后执行的方法
Step4.获取创建Bean实例对象.
com.vectorx.spring5.s8_xml.lifecycle.Orders@74e52ef6
Step5.执行销毁方法.

7、注解方式

7.1、什么是注解

• 注解是一种代码特殊标记，格式：@注解名称(属性名称=属性值,属性名称=属性值...)
• 注解作用：在类上面，方法上面，属性上面
• 注解目的：简化 XML 配置

7.2、创建对象

• @Component
• @Service
• @Controller
• @Repository

上面四个注解功能是一样的，都可以用来创建 Bean 实例

• 1）引入依赖

• 2）开启组件扫描

<?xml version="1.0" encoding="UTF-8"?>
<!--引入context名称空间-->
<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 http://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.vectorx.spring5.s11_annotation.dao,com.vectorx.spring5.s11_annotation.service"></context:component-scan>
</beans>

• 3）创建类，在类上添加创建对象注解

/**
 * value可省略，默认值为类名首字母小写
 */
@Component(value = "userService")
public class UserService {
    public void add(){
        System.out.println("UserService add...");
    }
}

7.3、组件扫描配置

设置扫描

• use-default-filters表示现在不使用默认filter，自己配置filter
• include-filter设置扫描哪些内容

<context:component-scan
                        base-package="com.vectorx.spring5.s11_annotation" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

设置不扫描

• 配置扫描包下所有内容
• exclude-filter设置不扫描哪些内容

<context:component-scan
                        base-package="com.vectorx.spring5.s11_annotation">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

7.4、属性注入

• @Autowired根据属性类型进行自动装配
• @Qualifier根据属性名称进行注入，需要和@Autowired一起使用
• @Resource可以根据类型和名称注入
• @Value根据普通类型注入

@Autowired

• 1）创建 Service 和 Dao 对象，在 Service 和 Dao 类上添加创建对象注解

public interface UserDao {
    void add();
}
@Repository
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {
        System.out.println("UserDaoImpl add...");
    }
}
@Service
public class UserService {
    public void add() {
        System.out.println("UserService add...");
    }
}

• 2）在 Service 类中添加 Dao 类型属性，在属性上面使用注解注入 Dao 对象

@Service
public class UserService {

    @Autowired
    private UserDao userDao;

    public void add() {
        System.out.println("UserService add...");
        userDao.add();
    }
}

因为@Autowired是根据属性类型进行注入的，如果 UserDao 的实现类不止一个，比如新增一个 UserDaoImpl2 类

@Repository
public class UserDaoImpl2 implements UserDao {
    @Override
    public void add() {
        System.out.println("UserDaoImpl2 add...");
    }
}

那么此时测试程序就会报错

Exception in thread "main" org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'userService': Unsatisfied dependency expressed through field 'userDao'; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.vectorx.spring5.s11_annotation.dao.UserDao' available: expected single matching bean but found 2: userDaoImpl,userDaoImpl2
...
Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.vectorx.spring5.s11_annotation.dao.UserDao' available: expected single matching bean but found 2: userDaoImpl,userDaoImpl2
...

大概意思就是说，主程序抛出了一个UnsatisfiedDependencyException即不满足依赖异常，嵌套异常是NoUniqueBeanDefinitionException即Bean定义不唯一异常，预期匹配单个 Bean 但是找到了两个 Bean

此时想要指定装配某一个实现类，就需要用到@Qualifier注解

@Qualifier

书接上回，如果我们想要从多个实现类中装配具体某一个实现类，可以这么写

@Autowired
@Qualifier(value = "userDaoImpl")
private UserDao userDao;

其中value值为具体的实现类上配置的注解中value值

@Repository
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {
        System.out.println("UserDaoImpl add...");
    }
}
@Repository
public class UserDaoImpl2 implements UserDao {
    @Override
    public void add() {
        System.out.println("UserDaoImpl2 add...");
    }
}

由于上述例子中，我们没有对@Repository配置相应的value，所以默认为首字母小写的类名

如果想使用 UserDaoImpl2 类，则

@Autowired
@Qualifier(value = "userDaoImpl2")
private UserDao userDao;

如果指定名称有误，即不存在名称为value对应的类，则会报NoSuchBeanDefinitionException异常，即找不到对应类

Exception in thread "main" org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'userService': Unsatisfied dependency expressed through field 'userDao'; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.vectorx.spring5.s11_annotation.dao.UserDao' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true), @org.springframework.beans.factory.annotation.Qualifier(value=userDaoImpl1)}
...
Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.vectorx.spring5.s11_annotation.dao.UserDao' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true), @org.springframework.beans.factory.annotation.Qualifier(value=userDaoImpl1)}

@Resource

• 根据类型注入

@Resource
private UserDao userDao;

• 根据名称注入

@Resource(name = "userDaoImpl")
private UserDao userDao;

需要注意的是@Resource注解所在包为javax.annotation即 Java 扩展包，所以 Spring 官方不建议使用该注解而推崇@Autowired和@Qualifier注解

@Value

上述注解都是对对象类型的属性进行注入，如果想要装配普通类型属性，如基本数据类型及其包装类等，则可以需要使用@Value注解

@Value(value = "vector")
private String name;
@Value(value = "100")
private Integer age;
@Value(value = "200.0d")
private Double length;
@Value(value = "true")
private boolean isOk;
@Value(value = "0,a,3,6,test")
private String[] arrs;

7.5、完全注解开发

• 1）创建配置类，替代 XML 配置文件

@Configuration
@ComponentScan(basePackages = "com.vectorx.spring5.s11_annotation")
public class SpringConfig {
}

• 2）编写测试类

ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userService", UserService.class);
userService.add();

与之前的不同点就是用AnnotationConfigApplicationContext代替了ClassPathXmlApplicationContext对象