Java动态代理

Java动态代理和cglib代理的区别有哪些?

区别：

1.实现接口方式

1.jdk动态代理实现InvocationHandler接口

public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}

2.cglib动态代理实现MethodInterceptor方法拦截器

2. 1Cglib动态代理：

   利用ASM框架，对代理对象类生成的class文件加载进来，通过修改其字节码生成子类来处理

public interface MethodInterceptor extends Callback
{
public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
MethodProxy proxy) throws Throwable;
}

2.什么时候使用jdk动态代理和cglib动态代理？

1、目标对象生成了接口 默认用JDK动态代理

2、如果目标对象使用了接口，可以强制使用cglib

3、如果目标对象没有实现接口，必须采用cglib库，Spring会自动在JDK动态代理和cglib之间转换

3.JDK动态代理和cglib字节码生成的区别？

1、JDK动态代理只能对实现了接口的类生成代理，而不能针对类（代码案例一和代码案例二解释这几句话）
2、Cglib是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，并覆盖其中方法的增强，
但是因为采用的是继承，所以该类或方法最好不要生成final，对于final类或方法，是无法继承的

4、Cglib比JDK快？

1、cglib底层是ASM字节码生成框架，但是字节码技术生成代理类，在JDL1.6之前比使用java反射的效率要高
2、在jdk6之后逐步对JDK动态代理进行了优化，在调用次数比较少时效率高于cglib代理效率
3、只有在大量调用的时候cglib的效率高，但是在1.8的时候JDK的效率已高于cglib
4、Cglib不能对声明final的方法进行代理，因为cglib是动态生成代理对象，final关键字修饰的类不可变只能被引用不能被修改

5、Spring如何选择是用JDK还是cglib？

1、当bean实现接口时，会用JDK代理模式
2、当bean没有实现接口，用cglib实现
3、可以强制使用cglib（在spring配置中加入<aop:aspectj-autoproxy proxyt-target-class=”true”/>）

总结回答：

1.实现接口方式，什么时候使用,字节码，执行速度，在spring中选择。

参考案例：

https://m.html.cn/qa/other/22646.html

动态代理概念：

• 什么事代理：现实生活中购买火车票。购买方式有直接到火车站售票点购买，或者去火车票代售点购买火车票。此时，代售点就是代理中介(具有购买，和退票)。

  动态代理利用了JDK API：

  动态地在内存中构建代理对象，从而实现对目标对象的代理功能。动态代理又被称为JDK代理或接口代理。

  动态代理和静态代理的区别：

  1、静态代理只代理一个类，而动态代理是代理接口下的多个实现类

  2、静态代理在编译时就知道要代理的类，而动态代理是在运行期动态生成的代理类。

  3 、动态代理类不需要实现接口，但是委托类还是需要实现接口。

  理论概念总结：

  1.代理的四要素：代理对象、被代理的行为、被代理的对象、行为的完全控制

  2.代理的应用：方便地为某些行为添加一些共同的逻辑（Spring AOP）或者是将行为的执行完全交由代理控制（RPC）

  3.java动态代理的原理：在运行时构建一个class字节码数组，并将其转换成一个运行时的Class对象，然后构造其实例

代码案例一、代理实现接口类

举个例子：假设火车站有购买车票方法和退票的方法，代理售票点也有购买车票和退票方法。

• 创建火车站购买车票接口

/**
* 火车票购买窗口
* @author jkl
*
*/
public interface ChooseService {
//购买火车票
public void buyTicket(String name);
//退火车票窗口
public void exitTicket(String name);
}

• 创建火车站购买车票实现接口类（委托类）

  public class ChooseServiceImpl implements ChooseService{
  @Override
  public void buyTicket(String name) {
  System.out.println("通过---["+name+"]---购买了车票");
  }
  @Override
  public void exitTicket(String name) {
  System.out.println("通过---【"+name+"---】退了车票");
  }
  }
  

• 创建jdk动态代理类

  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  /**
  * jdk动态代理类对象
  * @author jkl
  *
  */
  public class MyChooseProxyHandler implements InvocationHandler{
  private Object target ;
  //设置代理接口类
  public void setInterface(Object target){
  this.target=target;
  }
  //获取被代理类对象
  public Object getProxy(Object target){
  //System.out.println("使用当前类的ChooseService:"+this.getClass().getClassLoader());
  //System.out.println("当前类对象的接口ChooseService:"+target.getClass().getInterfaces());
  //System.out.println("当前类对象MyChooseProxyHandler:"+this);
  Object result = Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
  return result;
  }
  /**
  * proxy : 代理对象
  * methode:代理方法
  * args: 代理参数
  * 处理代理实例并返回结果
  */
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  Object result=
  method.invoke(target, args);
  logs(method.getName());
  return result;
  }
  /**
  * 日志记录方法处理
  */
  public void logs(String method){
  System.out.println("操作日志记录了"+method+"方法");
  }
  }
  

