Spring源码深度解析(容器方面)

时间:2022-09-16 17:17:36

1.1 IoC原理

​ 业务逻辑需要多个对象合作来实现,这样多个对象之间就存在依赖关系。控制反转把应用从复杂的对象依赖关系中解放出来,将依赖关系交给IoC容器管理(具体地就是将新建对象、为对象引用赋值等操作交给容器完成)。

1.2 IoC容器设计与实现:BeanFactory与ApplicationContext

1.实现BeanFactory的简单容器系列--实现了容器的最基本功能。

2.ApplicationContext应用上下文,在1的基础上,增加了许多面向框架的特性以及对应用环境的适配。

3.BeanDefinition抽象了对Bean的定义,用于管理对象和对象之间的依赖关系,是容器实现依赖反转的核心数据结构。

1.2.1 容器的设计

Spring源码深度解析(容器方面)

1.BeanFactory接口

2.BeanFactory设计原理(以XmlBeanFactory为例)

DefaultListableBeanFactory是默认的完整容器功能实现类,XMLBeanFactory继承该类并添加读取XML配置文件的功能。

Spring源码深度解析(容器方面)

编程式使用:

Spring源码深度解析(容器方面)

3.ApplicationContext

面向框架的使用风格

4.ApplicatioinContext设计原理(以FileSystemXmlApplicationContext为例)

1.2.3 IoC容器初始化过程(以FileSystemXmlApplicationContext为例)

IoC容器的初始化包括 BeanDefinition的定义、载入和注册三个过程(即1.2.1.2种函数式使用IoC),被封装在refresh()方法中。

  1. Resource定位:定位BeanDefinition资源的位置。

  2. BeanDefinition的载入:把上一步定位的资源载入,并转变为IoC容器内部的数据结构,即BeanDefinition(POJO对象在IoC容器中的抽象)。

  3. 向IoC容器注册这些BeanDefinition(到一个HashMap),具体是调用BeanDefinitionRegistry接口。

 

注意:这个过程并不包括依赖注入;依赖注入一般发生在第一次调用getBean时,但可以通过Bean的lazyinit属性调控。

下面具体讲这三个过程。

1.3 IoC详细初始化过程

1.3.1 BeaDefinition的Resource定位

Spring源码深度解析(容器方面)

在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)。

Spring源码深度解析(容器方面)

可以看到调用是从最上层的AbstractApplicaitonContext一步步往继承树子节点走。

  1. refresh()//AbstractApplicaitonContext

  2. 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。                                                      

  3. parseBeanDefinitionElement() //解析

    BeanDefinition只是一些静态配置信息,需要完成数据向容器的注册,才能完全发挥容器的作用。

1.3.3 BeanDefinition在容器的注册

1.private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();

将BeanName作为键, BeanDefinition作为值保存。

2.

Spring源码深度解析(容器方面)

1.4 依赖注入(Bean的加载)

<u>依赖注入是用户第一次向容器申请Bean时触发(例外:lazy-init,可以控制Bean的预实例化)。</u>

Spring源码深度解析(容器方面)

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