迈出成为架构师的第一步！看完这篇，带你秒懂Java三种代理模式！

时间  2021-08-12
标签 java 编程 设计模式 markdown 架构 ide 函数 工具 this 设计 栏目 Java 繁體版
原文   原文链接

迈出成为架构师的第一步！看完这篇，带你秒懂Java三种代理模式！

前言

代理(Proxy)模式是一种结构型设计模式，提供了对目标对象另外的访问方式；即经过代理对象访问目标对象。java

image-20210724125009890

这样作的好处是：能够在目标对象实现的基础上，加强额外的功能操做，即扩展目标对象的功能。编程

这里使用到编程中的一个思想：不要随意去修改别人已经写好的代码或者方法，若是须要修改，能够经过代理的方式来扩展该方法。设计模式

代理模式大体有三种角色：markdown

  • Real Subject：真实类，也就是被代理类、委托类。用来真正完成业务服务功能；
  • Proxy：代理类，将自身的请求用 Real Subject 对应的功能来实现，代理类对象并不真正的去实现其业务功能；
  • Subject：定义 RealSubject 和 Proxy 角色都应该实现的接口。

image-20210724125955100

代理模式有三种类型，静态代理，动态代理（JDK代理，接口代理）、Cglib代理（在内存中动态的建立目标对象的子类）架构

正文

静态代理

静态代理须要先定义接口，被代理对象与代理对象一块儿实现相同的接口，而后经过调用相同的方法来调用目标对象的方法。ide

image-20210726222112024

能够看见，代理类无非是在调用委托类方法的先后增长了一些操做。委托类的不一样，也就致使代理类的不一样。函数

某公司生产电视机，在当地销售须要找到一个代理销售商。那么客户须要购买电视机的时候，就直接经过代理商购买就能够。工具

代码示例：this

public class TV {

    private String name;//名称

    private String address;//生产地

    public TV(String name, String address) {
        this.name = name;
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "TV{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

建立公司接口：设计

public interface TVCompany {

    /**
     * 生产电视机
     * @return 电视机
     */
    public TV produceTV();
}

公司的工厂生产电视机：

public class TVFactory implements TVCompany {
    @Override
    public TV produceTV() {
        System.out.println("TV factory produce TV...");
        return new TV("小米电视机","合肥");
    }
}

代理商去下单拿货（静态代理类）:

public class TVProxy implements TVCompany{

    private TVCompany tvCompany;

    public TVProxy(){

    }

    @Override
    public TV produceTV() {
        System.out.println("TV proxy get order .... ");
        System.out.println("TV proxy start produce .... ");
        if(Objects.isNull(tvCompany)){
            System.out.println("machine proxy find factory .... ");
            tvCompany = new TVFactory();
        }
        return tvCompany.produceTV();
    }
}

消费者经过代理商拿货（代理类的使用）:

public class TVConsumer {

    public static void main(String[] args) {
        TVProxy tvProxy = new TVProxy();
        TV tv = tvProxy.produceTV();
        System.out.println(tv);
    }
}

输出结果：

TV proxy get order .... 
TV proxy start produce .... 
machine proxy find factory .... 
TV factory produce TV...
TV{name='小米电视机', address='合肥'}

Process finished with exit code 0

小结：

  • 优势：静态代理模式在不改变目标对象的前提下，实现了对目标对象的功能扩展。

  • 缺点：静态代理实现了目标对象的全部方法，一旦目标接口增长方法，代理对象和目标对象都要进行相应的修改，增长维护成本。

如何解决静态代理中的缺点呢？答案是可使用动态代理方式

动态代理

image-20210726224121229

动态代理具备以下特色：

  1. JDK动态代理对象不须要实现接口，只有目标对象须要实现接口。

  2. 实现基于接口的动态代理须要利用JDK中的API，在JVM内存中动态的构建Proxy对象。

  3. 须要使用到 java.lang.reflect.Proxy，和其newProxyInstance方法，可是该方法须要接收三个参数。

image-20210724132028289

注意该方法是在Proxy类中是静态方法，且接收的三个参数依次为：

  • ClassLoader loader：指定当前目标对象使用类加载器，获取加载器的方法是固定的。
  • Class<?>[] interfaces：目标对象实现的接口的类型，使用泛型方式确认类型。
  • InvocationHandler h：事件处理，执行目标对象的方法时，会触发事件处理器的方法，会把当前执行目标对象的方法做为参数传入。

有一天公司增长了业务，出售的商品愈来愈多，售后也须要更上。可是公司发现原来的代理商，还要再培训才能完成所有的业务，因而就找了另外的动态代理商B 。 代理商B 承诺无缝对接公司全部的业务，无论新增什么业务，均不须要额外的培训便可完成。

代码示例：

公司增长了维修业务：

public interface TVCompany {

    /**
     * 生产电视机
     * @return 电视机
     */
    public TV produceTV();

    /**
     * 维修电视机
     * @param tv 电视机
     * @return 电视机
     */
    public TV repair(TV tv);
}

工厂也得把维修业务搞起来：

public class TVFactory implements TVCompany {
    @Override
    public TV produceTV() {
        System.out.println("TV factory produce TV...");
        return new TV("小米电视机","合肥");
    }

    @Override
    public TV repair(TV tv) {
        System.out.println("tv is repair finished...");
        return new TV("小米电视机","合肥");
    }
}

B代理商 全面代理公司全部的业务。使用Proxy.newProxyInstance方法生成代理对象，实现InvocationHandler中的 invoke方法，在invoke方法中经过反射调用代理类的方法，并提供加强方法。

public class TVProxyFactory {

    private Object target;

    public TVProxyFactory(Object o){
        this.target = o;
    }

    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(),
                new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("TV proxy find factory for tv.... ");
                Object invoke = method.invoke(target, args);
                return invoke;
            }
        });
    }
}

