业务逻辑需要多个对象合作来实现，这样多个对象之间就存在依赖关系。控制反转把应用从复杂的对象依赖关系中解放出来，将依赖关系交给IoC容器管理（具体地就是将新建对象、为对象引用赋值等操作交给容器完成）。
1.2 IoC容器设计与实现：BeanFactory与ApplicationContext
1.实现BeanFactory的简单容器系列--实现了容器的最基本功能。
2.ApplicationContext应用上下文，在1的基础上，增加了许多面向框架的特性以及对应用环境的适配。
3.BeanDefinition抽象了对Bean的定义，用于管理对象和对象之间的依赖关系，是容器实现依赖反转的核心数据结构。
1.2.1 容器的设计
1.BeanFactory接口
2.BeanFactory设计原理（以XmlBeanFactory为例）
DefaultListableBeanFactory是默认的完整容器功能实现类，XMLBeanFactory继承该类并添加读取XML配置文件的功能。
编程式使用：
3.ApplicationContext
面向框架的使用风格
4.ApplicatioinContext设计原理（以FileSystemXmlApplicationContext为例）
1.2.3 IoC容器初始化过程（以FileSystemXmlApplicationContext为例）
IoC容器的初始化包括 BeanDefinition的定义、载入和注册三个过程（即1.2.1.2种函数式使用IoC），被封装在refresh()方法中。
-
Resource定位：定位BeanDefinition资源的位置。
-
BeanDefinition的载入：把上一步定位的资源载入，并转变为IoC容器内部的数据结构，即BeanDefinition（POJO对象在IoC容器中的抽象）。
-
向IoC容器注册这些BeanDefinition（到一个HashMap），具体是调用BeanDefinitionRegistry接口。
注意：这个过程并不包括依赖注入；依赖注入一般发生在第一次调用getBean时，但可以通过Bean的lazyinit属性调控。
下面具体讲这三个过程。
1.3 IoC详细初始化过程
1.3.1 BeaDefinition的Resource定位
在FileSystemXmlApplicationContext的构造函数中，refresh()启动容器初始化。
refresh(){
refreshBeanFactory(){
1.关闭可能存在的BeanFactory
2.createBeanFactory（）{}
3.loadBeanDefinitions(BeanFacotory){
//定位BeanDefinition的两种方式
1.ResourcePatternResolver.getResource()
2.getResource(){
1.CLASSPATH: new ClassPathResource()
2.URL: getResourceByPath（）
}
}
//载入
3.Reader（BeanFactory）；
//交给具体的reader，载入BeanDefinitions。
//配置reader
4.loadBeanDefinitions(Reader){
1.getConfigResources();//返回Resources【】或者String[]
2.reader.loadBeanDefinitions( Resources[]){
1.reader.loadBeanDefinition( Resources[i]){
1. loadBeanDefinitions( EncodedResource(resource)){
//创建InputSource并设置字符集
1.InputSource inputsource = new inputSource(
encodeResource.getResource().getInputStream()
).setEncoding(encodeResource.getEncoding());
//真正载入
2.doLoadBeanDefinitions( inputsource,encodeResource.getResource){
//加载前的准备工作
//交给DocumentReader去读取
1.registerBeanDefinitions(doc, resource){
1.documentReader = createBeanDefinitionDocumentReader();
//先完成通用xml解析，再按照Bean规则解析。
2.documentReader.registerBeanDefinitoins(doc, createContext(resource)){
//真正加载、解析
doRegisterBeanDefinitoins(Element root){
parseBeanDefinitions(){
//默认标签
1.parseDefaultElement(){
//包含了对beans、bean、alias、import标签的解析，以bean为例子
processBeanDefinition(){
//解析
parseBeanDefinitionElement(){};
//注册
registerBeanDefinition(){};
//通知相关监听器
fireComponentRegistered();
};
};
//自定义标签
2.parseCustomElemtn();
};
};
};
}；
};
};
}
}; } // } }}/* 1.refresh 2.refreshBeanFactory 2.1 关闭可能存在的BeanFactory 2.1 createBeanFactory（）{} 3.loadBeanDefinitions(BeanFacotory) 3.1定位BeanDefinition的两种方式 //载入 3.2 Reader（BeanFactory）；//关联reader和beanFactory 4.loadBeanDefinitions(Reader) 4.1 获取资源 5.reader.loadBeanDefinitions( Resources[]) 5.1 设置字符集 5.2 取得XML的inputSource 6.doLoadBeanDefinitions( inputsource,encodeResource.getResource) 6.1 解析XML-->document 7.registerBeanDefinitions(doc, resource) 7.1 创建DocumentReader 8. documentReader.registerBeanDefinitoins（） 9. doRegisterBeanDefinitoins(Element root) 10. parseBeanDefinitions(){ //真正解析，针对不同标签解析、注册、通知监听器 //默认标签 1.parseDefaultElement(){ //包含了对beans、bean、alias、import标签的解析，以bean为例子 processBeanDefinition(){ //解析 parseBeanDefinitionElement(){}; //注册 registerBeanDefinition(){}; //通知相关监听器 fireComponentRegistered(); }; }; //自定义标签 2.parseCustomElemtn();} */
1.3.2 BeanDefinition的载入和解析
把定义的BeanDefinition转为IoC容器内部数据结构（HashMap）。
可以看到调用是从最上层的AbstractApplicaitonContext一步步往继承树子节点走。
-
refresh（）//AbstractApplicaitonContext
-
refreshBeanFactory(){ //AbstractRefreshableApplicationContext
createBeanFactory-->DefaultListableBeanFactory
loadBeanDefinitions-->具体的实现的Reader
}
//处理默认标签--parseDefaultElemnt()包含 import,beans,bean,alias标签，下面只是bean标签
processBeanDefinition(Element ele, BeanDefinitionParseDelegate delegate){
1.delegate.parseBeanDefinitionElement(Elemnt , BeanDefinition ){
1.1提取id和name，解析beanName，parseBeanDefinitionElement(Element, BeanName, BeanDefinition){
1.1.1 提取class和parent，创建GenericBeanBeanDefinition(className, parent);
1.1.2 解析bean属性
1.1.3 解析bean的子元素属性，包括：Meta，LookupOverrideSubElement,ReplaceMethodsSubElement
ConstructorArgElements,PropertyElements,QualifierElements
};
return BeanDefinitionHolder(BeanDefinition, beanName, aliasesArray);
};
//解析默认标签中的自定义标签
2.delegate.decorateBeanDefinitionIfRequired();
//注册
3.BeanDefinitionReaderUtils.registerBeanDefinition(BeanDefinitionHolder ， BeanDefinitionRegistry{
3.1 使用beanName做唯一注册标识
registry.registerBeanDenifition(beanName, BeanDefinition);
3.2 注册所有别名
registry.registerBeanDenifition(beanName, alias);
};
4.getReaderContext().fireComponentRegistered(); //为扩展保留
}
//处理默认标签--parseDefaultElemnt()包含 import,beans,bean,alias标签，下面只是alias标签
processAliasRegisteration(){
1.提取BeanName和alias，都不可空，否则抛出异常
2.getReaderContext().getRegistery().registerAlias(name, alias); }
//处理默认标签--parseDefaultElemnt()包含 import,beans,bean,alias标签，下面只是import标签
嵌入式Beans，递归解析beans。
-
parseBeanDefinitionElement() //解析
BeanDefinition只是一些静态配置信息，需要完成数据向容器的注册，才能完全发挥容器的作用。
1.3.3 BeanDefinition在容器的注册
1.private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
将BeanName作为键， BeanDefinition作为值保存。
2.
1.4 依赖注入(Bean的加载)
<u>依赖注入是用户第一次向容器申请Bean时触发(例外：lazy-init，可以控制Bean的预实例化）。</u>
FactoryBean
一般Spring利用反射机制通过bean的class属性实现bean。这样比较复杂，在<bean>配置大量信息。可以通过实现FactoryBean接口，在getObject方法中来定制实例化bean的逻辑。另外，该FactoryBean的getBean方法返回的不是FactoryBean（“&beanname”这样取得）而是getObejct方法的bean。
1.4.1 实例化过程
getBean(){
doGetBean(){
1.//提取beanName
2.尝试从缓存或者实例工厂获取bean，取得的bean是原始状态，还需要getObjectForBeanInstance
getSingleton(beanName, true//允许早期依赖);
3. 缓存没有，则新创建。
3.1 原型模式的循环依赖检测
3.2 当XML中没有bean的配置时，去parentBeanFactory寻找
3.3 取得BeanDefinition后，转为RootBeanDefinition
3.4 存在依赖Bean，递归调用
3.5 根据Scope创建bean
每种scope，实际都是以下方法：
3.5.1 createBean();
3.5.2 getObjectForBeanInstance();
};
};
1、缓存中获取
getSingleton(beanName, true//允许早期依赖);
1.检测singletonObjects();获得bean则返回// map存放beanName和beanInstance
2.上一步没有获得bean，检测earlySingletonObjects();获得bean则返回//map存放还在创建过程中的bean，循环检测
3.前两步都没有获得bean，且允许早期依赖，从singletonFactories中获取ObjectFactory初始化策略，初始化bean
4.取得bean，
调用getObjectForBeanInstance{
1.检测是否是FactoryBean，
2.否直接返回bean，
3.是调用getObjectFromFacrotyBean(beanName){
1.检测单例
2.doGetObjectFromFacrotyBean(){
1.检测权限
2.factory.getObject();
//ObjectFactoryBean的后处理器--AbstractAutowireCapableBeanFactory
3.postProcessObjectFromFactoryBean();
//尽可能保证在Bean初始化后，都会调用注册的BeanPostProcessor的postProcessAfterInitialization方法
};
};
4.返回getObject方法的结果。
}
若这三步都没有获得，则需要新建。
2、获取单例(创建缓存中不存在的单例)
getSingleton(beanName, singletonFactory){
在singletonObjects上加锁
1.缓存检测，/*构造器循环依赖无法解决。setter循环依赖通过，提取暴露一个工厂方法，并将在当前创建bean池该bean的标识符，提供还未创建完成的Bean。
*/
2.beforeSingletonCreaton();//记录正在创建的状态
3.singletonFactory.getObject(){
1.createBean(beanName, mbd, args){
};
4.afterSingleCreation(); //删除正在创建的状态
5.addSingleton(beanName, singletonObject);//创建好的bean加入缓存，并删除各种辅助状态
}
createBean(beanName, mbd, args){
解析class
1.mbd.prepareMethodOverrides();//验证并准备覆盖的方法，主要是lookup-method和replace-method属性。
2.Object bean = resolveBeforeInstantiation(beanName, mbd){//对Bean的属性做些前置处理
bean = applyBeanPostProcessorsBeforeInstantiation(){
bean=applyBeanPostProcessorBeforeInstantiation();
if(bean!=null) applyBeanPostProcessorAfterInstantiation();
};//实例化前后处理器应用
if（bean!=null）
applyBeanPostProcessorsAfterInitialization();//实例化后后处理器应用,满足spring规则。
};
3.if(bean!=null) return bean;//短路测试
4.doCreateBean(beanName, mbd, args){
1.清除缓存？
2.createBeanInstance(){
1.resolveBeanClass //解析class
2.非public类无法访问，所以无法构建bean
3.mbd中工厂方法不为空，调工厂创建。
instantiateUsingFactoryMethod();
4.解析构造函数并实例化，缓存在resolvedConstructorOrFactory中。
5. autowireConstructor(){
//太复杂，大致为
确定参数（传入了参数（用户调用getBean可以传入），缓存中参数，配置文件中参数）
确定构造函数
转换参数类型和构造函数不确定性验证--不太懂
根据实例化策略（instantiate）和构造函数和参数，实例化Bean
};//构造函数自动注入
instantiateBean();//默认构造函数，没有参数直接根据实例化策略实例化Bean
instantiate{//实例化策略
if(beanDefinition.getMethodOverrides().isEmpty()) 直接反射
else 动态代理将覆盖的方法织入
}
}; Bean的合并后处理
3.依赖处理 addsingletonFactory() //单例，可循环依赖，当前Bean正在创建中，曝光工厂方法
4.populateBean(){//属性注入
1.getPropertyValues//提取属性
2.根据BeanWraper和pvs是否为空，考虑注入
3. //提取依赖的Bean，放入PropertyValues中。
autoWiredByName();
autoWiredByType();//比较复杂，暂不了解
4.postProcessPropertyValues();//填充属性前对属性再次处理。
5.applyPropertyValues();//应用属性到Bean中。 }; 5.initializeBean(){//Bean配置里面的init-method属性。前面已经执行了Bean的实例化和属性填充，现在是调用 //用户的初始化方法 1.invokeAwareMethods(){ 判断是BeanNameAware、BeanClassAware、还是BeanFactoryAware，分别传入相应的Aware前面部分。 //实现Aware的接口会取得一些资源 }; 2.applyBeanPostProcessorsBeforeInitialization(){ postProcessBeforeInitialization(); }; 3.invokeInitMethods(){ 先执行自定义Bean的initializingBean接口中afterPropertiesSet， 然后是init-method方法。 }; 4.applyBeanPostProcessorsAfterInitialization(){ postProcessAfterInitialization(); }; }; 6.循环依赖检测与处理 7.registerDisposableBeanIfNecessary(){ registerDispoableBean();//属性配置destrot-method //自定义的bean销毁方法 registerDestructionCallback(); }//注册DisposableBean销毁方法并返回 };};
1.5 ApplicatonContext
1.5.1 设置配置文件路径
setConfigoLcations(String[] locations){
resolcePath();//解析路径
}
1.5.2 扩展功能
refresh(){
1.prepareRefresh();
2.beanFactory=obtainFreshBeanFactory();
3.prepareBeanFactory(beanFactory);
4.postProcessBeanFactory(beanFactory);
5.invokeBeanFactoryPostProcessors(beanFactory);
6.registerBeanPostProcessors(beanFactory);
7.initMessageSource();
8.initApplicationEventMulticaster();
9.onRefresh();
10.registerListeners();
11.finishBeanFactoryInitializatioin(beanFactory);
12.finishRefresh();
}
1.prepareRefresh(); 准备刷新上下文环境
prepareRefresh(){
initPropertySources();//留给子类覆盖，个性化地属性处理和设置
getEnviroment().validateRequiredProperties();
};
2.beanFactory=obtainFreshBeanFactory();初始化BeanFactory并进行XML文件的读取
beanFactory=obtainFreshBeanFactory(){
refreshBeanFactry(){
1.关闭已有Beanfacory
2.createBeanFactory();
3.customizeBeanFactory(){
//开始扩展基本的bean
覆盖，循环依赖，
//注解方式注入的支持
setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidatResolver());
};//定制BeanFactory
4.loadBeanDefinitions(beanFactory);
5.保存至全局beanFactory
};
};
3.prepareBeanFactory(beanFactory);对beanFactory功能填充.ApplicationContext
prepareBeanFactory(beanFactory){
//添加表达式语言处理器
setBeanExpressionResolver(new StandardBeanExpressionResolver()){
}; -->在属性填充解析属性值时，调用evaluateBeanDefinitionString(){
this.beanExpressionResolver.evaluate();
}
//添加属性编辑器-->一些属性的是自定义的类，spring无法识别
addPropertyEditorRegistrar();
//添加BeanPostProcessor
addBeanPostProcessor(new ApplicationContextAwareProcessor(...)){
该处理器会调用 postprocessBefore||AfterInitialization()
invokeAwareInterfaces(){
获取一些资源
};
};
//设置忽略自动装配的接口-->在invokeAwareInterfaces中的资源的获取是由应用获取的，也就是说这些资源的依赖关系已经不再是容器管理。所以需要忽略。
//设置几个自动装配的特殊规则-->注册依赖
//添加AspectJ的支持
//添加默认系统环境的bean
};
4.postProcessBeanFactory(beanFactory);子类覆盖方法额外处理
通过实现BeanFactoryPostFactory接口，BeanFactory会在实例化任何bean之前获得配置信息，从而能够正确解析bean描述文件的变量引用。
5.invokeBeanFactoryPostProcessors(beanFactory);激活各种BeanFactory处理器
6.registerBeanPostProcessors(beanFactory);注册拦截Bean创建的Bean处理器。在bean实例化时调用。
//BeanFactory没有实现后处理器的自动注册，Application实现自动注册
registerBeanPostProcessors(beanFactory){
};
7.initMessageSource();为上下文初始化Message源
8.initApplicationEventMulticaster();初始化应用消息广播器，放入applicationEventMulticaster中
1.定义事件继承ApplicationEvent
2.定义监听器ApplicationListener
3.定义事件广播器
initApplicationEventMulticaster(){
注册事件广播器
}
4.事件广播器有下面方法
当sprin*生事件时，会调用下面方法遍历监听器
public void multicastEvent(final ApplicationEvent event){
listener.onApplicationEvent(event);//每个监听器都会获取到事件，但是否处理，则是监听器内部逻辑
}
9.onRefresh();initialize other special beans in specific context subclasses
10.registerListeners();查找Listener bean，注册到消息广播器中。
registerListeners(){
//硬编码方式
for(Application<?> listener : getApplicationListeners()){
getApplicationEventMulticaster().addApplicationListener(listener);
}
//配置文件注册监听器
String[] litenerBeanNames = getBeanNmesForType(ApplicationListener.class,true,false);
for(String lisName:listenerBeanNames){
getApplicationEventMulticaster().addApplicationListeer(lisName);
}
}
11.finishBeanFactoryInitializatioin(beanFactory);初始化剩下的单实例（非惰性）
finishBeanFactoryInitializatioin(beanFactory){
1.ConversionService的设置
注册在配置文件中的转换器，conversionServic，该 Bean中包含转换器，用于类型转换。
Converter<?class, ?class>比如前面的Converter<String, Date>//转换器
2.冻结所有bean的定义，再不能被修改或者进一步处理。
freezeConfiguration();
3.ApplicationContext会在启动时将所有单例bean提前实例化，便于在启动过程中发现配置中的错误，而不是在调用bean时才发现。
preInstantiateSingletons(){}
};
12.finishRefresh();完成刷新，通知生命周期处理器lifecycleProcessor,发出ContextRefreshEvent通知别人
//spring提供LifeCycle接口，包含start/stop接口。分别在启动和关闭时调用。
finishRefresh(){
initLifecycleProcessor();
gtLifecycleProcessor().onfresh();//启动所有实现lifecyce的bean。
//启动完成后通过事件发布机制发布事件
publishEvent(new ContextRefreshedEvent(this));
};
1.6 AOP
1.6.1 AopNamespaceHandler--AspectJ的解析器
public void init(){
registerBeanDefinitionParser("aspect-autoprxy",new AspectJAutoProxyBeanDefinitionParser(){
public BeabDefinition parse(Element, ParseContext){
//注册AnnotationAwareAspectJAutoProxyCreator
registerAspectJAnnotationAutoProxyCreatorIfNecessary(Element, ParseContext){
1.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
parserContext.getRegistry(),
parserContext.extractSource(sourceElement)
){//自动注册AnnotationAwareAspectJAutoProxyCreator（该类实现Aop功能）
return registerOrEscalateApcRequired(
AnnotationAwareAspectJAutoProxyCreator.calss,...){
//存在自动代理创建器，且与现在的不一致，需要根据优先级判断。
在register中注册代表自动创建器bean
return beandefinition;
};
};
//处理proxy-target-calss（true表示强制使用CGLIB动态代理）和expos-proxy属性
2.useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement());
//注册组件并通知。
3.registerComponentIfNecessary(beanDefinition, parserContext);
};
}
});
}
1.6.2 创建AOP代理
AnnotationAwareAspectJAutoProxyCreator继承自AbstracAutoProxyCreator,有方法postProcessorAfterInitializatioin()
postProcessorAfterInitializatioin(){
//封装指定bean
wrapIfNecessary(bean, beanName, cacheKey){
1.各种直接返回场景，已处理、无需增强..
2.获取增强
Object[] specificInterceptors = getAdviceAndAdvisorsForBean(bean.class, beanName, null){
findEligibleAdvisors(beanClss, beanName){
2.1 findCandidateAdvisors(){};
2.2 findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
return eligibleAdisors;
};
};
3.如果有增强，则针对增强创建代理
createProxy(bean,getClass(),beanName, specificInterceptors, new SingletoTargetSource(bean));
};
}
2.
2.1 提取advisors
findCandidateAdvisors(){
//将通过配置文件配置的AOP加载进来
List<Advisor> advisors = super.findandidateAdvisors();
2.1.1 advisors.addAll(this.aspectJAvdivsorsBuilder.buildAspectJAdvosprs());
return advisors;
};
2.1.1
buildAspectJAdvispos(){
1.通过BeanFactoryUtils获取所有beanNames，
2.遍历beanNames，进而获取beanType
3.如果beanType上有Aspect注解
解析注解中的增强方法
advisorFactory.getAdvisors(factory){
};
4.advisors.addAll();//记录在缓存中并返回advisors
}
2.1.1.3
getAdvisors(factory){
//普通增强器的获取，包括切点注解的获取和根据注解信息生成增强
1.getAdvisor(...){
//获取切点注解
getPointcut(...){
//获取方法上的注解
aspectJAnnotation=findAspectJAnnotationOnMethod(...){
1.设置注解敏感类
2.遍历敏感类与传入的方法上的标注匹配，来确定是哪个注解
findAnnotation（method, class）{}
};
//创建用于封装获取的信息的AspectJExpressionPointcut实例
ajexp=new AspectJExpressionPointcut(...);
//提取得到的注解中的表达式
ajexp.setExpression(aspectJannotation.getPointcutExpression());
return ajexp;
};
//根据获取的切点信息生成增强器
return new InstantiationModelAwarePointcutAdvisorImpl(...){
1.简单地将获取的信息封装在InstantiationModelAwarePointcutAdvisorImpl实例中
2.
//初始化对应的增强器
instantiateAvice(){
return ...getAdvice(...){
1.一些判断逻辑
//根据不同的注解类型封装不同的增强器
2.switch(aspectJAnnotation.getAnnotationType()){
case AtBefore.... case AtAfter... case AtAfterReturning .... } } }; }; } 2.加入同步实例化增强器 //用于引介增强的注解 3.获取DeclareParents //与普通getAdvisors相像 getDelaredParentsAdvisor()}; 2.2 找到满足我们配置的通配符的增强器findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName){ 遍历candidateAdvisors 1.先处理引介增强 canApply{} 2.处理普通bean的增强 canApply{}};3.createProxy(){ proxyFactory=new ProxyFactory(); 1.//获取当前类中相关属性 proxyFactory.copyFrom(this); 2.//添加代理接口 proxyFactory.addInterface(targetInterFace of targetInterfaces); 3.//将拦截器(各种拦截器，增强器，增强方法)统一封装为Advisor，并加入ProxyFactory中。 advisors = buildAdvisors(beanName, specificInterceptors){ 1.处理commonIntercepotors和specficInterceptor，加入allInterceptors中， //将拦截器(各种拦截器，增强器，增强方法)统一封装为Advisor 2.advisros[i]=this.advisorAdapterRegistry.wrap(allInterceptors.get(i)){ 根据传入参数类型是 a.Advisor （直接返回） b.Advice--1.MethodInterceptor...2.AdvisorAdapter DefaultPointcutAdvisor c.其他类型抛出异常 }; }; //加入ProxyFactory中 proxyFactory.addAdvisor(advisor of advisors); 4.//设置要代理的类 proxyFactory.setTargetSource(targetSource); 5.//定制代理的一些属性 customizeProxyFactory(proxyFactory); 6.//获取代理并返回 AopProxy return ProxyFactory.getProxy(this.proxyClassLoader){ //创建代理 1.return createAopProxy().getProxy(classLoader); { }; };};3.6.1.1createAopProxy(){ getAopProxyFactory().createAopProxy(this){ if(根据条件，选取代理方法 1.JDK动态代理，2.CGLIB) new JdkDynamicAopProxy(config); new CglibProxyFactory.createCglibProxy(config);}
1.6.3 JDK动态代理和Cglib代理
1.JDK动态代理和Cglib的区别
JDK动态代理针对接口，无法针对类。目标类实现了接口，默认采用该方式。没有实现必须CGLIB； CGLIB是针对类，生成子类，覆盖方法，所以原类中的方法不能是final
2.JdkDynamicAopProxy
示例
public interface UserService{
public abstract void add();
}
public class UserServiceImpl implements UserService{
public void add(){
System.out.println("-------------add-----------");
}
}
//创建自定义的InvocationHandler，用于对接口的方法增强
//必须重写的三个函数
public class MyInvocationHandler implements InvocatinHandler{
private Object target;
1.//将被代理对象传入
public MyInvocationHandler(Object target){
super();
this.target = target;
}
2.获取代理对象
public Object getProxy(){
return Proxy.newProxyInstance(classLoader, target.getClass().getInterfaces(),this);
}
3.执行目标对象方法
public Object invoke(Object proxy, Method method, Object[] args){
System.out.println("-------------add-----------");
Object result = method.invoke(target, args);
System.out.println("-------------add-----------");
return result;
}
}
3.jdk动态代理必须实现的三个接口
//必须重写的三个函数
1.//将被代理对象传入
public MyInvocationHandler(Object target)
2.获取代理对象
public Object getProxy(){
3.执行目标对象方法
public Object invoke(Object proxy, Method method, Object[] args){
4.Spring AOP JdkDynamicAopProxy也实现了InvocationHandler接口
public object invoke(Object proxy, Method method, Object[] args){
1.....很多逻辑
2.获取当前方法的拦截器链 //并封装再ReflectiveMethodInvocation中
3.proceed() //执行拦截器链
}
5.CGLIB动态代理
委托给Cglib2AopProxy完成
getProxy(){
1.创建enhancer
Enhancer enhancer = new createEnhancer();
2.设置父类
enhancer.setSuperclass(proxySuperClass);
3.设置拦截器
Callback[] callbacks = getCallbacks();
enhancer.setCallbacks();
4.生成代理类，以及创建代理
proxy=enhancer.create();
}