Spring注解驱动开发

Spring注解驱动开发图谱

Spring注解驱动开发_第1张图片

对于一些复杂、重要、难懂的注解进行详细说明:

  • @Conditional:按照条件依赖注入bean到spring容器
package com.anotation.bean;
public class Person {
	private String name;
	private Integer age;
	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 + "]";
	}
}



package com.anotation.condition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;
public class LinuxCondition implements Condition {

	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		ClassLoader classLoader = context.getClassLoader();
		Environment environment = context.getEnvironment();
		BeanDefinitionRegistry registry = context.getRegistry();
		
		String property = environment.getProperty("os.name");
		boolean definition = registry.containsBeanDefinition("person");
		if(property.contains("Mac OS X")){
			return true;
		}
		
		return false;
	}
}





package com.anotation.condition;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

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 true;
		}
		return false;
	}
}




package com.anotation.config;

import com.anotation.bean.Person;
import com.anotation.condition.LinuxCondition;
import com.anotation.condition.WindowsCondition;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MainConfig2 {

	/**
	 * 比尔盖茨搞windows系统
	 * @return
	 */
	@Bean("bill")
	@Conditional({WindowsCondition.class})
	public Person person01(){
		return new Person("Bill Gates",62);
	}

	/**
	 * mac搞mac系统
	 * @return
	 */
	@Conditional(LinuxCondition.class)
	@Bean("mac")
	public Person person02(){
		return new Person("mac", 48);
	}
}




package com.atguigu.test;

import com.anotation.bean.Blue;
import com.anotation.bean.Person;
import com.anotation.config.MainConfig;
import com.anotation.config.MainConfig2;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

import java.util.Map;

public class IOCTest {
	AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);


	@Test
	public void test03(){
		ConfigurableEnvironment environment = applicationContext.getEnvironment();
		String property = environment.getProperty("os.name");
		System.out.println(property);

		Person person = applicationContext.getBean(Person.class);

		System.out.println(person);


	}
}

运行结果:

Mac OS X
Person [name=mac, age=48, nickName=null]

 

 

 

  • @Import:Spring底层大量用的注解,对于下面的注解类中的@Import(AspectJAutoProxyRegistrar.class)来说:效果是:给容器中导入AspectJAutoProxyRegistrar类,而AspectJAutoProxyRegistrar的作用是向容器中registerorg.springframework.aop.config.internalAutoProxyCreator,...
package org.springframework.context.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

	boolean proxyTargetClass() default false;

	boolean exposeProxy() default false;

}

 

 

 

  • BeanPostProcessor:后置处理器:执行过程

    --> Spring IOC容器实例化Bean
    --> 调用BeanPostProcessor的postProcessBeforeInitialization方法
    --> 调用bean实例的初始化方法
    --> 调用BeanPostProcessor的postProcessAfterInitialization方法
    Spring容器通过BeanPostProcessor给了我们一个机会对Spring管理的bean进行再加工。比如:我们可以修改bean的属性,可以给bean生成一个动态代理实例等等。一些Spring AOP的底层处理也是通过实现BeanPostProcessor来执行代理包装逻辑的。

package com.anotation.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

/**
 * 后置处理器:初始化前后进行处理工作
 * 将后置处理器加入到容器中
 * @author zhengchao
 */
@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;
	}

}

 

 

 

  • @EnableAspectJAutoProxy,开启基于注解的aop模式:源码不详细解读
package com.anotation.config;

