第03篇_Spring_Core

第00章_前言

Spring是Java EE编程领域的一个轻量级开源框架，最早由Rod Johnson在 2002 年提出并随后创建，是为了解决企业级编程开发中的复杂性，实现敏捷开发的应用型框架 。框架的构成如下图所示，核心的模块有控制反转容器、面向切面编程、Web开发支持等。

Spring与传统的EJB相比，具有下面一些优势。

• IOC支持：提供IOC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。

• AOP支持：使用面向切面编程可以十分方便的解决一些传统OOP非常棘手的问题。

• 事务支持：使用声明式事务方式灵活的进行事务的管理, 提高开发效率和质量。

• 拥抱开源：提供了各种优秀框架和第三方库的集成和封装，降低其使用难度。

• 轻量且高效：Spring的 jar 包非常小，且运行时占用资源少，运行效率高。

第01章_IOC容器

第一节 程序中的耦合

1. 程序中的耦合

程序中的耦合指的是代码之间的相互依赖关系。如下面一段代码，业务层需要调用持久层进行保存操作，此时业务层就对持久层产生了直接依赖，如果需要对持久层实现类进行替换，需要修改业务层代码，不符合开闭原则。

1
public class AccountServiceImpl implements AccountService {
2
    @Override
3
    public void saveAccount() {
4
        // 业务层在此处直接依赖了持久层的实现类
5
        AccountDao accountDao = new AccountDaoImpl(); 
6
        accountDao.saveAccount();
7
    }
8
}

2. 使用工厂模式来解决耦合

首先将持久层对象的创建交给一个工厂类来实现，那么依赖关系将由服务层->持久层转变为服务层->工厂类。然后在工厂类通过反射来创建我们所需的对象，并且可以将全类名放置在外部配置文件中，以此来解决代码中存在的直接依赖关系。

27
1
// 1. 定义一个通用工厂，从配置文件读取全类名，并通过反射创建对象
2
public class BeanFactory{
3
    private static Properties env = new Properties();
4
    
5
    // 加载配置文件中的类名信息：key = accountDao value = org.example.dao.impl.AccountDaoImpl
6
    static{
7
        try {
8
            InputStream inputStream = BeanFactory.class.getResourceAsStream("/beans.properties");
9
            env.load(inputStream);
10
            inputStream.close();
11
        } catch (IOException e) {
12
            e.printStackTrace();
13
        }
14
    }
15
    
16
    // 从通用工厂构造对象
17
    public static Object getBean(String key){
18
         Object ret = null;
19
         try {
20
             Class clazz = Class.forName(env.getProperty(key));
21
             ret = clazz.newInstance();
22
         } catch (Exception e) {
23
            e.printStackTrace();
24
         }
25
         return ret;
26
     }
27
}

8
1
// 2. 服务层通过 key 从工厂获取所需依赖
2
public class AccountServiceImpl implements AccountService {
3
    @Override
4
    public void saveAccount() {
5
        AccountDao accountDao = BeanFactory.getBean(“accountDao”);
6
        accountDao.saveAccount();
7
    }
8
}

现在对持久层实现类进行动态替换时，只需要修改外部配置文件就可以了，上述这种将业务层对持久层的依赖转移给工厂的解决思路，被称为控制反转(Inversion of Control)。

控制反转是一个概念，是一种思想，指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对象控制权的转移，从程序代码本身反转到了外部容器，通过容器实现对象的创建，属性赋值，依赖的管理。

3. 使用Spring解决程序耦合

程序中的耦合是一个普遍存在问题，我们没必要为每一个应用都重复的编写上述类似代码，业界已经提供了一个通用的，被大众所认可的优秀解决方案Spring，让我们来看看如何使用Spring来解决程序中的耦合问题。

导入Spring依赖

22
1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <modelVersion>4.0.0</modelVersion>
6

7
    <groupId>org.example</groupId>
8
    <artifactId>Spring-demo01</artifactId>
9
    <version>1.0-SNAPSHOT</version>
10

11
    <dependencies>
12
        
13
        <!-- 引入spring-context依赖，同时会引入spring-core、spring-beans、spring-aop、spring-expression-->
14
        <dependency>
15
            <groupId>org.springframework</groupId>
16
            <artifactId>spring-context</artifactId>
17
            <version>5.2.9.RELEASE</version>
18
        </dependency>
19
       
20
    </dependencies>
21
    
22
</project>

注意：一般我们会选择较新的Spring 5 版本，这需要你的JDK版本在1.8及以上，Tomcat版本在8.0及以上。

配置IOC容器

需要一个配置文件用来配置 key 和全类名的映射关系，这个文件名一般为application.xml，放在任意类路径下即可。

10
1
<?xml version="1.0" encoding="UTF-8"?>
2
<beans xmlns="http://www.springframework.org/schema/beans"
3
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
       xsi:schemaLocation="http://www.springframework.org/schema/beans
5
http://www.springframework.org/schema/beans/spring-beans.xsd">
6

7
    <!-- 配置accountDao -->
8
    <bean id="accountDao" class="org.example.dao.impl.AccountDaoImpl"/>
