Spring中几个重要的接口应用

案例pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.3.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.cn.dl</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>post-construct-demo</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

1、ApplicationContextAware

       实现ApplicationContextAware接口 Spring在创建完所有的bean之后，会通过setApplicationContext方法将Spring容器作为参数传递给applicationContext变量，接下来就可以通过applicationContext变量来访问Spring容器本身所有的bean以及其它信息。

package com.cn.dl.config;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * 实现ApplicationContextAware接口
 * Spring在创建完所有的bean之后，会通过setApplicationContext方法将Spring容器作为参数传递给
 * applicationContext变量，接下来就可以通过applicationContext变量来访问Spring容器本身所有的bean
 * Created by yanshao on 2019/2/18.
 */
@Component
public class InitApplicationContextAwareConfig implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public ApplicationContext getApplicationContext() {
        return applicationContext;
    }
}

在其它业务层通过注入InitApplicationContextAwareConfig 对象来访问applicationContext变量。

2、InitializingBean

        InitializingBean接口为bean提供了初始化方法的方式，只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候会执行该方法。一般用这个接口在Spring初始化bean之后做一些初始化操作。

package com.cn.dl.config;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，
 * 凡是继承该接口的类，在初始化bean的时候会执行该方法。
 * 一般用这个接口在Spring 初始化bean之后做一些初始化操作
 * Created by yanshao on 2019/2/18.
 */
@Component
public class InitInitializingBeanConfig implements InitializingBean {
    public static final Map<String,String> map = new HashMap<>();

    @Override
    public void afterPropertiesSet() throws Exception {
        map.put("InitConfigMap1","afterPropertiesSet1");
        map.put("InitConfigMap2","afterPropertiesSet2");
        map.put("InitConfigMap3","afterPropertiesSet4");
    }
}

这里定义一个map集合，在测试的controller中可以获取map，然后打印其中的key和value，不要疑惑为什么搞了这么low的案例，这个案例主要是为了学会使用InitializingBean扩展接口。

3、BeanPostProcessor

       想在Spring容器中完成bean实例化、配置以及其它初始化方法前后要添加一些特殊的处理逻辑。需要定义一个或多个BeanPostProcessor接口实现类，然后注册到Spring IOC容器中。

      为了演示这个BeanPostProcessor接口的使用，专门定义了自动装配的注解BeanQuote，还有两个service方法：UserServiceImpl1、UserServiceImpl2

package com.cn.dl.annotation;

import org.springframework.stereotype.Component;

import java.lang.annotation.*;

/**
 * 自定义装配注解
 * Created by yanshao on 2019/2/18.
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Component
public @interface BeanQuote {
    String beanName() default "";
}

package com.cn.dl.service;

/**
 * Created by yanshao on 2019/2/18.
 */
public interface UserService {
    void register();
}

package com.cn.dl.service.impl;

import com.cn.dl.service.UserService;
import org.springframework.stereotype.Service;

/**
 * Created by yanshao on 2019/2/18.
 */
@Service
public class UserServiceImpl1 implements UserService {
    @Override
    public void register() {
        System.out.println("UserServiceImpl1>>>register()");
    }
}

package com.cn.dl.service.impl;

import com.cn.dl.service.UserService;
import org.springframework.stereotype.Service;

/**
 * Created by yanshao on 2019/2/18.
 */
@Service
public class UserServiceImpl2 implements UserService {
    @Override
    public void register() {
        System.out.println("UserServiceImpl2>>>register()");
    }
}

核心内容主要在InitBeanPostProcessorConfig

package com.cn.dl.config;

import com.cn.dl.annotation.BeanQuote;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;

/**
 * 想在Spring容器中完成bean实例化、配置以及其它初始化方法前后要添加一些特殊的处理逻辑。
 * 需要定义一个或多个BeanPostProcessor接口实现类，然后注册到Spring IoC容器中。
 * Created by yanshao on 2019/2/18.
 */
@Component
public class InitBeanPostProcessorConfig implements BeanPostProcessor{

    @Autowired
    InitApplicationContextAwareConfig initApplicationContextAwareConfig;


