Spring注解驱动开发


阅读数: 次   

一、容器

1.1 AnnotationConfigApplicationContext

之前写法

1
2
3
4
<bean id="person" class="com.atguigu.bean.Person"  scope="prototype" >
    <property name="age" value="${}"></property>
    <property name="name" value="zhangsan"></property>
</bean>
1
2
3
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
Person bean = (Person) applicationContext.getBean("person");
System.out.println(bean);

配置类

1
2
3
4
5
6
7
8
@Configuration  //告诉Spring这是一个配置类
public class MainConfig {
    //给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
    @Bean("person")
    public Person person01(){
        return new Person("lisi", 20);
    }
}

包扫描

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    Person bean = applicationContext.getBean(Person.class);
    System.out.println(bean);

    String[] namesForType = applicationContext.getBeanNamesForType(Person.class);
    for (String name : namesForType) {
        System.out.println(name);
    }
}

1.2 组件添加

@ComponentScan

1
2
3
4
5
6
7
8
9
@ComponentScans(
    value = {
        @ComponentScan(value="com.atguigu",includeFilters = {
            @Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
            @Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),
            @Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})
        },useDefaultFilters = false)	
    }
)

  • @ComponentScan value:指定要扫描的包

  • excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件

  • includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件

  • FilterType.ANNOTATION：按照注解

  • FilterType.ASSIGNABLE_TYPE：按照给定的类型；

  • FilterType.ASPECTJ：使用ASPECTJ表达式

  • FilterType.REGEX：使用正则指定

  • FilterType.CUSTOM：使用自定义规则

    MyTypeFilter

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    public class MyTypeFilter implements TypeFilter {
        /**
    	 * metadataReader：读取到的当前正在扫描的类的信息
    	 * metadataReaderFactory:可以获取到其他任何类信息的
    	 */
        @Override
        public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
            throws IOException {
            //获取当前类注解的信息
            AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
            //获取当前正在扫描的类的类信息
            ClassMetadata classMetadata = metadataReader.getClassMetadata();
            //获取当前类资源（类的路径）
            Resource resource = metadataReader.getResource();

            String className = classMetadata.getClassName();
            System.out.println("--->"+className);
            if(className.contains("er")){
                return true;
            }
            return false;
        }
    }

@Bean

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
52
53
54
55
56
57
58
/**
 * bean的生命周期：
 * 		bean创建---初始化----销毁的过程
 * 容器管理bean的生命周期；
 * 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
 * 
 * 构造（对象创建）
 * 		单实例：在容器启动的时候创建对象
 * 		多实例：在每次获取的时候创建对象\
 * 
 * BeanPostProcessor.postProcessBeforeInitialization
 * 初始化：
 * 		对象创建完成，并赋值好，调用初始化方法。。。
 * BeanPostProcessor.postProcessAfterInitialization
 * 销毁：
 * 		单实例：容器关闭的时候
 * 		多实例：容器不会管理这个bean；容器不会调用销毁方法；
 * 
 * 
 * 遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
 * 一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization
 * 
 * BeanPostProcessor原理
 * populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
 * initializeBean
 * {
 * applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
 * invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
 * applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 *}
 * 
 * 
 * 
 * 1）、指定初始化和销毁方法；
 * 		通过@Bean指定init-method和destroy-method；
 * 2）、通过让Bean实现InitializingBean（定义初始化逻辑），
 * 				DisposableBean（定义销毁逻辑）;
 * 3）、可以使用JSR250；
 * 		@PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
 * 		@PreDestroy：在容器销毁bean之前通知我们进行清理工作
 * 4）、BeanPostProcessor【interface】：bean的后置处理器；
 * 		在bean初始化前后进行一些处理工作；
 * 		postProcessBeforeInitialization:在初始化之前工作
 * 		postProcessAfterInitialization:在初始化之后工作
 * 
 * Spring底层对 BeanPostProcessor 的使用；
 * 		bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async,xxx BeanPostProcessor;
 */
@ComponentScan("com.atguigu.bean")
@Configuration
public class MainConfigOfLifeCycle {

    //@Scope("prototype")
    @Bean(initMethod="init",destroyMethod="detory")
    public Car car(){
        return new Car();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//第一种
@Component
public class Car {

    public Car(){
        System.out.println("car constructor...");
    }

    public void init(){
        System.out.println("car ... init...");
    }

    public void detory(){
        System.out.println("car ... detory...");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//第二种
@Component
public class Cat implements InitializingBean,DisposableBean {
   
   public Cat(){
      System.out.println("cat constructor...");
   }

   @Override
   public void destroy() throws Exception {
      System.out.println("cat...destroy...");
   }

   @Override
   public void afterPropertiesSet() throws Exception {
      System.out.println("cat...afterPropertiesSet...");
   }
}
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
@Component
public class Dog implements ApplicationContextAware {

    //@Autowired
    private ApplicationContext applicationContext;

    public Dog(){
        System.out.println("dog constructor...");
    }

    //对象创建并赋值之后调用
    @PostConstruct
    public void init(){
        System.out.println("Dog....@PostConstruct...");
    }

    //容器移除对象之前
    @PreDestroy
    public void detory(){
        System.out.println("Dog....@PreDestroy...");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * 后置处理器：初始化前后进行处理工作
 * 将后置处理器加入到容器中
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization..."+beanName+"=>"+bean);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization..."+beanName+"=>"+bean);
        return bean;
    }
}

@Configuration

@Component

@Service

@Controller

@Repository

@Conditional

按照一定的条件进行判断，满足条件给容器中注册bean

也可放在类上：类中组件统一设置。满足当前条件，这个类中配置的所有bean注册才能生效

1
2
3
4
5
6
7
8
9
10
11
12
//如果系统是windows，给容器中注册("bill")
//如果是linux系统，给容器中注册("linus")
@Bean("bill")
public Person person01(){
    return new Person("Bill Gates",62);
}

@Conditional(LinuxCondition.class)
@Bean("linus")
public Person person02(){
    return new Person("linus", 48);
}
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
//判断是否linux系统
public class LinuxCondition implements Condition {

    /**
	 * ConditionContext：判断条件能使用的上下文（环境）
	 * AnnotatedTypeMetadata：注释信息
	 */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // TODO是否linux系统
        //1、能获取到ioc使用的beanfactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //2、获取类加载器
        ClassLoader classLoader = context.getClassLoader();
        //3、获取当前环境信息
        Environment environment = context.getEnvironment();
        //4、获取到bean定义的注册类
        BeanDefinitionRegistry registry = context.getRegistry();

        String property = environment.getProperty("os.name");

        //可以判断容器中的bean注册情况，也可以给容器中注册bean
        boolean definition = registry.containsBeanDefinition("person");
        if(property.contains("linux")){
            return true;
        }
        return false;
    }
}

@Primary

@Primary：让Spring进行自动装配的时候，默认使用首选的bean,也可以继续使用@Qualifier指定需要装配的bean的名字

1
2
3
4
5
6
7
@Primary
@Bean("bookDao2")
public BookDao bookDao(){
    BookDao bookDao = new BookDao();
    bookDao.setLable("2");
    return bookDao;
}

@Lazy

懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；

1
2
3
4
5
6
@Lazy
@Bean("person")
public Person person(){
    System.out.println("给容器中添加Person....");
    return new Person("张三", 25);
}

@Scope

  • prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。每次获取的时候才会调用方法创建对象；
  • singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。以后每次获取就是直接从容器（map.get()）中拿 (默认)
  • request：同一次请求创建一个实例
  • session：同一个session创建一个实例
1
2
3
4
5
6
7
//默认是单实例的
@Scope("prototype")
@Bean("person")
public Person person(){
    System.out.println("给容器中添加Person....");
    return new Person("张三", 25);
}

@Import

给容器中注册组件

  1. 包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类]
  2. @Bean[导入的第三方包里面的组件]
  3. @Import[快速给容器中导入一个组件]
    • @Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名
    • ImportSelector:返回需要导入的组件的全类名数组；
    • ImportBeanDefinitionRegistrar:手动注册bean到容器中
  4. 使用Spring提供的 FactoryBean（工厂Bean）;
    • 默认获取到的是工厂bean调用getObject创建的对象
    • 要获取工厂Bean本身，我们需要给id前面加一个& (&colorFactoryBean)
1
2
3
4
@Configuration
@Import({Color.class,Red.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})
//@Import导入组件，id默认是组件的全类名
public class MainConfig2 {}
1
2
3
4
5
6
7
8
9
10
11
//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {
    //返回值，就是到导入到容器中的组件全类名
    //AnnotationMetadata:当前标注@Import注解的类的所有注解信息
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //importingClassMetadata
        //方法不要返回null值
        return new String[]{"com.atguigu.bean.Blue","com.atguigu.bean.Yellow"};
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    /**
	 * AnnotationMetadata：当前类的注解信息
	 * BeanDefinitionRegistry:BeanDefinition注册类；
	 * 		把所有需要添加到容器中的bean；调用
	 * 		BeanDefinitionRegistry.registerBeanDefinition手工注册进来
	 */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        boolean definition = registry.containsBeanDefinition("com.atguigu.bean.Red");
        boolean definition2 = registry.containsBeanDefinition("com.atguigu.bean.Blue");
        if(definition && definition2){
            //指定Bean定义信息；（Bean的类型，Bean。。。）
            RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
            //注册一个Bean，指定bean名
            registry.registerBeanDefinition("rainBow", beanDefinition);
        }
    }
}

