【代理模式】了解篇：静态代理 && 动态代理~

最新推荐文章于 2024-06-13 14:22:04 发布

IUIUStar

最新推荐文章于 2024-06-13 14:22:04 发布

阅读量695

点赞数 1

分类专栏： Spring学习文章标签：代理模式

本文链接：https://blog.csdn.net/qq_48479056/article/details/131963215

版权

Spring学习专栏收录该内容

14 篇文章 2 订阅

订阅专栏

4、JDK动态代理和CGLIB动态代理的区别？

1、什么是代理模式？

定义：

代理模式就是为其他对象提供一种代理以控制这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象就可以在客户端和目标对象之间起到中介的作用。类似于租房：租户和房东之间现在不直接沟通，找了中介来联系，那么中介就是代理，这种模式就是代理模式。

代理模式分为静态代理和动态代理。

2、静态代理

在静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常不方便（比如接口一旦增加新方法，目标对象和代理对象都要进行修改）同时也麻烦（需要对于每个目标类都单独写一个代理类，类似于房东有很多套房子，每套房子都要找一个中介来代理），因此实际场景中静态代理的使用非常少。

（1）从JVM的层面上讲：静态代理是在编译的时候就将接口、实现类、代理类等都变成了一个个实际的class文件。

模拟租户和房东之间的租房业务：

静态代理的使用步骤：

（1）创建一个接口和实现类——相当于房主现在要出租房；

//定义接口
public interface SellHouseService {
    void sell();
}

不过房主有很多套房子，现在只想出租房子一；

//实现接口：具体的房东要出租房子
public class SellHouseOneService implements SellHouseService{
    @Override
    public void sell() {
        System.out.println("SellHouseService...");
    }
}

（2）创建一个代理类也实现这个接口 ——房主将房子一出租的任务交给中介，不然中介也没有权限去给租户看房子。

//创建代理类
public class StaticProxy implements SellHouseService{
    //将目标对象注入到代理类（），然后在代理类的对应方法调用目标类中的对应方法
    private final SellHouseService sellHouseService;
    public StaticProxy(SellHouseService sellService){
        this.sellHouseService = sellService;
    }
    @Override
    public void sell() {
        System.out.println("before...");
        sellHouseService.sell();
        System.out.println("after...");
    }
}

（3）主函数

public class Main {
    public static void main(String[] args) {
        //创建目标对象：房东
        SellHouseService service = new SellHouseOneService();
        //创建代理对象：中介
        SellHouseService proxy = new StaticProxy(service);
        proxy.sell();
    }
}

当我租第二套房子，第三套的时候也要找一个代理...非常麻烦。这个时候我们就使用动态代理了。

3、动态代理

相比于静态代理，动态代理更加灵活，我们不用再针对每个目标类都单独去创建一个代理类了。

小Tips

（1）动态代理主要有两种：JDK动态代理和CGLIB动态代理机制。

（2）其中，Spring AOP的实现就依赖了动态代理。

（3）从JVM角度讲：动态代理是在运行的时候动态生成类字节码，并加载到JVM中。

（4）在Java动态dialing机制中：InvocationHander接口和Proxy类是核心。

3.1 JDK动态代理类

JDK动态代理类的使用步骤：

（1）定义接口及实现类（同静态代理）

（2）自定义InvocationHandler并重写invoke方法，在invoke方法中调用被代理类的方法并定义一些处理逻辑；

//自定义InvokeHandler并重写invoke方法
public class JDKInvocationHandler implements InvocationHandler {
    //目标对象就是被代理对象
    private Object target;
    public JDKInvocationHandler(Object target){
        this.target = target;
    }
    //代理对象，要运行的方法，传递的实参
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //增强方法：前置处理
        //1、安全检查
        System.out.println("安全检查");
        //2、记录日志
        System.out.println("记录日志");
        //3.时间统计开始
        System.out.println("记录开始时间");

        //4、在invoke方法中会通过反射调用被代理类的方法
        Object retVal = method.invoke(target,args);
        //5、时间统计结束
        System.out.println("记录结束时间");
        return retVal;
    }
}

（3）创建一个代理类并使用。

public class Main {
    public static void main(String[] args) {
        //创建代理对象
        SellHouseService target = new SellHouseOneService();
        //创建一个代理类：通过被代理类、被代理实现的接口、方法调用处理器来创建
        SellHouseService proxy = (SellHouseService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class[]{SellHouseService.class},
                new JDKInvocationHandler(target)
        );
        proxy.sell();
    }
}

小Tips

问：如何为Java对象创建一个代理对象？

java.lang.reflect.Proxy类：提供了为对象产生代理对象的方法；

（1）Public static Object newProxyInstance（ClassLoader loader,Class<?> [ ] interfaces，InvocationHandler h），newProxyInstance作用是生成一个代理对象。返回值就是代理；

（2）这个方法一共有三个参数：loader类加载器，用于加载代理对象；interfaces：被代理类实现的一些接口；还有实现了InvocationHanldler接口的对象。

（3）JDK动态代理的问题：只能代理实现了接口的类：因此使用CGLIB动态代理来解决。

（4）通过Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler 接口的类的 invoke()方法。 你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。

3.2 CGLIB动态代理类

CGLIB（Code Generation Library）允许我们在运行的时候对字节码进行修改和动态生成。CGLIB允许我们通过继承的方式实现代理。CGLIB动态代理机制中MethodIntercepor接口和Enhancer类是核心。在Spring AOP的设计中，如果目标对象实现了接口，则默认采用JDK动态代理，否则使用CGLIB动态代理。

CGLIB动态代理类的使用步骤：

（1）添加依赖

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

（2）自定义MethodInterceptor并重写Intercept方法，intercept用于拦截增强被代理类的方法，和JDK动态代理中的Invoke方法类似；

public interface MethodInterceptor extends Callback{
    // 拦截被代理类中的⽅法
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,MethodProxy proxy) throws Throwable;
}

public class CGLIBInterceptor implements MethodInterceptor {
    //被代理对象
    private Object target;
    public CGLIBInterceptor(Object target){
        this.target = target;
    }
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //1.安全检查
        System.out.println("安全检查");
        //2.记录⽇志
        System.out.println("记录⽇志");
        //3.时间统计开始
        System.out.println("记录开始时间");
        //通过cglib的代理⽅法调⽤
        Object retVal = methodProxy.invoke(target, args);
        //4.时间统计结束
        System.out.println("记录结束时间");
        return retVal;
    }
}

（3）通过Enhancer类的create()创建代理类并使用。

public static void main(String[] args) {
        SellHouseService target= new SellHouseOneService();
        SellHouseService proxy= (SellHouseService) Enhancer.create(target.getClass(),
                new CGLIBInterceptor(target));
        proxy.sell();
    }

4、JDK动态代理和CGLIB动态代理的区别？

（1）JDK 动态代理只能代理实现了接⼝的类或者直接代理接⼝，⽽ CGLIB 可以代
理未实现任何接⼝的类。
（2）CGLIB 动态代理是通过⽣成⼀个被代理类的⼦类来拦截被代理类的⽅法调
⽤，因此不能代理声明为 final。

（3）性能: ⼤部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更
加明显

IUIUStar

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【代理模式】了解篇：静态代理 && 动态代理~

代理模式就是为其他对象提供一种代理以控制这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象就可以在客户端和目标对象之间起到中介的作用。类似于租房：租户和房东之间现在不直接沟通，找了中介来联系，那么中介就是代理，这种模式就是代理模式。代理模式分为静态代理和动态代理。
复制链接

扫一扫