springAOP（一）实现原理

spring内部使用了jdk动态代理、cglib&＃xff08;通过生成字节码的方式&＃xff0c;继承目标类扩展目标类功能&＃xff09;两种方式实现了AOP框架。本篇先详细介绍spring内部的AOP概念实体、之后介绍spring AOP的使用方式和原理

实现原理

spring内部使用了jdk动态代理、cglib这两种机制构建了整个AOP框架的基础

JDK动态代理

我们可以通过反射技术&＃xff0c;为需要代理的目标对象&＃xff0c;创造一个代理类出来&＃xff0c;并且在代理类中执行我们所需要的逻辑&＃xff0c;如&＃xff1a;统计方法执行时间、打印日志。
相对于cglib技术&＃xff0c;JDK动态代理存在两个比较明显的缺点&＃xff1a;

1. 目标对象必须是通过实现接口的类&＃xff0c;才能创建代理
2. 在运行时&＃xff0c;使用反射进行扩展目标对象功能&＃xff0c;性能会略低于cglib字节码技术的实现方式

// 一个需要进行代理的接口
public interface Greeting {void sayHi(String name);void sayByte(String name);
}// 接口实现类&＃xff0c;即目标对象。
// 我们需要在不改变该实现类代码的基础上&＃xff0c;在执行接口方法时&＃xff0c;进行一些额外的功能
public class GreetingImpl implements Greeting {&＃64;Overridepublic void sayHi(String name) {System.out.println(name);}&＃64;Overridepublic void sayByte(String name) {System.out.println(name);}
}// 实现一个InvocationHandler&＃xff0c;用于执行额外功能&＃xff0c;并且调用目标对象的方法
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;/*** created by luhuancheng on 2018/11/17* &＃64;author luhuancheng*/
public class LogInvocationHandler implements InvocationHandler {private Object target;public LogInvocationHandler(Object target) {this.target &＃61; target;}&＃64;Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("Before execute"); // 在执行目标对象方法之前&＃xff0c;打印日志Object result &＃61; method.invoke(target, args); // 执行目标对象的方法System.out.println("After execute"); // 在执行目标对象方法之后&＃xff0c;打印日志return result;}
}// 创建动态代理
public class DynamicProxy {public static void main(String[] args) {Greeting greeting &＃61; new GreetingImpl();Object proxyInstance &＃61; Proxy.newProxyInstance(DynamicProxy.class.getClassLoader(), new Class[]{Greeting.class}, new LogInvocationHandler(greeting));Greeting proxy &＃61; (Greeting) proxyInstance;proxy.sayHi("luhuancheng");proxy.sayByte("luhuancheng");}
}


cglib字节码技术

当我们要代理的目标对象&＃xff0c;并不是由一个接口实现时。我们无法通过JDK动态代理来进行代理对象的创建&＃xff0c;这时候就需要cglib这种字节码技术的登场了。

