第02篇_Spring基础应用

第01章_SpringIOC

第一节 SpringIOC简介

1. 什么是SpringIOC？

IOC(Inversion of Control，控制反转)是一种编程范式，指将程序的某些流程（如对象创建、方法调用等）交由外部容器来控制。

​x
1
// 正常流程：程序自己控制
2
AccountDao accountDao = new AccountDaoImpl(); // 直接创建对象
3

4
// 控制反转：由外部容器控制
5
AccountDao accountDao = BeanFactory.getBean("accountDao"); // 通过容器获取对象

SpringIOC是 IOC 的一种实现，通过容器来管理和控制应用程序中对象的生命周期和依赖关系，从而实现对象之间的解耦和灵活的配置。

• spring-context：提供国际化、事件传播、资源加载等功能的支持。

• spring-aop：提供面向切面编程、AspectJ等功能的支持，后文将会详细讲解。

• spring-beans：提供对 bean 的创建、配置和管理等功能的支持。

• spring-core：主要包括核心类和工具类等，此外，提供ASM、CGLIB等功能的支持。

• spring-expression：提供表达式语言 SpEL （Spring Expression Language）的支持。

注意：

1. Guice 是由 Google 开发的一个轻量级依赖注入框架，通过注解和简单的配置来实现依赖注入，也是 IOC 的一种实现。

2. SpringIOC入门案例

1) 导入IOC依赖

23
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依赖 -->
14
        <!-- 同时会引入spring-core、spring-beans、spring-aop、spring-expression -->
15
        <dependency>
16
            <groupId>org.springframework</groupId>
17
            <artifactId>spring-context</artifactId>
18
            <version>5.2.9.RELEASE</version>
19
        </dependency>
20
       
21
    </dependencies>
22
    
23
</project>

注意：

1. 如果使用 Spring 5 版本，需要保证JDK 1.8+和 Tomcat 8.5+；如果使用 Spring 6 版本，则需要 JDK17+。

2) 配置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>

3) 使用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
}

第二节 容器详解

1. 什么是容器？

容器用于管理和控制应用程序中对象的生命周期和依赖关系，顶层接口为ApplicationContext，常见实现类如下：

• ClassPathXmlApplicationContext：从类路径下加载配置文件，独立应用程序一般使用此种方式。

• AnnotationConfigApplicationContext：从Java代码加载配置注解，一般适用于基于Java配置的注解开发模式。

• FileSystemXmlApplicationContext：从磁盘位置加载配置文件，受限于操作系统，一般不常用。

注意：

1. ApplicationContext 继承 BeanFactory 接口，扩展了AOP、Web、国际化、事件传递等功能，并在启动时初始化所有单例Bean。

2. 容器的创建和关闭

1) 通过XML配置创建

加载XML配置文件，创建一个 Spring 的 IOC 容器：

2
1
// 创建容器
2
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");

XML配置文件示例如下：

23
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
    <!-- Bean配置 -->
8
    <bean id="bean1" class="com.example.Test01"/>
9
    <bean id="bean2" class="com.example.Test02"/>
10
    
11
    <!-- 引入根标签为beans的外部配置文件-->
12
    <import resource="services.xml"/>
13
    <import resource="resources/messageSource.xml"/>
14
    <import resource="/resources/themeSource.xml"/>
15
    
16
    <!-- 使用 * 作为通配符 (注意：必须保证父配置文件名不能满足 * 所能匹配的格式，否则将出现循环递归包含)-->
17
    <import resource="dao/spring-*-dao.xml"/>
18

19
    <!-- 引入外部属性配置文件-->
20
    <context:property-placeholder location="classpath:/com/acme/jdbc.properties"/>
21
    
22
</beans>
23

2) 通过注解配置创建

加载配置类上的注解创建容器：

9
1
// 创建容器
2
ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
3

4
// 配置类
5
@Configuration
6
@ComponentScan(basePackages = "org.example") // 扫描 org.example 包中的其它组件
7
@Import({ JdbcConfig.class }) // 导入其它类中的配置信息
8
@PropertySource("classpath:/com/${my.placeholder:default/path}/app.properties") // 引入外部属性配置文件
9
public class SpringConfiguration {}

注意：

1. 配置类必须带有 @Configuration 或 @Component 等注解。

3) 通过Java代码创建

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
}

4) 关闭容器

一般只会在程序退出时关闭容器，可以向 JVM 注册一个关闭钩子，让 Spring 在程序退出时调用 Bean 的生命周期相关方法。

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

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

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

注意：

