简介
在之前的文章里我们讨论过AOP技术的应用基础。在常用的几种方法里,我们比对了decorator pattern,InvocationHandler, CGLib和AspectJ。这些方法都是为了在现有设计和代码的基础上去增加新的功能而不需要对原有的部分做什么改动。但是从前面技术应用的实例来看,光有这些东西直接应用到实现里还是显得不太友好。于是spring AOP框架里就提供了一些相关的脚手架来方便我们使用它们。那么,我们该怎么使用这些基础代码呢?这些具体的基础代码里又是怎么实现的以达到我们使用方便的目的呢?这里针对常用的几个部分进行讨论。
几个基本概念
刚看spring aop的时候,很多人会被里面提到的几个概念给弄迷糊。比如JointPoint, Advice, Pointcut, Aspect, Weaving, Target, Introduction。这些东西看起来比较含糊又有点不好理解。其实,抛开这些概念的表面,我们从一个创造者的角度来看他们就相对来说简单一些了。
我们首先来看AOP的基本思想,它无非就是想在程序执行的某些点中间增加一些可以定义的逻辑。那么现在就有这么几个点需要考虑。一个是怎么定义程序中执行的点?是某个方法吗?应该怎么来描述这个程序中具体的点呢?另外一个,我们希望在特定的点增加什么样的逻辑呢?这些逻辑该定义在哪里?我们要添加的逻辑和程序执行的点应该耦合在一起吗?如果应该是松耦合的,那么该用什么办法把他们给结合在一起呢?还有一个就是,我们添加的逻辑和程序执行点之间的执行关系,我们是希望在这个点之前执行?还是之后?所有这些都需要通过某种方式用机器可以理解执行的方式来描述出来。
在进一步澄清这些具体的概念之前,我们先看一个示例:
假设我们定义有如下的类Agent:
package com.yunzero; public class Agent { public void speak() { System.out.println("Bond"); } }
类Agent很简单,就定义了一个speak方法。里面输出一个简单的字符串。
接着,我们定义一个AgentDecorator类,它相当于是对Agent类的增强:
package com.yunzero; import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.intercept.MethodInvocation; public class AgentDecorator implements MethodInterceptor { @Override public Object invoke(MethodInvocation invocation) throws Throwable { System.out.println("James "); Object retVal = invocation.proceed(); System.out.println("!"); return retVal; } }
这个类实现了一个特定的接口MethodInterceptor。在具体的实现里,我们加入了自定义的逻辑,也就是在invocation.proceed()方法的前后输出两行字符串。在上述代码里我们可以看到,我们相当于在方法的执行过程中间做的增强。而具体是对哪个方法做了增强呢?这里没有明确去指定哪个方法,而是对所有的方法都做了这个增强,我们在后续会接着讨论。
现在,我们再看怎么把原有代码和增强部分给结合起来:
package com.yunzero; import org.springframework.aop.framework.ProxyFactory; public class App { public static void main( String[] args ) { Agent target = new Agent(); ProxyFactory pf = new ProxyFactory(); pf.addAdvice(new AgentDecorator()); pf.setTarget(target); Agent proxy = (Agent) pf.getProxy(); target.speak(); System.out.println(""); proxy.speak(); } }
在实现里,我们创建了一个ProxyFactory对象,通过addAdvice将前面定义的AgentDecorator加入进去。然后通过setTarget方法将原有的Agent对象加入到其中。最后,通过getProxy方法返回一个同样Agent类型的对象,但是它却不一样了。在执行上述代码之后,会有如下的输出:
Bond James Bond !
从上述代码的实现过程我们可以看到。我们通过程序的方式定义好原有的对象,这个对象有自己的实现和功能。像Agent对象,这就是前面提到的Target。所以Target无非就是一个我们需要去增强功能的目标对象。
而上述我们实现的AgentDecorator则是增强的逻辑,它本身是对所有方法的实现做的一个增强。相当于前面提到的Advice。我们可以尝试修改一下原有的代码,比如说增加一个如下的类:
package com.yunzero; public class Chatter { public void chat() { System.out.println("Knock knock"); } }
然后在后面的组合代码里改成如下:
package com.yunzero; import org.springframework.aop.framework.ProxyFactory; public class App { public static void main( String[] args ) { Chatter target = new Chatter(); ProxyFactory pf = new ProxyFactory(); pf.addAdvice(new AgentDecorator()); pf.setTarget(target); Chatter proxy = (Chatter) pf.getProxy(); target.chat(); System.out.println(""); proxy.chat(); } }
我们仅仅是把原有的Agent对象换成Chatter对象,它对应的输出则变成:
Knock knock James Knock knock !
可见这里增强业务的逻辑和原有的业务逻辑是松耦合的,他们可以自由组合。我们在程序里切入的点,在前面Agent对象里是speak方法,而在Chatter对象里是chat方法。它就是我们程序的切入点,也就是之前概念里提到的Pointcut。当然,这里似乎没有显式的指定Pointcut。
综合前面的代码,我们其实只是定义了原有的逻辑和增强逻辑,然后通过ProxyFactory对象将他们组合在一起。可见,具体实现逻辑的组合的细节就隐藏在ProxyFactory里了。我们先针对这几个基本的概念进一步讨论一下,后续再来探索一下ProxyFactory的实现细节。
Advice
在前面的讨论里,我们已经知道,advice是在某个切入点执行的代码。在示例代码里也显示了通过实现MethodInterceptor接口的一种Advice。在实际的框架里,根据我们的需要有很多种Advice。它们详情如下面的列表:
Advice Name | Interface | 描述 |
Before | org.springframework.aop.MethodBeforeAdvice | 在切入点之前执行自定义的逻辑。在Advice中出现异常的时候会后续的执行将会被跳过。 |
After-Returning | org.springframework.aop.AfterReturningAdvice | |
After(finally) | org.springframework.aop.AfterAdvice | 这个Advice会在被切入的方法执行失败或者抛异常的情况下也执行。 |
Around | org.aopalliance.intercept.MethodInterceptor | 这是通过AOP Alliance标准的实现,因为是对原有方法的一个深度定义,我们甚至可以跳过原来的实现用以替换成我们自己的实现。 |
Throws | org.springframework.aop.ThrowsAdvice | 在被切入的方法出现异常的时候执行。 |
Introduction | org.springframework.aop.IntroductionInterceptor |
我们在实际的使用中可以根据需要选择实现的接口就可以了。Advice接口以及相关的各种扩展接口的类关系如下图:
从上图的结构中也可以看到,在绝大多数的情况下Advice的执行情况都给定义好了。
Pointcut
在前面的讨论里有提到,spring里的切入点就是某个方法。前面的示例只是给了一个笼统的对所有方法都进行织入的做法。在具体的实现里,我们还需要根据不同的要求来定义程序的切入点。比如说,有的时候我们需要指定针对某些特定的类下面的方法作为切入点。有的时候我们需要匹配某些符合特定命名规则的方法,等等。所有这一切都表明了,我们需要有比较丰富的描述手段来支持这些需求。
在spring里,有专门的接口Pointcut来定义这一部分的描述。像Pointcut接口的定义如下:
public interface Pointcut { ClassFilter getClassFilter(); MethodMatcher getMethodMatcher(); Pointcut TRUE = TruePointcut.INSTANCE; }
这里定义了两个方法,一个返回ClassFilter对象,一个返回MethodMatcher对象。从名字上来看,这应该是分别用于过滤类名字和方法名字的。
ClassFilter和MethodMatcher的定义分别如下:
@FunctionalInterface public interface ClassFilter { boolean matches(Class<?> clazz); ClassFilter TRUE = TrueClassFilter.INSTANCE; }
public interface MethodMatcher { boolean matches(Method method, @Nullable Class<?> targetClass); boolean isRuntime(); boolean matches(Method method, @Nullable Class<?> targetClass, Object... args); MethodMatcher TRUE = TrueMethodMatcher.INSTANCE; }
很显然,ClassFilter里的matches方法就是根据class对象来判断,如果符合给定的要求,就返回true。否则就是false。而MethodMatcher里有两个matches方法,后面一个方法多了一系列的可选参数。这个方法可以用在动态运行的时候,根据方法调用的参数值进行检查判断。而前一个方法则是根据静态的方法属性和class对象来判断。
既然要实现查找和定位执行点就是要实现Pointcut接口,而实现这个接口就牵涉到返回ClassFilter和MethodMatcher对象。总的来说,要自己手工实现这一系列的接口还是比较麻烦的。所以spring里提供了一系列的实现。如下表:
实现类 | 描述 |
org.springframework.aop.support.annotation.AnnotationMatchingPointcut | 通过查找在类或者方法上定义的特定annotation来定位执行点。 |
org.springframework.aop.aspectj.AspectJExpressionPointcut | 那个AspectJ weaver来检查aspectJ的pointcut表达式。这是一种看起来有点像正则表达式的描述形式。 |
org.springframework.aop.support.ComposablePointcut | 将多个切入点组合到一起的pointcut。本身相当于一个辅助功能。 |
org.springframework.aop.support.ControlFlowPointcut | 符合某个方法里面控制流的切入点。 |
org.springframework.aop.support.DynamicMethodMatcherPointcut | 作为构造动态切入点的基类。 |
org.springframework.aop.support.JdkRegexpMethodPointcut | 通过构造正则表达式的方式来查找匹配切入点。 |
org.springframework.aop.support.NameMatchMethodPointcut | 通过简单的名字匹配来查找切入点。 |
org.springframework.aop.support.StaticMethodMatcherPointcut | 作为构造静态切入点的基类。 |
这些详细的Pointcut与子类的关系结构如下图:
有了这些描述之后,我们再来看看该怎么具体应用Pointcut接口的实现。
假设我们有两个类GoodGuitarist 和GreatGuitarist,它们都实现接口Singer:
public interface Singer { void sing(); }
public class GoodGuitarist implements Singer { @Override public void sing() { System.out.println("Who says I can't be free \n From all of the things that I used to be"); } }
public class GreatGuitarist implements Singer { @Override public void sing() { System.out.println("I shot the sheriff, \n But I did not shoot the deputy"); } }
这部分非常简单。然后我们定义一个Advice:
import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.intercept.MethodInvocation; public class SimpleAdvice implements MethodInterceptor { @Override public Object invoke(MethodInvocation invocation) throws Throwable { System.out.println(">> Invoking " + invocation.getMethod().getName()); Object retVal = invocation.proceed(); System.out.println(">> Done\n"); return retVal; } }
结合前面的讨论可以看到,这是一个Around advice。它主要打印当前调用的方法名。我们再定义一个Pointcut,这次是通过继承StaticMethodMatcherPointcut:
import java.lang.reflect.Method; import org.springframework.aop.ClassFilter; import org.springframework.aop.support.StaticMethodMatcherPointcut; public class SimpleStaticPointcut extends StaticMethodMatcherPointcut { @Override public boolean matches(Method method, Class<?> targetClass) { return ("sing".equals(method.getName())); } @Override public ClassFilter getClassFilter() { return cls -> (cls == GoodGuitarist.class); } }
里面的实现也很直白。找到sing方法。并且在getClassFilter里判断要求是GoodGuitarist class的类型。
然后,我们将它们两者结合起来使用:
public class App { public static void main( String[] args ) { GoodGuitarist johnMeyer = new GoodGuitarist(); GreatGuitarist ericClapton = new GreatGuitarist(); Singer proxyOne; Singer proxyTwo; Pointcut pc = new SimpleStaticPointcut(); Advice advice = new SimpleAdvice(); Advisor advisor = new DefaultPointcutAdvisor(pc, advice); ProxyFactory pf = new ProxyFactory(); pf.addAdvisor(advisor); pf.setTarget(johnMeyer); proxyOne = (Singer)pf.getProxy(); pf = new ProxyFactory(); pf.addAdvisor(advisor); pf.setTarget(ericClapton); proxyTwo = (Singer)pf.getProxy(); proxyOne.sing(); proxyTwo.sing(); } }
这里,我们定义了一个DefaultPointcutAdvisor,然后将前面构造好的Pointcut和Advice传入其中。ProxyFactory然后调用了addAdvisor。最后执行的时候输出如下:
>> Invoking sing Who says I can't be free From all of the things that I used to be >> Done I shot the sheriff, But I did not shoot the deputy
可见,虽然都设置了target,但是只有GoodGuitarist的sing方法被加入了这些内容,而另外一个类没有。这里就引出了另外一个东西,就是我们刚才看到的Advisor。我们定义了Advice,表示要加入的内容是什么。我们也定义了Pointcut,表示在哪个地方加。而Advisor就表示它们的一个组合。就是在哪个点做什么这么个意思。这里的Advisor就相当于书面上定义的aspect。
在spring里,为了实现支持不同的Advice和Pointcut的组合,它里面也定义了一系列的Advisor。整体的结构如下图所示:
这些新定义的Advisor实现是为了使得前面定义Advice, Pointcut再将它们组合起来的过程更加便利一些。
proxyfactory
前面讨论了半天,基本上明白了Advice, Pointcut, Advisor的含义以及应用场景。从使用的角度来说,我们无非就是定义好它们,然后通过调用ProxyFactory的对象来设置Advice, Pointcut,target或者Advisor。那么,ProxyFactory到底是怎么做的才实现了对我们定义的这些对象的组合呢?我们进一步探索一下。
我们首先看一下ProxyFactory相关的类结构图:
我们在getProxy方法的时候返回的对象就好像有了特殊的功能。而从类结构图里可以看到,前面继承的接口Adviced就有设置Advisor, TargetSource等操作。这些就为了后面的设置打下基础。既然是在getProxy方法的时候发现它的变化,我们就从这个方法跟进去看一下。
在ProxyFactory里,getProxy方法的定义如下:
public Object getProxy() { return createAopProxy().getProxy(); }
而createAopProxy方法的实现如下:
protected final synchronized AopProxy createAopProxy() { if (!this.active) { activate(); } return getAopProxyFactory().createAopProxy(this); }getAopProxyFactory的方法返回了一个引用的接口AopProxyFactory:
相关推荐
3. **工厂方法模式(Factory Method)**:Spring AOP中的`ProxyFactory`是一个典型的工厂方法模式实现,它根据不同的条件创建不同的代理对象,将实例化推迟到子类,提供了更大的灵活性。 4. **原型模式(Prototype...
在讨论Spring AOP(面向切面编程)时,首先需要理解几个核心概念。Spring AOP 是Spring框架提供的一个功能模块,它允许开发者将横切关注点(cross-cutting concerns)从业务逻辑中解耦出来,通过在方法调用前后进行...
Spring AOP的核心类包括`org.springframework.aop.framework.ProxyFactoryBean`、`org.springframework.aop.framework.ProxyFactory`、`org.springframework.aop.aspectj.autoproxy.AspectJAutoProxyCreator`等。...
- 使用`org.springframework.aop.framework.ProxyFactory`等接口来手动配置和创建包含通知的代理。 8. **动态代理**: - Spring AOP支持自动动态代理,根据需要创建代理实例。 9. **TargetSource替换**: - ...
最后,通过Spring的ProxyFactory创建代理对象,配置Advice,运行客户端代码,实现了在调用sayHello()前后插入自定义的行为。 需要注意的是,Spring AOP的实现并不局限于Eclipse环境,它可以在任何Java环境中使用。...
Spring AOP(面向切面编程)是Spring框架的一个重要组成部分,它通过预定义的切点(Pointcut)来拦截方法的调用,并将横切关注点(如日志、事务管理等)与业务逻辑分离。本知识点将围绕Spring AOP的核心组件进行分析...
<bean id="proxyFactory" class="org.springframework.aop.framework.ProxyFactoryBean"> <value>beforeAdvice <value>afterReturningAdvice ``` 2. **AspectJ**: - 是 Java 社区中最流行且功能...
Spring AOP源码02:ProxyFactory Spring AOP源码03:JdkDynamicAopProxy Spring AOP源码04:MethodInvocation 拦截器调用 Spring AOP源码05:DefaultAdvisorAutoProxyCreator Spring期末考压轴题:当Spring AOP遇上...
Java动态代理是Java提供的一种在运行时创建新类型对象的技术,它可以让我们在不修改原有代码的情况下,对方法的调用进行增强,这正是Spring AOP(面向切面编程)的核心思想。Spring AOP通过代理模式实现了对业务逻辑...
- **Spring AOP 的织入机制**:由 ProxyFactory 或 ProxyFactoryBean 在运行时自动完成。 ##### Target(目标对象) - **定义**:需要应用 Aspect 功能的对象。 - **实例化**:通常是一个具体的 Java 对象。 ####...
在Spring框架中,AOP(面向切面编程)是一个核心特性,它允许我们在不修改代码的情况下,对程序的行为进行统一的管理和控制。`ProxyFactoryBean`是Spring AOP实现中的一个重要类,它用于创建代理对象,使我们能够...
5. Weaving(编织):将切面应用到目标对象的过程,Spring AOP在运行时完成这个过程,通过ProxyFactory或ProxyFactoryBean。 二、AOP种类 1. 静态织入:在编译时完成,如AspectJ。 2. 动态织入:运行时进行,Spring...
- **使用ProxyFactory创建AOP代理**:另一种创建AOP代理的方式。 - **操作被通知的对象**:如何访问被代理的对象。 - **使用auto-proxy功能**:Spring自动代理机制。 - **事务管理** - **事务管理介绍**:...
使用`ProxyFactory`或`AopProxyFactoryBean`来创建代理,并将通知添加到代理工厂中。 总结起来,Spring AOP的通知类型提供了灵活的扩展机制,使得我们可以在不修改业务代码的前提下,实现如日志记录、事务管理、...
- **AOP代理**:`org.springframework.aop.ProxyFactoryBean`或`org.springframework.aop.framework.ProxyFactory`,创建AOP代理对象,实现切面逻辑。 - **事件驱动**:`ApplicationEvent`和`ApplicationListener`...
- `org.springframework.aop.framework.ProxyFactory`:这是一个非bean工厂类,提供了与`ProxyFactoryBean`相似的功能,但不依赖于IoC容器。 - `org.springframework.aop.framework.Advised`:这个接口定义了对代理...
### Spring AOP 源码深度剖析 #### 一、Spring AOP 介绍与核心概念 Spring AOP(面向切面编程)是Spring框架提供的一个强大的功能模块,它支持通过预编译方式和运行期动态代理实现AOP。在Spring框架中,AOP的核心...
在Spring框架中,AOP(面向切面编程)是一种强大的工具,它允许程序员定义横切关注点,并将这些关注点与应用程序的业务逻辑分离。在本篇笔记中,我们将深入探讨Spring AOP的核心流程,特别是在目标方法执行时的拦截...
7.7. 使用ProxyFactory通过编程创建AOP代理 7.8. 操作被通知对象 7.9. 使用“自动代理(autoproxy)”功能 7.9.1. 自动代理bean定义 7.9.1.1. BeanNameAutoProxyCreator 7.9.1.2. DefaultAdvisorAutoProxyCreator ...
Spring AOP 是 Spring 框架中的一个核心特性,它实现了面向切面编程(AOP)的概念,使得开发者能够方便地处理系统中的横切关注点,例如事务管理、日志记录、性能监控等。AOP 的核心概念包括连接点、切点、增强、目标...