---

Pre

Java-JDK动态代理

Java-CGLib动态代理

---

概述

代理模式是一种结构型设计模式，其目的是为其他对象提供一种代理以控制对这个对象的访问。

在 Java 中，代理模式有两种形式：

• 静态代理
• 动态代理

在代理模式中，代理类和目标类之间有一个抽象接口，代理类实现了这个接口，而目标类则实现了具体的业务逻辑。通过代理类调用目标类，可以实现对目标类的访问控制、权限检查、审计等功能。

代理模式在 Java 中应用广泛，例如可以使用代理模式来实现对网络请求的缓存、访问控制、限流等功能。

---

静态代理

概述

静态代理是一种在编译时生成代理类的方式。在静态代理中，代理类和委托类的关系在运行前就确定了。静态代理模式的实现需要手动编写代理类，并使用代理类来调用目标类。

静态代理是指在编译时就已经确定了代理类和被代理类的关系，代理类和被代理类都要实现同一个接口或者继承同一个父类。在静态代理中，代理类负责调用被代理类的方法，并在方法调用前后进行一些额外的处理。

静态代理的优点是简单易懂，容易实现，缺点是需要为每个被代理类编写一个代理类，如果被代理类过多，会导致代码冗长和维护困难。

---

Code

package com.artisan.proxy.static_proxy;/*** @author artisan*/
public interface Subject {void bussiness();
}

package com.artisan.proxy.static_proxy;/*** @author 小工匠* @version 1.0* @mark: show me the code , change the world*/
public class RealSubject implements Subject {@Overridepublic void bussiness() {System.out.println("RealSubject bussiness  Logic ");}
}

package com.artisan.proxy.static_proxy;/*** @author 小工匠* @version 1.0* @mark: show me the code , change the world* @desc: 代理类也需要实现同一个接口, 并持有真正的业务对象*/
public class ProxySubject implements Subject {/*** 持有真正的对象*/private RealSubject realSubject;/*** 传入要代理的对象, 通过构造函数实例化代理对象** @param realSubject*/public ProxySubject(RealSubject realSubject) {this.realSubject = realSubject;}@Overridepublic void bussiness() {// 代理前的业务逻辑System.out.println("ProxySubject before request");// 真正的业务处理逻辑realSubject.bussiness();// 代理后业务逻辑System.out.println("ProxySubject after request");}
}

package com.artisan.proxy.static_proxy;/*** @author 小工匠* @version 1.0* @mark: show me the code , change the world*/
public class StaticProxyDemo {public static void main(String[] args) {// 真正的处理对象RealSubject realSubject = new RealSubject();// 传入真正的处理对象，初始化代理对象ProxySubject proxySubject = new ProxySubject(realSubject);// 通过代理类调用实现了同一个接口或者继承了同一个父类的方法，以便织入代理逻辑，且不影响原来的方法的逻辑proxySubject.bussiness();}
}

---

动态代理

概述

动态代理是一种在运行时生成代理类的方式。在动态代理中，代理类和委托类的关系是在运行时确定的。动态代理模式的实现可以使用 Java 提供的 Proxy 类和 InvocationHandler 接口来实现 或者 CGLib动态代理。

---

实现方式一 - JDK代理或接口代理

概述

动态代理是指在运行时动态生成代理类，不需要为每个被代理类编写一个代理类。在动态代理中，代理类实现了InvocationHandler接口，通过反射机制调用被代理类的方法，并在方法调用前后进行一些额外的处理。

动态代理的优点是可以动态生成代理类，不需要为每个被代理类编写一个代理类，缺点是实现较为复杂。

Java动态代理是一种在运行时创建代理类的机制，它允许在不提前知道代理类的具体类型的情况下，动态地创建一个代理对象来代替原始类。相比于静态代理，动态代理更加灵活，可以代理任意的接口类型，不需要为每个被代理的类编写专门的代理类，而是通过Java的反射机制在运行时动态生成代理类。

动态代理主要使用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来实现。动态代理又被称为JDK代理或接口代理。

Code

package com.artisan.proxy.dynamic_jdk_proxy;/*** @author artisan*/
public interface Subject {void request();String handle(String inParams);
}

package com.artisan.proxy.dynamic_jdk_proxy;/*** @author 小工匠* @version 1.0* @mark: show me the code , change the world*/
public class RealSubject implements Subject {@Overridepublic void request() {System.out.println("real subject execute request");}@Overridepublic String handle(String inParams) {System.out.println("real subject execute handle, 入参： " + inParams);return inParams;}
}

package com.artisan.proxy.dynamic_jdk_proxy;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;/*** @author 小工匠* @version 1.0* @mark: show me the code , change the world*/
public class DynamicProxy implements InvocationHandler {private Object target;public DynamicProxy(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("DynamicProxy before request");Object result = method.invoke(target, args);System.out.println("DynamicProxy after request");return result;}
}

