设计模式-代理模式

最新推荐文章于 2024-08-29 17:15:49 发布

catch that elf

最新推荐文章于 2024-08-29 17:15:49 发布

阅读量338

点赞数 1

分类专栏：设计模式文章标签：设计模式代理模式动态代理静态代理 cglib原理

本文链接：https://blog.csdn.net/zhangxm_qz/article/details/88424737

版权

学习笔记同时被 2 个专栏收录

140 篇文章 0 订阅

订阅专栏

设计模式

11 篇文章 0 订阅

订阅专栏

代理模式（ProxyPattern）的定义也非常简单，是指为其他对象提供一种代理，以控制对这个对象的访问。代理对象在客服端和目标对象之间起到中介作用，代理模式属于结构型设计模式。使用代理模式主要有两个目的：一保护目标对象，二增强目标对象。

本文代码下载地址：https://github.com/zhangxinmin/designpattern.git

静态代理：
代理的代码是静态的。是我们手动完成的。这里模拟实现分库保存。当我们保存一个订单信息时根据订单的创建时间，保存到指定的数据库中。比如创建时间为 2019 年则保存到 DB_2019 库，创建时间为 2018 年则保存到 DB_2018 库。

增加类Order

public class Order {
    private String id;
    private Date createTime;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public Date getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
}

接口 IOrderService

public interface IOrderService {
    //保存订单信息
    public void save (Order order);
}

接口实现类 OrderServiceImpl

public class OrderServiceImpl implements IOrderService {
    @Override
    public void save(Order order) {
        System.out.println("保存订单信息...."+order.getCreateTime());
    }
}

DB选择类

public class DBRouterSelect {
    public final static String DEFAULT_DB=null;//默认db为空
    private final static ThreadLocal<String> local=new ThreadLocal<String>();
    private DBRouterSelect(){}//构造方法私有
    //获取本线程当前使用的数据库
    public static  String get(){
        return local.get();
    }
    //设置本线程使用的数据库
    public static  void set(String dbname){
        local.set(dbname);
    }
    //设置默认数据库
    public static void setDefault(){
        local.set(DBRouterSelect.DEFAULT_DB);
    }
}

代理类 ProxyOrderService

public class ProxyOrderService implements IOrderService {
    private IOrderService orderService;
    public ProxyOrderService(IOrderService orderServiceImpl){
        orderService=orderServiceImpl;
    }
    @Override
    public void save(Order order) {
        String year =new SimpleDateFormat("yyyy").format(order.getCreateTime());
        DBRouterSelect.set("DB_"+year);
        System.out.println("当前线程使用数据库："+DBRouterSelect.get());
        System.out.println("开始保存");
        orderService.save(order);
        System.out.println("保存完成");
    }
}

测试类：

public class Test {
    public static void main (String[] args){
        IOrderService serviceImpl = new OrderServiceImpl();
        ProxyOrderService prox = new ProxyOrderService(serviceImpl);
        Order order = new Order();
        order.setCreateTime(new Date());
        order.setId("222");
        prox.save(order);
    }
}

执行测试代码结果如下：
在这里插入图片描述
可以看到静态代理就是我们代理类持有一个被代理对象的实例，然后在调用被代理对象业务方法前后增加自己的扩展功能代码。接口类和实现类就是我们平常写的 service接口和实现类中的正常业务逻辑。而在代理类中增加了数据库选择代码。增强了原有实现类的功能。同时做到了实际业务功能和分库功能的解耦。

动态代理

用java动态代理实现上述功能，增加 OrderServiceDynamicProxyHander 类

public class OrderServiceDynamicProxyHander implements InvocationHandler {
    IOrderService service ;

    public IOrderService  getProxyInstance(IOrderService service){
        this.service=service;
        Class clazz=service.getClass();
        return (IOrderService)Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //如果是save方法执行如下操作
        if(method.getName().equals("save")){
            Order order= (Order)args[0];
            String year = new SimpleDateFormat("yyyy").format(new Date());
            DBRouterSelect.set("DB_"+year);
            System.out.println("自动选择数据库"+DBRouterSelect.get());
        }
        System.out.println("方法开始执行");
        Object res= method.invoke(service,args );
        System.out.println("方法执行完成");
        return res;
    }
    public static void main(String[] args){
        IOrderService serviceImpl = new OrderServiceImpl();
        IOrderService proxy = new OrderServiceDynamicProxyHander().getProxyInstance(serviceImpl);
        Order order = new Order();
        order.setCreateTime(new Date());
        order.setId("222");
        proxy.save(order);
    }
}