import com.anotation.aop.LogAspects;
import com.anotation.aop.MathCalculator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * 说明:
 *   1、环绕通知,动态代理,手动推进目标方法的运行(joinPoint.procced())
 *   2、@EnableAspectJAutoProxy,开启基于注解的aop模式
 *
 *
 *   AOP原理:看给容器中注册了什么组件,这个组件什么时候工作,这个组件的功能
 *      @EnableAspectJAutoProxy注解:
 *    1、@EnableAspectJAutoProxy
 *    @Import(AspectJAutoProxyRegistrar.class):给容器中导入AspectJAutoProxyRegistrar:
 *       AspectJAutoProxyRegistrar他给容器注册一个AnnotationAwareAspectJAutoProxyCreator
 *
 *    AnnotationAwareAspectJAutoProxyCreator
 * 		AnnotationAwareAspectJAutoProxyCreator
 * 			->AspectJAwareAdvisorAutoProxyCreator
 * 				->AbstractAdvisorAutoProxyCreator
 * 					->AbstractAutoProxyCreator
 * 							implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
 * 						关注后置处理器(在bean初始化完成前后做的事情)、自动装配BeanFactoryAware
 *
 *
 * 	  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() :
 * 						2、applyBeanPostProcessorsBeforeInitialization() 执行后置处理器postProcessBeforeInitialization
 * 						3、invokeInitMethods():执行自定义的初始化方法
 * 						4、applyBeanPostProcessorsAfterInitialization()  执行后置处理器postProcessAfterInitialization
 * 				4、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功
 *       7) 把BeanPostProcessor注册到BeanFactory中:
 *          beanFactory.addBeanPostProcessor(beanPostProcessor)
 *  ========以上是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程 ========
 *
 *    4、完成BeanFactory剩余的初始化工作:创建剩下的单实例bean
 *       1) 遍历获取容器所有的bean,依次创建对象
 *       2)、创建bean
 *
 *  AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】的作用
 *  1、每一个bean创建之前,调用postProcessBeforeInstantiation();
 *     关心MathCalculator和LogAspect的创建
 *     1) 判断当前bean是否在advisedBean中(保存了所有需要增强的bean)
 *     2)  判断当前bean是否是基础类型的Advice、Pointcut、Aspect。。。
 *
 *  2、创建对象 调用postProcessAfterInitialization:
 *      1)、获取bean的所有增强器
 *         1)获取候选当所有增强器(找到哪些通知方法是需要切入当前bean方法的)
 *         2)获取到能在bean使用的增强器
 *         3)给增强器排序
 *      2)、保存当前bean在advisedBeans中
 *      3)、创建bean的代理对象,创建当前bean的代理对象
 *         1)获取所有增强器(通知方法)
 *         2)保存到proxyFactory中
 *         3)创建代理对象
 *              JdkDynamicAopProxy(config);jdk动态代理
 * 				ObjenesisCglibAopProxy(config);cglib动态代理
 * 	    4)、给容器返回当前组件使用cglib增强了的代理对象
 * 	    5)、以后容器中获取到的就是这个组件的代理对象,执行目标方法的时候,代理对象就会执行通知方法
 * 	3、目标方法执行
 * 	    容器中保存了组件的代理对象(cglib增强后的对象),这个对象里面保存了详细信息
 * 	    1)CglibAopProxy.intercept()拦截目标方法的执行
 * 	    2)根据ProxyFactory对象获取将要执行的目标方法的拦截器链
 * 	    3)没有拦截器链,直接执行目标方法
 * 	       拦截器链(每一个通知方法又被包装为方法拦截器,利用MethodInterceptor机制)
 * 	    4)如果有拦截器链,把需要执行的目标对象,目标方法,拦截器链等信息传入创建一个CglibMethodInvocation对象
 * 	       并调用Object retval = mi.proceed()
 * 	    5)拦截器链的触发过程
 * 	       1)如果没有拦截器执行目标方法,或者拦截器的索引和拦截器数组-1大小一样,执行目标方法
 * 	       2)链式获取每一个拦截器,拦截器执行invoke方法,每一个拦截器等待下一个拦截器执行完成返回以后再来执行
 * 	          拦截器链的机制,保证通知方法与目标方法的执行顺序
 *
 * 	 总结:
 * 	   1)@EnableAspectJAutoProxy注解开启AOP功能
 * 	   2)@EnableAspectJAutoProxy会给容器注册一个组件AnnotationAwareAspectJAutoProxyCreator
 *     3)AnnotationAwareAspectJAutoProxyCreator是一个后置处理器
 *     4)容器的创建流程:
 *        1)registerBeanPostProcessors()注册后置处理器:创建AnnotationAwareAspectJAutoProxyCreator
 *        2)finishBeanFactoryInitialization()初始化剩下的单实例bean
 *           1)创建业务逻辑组件和切面组件
 *           2)AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程
 *           3)组件创建完成之后,判断组件是否需要增强
 *              是:切面的通知方法包装成增强器(Advisor);给业务逻辑组件创建一个代理对象
 *     5)执行目标方便
 *        1)代理对象执行目标方法
 *        2)CglibAopProxy.intercept()拦截目标方法的执行
 *          1)得到目标方法的拦截器链(增强器包装成拦截器MethodInterceptor)
 *          2) 利用拦截器的链式机制,依次进入每一个拦截器进行执行
 *          3)效果:
 *              正常执行:前置通知-->目标方法-->后置通知-->返回通知
 *              异常执行:前置通知-->目标方法-->后置通知-->异常通知
 *
 *
 */
@EnableAspectJAutoProxy
@Configuration
@ComponentScan(value = "com.anotation.aop")
public class MainConfigOfAOP {

	//加这个@ComponentScan(value = "com.anotation.aop"),就不用写下面的@Bean了,
//	@Bean
//	public MathCalculator calculator(){
//		return new MathCalculator();
//	}

//	@Bean
//	public LogAspects logAspects(){
//		return new LogAspects();
//	}

}

图示拦截目标方法的执行:

Spring注解驱动开发_第2张图片

 

 

  • Spring容器初始化分析
AnnotationConfigApplicationContext applicationContext  = new AnnotationConfigApplicationContext(ExtConfig.class);

Spring容器的refresh()【创建刷新】;
1、prepareRefresh()刷新前的预处理;
	1)、initPropertySources()初始化一些属性设置;子类自定义个性化的属性设置方法;
	2)、getEnvironment().validateRequiredProperties();检验属性的合法等
	3)、earlyApplicationEvents= new LinkedHashSet();保存容器中的一些早期的事件;
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】、
		systemEnvironment【Map】
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 singletonObjects = new ConcurrentHashMap(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;
		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;事件派发:

 

  •  

 

to be continue...

你可能感兴趣的:(Servlet,注解)