// 需要被代理的目标类&＃xff0c;该类没有实现任何一个接口
public class Requestable {public void request() {System.out.println("request in Requestable without implementint any interface");}
}import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;// 实现cglib的方法拦截器接口
public class RequestableCallback implements MethodInterceptor {private static final String INTERCEPTOR_METHOD_NAME &＃61; "request";&＃64;Overridepublic Object intercept(Object target, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {if (INTERCEPTOR_METHOD_NAME.equals(method.getName())) {System.out.println("Before execute");Object result &＃61; methodProxy.invokeSuper(target, args);System.out.println("After execute");return result;}return null;}
}import net.sf.cglib.proxy.Enhancer;// cglib代理实现-动态字节码生成技术扩展对象行为&＃xff08;对目标对象进行继承扩展&＃xff09;
public class CglibProxy {public static void main(String[] args) {Enhancer enhancer &＃61; new Enhancer();enhancer.setSuperclass(Requestable.class);enhancer.setCallback(new RequestableCallback());Requestable proxy &＃61; (Requestable) enhancer.create();proxy.request();}
}

AOP概念实体

JoinPoint

JoinPoint&＃xff0c;可以理解为执行切面动作的一个时机。如&＃xff1a;构造方法调用时&＃xff0c;字段设置时&＃xff0c;方法调用时&＃xff0c;方法执行时。但在spring AOP中&＃xff0c;仅支持方法执行时的JoinPoint。

类图

Pointcut

Pointcut&＃xff0c;是我们在开发AOP功能时&＃xff0c;定义的一个帮助我们捕捉系统中的相应JoinPoint的规则。

类图

1. ClassFilter, 用于匹配被执行织入操作的对象。如果类型对于我们要捕获的JoinPoint无关的话&＃xff0c;可以使用TruePointcut类
2. MethodMatcher&＃xff0c;用于匹配被执行织入操作的方法 。从大的分类可以分为两类&＃xff1a;StaticMethodMatcher&＃xff08;不关心Pointcut具体参数&＃xff09;、DynamicMethodMatcher&＃xff08;关系Pointcut具体参数&＃xff09;
3. StaticMethodMatcherPointcut继承了StaticMethodMatcher而且实现接口Pointcut&＃xff0c;其自身可以作为Pointcut和MethodMatcher
4. NameMatchMethodPointcut&＃xff0c;根据指定的方法名和JoinPoint方法名进行匹配
5. JdkRegexpMethodPointcut&＃xff0c;使用正则表达式与JoinPoint方法名进行匹配
6. AnnotationMatchingPointcut&＃xff0c;根据目标类中是否存在指定类型的注解来匹配JoinPoint
7. ComposablePointcut&＃xff0c;可以进行逻辑运算的Pointcut
8. DynamicMethodMatcherPointcut&＃xff0c;继承了DynamicMethodMatcher而且实现接口Pointcut&＃xff0c;其自身可以作为Pointcut和MethodMatcher

Advice

Advice&＃xff0c;定义了AOP功能中的横切逻辑

类图

BeforeAdvice

横切逻辑将在相应的JoinPoint执行之前执行

AfterAdvice

横切逻辑将在相应的JoinPoint执行之后执行。该接口又派生了两个子接口ThrowsAdvice、AfterReturningAdvice

ThrowsAdvice

横切逻辑将在相应的JoinPoint执行异常时执行

// ThrowsAdvice是一个没有定义方法的标记接口&＃xff0c;但是在横切逻辑执行时&＃xff0c;
// spring AOP内部会通过反射的方式&＃xff0c;检测ThrowsAdvice实现类的方法。
// 我们可以定义以下三个方法&＃xff0c;分别处理不同的异常
public class ExceptionBarrierThrowsAdvice implements ThrowsAdvice {public void afterThrowing(Throwable t) {// 普通异常处理逻辑}public void afterThrowing(RuntimeException e) {// 运行时异常处理逻辑}public void afterThrowing(Method method, Object[] args, Object target, ApplicationException e) {// 处理应用程序生成的异常}}/*** 业务异常类*/
class ApplicationException extends RuntimeException {}


AfterReturningAdvice

横切逻辑将在相应的JoinPoint正常执行返回时执行

MethodInterceptor

作为Spring AOP的环绕方法&＃xff08;Around Advice&＃xff09;&＃xff0c;可以拦截相应的JoinPoint方法执行&＃xff0c;从而在JoinPoint执行的前、正常返回、执行后这三个地方进行横切逻辑的切入

public class PerformanceMethodInterceptor implements MethodInterceptor {&＃64;Overridepublic Object invoke(MethodInvocation invocation) throws Throwable {long start &＃61; System.currentTimeMillis();try {// 调用目标方法return invocation.proceed();} finally {System.out.println(String.format("cost time: %d", System.currentTimeMillis() - start));}}
}


IntroductionInterceptor

Spring AOP框架中实现Introduction的接口。Introduction功能可以在不改变类的定义的情况下&＃xff0c;为目标类增加新的接口或属性

Advisor&＃xff08;对应AOP世界中的切面&＃xff0c;Aspect。&＃xff09;

Advisor&＃xff0c;代表了spring中的Aspect。
分为两大类&＃xff1a;PointcutAdvisor、IntroductionAdvisor

类图

PointcutAdvisor

PointcutAdvisor&＃xff0c;默认存在三个实现类DefaultPointcutAdvisor、NameMatchMethodPointcutAdvisor、RegexpMethodPointcutAdvisor

DefaultPointcutAdvisor

DefaultPointcutAdvisor作为PointcutAdvisor比较通用的一个实现类&＃xff0c;我们可以为其设置Pointcut、Advice。伪代码如下&＃xff1a;

Pointcut pointcut &＃61; ...
Advice advice &＃61; ...
DefaultPointcutAdvisor advisor &＃61; new DefaultPointcutAdvisor();
advisor.setPointcut(pointcut);
advisor.setAdvice(advice);


NameMatchMethodPointcutAdvisor

NameMatchMethodPointcutAdvisor&＃xff0c;其内部持有一个NameMatchMethodPointcut实例作为pointcut。可以通过setMappedName(String mappedName)或者setMappedNames(String... mappedNames)操作pointcut&＃xff0c;设置匹配的Pointcut方法名

RegexpMethodPointcutAdvisor

RegexpMethodPointcutAdvisor&＃xff0c;其内部持有一个AbstractRegexpMethodPointcut实现类的实例pointcut&＃xff08;默认为JdkRegexpMethodPointcut&＃xff09;&＃xff0c;使用setPattern(String pattern)或者setPatterns(String... patterns)设置正则表达式用于匹配JoinPoint方法名

DefaultBeanFactoryPointcutAdvisor

DefaultBeanFactoryPointcutAdvisor,间接继承了BeanFactoryAware&＃xff0c;其内部持有beanfactory。在指定advice时&＃xff0c;可以通过方法setAdviceBeanName(String adviceBeanName)指定advice在beanfactory中的唯一name。之后在需要Advice时&＃xff0c;将从beanfactory中获取&＃xff0c;减少了容器启动初期Advice和Advisor之间的耦合

IntroductionAdvisor

DefaultIntroductionAdvisor

DefaultIntroductionAdvisor作为唯一的Introduction类型的Advice&＃xff0c;只能使用于Introduction场景。

spring AOP织入原理

在spring AOP中&＃xff0c;可以通过ProxyFactory、ProxyFactoryBean、AbstractAutoProxyCreator(及其实现类)来执行织入

ProxyFactory

我们来看看ProxyFactory这个最基本的织入器是如何工作的。其步骤大致分为以下几步&＃xff1a;

1. 将目标对象传入构造器&＃xff0c;实例化一个ProxyFactory
2. 调用ProxyFactory相关方法&＃xff0c;设置所需的参数。如&＃xff1a;是否使用cglib优化setOptimize(true)、代理类setProxyTargetClass(true)
3. 指定要织入的接口&＃xff08;这个步骤可选&＃xff0c;代码内部会根据目标对象检测到接口&＃xff09;
4. 实例化切面&＃xff08;即Advisor&＃xff09;&＃xff0c;设置切面逻辑&＃xff08;将Advice实现类实例设置进Advisor实现类中&＃xff09;
5. 调用ProxyFactory.getProxy()获取代理类
6. 执行代理类

基于接口

/**
* 基于接口的织入 - JDK动态代理
*/
private static void forInterface() {// 1. 需要被拦截的接口实现类ITask task &＃61; new TaskImpl();// 2. 实例化一个执行织入操作的ProxyFactoryProxyFactory weaver &＃61; new ProxyFactory(task);// 我们也可以让基于接口的织入&＃xff0c;使用cglib的方式weaver.setProxyTargetClass(true);weaver.setOptimize(true);// 3. 指定需要织入的接口weaver.setInterfaces(ITask.class);// 4. 定义切面NameMatchMethodPointcutAdvisor advisor &＃61; new NameMatchMethodPointcutAdvisor();advisor.setMappedName("execute");// 5. 指定切面逻辑advisor.setAdvice(new PerformanceMethodInterceptor());// 6. 将切面添加到ProxyFactory实例中weaver.addAdvisor(advisor);// 7. 执行织入&＃xff0c;返回织入后的代理实例ITask proxyObject &＃61; (ITask) weaver.getProxy();// 8. 调用接口&＃xff0c;此时的执行逻辑中织入了切面逻辑proxyObject.execute();System.out.println(proxyObject);System.out.println(task);
}


基于类

/**
* 基于类的织入 - CGLIB
*/
private static void forClass() {// 1. 实例化一个执行织入操作的ProxyFactory&＃xff0c;作为织入器ProxyFactory weaver &＃61; new ProxyFactory(new Excutable());// 2. 实例化Advisor&＃xff08;切面&＃xff09;NameMatchMethodPointcutAdvisor advisor &＃61; new NameMatchMethodPointcutAdvisor();advisor.setMappedName("execute");// 3. 为Advisor设置切面逻辑advisor.setAdvice(new PerformanceMethodInterceptor());// 4. 为织入器设置切面weaver.addAdvisor(advisor);// 5. 执行织入Excutable proxyObject &＃61; (Excutable) weaver.getProxy();// 6. 调用接口&＃xff0c;此时的执行逻辑中织入了切面逻辑proxyObject.execute(); // 使用cglib&＃xff0c;第一次执行需要动态生成字节码&＃xff0c;效率比动态代理低。proxyObject.execute(); // 再次使用cglib&＃xff0c;直接执行第一次调用生成的字节码&＃xff0c;效率比动态代理高System.out.println(proxyObject.getClass());
}


Introduction织入

private static void forIntroduction() {ProxyFactory weaver &＃61; new ProxyFactory(new DevloperImpl());weaver.setInterfaces(IDevloper.class, ITester.class);TesterFeatureIntroductionInterceptor advice &＃61; new TesterFeatureIntroductionInterceptor();weaver.addAdvice(advice);
// DefaultIntroductionAdvisor advisor &＃61; new DefaultIntroductionAdvisor(advice);
// weaver.addAdvisor(advisor);Object proxy &＃61; weaver.getProxy();((ITester) proxy).test();((IDevloper) proxy).develSoftware();
}


ProxyFactory内部机制

类图

AopProxy

AopProxy对使用不同实现机制的代理进行了抽象。提供两个接口用于生成代理对象

Object getProxy();
Object getProxy(ClassLoader classLoader);


ProxyConfig

提供了5个属性用于配置控制代理对象生成的过程

private boolean proxyTargetClass &＃61; false;private boolean optimize &＃61; false;boolean opaque &＃61; false;boolean exposeProxy &＃61; false;private boolean frozen &＃61; false;


Advised

提供接口用于配置生成代理的必要配置信息&＃xff0c;比如Advice、Advisor等

AopProxyFactory

作为AopProxy的抽象工厂

DefaultAopProxyFactory

AopProxyFactory默认实现&＃xff0c;通过接口根据AdvisedSupport提供的配置信息创建代理

AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException;


ProxyFactory

作为基本的织入器&＃xff0c;继承了ProxyCreatorSupport&＃xff08;为了统一管理生成不同类型的AopProxy&＃xff0c;将生成逻辑抽象到了这个类中&＃xff09;。ProxyCreatorSupport持有了一个AopProxyFactory类型的实例&＃xff0c;默认为DefaultAopProxyFactory

主流程

ProxyFactoryBean&＃xff08;容器内织入&＃xff09;

使用ProxyFactory我们可以独立于spring的IOC容器来使用spring AOP框架。但是便于我们管理Pointcut、Advice等相关的bean&＃xff0c;我们一般利用IOC容器来进行管理。在IOC容器中&＃xff0c;使用ProxyFactoryBean来进行织入

类图

可以看出ProxyFactoryBean实现了接口FactoryBean&＃xff0c;其实现如下&＃xff1a;

public class ProxyFactoryBean extends ProxyCreatorSupportimplements FactoryBean<Object>, BeanClassLoaderAware, BeanFactoryAware {private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {if (this.advisorChainInitialized) {return;}// 当拦截器名称列表不为空时&＃xff0c;初始化advisor chainif (!ObjectUtils.isEmpty(this.interceptorNames)) {// 需要根据interceptorName从beanfactory中取到对应advisor的实例&＃xff0c;所以beanfactory不能为nullif (this.beanFactory &＃61;&＃61; null) {throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " &＃43;"- cannot resolve interceptor names " &＃43; Arrays.asList(this.interceptorNames));}// Globals can&＃39;t be last unless we specified a targetSource using the property...if (this.interceptorNames[this.interceptorNames.length - 1].endsWith(GLOBAL_SUFFIX) &&this.targetName &＃61;&＃61; null && this.targetSource &＃61;&＃61; EMPTY_TARGET_SOURCE) {throw new AopConfigException("Target required after globals");}// Materialize interceptor chain from bean names.for (String name : this.interceptorNames) {if (logger.isTraceEnabled()) {logger.trace("Configuring advisor or advice &＃39;" &＃43; name &＃43; "&＃39;");}// 如果name以符号"*"结尾&＃xff0c;则从beanfactory中获取beanname为name&＃xff08;去掉*&＃xff09;开头的所有Advisor、Interceptor类型的bean&＃xff0c;注册为Advisorif (name.endsWith(GLOBAL_SUFFIX)) {if (!(this.beanFactory instanceof ListableBeanFactory)) {throw new AopConfigException("Can only use global advisors or interceptors with a ListableBeanFactory");}addGlobalAdvisor((ListableBeanFactory) this.beanFactory,name.substring(0, name.length() - GLOBAL_SUFFIX.length()));}// 普通的name&＃xff08;即非*号匹配的bean&＃xff09;&＃xff0c;则直接从beanfactory获取&＃xff0c;添加到advisor chain中else {// If we get here, we need to add a named interceptor.// We must check if it&＃39;s a singleton or prototype.Object advice;if (this.singleton || this.beanFactory.isSingleton(name)) {// Add the real Advisor/Advice to the chain.advice &＃61; this.beanFactory.getBean(name);}else {// It&＃39;s a prototype Advice or Advisor: replace with a prototype.// Avoid unnecessary creation of prototype bean just for advisor chain initialization.advice &＃61; new PrototypePlaceholderAdvisor(name);}addAdvisorOnChainCreation(advice, name);}}}// 标记已初始化this.advisorChainInitialized &＃61; true;}private synchronized Object getSingletonInstance() {if (this.singletonInstance &＃61;&＃61; null) {// 根据targetName从beanfactory中获取目标对象this.targetSource &＃61; freshTargetSource();if (this.autodetectInterfaces && getProxiedInterfaces().length &＃61;&＃61; 0 && !isProxyTargetClass()) {// Rely on AOP infrastructure to tell us what interfaces to proxy.Class targetClass &＃61; getTargetClass();if (targetClass &＃61;&＃61; null) {throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");}// 自动识别目标对象的接口&＃xff0c;设置到interfaces属性中setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));}// Initialize the shared singleton instance.super.setFrozen(this.freezeProxy);// 生成代理对象this.singletonInstance &＃61; getProxy(createAopProxy());}return this.singletonInstance;}&＃64;Overridepublic Object getObject() throws BeansException {// 初始化advisor chaininitializeAdvisorChain();if (isSingleton()) {// 获取单例的代理return getSingletonInstance();}else {if (this.targetName &＃61;&＃61; null) {logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " &＃43;"Enable prototype proxies by setting the &＃39;targetName&＃39; property.");}// 获取原型的代理&＃xff08;每次都会重新生成代理对象&＃xff09;return newPrototypeInstance();}}
}

使用AbstractAutoProxyCreator实现类&＃xff08;自动织入&＃xff09;

从类图可以看出&＃xff0c;所有的AutoProxyCreator都间接实现了接口InstantiationAwareBeanPostProcessor。而InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation方法提供了一个机会&＃xff0c;让注册到beanfactory中的bean在实例化之前&＃xff0c;可以有一个创建实例的嵌入逻辑。具体可以看下springIOC容器实例化bean实例的过程分析

从类图可以看出&＃xff0c;所有的AutoProxyCreator都间接实现了接口InstantiationAwareBeanPostProcessor。而InstantiationAwareBeanPostProcessor#postProcessAfterInitialization方法提供了一个机会&＃xff0c;完成代理对象的创建&＃xff0c;并缓存到容器中&＃xff0c;供后续使用

BeanNameAutoProxyCreator

使用BeanNameAutoProxyCreator的伪代码

TargetClass target1 &＃61; new TargetClass();
TargetClass target2 &＃61; new TargetClass();BeanNameAutoProxyCreator autoProxyCreator &＃61; new BeanNameAutoProxyCreator();
// 指定目标实例的beanname
autoProxyCreator.setBeanNames("target1", "target2");
// 指定Advice&＃xff08;切面逻辑&＃xff09;
autoProxyCreator.setInterceptorNames("a interceptor name");// 完成以上配置的BeanNameAutoProxyCreator&＃xff0c;注册到IOC容器时&＃xff0c;将自动完成对target1、target2两个bean进行织入切面逻辑


总结

总结一下&＃xff1a;

1. 我们了解了spring aop中AOP实体的实现类&＃xff1a;JoinPoint、Pointcut、Advice、Advisor&＃xff08;Aspect&＃xff09;等
2. 使用ProxyFactory在容器外进行切面逻辑的织入
3. 使用ProxyFactoryBean在容器管理Advice、Advisor实例bean的基础上&＃xff0c;进行切面逻辑的织入
4. 使用AbstractAutoProxyCreator的实现类&＃xff0c;通过一些配置可以实现在容器启动时&＃xff0c;自动生成代理类。免去了手动生成代理类的过程

以下内容就是spring aop框架的实现原理&＃xff0c;可以看到创建aop的过程相当的繁琐&＃xff0c;并且如果使用这种方式来创建代理类&＃xff0c;织入切面逻辑的话&＃xff0c;存在大量的模板代码。在spring2.0中&＃xff0c;使用了一种全新的方法来简化我们开发AOP的流程。我们在下篇文章进行分析吧