• 测试jdk动态代理

  public class ChooseController {
  public static void main(String[] args) {
  ChooseService choose = new ChooseServiceImpl();
  choose.buyTicket("火车站");
  MyChooseProxyHandler handler = new MyChooseProxyHandler();
  handler.setInterface(choose);
  ChooseService service = (ChooseService) handler.getProxy(choose);
  service.buyTicket("代理售后点");
  service.exitTicket("代理售后点");
  }
  }
  

• 输出结果：

通过---[火车站]---购买了车票
通过---[代理售后点]---购买了车票
操作日志记录了buyTicket方法
通过---【代理售后点---】退了车票
操作日志记录了exitTicket方法

代码案例二、代理类

• 创建一个未实现接口的类

  	/**
  * 代理类
  * @author jkl
  *
  */
  public class RoleServiceImpl {
  public void addRole() {
  System.out.println("添加角色");
  }
  public void updateRole() {
  System.out.println("修改角色");
  }
  public void deleteRole() {
  System.out.println("删除角色");
  }
  }
  

• 创建jdk动态代理类

  package com.urun.proxy.users;
  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  public class MyProxyHandler implements InvocationHandler {
  private Object target;
  //被代理的接口
  public void setInterface(Object target ) {
  this.target=target;
  }
  //生成得到代理类
  public Object getProxy(){
  Object object =	Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
  return object;
  }
  /**
  * proxy : 代理对象
  * methode:代理方法
  * args: 代理参数
  * 处理代理实例并返回结果
  */
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  //动态代理的实质是利用了Java的反射机制完成
  Object object = method.invoke(target, args);
  logs(method.getName());
  return object;
  }
  public void logs(String method){
  System.out.println("操作日志记录了"+method+"方法");
  }
  }
  

• 测试未实现接口的类

  public class RoleController {
  public static void main(String[] args) {
  RoleServiceImpl role = new RoleServiceImpl();
  MyProxyHandler handler2 = new MyProxyHandler();
  //设置代理接口类
  handler2.setInterface(role);
  //角色
  RoleServiceImpl roleService = (RoleServiceImpl) handler2.getProxy();
  roleService.addRole();
  roleService.updateRole();
  }
  }
  

• 输出结果：

  传统方式直接调用：新增用户信息
  通过proxy动态代理调用：新增用户信息
  操作日志记录了add方法
  删除用户信息
  操作日志记录了delete方法
  Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy1 cannot be cast to com.urun.proxy.users.RoleServiceImpl
  at com.urun.proxy.users.UsersController.main(UsersController.java:20)
  

• 总结：jdk动态代理不实现未被实现接口的类。

• 总结：第一个输出结果是直接调用火车站的购买车票接口。

• 第二个输出结果是同到代理后调用火车站得购买车票窗口

• 第三条记录和最后一条记录记录了操作日志那个方法做了什么操作。

• 优点：在不改动原有的功能上添加扩展方法。

Proxy.newProxyInstance()方法源码分析

Dog dog = (Dog) Proxy.newProxyInstance(Dog.class.getClassLoader(),
new Class[]{Dog.class}, new MyProxyHandler(doge));

Object result = Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);

@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
//克隆代理类对象方法
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* 查找或生成指定的代理类
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* 使用指定的调用处理程序调用其构造函
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
//获取反射后的构造函数
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
//通过Java反射机制获取对象并返回该类对象
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}

invoke()的方法源码分析

	@CallerSensitive
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException
{
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, obj, modifiers);
}
}
MethodAccessor ma = methodAccessor;
// read volatile
if (ma == null) {
ma = acquireMethodAccessor();
}
return ma.invoke(obj, args);
}

Java静态代理

静态代理概念：

1.静态代理需要代理类和被代理类实现相同的接口。

2.静态代理的缺点是冗余，因为一个代理类只能代理一个接口，

3.因此如果需要代理多个接口时就会产生非常多的代理类，这样就会造成大量的资源消耗

4.另外也不利于维护，当接口增加方法，代理类和委托类都要进行修改，耦合性太大

代码实现案例

• 接口

package com.urun.proxy;
/**
* 接口
* @author jkl
*
*/
public interface Dog {
//吃狗粮
public void eat();
//睡觉
public String sleep();
}