工厂模式

1
2
3
4
5
6
7
@Configuration
public class MainConfig2 {
    @Bean
    public ColorFactoryBean colorFactoryBean(){
        return new ColorFactoryBean();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {

    //返回一个Color对象，这个对象会添加到容器中
    @Override
    public Color getObject() throws Exception {
        System.out.println("ColorFactoryBean...getObject...");
        return new Color();
    }

    @Override
    public Class<?> getObjectType() {
        return Color.class;
    }

    //是单例？
    //true：这个bean是单实例，在容器中保存一份
    //false：多实例，每次获取都会创建一个新的bean；
    @Override
    public boolean isSingleton() {
        return false;
    }
}

1.3 组件赋值

@Value

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
public class Person {
    //使用@Value赋值；
    //1、基本数值
    //2、可以写SpEL； #{}
    //3、可以写${}；取出配置文件【properties】中的值（在运行环境变量里面的值）

    @Value("张三")
    private String name;
    @Value("#{20-2}")
    private Integer age;
    @Value("${person.nickName}")
    private String nickName;

    public String getNickName() {
        return nickName;
    }
    public void setNickName(String nickName) {
        this.nickName = nickName;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }

    public Person(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", nickName=" + nickName + "]";
    }
}

@Autowired

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
52
53
54
55
56
57
58
59
60
61
62
63
/**
 * 自动装配;
 *        Spring利用依赖注入（DI），完成对IOC容器中中各个组件的依赖关系赋值；
 * 
 * 1）、@Autowired：自动注入：
 *        1）、默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class);找到就赋值
 *        2）、如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找
 *                       applicationContext.getBean("bookDao")
 *        3）、@Qualifier("bookDao")：使用@Qualifier指定需要装配的组件的id，而不是使用属性名
 *        4）、自动装配默认一定要将属性赋值好，没有就会报错；
 *           可以使用@Autowired(required=false);
 *        5）、@Primary：让Spring进行自动装配的时候，默认使用首选的bean；
 *              也可以继续使用@Qualifier指定需要装配的bean的名字
 *        BookService{
 *           @Autowired
 *           BookDao  bookDao;
 *        }
 * 
 * 2）、Spring还支持使用@Resource(JSR250)和@Inject(JSR330)[java规范的注解]
 *        @Resource:
 *           可以和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的；
 *           没有能支持@Primary功能没有支持@Autowired（reqiured=false）;
 *        @Inject:
 *           需要导入javax.inject的包，和Autowired的功能一样。没有required=false的功能；
 *  @Autowired:Spring定义的； @Resource、@Inject都是java规范
 *     
 * AutowiredAnnotationBeanPostProcessor:解析完成自动装配功能；       
 * 
 * 3）、 @Autowired:构造器，参数，方法，属性；都是从容器中获取参数组件的值
 *        1）、[标注在方法位置]：@Bean+方法参数；参数从容器中获取;默认不写@Autowired效果是一样的；都能自动装配
 *        2）、[标在构造器上]：如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取
 *        3）、放在参数位置：
 * 
 * 4）、自定义组件想要使用Spring容器底层的一些组件（ApplicationContext，BeanFactory，xxx）；
 *        自定义组件实现xxxAware；在创建对象的时候，会调用接口规定的方法注入相关组件；Aware；
 *        把Spring底层一些组件注入到自定义的Bean中；
 *        xxxAware：功能使用xxxProcessor；
 *           ApplicationContextAware==》ApplicationContextAwareProcessor；
 */
@Configuration
@ComponentScan({"com.atguigu.service","com.atguigu.dao",
                "com.atguigu.controller","com.atguigu.bean"})
public class MainConifgOfAutowired {
    @Primary
    @Bean("bookDao2")
    public BookDao bookDao(){
        BookDao bookDao = new BookDao();
        bookDao.setLable("2");
        return bookDao;
    }

    /**
    * @Bean标注的方法创建对象的时候，方法参数的值从容器中获取
    * @param car
    * @return
    */
    @Bean
    public Color color(Car car){
        Color color = new Color();
        color.setCar(car);
        return color;
    }
}

1 @Qualifier

2 其他方式

@Resources（JSR250）
  • 可以和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的；
  • 没有能支持@Primary功能没有支持@Autowired（reqiured=false）;
1
2
@Resource(name="bookDao2")
private BookDao bookDao;
@Inject（JSR330，需要导入javax.inject）
  • 需要导入javax.inject的包，和Autowired的功能一样。没有required=false的功能；
1
2
@Inject
private BookDao bookDao;

@PropertySource

之前：

1
2
3
4
5
<context:property-placeholder location="classpath:person.properties"/>
<bean id="person" class="com.atguigu.bean.Person"  scope="prototype" >
    <property name="age" value="${}"></property>
    <property name="name" value="zhangsan"></property>
</bean>
1
2
3
4
5
6
7
8
9
//使用@PropertySource读取外部配置文件中的k/v保存到运行的环境变量中;加载完外部的配置文件以后使用${}取出配置文件的值
@PropertySource(value={"classpath:/person.properties"})
@Configuration
public class MainConfigOfPropertyValues {
    @Bean
    public Person person(){
        return new Person();
    }
}

@PropertySources

@Profile

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
/**
 * Profile：
 *        Spring为我们提供的可以根据当前环境，动态的激活和切换一系列组件的功能；
 * 
 * 开发环境、测试环境、生产环境；
 * 数据源：(/A)(/B)(/C)；
 * 
 * 
 * @Profile：指定组件在哪个环境的情况下才能被注册到容器中，不指定，任何环境下都能注册这个组件
 * 
 * 1）、加了环境标识的bean，只有这个环境被激活的时候才能注册到容器中。默认是default环境
 * 2）、写在配置类上，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效
 * 3）、没有标注环境标识的bean在，任何环境下都是加载的；
 */

@PropertySource("classpath:/dbconfig.properties")
@Configuration
public class MainConfigOfProfile implements EmbeddedValueResolverAware{

    @Value("${db.user}")
    private String user;

    private StringValueResolver valueResolver;

    private String  driverClass;


    @Bean
    public Yellow yellow(){
        return new Yellow();
    }

    @Profile("test")
    @Bean("testDataSource")
    public DataSource dataSourceTest(@Value("${db.password}")String pwd) throws Exception{
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }


    @Profile("dev")
    @Bean("devDataSource")
    public DataSource dataSourceDev(@Value("${db.password}")String pwd) throws Exception{
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/ssm_crud");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    @Profile("prod")
    @Bean("prodDataSource")
    public DataSource dataSourceProd(@Value("${db.password}")String pwd) throws Exception{
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/scw_0515");

        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.valueResolver = resolver;
        driverClass = valueResolver.resolveStringValue("${db.driverClass}");
    }
}

Environment

pom.xml

1
2
3
4
5
6
7
8
9
10
11
<dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.44</version>
</dependency>

dbconfig.properties

1
2
3
db.user=root
db.password=123456
db.driverClass=com.mysql.jdbc.Driver

-Dspring.profiles.active=test

-Dspring.profiles.active=dev

-Dspring.profiles.active=prod

1
2
3
4
5
6
7
8
9
10
11
12
13
//1、使用命令行动态参数: 在虚拟机参数位置加载 -Dspring.profiles.active=test
//2、代码的方式激活某种环境；
public void test01(){
    AnnotationConfigApplicationContext applicationContext = 
        new AnnotationConfigApplicationContext();
    //1、创建一个applicationContext
    //2、设置需要激活的环境
    applicationContext.getEnvironment().setActiveProfiles("dev");
    //3、注册主配置类
    applicationContext.register(MainConfigOfProfile.class);
    //4、启动刷新容器
    applicationContext.refresh();
}

1.4 组件注入

方法参数

1
2
3
public void setCar(@Autowired Car car) {
   this.car = car;
}

构造器注入

1
2
3
4
5
6
//构造器要用的组件，都是从容器中获取
@Autowired
public Boss(Car car){
   this.car = car;
   System.out.println("Boss...有参构造器");
}

方法注入

1
2
3
4
5
6
@Autowired
//标注在方法，Spring容器创建当前对象，就会调用方法，完成赋值；
//方法使用的参数，自定义类型的值从ioc容器中获取
public void setCar(Car car) {
    this.car = car;
}

ApplicationContextAware

ApplicationContextAwareProcessor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
if (bean instanceof Aware) {
    if (bean instanceof EnvironmentAware) {
        ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
    }
    if (bean instanceof EmbeddedValueResolverAware) {
        ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
    }
    if (bean instanceof ResourceLoaderAware) {
        ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
    }
    if (bean instanceof ApplicationEventPublisherAware) {
        ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
    }
    if (bean instanceof MessageSourceAware) {
        ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
    }
    if (bean instanceof ApplicationContextAware) {
        ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
    }
}

xxxAware

Aware接口

1
2
3
4
5
6
7
8
9
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.beans.factory;

public interface Aware {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Component
public class Red implements ApplicationContextAware,BeanNameAware,EmbeddedValueResolverAware {
   
   private ApplicationContext applicationContext;

   @Override
   public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
      System.out.println("传入的ioc："+applicationContext);
      this.applicationContext = applicationContext;
   }

   @Override
   public void setBeanName(String name) {
      System.out.println("当前bean的名字："+name);
   }

   @Override
   public void setEmbeddedValueResolver(StringValueResolver resolver) {
      String resolveStringValue = resolver.resolveStringValue("你好 ${os.name} 我是 #{20*18}");
      System.out.println("解析的字符串："+resolveStringValue);
   }
}

1.5 AOP

底层：动态代理

指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式

使用步骤：

  1. 导入aop模块；Spring AOP：(spring-aspects)
  2. 定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx）
  3. 定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行
  4. 给切面类的目标方法标注何时何地运行（通知注解）
  5. 将切面类和业务逻辑类（目标方法所在类）都加入到容器中
  6. 必须告诉Spring哪个类是切面类(给切面类上加一个注解：@Aspect)
  7. 给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】(在Spring中很多的 @EnableXXX)

通知方法：

  • 前置通知(@Before)：logStart：在目标方法(div)运行之前运行
  • 后置通知(@After)：logEnd：在目标方法(div)运行结束之后运行（无论方法正常结束还是异常结束）
  • 返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行
  • 异常通知(@AfterThrowing)：logException：在目标方法(div)出现异常以后运行
  • 环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@EnableAspectJAutoProxy
@Configuration
public class MainConfigOfAOP {
    
   //业务逻辑类加入容器中
   @Bean
   public MathCalculator calculator(){
      return new MathCalculator();
   }

   //切面类加入到容器中
   @Bean
   public LogAspects logAspects(){
      return new LogAspects();
   }
}
1
2
3
4
5
6
public class MathCalculator {
	public int div(int i,int j){
		System.out.println("MathCalculator...div...");
		return i/j;	
	}
}
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
/**
 * 切面类
 * @Aspect： 告诉Spring当前类是一个切面类
 */
@Aspect
public class LogAspects {
   
   //抽取公共的切入点表达式
   //1、本类引用
   //2、其他的切面引用
   @Pointcut("execution(public int com.atguigu.aop.MathCalculator.*(..))")
   public void pointCut(){};
   
   //@Before在目标方法之前切入；切入点表达式（指定在哪个方法切入）
   @Before("pointCut()")
   public void logStart(JoinPoint joinPoint){
      Object[] args = joinPoint.getArgs();
      System.out.println(""+joinPoint.getSignature().getName()+"运行。。。@Before:参数列表是：{"+Arrays.asList(args)+"}");
   }
   
   @After("com.atguigu.aop.LogAspects.pointCut()")
   public void logEnd(JoinPoint joinPoint){
      System.out.println(""+joinPoint.getSignature().getName()+"结束。。。@After");
   }
   
   //JoinPoint一定要出现在参数表的第一位
   @AfterReturning(value="pointCut()",returning="result")
   public void logReturn(JoinPoint joinPoint,Object result){
      System.out.println(""+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:运行结果：{"+result+"}");
   }
   
   @AfterThrowing(value="pointCut()",throwing="exception")
   public void logException(JoinPoint joinPoint,Exception exception){
      System.out.println(""+joinPoint.getSignature().getName()+"异常。。。异常信息：{"+exception+"}");
   }
}

原理:

看给容器中注册了什么组件，这个组件什么时候工作，这个组件的功能是什么？

  1. @EnableAspectJAutoProxy是什么？

    @Import(AspectJAutoProxyRegistrar.class)：给容器中导入AspectJAutoProxyRegistrar

    利用AspectJAutoProxyRegistrar自定义给容器中注册bean；BeanDefinetion

    internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator

    给容器中注册一个AnnotationAwareAspectJAutoProxyCreator

  2. AnnotationAwareAspectJAutoProxyCreator

    AnnotationAwareAspectJAutoProxyCreator->AspectJAwareAdvisorAutoProxyCreator->AbstractAdvisorAutoProxyCreator->AbstractAutoProxyCreator

    implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware

    后置处理器（在bean初始化完成前后做事情）、自动装配BeanFactory

流程：

  1. 传入配置类，创建ioc容器

  2. 注册配置类，调用 refresh() 刷新容器

  3. registerBeanPostProcessors(beanFactory); 注册bean的后置处理器来方便拦截bean的创建

    1）、先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor

    2）、给容器中加别的BeanPostProcessor

    3）、优先注册实现了PriorityOrdered接口的BeanPostProcessor

    4）、再给容器中注册实现了Ordered接口的BeanPostProcessor

    5）、注册没实现优先级接口的BeanPostProcessor

    6）、注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中

    • 创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】

      1）、创建Bean的实例

      2）、populateBean；给bean的各种属性赋值

      3）、initializeBean：初始化bean

      ​ ① invokeAwareMethods()：处理Aware接口的方法回调

      ​ ② applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization()

      ​ ③ invokeInitMethods()；执行自定义的初始化方法

      ​ ④ applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization()

      4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；–》aspectJAdvisorsBuilder

    7）、把BeanPostProcessor注册到BeanFactory中;beanFactory.addBeanPostProcessor(postProcessor)

    以上是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程

  4. finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；创建剩下的单实例bean

    1）、遍历获取容器中所有的Bean，依次创建对象getBean(beanName);

    ​ getBean->doGetBean()->getSingleton()->

    2）、创建bean

    • AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截，InstantiationAwareBeanPostProcessor，会调用postProcessBeforeInstantiation()

      1）、先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；(只要创建好的Bean都会被缓存起来)

      2）、createBean();创建bean

      ​ [AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建之前先尝试返回bean的实例]

      ​ 【BeanPostProcessor是在Bean对象创建完成初始化前后调用的】

      ​ 【InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的】

      ​ ① resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation

      ​ 希望后置处理器在此能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续

      ​ 后置处理器先尝试返回对象

      ​ bean = applyBeanPostProcessorsBeforeInstantiation()

      ​ 拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor;

      ​ 就执行postProcessBeforeInstantiation

      ​ if (bean != null) { bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);}

      ​ ② doCreateBean(beanName, mbdToUse, args);真正的去创建一个bean实例；和3.6流程一样；

AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】 的作用：

  1. 每一个bean创建之前，调用postProcessBeforeInstantiation()

    MathCalculator和LogAspect的创建

    1）、判断当前bean是否在advisedBeans中（保存了所有需要增强bean）

    2）、判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，或者是否是切面（@Aspect）

    3）、是否需要跳过

    ​ ① 获取候选的增强器（切面里面的通知方法）【List<Advisor> candidateAdvisors】

    ​ 每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor

    ​ 判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true

    ​ ② 永远返回false

  2. 创建对象

    postProcessAfterInitialization；

    ​ return wrapIfNecessary(bean, beanName, cacheKey);//包装如果需要的情况下

    1）、获取当前bean的所有增强器（通知方法） Object[] specificInterceptors

    ​ ① 找到候选的所有的增强器（找哪些通知方法是需要切入当前bean方法的）

    ​ ② 获取到能在bean使用的增强器。

    ​ ③ 给增强器排序

    2）、保存当前bean在advisedBeans中；

    3）、如果当前bean需要增强，创建当前bean的代理对象；

    ​ ① 获取所有增强器（通知方法）

    ​ ② 保存到proxyFactory

    ​ ③ 创建代理对象：Spring自动决定

    ​ JdkDynamicAopProxy(config);jdk动态代理；

    ​ ObjenesisCglibAopProxy(config);cglib的动态代理；

    4）、给容器中返回当前组件使用cglib增强了的代理对象；

    5）、以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；

  3. 目标方法执行

    容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）；

    1）、CglibAopProxy.intercept();拦截目标方法的执行

    2）、根据ProxyFactory对象获取将要执行的目标方法拦截器链

    ​ List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

    ​ ① List<Object> interceptorList保存所有拦截器 5 | 一个默认的ExposeInvocationInterceptor 和 4个增强器

    ​ ② 遍历所有的增强器，将其转为Interceptor | registry.getInterceptors(advisor);

    ​ ③ 将增强器转为List<MethodInterceptor>; | 如果是MethodInterceptor，直接加入到集合中,如果不是，使用AdvisorAdapter将增强器转为MethodInterceptor；转换完成返回MethodInterceptor数组；

    3）、如果没有拦截器链，直接执行目标方法

    ​ 拦截器链（每一个通知方法又被包装为方法拦截器，利用MethodInterceptor机制）

    4）、如果有拦截器链，把需要执行的目标对象，目标方法，拦截器链等信息传入创建一个 CglibMethodInvocation 对象，并调用 Object retVal = mi.proceed();

    5）、拦截器链的触发过程;

    ​ ① 如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法；

    ​ ② 链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；

    ​ 拦截器链的机制，保证通知方法与目标方法的执行顺序

总结：

  1. @EnableAspectJAutoProxy 开启AOP功能

  2. @EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator

  3. AnnotationAwareAspectJAutoProxyCreator是一个后置处理器

  4. 容器的创建流程：

    1）、registerBeanPostProcessors（）注册后置处理器；创建AnnotationAwareAspectJAutoProxyCreator对象

    2）、AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程

    3）、组件创建完之后，判断组件是否需要增强

    ​ 是：切面的通知方法，包装成增强器（Advisor）;给业务逻辑组件创建一个代理对象（cglib）；

  5. 执行目标方法：

    1）、代理对象执行目标方法

    2）、CglibAopProxy.intercept()；

    ​ ① 得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）

    ​ ② 利用拦截器的链式机制，依次进入每一个拦截器进行执行；

    ​ ③ 效果：

    ​ 正常执行：前置通知->目标方法->后置通知->返回通知

    ​ 出现异常：前置通知->目标方法->后置通知->异常通知

1.6 声明式事务

环境搭建：

  1. 导入相关依赖

    数据源、数据库驱动、Spring-jdbc模块

  2. 配置数据源、JdbcTemplate（Spring提供的简化数据库操作的工具）操作数据

  3. 给方法上标注 @Transactional 表示当前方法是一个事务方法

  4. @EnableTransactionManagement 开启基于注解的事务管理功能

  5. 配置事务管理器来控制事务

    1
    2
    3
    4
    @Bean
    public PlatformTransactionManager transactionManager() throws Exception{
        return new DataSourceTransactionManager(dataSource());
    }
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
@EnableTransactionManagement
@ComponentScan("com.atguigu.tx")
@Configuration
public class TxConfig {
   
   //数据源
   @Bean
   public DataSource dataSource() throws Exception{
      ComboPooledDataSource dataSource = new ComboPooledDataSource();
      dataSource.setUser("root");
      dataSource.setPassword("123456");
      dataSource.setDriverClass("com.mysql.jdbc.Driver");
      dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
      return dataSource;
   }
   
   @Bean
   public JdbcTemplate jdbcTemplate() throws Exception{
      //Spring对@Configuration类会特殊处理；给容器中加组件的方法，多次调用都只是从容器中找组件
      JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource());
      return jdbcTemplate;
   }
   
   //注册事务管理器在容器中
   @Bean
   public PlatformTransactionManager transactionManager() throws Exception{
      return new DataSourceTransactionManager(dataSource());
   }
}
1
2
3
4
5
6
7
8
9
10
@Repository
public class UserDao {
	@Autowired
	private JdbcTemplate jdbcTemplate;
	public void insert(){
		String sql = "INSERT INTO `tbl_user`(username,age) VALUES(?,?)";
		String username = UUID.randomUUID().toString().substring(0, 5);
		jdbcTemplate.update(sql, username,19);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
@Service
public class UserService {
   @Autowired
   private UserDao userDao;
   
   @Transactional
   public void insertUser(){
      userDao.insert();
      //otherDao.other();xxx
      System.out.println("插入完成...");
      int i = 10/0;
   }
}

原理：

  1. @EnableTransactionManagement

    利用TransactionManagementConfigurationSelector给容器中会导入组件

    导入两个组件 AutoProxyRegistrar | ProxyTransactionManagementConfiguration

  2. AutoProxyRegistrar：

    给容器中注册一个 InfrastructureAdvisorAutoProxyCreator 组件

    InfrastructureAdvisorAutoProxyCreator：利用后置处理器机制在对象创建以后，包装对象，返回一个代理对象（增强器），代理对象执行方法利用拦截器链进行调用；

  3. ProxyTransactionManagementConfiguration 做了什么？

    给容器中注册事务增强器

    1）、事务增强器要用事务注解的信息，AnnotationTransactionAttributeSource解析事务注解

    2）、事务拦截器：

    ​ TransactionInterceptor；保存了事务属性信息，事务管理器；

    ​ 他是一个 MethodInterceptor;在目标方法执行的时候,执行拦截器链;

    ​ 事务拦截器作用：

    ​ ① 先获取事务相关的属性

    ​ ② 再获取PlatformTransactionManager，如果事先没有添加指定任何transactionmanger

    ​ 最终会从容器中按照类型获取一个PlatformTransactionManager

    ​ ③ 执行目标方法

    ​ 如果异常，获取到事务管理器，利用事务管理回滚操作；

    ​ 如果正常，利用事务管理器，提交事务

二、扩展原理

2.1 BeanFactoryPostProcessor：beanFactory的后置处理器

在BeanFactory标准初始化之后调用，来定制和修改BeanFactory的内容；所有的bean定义已经保存加载到beanFactory，但是bean的实例还未创建

1
2
3
4
5
6
7
8
@ComponentScan("com.atguigu.ext")
@Configuration
public class ExtConfig {
   @Bean
   public Blue blue(){
      return new Blue();
   }
}
1
2
3
4
5
6
7
8
9
10
11
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
   @Override
   public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
      System.out.println("MyBeanFactoryPostProcessor...postProcessBeanFactory...");
      int count = beanFactory.getBeanDefinitionCount();
      String[] names = beanFactory.getBeanDefinitionNames();
      System.out.println("当前BeanFactory中有"+count+" 个Bean");
      System.out.println(Arrays.asList(names));
   }
}

BeanFactoryPostProcessor原理:

  1. ioc容器创建对象

  2. invokeBeanFactoryPostProcessors(beanFactory) 如何找到所有的BeanFactoryPostProcessor并执行他们的方法

    1）、直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法

    2）、在初始化创建其他组件前面执行

2.2 BeanDefinitionRegistryPostProcessor

BeanFactoryPostProcessor子类，可自定义添加bean定义

在所有bean定义信息将要被加载，bean实例还未创建的

优先于BeanFactoryPostProcessor执行

利用BeanDefinitionRegistryPostProcessor给容器中再额外添加一些组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor{
   @Override
   public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
      System.out.println("MyBeanDefinitionRegistryPostProcessor...bean的数量："+beanFactory.getBeanDefinitionCount());
   }

   //BeanDefinitionRegistry Bean定义信息的保存中心，以后BeanFactory就是按照BeanDefinitionRegistry里面保存的每一个bean定义信息创建bean实例；
   @Override
   public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
      System.out.println("postProcessBeanDefinitionRegistry...bean的数量："+registry.getBeanDefinitionCount());
      //RootBeanDefinition beanDefinition = new RootBeanDefinition(Blue.class);
      AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Blue.class).getBeanDefinition();
      registry.registerBeanDefinition("hello", beanDefinition);
   }
}

