设计模式之代理模式

        经过一天的学习和思考，终于理解了官方文档中的InvocationHandler的解释 ，网上的资料都将其翻译为【proxy代理实例的调用】【处理程序】【实现的一个接口】，这里的调用是一个名词，我最终的理解是，InvocationHandler这个接口的 实现类 是 处理 proxy这个动态创建的代理对象调用的方法 的程序，由用户编写，具体见文中红字，结合例子程序理解。

 代理模式

       1.  代理模式：给某一个对象提供一个代理对象，并由代理对象控制对原有对象的引用。

         2. 为什么要使用代理模式：开闭原则（开放扩展，关闭修改）。

• 代理对象除了是客户类和委托对象之间的中介以外，还可以在不改变原有业务代码的基础上，扩展功能。
• 代理对象并不负责基础业务的实现，是通过调用委托对象的业务方法实现。扩展功能包括在方法调用前后增加的消息预处理、消息过滤或打印日志等公共功能。
• 原有功能的复用性得到很大提高，这也是为什么要尽量将一个大方法拆分成多个小方法的原因，代码冗余量降低，复用性提高。

        3. 代理模式分类：静态代理和动态代理。

静态代理

• 静态代理：显式定义java代理类。
• 代理模式的角色：
  • 抽象角色：接口，封装一类业务（比如信用分服务接口的增删改查）

    // 出租房屋，抽象角色：基础业务
    public interface Rent {
    
        void rent();
    }

  • 真实角色：被代理的角色。接口的一个实现类，实现了接口中的基本业务。

    // 房东，真实角色，实现了基础业务
    public class Host implements Rent {
        public void rent() {
            System.out.println("房东出租房子");
        }
    }

  • 代理角色：代理真实角色。接口的一个实现类，在基础业务上做了扩展。可以访问真实角色，基础业务调用真实对象实现，扩展业务自定义。

    // 中介，代理角色：实现了基础业务，封装一层，在不改变原有业务的基础上可以丰富其功能
    public class Proxy implements Rent {
    
        // 代理角色需要知道其代理的真实角色
        private Host host;
    
        public Proxy() {
        }
    
        public Proxy(Host host) {
            this.host = host;
        }
        
        public void rent() {
            seeHouse(); // 前置增强
            host.rent();
            sign(); // 后置增强
        }
    
        private void seeHouse(){
            System.out.println("中介带领看房");
        }
    
        private void sign(){
            System.out.println("通过中介签合同");
        }
    }

  • 客户端：访问代理对象的人

    public class Client {
        public static void main(String[] args) {
    
            Host host = new Host();
    
            // proxy：代理真实对象host的代理对象
            Proxy proxy = new Proxy(host);
    
            proxy.rent();
    
        }
    }

• 静态代理的优点：
  • 使用代理并不是为了减少代码量，也不是为了方便。而是要提高可扩展性、减少冗余；公司的实际业务也不允许修改原有的业务代码。
  • 可以保留原有功能，是每个服务接口的能力更加纯粹
  • 没有什么是加一层解决不了的；层层封装相比于修改源代码是一种扩展性的表现。
• 静态代理的缺点：
  • 为每一个服务接口的实现类都要手动实现一个对应的代理类。接口一旦改变，代理类也要改变。
  • 每次都增加一层封装，代码量会翻倍，开发效率降低。

动态代理

• 动态代理：无需手动创建代理类，在程序运行过程中动态创建代理对象。
• 实现动态代理的两种方式：即在程序运行过程中动态创建代理对象的两种方式。
  • 基于接口的动态代理：Proxy类+InvocationHandler接口。
  • 基于类的动态代理：gblib。第一种方式只能代理接口（的实现类），对于没有接口的类就需要使用gblib来实现动态代理，gblib直接对字节码操作，通过字节码技术为该类创建一个子类，利用方法拦截技术拦截所有对父类方法的调用，然后织入横切逻辑，实现功能扩展。由于采用的是继承，所以不能对final修饰的类进行代理。
