大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。
Jetbrains全家桶1年46,售后保障稳定
转载地址:https://my.oschina.net/elain/blog/382494
一、什么是 AOP
AOP(Aspect-OrientedProgramming,面向切面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为(日志、安全、事务)的时候,OOP则显得无能为力。也就是说,OOP允许你定义从上到下的关系,但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中,而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码,如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切(cross-cutting)代码,在OOP设计中,它导致了大量代码的重复,模块间的藕合度高,而不利于各个模块的重用。
而AOP技术则恰恰相反,它利用一种称为“横切”的技术,剖解开封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,并将其名为“Aspect”,即切面。所谓“切面”,简单地说,就是将那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系,如果说“对象”是一个空心的圆柱体,其中封装的是对象的属性和行为;那么面向方面编程的方法,就仿佛一把利刃,将这些空心圆柱体剖开,以获得其内部的消息。而剖开的切面,也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原,不留痕迹。
使用“横切”技术,AOP把软件系统分为两个部分:核心业务逻辑组件和横切关注点。横切关注点模块化为特殊的类,这些类被称为“切面”,好处:1.横切关注点都集中于一块,不会出现大量重复代码;2.核心模块只关注核心功能的代码,模块间藕合度降低。
二、AOP 的实现原理
三、AOP相关概念
连接点(Joinpoint):在程序执行过程中某个特定的点,比如某方法调用的时候或者处理异常的时候。在Spring AOP中,一个连接点总是表示一个方法的执行。通俗的说就是加入切点的那个点
通知(Advice):在切面的某个特定的连接点上执行的动作。其中包括了“around”、“before”和“after”等不同类型的通知(通知的类型将在后面部分进行讨论)。许多AOP框架(包括Spring)都是以拦截器做通知模型,并维护一个以连接点为中心的拦截器链。
切入点(Pointcut):匹配连接点的断言。通知和一个切入点表达式关联,并在满足这个切入点的连接点上运行(例如,当执行某个特定名称的方法时)。切入点表达式如何和连接点匹配是AOP的核心:Spring缺省使用AspectJ切入点语法。
引入(Introduction):用来给一个类型声明额外的方法或属性(也被称为连接类型声明(inter-type declaration))。Spring允许引入新的接口(以及一个对应的实现)到任何被代理的对象。例如,你可以使用引入来使一个bean实现IsModified接口,以便简化缓存机制。
织入(Weaving):将切面应用到目标对象来创建新的代理对象的过程。这些可以在编译时(例如使用AspectJ编译器),类加载时和运行时完成。Spring和其他纯Java AOP框架一样,在运行时完成织入。
增强(Advice):是织入到目标类连接点上的一段程序代码。Spring使用增强类定义横切逻辑,同时由于Spring只支持方法连接点,增强还包括了在方法上的哪一点加入横切代码的方位信息,所以增强既包括横切逻辑、还包含部分连接点的信息。
引介(Introduction):是一种特殊的增强,为类添加一些属性和方法。
切面(Advisor):代表一般切面,包含了横切代码和连接点信息,本身是一个简单的切面,横切的连接点是目标类的所有方法。3种类型:一般切面(advisor)、切点切面(PointcutAdvisor)、引介切面(IntroductionAdvisor)。
四、Spring中AOP的实现
第一种是基于xml配置文件方式的实现,
第二种是基于注解方式的实现。
首先我们来看一下业务逻辑service层:
- <span style=‘font-family: “Microsoft YaHei”;’>/**
- * RegisterService的实现类
- * @author 曹胜欢 */
- public class RegisterServiceImpl implements RegisterService {
- private RegisterDao registerDao;
- public RegisterServiceImpl() {}
- /** 带参数的构造方法 */
- public RegisterServiceImpl(RegisterDao registerDao){
- this.registerDao =registerDao;
- }
- public void save(String loginname, String password) {
- registerDao.save(loginname, password);
- throw new RuntimeException(“故意抛出一个异常。。。。”);
- }
- /** set方法 */
- public void setRegisterDao(RegisterDao registerDao) {
- this.registerDao = registerDao;
- }}</span>
/** * RegisterService的实现类 * @author 曹胜欢 */ public class RegisterServiceImpl implements RegisterService { private RegisterDao registerDao; public RegisterServiceImpl() {} /** 带参数的构造方法 */ public RegisterServiceImpl(RegisterDao registerDao){ this.registerDao =registerDao; } public void save(String loginname, String password) { registerDao.save(loginname, password); throw new RuntimeException("故意抛出一个异常。。。。"); } /** set方法 */ public void setRegisterDao(RegisterDao registerDao) { this.registerDao = registerDao; }}
对于业务系统来说,RegisterServiceImpl类就是目标实现类,它的业务方法,如save()方法的前后或代码会出现异常的地方都是AOP的连接点。
下面是日志服务类的代码:
- <span style=‘font-family: “Microsoft YaHei”;’>/**
- * 日志切面类
- * @author 曹胜欢
- */
- public class LogAspect {
- //任何通知方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型
- public void before(JoinPoint call) {
- //获取目标对象对应的类名
- String className = call.getTarget().getClass().getName();
- //获取目标对象上正在执行的方法名
- String methodName = call.getSignature().getName();
- System.out.println(“前置通知:” + className + “类的” + methodName + “方法开始了”);
- }
- public void afterReturn() {
- System.out.println(“后置通知:方法正常结束了”);
- }
- public void after(){
- System.out.println(“最终通知:不管方法有没有正常执行完成,一定会返回的”);
- }
- public void afterThrowing() {
- System.out.println(“异常抛出后通知:方法执行时出异常了”);
- }
- //用来做环绕通知的方法可以第一个参数定义为org.aspectj.lang.ProceedingJoinPoint类型
- public Object doAround(ProceedingJoinPoint call) throws Throwable {
- Object result = null;
- this.before(call);//相当于前置通知
- try {
- result = call.proceed();
- this.afterReturn(); //相当于后置通知
- } catch (Throwable e) {
- this.afterThrowing(); //相当于异常抛出后通知
- throw e;
- }finally{
- this.after(); //相当于最终通知
- }
- return result;
- }
- }</span>
/** * 日志切面类 * @author 曹胜欢 */ public class LogAspect { //任何通知方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型 public void before(JoinPoint call) { //获取目标对象对应的类名 String className = call.getTarget().getClass().getName(); //获取目标对象上正在执行的方法名 String methodName = call.getSignature().getName(); System.out.println("前置通知:" + className + "类的" + methodName + "方法开始了"); } public void afterReturn() { System.out.println("后置通知:方法正常结束了"); } public void after(){ System.out.println("最终通知:不管方法有没有正常执行完成,一定会返回的"); } public void afterThrowing() { System.out.println("异常抛出后通知:方法执行时出异常了"); } //用来做环绕通知的方法可以第一个参数定义为org.aspectj.lang.ProceedingJoinPoint类型 public Object doAround(ProceedingJoinPoint call) throws Throwable { Object result = null; this.before(call);//相当于前置通知 try { result = call.proceed(); this.afterReturn(); //相当于后置通知 } catch (Throwable e) { this.afterThrowing(); //相当于异常抛出后通知 throw e; }finally{ this.after(); //相当于最终通知 } return result; } }
这个类属于业务服务类,如果用AOP的术语来说,它就是一个切面类,它定义了许多通知。Before()、afterReturn()、after()和afterThrowing()这些方法都是通知。
下面我们就来看具体配置,首先来看一下:
<1>.基于xml配置文件的AOP实现:这种方式在实现AOP时,有4个步骤。
- <span style=‘font-family: “Microsoft YaHei”;’><?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:aop=“http://www.springframework.org/schema/aop”
- xsi:schemaLocation=”
- http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
- http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd>
- <bean id=“registerDaoImpl” class=“com.zxf.dao.RegisterDaoImpl”/>
- <bean id=“registerService” class=“com.zxf.service.RegisterServiceImpl”>
- <property name=” registerDaoImpl “ ref=” RegisterDaoImpl “/>
- </bean>
- <!– 日志切面类 –>
- <bean id=“logAspectBean” class=“com.zxf.aspect.LogAspect”/>
- <!– 第1步: AOP的配置 –>
- <aop:config>
- <!– 第2步:配置一个切面 –>
- <aop:aspect id=“logAspect” ref=“logAspectBean”>
- <!– 第3步:定义切入点,指定切入点表达式 –>
- <aop:pointcut id=“allMethod”
- expression=“execution(* com.zxf.service.*.*(..))”/>
- <!– 第4步:应用前置通知 –>
- <aop:before method=“before” pointcut-ref=“allMethod” />
- <!– 第4步:应用后置通知 –>
- <aop:after-returning method=“afterReturn” pointcut-ref=“allMethod”/>
- <!– 第4步:应用最终通知 –>
- <aop:after method=“after” pointcut-ref=“allMethod”/>
- <!– 第4步:应用抛出异常后通知 –>
- <aop:after-throwing method=“afterThrowing” pointcut-ref=“allMethod”/>
- <!– 第4步:应用环绕通知 –>
- <!–
- <aop:around method=“doAround” pointcut-ref=“allMethod” />
- –>
- </aop:aspect>
- </aop:config>
- </beans></span>
<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd> <bean id="registerDaoImpl" class="com.zxf.dao.RegisterDaoImpl"/> <bean id="registerService" class="com.zxf.service.RegisterServiceImpl"> <property name=" registerDaoImpl " ref=" RegisterDaoImpl "/> </bean> <!-- 日志切面类 --> <bean id="logAspectBean" class="com.zxf.aspect.LogAspect"/> <!-- 第1步: AOP的配置 --> <aop:config> <!-- 第2步:配置一个切面 --> <aop:aspect id="logAspect" ref="logAspectBean"> <!-- 第3步:定义切入点,指定切入点表达式 --> <aop:pointcut id="allMethod" expression="execution(* com.zxf.service.*.*(..))"/> <!-- 第4步:应用前置通知 --> <aop:before method="before" pointcut-ref="allMethod" /> <!-- 第4步:应用后置通知 --> <aop:after-returning method="afterReturn" pointcut-ref="allMethod"/> <!-- 第4步:应用最终通知 --> <aop:after method="after" pointcut-ref="allMethod"/> <!-- 第4步:应用抛出异常后通知 --> <aop:after-throwing method="afterThrowing" pointcut-ref="allMethod"/> <!-- 第4步:应用环绕通知 --> <!-- <aop:around method="doAround" pointcut-ref="allMethod" /> --> </aop:aspect> </aop:config> </beans>
上述配置针对切入点应用了前置、后置、最终,以及抛出异常后通知。这样在测试执行RegisterServiceImpl类的save()方法时,控制台会有如下结果输出:
前置通知:com.zxf.service.RegisterServiceImpl类的save方法开始了。
针对MySQL的RegisterDao实现中的save()方法。
后置通知:方法正常结束了。
最终通知:不管方法有没有正常执行完成,一定会返回的。
下面我们在来看一下第二种配置方式:
<2>基于注解的AOP的实现
首先创建一个用来作为切面的类LogAnnotationAspect,同时把这个类配置在spring的配置文件中。
在spring2.0以后引入了JDK5.0的注解Annotation的支持,提供了对AspectJ基于注解的切面的支持,从而 更进一步地简化AOP的配置。具体的步骤有两步。
Spring的配置文件是如下的配置:
- <span style=‘font-family: “Microsoft YaHei”;’><?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:aop=“http://www.springframework.org/schema/aop”
- xsi:schemaLocation=”
- http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
- http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd>
- <bean id=“registerDao” class=“com.zxf.dao.RegisterDaoImpl”/>
- <bean id=“registerService” class=“com.zxf.service.RegisterServiceImpl”>
- <property name=“registerDao” ref=“registerDao”/>
- </bean>
- <!– 把切面类交由Spring容器来管理 –>
- <bean id=“logAspectBean” class=“com.zxf.aspect.LogAnnotationAspect”/>
- <!– 启用spring对AspectJ注解的支持 –>
- <aop:aspectj-autoproxy/>
- </beans></span>
<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd> <bean id="registerDao" class="com.zxf.dao.RegisterDaoImpl"/> <bean id="registerService" class="com.zxf.service.RegisterServiceImpl"> <property name="registerDao" ref="registerDao"/> </bean> <!-- 把切面类交由Spring容器来管理 --> <bean id="logAspectBean" class="com.zxf.aspect.LogAnnotationAspect"/> <!-- 启用spring对AspectJ注解的支持 --> <aop:aspectj-autoproxy/> </beans>
这是那个切面的类LogAnnotationAspect
- <span style=‘font-family: “Microsoft YaHei”;’>/**
- * 日志切面类
- */
- @Aspect //定义切面类
- public class LogAnnotationAspect {
- @SuppressWarnings(“unused”)
- //定义切入点,提供一个方法,这个方法的名字就是改切入点的id
- @Pointcut(“execution(* com.zxf.service.*.*(..))”)
- private void allMethod(){}
- //针对指定的切入点表达式选择的切入点应用前置通知
- @Before(“execution(* com. zxf.service.*.*(..))”)
- public void before(JoinPoint call) {
- String className = call.getTarget().getClass().getName();
- String methodName = call.getSignature().getName();
- System.out.println(“【注解-前置通知】:” + className + “类的”
- + methodName + “方法开始了”);
- }
- //访问命名切入点来应用后置通知
- @AfterReturning(“allMethod()”)
- public void afterReturn() {
- System.out.println(“【注解-后置通知】:方法正常结束了”);
- }
- //应用最终通知
- @After(“allMethod()”)
- public void after(){
- System.out.println(“【注解-最终通知】:不管方法有没有正常执行完成,”
- + “一定会返回的”);
- }
- //应用异常抛出后通知
- @AfterThrowing(“allMethod()”)
- public void afterThrowing() {
- System.out.println(“【注解-异常抛出后通知】:方法执行时出异常了”);
- }
- //应用周围通知
- //@Around(“allMethod()”)
- public Object doAround(ProceedingJoinPoint call) throws Throwable{
- Object result = null;
- this.before(call);//相当于前置通知
- try {
- result = call.proceed();
- this.afterReturn(); //相当于后置通知
- } catch (Throwable e) {
- this.afterThrowing(); //相当于异常抛出后通知
- throw e;
- }finally{
- this.after(); //相当于最终通知
- }
- return result;
- }
- }</span>
/** * 日志切面类 */ @Aspect //定义切面类 public class LogAnnotationAspect { @SuppressWarnings("unused") //定义切入点,提供一个方法,这个方法的名字就是改切入点的id @Pointcut("execution(* com.zxf.service.*.*(..))") private void allMethod(){} //针对指定的切入点表达式选择的切入点应用前置通知 @Before("execution(* com. zxf.service.*.*(..))") public void before(JoinPoint call) { String className = call.getTarget().getClass().getName(); String methodName = call.getSignature().getName(); System.out.println("【注解-前置通知】:" + className + "类的" + methodName + "方法开始了"); } //访问命名切入点来应用后置通知 @AfterReturning("allMethod()") public void afterReturn() { System.out.println("【注解-后置通知】:方法正常结束了"); } //应用最终通知 @After("allMethod()") public void after(){ System.out.println("【注解-最终通知】:不管方法有没有正常执行完成," + "一定会返回的"); } //应用异常抛出后通知 @AfterThrowing("allMethod()") public void afterThrowing() { System.out.println("【注解-异常抛出后通知】:方法执行时出异常了"); } //应用周围通知 //@Around("allMethod()") public Object doAround(ProceedingJoinPoint call) throws Throwable{ Object result = null; this.before(call);//相当于前置通知 try { result = call.proceed(); this.afterReturn(); //相当于后置通知 } catch (Throwable e) { this.afterThrowing(); //相当于异常抛出后通知 throw e; }finally{ this.after(); //相当于最终通知 } return result; } }
五:Spring中AOP的两种代理方式(Java动态代理和CGLIB代理)
Spring AOP使用动态代理技术在运行期织入增强代码。使用两种代理机制:基于JDK的动态代理(JDK本身只提供接口的代理);基于CGlib的动态代理。
1. JDK的动态代理主要涉及java.lang.reflect包中的两个类:Proxy和InvocationHandler。其中InvocationHandler只是一个接口,可以通过实现该接口定义横切逻辑,并通过反射机制调用目标类的代码,动态的将横切逻辑与业务逻辑织在一起。而Proxy利用InvocationHandler动态创建一个符合某一接口的实例,生成目标类的代理对象。(只能为接口创建代理实例)
- <span style=‘font-family: “Microsoft YaHei”;’>//需要被代理的接口
- public interface ForumService {
- public void removeTopic(int topicId);
- public void removeForum(int forumId);
- }
- //被代理接口的实现类,包含核心的业务逻辑
- public class ForumServiceImpl implements ForumService{
- @Override
- public void removeTopic(int topicId) {
- System.out.println(“模拟删除Topic记录:”+ topicId);
- try {
- Thread.currentThread().sleep(20);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- @Override
- public void removeForum(int forumId) {
- System.out.println(“模拟删除Forum记录:”+ forumId);
- try {
- Thread.currentThread().sleep(40);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- }
- }
- //性能监控核心代码生成
- public class MethodPerformance {
- private long begin;
- private long end;
- private String serviceMethod;
- public MethodPerformance(String serviceMethod) {
- this.serviceMethod = serviceMethod;
- this.begin = System.currentTimeMillis();
- };
- public void printPerformance(){
- this.end = System.currentTimeMillis();
- long elapse = this.end – this.begin;
- System.out.println(serviceMethod + ” cost “ + elapse +“ms”);
- }
- }
- //线程安全的横切逻辑
- public class PerformanceMonitor {
- private static ThreadLocal<MethodPerformance> tl= new ThreadLocal<MethodPerformance>();
- public static void begin(String method){
- System.out.println(“begin monitor”);
- MethodPerformance mp = new MethodPerformance(method);
- tl.set(mp);
- }
- public static void end(){
- System.out.println(“end monitor”);
- MethodPerformance mp = tl.get();
- mp.printPerformance();
- }
- }
- //AOP横切模块
- public class PerfermanceHandler implements InvocationHandler{
- private Object target;
- public PerfermanceHandler(Object target) {
- this.target = target;
- }
- @Override
- public Object invoke(Object proxy, Method method, Object[] args)
- throws Throwable {
- PerformanceMonitor.begin(target.getClass().getName()+“.”+method.getName());
- Object object = method.invoke(target, args);
- PerformanceMonitor.end();
- return object;
- }
- }
- //测试
- public class TestForumService {
- public static void main(String[] args) {
- ForumService target = new ForumServiceImpl();
- //将目标业务类与横切代码编织到一起
- PerfermanceHandler handler = new PerfermanceHandler(target);
- //创建代理实例
- ForumService proxy = (ForumService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
- target.getClass().getInterfaces(), handler);
- proxy.removeForum(10);
- proxy.removeTopic(1012);
- }
- }</span>
//需要被代理的接口 public interface ForumService { public void removeTopic(int topicId); public void removeForum(int forumId); } //被代理接口的实现类,包含核心的业务逻辑 public class ForumServiceImpl implements ForumService{ @Override public void removeTopic(int topicId) { System.out.println("模拟删除Topic记录:"+ topicId); try { Thread.currentThread().sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } } @Override public void removeForum(int forumId) { System.out.println("模拟删除Forum记录:"+ forumId); try { Thread.currentThread().sleep(40); } catch (InterruptedException e) { e.printStackTrace(); } } } //性能监控核心代码生成 public class MethodPerformance { private long begin; private long end; private String serviceMethod; public MethodPerformance(String serviceMethod) { this.serviceMethod = serviceMethod; this.begin = System.currentTimeMillis(); }; public void printPerformance(){ this.end = System.currentTimeMillis(); long elapse = this.end - this.begin; System.out.println(serviceMethod + " cost " + elapse +"ms"); } } //线程安全的横切逻辑 public class PerformanceMonitor { private static ThreadLocal<MethodPerformance> tl= new ThreadLocal<MethodPerformance>(); public static void begin(String method){ System.out.println("begin monitor"); MethodPerformance mp = new MethodPerformance(method); tl.set(mp); } public static void end(){ System.out.println("end monitor"); MethodPerformance mp = tl.get(); mp.printPerformance(); } } //AOP横切模块 public class PerfermanceHandler implements InvocationHandler{ private Object target; public PerfermanceHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { PerformanceMonitor.begin(target.getClass().getName()+"."+method.getName()); Object object = method.invoke(target, args); PerformanceMonitor.end(); return object; } } //测试 public class TestForumService { public static void main(String[] args) { ForumService target = new ForumServiceImpl(); //将目标业务类与横切代码编织到一起 PerfermanceHandler handler = new PerfermanceHandler(target); //创建代理实例 ForumService proxy = (ForumService) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler); proxy.removeForum(10); proxy.removeTopic(1012); } }
begin monitor
模拟删除Forum记录:10
end monitor
com.baobaotao.proxy.ForumServiceImpl.removeForum cost 42ms
begin monitor
模拟删除Topic记录:1012
end monitor
com.baobaotao.proxy.ForumServiceImpl.removeTopic cost 21ms
2.CGLib采用底层的字节码技术,为一个类创建子类,并在子类中采用方法拦截的技术拦截所有父类的调用方法,并顺势织入横切逻辑。
- <span style=‘font-family: “Microsoft YaHei”;’>package com.baobaotao.proxy;
- import java.lang.reflect.Method;
- import org.springframework.cglib.proxy.Enhancer;
- import org.springframework.cglib.proxy.MethodInterceptor;
- import org.springframework.cglib.proxy.MethodProxy;
- public class CglibProxy implements MethodInterceptor{
- private Enhancer enhancer = new Enhancer();
- public Object getProxy(Class clazz){
- enhancer.setSuperclass(clazz);//设置创建子类的类
- enhancer.setCallback(this);
- return enhancer.create();//通过字节码技术动态创建子类实例
- }
- @Override
- public Object intercept(Object target, Method method, Object[] args,
- MethodProxy proxy) throws Throwable {
- PerformanceMonitor.begin(target.getClass().getName()+“.”+method.getName());
- Object object = proxy.invokeSuper(target, args);
- PerformanceMonitor.end();
- return object;
- }
- }
- package com.baobaotao.proxy;
- import java.lang.reflect.Proxy;
- //测试
- public class TestForumService {
- public static void main(String[] args) {
- CglibProxy cglibProxy = new CglibProxy();
- ForumServiceImpl service = (ForumServiceImpl) cglibProxy.getProxy(ForumServiceImpl.class);
- service.removeForum(10);
- service.removeTopic(1012);
- }
- }</span>
package com.baobaotao.proxy; import java.lang.reflect.Method; import org.springframework.cglib.proxy.Enhancer; import org.springframework.cglib.proxy.MethodInterceptor; import org.springframework.cglib.proxy.MethodProxy; public class CglibProxy implements MethodInterceptor{ private Enhancer enhancer = new Enhancer(); public Object getProxy(Class clazz){ enhancer.setSuperclass(clazz);//设置创建子类的类 enhancer.setCallback(this); return enhancer.create();//通过字节码技术动态创建子类实例 } @Override public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable { PerformanceMonitor.begin(target.getClass().getName()+"."+method.getName()); Object object = proxy.invokeSuper(target, args); PerformanceMonitor.end(); return object; } } package com.baobaotao.proxy; import java.lang.reflect.Proxy; //测试 public class TestForumService { public static void main(String[] args) { CglibProxy cglibProxy = new CglibProxy(); ForumServiceImpl service = (ForumServiceImpl) cglibProxy.getProxy(ForumServiceImpl.class); service.removeForum(10); service.removeTopic(1012); } }
begin monitor
模拟删除Forum记录:10
end monitor
com.baobaotao.proxy.ForumServiceImpl
626e31f5(子类).removeForum cost 67ms
begin monitor
模拟删除Topic记录:1012
end monitor
com.baobaotao.proxy.ForumServiceImpl
626e31f5.removeTopic cost 20ms
Spring增强类
Spring支持5种增强类型:
1)前置增强:org.springframework.aop.BeforeAdvice代表前置增强,spring只支持方法级的增强,目前可用MethodBeforeAdvice。
- <span style=‘font-family: “Microsoft YaHei”;’>public interface Waiter {
- public void greetTo(String name);
- public void serveTo(String name);
- }
- public class NaiveWaiter implements Waiter {
- @Override
- public void greetTo(String name) {
- System.out.println(“greetTo “+ name +“…”);
- }
- @Override
- public void serveTo(String name) {
- System.out.println(“serveTo “+ name +“…”);
- }
- }
- import java.lang.reflect.Method;
- import org.springframework.aop.MethodBeforeAdvice;
- public class GreeteBeforeAdvice implements MethodBeforeAdvice{
- @Override
- public void before(Method arg0, Object[] arg1, Object arg2)
- throws Throwable {
- String client = (String) arg1[0];
- System.out.println(“How are you!”+client+“.”);
- }
- }
- import org.springframework.aop.BeforeAdvice;
- import org.springframework.aop.framework.ProxyFactory;
- public class TestBeforeAdvice {
- public static void main(String[] args) {
- Waiter target = new NaiveWaiter();
- BeforeAdvice advice = new GreeteBeforeAdvice();
- //Spring提供的代理工厂
- ProxyFactory pf = new ProxyFactory();//使用Cglib2AOPProx 即CGlib代理技术创建代理
- // pf.setInterfaces(target.getClass().getInterfaces());//使用JdkDynamicAopProxy
- //设置代理目标
- pf.setTarget(target);
- //添加增强处理
- pf.addAdvice(advice);
- //生成代理实例
- Waiter waiter = (Waiter) pf.getProxy();
- waiter.greetTo(“Tom”);
- waiter.serveTo(“Lucy”);
- // ApplicationContext ctx = new ClassPathXmlApplicationContext(“beans.xml”);
- // Waiter waiter1 = (Waiter) ctx.getBean(“waiter”);
- // waiter1.greetTo(“John”);
- }
- }
- <bean id=“target” class=“com.baobaotao.advice.NaiveWaiter” />
- <bean id=“greeteAdvice” class=“com.baobaotao.advice.GreeteBeforeAdvice” />
- <bean id=“waiter” class=“org.springframework.aop.framework.ProxyFactoryBean”
- p:proxyInterfaces=“com.baobaotao.advice.Waiter” p:interceptorNames=“greeteAdvice”
- p:target-ref=“target” /></span>
public interface Waiter { public void greetTo(String name); public void serveTo(String name); } public class NaiveWaiter implements Waiter { @Override public void greetTo(String name) { System.out.println("greetTo "+ name +"..."); } @Override public void serveTo(String name) { System.out.println("serveTo "+ name +"..."); } } import java.lang.reflect.Method; import org.springframework.aop.MethodBeforeAdvice; public class GreeteBeforeAdvice implements MethodBeforeAdvice{ @Override public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable { String client = (String) arg1[0]; System.out.println("How are you!"+client+"."); } } import org.springframework.aop.BeforeAdvice; import org.springframework.aop.framework.ProxyFactory; public class TestBeforeAdvice { public static void main(String[] args) { Waiter target = new NaiveWaiter(); BeforeAdvice advice = new GreeteBeforeAdvice(); //Spring提供的代理工厂 ProxyFactory pf = new ProxyFactory();//使用Cglib2AOPProx 即CGlib代理技术创建代理 // pf.setInterfaces(target.getClass().getInterfaces());//使用JdkDynamicAopProxy //设置代理目标 pf.setTarget(target); //添加增强处理 pf.addAdvice(advice); //生成代理实例 Waiter waiter = (Waiter) pf.getProxy(); waiter.greetTo("Tom"); waiter.serveTo("Lucy"); // ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml"); // Waiter waiter1 = (Waiter) ctx.getBean("waiter"); // waiter1.greetTo("John"); } } <bean id="target" class="com.baobaotao.advice.NaiveWaiter" /> <bean id="greeteAdvice" class="com.baobaotao.advice.GreeteBeforeAdvice" /> <bean id="waiter" class="org.springframework.aop.framework.ProxyFactoryBean" p:proxyInterfaces="com.baobaotao.advice.Waiter" p:interceptorNames="greeteAdvice" p:target-ref="target" />
2)后置增强:org.springframework.aop.AfterReturningAdvice代表后置增强,在目标方法执行后实施增强。
- <span style=‘font-family: “Microsoft YaHei”;’>import java.lang.reflect.Method;
- import org.springframework.aop.AfterReturningAdvice;
- public class GreeteAfterAdvice implements AfterReturningAdvice{
- @Override
- public void afterReturning(Object arg0, Method arg1, Object[] arg2,
- Object arg3) throws Throwable {
- System.out.println(“Please enjoy yourself!”);
- }
- }
- <bean id=“waiter” class=“org.springframework.aop.framework.ProxyFactoryBean”
- p:proxyInterfaces=“com.baobaotao.advice.Waiter” p:interceptorNames=“greeteBefore,greeteAfter”
- p:target-ref=“target” /></span>
import java.lang.reflect.Method; import org.springframework.aop.AfterReturningAdvice; public class GreeteAfterAdvice implements AfterReturningAdvice{ @Override public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable { System.out.println("Please enjoy yourself!"); } } <bean id="waiter" class="org.springframework.aop.framework.ProxyFactoryBean" p:proxyInterfaces="com.baobaotao.advice.Waiter" p:interceptorNames="greeteBefore,greeteAfter" p:target-ref="target" />
3)环绕增强:org.aopalliance.intercept.MethodInterceptor代表环绕增强,在目标方法执行前后实施增强。
- <span style=‘font-family: “Microsoft YaHei”;’>import org.aopalliance.intercept.MethodInterceptor;
- import org.aopalliance.intercept.MethodInvocation;
- public class GreeteInterceptor implements MethodInterceptor{
- @Override
- public Object invoke(MethodInvocation inv) throws Throwable {
- Object[] args = inv.getArguments();
- String client = (String) args[0];
- System.out.println(“How are you!”+client+“.”);
- Object obj = inv.proceed();
- System.out.println(“Please enjoy yourself!”);
- return obj;
- }
- }</span>
import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.intercept.MethodInvocation; public class GreeteInterceptor implements MethodInterceptor{ @Override public Object invoke(MethodInvocation inv) throws Throwable { Object[] args = inv.getArguments(); String client = (String) args[0]; System.out.println("How are you!"+client+"."); Object obj = inv.proceed(); System.out.println("Please enjoy yourself!"); return obj; } }
4)异常抛出增强:org.springframework.aop.ThrowsAdvice,在目标方法执行抛出异常后实施增强。方法名必须为afterThrowing,如参前三个可选,最后一个是Throwable或其子类。
- <span style=‘font-family: “Microsoft YaHei”;’>import java.lang.reflect.Method;
- import org.springframework.aop.ThrowsAdvice;
- public class TransactionManager implements ThrowsAdvice {
- public void afterThrowing(Method method, Object[] args, Object target,
- Exception ex) throws Throwable {
- System.out.println(“———–“);
- System.out.println(“method:” + method.getName());
- System.out.println(“抛出异常:” + ex.getMessage());
- System.out.println(“成功回滚事务。”);
- }
- }</span>
import java.lang.reflect.Method; import org.springframework.aop.ThrowsAdvice; public class TransactionManager implements ThrowsAdvice { public void afterThrowing(Method method, Object[] args, Object target, Exception ex) throws Throwable { System.out.println("-----------"); System.out.println("method:" + method.getName()); System.out.println("抛出异常:" + ex.getMessage()); System.out.println("成功回滚事务。"); } }
5)引介增强:org.springframework.aop.IntroductionInterceptor,表示目标类添加一些新的方法和属性,连接点是类级别,而不是方法级别。
- <span style=‘font-family: “Microsoft YaHei”;’>import org.aopalliance.intercept.MethodInvocation;
- import org.springframework.aop.support.DelegatingIntroductionInterceptor;
- import com.baobaotao.proxy.PerformanceMonitor;
- public class ControllablePerformaceMonitor extends DelegatingIntroductionInterceptor implements Monitorable{
- private ThreadLocal<Boolean> MonitorStatusMap = new ThreadLocal<Boolean>();
- @Override
- public void setMonitorActive(boolean active) {
- MonitorStatusMap.set(active);
- }
- @Override
- public Object invoke(MethodInvocation mi) throws Throwable {
- Object obj = null;
- if (MonitorStatusMap.get() != null && MonitorStatusMap.get()) {
- PerformanceMonitor.begin(mi.getClass().getName() + “.”
- + mi.getMethod().getName());
- obj = super.invoke(mi);
- PerformanceMonitor.end();
- } else {
- obj = super.invoke(mi);
- }
- return obj;
- }
- }
- <bean id=“forumService” class=“org.springframework.aop.framework.ProxyFactoryBean”
- p:interfaces=“com.baobaotao.introduce.Monitorable” //引入引介增强要实现的接口
- p:target-ref=“forumServiceTarget”
- p:interceptorNames=“pmonitor”
- p:proxyTargetClass=“true” />//只能通过为目标类型类创建子类的方式生成增强的代理</span>
import org.aopalliance.intercept.MethodInvocation; import org.springframework.aop.support.DelegatingIntroductionInterceptor; import com.baobaotao.proxy.PerformanceMonitor; public class ControllablePerformaceMonitor extends DelegatingIntroductionInterceptor implements Monitorable{ private ThreadLocal<Boolean> MonitorStatusMap = new ThreadLocal<Boolean>(); @Override public void setMonitorActive(boolean active) { MonitorStatusMap.set(active); } @Override public Object invoke(MethodInvocation mi) throws Throwable { Object obj = null; if (MonitorStatusMap.get() != null && MonitorStatusMap.get()) { PerformanceMonitor.begin(mi.getClass().getName() + "." + mi.getMethod().getName()); obj = super.invoke(mi); PerformanceMonitor.end(); } else { obj = super.invoke(mi); } return obj; } } <bean id="forumService" class="org.springframework.aop.framework.ProxyFactoryBean" p:interfaces="com.baobaotao.introduce.Monitorable" //引入引介增强要实现的接口 p:target-ref="forumServiceTarget" p:interceptorNames="pmonitor" p:proxyTargetClass="true" />//只能通过为目标类型类创建子类的方式生成增强的代理
AOP切面的配置方式
1)基于Schema的配置:在xml中描述切点、增强类型,切面类为pojo
2)基于AspectJ的配置:切点、增强类型使用注解进行描述
发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/227295.html原文链接:https://javaforall.cn
【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛
【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...