设计模式-代理模式

代理模式

(文章目录)

什么是代理模式

  代理模式（Proxy Design Pattern）的原理和代码实现都不难掌握。它在不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能。

为什么要用代理模式

• 职责清晰，功能增强部分代码可以放到代理类中，减少与业务代码的耦合；
• 更符合开闭原则，对于修改的代码，放到代理类中，减少修改原有业务代码；

如何实现代理模式

静态代理

  预先将代理类编写好添加到工程中，而具体的实现方式又分为基于接口实现、基于继承实现，我们逐一进行讲解：

基于接口实现静态代理

  顾名思义，我们将原始类和代理类都实现同一接口来完成代理类中对原始类功能的增强。

// 接口
public interface ILoginService {
    String login(String userName, String passWord);
}

// 业务实现类
public class LoginService implements ILoginService{
    @Override
    public String login(String userName, String passWord) {
        System.out.println("校验用户名密码");
        return "ok";
    }
}

// 业务代理类
public class LoginServiceProxy implements ILoginService{
    private ILoginService iLoginService;

    public LoginServiceProxy(ILoginService iLoginService){
        this.iLoginService = iLoginService;
    }
    @Override
    public String login(String userName, String passWord) {

        System.out.println("代理类：执行校验前的操作");

        String login = this.iLoginService.login(userName, passWord);

        System.out.println("代理类：执行校验后的操作");

        return login;
    }
}

// 测试
public class TestProxy {
    public static void main(String[] args) {
        LoginService loginService = new LoginService();
        ILoginService iLoginService = new LoginServiceProxy(loginService);
        String login = iLoginService.login("", "");
    }
}

基于继承实现静态代理

  但是，如果原始类并没有定义接口，并且原始类代码并不是我们开发维护的（比如它来自一个第三方的类库），我们也没办法直接修改原始类，给它重新定义一个接口。在这种情况下，我们该如何实现代理模式呢？那么就需要用到我们接下来讲的采用继承的方式。让代理类继承原始类，然后扩展附加功能。代码示例如下：

public class LoginServiceProxy extends LoginService{

    @Override
    public String login(String userName, String passWord) {

        System.out.println("代理类：执行校验前的操作");

        String login = super.login(userName, passWord);

        System.out.println("代理类：执行校验后的操作");

        return login;
    }
}

动态代理

  静态代理很好实现，也很好理解，但是有一定的缺陷。一方面，我们需要在代理类中，将原始类中的所有的方法，都重新实现一遍，并且为每个方法都附加相似的代码逻辑。另一方面，如果要添加的附加功能的类有不止一个，我们需要针对每个类都创建一个代理类。如果有 50 个要添加附加功能的原始类，那我们就要创建 50 个对应的代理类。这会导致项目中类的个数成倍增加，增加了代码维护成本。并且，每个代理类中的代码都有点像模板式的“重复”代码，也增加了不必要的开发成本。   那这个问题怎么解决呢？ 我们可以使用动态代理来解决这个问题。所谓动态代理（Dynamic Proxy），就是我们不事先为每个原始类编写代理类，而是在运行的时候，动态地创建原始类对应的代理类，然后在系统中用代理类替换掉原始类。那如何实现动态代理呢？

// 省略ILoginSerivce和LoginService的代码示例
...

// 动态创建代理类处理器
public class DynamicProxyHandler<T> implements InvocationHandler {
    private T proxiedObject;

    public DynamicProxyHandler(T proxiedObject) {
        this.proxiedObject = proxiedObject;
    }

    public T getProxy(){
        ClassLoader classLoader = proxiedObject.getClass().getClassLoader();
        Class<T>[] interfaceObjectArr = (Class<T>[]) proxiedObject.getClass().getInterfaces();
        return (T) Proxy.newProxyInstance(classLoader, interfaceObjectArr, this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("动态代理类：执行校验前的操作");
        Object result = method.invoke(proxiedObject, args);
        System.out.println("动态代理类：执行校验后的操作");
        return result;
    }
}

// 使用代理类
public class TestProxy {
    public static void main(String[] args) {
        ILoginService loginService = new LoginService();
        DynamicProxyHandler handler = new DynamicProxyHandler(loginService);
        ILoginService loginServiceDynamicProxy = (ILoginService) handler.getProxy();
        loginServiceDynamicProxy.login("","");
    }
}

  实际上，Spring AOP 底层的实现原理就是基于动态代理。用户配置好需要给哪些类创建代理，并定义好在执行原始类的业务代码前后执行哪些附加功能。Spring 为这些类创建动态代理对象，并在 JVM 中替代原始类对象。原本在代码中执行的原始类的方法，被换作执行代理类的方法，也就实现了给原始类添加附加功能的目的。

总结

  代理模式常用在业务系统中开发一些非功能性需求，比如：监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦，放到代理类统一处理，让程序员只需要关注业务方面的开发。除此之外，代理模式还可以用在 RPC、缓存等应用场景中