• 动态代理角色：与静态代理的角色相同，但是代理对象的创建方式不同。下面演示基于接口的动态代理
  • 抽象角色：

    // 抽象角色
    public interface Rent {
        void rent();
    }

  • 真实角色：

    // 真实角色 房东
    public class Host implements Rent {
        public void rent() {
            System.out.println("房东出租房子");
        }
    }

  • 代理角色：无需显式创建。在程序运行的过程中，通过Proxy类的静态方法动态获取。
  • 测试类：

    public class Client {
        public static void main(String[] args) {
            // 1. 创建真实对象
            Host host = new Host();
    
            // 2.1 创建调用处理器对象
            ProxyInvocationHandler handler = new ProxyInvocationHandler();
            // 2.2 设置被代理的对象，即真实对象
            handler.setRent(host);
    
            /**
             * 3. 获取代理对象
             *  代理实例已经与调用处理器关联
             *  当通过代理对象调用一个方法时，会通过反射机制调用
             */
            Rent proxy = (Rent) Proxy.newProxyInstance(
                    ProxyInvocationHandler.class.getClassLoader(), // 调用处理器的类加载器
                    host.getClass().getInterfaces(), // 目标对象的接口类型
                    handler); // 调用处理器对象
            
            /**
             * 4. 所谓的【调用】
             *  由于代理对象是动态生成的，并没有重写rent法，所以要移交给InvocationHandler处理
             */
            proxy.rent();
        }
    }

  • 调用处理器：InvocationHandler接口的实现类，重写invoke方法扩展业务功能。所谓【调用】处理程序，就是处理【调用】的类。这里的【调用】是一个名词，是指代理实例proxy对方法的调用（proxy.rent()），对这种调用的处理（因为没有显式重写的rent方法）交给InvocationHandler（调用处理器）的invoke方法，这种调用处理的转移处理是通过反射实现的。

    // 调用处理器：处理【调用】的类
    public class ProxyInvocationHandler implements InvocationHandler{
    
        // 代理实例要代理的接口
        private Rent rent;
    
        public void setRent(Rent rent) {
            this.rent = rent;
        }
    
        // 真正处理【代理对象的方法调用】的方法
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            seeHouse();
            Object result = method.invoke(rent, args);
            sign();
            return result;
        }
    
        private void seeHouse(){
            System.out.println("中介带领看房子");
        }
    
        private void sign(){
            System.out.println("与中介签合同");
        }
    }

• 优点：
  • 一个动态代理类代理一类业务，即代理的是接口（一类业务一般封装到一个接口中）
  • 所以，实现了同一接口的类（因为Proxy是根据接口创建代理实例）都可以使用同一个调用处理器处理调用。
• 抽象通用的调用处理器
  • 通用的调用处理器

    // 通用的调用处理类
    public class GeneralInvocationHandler implements InvocationHandler {
    
        // 被代理的接口
        private Object target;
    
        public void setTarget(Object target) {
            this.target = target;
        }
    
        // 调用处理方法
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            return method.invoke(target, args);
        }
    }

  • 测试类

    public class Client {
    
        public static void main(String[] args) {
            // 1. 创建真实对象
            UserServiceImpl userService = new UserServiceImpl();
    
            // 2.1 获取调用处理器
            GeneralInvocationHandler invocationHandler = new GeneralInvocationHandler();
            // 2.2 设置具体的被代理的真实对象
            invocationHandler.setTarget(userService); 
    
            // 3. 获取代理对象
            // 所谓代理对象并不是什么复杂的东西，简单理解就是一个类实例
            // 扩展了真实对象的功能，这交给invoke方法实现
            UserService proxy = (UserService) Proxy.newProxyInstance(
                    GeneralInvocationHandler.class.getClassLoader(), 
                    userService.getClass().getInterfaces(), // 代理的接口
                    invocationHandler);
    
            // 4. 执行方法
            proxy.add();
        }
    }