Spring注解驱动开发（四）

AOP面向切面编程

AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

底层实现

Spring 的 AOP 的底层用到两种代理机制：

• JDK 的动态代理 ：类必须实现接口，所以是针对实现了接口的类产生代理.
• Cglib 的动态代理：针对没有实现接口的类产生代理，应用的是底层的字节码增强的技术生成当前类的子类对象

JDK 的动态代理

• UserService接口，实现增删改查的功能

1 2 3 4 5 6 7 8

package com.cuzz.service; public interface UserService { void add(); void delete(); void update(); void get(); }

• UserService接口的实现的类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

public class UserServiceImpl implements UserService { @Override public void add() { System.out.println("添加一个user"); } @Override public void delete() { System.out.println("删除一个user"); } @Override public void update() { System.out.println("更新一个user"); } @Override public void get() { System.out.println("查询一个user"); } }

• 实现动态代理

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

package com.cuzz.service; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class UserServiceProxyFactory implements InvocationHandler{ private UserService us; public UserServiceProxyFactory(UserService us) { super(); this.us = us; } // 获得动态代理 public UserService getUserServiceProxy() { // 生成动态代理 UserService usProxy = (UserService) Proxy.newProxyInstance(UserServiceProxyFactory.class.getClassLoader(), UserServiceImpl.class.getInterfaces(), this); // 这个 this 就是实现 InvocationHandler 的对象 return usProxy; } @Override public Object invoke(Object arg0, Method method, Object[] arg2) throws Throwable { System.out.println("打开事务!"); Object invoke = method.invoke(us, arg2); System.out.println("提交事务!"); return invoke; } }

• 测试

1 2 3 4 5 6 7 8 9

public class TestDemo { @Test public void test01(){ UserService us = new UserServiceImpl(); UserServiceProxyFactory factory = new UserServiceProxyFactory(us); UserService usProxy = factory.getUserServiceProxy(); usProxy.add(); } }

• 输出

1 2 3

打开事务! 添加一个user 提交事务!

Cglib 的动态代理

• Cglib 的动态代理的代码实现

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

package com.cuzz.service; 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 UserServiceProxyFactory2 implements MethodInterceptor { public UserService getUserServiceProxy(){ // 帮我们生成代理对象 Enhancer en = new Enhancer(); // 设置对谁进行代理 en.setSuperclass(UserServiceImpl.class); // 代理要做什么 en.setCallback(this); // 创建代理对象 UserService us = (UserService) en.create(); return us; } @Override public Object intercept(Object prxoyobj, Method method, Object[] arg, MethodProxy methodProxy) throws Throwable { // 打开事务 System.out.println("打开事务!"); // 调用原有方法 Object returnValue = methodProxy.invokeSuper(prxoyobj, arg); // 提交事务 System.out.println("提交事务!"); return returnValue; } }

• 测试

1 2 3 4 5 6

@Test public void test02() { UserServiceProxyFactory2 factory = new UserServiceProxyFactory2(); UserService usProxy = factory.getUserServiceProxy(); usProxy.add(); }

Spring的AOP开发(基于AspectJ)

AOP的开发中的相关术语：

• Joinpoint(连接点)：所谓连接点是指那些被拦截到的点，在 spring 中这些点指的是方法，因为 spring 只支持方法类型的连接点
• Pointcut(切入点)：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
• Advice(通知/增强)：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
• Introduction(引介)：引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field
• Target(目标对象)：代理的目标对象
• Weaving(织入)：是指把增强应用到目标对象来创建新的代理对象的过程，spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装在期织入
• Proxy（代理）：一个类被 AOP 织入增强后，就产生一个结果代理类
• Aspect(切面)：是切入点和通知（引介）的结合

通知类型

• 前置通知 ：在目标方法执行之前执行
• 后置通知 ：在目标方法执行之后执行
• 环绕通知 ：在目标方法执行前和执行后执行
• 异常抛出通知：在目标方法执行出现异常的时候执行
• 最终通知 ：无论目标方法是否出现异常 最终通知都会执行

代码演示

通知类，给切面的目标方法标注何时地运行，必须告诉 Spring 哪个类是切面类，添加注解 @Aspect

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

@Aspect // 表示该类是一个通知类 public class MyAdvice { // 前置通知 @Before("execution(* com.cuzz.service..*ServiceImpl.*(..))") public void before(){ System.out.println("这是前置通知!!"); } // 后置通知 @AfterReturning("execution(* com.cuzz.service..*ServiceImpl.*(..))") public void afterReturning(){ System.out.println("这是后置通知(如果出现异常不会调用)!!"); } // 环绕通知 @Around("execution(* com.cuzz.service..*ServiceImpl.*(..))") public Object around(ProceedingJoinPoint pjp) throws Throwable { System.out.println("这是环绕通知之前的部分!!"); // 调用目标方法 Object proceed = pjp.proceed(); System.out.println("这是环绕通知之后的部分!!"); return proceed; } // 异常通知 @AfterThrowing("execution(* com.cuzz.service..*ServiceImpl.*(..))") public void afterException(){ System.out.println("出事啦!出现异常了!!"); } // 后置通知 @After("execution(* com.cuzz.service..*ServiceImpl.*(..))") public void after(){ System.out.println("这是后置通知(出现异常也会调用)!!"); } }

配置类，将切面类和业务逻辑类都加入到容器中，给配置类加 @EnableAspectJAutoProxy 注解

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

/** * @Author: cuzz * @Date: 2019/2/10 20:43 * @Description: */ @Configuration @EnableAspectJAutoProxy public class MainConfigOfAOP { @Bean public UserService userService() { return new UserServiceImpl(); } @Bean public MyAdvice myAdvice() { return new MyAdvice(); } }

测试

1 2 3 4 5 6 7 8 9 10

@Test public void test03() { AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class); UserService userService = (UserService) applicationContext.getBean("userService"); userService.add(); userService.delete(); userService.update(); userService.get(); }

如果报错添加依赖

1 2 3 4 5

org.aspectj aspectjweaver 1.8.4