 package com.artisan.proxy.dynamic_jdk_proxy;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;/*** @author 小工匠* @version 1.0* @mark: show me the code , change the world*/
public class DynamicJdkProxyDemo {public static void main(String[] args) {// 创建真实（返回值请使用接口来接收）Subject subject = new RealSubject();// 创建动态代理类InvocationHandler invocationHandler = new DynamicProxy(subject);// 一切都是面向接口  方式一Subject subjectProxy = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(),new Class[]{Subject.class},invocationHandler);// 通过动态代理进行request方法调用subjectProxy.request();System.out.println("------------------------------");String handle = subjectProxy.handle("1-testInParams");System.out.println(handle);System.out.println("------------------------------");// 一切都是面向接口  方式二Subject o = (Subject) Proxy.newProxyInstance(subject.getClass().getClassLoader(),subject.getClass().getInterfaces(),invocationHandler);// 通过动态代理进行request方法调用o.request();System.out.println("------------------------------");String handle1 = o.handle("2-testInParams");System.out.println(handle1);}
}

通过动态代理，我们在执行类的方法前后成功添加了额外的处理（xxxx），同时客户端代码无需关心具体的日志记录逻辑，实现了解耦。动态代理在很多场景下非常有用，例如AOP（面向切面编程）等

---

实现方式二 - CGLib 子类代理 (Code Generation Library)

概述

CGLIB（Code Generation Library）是一个开源的第三方库，用于在Java运行时生成字节码并创建代理类。与Java标准库中的动态代理（基于接口）不同，CGLIB代理可以代理普通类，即使它们没有实现任何接口。CGLIB使用ASM库来生成字节码，并通过继承的方式创建代理类，因此也被称为子类代理。CGLIB广泛用于各种框架和库中，如Spring AOP

cglib代理是一种基于字节码技术的代理方式，它可以在运行时动态生成被代理类的子类，并覆盖其中的方法来实现代理。在cglib代理中，被代理类不需要实现任何接口或者继承任何父类。

cglib代理的优点是不需要为每个被代理类编写一个接口或者父类，可以对任意类进行代理，缺点是由于它是基于字节码技术实现的，所以生成的子类可能会比较庞大。

---

pom依赖

     <dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.3.0</version></dependency>

---

Code

 package com.artisan.proxy.dynamic_cglib_proxy;/*** @author 小工匠* @version 1.0* @mark: show me the code , change the world* @desc: 普通类*/
public class NormalClass {public String logic() {System.out.println("Normal class execute Logic");return "OK";}public int minus(int a, int b) {System.out.println("Normal class execute minus");return a - b;}
}

 package com.artisan.proxy.dynamic_cglib_proxy;/*** @author artisan*/
public interface Subject {void request();String handle(String inParams);
}package com.artisan.proxy.dynamic_cglib_proxy;/*** @author 小工匠* @version 1.0* @mark: show me the code , change the world* @desc: 接口类*/
public class RealSubject implements Subject {@Overridepublic void request() {System.out.println("real subject execute request");}@Overridepublic String handle(String inParams) {System.out.println("real subject execute handle, 入参： " + inParams);return inParams;}
}

package com.artisan.proxy.dynamic_cglib_proxy;import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;/*** @author 小工匠* @version 1.0* @mark: show me the code , change the world* @desc: Cglib动态代理回调类, 需要实现MethodInterceptor接口*/
public class CglibProxy implements MethodInterceptor {/****/private Object target;public CglibProxy(Object target) {this.target = target;}/*** 创建代理类** @return*/public Object createProxy() {// 创建Enhancer对象,用于生成动态代理Enhancer enhancer = new Enhancer();// 设置需要创建代理的类enhancer.setSuperclass(target.getClass());// 设置回调对象,处理代理方法调用enhancer.setCallback(this);// 生成代理类return enhancer.create();}/*** 拦截代理类方法调用** @param o           代理类实例* @param method      代理类方法* @param args        方法参数* @param methodProxy 方法代理,用于调用父类方法*/@Overridepublic Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {// 前置处理System.out.println("CglibProxy before request");// 调用父类方法Object result = methodProxy.invokeSuper(o, args);// 后置处理System.out.println("CglibProxy after request");return result;}
}

package com.artisan.proxy.dynamic_cglib_proxy;/*** @author 小工匠* @version 1.0* @mark: show me the code , change the world*/
public class DynamicCglibProxyDemo {public static void main(String[] args) {testNormalClass();System.out.println("==============================");testInterface();}/*** 代理普通类*/public static void testNormalClass() {// 真实类NormalClass normalClass = new NormalClass();// 构建代理类CglibProxy cglibProxy = new CglibProxy(normalClass);// 创建代理类NormalClass proxy = (NormalClass) cglibProxy.createProxy();// 通过代理类执行方法调用无参方法proxy.logic();System.out.println("---------------------------");// 调用代理对象的方法,传入参数int result = proxy.minus(5, 2);System.out.println(result);}/*** 代理接口*/public static void testInterface() {// 真实类Subject subject = new RealSubject();//  构建代理类CglibProxy cglibProxy = new CglibProxy(subject);// 创建代理类Subject subjectProxy = (Subject) cglibProxy.createProxy();// 通过代理类执行方法调用无参方法subjectProxy.request();System.out.println("---------------------------");// 调用代理对象的方法,传入参数String result = subjectProxy.handle("testInparmas");System.out.println(result);}
}

通过CGLIB代理，我们成功在方法执行前后添加了额外的处理（xx），实现了解耦。CGLIB代理在不需要接口的情况下也能很好地完成代理任务，但由于它是通过继承的方式生成代理类，可能会影响某些场景，比如无法代理final方法。