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()
流程：
-
传入配置类，创建ioc容器
-
注册配置类，调用refresh（）刷新容器；
-
registerBeanPostProcessors(beanFactory);注册bean的后置处理器来方便拦截bean的创建；
- 先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor
- 给容器中加别的BeanPostProcessor
- 优先注册实现了PriorityOrdered接口的BeanPostProcessor；
- 再给容器中注册实现了Ordered接口的BeanPostProcessor；
- 注册没实现优先级接口的BeanPostProcessor；
- 注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】
- 创建Bean的实例
- populateBean；给bean的各种属性赋值
- initializeBean：初始化bean；
- invokeAwareMethods()：处理Aware接口的方法回调
- applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization()
- invokeInitMethods()；执行自定义的初始化方法
- applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization()
- BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；--》aspectJAdvisorsBuilder
- 把BeanPostProcessor注册到BeanFactory中；beanFactory.addBeanPostProcessor(postProcessor);
=以上是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程==
AnnotationAwareAspectJAutoProxyCreator => InstantiationAwareBeanPostProcessor
-
finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；创建剩下的单实例bean
-
遍历获取容器中所有的Bean，依次创建对象getBean(beanName);getBean->doGetBean()->getSingleton()->
-
创建bean,【AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截, InstantiationAwareBeanPostProcessor，会调用postProcessBeforeInstantiation()】
-
先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；只要创建好的Bean都会被缓存起来
-
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】的作用：
-
每一个bean创建之前，调用postProcessBeforeInstantiation()；关心MathCalculator和LogAspect的创建(只需要关心 aop 类和代理类的创建)
- 判断当前bean是否在advisedBeans中（保存了所有需要增强bean）
- 判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，或者是否是切面（@Aspect）
- 是否需要跳过
- 获取候选的增强器（切面里面的通知方法）【List
candidateAdvisors】，每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor；判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true - 否者永远返回false
- 获取候选的增强器（切面里面的通知方法）【List
-
创建对象
postProcessAfterInitialization；return wrapIfNecessary(bean, beanName, cacheKey);//包装如果需要的情况下
- 筛选bean能用的增强器
- 获取当前bean的所有增强器（通知方法） Object[] specificInterceptors
- 获取到能在bean使用的增强器。
- 给增强器排序
- 保存当前bean在advisedBeans中；
- 如果当前bean需要增强，创建当前bean的代理对象；
- 获取所有增强器（通知方法）
- 保存到proxyFactory
- 创建代理对象：Spring自动决定
- JdkDynamicAopProxy(config);jdk动态代理；
- ObjenesisCglibAopProxy(config);cglib的动态代理；
- 给容器中返回当前组件使用cglib增强了的代理对象；
- 以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；
- 筛选bean能用的增强器
-
目标方法执行
容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）；
-
CglibAopProxy.intercept();拦截目标方法的执行
-
根据ProxyFactory对象获取将要执行的目标方法拦截器链；
-
List
-
遍历所有的增强器，将其转为Interceptor；-> registry.getInterceptors(advisor);
-
将增强器转为List
； -> 如果是MethodInterceptor，直接加入到集合中
-> 如果不是，使用AdvisorAdapter将增强器转为MethodInterceptor；
-> 转换完成返回MethodInterceptor数组；
-
-
如果没有拦截器链，直接执行目标方法;拦截器链（每一个通知方法又被包装为方法拦截器，利用MethodInterceptor机制）
-
如果有拦截器链，把需要执行的目标对象，目标方法，拦截器链等信息传入创建一个 CglibMethodInvocation 对象，并调用 Object retVal = mi.proceed();
-
拦截器链的触发过程;
- 如果没有拦截器执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法；
- 链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；拦截器链的机制，保证通知方法与目标方法的执行顺序；拦截器链执行底层是使用 try-cache-finally 来完成的
-
总结AOP：
-
@EnableAspectJAutoProxy 开启AOP功能
-
@EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator,他是后置处理器
-
容器的创建流程：
-
registerBeanPostProcessors() 注册后置处理器；创建AnnotationAwareAspectJAutoProxyCreator对象
-
finishBeanFactoryInitialization（）初始化剩下的单实例bean
-
创建业务逻辑组件和切面组件bean
-
AnnotationAwareAspectJAutoProxyCreator 拦截组件的创建过程
-
组件创建完之后，判断组件是否需要增强;增强器使用 porintCat() 来匹配
是：切面的通知方法，包装成增强器（Advisor）并给业务逻辑组件创建一个代理对象（cglib）；
-
-
-
执行目标方法：
- 代理对象执行目标方法
- CglibAopProxy.intercept()；执行拦截器
- 得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）
- 利用拦截器的链式机制，依次进入每一个拦截器进行执行；拦截器链执行底层是使用 try-cache-finally 来完成的
- 效果：
- 正常执行：前置通知-》目标方法-》后置通知-》返回通知
- 出现异常：前置通知-》目标方法-》后置通知-》异常通知
☆aop 原理话语版：
主要是依靠动态代理和拦截器机制
加入开启 aop 注解后，会给容器中加一个后置处理器，那个后置处理器能在 bean 初始化前后进行执行，在 bean 创建后，通过 切面方法判断是否需要增强，如果要增强，则将定义的切面方法包装成增强器，并通过 cglib 创建一个代理对象放入容器中，该代理对象中包含了增强器，以后容器中的对象就是增强后的对象；在bean执行目标方法时，使用的是代理对象，代理对象就会执行通知方法的流程；
目标方法执行时，CglibAopProxy 能拦截到目标方法的执行，从代理对象中获取到拦截器链，如果没有拦截器链，直接执行目标方法;如果有就遍历所有的增强器，将其转为Interceptor；并将目标对象，目标方法，拦截器链合并创建一个对象 CglibMethodInvocation;
该对象执行自身的方法proceed()来执行拦截器链和目标方法；拦截器链执行底层是使用 try-cache-finally；
声明式事务
环境搭建：
1、导入相关依赖：数据源、数据库驱动、Spring-jdbc模块
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.3.12.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/c3p0/c3p0 -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.44</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>4.3.14.RELEASE</version>
</dependency>
2、配置数据源、JdbcTemplate（Spring提供的简化数据库操作的工具）操作数据
3、给方法上标注 @Transactional 表示当前方法是一个事务方法；
4、@EnableTransactionManagement 开启基于注解的事务管理功能；
5、配置事务管理器来控制事务;PlatformTransactionManager
conf:
package org.tuniu.demo.test7.conf;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.sql.DataSource;
import java.beans.PropertyVetoException;
/**
* 声明式事务：
*
* 环境搭建：
* 1、导入相关依赖
* 数据源、数据库驱动、Spring-jdbc模块
* 2、配置数据源、JdbcTemplate（Spring提供的简化数据库操作的工具）操作数据
* 3、给方法上标注 @Transactional 表示当前方法是一个事务方法；
* 4、 @EnableTransactionManagement 开启基于注解的事务管理功能；
* @EnableXXX
* 5、配置事务管理器来控制事务;
* @Bean
* public PlatformTransactionManager transactionManager()
*
*
* 原理：
* 1）、@EnableTransactionManagement
* 利用TransactionManagementConfigurationSelector给容器中会导入组件
* 导入两个组件
* AutoProxyRegistrar
* ProxyTransactionManagementConfiguration
* 2）、AutoProxyRegistrar：
* 给容器中注册一个 InfrastructureAdvisorAutoProxyCreator 组件；
* InfrastructureAdvisorAutoProxyCreator：？
* 利用后置处理器机制在对象创建以后，包装对象，返回一个代理对象（增强器），代理对象执行方法利用拦截器链进行调用；
*
* 3）、ProxyTransactionManagementConfiguration 做了什么？
* 1、给容器中注册事务增强器；
* 1）、事务增强器要用事务注解的信息，AnnotationTransactionAttributeSource解析事务注解
* 2）、事务拦截器：
* TransactionInterceptor；保存了事务属性信息，事务管理器；
* 他是一个 MethodInterceptor；
* 在目标方法执行的时候；
* 执行拦截器链；
* 事务拦截器：
* 1）、先获取事务相关的属性
* 2）、再获取PlatformTransactionManager，如果事先没有添加指定任何transactionmanger
* 最终会从容器中按照类型获取一个PlatformTransactionManager；
* 3）、执行目标方法
* 如果异常，获取到事务管理器，利用事务管理回滚操作；
* 如果正常，利用事务管理器，提交事务
*
*/
@EnableTransactionManagement
@Configuration
@ComponentScan(value = "org.tuniu.demo.test7")
public class TxConf {
@Value("${name}")
private String name;
@Value("${password}")
private String password;
@Value("${url}")
private String url;
//数据源
@Bean
public DataSource dataSource() throws PropertyVetoException {
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setUser(name);
dataSource.setPassword(password);
dataSource.setDriverClass("com.mysql.jdbc.Driver");
dataSource.setJdbcUrl(url);
return dataSource;
}
@Bean
public JdbcTemplate jdbcTemplate() throws PropertyVetoException {
//Spring对 @Configuration 类会特殊处理；给容器中加组件的方法，多次调用都只是从容器中找组件
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource());
return jdbcTemplate;
}
//注册事务管理器在容器中
@Bean
public PlatformTransactionManager transformerManager(DataSource dataSource){
return new DataSourceTransactionManager(dataSource);
}
}
Service:
package org.tuniu.demo.test7.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.tuniu.demo.test7.dao.UserDao;
@Service
public class UserService {
@Autowired
UserDao userDao;
@Transactional
public void insertUser(){
userDao.insert();
//otherDao.other();xxx
System.out.println("插入完成...");
// int i = 10/0;
}
}
Dao:
package org.tuniu.demo.test7.dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.util.UUID;
@Repository
public class UserDao {
@Autowired
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);
}
}
Test:
package org.tuniu.test2;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.tuniu.demo.test7.conf.TxConf;
import org.tuniu.demo.test7.service.UserService;
public class TestConf7 {
@Test
public void add(){
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(TxConf.class);
UserService userService = (UserService) applicationContext.getBean("userService");
userService.insertUser();
}
}
☆@Transactional原理
-
@EnableTransactionManagement注解利用TransactionManagementConfigurationSelector给容器中会导入了两个组件AutoProxyRegistrar，ProxyTransactionManagementConfiguration
-
AutoProxyRegistrar：
- 给容器中注册一个 InfrastructureAdvisorAutoProxyCreator 组件；利用后置处理器机制在对象创建以后，包装对象，返回一个代理对象（增强器），代理对象执行方法利用拦截器链进行调用；
-
ProxyTransactionManagementConfiguration做了什么：
- 给容器中注册事务增强器；
- 事务增强器要用事务注解的信息，AnnotationTransactionAttributeSource 帮助解析事务注解
- 事务拦截器：TransactionInterceptor；保存了事务属性信息，事务管理器；他是一个 MethodInterceptor 方法拦截器；
- 在目标方法执行的时候；执行拦截器链；
- 事务拦截器：
- 先获取事务相关的属性
- 再获取 PlatformTransactionManager，如果事先没有添加指定任何 transactionmanger 最终会从容器中按照类型获取一个PlatformTransactionManager；
- 执行目标方法
- 如果异常，获取到事务管理器，利用事务管理回滚操作；
- 如果正常，利用事务管理器，提交事务
- 给容器中注册事务增强器；
原理话语版：
核心是@EnableTransactionManagement，这个注解能给容器中导入自动代理注册器AutoProxyRegistrar，该组件利用后置处理器在对象创建后，包装并返回一个代理对象，代理对象执行方法利用拦截器链进行调用；还会给容器中注册事务增强器，事务拦截器 transactionmanger 拦截事务注解标注的方法，在 sql 执行之前开启事务管理器，如果异常，获取到事务管理器，利用事务管理回滚操作（不会走提交）；如果正常执行，利用事务管理器，提交事务
扩展原理：
后置处理器：
BeanPostProcessor：bean后置处理器，bean创建对象初始化前后进行拦截工作的
-
BeanFactoryPostProcessor：beanFactory的后置处理器；
-
在BeanFactory标准初始化之后调用，来定制和修改BeanFactory的内容；
-
所有的bean定义已经保存加载到beanFactory，但是bean的实例还未创建
-
BeanFactoryPostProcessor原理:
-
ioc容器创建对象
-
invokeBeanFactoryPostProcessors(beanFactory);
如何找到所有的BeanFactoryPostProcessor并执行他们的方法?
- 直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法
- 在初始化创建其他组件前面执行
-
-
-
BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor
postProcessBeanDefinitionRegistry();在所有bean定义信息将要被加载，bean实例还未创建的时候执行；
优先于BeanFactoryPostProcessor执行；利用BeanDefinitionRegistryPostProcessor给容器中再额外添加一些组件；
原理：
1. ioc创建对象
1. refresh()-》invokeBeanFactoryPostProcessors(beanFactory);
3. 从容器中获取到所有的BeanDefinitionRegistryPostProcessor组件。
1. 依次触发所有的postProcessBeanDefinitionRegistry()方法
2. 再来触发postProcessBeanFactory()方法BeanFactoryPostProcessor；
4. 再来从容器中找到BeanFactoryPostProcessor组件；然后依次触发postProcessBeanFactory()方法
监听：
ApplicationListener：监听容器中发布的事件。事件驱动模型开发；
public interface ApplicationListener
监听 ApplicationEvent 及其下面的子事件；
步骤：
-
写一个监听器（ApplicationListener实现类）来监听某个事件（ApplicationEvent及其子类）
@EventListener;
原理：使用EventListenerMethodProcessor处理器来解析方法上的@EventListener； -
把监听器加入到容器；
-
只要容器中有相关事件的发布，我们就能监听到这个事件；
- ContextRefreshedEvent：容器刷新完成（所有bean都完全创建）会发布这个事件；
- ContextClosedEvent：关闭容器会发布这个事件；
-
发布一个事件：applicationContext.publishEvent()；
原理：
ContextRefreshedEvent、IOCTest_Ext$1[source=我发布的时间]、ContextClosedEvent；
- ContextRefreshedEvent事件：
- 容器创建对象：refresh()；
- finishRefresh();容器刷新完成会发布ContextRefreshedEvent事件
- 事件发布流程
- 自己发布事件；
- 容器关闭会发布ContextClosedEvent；
【事件发布流程】：
publishEvent(new ContextRefreshedEvent(this));
- 获取事件的多播器（派发器）：getApplicationEventMulticaster()
- multicastEvent派发事件：
- 获取到所有的ApplicationListener；
- 循环发送：for (final ApplicationListener<?> listener : getApplicationListeners(event, type))
- 如果有Executor，可以支持使用Executor进行异步派发；Executor executor = getTaskExecutor();
- 否则，同步的方式直接执行listener方法；invokeListener(listener, event);拿到listener回调onApplicationEvent方法；
【事件多播器（派发器）】:
- 容器创建对象：refresh();
- initApplicationEventMulticaster();初始化ApplicationEventMulticaster；
- 先去容器中找有没有id=“applicationEventMulticaster”的组件；
- 如果没有this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
并且加入到容器中，我们就可以在其他组件要派发事件，自动注入这个applicationEventMulticaster；
【容器中有哪些监听器】
- 容器创建对象：refresh();
- registerListeners();
从容器中拿到所有的监听器，把他们注册到applicationEventMulticaster中；
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
//将listener注册到ApplicationEventMulticaster中
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
SmartInitializingSingleton 原理：->afterSingletonsInstantiated();
- ioc容器创建对象并refresh()；
- finishBeanFactoryInitialization(beanFactory);初始化剩下的单实例bean；
- 先创建所有的单实例bean；getBean();
- 获取所有创建好的单实例bean，判断是否是SmartInitializingSingleton类型的；
如果是就调用afterSingletonsInstantiated();
☆Spring容器刷新原理:
Spring容器的refresh()【创建刷新】;
加重锁：
-
prepareRefresh(): 刷新前的预处理
- initPropertySources()初始化一些属性设置和占位符;子类自定义个性化的属性设置方法；
- getEnvironment().validateRequiredProperties();检验属性的合法等属性是否都能解析
- earlyApplicationEvents= new LinkedHashSet
();保存容器中的一些早期的事件；
-
obtainFreshBeanFactory(); 获取BeanFactory
- refreshBeanFactory();刷新【创建】BeanFactory；创建了一个this.beanFactory = new DefaultListableBeanFactory();设置id；
- getBeanFactory();返回刚才GenericApplicationContext创建的BeanFactory对象；
- 将创建的BeanFactory【DefaultListableBeanFactory】返回；
-
prepareBeanFactory(beanFactory); BeanFactory的预准备工作(对BeanFactory进行一些设置)
- 设置BeanFactory的类加载器、支持表达式解析器...
- 添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
- 设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
- 注册可以解析的自动装配；我们能直接在任何组件中自动注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
- 添加BeanPostProcessor【ApplicationListenerDetector】
- 添加编译时的AspectJ；
- 给BeanFactory中注册一些能用的组件；environment【ConfigurableEnvironment】、systemProperties【Map<String, Object>】、systemEnvironment【Map<String, Object>】
-
postProcessBeanFactory(beanFactory); BeanFactory准备工作完成后进行的后置处理工作；
- 子类可以通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置
以上是BeanFactory的创建及预准备工作==========
-
invokeBeanFactoryPostProcessors(beanFactory); 执行BeanFactoryPostProcessor的方法
BeanFactoryPostProcessor：BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的；
两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
- 先执行BeanDefinitionRegistryPostProcessor的方法；
- 获取所有的BeanDefinitionRegistryPostProcessor；
- 看先执行实现了PriorityOrdered优先级接口的；postProcessor.postProcessBeanDefinitionRegistry(registry)
- 在执行实现了Ordered顺序接口的；postProcessor.postProcessBeanDefinitionRegistry(registry)
- 最后执行没有实现任何优先级或者是顺序接口的；postProcessor.postProcessBeanDefinitionRegistry(registry)
- 再执行BeanFactoryPostProcessor的方法
- 获取所有的BeanFactoryPostProcessor
- 看先执行实现了PriorityOrdered优先级接口的；postProcessor.postProcessBeanFactory()
- 在执行实现了Ordered顺序接口的；postProcessor.postProcessBeanFactory()
- 最后执行没有实现任何优先级或者是顺序接口的；postProcessor.postProcessBeanFactory()
- 先执行BeanDefinitionRegistryPostProcessor的方法；
-
registerBeanPostProcessors(beanFactory); 注册BeanPostProcessor（Bean的后置处理器）【注册拦截 bean 创建的 bean 处理器】
不同接口类型的BeanPostProcessor；在Bean创建前后的执行时机是不一样的
BeanPostProcessor、
DestructionAwareBeanPostProcessor、
InstantiationAwareBeanPostProcessor、
SmartInstantiationAwareBeanPostProcessor、
MergedBeanDefinitionPostProcessor【internalPostProcessors】、
- 获取所有的 BeanPostProcessor;后置处理器都默认可以通过PriorityOrdered、Ordered接口来执行优先级
- 先注册PriorityOrdered优先级接口的BeanPostProcessor；
- 再注册Ordered接口的
- 最后注册没有实现任何优先级接口的
- 最终注册MergedBeanDefinitionPostProcessor；
- 注册一个ApplicationListenerDetector；来在Bean创建完成后检查是否是ApplicationListener，如果是applicationContext.addApplicationListener((ApplicationListener<?>) bean);
-
initMessageSource(); 初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
-
获取BeanFactory
-
看容器中是否有id为messageSource的，类型是MessageSource的组件，如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；
-
把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);
-
-
initApplicationEventMulticaster(); 初始化事件派发器
- 获取BeanFactory
- 从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；
- 如果上一步没有配置；创建一个SimpleApplicationEventMulticaster
- 将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入
-
onRefresh(); 留给子容器（子类）
- 子类重写这个方法，在容器刷新的时候可以自定义逻辑；
-
registerListeners(); 给容器中将所有项目里面的监听 bean (ApplicationListener)注册进来；
- 从容器中拿到所有的ApplicationListener
- 将每个监听器添加到事件派发器中；getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
- 派发之前步骤产生的事件；
-
finishBeanFactoryInitialization(beanFactory); 初始化所有剩下的非懒加载的单实例bean；
-
beanFactory.preInstantiateSingletons();初始化后剩下的单实例bean
-
获取容器中的所有Bean，依次进行初始化和创建对象
-
获取Bean的定义信息；RootBeanDefinition
-
Bean不是抽象的，是单实例的，是懒加载；
-
判断是否是FactoryBean；是否是实现FactoryBean接口的Bean；
-
不是工厂Bean。利用getBean(beanName);创建对象
-
getBean(beanName)； ioc.getBean();
-
doGetBean(name, null, null, false);
-
先获取缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来），从private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>
-
缓存中获取不到，开始Bean的创建对象流程；
-
标记当前bean已经被创建
-
获取Bean的定义信息；
-
【获取当前Bean依赖的其他Bean;如果有按照getBean()把依赖的Bean先创建出来；】递归
-
启动单实例Bean的创建流程；
-
createBean(beanName, mbd, args);
-
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);让BeanPostProcessor先拦截返回代理对象；
【InstantiationAwareBeanPostProcessor】：提前执行；先触发：postProcessBeforeInstantiation()；
如果有返回值：触发postProcessAfterInitialization()；
-
如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象；调用4.
-
Object beanInstance = doCreateBean(beanName, mbdToUse, args);创建Bean
-
【创建Bean实例】；createBeanInstance(beanName, mbd, args);利用工厂方法或者对象的构造器创建出Bean实例；
-
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);
-
【Bean属性赋值】populateBean(beanName, mbd, instanceWrapper);
赋值之前：
-
拿到InstantiationAwareBeanPostProcessor后置处理器；postProcessAfterInstantiation()；
-
拿到InstantiationAwareBeanPostProcessor后置处理器；postProcessPropertyValues()；
赋值之前结束
-
应用Bean属性的值；为属性利用setter方法等进行赋值；applyPropertyValues(beanName, mbd, bw, pvs);
-
-
【Bean初始化】initializeBean(beanName, exposedObject, mbd);
- 【执行Aware接口方法】invokeAwareMethods(beanName, bean);执行xxxAware接口的方法
- 【执行后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); BeanPostProcessor.postProcessBeforeInitialization();
- 【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
- 是否是InitializingBean接口的实现；执行接口规定的初始化；
- 是否自定义初始化方法；
- 【执行后置处理器初始化之后】applyBeanPostProcessorsAfterInitialization BeanPostProcessor.postProcessAfterInitialization()；
-
注册Bean的销毁方法；
-
-
将创建的Bean添加到缓存中singletonObjects；ioc容器就是这些Map；
很多的Map里面保存了单实例Bean，环境信息。。。。；
所有Bean都利用getBean创建完成以后；
检查所有的Bean是否是SmartInitializingSingleton接口的；如果是；就执行afterSingletonsInstantiated()；
-
-
-
-
-
-
finishRefresh(); 完成BeanFactory的初始化创建工作；IOC容器就创建完成；
- initLifecycleProcessor();初始化和生命周期有关的后置处理器；LifecycleProcessor
- 默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultLifecycleProcessor();加入到容器；
- 写一个LifecycleProcessor的实现类，可以在BeanFactory
void onRefresh();
void onClose();
- getLifecycleProcessor().onRefresh();拿到前面定义的生命周期处理器（BeanFactory）；回调onRefresh()；
- publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件；
- liveBeansView.registerApplicationContext(this);
- initLifecycleProcessor();初始化和生命周期有关的后置处理器；LifecycleProcessor
总结=====
-
Spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息；
- xml注册bean；
- 注解注册Bean；@Service、@Component、@Bean、xxx
- xml注册bean；
-
Spring容器会合适的时机创建这些Bean
- 用到这个bean的时候；利用getBean创建bean；创建好以后保存在容器中；
- 统一创建剩下所有的bean的时候；finishBeanFactoryInitialization()；
-
后置处理器；BeanPostProcessor
-
每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能；
AutowiredAnnotationBeanPostProcessor:处理自动注入
AnnotationAwareAspectJAutoProxyCreator:来做AOP功能；
xxx....
增强的功能注解：
AsyncAnnotationBeanPostProcessor
-
-
事件驱动模型；
ApplicationListener；事件监听；
ApplicationEventMulticaster；事件派发：
Servlet3.0:
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；
springmvc:
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
感谢尚硅谷！！！
