spring 注解驱动

目录

• 起步：
  • xml方式：
  • 注解方式：
• 配置类：
  • Config:
• 自动装配
  • @Autowired
  • @Resource
  • @Inject
  • 自动装配原理：
• 导入 bean:
  • @Conditional
  • @Import
  • @Bean
  • @Lazy
  • @Scope
  • @PropertySource
  • @Profile
• bean的生命周期
  • bean的生命周期：
  • BeanPostProcessor原理
  • 初始化和销毁通知：
  • 获取容器：
• 动态代理AOP:
  • 搭建步骤：
  • 小结：
  • 流程：
• 声明式事务
  • 环境搭建：
  • ☆@Transactional原理
  • 原理话语版：
• 扩展原理：
  • 后置处理器：
  • 原理：
  • 监听：
  • 原理：
• ☆Spring容器刷新原理:
• Servlet3.0:
• springmvc:

 

正文

spring注解版：

回到顶部

起步：

xml方式：

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>

    <groupId>org.tuniu</groupId>
    <artifactId>spring-annotation</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--spring 的核心配置包-->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>
        <!--spring 的核心配置包-->

    </dependencies>

</project>

Bean：

public class Person {
    private String name;
    private Integer age;
    private String nickName;

    public Person() {
    }

    public Person(String name, Integer age, String nickName) {
        this.name = name;
        this.age = age;
        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 String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <!--配置文件配置 bean-->
    <bean id="person" class="org.tuniu.demo.test1.mybean.Person">
        <property name="name" value="张三"></property>
        <property name="age" value="12"></property>
    </bean>
</beans>

Maintest:

package org.tuniu.demo.test1;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.tuniu.demo.test1.conf.MainConfig;
import org.tuniu.demo.test1.mybean.Person;

public class MainTest {
    public static void main(String[] args) {
        //读取配置文件加载容器
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/bean.xml");
        //从容器中获取 bean
        Person person = (Person) applicationContext.getBean("person");
        System.out.println(person);
    }
}

注解方式：

Config:

package org.tuniu.demo.test1.conf;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.tuniu.demo.test1.mybean.Person;

//配置类==配置文件
@Configuration
public class MainConfig {//告诉Spring这是一个配置类

    //给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
    @Bean
    public Person person01(){
        return new Person("李四",21,"2b");
    }
}

Maintest:

package org.tuniu.demo.test1;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.tuniu.demo.test1.conf.MainConfig;
import org.tuniu.demo.test1.mybean.Person;

public class MainTest {
    public static void main(String[] args) {
        //通过注解的方式获取 bean
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
        Person person01 = (Person) annotationConfigApplicationContext.getBean("person01");
        System.out.println(person01);
    }
}

回到顶部

配置类：

Config:

package org.tuniu.demo.test1.conf;

import org.springframework.context.annotation.*;
import org.tuniu.demo.test1.mybean.Person;

//配置类==配置文件
@Configuration
//@ComponentScan(value = "org.tuniu")
@ComponentScans(
        value = {
                @ComponentScan(value = "org.tuniu", includeFilters = {
/*                @Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
                  @Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),*/
                        @ComponentScan.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：使用自定义规则
public class MainConfig1 {//告诉Spring这是一个配置类

    //给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
    @Bean
    public Person person01() {
        return new Person("李四", 21, "2b");
    }
}

扫描过滤器：
MyTypeFilter

package org.tuniu.demo.test1.conf;

import org.springframework.core.io.Resource;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;

import java.io.IOException;

/**
 * 自定义一个扫描注解的过滤器
 * 如果类名称包含了 er 字符,才扫描注入
 */
public class MyTypeFilter implements TypeFilter {
    /**
     * metadataReader：读取到的当前正在扫描的类的信息
     * metadataReaderFactory:可以获取到其他任何类信息的
     */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        //获取当前类注解的信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        System.out.println(annotationMetadata);
        //获取当前正在扫描的类的类信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        System.out.println(classMetadata);
        //获取当前类资源（类的路径）
        Resource resource = metadataReader.getResource();
        System.out.println(resource);
        String className = classMetadata.getClassName();
        System.out.println("--->"+className);
        //如果类名称包含了 er 字符,才扫描注入
        if(className.contains("er")){
            return true;
        }
        return false;
    }
}

回到顶部

自动装配

@Autowired

自动装配;
Spring利用依赖注入（DI），完成对IOC容器中中各个组件的依赖关系赋值；

1）、@Autowired：自动注入：
1）、默认优先按照类型去容器中找对应的组件:找到就赋值;同applicationContext.getBean(BookDao.class);
2）、如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找
同applicationContext.getBean("bookDao")
3）、@Qualifier("bookDao")：使用@Qualifier指定需要装配的组件的id，而不是使用属性名
4）、自动装配默认一定要有 bean ，没有就会报错；可以使用@Autowired(required=false);来解决
5）、@Primary：让Spring进行自动装配的时候，默认使用首选的bean；
也可以继续使用@Qualifier指定需要装配的bean的名字
BookService{
@Autowired
BookDao bookDao;
}

@Resource

2）、Spring还支持使用@Resource(JSR250)和@Inject(JSR330)[java规范的注解]
@Resource:
可以和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的；
不能支持@Primary功能；

​ 不能支持@Autowired(reqiured=false)

@Inject

​ @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（实现他的功能，但不是实现类）；

默认加在ioc容器中的组件，容器启动会调用无参构造器创建对象，再进行初始化赋值等操作

//默认加在ioc容器中的组件，容器启动会调用无参构造器创建对象，再进行初始化赋值等操作
@Component
public class Boss {
   private Car car;
   
   //构造器要用的组件，都是从容器中获取
   public Boss(Car car){
      this.car = car;
      System.out.println("Boss...有参构造器");
   }

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

}

@Repository
@Controller
@Service
//bean的名字默认是类名首字母小写

回到顶部

导入 bean:

package org.tuniu.demo.test3.conf;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.*;
import org.tuniu.demo.test3.mybean.*;
import org.tuniu.demo.test3.mycondition.*;

//类中组件统一设置。满足当前条件，这个类中配置的所有bean注册才能生效；
@Conditional({WindowsCondition.class})
@Configuration
@Import({Color.class, Red.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
//@Import导入组件，id默认是组件的全类名
public class MainConfig2 {
//默认是单实例的
    /**
     * ConfigurableBeanFactory#SCOPE_PROTOTYPE
     * @see ConfigurableBeanFactory#SCOPE_SINGLETON
     * @see org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST  request
     * @see org.springframework.web.context.WebApplicationContext#SCOPE_SESSION     sesssion
     * @return\
     * @Scope:调整作用域
     * prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。
     *                 每次获取的时候才会调用方法创建对象；
     * singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。
     *           以后每次获取就是直接从容器（map.get()）中拿，
     * request：同一次请求创建一个实例
     * session：同一个session创建一个实例
     *
     * 懒加载：
     *        单实例bean：默认在容器启动的时候创建对象；
     *        懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；
     *
     */
// @Scope("prototype")
    @Lazy
    @Bean("person")
    public Person person(){
        System.out.println("给容器中添加Person....");
        return new Person("张三", 25);
    }

    /**
     * @Conditional({Condition}) ： 按照一定的条件进行判断，满足条件给容器中注册bean
     *
     * 如果系统是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）、包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类]
     * 2）、@Bean[导入的第三方包里面的组件]
     * 3）、@Import[快速给容器中导入一个组件]
     *        1）、@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名
     *        2）、ImportSelector:返回需要导入的组件的全类名数组；
     *        3）、ImportBeanDefinitionRegistrar:手动注册bean到容器中
     * 4）、使用Spring提供的 FactoryBean（工厂Bean）;
     *        1）、默认获取到的是工厂bean调用getObject创建的对象
     *        2）、要获取工厂Bean本身，我们需要给id前面加一个&
     *           &colorFactoryBean
     */
    @Bean
    public ColorFactoryBean colorFactoryBean(){
        return new ColorFactoryBean();
    }

}

@Conditional

//类中组件统一设置。满足当前条件，这个类中配置的所有bean注册才能生效；
@Conditional({WindowsCondition.class})

//判断是否windows系统
public class WindowsCondition implements Condition {

	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		Environment environment = context.getEnvironment();
		String property = environment.getProperty("os.name");
		if(property.contains("Windows")){
			return false;
		}
		return true;
	}
}

@Import

@Import导入组件，id默认是组件的全类名

//@Import导入组件，id默认是组件的全类名
@Import({Color.class, Red.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class})
org.tuniu.demo.test3.mybean.Color

package org.tuniu.demo.test3.mycondition;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector {

   //返回值，就是到导入到容器中的组件全类名
   //AnnotationMetadata:当前标注@Import注解的类的所有注解信息
   @Override
   public String[] selectImports(AnnotationMetadata importingClassMetadata) {
      // TODO Auto-generated method stub
      //importingClassMetadata
      //方法不要返回null值
      return new String[]{"org.tuniu.demo.test3.mybean.Blue","org.tuniu.demo.test3.mybean.Yellow"};
   }
}

package org.tuniu.demo.test3.mycondition;

import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
import org.tuniu.demo.test2.mybean.RainBow;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

   /**
    * AnnotationMetadata：当前类的注解信息
    * BeanDefinitionRegistry:BeanDefinition注册类；
    *        把所有需要添加到容器中的bean；调用
    *        BeanDefinitionRegistry.registerBeanDefinition手工注册进来
    */
   @Override
   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
      
      boolean definition = registry.containsBeanDefinition("org.tuniu.demo.test3.mybean.Red");
      boolean definition2 = registry.containsBeanDefinition("org.tuniu.demo.test3.mybean.Blue");
      if(definition && definition2){
         //指定Bean定义信息；（Bean的类型，Bean。。。）
         RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
         //注册一个Bean，指定bean名
         registry.registerBeanDefinition("rainBow", beanDefinition);
      }
   }
}

@Bean

默认是bean 是方法名

@Lazy

懒加载：

​ 单实例bean：默认在容器启动的时候创建对象；

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

@Lazy
@Bean("person")
public Person person(){
    System.out.println("给容器中添加Person....");
    return new Person("张三", 25);
}
Object bean = applicationContext.getBean("person");//此时才会创建

@Scope

prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。
每次获取的时候才会调用方法创建对象；
singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。
以后每次获取就是直接从容器（map.get()）中拿，
request：同一次请求创建一个实例
session：同一个session创建一个实例

@PropertySource

扫描配置文件

//使用@PropertySource读取外部配置文件中的k/v保存到运行的环境变量中;加载完外部的配置文件以后使用${}取出配置文件的值

package org.tuniu.demo.test4.conf;


import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.EmbeddedValueResolverAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.context.annotation.PropertySource;
import org.springframework.util.StringValueResolver;
import org.tuniu.demo.test4.mybean.Yellow;

import javax.sql.DataSource;

/**
 * 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}");
   }

}

@Profile

@Profile("test")//代表 test 环境

回到顶部

bean的生命周期

bean的生命周期：

​ bean创建---初始化----销毁的过程
容器管理bean的生命周期；
我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法

构造（对象创建）
单实例：在容器启动的时候创建对象
多实例：在每次获取的时候创建对象

BeanPostProcessor.postProcessBeforeInitialization
初始化：
对象创建完成，并赋值好，调用初始化方法。。。
BeanPostProcessor.postProcessAfterInitialization
销毁：
单实例：容器关闭的时候
多实例：容器不会管理这个bean；容器不会调用销毁方法；

遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization

BeanPostProcessor原理

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;

public class Car {

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

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

package org.tuniu.demo.test5.mybean;

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

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@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;
   }
}

/**
 * InitializingBean初始化前方法接口
 * DisposableBean销毁后方法接口
 */
public class Color implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("color..init..");
    }

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

package org.tuniu.demo.test5.conf;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.tuniu.demo.test5.mybean.Car;

/**
 * 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("org.tuniu.demo.test5")
@Configuration
public class MainConfigOfLifeCycle {
    //@Scope("prototype")
    @Bean(initMethod="init",destroyMethod="detory")
    public Car car(){
        return new Car();
    }

    @Bean
    public Color color(){
        return new Color();
    }
  
    @Bean
    public Dog dog(){
        return new Dog();
    }
}

获取容器：

实现ApplicationContextAware接口；

package org.tuniu.demo.test3.mybean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.EmbeddedValueResolverAware;
import org.springframework.stereotype.Component;
import org.springframework.util.StringValueResolver;

@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);
   }
}

回到顶部

动态代理AOP:

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

搭建步骤：

1、导入aop模块；Spring AOP：(spring-aspects)

        <!--aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>

2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx）

package org.tuniu.demo.test6.aop;

/**
 * 计算器-减法运算
 */
public class MathCalculator {
   
   public int div(int i,int j){
      System.out.println("MathCalculator...div...");
      return i/j;    
   }
}

3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知 MathCalculator.div() 运行到哪里然后执行；

通知方法：
前置通知(@Before)：logStart：在目标方法(div)运行之前运行
后置通知(@After)：logEnd：在目标方法(div)运行结束之后运行（无论方法正常结束还是异常结束）
返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行
异常通知(@AfterThrowing)：logException：在目标方法(div)出现异常以后运行
环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）

4、给切面类的目标方法标注何时何地运行（通知注解）；

5、必须告诉Spring哪个类是切面类(给切面类上加一个注解：@Aspect)

package org.tuniu.demo.test6.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;

import java.util.Arrays;

/**
 * 日志切面类
 *
 * @Aspect 告诉Spring当前类是一个切面类
 */
@Aspect
public class LogAspects {
    //抽取公共的切入点表达式
    //1、本类引用
    //2、其他的切面引用
    @Pointcut("execution(public int org.tuniu.demo.test6.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("org.tuniu.demo.test6.aop.LogAspects.pointCut()")
    public void logEnd(JoinPoint joinPoint) {
        System.out.println("" + joinPoint.getSignature().getName() + "结束。。。@After");
    }

    @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 + "}");
    }
}

6、将切面类和业务逻辑类（目标方法所在类）都加入到容器中;

[7]、给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】
在Spring中很多的 @EnableXXX;

package org.tuniu.demo.test6.conf;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.tuniu.demo.test6.aop.LogAspects;
import org.tuniu.demo.test6.aop.MathCalculator;

@EnableAspectJAutoProxy
@Configuration
public class MainConfigOfAOP {

    //业务逻辑类加入容器中
    @Bean
    public MathCalculator calculator() {
        return new MathCalculator();
    }

    //切面类加入到容器中
    @Bean
    public LogAspects logAspects() {
        return new LogAspects();
    }
}

小结：

三步：
1）、将业务逻辑组件和切面类都加入到容器中；告诉Spring哪个是切面类（@Aspect）
2）、在切面类上的每一个通知方法上标注通知注解，告诉Spring何时何地运行（切入点表达式）
3）、开启基于注解的aop模式；@EnableAspectJAutoProxy

AOP原理：【看给容器中注册了什么组件，这个组件什么时候工作，这个组件的功能是什么？】
@EnableAspectJAutoProxy；
1、@EnableAspectJAutoProxy是什么？
@Import(AspectJAutoProxyRegistrar.class)：给容器中导入AspectJAutoProxyRegistrar
利用AspectJAutoProxyRegistrar自定义给容器中注册bean；BeanDefinetion
internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator

​ 给容器中注册一个AnnotationAwareAspectJAutoProxyCreator；

2、 AnnotationAwareAspectJAutoProxyCreator：
AnnotationAwareAspectJAutoProxyCreator
->AspectJAwareAdvisorAutoProxyCreator
->AbstractAdvisorAutoProxyCreator
->AbstractAutoProxyCreator
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
关注后置处理器（在bean初始化完成前后做事情）、自动装配BeanFactory

AbstractAutoProxyCreator.setBeanFactory()
AbstractAutoProxyCreator.有后置处理器的逻辑；

AbstractAdvisorAutoProxyCreator.setBeanFactory()-》initBeanFactory()

AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()

流程：

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；
         1. invokeAwareMethods()：处理Aware接口的方法回调
         2. applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization()
         3. invokeInitMethods()；执行自定义的初始化方法
         4. applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization()
      4. BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；--》aspectJAdvisorsBuilder
   7. 把BeanPostProcessor注册到BeanFactory中；beanFactory.addBeanPostProcessor(postProcessor);

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

   AnnotationAwareAspectJAutoProxyCreator => InstantiationAwareBeanPostProcessor

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实例之前先尝试用后置处理器返回对象的】

         1. resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation，希望后置处理器在此能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续

            后置处理器先尝试返回对象；bean = applyBeanPostProcessorsBeforeInstantiation(); 拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor;就执行postProcessBeforeInstantiation

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

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

AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】的作用：

1. 每一个bean创建之前，调用postProcessBeforeInstantiation()；关心MathCalculator和LogAspect的创建(只需要关心 aop 类和代理类的创建)

   1. 判断当前bean是否在advisedBeans中（保存了所有需要增强bean）
   2. 判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，或者是否是切面（@Aspect）
   3. 是否需要跳过
      1. 获取候选的增强器（切面里面的通知方法）【List candidateAdvisors】，每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor；判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true
      2. 否者永远返回false

2. 创建对象

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

   1. 筛选bean能用的增强器
      1. 获取当前bean的所有增强器（通知方法） Object[] specificInterceptors
      2. 获取到能在bean使用的增强器。
      3. 给增强器排序
   2. 保存当前bean在advisedBeans中；
   3. 如果当前bean需要增强，创建当前bean的代理对象；
      1. 获取所有增强器（通知方法）
      2. 保存到proxyFactory
      3. 创建代理对象：Spring自动决定
         1. JdkDynamicAopProxy(config);jdk动态代理；
         2. ObjenesisCglibAopProxy(config);cglib的动态代理；
   4. 给容器中返回当前组件使用cglib增强了的代理对象；
   5. 以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；

3. 目标方法执行

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

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

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

      1. List