原理：

  1. ioc创建对象

  2. refresh() -> invokeBeanFactoryPostProcessors(beanFactory)

  3. 从容器中获取到所有的BeanDefinitionRegistryPostProcessor组件

    1）、依次触发所有的postProcessBeanDefinitionRegistry()方法

    2）、再来触发postProcessBeanFactory()方法BeanFactoryPostProcessor

  4. 再来从容器中找到BeanFactoryPostProcessor组件；然后依次触发postProcessBeanFactory()方法

2.3 ApplicationListener

监听容器中发布的事件。事件驱动模型开发

public interface ApplicationListener<E extends ApplicationEvent>

监听 ApplicationEvent 及其下面的子事件

步骤：

  1. 写一个监听器（ApplicationListener实现类）来监听某个事件（ApplicationEvent及其子类）

    @EventListener;

    原理：使用EventListenerMethodProcessor处理器来解析方法上的@EventListener

  2. 把监听器加入到容器

  3. 只要容器中有相关事件的发布，我们就能监听到这个事件

    ContextRefreshedEvent：容器刷新完成（所有bean都完全创建）会发布这个事件

    ContextClosedEvent：关闭容器会发布这个事件

  4. 发布一个事件

    applicationContext.publishEvent()

1
2
3
4
5
6
7
8
@Component
public class MyApplicationListener implements ApplicationListener<ApplicationEvent> {
   //当容器中发布此事件以后，方法触发
   @Override
   public void onApplicationEvent(ApplicationEvent event) {
      System.out.println("收到事件："+event);
   }
}
1
2
3
4
5
6
7
@Service
public class UserService {
   @EventListener(classes={ApplicationEvent.class})
   public void listen(ApplicationEvent event){
      System.out.println("UserService。。监听到的事件："+event);
   }
}

