Spring基础之AOP和代理模式

文章目录

- 理解AOP
- - AOP的实现原理
- AOP代理模式
- - 静态代理
  - 动态代理
  - - 1-JDK动态代理
    - 2-CGLIB动态代理
- 总结

理解AOP

OOP - - Object Oriented Programming 面向对象编程
AOP - - Aspect Oriented Programming 面向切面编程
AOP是Spring提供的关键特性之一。AOP即面向切面编程，是OOP编程的有效补充。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入了很多的系统性相关的逻辑–比如：事务管理、日志记录、权限管理等，从而达到了将不同的关注点分离出来松耦合的效果。

AOP的实现原理

AOP的实现原理就是代理模式----其关键点是AOP框架自动创建的AOP代理
AOP代理分为静态AOP代理和动态AOP代理:

静态AOP代理 –– 是指AspectJ实现的AOP代理，它是将切面代码直接编译到Java字节码文件中，发生在编译时。
动态AOP代理 –– 是指将切面代码进行动态织入实现的AOP代理，发生在运行时。Spring的AOP即为动态AOP实现技术为：JDK提供的动态代理技术和CGLIB(Code Generation Library动态字节码增强技术)。尽管实现技术不一样，但都是基于代理模式，都是生成一个代理对象。

AOP代理模式

代理模式的核心作用就是通过代理，控制对被代理的目标对象的访问。它的设计思路是：定义一个抽象角色{接口}，让代理角色和真实角色分别去实现它。

真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。它只关注真正的业务逻辑。

代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并在前后可以附加自己的操作。
代理模式实现歌星演出场景

静态代理

要求被代理类和代理类同时实现相应的一套接口，通过代理类调用重写接口的方法，实际上调用的是原始对象的同样的方法。如下图

在这里插入图片描述

/*** 明星接口*/
public interface Star {void sing();
}
/*** 真实明星类*/
public class RealStar implements Star{@Overridepublic void sing() {System.out.println("明星本人开始唱歌...");}
}/*** 明星静态代理类*/
public class ProxyStar implements Star{private Star star; //接收明星对象/*** 通过构造方法传进来真实的明星对象* @param star*/public ProxyStar(Star star) {this.star = star;}@Overridepublic void sing() {System.out.println("明星代理先进行商务谈判...");//真实明星唱歌star.sing();System.out.println("明星演出完,代理收款...");}
}

这样的话，逻辑就非常清晰了。在代理类中，可以看到，维护了一个Star对象，通过构造方法传进来一个真实的Star对象给其赋值，
然后在唱歌这个方法里，使用真实对象来唱歌。所以说面谈、收钱都是由代理对象来实现的，唱歌是代理对象让真实对象来做。

/*** 测试客户端*/
public class TestClient {/*** 测试静态代理结果* @param args*/public static void main(String[] args) {Star realStar = new RealStar(); //创建真实对象Star proxy = new ProxyStar(realStar); //创建代理对象proxy.sing();}
}

静态代理的优缺点：
优点:
　　1.被代理的业务类只需要做好自己的业务，实现了责任分离，保证了业务类的重用性
　　2.将业务类隐藏起来，起到了保护作用
缺点:
　　1.代理对象的某个接口只服务于某一个业务对象，每个真实对象都得创建一个代理对象
　　2.如果接口增加一个方法，除了所有实现类需要实现这个方法外，代理类也需要实现，增加了代码的复杂度和成本

动态代理

在程序运行时由JVM通过反射机制动态的创建出代理对象的字节码。代理对象和真实对象的关系是在程序运行时才确定

1-JDK动态代理

JDK动态代理是使用java.lang.reflect包中的Proxy类与InvocationHandler接口来完成的，要使用JDK动态代理，必须要定义接口

API分析:
(1) java.lang.reflect.Proxy 类|-Java动态代理机制生成的所有动态代理类的父类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler hanlder)
方法职责：为指定类加载器、一组接口及调用处理器  生成动态代理类实例 
参数:loader        :类加载器interfaces        :目标(真实)对象实现的接口hanlder        :代理执行处理器
返回:动态生成的代理对象
(2) java.lang.reflect.InvocationHandler接口:
public Object invoke(Object proxy, Method method, Object[] args)
方法职责：负责集中处理动态代理类上的所有方法调用
参数: proxy :  生成的代理对象method: 当前调用的真实方法对象args:    当前调用方法的实参
返回: 真实方法的返回结果
jdk动态代理操作步骤 实现InvocationHandler接口，创建自己增强代码的处理器。
②　给Proxy类提供ClassLoader对象和代理接口类型数组，创建动态代理对象。
③　在处理器中实现增强操作。