1. 在 Web 环境中，基于 Web 的容器实现默认注册了关闭钩子，无需重复注册。

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

3. 容器的基本使用

1) 获取对象

可以通过T getBean(String name, Class<T> requiredType)等方法获取 Bean 的实例：

8
1
// 通过 key + 类型 获取
2
PetStoreService service = context.getBean("petStore", PetStoreService.class);
3

4
// 通过 key 获取（需要强转）
5
Person person = (Person)ctx.getBean("person");
6

7
// 通过 类型 获取（必须保证该类型只有一个Bean）
8
Person person = ctx.getBean(Person.class);

2) 获取容器信息

15
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.containsBean("userDao")
12
    
13
// 判断是否存在指定id的Bean(不能判断name指定的别名)
14
boolean isExist = ctx.containsBeanDefinition("userDao")
15

4. 容器的环境配置

1) 环境与策略

Environment接口用来表示整个应用运行时的环境，是当前Bean集合及相关属性在容器中的一个抽象。

Profile用于控制哪些 Bean 被注册，哪些 Bean 不被注册，只有处于活动状态的 Bean 才会被注册。

2) 配置环境(@Profile)

@Profile 注解可以作用于配置类或方法之上，表示只有对应的环境被激活时，被注解的Bean才会被注册到Spring容器。

26
1
// 开发环境需注册的Bean
2
@Configuration
3
@Profile("development")
4
public class StandaloneDataConfig {
5

6
    @Bean
7
    public DataSource dataSource() {
8
        return new EmbeddedDatabaseBuilder()
9
            .setType(EmbeddedDatabaseType.HSQL)
10
            .addScript("classpath:com/bank/config/sql/schema.sql")
11
            .addScript("classpath:com/bank/config/sql/test-data.sql")
12
            .build();
13
    }
14
}
15

16
// 生产环境需注册的Bean
17
@Configuration
18
@Profile("production")
19
public class JndiDataConfig {
20

21
    @Bean(destroyMethod="")
22
    public DataSource dataSource() throws Exception {
23
        Context ctx = new InitialContext();
24
        return (DataSource) ctx.lookup("java:comp/env/jdbc/datasource");
25
    }
26
}

22
1
@Configuration
2
public class AppConfig {
3

4
    // 开发环境需注册的Bean
5
    @Bean("dataSource")
6
    @Profile("development")
7
    public DataSource standaloneDataSource() {
8
        return new EmbeddedDatabaseBuilder()
9
            .setType(EmbeddedDatabaseType.HSQL)
10
            .addScript("classpath:com/bank/config/sql/schema.sql")
11
            .addScript("classpath:com/bank/config/sql/test-data.sql")
12
            .build();
13
    }
14

15
    // 生产环境需注册的Bean
16
    @Bean("dataSource")
17
    @Profile("production")
18
    public DataSource jndiDataSource() throws Exception {
19
        Context ctx = new InitialContext();
20
        return (DataSource) ctx.lookup("java:comp/env/jdbc/datasource");
21
    }
22
}

提示

1. 可以使用一些基本运算符来配置Bean的环境。如 production & (us-east | eu-central)。

2. 可以同时配置多个环境。如@Profile({"p1", "!p2"})表示在p1活动状态或p2未活动状态进行注册。

3. 如果 @Profile 注解作用于同名的@Bean方法(方法重载)之上，则它们之间的配置最好相同。

在XML配置中，可以使用 beans 标签的profile属性来配置Bean的环境，但可能会有一些限制。

11
1
<beans profile="development"
2
    xmlns="http://www.springframework.org/schema/beans"
3
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
5
    xsi:schemaLocation="...">
6

7
    <jdbc:embedded-database id="dataSource">
8
        <jdbc:script location="classpath:com/bank/config/sql/schema.sql"/>
9
        <jdbc:script location="classpath:com/bank/config/sql/test-data.sql"/>
10
    </jdbc:embedded-database>
11
</beans>

3) 激活环境

我们在启动容器时，可以指定激活的环境，最直接的方法是通过 Environment API 以编程方式进行配置。

4
1
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
2
ctx.getEnvironment().setActiveProfiles("profile1", "profile2");
3
ctx.register(SomeConfig.class, StandaloneDataConfig.class, JndiDataConfig.class);
4
ctx.refresh();

当然，也可以使用声明式的方式，通过系统环境变量、JVM系统属性等方式设置 spring.profiles.active 属性的值。

1
1
-Dspring.profiles.active="profile1,profile2"