原理：

ContextRefreshedEvent、IOCTest_Ext$1[source=我发布的时间]、ContextClosedEvent

  1. ContextRefreshedEvent事件

    1）、容器创建对象：refresh()

    2）、finishRefresh();容器刷新完成会发布ContextRefreshedEvent事件

  2. 自己发布事件

  3. 容器关闭会发布ContextClosedEvent

事件发布流程:publishEvent(new ContextRefreshedEvent(this))

  1. 获取事件的多播器（派发器）：getApplicationEventMulticaster()

  2. multicastEvent派发事件

  3. 获取到所有的ApplicationListener

    for (final ApplicationListener<?> listener : getApplicationListeners(event, type)){}

    1）、如果有Executor，可以支持使用Executor进行异步派发

    ​ Executor executor = getTaskExecutor()

    2）、否则，同步的方式直接执行listener方法；invokeListener(listener, event)

    ​ 拿到listener回调onApplicationEvent方法

事件多播器（派发器）

  1. 容器创建对象：refresh()

  2. initApplicationEventMulticaster();初始化ApplicationEventMulticaster

    1）、先去容器中找有没有id=“applicationEventMulticaster”的组件

    2）、如果没有this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);

    ​ 并且加入到容器中，我们就可以在其他组件要派发事件，自动注入这个applicationEventMulticaster