直接运行结果和静态代理类一致：
在这里插入图片描述
这里使用jdk动态代理完成了和静态代理相同过得功能。如何实现的呢？实际上 jdk动态生成了一个新的java类。通过如下方法可以将生成的代理类的字节码保存到$Proxy0.class 。然后反编译可以看到源码：

  public static void main(String[] args) throws Exception {
        IOrderService serviceImpl = new OrderServiceImpl();
        IOrderService proxy = new OrderServiceDynamicProxyHander().getProxyInstance(serviceImpl);
        byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{IOrderService.class});
        FileOutputStream fos = new FileOutputStream("$Proxy0.class");
        fos.write(bytes);
        fos.flush();
        fos.close();
   }

反编译后

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

import com.test.proxy.staitc.IOrderService;
import com.test.proxy.staitc.Order;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements IOrderService {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void save(Order var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.test.proxy.staitc.IOrderService").getMethod("save", Class.forName("com.test.proxy.staitc.Order"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

可以看到 jdk生成的类和被代理类实现了同样的借口同时继承了 Proxy类。代理类中覆盖了原有的方法。方法不是调用原来被代理类中的方法而是调用 InvacationHandler 中的invoke方法如：
在这里插入图片描述
而handler 中的方法，会有我们新增的逻辑如下：

在这里插入图片描述
总的来说动态搭理就是代码执行的时候自动生成一个新的类，并编译加载到虚拟机中，供我们调用。我们也可以自己动态的生成类。来实现自定义的动态代理。原理一样这里不演示了。

CGLib 调用 API 及原理分析

实现代码如下，执行代码效果和静态代理效果一样

public class OrderSeriveCGLibMethodInterceptor implements MethodInterceptor {

   public Object getInstance(Class clazz){
       Enhancer enhancer = new Enhancer();
       enhancer.setSuperclass(clazz );
       enhancer.setCallback(this);
       return enhancer.create();
   }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before(o,method,objects,methodProxy);
        methodProxy.invokeSuper(o,objects);
        after(o,method,objects,methodProxy);
        return null;
    }

    private void before (Object o, Method method, Object[] objects, MethodProxy methodProxy){
        Order order= (Order)objects[0];
        String year = new SimpleDateFormat("yyyy").format(new Date());
        DBRouterSelect.set("DB_"+year);
        System.out.println("自动选择数据库"+DBRouterSelect.get());
        System.out.println("方法开始执行");
    }
    private void after (Object o, Method method, Object[] objects, MethodProxy methodProxy){
        System.out.println("方法执行结束");
    }
    public static void main(String[] args) throws Exception {
        IOrderService serviceImpl = (IOrderService) new OrderSeriveCGLibMethodInterceptor().getInstance(OrderServiceImpl.class);
        Order order = new Order();
        order.setCreateTime(new Date());
        order.setId("222");
        serviceImpl.save(order);

    }

}

执行结果：
在这里插入图片描述
CGLib 代理的目标对象不需要实现任何接口，它是通过动态继承目标对象实现的动态代理,那么cglib如何实现代理的呢？我们通过如下代码将动态生成的代理类写磁盘

public static void main(String[] args) throws Exception {
        //利用 cglib 的代理类可以将内存中的 class 文件写入本地磁盘
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,
                "D://cglib_proxy_class/");
        IOrderService serviceImpl = (IOrderService) new OrderSeriveCGLibMethodInterceptor().getInstance(OrderServiceImpl.class);
        Order order = new Order();
        order.setCreateTime(new Date());
        order.setId("222");
        serviceImpl.save(order);
    }

执行代码后发现指定目录中有多个文件，包名和被代理类相同

在这里插入图片描述
OrderServiceImplEnhancerByCGLIB2a8da7b2.class 这个类就是代理类，它继承了被代理类，并且重写了被代理类中的所有方法，并且会有 MethodProxy 与之对应。