9
    
10
</beans>

使用IOC容器

在业务代码中通过容器来获取所需的依赖，而不是直接创建依赖对象。

10
1
public class AccountServiceImpl implements AccountService {
2
    @Override
3
    public void saveAccount() {
4
        // 通过Spring的IOC容器来获取accountDao实现类
5
        ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
6
        AccountDao accountDao = (AccountDao)ctx.getBean("accountDao");
7
        
8
        accountDao.saveAccount();
9
    }
10
}

第二节 IOC容器

1. ApplicationContext接口

ApplicationContext接口继承自 BeanFactory，代表 Spring 的 IOC 容器，容器读取配置元数据中的指令，进行对象的实例化、配置和组装。Spring为适应不同的场景，提供了多个实现类，常见的几种如下：

ApplicationContext和BeanFactory的区别

BeanFactory 提供了最基本的容器功能，而 ApplicationContext 是 BeanFactory 的完整超集，添加了更多的企业特定的功能。

• 面向切面编程(AOP)

• Web应用(WebApplicationContext)

• 国际化(MessageSource)

• 事件传递(Event publication)

特别的，BeanFactory 总是会懒初始化 Bean，而 ApplicationContext 默认情况下在容器启动时初始化所有的Singleton Bean。

2. 容器的创建

容器的创建需要提供配置元数据，这些元数据可以是XML、注解或Java代码的形式。

XML配置方式

2
1
// 加载services.xml和daos.xml中配置的元数据，创建一个Spring的IOC容器
2
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");

注解配置方式

2
1
// 加载 SpringConfiguration 配置的注解创建容器
2
ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);

SpringConfiguration 的代码如下，一般为一个配置类(@Configuration注解的类)。

7
1
// Spring 配置类
2
//    1. @ComponentScan：扫描 com.itheima.Spring 包中的 spring 组件
3
//    2. @Import：导入其它类中的配置信息
4
@Configuration
5
@ComponentScan(basePackages = "com.itheima.Spring")
6
@Import({ JdbcConfig.class })
7
public class SpringConfiguration {}

当然，也可以使用普通的组件类(@Component注解的类)或带有 JSR-330 元数据注解的类。

编程配置方式

16
1
public static void main(String[] args) {
2
    // 定义一个容器(无参方式)
3
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
4
    
5
    // 注册配置类
6
    ctx.register(AppConfig.class, OtherConfig.class);
7
    ctx.register(AdditionalConfig.class);
8
    
9
    // 扫描配置类并刷新容器
10
    ctx.scan("com.acme");
11
    ctx.refresh();
12
    
13
    // 使用容器
14
    MyService myService = ctx.getBean(MyService.class);
15
    myService.show();
16
}

3. 容器的关闭

在Web环境中，Spring 的基于 Web 的容器实现已经具有适当的代码，可以在相关 Web 应用程序关闭时正常关闭 Spring IoC 容器。在非 Web 应用程序环境中，请向 JVM 注册一个关闭钩子，这样Spring可以调用你单例 bean 上设置的 destroy 方法，以便释放所有资源。

13
1
import org.springframework.context.ConfigurableApplicationContext;
2
import org.springframework.context.support.ClassPathXmlApplicationContext;
3

4
public final class Boot {
5

6
    public static void main(final String[] args) throws Exception {
7
        // 创建容器
8
        ConfigurableApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
9

10
        // 注册关闭钩子
11
        ctx.registerShutdownHook(); 
12
    }
13
}

JVM的关闭钩子在什么场景下有效？

答：正常退出、System.exit()、Ctrl+C中断、OutofMemory宕机、Kill pid杀死进程(kill -9除外)、系统关闭等。

3. 容器的使用

容器创建完成后，我们就可以通过使用方法T getBean(String name, Class<T> requiredType)检索 bean 的实例。

2
1
// 通过key和类型检索Spring实例
2
PetStoreService service = context.getBean("petStore", PetStoreService.class);

除此之外，ApplicationContext接口还有其他几种检索 bean 的方法，但是理想情况下，您的应用程序代码永远不要使用它们。

5
1
// 通过key获取对象后，进行强制类型转换
2
Person person = (Person)ctx.getBean("person");
3

4
// 通过类型匹配获取对象(注意：此时只能有一个Bean是Person类型)
5
Person person = ctx.getBean(Person.class);

容器除了获取对象的方法外，还提供了一些辅助方法，用于获取容器的相关信息。

14
1
// 获取Bean总数
2
int count = ctx.getBeanDefinitionCount();
3

4
// 获取所有Bean的id
5
String[] beanDefinitionNames = ctx.getBeanDefinitionNames();
6

7
// 获取所有某类型Bean的id
8
String[] beanNamesForType = ctx.getBeanNamesForType(UserDao.class);
9

10
// 判断是否存在指定id的Bean(不能判断name指定的别名)
11
boolean isExist = ctx.containsBeanDefinition("userDao")
12
 
13
// 判断是否存在指定id的Bean(可以判断name指定的别名)
14
boolean isExist = ctx.containsBean("userDao")

4. 容器的扩展