在特定环境，如WEB开发中也可以设置 web.xml 中的 servlet 上下文参数，或测试环境中通过 @ActiveProfiles 注解来声明。

4) 默认环境

当spring.profiles.active没有被设置时，那么 Spring 会根据spring.profiles.default属性的值（默认为default）来激活环境，可以使用 setDefaultProfiles() 方法或 spring.profiles.default 属性来修改。

12
1
@Configuration
2
@Profile("default")
3
public class DefaultDataConfig {
4

5
    @Bean
6
    public DataSource dataSource() {
7
        return new EmbeddedDatabaseBuilder()
8
            .setType(EmbeddedDatabaseType.HSQL)
9
            .addScript("classpath:com/bank/config/sql/schema.sql")
10
            .build();
11
    }
12
}

5. 容器的事件处理

1) 事件处理简介

ApplicationContext 中的事件处理是通过ApplicationEvent类和ApplicationListener接口提供的，属于典型的观察者设计模式。

支持的标准事件如下：

下面是一个监听示例：

19
1
// 1. 实现ApplicationListener接口方式
2
@Component
3
public class ContextRefreshedEventListener implements ApplicationListener<ContextRefreshedEvent> {
4

5
    @Override
6
    public void onApplicationEvent(ContextRefreshedEvent event) {
7
        System.out.println("ContextRefreshedEvent received: " + event.getApplicationContext().getId());
8
    }
9
}
10

11
// 2. @EventListener注解方式
12
@Component
13
public class ContextRefreshedEventListener {
14

15
    @EventListener
16
    public void handleContextRefreshedEvent(ContextRefreshedEvent event) {
17
        System.out.println("ContextRefreshedEvent received: " + event.getApplicationContext().getId());
18
    }
19
}

@EventListener注解可以对接收的事件进行更加精细的控制，示例如下：

19
1
// 通过事件类型限定接收的事件
2
@EventListener({ContextStartedEvent.class, ContextRefreshedEvent.class})
3
public void handleContextStart() {
4
}
5

6
// 通过泛型限定接收的事件
7
@EventListener
8
public void onPersonCreated(EntityCreatedEvent<Person> event) {
9
}
10

11
// 通过SPEL表达式限定接收的事件
12
@EventListener(condition = "#blEvent.content == 'my-event'")
13
public void processBlackListEvent(BlackListEvent blEvent) {
14
}
15

16
// 事件传递：处理完当前事件后，通过返回值再发布新的事件（可以返回集合类型）
17
@EventListener
18
public ListUpdateEvent handleBlackListEvent(BlackListEvent event) {
19
}

注意：

1. 默认情况下，事件侦听器会同步接收事件，这意味着publishEvent()方法将阻塞，直到所有侦听器都已完成对事件的处理为止。

2. 这种同步和单线程方法的优点是：当侦听器收到事件时，如果有可用的事务上下文，它将在发布者的事务中进行操作。

2) 自定义事件

可以实现ApplicationEvent接口自定义事件：

12
1
// BlackListEvent事件
2
public class BlackListEvent extends ApplicationEvent {
3
    // 事件属性
4
    private final String address; // 邮箱地址
5
    private final String content; // 邮箱内容
6

7
    public BlackListEvent(Object source, String address, String content) {
8
        super(source);
9
        this.address = address;
10
        this.content = content;
11
    }
12
}

并通过ApplicationEventPublisher来发布：

24
1
// 邮箱服务
2
@Service
3
public class EmailService implements ApplicationEventPublisherAware {
4
    private List<String> blackList;
5
    private ApplicationEventPublisher publisher;
6

7
    public void setBlackList(List<String> blackList) {
8
        this.blackList = blackList;
9
    }
10

11
    // 通过感知接口获得ApplicationEventPublisher
12
    public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
13
        this.publisher = publisher;
14
    }
15

16
    // 业务方法
17
    public void sendEmail(String address, String content) {
18
        if (blackList.contains(address)) {
19
            // 发布BlackListEvent事件
20
            publisher.publishEvent(new BlackListEvent(this, address, content));
21
            return;
22
        }
23
    }
24
}

3) 监听器配置

异步监听

4
1
@EventListener
2
@Async // 异步监听
3
public void processBlackListEvent(BlackListEvent event) {
4
}

注意：

1. 如果事件监听器抛出Exception，则它不会传播到调用者。有关更多详细信息，请参见AsyncUncaughtExceptionHandler。

2. 此类事件侦听器无法发送答复。如果您需要发送另一个事件作为处理结果，请注入ApplicationEventPublisher以手动发送事件。

调用顺序

