spring aop两种动态代理方式及其区别（代理模式）

冷不防 2023-01-07 13:28 143阅读 0赞

**什么是动态代理？**

假如我有一个user对象，该对象里面有4个方法，增、删、改、查，外界能直接调用这4个方法吗？拿百度来说，你能随便对百度上的内容进行增、删、改、查操作吗？你最多能执行查的操作，增、删、改的操作是不能执行的，你必须要加一个权限操作，应该看看你是否有权限执行这个操作。**同理**，谁操作了这个东西，你需要给我留下记录，免得我不知道是谁做的。所以，我应该在每一个方法的前面加权限校验，在每一个方法的后面加日志记录。

该怎么做呢？

有人说，很简单，直接在user对象的实现类里面去改，在增、删、改查前面加上权限校验，在后面加上日志记录。你能随便改别人的代码吗？你一改，所以用过user对象的地方都要改，这不乱套了吗？

有人说，可以再重新创建一个user对象，在新对象中加上权限校验和日志记录。确实是这样。但是如果我还有一个学生类，还有一个老师类...等等，你每一个都新创建一个对象的话，太麻烦了，而且没有必要，因为对我来说，我只关心对象的增、删、改、查操作，对于权限校验和日志记录我并不关心，这个时候，我们可以找中介来做权限校验和日志记录的事情，这个中介就是动态代理对象！

动态代理

代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。

举例：春季回家买票让人代买

动态代理：在程序运行过程中产生的这个对象

而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理

在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。我们有更强大的代理cglib

Proxy类中的方法创建动态代理类对象

public static Object newProxyInstance(ClassLoader loader,Class<?>\[\] interfaces,InvocationHandler h)

最终会调用InvocationHandler的方法

InvocationHandler

Object invoke(Object proxy,Method method,Object\[\] args)

代码如何来实现呢？