容器中有哪些监听器

  1. 容器创建对象：refresh()

  2. registerListeners()

    从容器中拿到所有的监听器，把他们注册到applicationEventMulticaster中

    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);

    1
    2
    //将listener注册到ApplicationEventMulticaster中
    getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

SmartInitializingSingleton 原理：->afterSingletonsInstantiated()

  1. ioc容器创建对象并refresh()

  2. finishBeanFactoryInitialization(beanFactory);初始化剩下的单实例bean

    1）、先创建所有的单实例bean；getBean()

    2）、获取所有创建好的单实例bean，判断是否是SmartInitializingSingleton类型的

    ​ 如果是就调用afterSingletonsInstantiated()

2.4 Spring容器创建过程

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
Spring容器的refresh()【创建刷新】;
1、prepareRefresh()刷新前的预处理;
   1）、initPropertySources()初始化一些属性设置;子类自定义个性化的属性设置方法；
   2）、getEnvironment().validateRequiredProperties();检验属性的合法等
   3）、earlyApplicationEvents= new LinkedHashSet<ApplicationEvent>();保存容器中的一些早期的事件；
2、obtainFreshBeanFactory();获取BeanFactory；
   1）、refreshBeanFactory();刷新【创建】BeanFactory；
         创建了一个this.beanFactory = new DefaultListableBeanFactory();
         设置id；
   2）、getBeanFactory();返回刚才GenericApplicationContext创建的BeanFactory对象；
   3）、将创建的BeanFactory【DefaultListableBeanFactory】返回；
