本文介绍 Spring AOP 技术的基础概念与应用场景，包括 AOP 的核心术语、通知类型及其实现方式。并通过三个示例详细讲解了如何使用 Spring AOP 进行面向切面编程，涵盖不带切点的切面、带切点的切面和自动代理模式。
AOP技术是面向切面编程，采取横向抽取机制，取代了传统继承体系的重复性代码（性能监视、事务管理、安全检查、缓存）。Spring的AOP使用纯java语言编写，不需要专门的编译过程和类加载过程，在运行期采用动态代理方式向目标类织入增强的代码。
AOP的相关术语：
JoinPoint（连接点）：被拦截的点，在Spring中所谓的点就是方法，Spring值支持方法类型的连接点。
CutPoint(切入点):对哪些连接点进行拦截的定义。
Adivice（通知/增强）：拦截到JoinPoint后要做的事就叫做通知。通知分为前置通知、后置通知、环绕通知、异常通知、最终通知。
Introduction(引介)：引介是一种特殊的通知，在不修改代码的前提下，可以动态的为类添加属性和方法。
Target(目标)：代理的目标对象。
Weaving(织入)：把增强应用到目标对象来创建代理对象的过程。Spring采用动态代理织入，而AspectJ采用编译器织入和类装载期织入。
Proxy(代理)：一个类被AOP增强后，就产生一个结果代理类
Aspect(切面)：是切入点和通知（引介）的结合。
Spring中AOP技术的底层原理
JDK动态代理：对接口或实现接口的类进行动态代理
CGLib动态代理：对类进行代理。
Spring中的五种通知方式
Spring中的通知:(增强代码)
前置通知 org.springframework.aop.MethodBeforeAdvice
* 在目标方法执行前实施增强
后置通知 org.springframework.aop.AfterReturningAdvice
* 在目标方法执行后实施增强
环绕通知 org.aopalliance.intercept.MethodInterceptor
* 在目标方法执行前后实施增强
异常抛出通知 org.springframework.aop.ThrowsAdvice
* 在方法抛出异常后实施增强
引介通知 org.springframework.aop.IntroductionInterceptor
* 在目标类中添加一些新的方法和属性
Spring的AOP开发
针对所有方法的增强:(不带有切点的切面)：
1.导入jar包
2.编写代理的类
//代理的接口
package com.zhangyike.aop;
public interface Person {
public void eat();
public void study();
public void play();
}//接口的实现类
package com.zhangyike.aop;
public class ImpPerson implements Person {
@Override
public void eat() {
System.out.println("实现类中吃");
}
@Override
public void study() {
System.out.println("实现类中学");
}
@Override
public void play() {
System.out.println("实现类中玩");
}
}3.编写增强的代码：
package com.zhangyike.aop;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
/*
* 使用前置增强
*/
public class AdvisorPerson implements MethodBeforeAdvice{
//被拦截的方法执行前，执行这个方法
/*
* method:执行的方法
* args:参数
* target:目标对象
*/
@Override
public void before(Method method, Object[] arg1, Object arg2)
throws Throwable {
System.out.println(method.getName() + "拦截前被增强");
}
}4.编写xml配置文件：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
<!-- 不带切点的切面分析 -->
<!-- 定义被增强的类，接口的实现类 -->
<bean id="impPerson" class="com.zhangyike.aop.ImpPerson"></bean>
<!-- 定义通知增强 -->
<bean id="advisorPerson" class="com.zhangyike.aop.AdvisorPerson"></bean>
<!-- 用Spring配置方式生成代理，注意这里属性的名称是固定的，不能自定义，否则会出现加载配置文件失败的异常。 -->
<bean id="personProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 设置目标对象 -->
<property name="target" ref="impPerson"></property>
<!-- 代理要实现的接口，value是接口的全路径 -->
<property name="proxyInterfaces" value="com.zhangyike.aop.Person"></property>
<!-- 设置增强，用value，而不是ref,不设置这个，不会增强 -->
<property name="interceptorNames" value="advisorPerson"></property>
<!-- 默认采用jdk动态代理方式，强制使用CGLib动态代理方式 -->
<property name="optimize" value="true"></property>
</bean>
</beans>5.编写测试类
package com.zhangyike.aop;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
//xml文件要和测试类在同一包中
@ContextConfiguration("applicationContext.xml")
public class DemoTest1 {
@Autowired
@Qualifier("personProxy")
Person personProxy;
@Test
public void test1(){
personProxy.eat();
personProxy.study();
personProxy.play();
}
}六、测试结果：
eat拦截前被增强
实现类中吃
study拦截前被增强
实现类中学
play拦截前被增强
实现类中玩
带有切点的切面:(针对目标对象的某些方法进行增强)
PointcutAdvisor 接口:
DefaultPointcutAdvisor 最常用的切面类型，它可以通过任意Pointcut和Advice 组合定义切面
RegexpMethodPointcutAdvisor 构造正则表达式切点切面
1.导入jar包
2.编写代理的类
//代理的接口
package com.zhangyike.aop;
public interface Person {
public void eat();
public void study();
public void play();
}//接口的实现类
package com.zhangyike.aop;
public class ImpPerson implements Person {
@Override
public void eat() {
System.out.println("实现类中吃");
}
@Override
public void study() {
System.out.println("实现类中学");
}
@Override
public void play() {
System.out.println("实现类中玩");
}
}3.编写增强类
package com.zhangyike.aop1;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
/*
* 环绕通知
*/
public class AdvisorPerson implements MethodInterceptor{
@Override
public Object invoke(MethodInvocation arg0) throws Throwable {
System.out.println("方法执行前");
Object result = arg0.proceed();//执行目标对象的方法
System.out.println("方法执行后");
return result;
}
}4.在xml中配置增强代码
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
<!-- 带切点的切面分析 -->
<!-- 定义被增强的类，也就是目标类，接口的实现类 -->
<bean id="impPerson" class="com.zhangyike.aop1.ImpPerson"></bean>
<!-- 定义通知增强的类 -->
<bean id="advisorPerson" class="com.zhangyike.aop1.AdvisorPerson"></bean>
<!-- 定义切点 -->
<bean id="myjoinpoint" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!-- 定义表达式，说明哪些方法被拦截 -->
<!-- .:任意字符 *：任意个
<property name="pattern" value=".*"/>
<property name="pattern" value="com\.zhangyike\.aop\.Person\.add.*"/>
<property name="pattern" value=".*add.*"></property>
-->
<!-- 对一个方法进行拦截
<property name="pattern" value="*.eat.*"></property> -->
<!-- 对吃、玩多个方法方法拦截 -->
<property name="patterns" value=".*eat.*,.*play.*"></property>
<!-- 设置增强的类 -->
<property name="advice" ref="advisorPerson" ></property>
</bean>
<!-- 用Spring配置方式生成代理，并定义切面-->
<bean id="personProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 设置目标对象 -->
<property name="target" ref="impPerson"></property>
<!-- 代理要实现的接口，value是接口的全路径 -->
<property name="proxyInterfaces" value="com.zhangyike.aop1.Person"></property>
<!-- 设置增强，用value，而不是ref,不设置这个，不会增强 -->
<property name="interceptorNames" value="myjoinpoint"></property>
<!-- 默认采用jdk动态代理方式，强制使用CGLib动态代理方式 -->
<property name="optimize" value="true"></property>
</bean>
</beans>5.测试类：
package com.zhangyike.aop1;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("applicationContext.xml")
public class DemoTest1 {
@Autowired//自动注入
@Qualifier("personProxy")//按类型注入
Person person;
@Test
public void test1(){
person.eat();
System.out.println();
person.study();
System.out.println();
person.play();
System.out.println();
}
}
六、执行结果
方法执行前
实现类中吃
方法执行后
实现类中学
方法执行前
实现类中玩
方法执行后
可见带有切面的切点对拦截的方法进行了增强，而未拦截的方法没有设置增强。
自动代理模式
前面两个例子中，每个代理都是通过ProxyFactoryBean织入切面代理，在实际开发中，非常多的Bean每个都配置ProxyFactoryBean开发维护量巨大。
自动创建代理：基于后处理bean，在bean的创建过程中完成增强，生成bean代理对象。
BeanNameAutoProxyCreator 根据Bean名称创建代理
DefaultAdvisorAutoProxyCreator 根据Advisor本身包含信息创建代理
* AnnotationAwareAspectJAutoProxyCreator 基于Bean中的
简单的demo：
一、导包
二、编写代理的目标类
//第一个要代理的目标类
package com.zhangyike.aop2;
public class ImpPerson {
public void eat() {
System.out.println("人中吃.........");
}
public void study() {
System.out.println("人中学.........");
}
public void play() {
System.out.println("人中玩.........");
}
}
//第二个要代理的目标类
package com.zhangyike.aop2;
public class Animal {
public void eat() {
System.out.println("动物中吃.........");
}
public void study() {
System.out.println("动物中学.........");
}
public void play() {
System.out.println("动物中玩.........");
}
}第三步、编写增强的代码
//前置增强
package com.zhangyike.aop2;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
public class BeforeAdvicor implements MethodBeforeAdvice{
@Override
public void before(Method arg0, Object[] arg1, Object arg2)
throws Throwable {
System.out.println(arg0.getName() + "--增强前---" );
}
}
//后置增强
package com.zhangyike.aop2;
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
public class AfterAdvicor implements AfterReturningAdvice{
@Override
public void afterReturning(Object arg0, Method arg1, Object[] arg2,
Object arg3) throws Throwable {
System.out.println(arg1.getName() + "--后置增强...");
}
}//环绕增强
package com.zhangyike.aop2;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class AroundAdvicor implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation arg0) throws Throwable {
System.out.println(arg0.getMethod().getName() + "..增强前...");
Object result = arg0.proceed();//执行方法
System.out.println(arg0.getMethod().getName() + "..增强后...");
return result;
}
}
第四步、生成代理，配置xml文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
<!-- 带切点的切面分析 -->
<!-- 定义被增强的类，也就是目标类，接口的实现类 -->
<bean id="impPerson" class="com.zhangyike.aop2.ImpPerson"></bean>
<bean id="animal" class="com.zhangyike.aop2.Animal"></bean>
<!-- 定义通知增强的类 -->
<bean id="aroundAdvicor" class="com.zhangyike.aop2.AroundAdvicor"></bean>
<bean id="afterAdvicor" class="com.zhangyike.aop2.AfterAdvicor"></bean>
<bean id="beforeAdvicor" class="com.zhangyike.aop2.BeforeAdvicor"></bean>
<!-- 注意：如果一个方法被三种方式分别增强，那么先执行前置增强、在执行环绕增强、最后执行后置增强 -->
<!-- 定义第一个带有切点切面 -->
<bean id="myjoinpoint1" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!-- 对吃、玩多个方法方法拦截 -->
<property name="pattern" value=".*eat.*"></property>
<!-- 设置增强的类 -->
<property name="advice" ref="afterAdvicor" ></property>
</bean>
<!-- 定义第二个带有切点切面 -->
<bean id="myjoinpoint2" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!-- 对吃、玩多个方法方法拦截 -->
<property name="pattern" value=".*eat.*"></property>
<!-- 设置增强的类 -->
<property name="advice" ref="beforeAdvicor" ></property>
</bean>
<!-- 定义第三个带有切点切面 -->
<bean id="myjoinpoint3" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<!-- 对吃、玩多个方法方法拦截 -->
<property name="patterns" value=".*eat.*,.*study.*"></property>
<!-- 设置增强的类 -->
<property name="advice" ref="aroundAdvicor" ></property>
</bean>
<!-- 自动生成代理，没有被定义切点切面的方法将不会被增强，执行他自己本身的方法,定义切点切面的方法将执行定义后的方法-->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>
</beans>第五步、测试类
package com.zhangyike.aop2;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("applicationContext.xml")
public class DemoTest1 {
@Autowired
@Qualifier("animal")//注入的是自己的bean对象，说明在bean的创建过程中完成的增强，生成的bean对象就是增强之后的对象了。
Animal animal;
@Autowired
@Qualifier("impPerson")
ImpPerson person;
@Test
public void test1(){
animal.eat();
System.out.println();
animal.play();
System.out.println();
animal.study();
System.out.println();
person.eat();
System.out.println();
person.play();
System.out.println();
person.study();
System.out.println();
}
}
第六步：测试结果
eat–增强前—
eat..增强前…
动物中吃………
eat..增强后…
eat–后置增强…
动物中玩………
study..增强前…
动物中学………
study..增强后…
eat–增强前—
eat..增强前…
人中吃………
eat..增强后…
eat–后置增强…
人中玩………
study..增强前…
人中学………
study..增强后…
本篇文章给出了三个Demo，分别是不带切点的切面、带切点的切面、
自动代理模式，前两种是ProxyFactoryBean代理，第三种是
DefaultAdvisorAutoProxyCreator，区别是：
ProxyFattoryBean：先有被代理对象，将被代理对象存入到代理类中生成代理。
DefaultAdvisorAutoProxyCreator：在bean生成的时候，就产生了代理对象，将生成的代理对象返回，生成的bean就是代理对象。
扫一扫
565
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