<table> 
 <tbody> 
 <tr> 
 <td> package&nbsp;itcast_06; &nbsp; /* &nbsp;* 用户操作接口 &nbsp;*/ public&nbsp;interface&nbsp;UserDao { public&nbsp;abstract&nbsp;void&nbsp;add(); &nbsp; public&nbsp;abstract&nbsp;void&nbsp;delete(); &nbsp; public&nbsp;abstract&nbsp;void&nbsp;update(); &nbsp; public&nbsp;abstract&nbsp;void&nbsp;find(); } </td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
 <tr> 
 <td> package&nbsp;itcast_06; &nbsp; /** &nbsp;* 用户接口实现类 &nbsp;*&nbsp;@author&nbsp;Administrator &nbsp;* &nbsp;*/ public&nbsp;class&nbsp;UserDaoImpl&nbsp;implements&nbsp;UserDao { &nbsp; @Override public&nbsp;void&nbsp;add() { System.out.println("添加功能"); } &nbsp; @Override public&nbsp;void&nbsp;delete() { System.out.println("删除功能"); } &nbsp; @Override public&nbsp;void&nbsp;update() { System.out.println("修改功能"); } &nbsp; @Override public&nbsp;void&nbsp;find() { System.out.println("查找功能"); } } </td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
 <tr> 
 <td> package&nbsp;itcast_06; &nbsp; import&nbsp;java.lang.reflect.InvocationHandler; import&nbsp;java.lang.reflect.Method; &nbsp; //写一个类实现InvocationHandler接口 public&nbsp;class&nbsp;MyInvocationHandler&nbsp;implements&nbsp;InvocationHandler { private&nbsp;Object&nbsp;target;&nbsp;// 目标对象 &nbsp; public&nbsp;MyInvocationHandler(Object&nbsp;target) { this.target&nbsp;=&nbsp;target; } &nbsp; //重写invoke()方法 public&nbsp;Object invoke(Object&nbsp;proxy, Method&nbsp;method, Object[]&nbsp;args) throws&nbsp;Throwable { System.out.println("权限校验"); Object&nbsp;result&nbsp;=&nbsp;method.invoke(target,&nbsp;args); System.out.println("日志记录"); return&nbsp;result;&nbsp;// 返回的是代理对象 } } </td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
 <tr> 
 <td> package&nbsp;itcast_06; &nbsp; import&nbsp;java.lang.reflect.Proxy; &nbsp; public&nbsp;class&nbsp;Test { public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args) { UserDao&nbsp;ud&nbsp;=&nbsp;new&nbsp;UserDaoImpl(); ud.add(); ud.delete(); ud.update(); ud.find(); System.out.println("-----------"); // 我们要创建一个动态代理对象 //&nbsp;Proxy类中有一个方法可以创建动态代理对象 // public static Object newProxyInstance(ClassLoader loader,Class&lt;?&gt;[] // interfaces,InvocationHandler h) // 我准备对ud对象做一个代理对象 MyInvocationHandler&nbsp;handler&nbsp;=&nbsp;new&nbsp;MyInvocationHandler(ud); UserDao&nbsp;proxy&nbsp;= (UserDao) Proxy.newProxyInstance(ud.getClass() .getClassLoader(),&nbsp;ud.getClass().getInterfaces(),&nbsp;handler); proxy.add(); proxy.delete(); proxy.update(); proxy.find(); &nbsp; } } </td> 
 </tr> 
 </tbody> 
</table>

以上为JDK动态代理，只能针对接口做代理。我们有更强大的代理cglib。

**JDK动态代理依赖一个类和一个接口，分别是什么？**

**答：**Proxy类和InvocationHandler接口。

调用Proxy类中的*newProxyInstance*(ClassLoader loader,Class<?>\[\] interfaces,InvocationHandler h)方法可以创建一个动态代理对象，但是这个方法需要3个参数，前两个参数是固定的，但第三个参数比较麻烦，需要我们创建一个类MyInvocationHandler来实现InvocationHandler接口，这个类里面要重写invoke()方法。

**JDK动态代理和cglib动态代理有什么区别？**

**答：**JDK动态代理智能对实现了接口的类生成代理对象；

cglib可以对任意类生成代理对象，它的原理是对目标对象进行继承代理，如果目标对象被final修饰，那么该类无法被cglib代理。

**Spring框架的一大特点就是AOP，SpringAOP的本质就是动态代理，那么Spring到底使用的是JDK代理，还是cglib代理呢？**

**答：**混合使用。如果被代理对象实现了接口，就优先使用JDK代理，如果没有实现接口，就用用cglib代理。

### **动态代理的应用** ###

AOP（Aspect-OrientedProgramming，面向切面编程），AOP包括切面（aspect）、通知（advice）、连接点（joinpoint），实现方式就是通过对目标对象的代理在连接点前后加入通知，完成统一的切面操作。

实现AOP的技术，主要分为两大类：

一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；

二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

Spring提供了两种方式来生成代理对象: JDKProxy和Cglib，具体使用哪种方式生成由AopProxyFactory根据AdvisedSupport对象的配置来决定。

**默认的策略是如果目标类是接口，则使用JDK动态代理技术，如果目标对象没有实现接口，则默认会采用CGLIB代理。**

如果目标对象实现了接口，可以强制使用CGLIB实现代理（添加CGLIB库，**并在spring配置中加入<aop:aspectj-autoproxy proxy-target-class="true"/>**）。

# **JDK动态代理** #

1、因为利用JDKProxy生成的代理类实现了接口，所以目标类中所有的方法在代理类中都有。   
2、生成的代理类的所有的方法都拦截了目标类的所有的方法。而拦截器中invoke方法的内容正好就是代理类的各个方法的组成体。   
3、利用JDKProxy方式必须有接口的存在。   
4、invoke方法中的三个参数可以访问目标类的被调用方法的API、被调用方法的参数、被调用方法的返回类型。

# **cglib动态代理** #

1、 CGlib是一个强大的,高性能,高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。   
2、 用CGlib生成代理类是目标类的子类。   
3、 用CGlib生成 代理类不需要接口   
4、 用CGLib生成的代理类重写了父类的各个方法。   
5、 拦截器中的intercept方法内容正好就是代理类中的方法体

# **spring两种代理方式** #

1. 若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。   
优点：因为有接口，所以使系统更加松耦合   
缺点：为每一个目标类创建接口

2. 若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。   
优点：因为代理类与目标类是继承关系，所以不需要有接口的存在。   
缺点：因为没有使用接口，所以系统的耦合性没有使用JDK的动态代理好。