在Spring项目启动时处理事情的几种实现方式

在实际项目开发中有些时候需要在Spring容器启动时做一些处理，比如缓存字典数据、自定义数据源配置类、自动注册定时任务等等，结合自己的经验总结以下几种实现方式：

1、使用 @PostConstruct 注解

被@PostConstruct修饰的方法会在Bean初始化完成之后调用。这时Bean的依赖注入也已经完成了，可以调用注入的bean。比如用于自定义一些数据源配置类，代码示例如下：

/**
 * 自定义数据源
 *
 * @author lyc
 * @date 2022/8/21
 */
@Component
public class TempDbSource {
    @Value("${lyc.datasource.url}")
    private String url;
    @Value("${lyc.datasource.type}")
    private String type;
    @Value("${lyc.datasource.driver-class-name}")
    private String driverClass;
    @Value("${lyc.datasource.username}")
    private String username;
    @Value("${lyc.datasource.password}")
    private String password;
    @Value("${lyc.datasource.pwd-public-key}")
    private String pwdPublicKey;

    private SqlSessionTemplate sqlSessionTemplate;

    @PostConstruct
    public void init() throws Exception {
        DruidDataSource slaveDataSource = new DruidDataSource();
        slaveDataSource.setUrl(url);
        slaveDataSource.setDbType(type);
        slaveDataSource.setFilters("config");
        slaveDataSource.setDriverClassName(driverClass);
        slaveDataSource.setUsername(username);
        slaveDataSource.setPassword(password);
        slaveDataSource.setConnectionProperties("config.decrypt=true;config.decrypt.key=" + pwdPublicKey);

        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        // 扫描相关mapper文件
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        Resource[] mapperLocations = ArrayUtil.addAll(resolver.getResources("classpath*:mapper/com/lyc/TempMapper.xml"));
        sqlSessionFactoryBean.setMapperLocations(mapperLocations);
        // 调用dataSource
        sqlSessionFactoryBean.setDataSource(slaveDataSource);
        // 映射实体类
        sqlSessionFactoryBean.setTypeAliasesPackage("com.lyc.entity");
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBean.getObject();
        sqlSessionTemplate = new SqlSessionTemplate(sqlSessionFactory);
    }

    public SqlSessionTemplate getSqlSessionTemplate() {
        return sqlSessionTemplate;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

2、实现 InitializingBean 接口

实现 Spring 的InitializingBean接口同样可以实现在 Bean 初始化完成之后执行相应逻辑的功能，实现InitializingBean接口，在afterPropertiesSet方法中处理，示例代码如下：

/**
 * 测试实现InitializingBean接口
 *
 * @author lyc
 * @date 2022/8/21
 */
@Slf4j
@Component
public class TestInitializingBean implements InitializingBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("TestInitializingBean...afterPropertiesSet");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3、实现SmartLifecycle接口

这是一个生命周期管理接口，包含多个接口方法。各接口说明及代码示例如下：

start()：bean 初始化完毕后，该方法会被执行。
stop()：容器关闭后，spring 容器发现当前对象实现了 SmartLifecycle，就调用 stop(Runnable)， 如果只是实现了 Lifecycle，就调用 stop()。
isRunning：当前状态，用来判你的断组件是否在运行。
getPhase：控制多个 SmartLifecycle 的回调顺序的，返回值越小越靠前执行 start() 方法，越靠后执行 stop() 方法。
isAutoStartup()：start 方法被执行前先看此方法返回值，返回 false 就不执行 start 方法了。
stop(Runnable)：容器关闭后，spring 容器发现当前对象实现了 SmartLifecycle，就调用 stop(Runnable)， 如果只是实现了 Lifecycle，就调用 stop()。

/**
 * 测试SmartLifecycle接口
 *
 * @author lyc
 * @date 2022/8/21
 */
@Slf4j
@Component
public class TestSmartLifecycle implements SmartLifecycle {

    private boolean isRunning = false;

    @Override
    public void start() {
    	//这里添加初始化具体处理逻辑
        log.info("TestSmartLifecycle...start...");
        isRunning = true;
    }

    @Override
    public void stop() {
        log.info("TestSmartLifecycle...stop...");
        isRunning = false;
    }

    @Override
    public boolean isRunning() {
        return isRunning;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

4、实现SmartInitializingSingleton接口

/**
 * 容器启动后创建JOB
 *
 * @author lyc
 * @date 2022/8/21
 */
@Slf4j
@Component
public class JobAutoCreate implements SmartInitializingSingleton {
    @Override
    public void afterSingletonsInstantiated() {
        //处理Job创建
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在Spring IOC这个阶段有getBean()，而实现了SmartInitializingSingleton接口的Bean，afterSingletonsInstantiated()在getBean之后也就是单实力Bean初始化完成之后会被调用。

5、监听 ApplicationListener 事件或使用@EventListener

在Spring里面有一套完整的事件处理机制，容器启动过程中各节点会有对应的事件，如果要在初始化时做一些事情，可以实现ApplicationListener接口接收相应的事件，实现onApplicationEvent方法，在容器将所有的 Bean 都初始化完成之后，就会执行该方法。示例代码如下：

/**
 * 测试监听容器启动刷新事件
 *
 * @author lyc
 * @date 2022/8/21
 */
@Slf4j
@Component
public class TestApplicationListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        log.info("TestApplicationListener....ContextRefreshedEvent...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

除了实现ApplicationListener接口还可以在方法上加@EventListener注解，效果一样，代码示例：

/**
 * 测试注解方式监听容器启动刷新事件
 *
 * @author lyc
 * @date 2022/8/21
 */
@Slf4j
@Component
public class TestApplicationListener2 {

    @EventListener
    public void onApplicationEvent(ContextRefreshedEvent event) {
        log.info("TestApplicationListener2....ContextRefreshedEvent...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6、SpringBoot中实现ApplicationRunner接口

而在SpringBoot项目中可以通过实现ApplicationRunner接口，实现run方法来实现初始化时处理特定逻辑，示例代码如下：

/**
 * 初始化时缓存字典数据
 * 
 * @author lyc
 * @date 2022/8/21
 */
@Slf4j
@Component
public class DictCache implements ApplicationRunner {
    @Autowired
    private DictService dictService;
    
    @Override
    public void run(ApplicationArguments args) {
    	//这里就可以具体实现查询字典，缓存数据操作
        dictService.cache();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

7、SpringBoot中实现CommandLineRunner接口

SpringBoot项目中还可以实现CommandLineRunner接口，效果是一样的，SpringBoot将在启动初始化完成之后调用实现了CommandLineRunner的接口的run方法，示例代码如下：

/**
 * 测试实现CommandLineRunner
 *
 * @author lyc
 * @date 2022/8/21
 */
@Slf4j
@Component
public class TestCommandLineRunner implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        log.info("TestCommandLineRunner...run");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15