【设计模式】代理模式

本篇文章总结自 【通俗易懂的23种设计模式教学】bilibili 狂神说Java代理模式

代理模式介绍

• 在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用。
• Spring AOP 底层原理就运用到了代理模式，例如要给核心代码加上打印日志等操作，如果只考虑写死代码，就直接在核心代码中加入日志，如果未来还需要改动日志的话，又需要修改核心代码，不符合开闭原则。而代理模式就是帮我们代理核心业务代码，分离出公共业务代码（例如日志）并帮我们调用核心业务代码。
• 代理模式分为静态代理与动态代理。

静态代理

• 案例：
  有一个核心业务类，里面有增删改查四个方法，现要给四个方法加上日志而不改动核心方法。
• 代码结构：
  
  IService 是业务接口，ServiceImpl 为实现类，Proxy 代理类实现 IService 接口同时持有 service 的对象，在代理类中加上对各个方法的公共业务，最后使用 Client 去调用代理类中方法。
• IService 接口：

public interface IService {
    void add();
    void update();
    void delete();
    void select();
}

• ServiceImpl ：

public class ServiceImpl implements IService {
    @Override
    public void add() {
        System.out.println("新增");
    }

    @Override
    public void update() {
        System.out.println("修改");
    }

    @Override
    public void delete() {
        System.out.println("删除");
    }

    @Override
    public void select() {
        System.out.println("查询");
    }
}

• Proxy ：

public class Proxy implements IService {

    private IService service;

    public Proxy(IService service) {
        this.service = new ServiceImpl();
    }

    @Override
    public void add() {
        log("add");
        service.add();
    }

    @Override
    public void update() {
        log("update");
        service.update();
    }

    @Override
    public void delete() {
        log("delete");
        service.delete();
    }

    @Override
    public void select() {
        log("select");
        service.select();
    }

    private void log(String msg) {
        System.out.println("打印" + msg + "日志");
    }
}

• Client：

public class Client {
    public static void main(String[] args) {
        Proxy proxy = new Proxy(new ServiceImpl());
        proxy.add();
    }
}

• 结果：
  
• 静态代理优势：
  可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
  公共代码交给代理角色，实现了业务的分工
  公共业务发生扩展的时候，方便集中管理
• 静态代理劣势：
  一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低

动态代理

• 之前在静态代理中，一个需要被代理的接口就对应一个代理类，不够灵活，这时引入动态代理就可以动态生成指定接口的代理类
• 动态代理分为 基于接口的动态代理（JDK动态代理），基于类的（cglib），Java 字节码实现（javasist）
• 案例：
  与之前一致，该案例基于接口的动态代理。
• 代码结构：
  
• ProxyInvocationHandler 类的介绍：
  该类实现了 InvocationHandler 接口并重写 invoke 方法：
  
  
  还需要 Proxy 类中的 newProxyInstance 方法去获取一个代理类
  
  
• IService 与 ServiceImpl 与之前一致
• ProxyInvocationHandler 类：

public class ProxyInvocationHandler implements InvocationHandler {

    private Object object;

    public void setObject(Object object) {
        this.object = object;
    }

    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), object.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法名" + method.getName());
        for (Object arg : args) {
            System.out.println("参数" + arg);
        }
        return method.invoke(object, args);
    }
}

• Client

public class Client {
    public static void main(String[] args) {
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setObject(new ServiceImpl());
        IService service = (IService) pih.getProxy();
        service.add("add");
    }
}

• 结果：
  
• 动态代理的优势
  可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
  公共的业务交给代理角色，实现了公共业务与核心业务的分工
  公共业务发生扩展的时候，只需要修改一次即可
  一个动态代理类代理一个接口，一般就是对应的一类业务
  一个动态代理类可以代理多个类，只要是实现了同一个接口即可