如果需要先调用一个侦听器，则可以将@Order注解添加到方法声明中，如以下示例所示：

4
1
@EventListener
2
@Order
3
public void processBlackListEvent(BlackListEvent event) {
4
}

6. 容器的扩展接口

1) BeanFactoryPostProcessor

BeanFactoryPostProcessor 可以在容器初始化阶段动态地调整 Bean 的配置信息，而无需修改原始的配置文件或注解。

5
1
@FunctionalInterface
2
public interface BeanFactoryPostProcessor {
3
    // 在 加载Bean定义之后，实际创建 Bean 实例之前 调用
4
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
5
}

注意：

1. 可以实现Ordered接口或使用@Order 注解来控制多个 BeanFactoryPostProcessor 实例的执行顺序。

2. AOP 等功能是基于 BeanFactoryPostProcessor 实现的，因此不能对 BeanFactoryPostProcessor 的实现类对象进行织入。

PropertyPlaceholderConfigurer

PropertyPlaceholderConfigurer用于解析配置文件中的占位符，并进行字符串替换操作。

15
1
<!-- 注册一个内置的BeanFactoryPostProcessor：PropertyPlaceholderConfigurer 
2
     locations：指定外部属性配置文件，一般为properties格式
3
     properties：指定一些键值对形式的属性值
4
     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}"/>

PropertyOverrideConfigurer

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

2) BeanPostProcessor

BeanPostProcessor 可以在创建 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"/>

3) Lifecycle/SmartLifecycle接口

在容器启动和关闭时，会检索所有实现了Lifecycle和SmartLifecycle接口的Bean，对其进行批量处理。

Lifecycle

25
1
@Component
2
public class MyLifecycleBean implements Lifecycle {
3
    private boolean running = false;
4

5
    // 在容器启动时，如果 isRunning==false，则执行
6
    @Override
7
    public void start() {
8
        System.out.println("Starting the bean...");
9
        running = true;
10
    }
11

12
    // 在容器关闭时，如果 isRunning==true，则执行
13
    @Override
14
    public void stop() {
15
        System.out.println("Stopping the bean...");
16
        running = false;
17
    }
18

19
    // 判断Bean是否正在运行
20
    @Override
21
    public boolean isRunning() {
22
        return running;
23
    }
24
}
25

SmartLifecycle

43
1
public class MySmartLifecycleBean implements SmartLifecycle {
2
    private boolean running = false;
3

4
    // 在容器启动时，如果 isRunning==false&&isAutoStartup==true，则执行
5
    @Override
6
    public void start() {
7
        System.out.println("Starting the bean...");
8
        running = true;
9
    }
10

11
    // 在容器关闭时，如果 isRunning==true，则执行
12
    @Override
13
    public void stop() {
14
        System.out.println("Stopping the bean...");
15
        running = false;
16
    }
17

18
    // 判断Bean是否正在运行
19
    @Override
20
    public boolean isRunning() {
21
        return running;
22
    }
23

24
    // 指定启动和停止的顺序
25
    @Override
26
    public int getPhase() {
27
        return 0; 
28
    }
29

30
    // 是否自动启动
31
    @Override
32
    public boolean isAutoStartup() {
33
        return true; 
34
    }
35

36
    // 提供停止后的回调方法
37
    @Override
38
    public void stop(Runnable callback) {
39
        stop();
40
        callback.run(); // 执行回调
41
    }
42
}
43

第三节 Bean详解

1. 什么是Bean？

Bean 是被 Spring 容器管理的 Java 对象，是实现 Spring IoC 和依赖注入的基础。

2. Bean的定义方式

1) 基于构造方法的定义

一般用于可以直接通过构造方法实例化并配置的对象：

8
1
<!-- 基于无参构造定义 -->
2
<bean id="accountService" class="org.example.service.impl.AccountServiceImpl"/>
3

4
<!-- 基于有参构造定义 -->
5
<bean id="exampleBean" class="com.example.ExampleBean">
6
    <constructor-arg value="参数字面值"/>
7
    <constructor-arg ref="被引用的其它Bean"/>
8
</bean>

2) 基于FactoryBean的定义

一般用于构建复杂对象，如DataSource、SqlSessionFactory等。首先需要一个FactoryBean，用来描述复杂对象的构建过程：

43
1
import org.springframework.beans.factory.FactoryBean;
2
import com.zaxxer.hikari.HikariDataSource;
3