执行 save 方法时也是执行的创建代理对象时传入的 MethodInterceptor 的intercept方法,也就是我们添加了附加逻辑的方法。如下：
在这里插入图片描述

在这里插入图片描述
调用过程：代理对象调用 this.save()方法 -> 调用拦截器->methodProxy.invokeSuper->CGLIB$save$0->被代理对象 save()方法。此时，我们发现拦截器 MethodInterceptor 中就是由 MethodProxy 的 invokeSuper方法调用代理方法的，MethodProxy 非常关键最终调用fci.f2.invoke 如下：
在这里插入图片描述
fci.f2.invoke 这个方法实际上在这个类中如下。

这个类是就是fastclass ，在这个类中我们找到了 invoke方法 ,invoke 调用了 var10000 的 save 方法，var10000 就是我们传入的被代理对象。

动态生成的另外一个类是被代理对象的fastClass

CGLib 动态代理执行代理方法效率之所以比 JDK 的高是因为 Cglib 采用了 FastClass 机制，它的原理简单来说就是：为代理类和被代理类各生成一个 Class，这个 Class 会为代理类或被代理类的方法分配一个 index(int 类型)。这个 index 当做一个入参，FastClass就可以直接定位要调用的方法直接进行调用，这样省去了反射调用，所以调用效率比 JDK动态代理通过反射调用高。

CGLib 和 JDK 动态代理对比
1.JDK 动态代理是实现了被代理对象的接口，CGLib 是继承了被代理对象。
2.JDK 和 CGLib 都是在运行期生成字节码，JDK 是直接写 Class 字节码，CGLib 使用 ASM框架写 Class 字节码，Cglib 代理实现更复杂，生成代理类比 JDK 效率低。
3.JDK 调用代理方法，是通过反射机制调用，CGLib 是通过 FastClass 机制直接调用方法，CGLib 执行效率更高。
4.CGLIb不能代理 final修饰的方法
代理模式在 Spring 源码中的应用

ProxyFactoryBean 核心的方法就是 getObject()方法，我们来看一下源码
在这里插入图片描述
在 getObject()方法中，主要调用 getSingletonInstance()和 newPrototypeInstance()；在 Spring 的配置中，如果不做任何设置，那么 Spring 代理生成的 Bean 都是单例对象。如果修改 scope 则每次创建一个新的原型对象。
Spring 利用动态代理实现 AOP 有两个非常重要的类，一个是 JdkDynamicAopProxy 类和 CglibAopProxy 类，来看一下类图：
在这里插入图片描述
Spring 中的代理选择原则
1、当 Bean 有实现接口时，Spring 就会用 JDK 的动态代理
2、当 Bean 没有实现接口时，Spring 选择 CGLib。
3、Spring 可以通过配置强制使用 CGLib，只需在 Spring 的配置文件中加入如下代码：

<aop:aspectj-autoproxy proxy-target-class="true"/>

静态代理和动态的本质区别
1、静态代理只能通过手动完成代理操作，如果被代理类增加新的方法，代理类需要同步新增，违背开闭原则。
2、动态代理采用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则。
3、若动态代理要对目标类的增强逻辑扩展，结合策略模式，只需要新增策略类便可完成，无需修改代理类的代码。

代理模式的优缺点
优点：
1、代理模式能将代理对象与真实被调用的目标对象分离。
2、一定程度上降低了系统的耦合度，扩展性好。
3、可以起到保护目标对象的作用。
4、可以对目标对象的功能增强。
缺点：
1、代理模式会造成系统设计中类的数量增加。
2、在客户端和目标对象增加一个代理对象，会造成请求处理速度变慢。
3、增加了系统的复杂度。

catch that elf

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
设计模式-代理模式

代理模式（ProxyPattern）的定义也非常简单，是指为其他对象提供一种代理，以控制对这个对象的访问。代理对象在客服端和目标对象之间起到中介作用，代理模式属于结构型设计模式。使用代理模式主要有两个目的：一保护目标对象，二增强目标对象。静态代理：代理的代码是静态的。是我们手动完成的。这里模拟实现分库保存。当我们保存一个订单信息时根据订单的创建时间，保存到指定的数据库中。比如创建时间为...
复制链接

扫一扫