3、prepareBeanFactory(beanFactory);BeanFactory的预准备工作（BeanFactory进行一些设置）；
   1）、设置BeanFactory的类加载器、支持表达式解析器...
   2）、添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
   3）、设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
   4）、注册可以解析的自动装配；我们能直接在任何组件中自动注入：
         BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
   5）、添加BeanPostProcessor【ApplicationListenerDetector】
   6）、添加编译时的AspectJ；
   7）、给BeanFactory中注册一些能用的组件；
      environment【ConfigurableEnvironment】、
      systemProperties【Map<String, Object>】、
      systemEnvironment【Map<String, Object>】
4、postProcessBeanFactory(beanFactory);BeanFactory准备工作完成后进行的后置处理工作；
   1）、子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置
======================以上是BeanFactory的创建及预准备工作==================================
5、invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor的方法；
   BeanFactoryPostProcessor：BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的；
   两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
   1）、执行BeanFactoryPostProcessor的方法；
      先执行BeanDefinitionRegistryPostProcessor
      1）、获取所有的BeanDefinitionRegistryPostProcessor；
      2）、看先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor、
         postProcessor.postProcessBeanDefinitionRegistry(registry)
      3）、在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor；
         postProcessor.postProcessBeanDefinitionRegistry(registry)
      4）、最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors；
         postProcessor.postProcessBeanDefinitionRegistry(registry)
         
      
      再执行BeanFactoryPostProcessor的方法
      1）、获取所有的BeanFactoryPostProcessor
      2）、看先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor、
         postProcessor.postProcessBeanFactory()
      3）、在执行实现了Ordered顺序接口的BeanFactoryPostProcessor；
         postProcessor.postProcessBeanFactory()
      4）、最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor；
         postProcessor.postProcessBeanFactory()
6、registerBeanPostProcessors(beanFactory);注册BeanPostProcessor（Bean的后置处理器）【 intercept bean creation】
      不同接口类型的BeanPostProcessor；在Bean创建前后的执行时机是不一样的
      BeanPostProcessor、
      DestructionAwareBeanPostProcessor、
      InstantiationAwareBeanPostProcessor、
      SmartInstantiationAwareBeanPostProcessor、
      MergedBeanDefinitionPostProcessor【internalPostProcessors】、
      
      1）、获取所有的 BeanPostProcessor;后置处理器都默认可以通过PriorityOrdered、Ordered接口来执行优先级
      2）、先注册PriorityOrdered优先级接口的BeanPostProcessor；
         把每一个BeanPostProcessor；添加到BeanFactory中
         beanFactory.addBeanPostProcessor(postProcessor);
      3）、再注册Ordered接口的
      4）、最后注册没有实现任何优先级接口的
      5）、最终注册MergedBeanDefinitionPostProcessor；
      6）、注册一个ApplicationListenerDetector；来在Bean创建完成后检查是否是ApplicationListener，如果是
         applicationContext.addApplicationListener((ApplicationListener<?>) bean);
7、initMessageSource();初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
      1）、获取BeanFactory
      2）、看容器中是否有id为messageSource的，类型是MessageSource的组件
         如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；
            MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；
      3）、把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；
         beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);   
         MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);
8、initApplicationEventMulticaster();初始化事件派发器；
      1）、获取BeanFactory
      2）、从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；
      3）、如果上一步没有配置；创建一个SimpleApplicationEventMulticaster
      4）、将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入
9、onRefresh();留给子容器（子类）
      1、子类重写这个方法，在容器刷新的时候可以自定义逻辑；
10、registerListeners();给容器中将所有项目里面的ApplicationListener注册进来；
      1、从容器中拿到所有的ApplicationListener
      2、将每个监听器添加到事件派发器中；
         getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
      3、派发之前步骤产生的事件；