    @Nullable
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Class cls = bean.getClass();
        Field fields[] = cls.getDeclaredFields();
        for(Field field : fields){
            //如果某个属性添加里这个注解，通过beanName的值来自动装配
            if(field.isAnnotationPresent(BeanQuote.class)){
                System.out.println("自定义装配注解>>>"+initApplicationContextAwareConfig.getApplicationContext().getBean(field.getAnnotation(BeanQuote.class).beanName()));
                field.setAccessible(true);
                try {
                    //从Spring容器中获取指定bean并set
                    field.set(bean,initApplicationContextAwareConfig.getApplicationContext().getBean(field.getAnnotation(BeanQuote.class).beanName()));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
        return bean;
    }

}

    @BeanQuote(beanName = "userServiceImpl1")
    private UserService userService;

       这里注入了InitBeanPostProcessorConfig 对象，为了获取applicationContext对象，得到所有依赖注入的bean，然后通过BeanQuote注解中beanName的值来注入指定的bean。

如果使用@Autowired来注入，发现有两个类型为UserService的bean，编译都编译不了

    @Autowired
    private UserServiceImpl1 userServiceImpl1;
    @Autowired
    private UserServiceImpl2 userServiceImpl2;

或者我们可以这样来注入，在业务层想用哪个就用哪个，这里主要为了学习使用BeanPostProcessor，就不这样干了。

4、顺便有一个Servlet注解PostConstruct

       从Java EE5规范开始,Servlet增加的一个注解，在Spring 创建完对象和自动装配完成之后开始执行，并且只执行一次，它可以做一些业务上的初始化操作，或者启动任务之类的。加了@PostConstruct的方法：

•      不能有任何参数 例如：void task(String task)，启动会抛错
•      可以throws 异常
•      可以被static、final修饰

/**
     * 加了@PostConstruct的方法：
     * 1、不能有任何参数 例如：void task(String task)
     * 2、可以throws 异常
     * 3、可以被static、final修饰
     * */
    @PostConstruct
    public static final void task() throws Exception{
        new Thread(() -> {
            while (true){
                try {
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println("task 定时任务");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

5、DisposableBean

在Bean被销毁、生命周期结束之前被调用，用于做一些销毁工作

package com.cn.dl.config;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.stereotype.Component;

/**
 * Created by yanshao on 2019/2/18.
 */
@Component
public class DisposableBeanConfig implements DisposableBean {
    /**
     * 该方法会在Bean被销毁、生命周期结束之前被调用，用于做一些销毁工作
     * */
    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBeanConfig");
    }
}

6、测试controller

package com.cn.dl.controller;

import com.cn.dl.annotation.BeanQuote;
import com.cn.dl.config.InitInitializingBeanConfig;
import com.cn.dl.service.UserService;
import com.cn.dl.service.impl.UserServiceImpl2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.PostConstruct;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * Created by yanshao on 2019/2/18.
 */
@RestController
@RequestMapping({"/api/user/"})
public class UserController {


    @Autowired
    UserServiceImpl2 userServiceImpl2;

    @BeanQuote(beanName = "userServiceImpl1")
    private UserService userService;


    @GetMapping("getUserData")
    public void getUserData(){
        System.out.println("getUserData");
    }

    @GetMapping("register")
    public void register(){
        userService.register();
    }

    @GetMapping("getMap")
    public void getMap(){
        Map<String,String> map = InitInitializingBeanConfig.map;
        map.forEach((k,v) -> {
            System.out.println("getMap>>>"+ k + ">>>" + v);
        });
    }

    /**
     * 加了@PostConstruct的方法：
     * 1、不能有任何参数 例如：void task(String task)
     * 2、可以throws 异常
     * 3、可以被static、final修饰
     * */
    @PostConstruct
    public static final void task() throws Exception{
        new Thread(() -> {
            while (true){
                try {
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println("task 定时任务");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

1、启动项目之后定时任务每隔3秒执行一次

2、访问127.0.0.1:8080/api/user/getMap

在InitializingBean做的初始化map的值被打印出来了，在实际开发中，经常用到InitializingBean

3、访问 127.0.0.1:8080/api/user/register

打印出UserServiceImpl1>>>register()，说明自定义装配注解和通过BeanPostProcessor对bean初始化的特殊处理没有问题

如果改成userServiceImpl2，打印结果UserServiceImpl2>>>register()

    @BeanQuote(beanName = "userServiceImpl2")
    private UserService userService;