BeanPostProcessor

BeanPostProcessor 接口可以在 Bean 的初始化生命周期前后植入一些自定义逻辑，对创建的 Bean 进行二次加工。

28
1
// 1. 创建一个 BeanPostProcessor
2
public class MyBeanPostProcessor implements BeanPostProcessor {
3
    
4
    /**
5
    * 在Bean完成实例化和注入之后、初始化之前执行
6
    *
7
    * @bean         已完成注入后的Bean对象
8
    * @beanName     bean的id属性
9
    * @return       修改后的Bean对象
10
    */
11
    @Override
12
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
13
        return bean;
14
    }
15

16
    /**
17
    * 在Bean完成初始化之后执行
18
    *
19
    * @bean         已完成初始化后的Bean对象
20
    * @beanName     bean的id属性
21
    * @return       修改后的Bean对象
22
    */
23
    @Override
24
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
25
        System.out.println("Bean '" + beanName + "' created : " + bean.toString());
26
        return categroy;
27
    }
28
}

2
1
<!-- 2. 将自定义BeanPostProcessor注册到Spring容器-->
2
<bean id="myBeanPostProcessor" class="xxx.MyBeanPostProcessor"/>

BeanFactoryPostProcessor

BeanFactoryPostProcessor 接口用于读取配置元数据，并在Bean的实例化之前对其进行修改。Spring定义了一些内置的Bean工厂后处理器，如PropertyPlaceholderConfigurer用于解析配置文件中的占位符，并进行字符串替换操作。

15
1
<!-- 注册一个内置的BeanFactoryPostProcessor：PropertyPlaceholderConfigurer 
2
    1. locations：指定外部属性配置文件，一般为properties格式
3
    2. properties：指定一些键值对形式的属性值
4
    3. systemPropertiesMode：是否检查System属性
5
        * never                 从不查找System属性
6
        * fallback              如果从properties-ref和location中未找到需要的属性值，则去System属性查找
7
        * override/evironment   始终查找System属性，并覆盖其他方式配置的值
8
-->
9
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
10
    <property name="locations" value="classpath:com/something/strategy.properties"></property>
11
    <property name="properties" value="custom.strategy.class=com.something.DefaultStrategy"></property>
12
</bean>
13

14
<!-- 使用占位符来获取配置的属性值，这将会在Bean实例化之前进行替换-->
15
<bean id="serviceStrategy" class="${custom.strategy.class}"/>

除此之外，与属性相关的Bean工厂后处理器还有 PropertyOverrideConfigurer，用于对配置的属性进行覆盖操作。

4
1
<!-- 注册一个内置的BeanFactoryPostProcessor：PropertyOverrideConfigurer 
2
    location：指定一个外部配置文件，存放需要覆盖的属性和值，以 beanName.property=value 的格式，并支持复合属性
3
--> 
4
<context:property-override location="classpath:override.properties"/>

一个 override.properties 配置文件的示例如下。

4
1
# 覆盖 dataSource 的 driverClassName 属性值为 com.mysql.jdbc.Driver
2
dataSource.driverClassName=com.mysql.jdbc.Driver
3
# 覆盖 tom 的 fred.bob.sammy 属性值为 123
4
tom.fred.bob.sammy=123

Ban(Factory)PostProcessor 的一些处理细节

1. Bean(Factory)PostProcessor 是容器范围的，对该容器内的所有 Bean 都生效。

2. Bean(Factory)PostProcessor 会尽早被实例化，即使你为它们配置了懒加载属性，容器也会忽略。

3. 你定义了多个 Bean(Factory)PostProcessor，可以通过实现Ordered接口并使用order属性来控制它们的执行顺序。

4. 如果你使用@Bean来创建Bean(Factory)PostProcessor，则必须保证返回类型是该接口的实现类，否则容器无法正确检测。

5. AOP 中一些基础结构类是基于BeanPostProcessor来实现的，因此该接口的实现类和依赖其的Bean都不适合自动代理。

6. BeanFactoryPostProcessor 不能对实现了BeanFactoryPostProcessor接口的Bean定义进行修改。

7. 虽然可以通过BeanFactory.getBean()来提早实例化Bean，但这是不被推荐的，因为可以会绕过 bean 的后处理。

5. 多文件配置

引入外部配置文件

你也可以将所有元数据写在同一个配置文件中，或者通过<import/>标签引入其它文件中的元数据配置。

13
1
<beans>
2
    <!-- 引入根标签为beans的外部配置文件-->
3
    <import resource="services.xml"/>
4
    <import resource="resources/messageSource.xml"/>
5
    <import resource="/resources/themeSource.xml"/>
6
    
7
    <!-- 使用 * 作为通配符 (注意：必须保证父配置文件名不能满足 * 所能匹配的格式，否则将出现循环递归包含)-->
8
    <import resource="dao/spring-*-dao.xml"/>
9

10

11
    <bean id="bean1" class="..."/>
12
    <bean id="bean2" class="..."/>
13
</beans>

引入外部属性文件

对于一些需要经常修改的内容，如Jdbc连接信息等，可以单独放在一个小配置文件中，方便维护。

