@EnableAspectJAutoProxy //第一种方式注解
<aop:aspectj-autoproxy> //第二种方式xml配置
spring aop 功能通过这二种方式激活:
spring 会根据 AspectJAutoProxyBeanDefinitionParser
解析类会注册一个 AnnotationAwareAspectJAutoProxyCreator 类的Bean定义
String AUTO_PROXY_CREATOR_BEAN_NAME = “org.springframework.aop.config.internalAutoProxyCreator”;
<aop:aspectj-autoproxy proxy-target-class=“false” expose-proxy=“false”></aop:aspectj-autoproxy>
AnnotationAwareAspectJAutoProxyCreator 分析
本质上还是一个BeanPostProcessor, 通过初始化bean时. 对实例进行代理实现AOP功能
AnnotationAwareAspectJAutoProxyCreator 继承自AspectJAwareAdvisorAutoProxyCreator 类
private List<Pattern> includePatterns;
private AspectJAdvisorFactory aspectJAdvisorFactory; //factory
private BeanFactoryAspectJAdvisorsBuilder aspectJAdvisorsBuilder; // builder
/**
* 检查给定的方面bean是否有资格进行自动代理
*/
protected boolean isEligibleAspectBean(String beanName) {
if (this.includePatterns == null) {
return true;
} else {
for (Pattern pattern : this.includePatterns) {
if (pattern.matcher(beanName).matches()) {
return true;
}
}
return false;
}
}
/**
* 初始化父类Bean工厂及本类工厂
*/
@Override
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
super.initBeanFactory(beanFactory);
if (this.aspectJAdvisorFactory == null) {
this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
}
// 继承BeanFactoryAspectJAdvisorsBuilder类
this.aspectJAdvisorsBuilder = new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
}
AspectJAwareAdvisorAutoProxyCreator 抽象类分析
// 顾问比较
private static final Comparator<Advisor> DEFAULT_PRECEDENCE_COMPARATOR = new AspectJPrecedenceComparator();
/**
* 按照AspectJ优先级对其余部分排序。如果两条建议来自同一方面，那么它们的顺序将是相同的
* 从同一方面提出的意见，则按照下列规则进一步排列:
* <ul>
* <li>如果这对中的任何一个在advice之后，那么最后声明的advice将获得最高的优先级(最后运行)</li>
* <li>否则，首先声明的通知将获得最高优先级(首先运行)</li>
* </ul>
* <p><b> 重要提示:</b> 建议器按优先级排序，从最高优先级到最低优先级。
* “在进入”连接点的“途中”，应该首先运行优先级最高的advisor工具。
* 在连接点的“退出”过程中，应该最后运行优先级最高的advisor工具
*/
protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
List<PartiallyComparableAdvisorHolder> partiallyComparableAdvisors = new ArrayList<>(advisors.size());
for (Advisor element : advisors) {
partiallyComparableAdvisors.add(new PartiallyComparableAdvisorHolder(element, DEFAULT_PRECEDENCE_COMPARATOR));
}
List<PartiallyComparableAdvisorHolder> sorted = PartialOrder.sort(partiallyComparableAdvisors);
if (sorted != null) {
List<Advisor> result = new ArrayList<>(advisors.size());
for (PartiallyComparableAdvisorHolder pcAdvisor : sorted) {
result.add(pcAdvisor.getAdvisor());
}
return result;
}
else {
return super.sortAdvisors(advisors);
}
}
AbstractAdvisorAutoProxyCreator 抽象类分析
private BeanFactoryAdvisorRetrievalHelper advisorRetrievalHelper; //bean工厂顾问检索(BeanFactory)
/**
* 初始化BeanFactory
*/
public void setBeanFactory(BeanFactory beanFactory) {
super.setBeanFactory(beanFactory); //初始化父类BeanFactory
if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
throw new IllegalArgumentException();
}
initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
}
/**
* 初始化BeanFactory
*/
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory);
}
/**
* 找到所有顾问, 返回数组数据
*/
protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
/**
* 找到所有合适的顾问自动代理这个类
*/
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
List<Advisor> candidateAdvisors = findCandidateAdvisors(); //通过工厂找到所有 @Advisor 注解的类
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
/**
* 找到所有替补顾问使用在自动代理
*/
protected List<Advisor> findCandidateAdvisors() {
Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
return this.advisorRetrievalHelper.findAdvisorBeans();
}
/**
* 搜索给定的候选顾问以查找所有可以应用于指定bean的顾问
*/
protected List<Advisor> findAdvisorsThatCanApply(
List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
ProxyCreationContext.setCurrentProxiedBeanName(beanName);
try {
return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
}
finally {
ProxyCreationContext.setCurrentProxiedBeanName(null);
}
}
AbstractAutoProxyCreator 抽象类
AbstractAutoProxyCreator 通过实现InstantationAwareBeanPostProcessor接口中postProcessBeforeInstantiation()方法是在创建对象调用构造函数之前通过ProxyFactory 类创建代理对象 。
ProxyFactory 的超类ProxyCreatorSupport中有个属性AopProxyFactory 代理工厂。 通过工厂可以获取AopProxy。
DefaultAopProxyFactory 是AopProxyFactory的默认实现…
《DefaultAopProxyFactory.java》
/**
* 默认使用Jdk动态代理
*/
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
// config.isOptimize() (默认false)
// config.isProxyTargetClass() (默认false)
// hasNoUserSuppliedProxyInterfaces(config) (是否有接口)
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " + "Either an interface or a target is required for proxy creation.");
}
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
InstantiationAwareBeanPostProcessor 接口(spring 扩展接口)
/**
* 初始化(即调用构造函数)之前处理
*/
Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName){
return null;
}
/**
* 初始化(即调用构造函数)之后处理
*/
boolean postProcessAfterInstantiation(Object bean, String beanName){
return true;
}
Advisor 接口 (顾问)
通知和顾问都是切面的实现方式！
通知是顾问的一个属性！
//通知接口的默认实现
Advice EMPTY_ADVICE = new Advice() {};
//获取通知
Advice getAdvice();
Advice 接口 (通知)
用于通知的标记接口。实现可以是任何类型的通知，比如拦截器