• 接口实现类

  public class BlackDog implements Dog{
  @Override
  public void eat() {
  System.out.println("狗啃骨头");
  }
  @Override
  public String sleep() {
  System.out.println("狗睡觉了");
  return null;
  }
  }
  

• 代理类

  /**
  * 静态代理类
  * @author jkl
  *
  */
  public class StaticHandler implements Dog{
  private Dog dog ;
  public StaticHandler(Dog dog){
  this.dog=dog;
  }
  @Override
  public void eat() {
  dog.eat();
  }
  @Override
  public String sleep() {
  dog.sleep();
  return null;
  }
  }
  

• 客户端测试

  /**
  * 客户端静态代理
  * @author jkl
  *
  */
  public class StaticClient {
  public static void main(String[] args) {
  BlackDog dog =
  new BlackDog();
  Dog d = new StaticHandler(dog);
  d.eat();
  d.sleep();
  }
  }
  

• 输出结果

  狗啃骨头
  狗睡觉了
  

  参考案例：

  https://blog.csdn.net/qq_44457440/article/details/101119978

spring-cglib动态代理

注意：如果是springboot项目的版本过高会出现如下错误

Exception in thread "main" java.lang.ExceptionInInitializerError
at com.urun.cglibproxy.mycglib.UserProxyController.main(UserProxyController.java:12)
Caused by: java.lang.IllegalArgumentException
at org.objectweb.asm.ClassVisitor.<init>(Unknown Source)
at net.sf.cglib.core.DebuggingClassWriter.<init>(DebuggingClassWriter.java:49)
at net.sf.cglib.core.DefaultGeneratorStrategy.getClassVisitor(DefaultGeneratorStrategy.java:30)

创建maven项目工程

引入cglib依赖包

 <dependencies>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.8.RELEASE</version>
</dependency>
</dependencies>

cglib代理类方法

一、创建代理类（注意是类而不是接口）

生活中案例：租客，中介，房东。

房东：假设拥有收租和退租两个权限，此时房东将自己拥有的权限赋予中介（为代理），租客只能通过中介办理租房业务。

在现实生活中租客可以直接和房东办理租房和退租业务，现在交由中介来完成，整个办理租房的业务通过中介完成，这个过程就叫代理

画图理解：

1.创建代理类对象

/**
* cglbi代理类
* @author jkl
*
*/
public class Landlord {
public void deliver() {
try {
System.out.println("告知房东出租成功，房东收钱");
} catch (Exception e) {
e.printStackTrace();
System.out.println("出现异常，终止");
}
}
public void out() {
try {
System.out.println("告知房东，租客退房");
} catch (Exception e) {
e.printStackTrace();
System.out.println("出现异常，终止");
}
}
}

2.创建MethodInterceptor代理方法

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CglibMethodInterceptor implements MethodInterceptor {
// 需要被代理的对象
private Object target;
public Object getTarget() {
return target;
}
public void setTarget(Object target) {
this.target = target;
}
/**
* 通过 method 引用实例
Object result = method.invoke(target, args); 形式反射调用被代理类方法，
* target 实例代表被代理类对象引用, 初始化 CglibMethodInterceptor 时候被赋值 。但是Cglib不推荐使用这种方式
* @param obj
代表Cglib 生成的动态代理类 对象本身
* @param method 代理类中被拦截的接口方法 Method 实例
* @param args
接口方法参数
* @param proxy
用于调用父类真正的业务类方法。可以直接调用被代理类接口方法
* @return
* @throws Throwable
*/
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
Object retVal = null;
try {
System.out.println("与中介的交谈");
// 房东收钱
Object result = proxy.invokeSuper(obj, args);
// Object result = method.invoke(target, args);
System.out.println("达成协议");
} catch (Exception e) {
e.printStackTrace();
System.out.println("出现异常，终止协议");
}
return retVal;
}
}

3.客户端测试代理类

import net.sf.cglib.proxy.Enhancer;
public class CglibTest {
public static void main(String[] args) throws Exception {
// 两个new对象和设置对象应该交给spring去做，不应该在这里写的，为了方便理解，就不关联到spring了！
// 增强类
CglibMethodInterceptor cglibMethodInterceptor = new CglibMethodInterceptor();
// 需被代理的对象
Landlord landlord = new Landlord();
// 把真实对象放入增强类中，隐藏起来
cglibMethodInterceptor.setTarget(landlord);
// 创建Enhancer，用来创建动态代理类
Enhancer enhancer = new Enhancer();
// 为代理类指定需要代理的类
enhancer.setSuperclass(cglibMethodInterceptor.getTarget().getClass());
// 设置调用代理类会触发的增强类
enhancer.setCallback(cglibMethodInterceptor);
// 获取动态代理类对象并返回
Landlord proxy = (Landlord) enhancer.create();
// 调用代理类的方法
proxy.deliver();
System.out.println("==================");
proxy.out();
}
}