15
1
<!--引入外部属性文件方式一：使用PropertyPlaceholderConfigurer -->
2
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
3
    <property name="db-connection" value="db.properties"></property>
4
</bean>
5

6
<!-- 引入外部属性文件方法二: 要引入context命名空间-->
7
<!-- <context:property-placeholder location="classpath:db.properties"/>-->
8

9
<!--配置连接池-->
10
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
11
    <property name="driverClassName" value="${db.driverclass}"></property>
12
    <property name="url" value="${db.url}"></property>
13
    <property name="username" value="${db.username}"></property>
14
    <property name="password" value="${db.password}"></property>
15
</bean>

db.properties文件示例如下：

4
1
db.driverclass=com.mysql.jdbc.Driver
2
db.url=jdbc:mysql://localhost:3306/userDb?characterEncoding=utf-8
3
db.username=root
4
db.password=root

第三节 Bean详解

1. Bean的实例化

构造方法创建

Spring配置文件的顶层标签为beans，可以配置多个<bean>标签，一个简单的bean配置示例如下：

1
1
<bean id="accountService" class="org.example.service.impl.AccountServiceImpl"/>

其中id属性是全局的唯一标识，用于从容器中获取对象。class属性则是对应的全限定类名，默认情况下，使用反射调用类中的无参构造函数来创建对象，如果缺少无参构造则无法创建。

FactoryBean创建

随着业务的复杂性提升，某些复杂对象的创建不能直接通过new关键字来实现，如Connect、SqlSessionFactory等，为此Spring提供了实现FactoryBean接口的方式来完成复杂对象的配置，首先实现FactoryBean接口，示例如下。

然后在配置文件中引用FactoryBean实现类来创建所需要的对象，配置如下：

1
1
<bean id="conn" class="com.baizhiedu.factorybean.ConnectionFactoryBean"/>

值得注意的是，这和简单对象的配置很相似，但实际上，Spring会检测class属性配置的类，如果是FactoryBean接口的实现类，那么通过id值获得的是这个类所创建的复杂对象(如：Connection）。

提示：就想获得FactoryBean类型的对象，可以通过ctx.getBean("&conn")的方式获取，得到的就是ConnectionFactoryBean对象。

普通工厂类来创建

虽然上述方式解决了复杂对象创建的问题，但使用的工厂类必须实现FacotryBean接口，为了整合一些遗留系统，Spring还可以使用普通的工厂类来创建所需的对象。

• 工厂方法为静态方法

这种方式也是在class属性指定使用的工厂类，但需要通过factory-method属性额外指定创建对象的静态方法，示例如下：

6
1
public class StaticFactory {
2
    // 创建对象的静态方法
3
    public static IAccountService createAccountService() {
4
        return new AccountServiceImpl();
5
    }
6
}

2
1
<bean id="accountService" class="com.itheima.factory.StaticFactory"   
2
      factory-method="createAccountService"></bean>  

• 工厂方法为非静态方法

如果factory-method是非静态方法，那么将class属性留空，使用factory-bean属性引用工厂类对象，示例如下：

6
1
public class InstanceFactory {
2
    // 创建对象的非静态方法
3
    public IAccountService createAccountService(){  
4
        return new AccountServiceImpl();  
5
    }  
6
}  

11
1
<!-- 创建工厂类对象 -->
2
<bean id="instancFactory" class="com.itheima.factory.InstanceFactory"></bean>  
3

4
<!-- 创建业务对象
5
        * factory-bean 属性:用于指定工厂类bean的id
6
        * factory-method 属性:用于指定实例工厂中创建对象的方法
7
-->
8
 <bean id="accountService"   
9
       factory-bean="instancFactory"   
10
       factory-method="createAccountService"></bean> 
11

2. Bean的生命周期

生命周期指Bean从创建到销毁的整个过程，Spring提供了一些机制允许我们对bean生命周期的管理进行干预。

@PostConstruct /@PreDestroy注解

@PostConstruct 和 @PreDestroy 是 JSR-250 的生命周期注解，Spring 在 CommonAnnotationBeanPostProcessor 中对其做了实现。在 Bean 的初始化期间会调用被@PostConstruct注解的方法，在销毁期间会调用被@PreDestroy注解的方法。

12
1
public class CachingMovieLister {
2

3
    @PostConstruct
4
    public void populateMovieCache() {
5
        // populates the movie cache upon initialization...
6
    }
7

8
    @PreDestroy
9
    public void clearMovieCache() {
10
        // clears the movie cache upon destruction...
11
    }
12
}

InitializingBean/DisposableBean接口

如果bean实现了InitializingBean接口，容器会在创建bean的时候调用其afterPropertiesSet()方法，如果实现了DisposableBean接口，容器在销毁bean的时候调用其destroy()方法。

1
1
<bean id="exampleInitBean" class="examples.AnotherExampleBean"/>

10
1
public class AnotherExampleBean implements InitializingBean, DisposableBean {
2

3
    public void afterPropertiesSet() {
4
        // do some initialization work
5
    }
6

7
    public void destroy() {
8
        // do some destruction work (like releasing pooled connections)
9
    }
10
}

init-method/destroy-method属性

对于基于 XML 的配置元数据，可以使用init-method/destroy-method属性指定无参无返回值方法的名称作为初始化方法和销毁方法。

2
1
<bean id="exampleInitBean" class="examples.ExampleBean" init-method="init" destroy-method="cleanup"/>
2

11
1
public class ExampleBean {
2

3
    public void init() {
4
        // do some initialization work
5
    }
6

7
    public void cleanup() {
8
        // do some destruction work (like releasing pooled connections)
9
    }
10
}
11

为了简化配置，你可以使用<beans>标签的default-init-method/default-destroy-method属性来为所有子标签中的bean指定默认初始化和销毁方法。但必须注意，Spring 容器保证在为 bean 提供所有依赖项后立即调用配置的初始化回调，因此，在原始 bean 引用上调用了初始化回调，这意味着 AOP 拦截器等尚未应用于 bean。

提示：使用Java代码配置元数据时，使用@Bean的initMethod和destroyMethod属性来指定初始化和销毁方法。

Bean启动和停止事件回调

可以通过实现Lifecycle接口来定义 Bean 的启动和停止事件回调，当容器本身接收到启动和停止 signal 时(例如，对于运行时的停止/重新启动场景)，它将把这些调用级联到在该上下文中定义的所有Lifecycle实现。

25
1
// 实现了Lifecycle接口的Bean
2
@Component
3
public class MyLifeCycleBean1 implements Lifecycle {
4
    private boolean status = true;
5

6
    // 容器start的时候，如果 isRunning==false，则执行该方法
7
    @Override
8
    public void start() {
9
        System.out.println("start");
10
    }
11
    
12
    // 判断Bean是否正在运行
13
    @Override
14
    public boolean isRunning() {
15
        System.out.println("isRunning");
16
        status = !status;
17
        return status;
18
    }
19
    
20
    // 容器stop的时候，如果 isRunning==true，则执行该方法
21
    @Override
22
    public void stop() {
23
        System.out.println("stop");
24
    }
25
}

14
1
public class SpringTest {
2
    public static void main(String[] args) {
3
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MyLifeCycleBean1.class);
4
        ctx.registerShutdownHook();
5
        ctx.start();
6
        //ctx.stop(); // 注册关闭钩子后会在容器关闭时调用该方法
7
    }
8
}
9
/*
10
isRunning
11
start
12
isRunning
13
stop
14
 */

