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 {
@Override
public 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;
}
@Override
public 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 {
@Override
public void request() {
System.out.println("real subject execute request");
}
@Override
public 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;
}
@Override
public 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 {
@Override
public void request() {
System.out.println("real subject execute request");
}
@Override
public 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 方法代理,用于调用父类方法
*/
@Override
public 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方法。文章来源：https://www.toymoban.com/news/detail-647846.html
文章来源地址https://www.toymoban.com/news/detail-647846.html
到了这里，关于Java Review - 关于代理的二三事儿的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