4
// 用于创建数据源的FactoryBean
5
public class DataSourceFactoryBean implements FactoryBean<HikariDataSource> {
6
    // 属性配置
7
    private String jdbcUrl;
8
    private String username;
9
    private String password;
10
    private String driverClassName;
11

12
    // 传入属性
13
    public DataSourceFactoryBean(String jdbcUrl, String username, String password, String driverClassName) {
14
        this.jdbcUrl = jdbcUrl;
15
        this.username = username;
16
        this.password = password;
17
        this.driverClassName = driverClassName;
18
    }
19

20
    // 获取目标对象
21
    @Override
22
    public HikariDataSource getObject() throws Exception {
23
        HikariDataSource dataSource = new HikariDataSource();
24
        dataSource.setJdbcUrl(jdbcUrl);
25
        dataSource.setUsername(username);
26
        dataSource.setPassword(password);
27
        dataSource.setDriverClassName(driverClassName);
28
        return dataSource;
29
    }
30

31
    // 获取目标对象类型
32
    @Override
33
    public Class<?> getObjectType() {
34
        return HikariDataSource.class;
35
    }
36

37
    // 是否为单例Bean
38
    @Override
39
    public boolean isSingleton() {
40
        return true;
41
    }
42
}
43

然后，基于FactoryBean来定义复杂对象：

2
1
<!-- 基于FactoryBean定义复杂对象 -->
2
<bean id="dataSource" class="org.example.DataSourceFactoryBean"/>

当实例化复杂对象时，如果发现是FactoryBean类型，则会调用其getObject()方法创建复杂对象。

注意：

1. FactoryBean本质上是一个工厂类，如果需要获取FactoryBean本身，可以通过ctx.getBean("&dataSource")的方式获取。

3) 基于普通工厂类定义

一般用于第三方模块复杂对象的构建，基于未实现 FacotryBean 接口的普通工厂类：

静态工厂

静态工厂类如下：

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

通过工厂类的静态方法构建对象：

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

实例工厂

实例工厂类如下：

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

通过工厂类的实例方法构建对象：

10
1
<!-- 创建工厂类对象 -->
2
<bean id="instancFactory" class="org.example.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> 

3. Bean的生命周期

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

1) @PostConstruct/@PreDestroy注解

@PostConstruct 和 @PreDestroy 基于内置的CommonAnnotationBeanPostProcessor实现，在Bean的初始化前后调用相应方法。

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
}

注意：

1. 被@PostConstruct 和 @PreDestroy注解的方法不能是抽象方法，必须无参无返回值，建议使用public static修饰。

2) InitializingBean/DisposableBean接口

如果实现了InitializingBean或DisposableBean接口，则会在初始化和销毁时分别调用其相应方法。

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
}

3) init-method/destroy-method属性

使用init-method和destroy-method属性可以指定无参无返回值方法的名称作为初始化方法和销毁方法。

8
1
public class ExampleBean {
2
    // 初始化方法
3
    public void init() {
4
    }
5
    // 销毁方法
6
    public void cleanup() {
7
    }
8
}

2
1
<!-- 指定初始化方法和销毁方法 -->
2
<bean id="exampleInitBean" class="examples.ExampleBean" init-method="init" destroy-method="cleanup"/>

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

7
1
@Configuration
2
public class AppConfig {
3
    @Bean(initMethod = "init", destroyMethod = "cleanup")
4
    public ExampleBean bean01() {
5
        return new ExampleBean();
6
    }
7
}

注意：

1. <beans>标签的default-init-method/default-destroy-method属性可以指定所有Bean的默认初始化和销毁方法。

4) 执行顺序总结

如果一个 Bean 同时配置了多种方式的初始化和销毁方法，初始化和销毁都会按照注解->接口->属性的顺序执行：

• 调用 @PostConstruct 注解的初始化方法

• 调用 InitializingBean 接口定义的 afterPropertiesSet()方法

• 调用属性配置的初始化方法

• 调用 @PreDestroy 注解的销毁方法

• 调用 DisposableBean 接口定义的 destroy()方法

• 调用属性配置的销毁方法

注意：

1. 同一个初始化或销毁方法即使被多种方式配置，也只会被执行1次。

3. Bean的作用范围

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

1) singleton

singleton表示单例范围（默认），只会创建一次，一般在容器启动时创建，容器销毁时随之销毁，适合无状态的 Bean。

2
1
<!---定义单例Bean->
2
<bean id="accountDao" class="org.example.dao.impl.AccountDaoImpl" scope="singleton"/>

2) prototype

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

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

注意：

1. 对于原型Bean，Spring不会管理其完整的生命周期，不会调用已配置的生命周期销毁回调。