如果想对 start 和 stop 生命周期进行更精细的控制，可以实现SmartLifecycle接口。如通过isAutoStartup方法返回 true 可以实现容器创建后自动启动；通过getPhase()方法返回合适的相位值来控制启动和停止的顺序，该值越大，则越晚执行，越早销毁，默认值为Integer.MAX_VALUE(如果实现的是LifeCycle接口，则默认为0)，详细用法请参考Spring官方文档。

不同生命周期机制的执行顺序

如果为一个 bean 配置了多个生命周期机制，当方法名称相同时，该方法将只执行一次。如果方法名称不一致，那么将按照注解配置优先，接口配置次之，XML配置最后执行的原则调用生命周期方法。

1）用 @PostConstruct 注解的方法

2）InitializingBean 回调接口定义的 afterPropertiesSet()方法

3）自定义配置的 init() 方法

4）用 @PreDestroy 注解的方法

5）DisposableBean 回调接口定义的 destroy()方法

6）自定义配置的 destroy() 方法

3. Bean的作用范围

Bean的作用范围决定了Bean的作用域以及在获取对象时是否创建新的实例等，通过scope属性进行配置。

singleton

默认配置的作用范围为singleton，表示单例范围，只创建一次，一般在容器启动时创建，容器销毁时随之销毁。

1
1
<bean id="accountDao" class="org.example.dao.impl.AccountDaoImpl" scope="singleton"/>

prototype

prototype表示原型范围(多例)，在每次从容器获取对象时，始终会创建新的实例返回。

1
1
<bean id="accountDao" class="org.example.dao.impl.AccountDaoImpl" scope="prototype"/>

与其它作用范围不同的是，Spring不管理原型Bean的完整生命周期，不会调用已配置的生命周期销毁回调。

注意：关于单例bean中注入原型bean的一些细节

• 在单例Bean中依赖原型Bean时，由于单例Bean只会被IoC容器初始化一次，其依赖也只会被处理一次，因此其依赖的原型Bean也将“隐式”的成为单例。

• 如何解决这个问题，有两种办法，一种是在使用原型Bean时每次都依赖查找，这样IoC容器会每次都重新创建原型Bean；

• 另一种办法就是使用@Lookup注解来解决，这种是官方给出解决方案，需注意的是使用@Lookup注解的方法必须声明为抽象方法。

适用于web的作用范围

在Web应用中，提供了一些特殊的bean作用范围，如request、session、application、websocket等，分别与HTTP中的Request、Session、ServletContext、WebSocket作用域一致，这里不做详细讲解，具体可参考Spring的官方文档。

自定义作用范围