4.输出结果：

与中介的交谈
告知房东出租成功，房东收钱
达成协议
==================
与中介的交谈
告知房东，租客退房
达成协议

二、接口代理

1、创建房东接口

/**
* 房东接口
* @author jkl
*
*/
public interface LandlordSerivce {
//收租
public void rent();
//退租
public void without();
}

2、创建房东接口实现类

/**
* 房东接口实现类
* @author jkl
*
*/
public class LandlordSerivceImpl implements LandlordSerivce{
public void rent() {
System.out.println("房东收租");
}
public void without() {
System.out.println("房东退租");
}
}

3、创建中介代理接口类

注意导包是：import net.sf.cglib.proxy.MethodInterceptor;

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
/**
* 中介代理类
* @author jkl
*
*/
public class CglibMediaInterceptor implements MethodInterceptor{
//需要被代理的对象
private Object target;
/**
* 设置代理类对象
* @param target
*/
public void setTarget(Object target) {
this.target = target;
}
public Object getTarget() {
return target;
}
public Object getProxy(){
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(this.getTarget().getClass());
enhancer.setCallback(this);
Object obj =enhancer.create();
return obj;
}
/**
* 通过 method 引用实例
Object result = method.invoke(target, args); 形式反射调用被代理类方法，
* target 实例代表被代理类对象引用, 初始化 CglibMethodInterceptor 时候被赋值 。但是Cglib不推荐使用这种方式
* @param obj
代表Cglib 生成的动态代理类 对象本身
* @param method 代理类中被拦截的接口方法 Method 实例
* @param args
接口方法参数
* @param proxy
用于调用父类真正的业务类方法。可以直接调用被代理类接口方法
* @return
* @throws Throwable
*/
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
Object result = null;
try {
media();//中介自己的相关业务
result =	proxy.invokeSuper(obj, args);//房东业务: 处理收租和退租
userLogs(method.getName());//记录操作日志
System.out.println("==============================="+proxy.getSuperName());
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
public void media(){
System.out.println("与中介交谈租房相关事项");
}
public void userLogs(String method){
System.out.println("记录用户操作日志，执行了:"+method+"方法");
}
}

4、创建租客客户端测试

/**
* 租客客户端
* @author jkl
*
*/
public class TenantsClient {
public static void main(String[] args) {
CglibMediaInterceptor cglib = new CglibMediaInterceptor();
LandlordSerivce serivce = new LandlordSerivceImpl();
cglib.setTarget(serivce);
LandlordSerivce landlordSerivce =(LandlordSerivce)cglib.getProxy();
landlordSerivce.rent();
landlordSerivce.without();
}
}

5、输出结果

与中介交谈租房相关事项
房东收租 #被代理的接口
记录用户操作日志，执行了:rent方法 #扩展日志房方法
===============================CGLIB$rent$0
与中介交谈租房相关事项
房东退租 #被代理的接口
记录用户操作日志，执行了:without方法
#扩展日志房方法
===============================CGLIB$without$1

三、接口代理测试2

租客客户端测试

/**
* 租客客户端
* @author jkl
*
*/
public class TenantsClient2 {
public static void main(String[] args) throws Exception {
// System.getProperty("user.dir")：当前项目绝对路径
String path = "G:/my-study/eclipse-project/ssm-boot-web/target";
String userDir = "user.dir";
//
saveGeneratedCGlibProxyFiles(System.getProperty(path));
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, path);
CglibMediaInterceptor cglib = new CglibMediaInterceptor();
LandlordSerivce serivce = new LandlordSerivceImpl();
cglib.setTarget(serivce);
LandlordSerivce landlordSerivce =(LandlordSerivce)cglib.getProxy();
landlordSerivce.rent();
landlordSerivce.without();
}
/**
* 设置保存Cglib代理生成的类文件。
*/
public static void saveGeneratedCGlibProxyFiles(String dir) throws Exception {
Field field = System.class.getDeclaredField("props");
field.setAccessible(true);
Properties props = (Properties) field.get(null);
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, dir);//dir为保存文件路径
props.put("net.sf.cglib.core.DebuggingClassWriter.traceEnabled", "true");
}
}

输出结果：

//生成.classes文件路径
CGLIB debugging enabled, writing to 'G:/my-study/eclipse-project/ssm-boot-web/target'
与中介交谈租房相关事项
房东收租
记录用户操作日志，执行了:rent方法
===============================CGLIB$rent$0
与中介交谈租房相关事项
房东退租
记录用户操作日志，执行了:without方法
===============================CGLIB$without$1