11、finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean；
   1、beanFactory.preInstantiateSingletons();初始化后剩下的单实例bean
      1）、获取容器中的所有Bean，依次进行初始化和创建对象
      2）、获取Bean的定义信息；RootBeanDefinition
      3）、Bean不是抽象的，是单实例的，是懒加载；
         1）、判断是否是FactoryBean；是否是实现FactoryBean接口的Bean；
         2）、不是工厂Bean。利用getBean(beanName);创建对象
            0、getBean(beanName)； ioc.getBean();
            1、doGetBean(name, null, null, false);
            2、先获取缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来）
               从private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);获取的
            3、缓存中获取不到，开始Bean的创建对象流程；
            4、标记当前bean已经被创建
            5、获取Bean的定义信息；
            6、【获取当前Bean依赖的其他Bean;如果有按照getBean()把依赖的Bean先创建出来；】
            7、启动单实例Bean的创建流程；
               1）、createBean(beanName, mbd, args);
               2）、Object bean = resolveBeforeInstantiation(beanName, mbdToUse);让BeanPostProcessor先拦截返回代理对象；
                  【InstantiationAwareBeanPostProcessor】：提前执行；
                  先触发：postProcessBeforeInstantiation()；
                  如果有返回值：触发postProcessAfterInitialization()；
               3）、如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象；调用4）
               4）、Object beanInstance = doCreateBean(beanName, mbdToUse, args);创建Bean
                   1）、【创建Bean实例】；createBeanInstance(beanName, mbd, args);
                     利用工厂方法或者对象的构造器创建出Bean实例；
                   2）、applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                     调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);
                   3）、【Bean属性赋值】populateBean(beanName, mbd, instanceWrapper);
                     赋值之前：
                     1）、拿到InstantiationAwareBeanPostProcessor后置处理器；
                        postProcessAfterInstantiation()；
                     2）、拿到InstantiationAwareBeanPostProcessor后置处理器；
                        postProcessPropertyValues()；
                     =====赋值之前：===
                     3）、应用Bean属性的值；为属性利用setter方法等进行赋值；
                        applyPropertyValues(beanName, mbd, bw, pvs);
                   4）、【Bean初始化】initializeBean(beanName, exposedObject, mbd);
                     1）、【执行Aware接口方法】invokeAwareMethods(beanName, bean);执行xxxAware接口的方法
                        BeanNameAware\BeanClassLoaderAware\BeanFactoryAware
                     2）、【执行后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
                        BeanPostProcessor.postProcessBeforeInitialization（）;
                     3）、【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
                        1）、是否是InitializingBean接口的实现；执行接口规定的初始化；
                        2）、是否自定义初始化方法；
                     4）、【执行后置处理器初始化之后】applyBeanPostProcessorsAfterInitialization
                        BeanPostProcessor.postProcessAfterInitialization()；
                   5）、注册Bean的销毁方法；
               5）、将创建的Bean添加到缓存中singletonObjects；
            ioc容器就是这些Map；很多的Map里面保存了单实例Bean，环境信息。。。。；
      所有Bean都利用getBean创建完成以后；
         检查所有的Bean是否是SmartInitializingSingleton接口的；如果是；就执行afterSingletonsInstantiated()；
12、finishRefresh();完成BeanFactory的初始化创建工作；IOC容器就创建完成；
      1）、initLifecycleProcessor();初始化和生命周期有关的后置处理器；LifecycleProcessor
         默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultLifecycleProcessor();
         加入到容器；
         
         写一个LifecycleProcessor的实现类，可以在BeanFactory
            void onRefresh();
            void onClose();    
      2）、    getLifecycleProcessor().onRefresh();
         拿到前面定义的生命周期处理器（BeanFactory）；回调onRefresh()；
      3）、publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件；
      4）、liveBeansView.registerApplicationContext(this);
   
   ======总结======
   1）、Spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息；
      1）、xml注册bean；<bean>
      2）、注解注册Bean；@Service、@Component、@Bean、xxx
   2）、Spring容器会合适的时机创建这些Bean
      1）、用到这个bean的时候；利用getBean创建bean；创建好以后保存在容器中；
      2）、统一创建剩下所有的bean的时候；finishBeanFactoryInitialization()；
   3）、后置处理器；BeanPostProcessor
      1）、每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能；
         AutowiredAnnotationBeanPostProcessor:处理自动注入
         AnnotationAwareAspectJAutoProxyCreator:来做AOP功能；
         xxx....
         增强的功能注解：
         AsyncAnnotationBeanPostProcessor
         ....
   4）、事件驱动模型；
      ApplicationListener；事件监听；
      ApplicationEventMulticaster；事件派发：

三、web

3.1 servlet3.0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Shared libraries（共享库） / runtimes pluggability（运行时插件能力）

1、Servlet容器启动会扫描，当前应用里面每一个jar包的
	ServletContainerInitializer的实现
2、提供ServletContainerInitializer的实现类；
	必须绑定在，META-INF/services/javax.servlet.ServletContainerInitializer
	文件的内容就是ServletContainerInitializer实现类的全类名；

总结：容器在启动应用的时候，会扫描当前应用每一个jar包里面
META-INF/services/javax.servlet.ServletContainerInitializer
指定的实现类，启动并运行这个实现类的方法；传入感兴趣的类型；


ServletContainerInitializer；
@HandlesTypes；
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
//容器启动的时候会将@HandlesTypes指定的这个类型下面的子类（实现类，子接口等）传递过来；
//传入感兴趣的类型；
@HandlesTypes(value={HelloService.class})
public class MyServletContainerInitializer implements ServletContainerInitializer {

   /**
    * 应用启动的时候，会运行onStartup方法；
    * 
    * Set<Class<?>> arg0：感兴趣的类型的所有子类型；
    * ServletContext arg1:代表当前Web应用的ServletContext；一个Web应用一个ServletContext；
    * 
    * 1）、使用ServletContext注册Web组件（Servlet、Filter、Listener）
    * 2）、使用编码的方式，在项目启动的时候给ServletContext里面添加组件；
    *        必须在项目启动的时候来添加；
    *        1）、ServletContainerInitializer得到的ServletContext；
    *        2）、ServletContextListener得到的ServletContext；
    */
   @Override
   public void onStartup(Set<Class<?>> arg0, ServletContext sc) throws ServletException {
      System.out.println("感兴趣的类型：");
      for (Class<?> claz : arg0) {
         System.out.println(claz);
      }
      
      //注册组件  ServletRegistration  
      ServletRegistration.Dynamic servlet = sc.addServlet("userServlet", new UserServlet());
      //配置servlet的映射信息
      servlet.addMapping("/user");
      
      
      //注册Listener
      sc.addListener(UserListener.class);
      
      //注册Filter  FilterRegistration
      FilterRegistration.Dynamic filter = sc.addFilter("userFilter", UserFilter.class);
      //配置Filter的映射信息
      filter.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), true, "/*");
   }
}

SpringMVC

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
1、web容器在启动的时候，会扫描每个jar包下的META-INF/services/javax.servlet.ServletContainerInitializer
2、加载这个文件指定的类SpringServletContainerInitializer
3、spring的应用一启动会加载感兴趣的WebApplicationInitializer接口的下的所有组件；
4、并且为WebApplicationInitializer组件创建对象（组件不是接口，不是抽象类）
   1）、AbstractContextLoaderInitializer：创建根容器；createRootApplicationContext()；
   2）、AbstractDispatcherServletInitializer：
         创建一个web的ioc容器；createServletApplicationContext();
         创建了DispatcherServlet；createDispatcherServlet()；
         将创建的DispatcherServlet添加到ServletContext中；
            getServletMappings();
   3）、AbstractAnnotationConfigDispatcherServletInitializer：注解方式配置的DispatcherServlet初始化器
         创建根容器：createRootApplicationContext()
               getRootConfigClasses();传入一个配置类
         创建web的ioc容器： createServletApplicationContext();
               获取配置类；getServletConfigClasses();
   