Bean 作用域机制是可扩展的，您可以定义自己的范围，甚至重新定义一些内置范围(singleton和prototype除外)。要将自定义范围集成到 Spring 容器中，您需要实现Scope接口。Scope接口有四种方法可以从范围中获取对象，从范围中删除对象，然后销毁它们。

11
1
// 从基础范围返回对象，如果找不到该对象，则创建新实例返回
2
Object get(String name, ObjectFactory objectFactory)
3

4
// 从基础范围中删除该对象并返回删除的值，如果找不到该对象则返回null
5
Object remove(String name)
6
    
7
// 注册在销毁作用域或销毁作用域中的指定对象时作用域应执行的回调
8
void registerDestructionCallback(String name, Runnable destructionCallback)
9
    
10
// 获取基础范围的会话标识符，每个范围的标识符都不相同。对于会话范围的实现，此标识符可以是会话标识符。
11
String getConversationId()

在编写自定义Scope实现之后，您需要使 Spring 容器意识到您的新作用域。通过以下方法在 Spring 容器中注册新的Scope。

2
1
Scope threadScope = new SimpleThreadScope();
2
beanFactory.registerScope("thread", threadScope);

除了使用程序进行Scope的注册外，您还可以通过使用CustomScopeConfigurer类以声明方式进行Scope注册，如以下示例所示：

15
1
......
2

3
    <bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">
4
        <property name="scopes">
5
            <map>
6
                <entry key="thread">
7
                    <bean class="org.springframework.context.support.SimpleThreadScope"/>
8
                </entry>
9
            </map>
10
        </property>
11
    </bean>
12

13
    <bean id="thing2" class="x.y.Thing2" scope="thread"/>
14

15
......

从 Spring 3.0 开始，线程作用域可用，但默认情况下未注册。有关更多信息，请参见SimpleThreadScope的文档。

4. Bean的感知接口

感知接口(Aware)表示 Bean 向容器声明它们需要某种基础结构依赖性。这些接口回调在填充常规 bean 属性之后，但在初始化回调(例如InitializingBean，afterPropertiesSet或自定义 init-method)之前调用。

ApplicationContextAware

当 ApplicationContext 在创建实现ApplicationContextAware接口的对象实例时，该实例将获得对该ApplicationContext的引用。

4
1
// ApplicationContextAware接口定义
2
public interface ApplicationContextAware {
3
    void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
4
}

BeanNameAware

当 ApplicationContext 在创建实现BeanNameAware接口的类时，该类将获得对在其关联的对象定义中定义的名称的引用。

4
1
// BeanNameAware接口定义
2
public interface BeanNameAware {
3
    void setBeanName(String name) throws BeansException;
4
}

其它感知接口

注意：使用这些接口会将您的代码与 Spring API 绑定在一起，并且不遵循“控制反转”样式。因此，我们建议将它们用于需要以编程方式访问容器的基础结构 Bean。

5. Bean的自动装配

Spring 容器可以自动装配协作 Bean 之间的关系，即在创建对象后，自动从容器中查找所需的依赖并进行注入。这可以大大减少指定属性或构造函数参数的需要，并且当类中新增依赖项时，无需修改配置即可自动满足该依赖项。

自动装配的模式共有四种，通过bean标签的autowire属性来指定。

15
1
<!-- byName 自动注入 -->
2
<bean id="myStudent" class="com.bjpowernode.ba04.Student" autowire="byName">
3
    <property name="name" value="李四"/>
4
    <property name="age" value="22" />
5
    <!--引用类型的赋值-->
6
    <!--<property name="school" ref="mySchool" />-->
7
</bean>
8

9
<!-- byType 自动注入 -->
10
<bean id="myStudent" class="com.bjpowernode.ba05.Student" autowire="byType">
11
    <property name="name" value="张三"/>
12
    <property name="age" value="26" />
13
    <!--引用类型的赋值-->
14
    <!--<property name="school" ref="mySchool" />-->
15
</bean>

如果使用ByType自动装配匹配到了多个Bean，则可以设置某些Bean的 autowire-candidate属性为false，从候选列表去除。或者也可以通过设置某个Bean的primary属性为true，将其作为主要候选对象。上面两种配置仅对按类型自动装配(byType/Constructor)有效，按名称自动装配(byName)不受其影响。

6. Bean定义继承

在Bean的配置中，可以通过parent属性来指定另一个Bean作为该Bean的 ParentBean， 从而继承一些可复用的配置数据，并可以覆盖某些值或根据需要添加其他值，这是一种模板方法模式的一种体现。

12
1
<!-- ParentBean的定义。一般将 ParentBean 标记为 abstract，用作纯模板 Bean 使用，同时可以省略 class 属性 -->
2
<bean id="inheritedTestBean" abstract="true" >
3
    <property name="name" value="parent"/>
4
    <property name="age" value="1"/>
5
</bean>
6

7
<!-- ChildBean的定义-->
8
<bean id="inheritsWithDifferentClass" class="org.springframework.beans.DerivedTestBean" init-method="initialize"
9
      parent="inheritedTestBean"> 
10
    <property name="name" value="override"/>