Cglib源码分析

代理类有三个class类

查看源码如何实现代理

查看第二类就可以知道源码是怎么实现的了。

import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class LandlordSerivceImpl$$EnhancerByCGLIB$$f0007ca2 extends LandlordSerivceImpl implements Factory {
private boolean CGLIB$BOUND;
public static Object CGLIB$FACTORY_DATA;
private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
private static final Callback[] CGLIB$STATIC_CALLBACKS;
private MethodInterceptor CGLIB$CALLBACK_0; // 拦截器(增强类)
private static Object CGLIB$CALLBACK_FILTER;
private static final Method CGLIB$rent$0$Method;
private static final MethodProxy CGLIB$rent$0$Proxy;
private static final Object[] CGLIB$emptyArgs; // 参数
private static final Method CGLIB$without$1$Method; // 被代理方法
private static final MethodProxy CGLIB$without$1$Proxy; // 代理方法
private static final Method CGLIB$equals$2$Method; // 被代理方法
private static final MethodProxy CGLIB$equals$2$Proxy; // 代理方法
private static final Method CGLIB$toString$3$Method;
private static final MethodProxy CGLIB$toString$3$Proxy;
private static final Method CGLIB$hashCode$4$Method;
private static final MethodProxy CGLIB$hashCode$4$Proxy;
private static final Method CGLIB$clone$5$Method;
private static final MethodProxy CGLIB$clone$5$Proxy;
static void CGLIB$STATICHOOK1() {
CGLIB$THREAD_CALLBACKS = new ThreadLocal();
CGLIB$emptyArgs = new Object[0];
// 代理类
Class var0 = Class.forName("com.myproxy.landlord.LandlordSerivceImpl$$EnhancerByCGLIB$$f0007ca2");
// 被代理类
Class var1;
// 方法集合
Method[] var10000 = ReflectUtils.findMethods(new String[]{"rent", "()V", "without", "()V"}, (var1 = Class.forName("com.myproxy.landlord.LandlordSerivceImpl")).getDeclaredMethods());
// 方法实例赋值给字段（被代理方法）
CGLIB$rent$0$Method = var10000[0];
// 方法实例赋值给字段（代理方法）
CGLIB$rent$0$Proxy = MethodProxy.create(var1, var0, "()V", "rent", "CGLIB$rent$0");
CGLIB$without$1$Method = var10000[1];
CGLIB$without$1$Proxy = MethodProxy.create(var1, var0, "()V", "without", "CGLIB$without$1");
var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
CGLIB$equals$2$Method = var10000[0];
CGLIB$equals$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
CGLIB$toString$3$Method = var10000[1];
CGLIB$toString$3$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
CGLIB$hashCode$4$Method = var10000[2];
CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
CGLIB$clone$5$Method = var10000[3];
CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
}
final void CGLIB$rent$0() {
super.rent();
}
//收组
public final void rent() {
// 获取拦截器（增强类）
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
if (var10000 != null) {
// 拦截器(增强类)
var10000.intercept(this, CGLIB$rent$0$Method, CGLIB$emptyArgs, CGLIB$rent$0$Proxy);
} else {
super.rent();
}
}
final void CGLIB$without$1() {
super.without();
}
//退租
public final void without() {
// 获取拦截器（增强类）
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
if (var10000 != null) {
// 拦截器(增强类)
var10000.intercept(this, CGLIB$without$1$Method, CGLIB$emptyArgs, CGLIB$without$1$Proxy);
} else {
super.without();
}
}
}

nt();
}
//收组
public final void rent() {
// 获取拦截器（增强类）
MethodInterceptor var10000 = this.CGLIBKaTeX parse error: Expected '}', got 'EOF' at end of input: … CGLIBBIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}

if (var10000 != null) {
// 拦截器(增强类)
var10000.intercept(this, CGLIB$rent$0$Method, CGLIB$emptyArgs, CGLIB$rent$0$Proxy);
} else {
super.rent();
}
}
final void CGLIB$without$1() {
super.without();
}
//退租
public final void without() {
// 获取拦截器（增强类）
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
if (var10000 != null) {
// 拦截器(增强类)
var10000.intercept(this, CGLIB$without$1$Method, CGLIB$emptyArgs, CGLIB$without$1$Proxy);
} else {
super.without();
}
}

最后

以上就是愤怒中心为你收集整理的Java动态代理和cglib动态代理的区别Java动态代理Java静态代理spring-cglib动态代理的全部内容，希望文章能够帮你解决Java动态代理和cglib动态代理的区别Java动态代理Java静态代理spring-cglib动态代理所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。