总结：
   以注解方式来启动SpringMVC；继承AbstractAnnotationConfigDispatcherServletInitializer；
实现抽象方法指定DispatcherServlet的配置信息；

===========================
定制SpringMVC；
1）、@EnableWebMvc:开启SpringMVC定制配置功能；
   <mvc:annotation-driven/>；

2）、配置组件（视图解析器、视图映射、静态资源映射、拦截器。。。）
   extends WebMvcConfigurerAdapter
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//web容器启动的时候创建对象；调用方法来初始化容器以前前端控制器
public class MyWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

   //获取根容器的配置类；（Spring的配置文件）   父容器；
   @Override
   protected Class<?>[] getRootConfigClasses() {
      return new Class<?>[]{RootConfig.class};
   }

   //获取web容器的配置类（SpringMVC配置文件）  子容器；
   @Override
   protected Class<?>[] getServletConfigClasses() {
      return new Class<?>[]{AppConfig.class};
   }

   //获取DispatcherServlet的映射信息
   //  /：拦截所有请求（包括静态资源（xx.js,xx.png）），但是不包括*.jsp；
   //  /*：拦截所有请求；连*.jsp页面都拦截；jsp页面是tomcat的jsp引擎解析的；
   @Override
   protected String[] getServletMappings() {
      return new String[]{"/"};
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
package com.atguigu.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

//Spring的容器不扫描controller;父容器
@ComponentScan(value = "com.atguigu", excludeFilters = {
    @Filter(type = FilterType.ANNOTATION, classes = {Controller.class})
})
public class RootConfig {
}
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
package com.atguigu.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import com.atguigu.controller.MyFirstInterceptor;

//SpringMVC只扫描Controller；子容器
//useDefaultFilters=false 禁用默认的过滤规则；
@ComponentScan(value = "com.atguigu", includeFilters = {
    @Filter(type = FilterType.ANNOTATION, classes = {Controller.class})
}, useDefaultFilters = false)
@EnableWebMvc
public class AppConfig extends WebMvcConfigurerAdapter {
    //定制
    //视图解析器
    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        //默认所有的页面都从 /WEB-INF/ xxx .jsp
        //registry.jsp();
        registry.jsp("/WEB-INF/views/", ".jsp");
    }

    //静态资源访问
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    //拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //super.addInterceptors(registry);
        registry.addInterceptor(new MyFirstInterceptor()).addPathPatterns("/**");
    }
}
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
package com.atguigu.controller;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.atguigu.service.HelloService;

@Controller
public class HelloController {

    @Autowired
    HelloService helloService;

    @ResponseBody
    @RequestMapping("/hello")
    public String hello() {
        String hello = helloService.sayHello("tomcat..");
        return hello;
    }

    //  /WEB-INF/views/success.jsp
    @RequestMapping("/suc")
    public String success() {
        return "success";
    }
}
1
2
3
4
5
6
7
8
9
10
package com.atguigu.service;

import org.springframework.stereotype.Service;

@Service
public class HelloService {
    public String sayHello(String name) {
        return "Hello " + name;
    }
}
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
package com.atguigu.controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public class MyFirstInterceptor implements HandlerInterceptor {

   //目标方法运行之前执行
   @Override
   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
         throws Exception {
      System.out.println("preHandle..."+request.getRequestURI());
      return true;
   }

   //目标方法执行正确以后执行
   @Override
   public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
         ModelAndView modelAndView) throws Exception {
      System.out.println("postHandle...");

   }

   //页面响应以后执行
   @Override
   public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
         throws Exception {
      System.out.println("afterCompletion...");
   }
}

3.2 异步请求

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
package com.atguigu.controller;

import java.util.UUID;
import java.util.concurrent.Callable;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.context.request.async.DeferredResult;

import com.atguigu.service.DeferredResultQueue;


@Controller
public class AsyncController {
   
   @ResponseBody
   @RequestMapping("/createOrder")
   public DeferredResult<Object> createOrder(){
      DeferredResult<Object> deferredResult = new DeferredResult<>((long)3000, "create fail...");
         
      DeferredResultQueue.save(deferredResult);
      
      return deferredResult;
   }
   
   @ResponseBody
   @RequestMapping("/create")
   public String create(){
      //创建订单
      String order = UUID.randomUUID().toString();
      DeferredResult<Object> deferredResult = DeferredResultQueue.get();
      deferredResult.setResult(order);
      return "success===>"+order;
   }
   
   /**
    * 1、控制器返回Callable
    * 2、Spring异步处理，将Callable 提交到 TaskExecutor 使用一个隔离的线程进行执行
    * 3、DispatcherServlet和所有的Filter退出web容器的线程，但是response 保持打开状态；
    * 4、Callable返回结果，SpringMVC将请求重新派发给容器，恢复之前的处理；
    * 5、根据Callable返回的结果。SpringMVC继续进行视图渲染流程等（从收请求-视图渲染）。
    * 
    * preHandle.../springmvc-annotation/async01
      主线程开始...Thread[http-bio-8081-exec-3,5,main]==>1513932494700
      主线程结束...Thread[http-bio-8081-exec-3,5,main]==>1513932494700
      =========DispatcherServlet及所有的Filter退出线程============================
      
      ================等待Callable执行==========
      副线程开始...Thread[MvcAsync1,5,main]==>1513932494707
      副线程开始...Thread[MvcAsync1,5,main]==>1513932496708
      ================Callable执行完成==========
      
      ================再次收到之前重发过来的请求========
      preHandle.../springmvc-annotation/async01
      postHandle...（Callable的之前的返回值就是目标方法的返回值）
      afterCompletion...
      
      异步的拦截器:
         1）、原生API的AsyncListener
         2）、SpringMVC：实现AsyncHandlerInterceptor；
    * @return
    */
   @ResponseBody
   @RequestMapping("/async01")
   public Callable<String> async01(){
      System.out.println("主线程开始..."+Thread.currentThread()+"==>"+System.currentTimeMillis());
      
      Callable<String> callable = new Callable<String>() {
         @Override
         public String call() throws Exception {
            System.out.println("副线程开始..."+Thread.currentThread()+"==>"+System.currentTimeMillis());
            Thread.sleep(2000);
            System.out.println("副线程开始..."+Thread.currentThread()+"==>"+System.currentTimeMillis());
            return "Callable<String> async01()";
         }
      };
      
      System.out.println("主线程结束..."+Thread.currentThread()+"==>"+System.currentTimeMillis());
      return callable;
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.atguigu.service;

import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

import org.springframework.web.context.request.async.DeferredResult;

public class DeferredResultQueue {
   
   private static Queue<DeferredResult<Object>> queue = new ConcurrentLinkedQueue<DeferredResult<Object>>();
   
   public static void save(DeferredResult<Object> deferredResult){
      queue.add(deferredResult);
   }
   
   public static DeferredResult<Object> get( ){
      return queue.poll();
   }
}

<学习自尚硅谷雷神>

赏

Thanks

支付宝
微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

CodeMing，<br>就学于河南大学软件学院<br><br>目前单身未婚<br/>理想大厂搬砖<br/><br/>'敢于认错，知错不改'<br>文能提笔安天下，武能上'码'定乾坤。