购买、维修这两个业务 B代理就能够直接搞定了。后面公司再增长业务，B代理也能够同样搞定。

public class TVConsumer {

    public static void main(String[] args) {
        TVCompany target = new TVFactory();
        TVCompany tvCompany = (TVCompany) new TVProxyFactory(target).getProxy();
        TV tv = tvCompany.produceTV();
        tvCompany.repair(tv);
    }
}

输出结果：

TV proxy find factory for tv.... 
TV factory produce TV...
TV proxy find factory for tv.... 
tv is repair finished...

Process finished with exit code 0

小结：

  1. 代理对象不须要实现接口，可是目标对象必定要实现接口，不然不能用动态代理。

  2. 动态代理的方式中，全部的函数调用最终都会通过 invoke 函数的转发，所以咱们就能够在这里作一些本身想作的操做，好比日志系统、事务、拦截器、权限控制等。

JDK 动态代理有一个最致命的问题是它只能代理实现了某个接口的实现类，而且代理类也只能代理接口中实现的方法，要是实现类中有本身私有的方法，而接口中没有的话，该方法不能进行代理调用。

怎么解决这个问题呢？咱们能够用 CGLIB 动态代理机制。

Cglib代理

静态代理和JDK代理都须要某个对象实现一个接口，有时候代理对象只是一个单独对象，此时可使用Cglib代理。

image-20210726224750356

Cglib代理能够称为子类代理，是在内存中构建一个子类对象，从而实现对目标对象功能的扩展。

C代理商不只想代理公司，并且还想代理多个工厂的产品。

Cglib经过Enhancer 来生成代理类，经过实现MethodInterceptor接口，并实现其中的intercept方法，在此方法中能够添加加强方法，并能够利用反射Method或者MethodProxy继承类 来调用原方法。

看到 B代理商承接了公司（接口）的多种业务，那么此时C代理商又从中发现新的商机， B 只能代理某个公司的产品，而我不只想要代理公司产品，并且对接不一样的工厂，拿货渠道更广，赚钱更爽快。因而Cglib就用上了。

代码示例：

public class TVProxyCglib implements MethodInterceptor {

    //给目标对象建立一个代理对象
    public Object getProxyInstance(Class c){
        //1.工具类
        Enhancer enhancer = new Enhancer();
        //2.设置父类
        enhancer.setSuperclass(c);
        //3.设置回调函数
        enhancer.setCallback(this);
        //4.建立子类（代理对象）
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("TVProxyFactory enhancement.....");
        Object object = methodProxy.invokeSuper(o, objects);
        return object;
    }
}

新代理的B工厂

public class TVFactoryB {

    public TV produceTVB() {
        System.out.println("tv factory B producing tv.... ");
        return new TV("华为电视机", "南京");
    }

    public TV repairB(TV tv) {
        System.out.println("tv B is repair finished.... ");
        return tv;
    }
}

C代理能够直接和公司合做，也能够和工厂打交道。而且能够代理任何工厂的产品。

public class TVConsumer {

    public static void main(String[] args) {
        TVCompany tvCompany = (TVCompany) new TVProxyCglib().getProxyInstance(TVFactory.class);
        TV tv = tvCompany.produceTV();
        tvCompany.repair(tv);
        System.out.println("==============================");

        TVFactoryB tvFactoryB = (TVFactoryB) new TVProxyCglib().getProxyInstance(TVFactoryB.class);
        TV tv = tvFactoryB.produceTVB();
        tvFactoryB.repairB(tv);
    }
}

输出结果：

TVProxyFactory enhancement.....
TV factory produce TV...
TVProxyFactory enhancement.....
tv is repair finished...
==============================
TVProxyFactory enhancement.....
tv factory B producing tv.... 
TVProxyFactory enhancement.....
tv B is repair finished.... 

Process finished with exit code 0

Spring中AOP使用代理

Spring中AOP的实现有JDK和Cglib两种，以下图：

image-20210724133134109

若是目标对象须要实现接口，则使用JDK代理。

若是目标对象不须要实现接口，则使用Cglib代理。

总结

  1. 静态代理：须要代理类和目标类都实现接口的方法，从而达到代理加强其功能。

  2. JDK动态代理：须要代理类实现某个接口，使用Proxy.newProxyInstance方法生成代理类，并实现InvocationHandler中的invoke方法，实现加强功能。

  3. Cglib动态代理：无需代理类实现接口，使用Cblib中的Enhancer来生成代理对象子类，并实现MethodInterceptor中的intercept方法，在此方法中能够实现加强功能。

标签: [Java]
在这里插入图片描述

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程