11
    <!-- 将从 ParentBean 继承 age 属性的注入 -->
12
</bean>

ChildBean 可以从 ParentBean 继承Bean的作用范围、生命周期、属性注入等信息，但依赖项、自动装配模式等一些信息始终从子类获取，这需要我们在开发过程中多加关注。

注意：

1. Spring的继承是对象层面的继承，子类继承父类对象的属性值。因此，Spring 中，不同类之间可以互相继承。

2. Java是类层面的继承，继承的是父类的类结构信息。如果用 Java 代码的方式来配置元数据，那么可以直接使用 java 的继承机制来复用元数据的配置信息。

7. Bean其它属性

别名(name/alias)

Bean除了具有唯一性的 id 属性外，还可以定义若干个别名，以兼容不同的业务系统，通常使用name属性或<alias>标签来实现。

6
1
<!-- 配置service，并指定别名，别名以逗号、分号或空格间隔-->
2
<bean id="accountService" name="accountService2,accountService3" class="org.example.service.impl.AccountServiceImpl"/>
3

4
<!--使用alias标签定义别名-->
5
<alias name="accountService2" alias="accountServiceA"/>
6

初始化顺序(depends-on)

depends-on属性可以指定初始化时间依赖性，也可以在Bean是单例的的情况下指定相应的销毁时间依赖性。

9
1
<bean id="manager" class="ManagerBean" />
2
<bean id="accountDao" class="x.y.jdbc.JdbcAccountDao" />
3

4
<!--
5
    depends-on：在初始化beanOne之前强制先初始化manager和accountDao，在销毁时先销毁manager和accountDao，再销毁beanOne。
6
-->
7
<bean id="beanOne" class="ExampleBean" depends-on="manager,accountDao">
8
    <property name="manager" ref="manager" />
9
</bean>

懒加载(lazy-init)

单例Bean默认在容器创建时进行实例化，如果想让Bean在使用时再创建，则可指定lazy-init属性为true。

2
1
<!-- 配置 ExpensiveToCreateBean 延迟加载 -->
2
<bean id="lazy" class="com.something.ExpensiveToCreateBean" lazy-init="true"/>

如果需要对多个Bean进行配置，也可以选择beans标签的default-lazy-init属性，为其内部的所有Bean设置可覆盖的默认值。

3
1
<beans default-lazy-init="true">
2
    <!-- no beans will be pre-instantiated... -->
3
</beans>

提示：如果你使用注解配置，可以使用 @Lazy 注解来实现懒加载，并且该注解可以放置在标有@Autowired或@Inject的注入点上。在这种情况下，它导致注入了惰性解析代理。

第四节 依赖注入配置

依赖注入 (Dependency Inject)是控制反转思想的一种实现方式，指的是程序运行过程中，若需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部容器，由外部容器创建后传递给程序。

1. 构造函数注入

基于构造函数的注入是通过容器调用有参构造函数来完成的，每个参数代表了一个依赖项。

11
1
<!--构造注入，使用name属性
2
    1. name：指定构造函数参数名称。(在进行set注入时可以使用复合属性名，如student.birthday.year)
3
    2. value：用于注入基本属性值和String
4
    3. ref：用于注入引用类型
5
    4. 集合、空值、内联Bean的注入应使用子标签来完成
6
-->
7
<bean id="myStudent" class="com.bjpowernode.ba03.Student">
8
    <constructor-arg name="myage" value="22" />
9
    <constructor-arg name="myname" value="李四"/>
10
    <constructor-arg name="mySchool" ref="mySchool"/>
11
</bean>

对于极少数情况下无法使用构造函数自变量名称的情况(通常，如果字节码是在没有调试信息的情况下编译的)，可以通过参数索引进行构造函数的匹配，并且允许在能够推断的情况下省略索引属性。

13
1
<!--构造注入，使用index，参数的位置，构造方法参数从左往右位置是0,1,2-->
2
<bean id="myStudent2" class="com.bjpowernode.ba03.Student">
3
    <constructor-arg index="1" value="28"/>
4
    <constructor-arg index="0" value="张三"/>
5
    <constructor-arg index="2" ref="mySchool" />
6
</bean>
7

8
<!--构造注入，省略index属性-->
9
<bean id="myStudent3" class="com.bjpowernode.ba03.Student">
10
    <constructor-arg  value="张峰"/>
11
    <constructor-arg  value="28"/>
12
    <constructor-arg  ref="mySchool" />
13
</bean>

还可以使用更为简洁的语法来进行构造函数的注入配置，但这最好是在创建 bean 定义时使用支持自动属性完成的 IDE，否则错字是在运行时而不是设计时发现的。

18
1
<beans xmlns="http://www.springframework.org/schema/beans"
2
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3
    xmlns:c="http://www.springframework.org/schema/c"
4
    xsi:schemaLocation="http://www.springframework.org/schema/beans
5
        http://www.springframework.org/schema/beans/spring-beans.xsd">
6

7
    <bean id="thingOne" class="x.y.ThingTwo"/>
8
    <bean id="thingTwo" class="x.y.ThingThree"/>
