spring AOP
什么叫AOP?
这种在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。
面向切面编程（AOP是Aspect Oriented Program的首字母缩写） ，我们知道，面向对象的特点是继承、多态和封装。而封装就要求将功能分散到不同的对象中去，这在软件设计中往往称为职责分配。
实际上也就是说，让不同的类设计不同的方法。这样代码就分散到一个个的类中去了。这样做的好处是降低了代码的复杂程度，使类可重用。 但是人们也发现，在分散代码的同时，也增加了代码的
重复性。什么意思呢？比如说，我们在两个类中，可能都需要在每个方法中做日志。按面向对象的设计方法，我们就必须在两个类的方法中都加入日志的内容。也许他们是完全相同的，但就是因为面向对象
的设计让类与类之间无法联系，而不能将这些重复的代码统一起来。 也许有人会说，那好办啊，我们可以将这段代码写在一个独立的类独立的方法里，然后再在这两个类中调用。但是，这样一来，这两
个类跟我们上面提到的独立的类就有耦合了，它的改变会影响这两个类。那么，有没有什么办法，能让我们在需要的时候，随意地加入代码呢？这种在运行时，动态地将代码切入到类的指定方法、指定位置
上的编程思想就是面向切面的编程。 一般而言，我们管切入到指定类指定方法的代码片段称为切面，而切入到哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一
个切片中，等到需要时再切入对象中去，从而改变其原有的行为。这样看来，AOP其实只是OOP的补充而已。OOP从横向上区分出一个个的类来，而AOP则从纵向上向对象中加入特定的代码。有了AOP，OOP
变得立体了。如果加上时间维度，AOP使OOP由原来的二维变为三维了，由平面变成立体了。从技术上来说，AOP基本上是通过代理机制实现的。
1.代理模式readMe：
1 代理设计模式： 是java中常用的设计模式！ 2 3 特点： 4 01.委托类和代理类有相同的接口或者共同的父类！ 5 02.代理类为委托类负责处理消息，并将消息转发给委托类！ 6 03.委托类和代理类对象通常存在关联关系！ 7 一个代理类对象与一个委托类对象关联！ 8 04.代理类本身并不是真正的实现者！而是通过调用委托类的方法， 9 来实现功能！ 10 11 12 按照代理类创建的时机，代理类分为两种： 13 01.静态代理：由我们程序猿或者特定的工具自动生成了源代码， 14 在程序运行之前，.class文件已经存在了！ 15 （serviceImpl 调用了 dao层的方法！ 真正的实现是Dao） 16 02.动态代理：在程序运行期间，通过反射的方式动态的创建出来！ 17 18 19 按照我们的使用方式： 是由共同的接口还是公共的父类？ 20 21 01.jdk动态代理 （接口） 22 必须知道一个类和一个接口 23 001.InvocationHandler接口只有一个方法 24 25 public Object invoke(Object proxy, Method method, Object[] args) 26 throws Throwable; 27 28 proxy：代理类对象 29 method：被代理的方法 30 args：被代理的方法的参数列表 31 32 002.Proxy 类： 33 public static Object newProxyInstance(ClassLoader loader, 34 Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException 35 loader:类加载器 36 interfaces：代理类实现的所有接口 37 h：InvocationHandler接口的一个实例 this当前对象 38 因为我们想使用jdk动态代理 必须是 代理类 实现 InvocationHandler！ 39 它让我们传递父接口 我们传递 自身！ 40 41 02.cglib动态代理（接口+父类） 42 必须知道一个类和一个接口 43 001.MethodInterceptor接口 44 45 public Object intercept(Object obj, 46 Method method,Object[] args,MethodProxy proxy) throws Throwable; 47 48 intercept是所有拦截器执行的方法，类似于jdk动态代理中的invoke 49 50 51 002. Enhancer类 52 53 设置委托类和代理类的公共接口或者公共的父类 54 public void setSuperclass(Class superclass) { 55 if (superclass != null && superclass.isInterface()) { 56 setInterfaces(new Class[]{ superclass }); 57 } else if (superclass != null && superclass.equals(Object.class)) { 58 // affects choice of ClassLoader 59 this.superclass = null; 60 } else { 61 this.superclass = superclass; 62 } 63 } 64 65 代理类执行完毕 通知委托类 66 public void setCallback(final Callback callback) { 67 setCallbacks(new Callback[]{ callback }); 68 } 69 70 71 在Enhancer类的父类AbstractClassGenerator中有一个方法 72 创建我们需要的代理类 73 protected Object create(Object key)
2.静态代理：
01.接口代码：
package cn.pb.dao; /** * 动物类 父接口 */ public interface Animal { //主业务 void eat(); void sleep(); }
02.实现类代码：
package cn.pb.dao.impl; /** * 狗狗类 实现了Animal接口 */ import cn.pb.dao.Animal; public class Dog implements Animal { public void eat() { System.out.println("狗狗在啃骨头！"); } public void sleep() { System.out.println("狗狗在午休！"); } }
03.静态代理类：
package cn.pb.staticproxy; import cn.pb.dao.Animal; import cn.pb.dao.impl.Dog; /** * 狗狗的静态代理类 */ public class AnimalStaticProxy implements Animal { private Dog dog; public void sleep() { System.out.println("主人在召唤"); //系统级业务 dog.sleep(); System.out.println("主人离开"); //系统级业务 } public void eat() { System.out.println("主人在召唤"); //系统级业务 dog.eat(); System.out.println("主人离开"); //系统级业务 } public Dog getDog() { return dog; } public void setDog(Dog dog) { this.dog = dog; } /** * 我们发现的问题 * 01：代码冗余 * 02：把冗余的代码提取成公共的方法 * 03：有可能小猫咪也有这些方法 * 04：提取成一个工具类中的方法 * 05：现在有一个小猫咪 也需要执行 sleep和eat 以及系统级业务方法 * 06：我们又得创建一个小猫咪对应的代理类 * 07：动物有很多 ，难道需要我们创建N个代理类吗？？肯定！ */ }
04.测试类代码：
/** * 静态代理的测试方法 */ @Test public void testStaticProxy(){ AnimalStaticProxy proxy = new AnimalStaticProxy(); Dog dog=new Dog(); proxy.setDog(dog); proxy.eat(); System.out.println("*************"); proxy.sleep(); }
3.JDK动态代理：
01.接口代码：
package cn.pb.dao; /** * 动物类 父接口 */ public interface Animal { //主业务 void eat(); void sleep(); }
02.实现类代码：
package cn.pb.dao.impl; /** * 狗狗类 实现了Animal接口 */ import cn.pb.dao.Animal; public class Dog implements Animal { public void eat() { System.out.println("狗狗在啃骨头！"); } public void sleep() { System.out.println("狗狗在午休！"); } }
03.动态代理类代码：
package cn.pb.jdkdynamicproxy; /** * JDK的动态代理类 */ import cn.pb.dao.Animal; import cn.pb.dao.impl.Dog; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class AnimalJdkDynamicProxy implements InvocationHandler { /** * 01.我们不确定委托类是谁？委托类的类型 是Object * 和委托类建立关联关系 */ private Object target; /** * 02.给我一个委托类，我返回一个代理类对象 */ public Object createProxy(Object target){ //根据传递的参数 进行对象的关联 this.target=target; return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this); } /** * * @param proxy :代理对象 * @param method ：方法名 * @param args ： 参数列表 * @return */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("主人在召唤"); //系统级业务 开始事务 Object result= method.invoke(target,args); // 主业务 System.out.println("主人离开"); //系统级业务 日志处理 关闭事务 return result; } //创建测试方法 public static void main(String[] args) { AnimalJdkDynamicProxy proxy=new AnimalJdkDynamicProxy(); Animal dog= (Animal) proxy.createProxy(new Dog()); dog.eat(); System.out.println("**************************"); dog.sleep(); } }
04.测试代码：
@Test public void testJdkDynamicProxy(){ AnimalJdkDynamicProxy proxy=new AnimalJdkDynamicProxy(); Animal dog= (Animal) proxy.createProxy(new Dog()); dog.eat(); System.out.println("**************************"); dog.sleep(); }
4.cglib动态代理：
01.接口代码：
package cn.pb.dao; /** * 动物类 父接口 */ public interface Animal { //主业务 void eat(); void sleep(); }
02.实现类代码：
package cn.pb.dao.impl; /** * 狗狗类 实现了Animal接口 */ import cn.pb.dao.Animal; public class Dog implements Animal { public void eat() { System.out.println("狗狗在啃骨头！"); } public void sleep() { System.out.println("狗狗在午休！"); } }
03.动态代理类代码：
package cn.pb.cglibdynamicproxy; /** * Cglib动态代理 */ import cn.pb.dao.Animal; import cn.pb.dao.impl.Dog; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; import java.lang.reflect.Method; public class AnimalCglibDynamicProxy implements MethodInterceptor { /** * 在enhancer中有一个setCallBack(this) * 这样就实现了代理类和委托类的关联 */ private Enhancer enhancer=new Enhancer(); /** * 创建代理类对象 */ public Object createProxy(Class clazz){ //设置公共的接口或者公共的类 enhancer.setSuperclass(clazz); //建立关联关系 enhancer.setCallback(this); return enhancer.create(); } /** * 类似于我们jdk中的invoke */ public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("主人在召唤"); //系统级业务 开始事务 Object result= proxy.invokeSuper(obj,args); // 主业务 System.out.println("主人离开"); //系统级业务 日志处理 关闭事务 return result; } //创建测试方法 public static void main(String[] args) { AnimalCglibDynamicProxy proxy=new AnimalCglibDynamicProxy(); //这里的参数可以传三种形式01：new Dog().getClass() // 02：Class.forName("cn.pb.dao.impl.Dog") 03.Dog.class Animal dog= (Animal) proxy.createProxy(new Dog().getClass()); dog.eat(); System.out.println("**************************"); dog.sleep(); } }
04.测试代码：
@Test public void testCglibDynamicProxy(){ AnimalJdkDynamicProxy proxy=new AnimalJdkDynamicProxy(); Animal dog= (Animal) proxy.createProxy(new Dog()); dog.eat(); System.out.println("**************************"); dog.sleep(); }
就是在方法前或后要做的一些事情。AOP中官方叫法为“切面” 如果写到方法中。后期维护很难。
1：核心代码
1 package com.spring.aop; 2 3 public interface ArithmeticCalculator { 4 5 int add(int i, int j); 6 int sub(int i, int j); 7 8 int mul(int i, int j); 9 int div(int i, int j); 10 11 }
1 package com.spring.aop; 2 3 import org.springframework.stereotype.Component; 4 5 @Component("arithmeticCalculator") 6 public class ArithmeticCalculatorImpl implements ArithmeticCalculator { 7 8 public int add(int i, int j) { 9 int result = i + j; 10 return result; 11 } 12 13 public int sub(int i, int j) { 14 int result = i - j; 15 return result; 16 } 17 18 public int mul(int i, int j) { 19 int result = i * j; 20 return result; 21 } 22 23 public int div(int i, int j) { 24 int result = i / j; 25 return result; 26 } 27 28 }
2：写一个切面的类
package com.spring.aop;
import java.util.Arrays;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
/**
* 可以使用 @Order 注解指定切面的优先级, 值越小优先级越高
*/
@Order(1)
@Aspect
@Component
public class LoggingAspect {
/**
* 定义一个方法, 用于声明切入点表达式. 一般地, 该方法中再不需要添入其他的代码.
* 使用 @Pointcut 来声明切入点表达式.
* 后面的其他通知直接使用方法名来引用当前的切入点表达式.
*/
@Pointcut("execution(public int com.atguigu.spring.aop.ArithmeticCalculator.*(..))")
public void declareJointPointExpression(){}
/**
* 在 com.atguigu.spring.aop.ArithmeticCalculator 接口的每一个实现类的每一个方法开始之前执行一段代码
*/
@Before("declareJointPointExpression()")
public void beforeMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
Object [] args = joinPoint.getArgs();
System.out.println("The method " + methodName + " begins with " + Arrays.asList(args));
}
/**
* 在方法执行之后执行的代码. 无论该方法是否出现异常
*/
@After("declareJointPointExpression()")
public void afterMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method " + methodName + " ends");
}
/**
* 在方法法正常结束受执行的代码
* 返回通知是可以访问到方法的返回值的!
*/
@AfterReturning(value="declareJointPointExpression()",
returning="result")
public void afterReturning(JoinPoint joinPoint, Object result){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method " + methodName + " ends with " + result);
}
/**
* 在目标方法出现异常时会执行的代码.
* 可以访问到异常对象; 且可以指定在出现特定异常时在执行通知代码
*/
@AfterThrowing(value="declareJointPointExpression()",
throwing="e")
public void afterThrowing(JoinPoint joinPoint, Exception e){
String methodName = joinPoint.getSignature().getName();
System.out.println("The method " + methodName + " occurs excetion:" + e);
}
/**
* 环绕通知需要携带 ProceedingJoinPoint 类型的参数.
* 环绕通知类似于动态代理的全过程: ProceedingJoinPoint 类型的参数可以决定是否执行目标方法.
* 且环绕通知必须有返回值, 返回值即为目标方法的返回值
*/
/*
@Around("execution(public int com.atguigu.spring.aop.ArithmeticCalculator.*(..))")
public Object aroundMethod(ProceedingJoinPoint pjd){
Object result = null;
String methodName = pjd.getSignature().getName();
try {
//前置通知
System.out.println("The method " + methodName + " begins with " + Arrays.asList(pjd.getArgs()));
//执行目标方法
result = pjd.proceed();
//返回通知
System.out.println("The method " + methodName + " ends with " + result);
} catch (Throwable e) {
//异常通知
System.out.println("The method " + methodName + " occurs exception:" + e);
throw new RuntimeException(e);
}
//后置通知
System.out.println("The method " + methodName + " ends");
return result;
}
*/
}
3：配置文件中配置上使用注解和AOP
<?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:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop" 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/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd "> <!-- 自动扫描的包 --> <context:component-scan base-package="com.spring.aop"></context:component-scan> <!-- 使 AspectJ 的注解起作用 --> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> </beans>
***：小知识：先执行哪个切面类
@Order(1) 值越小越先 执行
4：基于xml文件配置的方式
<!-- 配置目标方法的类的bean -->
<bean id="arithmeticCalculator"
class="com.spring.aop.ArithmeticCalculatorImpl"
></bean>
<!-- 配置切面类的bean -->
<bean id="laoggingAspect"
class="com.spring.aop.LoggingAspect"
></bean>
<!-- 配置AOP -->
<aop:config>
<!-- 切点表达式 就是配置哪个方法是切面 -->
<aop:pointcut expression="execution(* com.spring.aop.ArithmeticCalculator.*(int, int))" id="pointcut"/>
<!-- 调用方法的时候先执行切面 -->
<aop:aspect ref="laoggingAspect">
<aop:before method="beforeMethod" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