示例：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** JDK动态代理处理类*/
public class JdkProxyHandler implements InvocationHandler {/*** 用来接收真实明星对象*/private Object realStar;/*** 传入真实明星对象，动态创建一个代理** @param realStar* @return*/public Object bind(Object realStar) {this.realStar = realStar;return Proxy.newProxyInstance(realStar.getClass().getClassLoader(),realStar.getClass().getInterfaces(), this);}/*** 当调用代理对象的方法时，会调用此方法** @param proxy* @param method* @param args* @return* @throws Throwable*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("明星代理先进行谈判...");Object result = method.invoke(realStar, args); //真实对象明星唱歌System.out.println("演出完,代理收款...");return result;}
}
/*** 测试Jdk动态代理客户端*/
public class TestJdkProxyClient {public static void main(String[] args) {Star realStar = new RealStar(); //真实对象//创建一个代理对象实例Star proxy = (Star)new JdkProxyHandler().bind(realStar);//代理对象调用方法proxy.sing();}
}

相对于静态代理，JDK 动态代理大大减少了我们的开发任务，同时减少了对业务接口的依赖，降低了耦合度

2-CGLIB动态代理

由上面的分析可知，JDK 实现动态代理需要实现类通过接口定义业务方法，那对于没有接口的类，如何实现动态代理呢，这就需要 CGLIB 了。

CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成某个类的子类.
CGLIB动态代理是针对没有接口的类进行的代理，和JDK动态代理的区别是获取代理对象的方法不一样

/*** 真实明星类*/
public class RealStar{public void sing() {System.out.println("明星本人开始唱歌...");}
}import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;/*** Cglib代理处理类*/
public class CglibProxyHandler implements MethodInterceptor {/*** 维护的目标对象*/private Object realStar;/***  Enhancer类是CGLIB中的一个字节码增强器，它可以方便的对你想要处理的类进行扩展*/private Enhancer enhancer = new Enhancer();/*** 根据被代理对象的类型 ,动态创建一个代理对象* @param realStar* @return*/public Object bind(Object realStar){
this.realStar = realStar;enhancer.setSuperclass(realStar.getClass()); //使用增强器,设置被代理对象为父类enhancer.setCallback(this);  //设置回调方法,拦截器//动态创建一个代理类对象，并返回return enhancer.create();}/***  当调用代理对象的方法时，会调用此方法进行拦截* @param proxy 代理对象* @param method 需要增强的方法* @param objects 需要增强方法的参数* @param methodProxy  需要增强的方法的代理* @return 方法执行后的返回值* @throws Throwable*/@Overridepublic Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {System.out.println("代理明星先进行演出谈判...");//invokeSuper方法调用的对象已经是增强了Object result = methodProxy.invokeSuper(object,args); //明星唱歌System.out.println("演出完成,代理去收款...");return result;}
}/*** 测试Cglib动态代理客户端*/
public class TestCglibProxyClient {public static void main(String[] args) {RealStar realStar = new RealStar(); //真实对象//创建一个代理对象实例RealStar proxy = (RealStar) new CglibProxyHandler().bind(realStar);//代理对象调用方法proxy.sing();}
}

关于CGLIB 动态代理总结：

CGLib所创建的动态代理对象在实际运行时候的性能要比JDK动态代理高不少，但是CGLIB 创建代理对象时所花费的时间却比JDK多得多，所以对于单例singleton的对象，因为无需频繁创建对象，用 CGLIB 合适，反之使用JDK方式要更为合适一些。
CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的，诸如private的方法也是不可以作为切面的。

小结
Spring AOP 中的代理使用逻辑：如果目标对象实现了接口，默认情况下会采用 JDK 的动态代理实现 AOP；如果目标对象没有实现了接口，则采用 CGLIB 库，Spring 会自动在 JDK 动态代理和 CGLIB 动态代理之间转换