9

10
    <!-- 使用c名称空间简化构造注入的书写方式 
11
            1. 基本类型使用 c:属性名="属性值"
12
            2. 引用类型使用 c:属性名_ref="属性值"
13
    -->
14
    <bean id="thingOne" class="x.y.ThingOne" 
15
          c:thingTwo-ref="thingTwo" 
16
          c:thingThree-ref="thingThree" 
17
          c:email="[emailprotected]"/>
18
</beans>

提示：使用工厂创建Bean对象时，可以通过constructor-arg标签进行工厂方法的参数注入，使用方式同构造函数注入一致。

2. Set方法注入

基于Set方法的注入是在对象创建完成后，调用对象的set方法来进行属性注入。

8
1
<bean id="now" class="java.util.Date"></bean> 
2

3
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
4
    <property name="name" value="test"></property>
5
    <property name="age" value="21"></property>
6
    <property name="birthday" ref="now"></property>
7
</bean>
8

类似的，可以使用p名称空间来进行简化书写。

13
1
<beans xmlns="http://www.Springframework.org/schema/beans"
2
    xmlns:p="http://www.Springframework.org/schema/p"
3
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.Springframework.org/schema/beans        
4
                    http://www.Springframework.org/schema/beans/Spring-beans.xsd">
5

6
    <bean id="now" class="java.util.Date"></bean> 
7
    
8
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl4" 
9
          p:name="test" 
10
          p:age="21" 
11
          p:birthday-ref="now"/>
12
</beans> 
13

3. 注入集合属性

顾名思义，就是给类中的集合成员进行属性注入，用的也是set方法注入的方式，只不过变量的数据类型都是集合。

47
1
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
2
    <!-- 给数组注入数据 -->
3
    <property name="myStrs">
4
        <set>
5
            <value>AAA</value>
6
            <value>BBB</value>
7
            <value>CCC</value>
8
        </set>
9
    </property>
10

11
    <!-- 注入list 集合数据 -->
12
    <property name="myList">
13
        <array>
14
            <value>AAA</value>
15
            <value>BBB</value>
16
            <value>CCC</value>
17
        </array>
18
    </property>
19

20
    <!-- 注入set 集合数据 -->
21
    <property name="mySet">
22
        <list>
23
            <value>AAA</value>
24
            <value>BBB</value>
25
            <value>CCC</value>
26
        </list>
27
    </property>
28

29
    <!-- 注入Map 数据 -->
30
    <property name="myMap">
31
        <props>
32
            <prop key="testA">aaa</prop>
33
            <prop key="testB">bbb</prop>
34
        </props>
35
    </property>
36

37
    <!-- 注入properties 数据 -->
38
    <property name="myProps">
39
        <map>
40
            <entry key="testA" value="aaa"></entry>
41
            <entry key="testB">
42
                <value>bbb</value>
43
            </entry>
44
        </map>
45
    </property>
46
</bean> 
47

提示：集合数据分两种，单列集合(array,list,set)和双列集合(map,entry,props,prop)，同类型集合注入方式可以兼容。

如果Bean存在继承关系，则可以通过merge属性来合并父类的集合。

23
1
<!-- 定义一个ParentBean，并给adminEmails集合进行注入 -->
2
<beans>
3
    <bean id="parent" abstract="true" class="example.ComplexObject">
4
        <property name="adminEmails">
5
            <props>
6
                <prop key="administrator">[emailprotected]</prop>
7
                <prop key="support">[emailprotected]</prop>
8
            </props>
9
        </property>
10
    </bean>
11

12
<!-- 定义一个ChildBean，同样给adminEmails集合进行注入 
13
    1. merge：继承父类集合中的属性，并进行选择性覆盖
14
-->
15
    <bean id="child" parent="parent">
16
        <property name="adminEmails">
17
            <props merge="true">
18
                <prop key="sales">[emailprotected]</prop>
19
                <prop key="support">[emailprotected]</prop>
20
            </props>
21
        </property>
22
    </bean>
23
<beans>

4. 注入原型Bean

如果某个Bean是单例的，并且依赖了原型Bean，则该原型Bean不能使用上述方式直接注入，必须在每次使用时都创建新的实例。

实现感知接口方式

通过实现感知接口ApplicationContextAware或BeanFactoryAware获取容器的引用，进而调用getBean方法创建原型Bean。

20
1
public class SingleBeanDemo implements BeanFactoryAware {
2
    private BeanFactory beanFactory;
3

4
    // 实现感知接口的抽象方法，在创建Bean的时候回调，注入容器的引用
5
    @Override
6
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
7
        this.beanFactory = beanFactory;
8
    }
9
    
10
    // 从容器获取原型Bean实例
11
    protected PrototypeBeanDemo getPrototypeBeanDemo(){
12
        this.beanFactory.getBean("prototypeBeanDemo", PrototypeBeanDemo.class)();
13
    }
14
    
15
    // 在业务方法中使用原型Bean
16
    public void bizMethod() {
17
        PrototypeBeanDemo prototypeBeanDemo = getPrototypeBeanDemo();
18
    }
19
}
20