设计模式------代理模式(Proxy Pattern)

1. 什么是代理模式

代理模式指给某个类对象（被代理者）提供一个代理对象（代理者），并且代理类中会保存一个被代理者的引用，这样只要让代理者与被代理者实现相同的接口，代理类就可以代替被代理类了。举个例子：

就好像我们平时的登录操作，实体类只需简单的校验账号密码即可，又代理被处理其它的安全校验。

此时类图关系如下：

由于代理类的登录操作还需要依赖实体类的校验，所以我们需要保存一个实体类的引用，代理类来对实体类的操作做扩展，这就是代理模式。

 

2. 代理模式的优点

 

2.1. 职责清晰

实体类只用实现实际的业务逻辑，不用关心其它非本职的事务，通过后期的代理完成具体事务，使程序简洁清晰。

如例子中实体类的登录只需要负责账号密码的校验即可，其它的安全校验业务交给代理类完成。

 

2.2. 中介隔离

代理对象可以在用户和目标对象之间起到中介的作用，这样起到了中介的作用和保护了目标对象的作用。

如例子中我们的实体类登录方法太简单了，不能让别人直接调用到，就使用代理类作为一个中介处理调用。

 

2.3. 高扩展性

代理类除了是用户类和实体类的中介之外，我们还可以通过给代理类增加额外的功能来扩展实体类的功能，这样做我们只需要修改代理类而不需要再修改实体类，符合代码设计的开闭原则。

如例子我们的实体类可以完全不用修改，只通过扩展代理类可以实现各式各样的安全性校验功能。

 

3. 代理模式的种类

根据不同的实现方式，代理模式一共可以分为三种。

3.1. 静态代理

静态代理的特点是在程序运行前，代理类的 .class 文件已经由程序员创建完毕。

 

接口类：

/**
 * Created by vMars on 2019/9/6.
 */
public interface Login {
    void login();
}

 

实体类：

/**
 * Created by vMars on 2019/9/6.
 */
public class NormalLogin implements Login {

    @Override
    public void login() {
        System.out.println("账号秘密校验");
    }
}

 

代理类：

/**
 * Created by vMars on 2019/9/6.
 */
public class ProxyLogin implements Login {

    private NormalLogin bossSellTea;

    public ProxyLogin(final NormalLogin bossSellTea) {
        this.bossSellTea = bossSellTea;
    }

    @Override
    public void login() {
        System.out.println("登录前代理的其它安全校验");
        bossSellTea.login();
        System.out.println("登录后代理的其它工作");
    }
}

 

测试类：

/**
 * Created by vMars on 2019/9/6.
 */
public class ProxyTest {
    public static void main(String[] args) {
        Login login = new NormalLogin();
        login.login();

        login = new ProxyLogin((NormalLogin) login);
        login.login();
    }
}

 

静态代理很容易理解，就是代理模式思路的简单实现。

但静态代理模式有一个缺点，那就是需要在编译前写好代理类，在代理很多的场景下就需要添加许多的代理类，增加了应用程序的复杂度。

 

3.2. 动态代理

为了应对静态代理的缺点，我们可以使用动态代理。

与静态代理不同的是，动态代理得代理类是在程序运行时通过反射机制动态创建的。

（实体类、代理类、接口沿用上面的）

 

动态处理器：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * Created by vMars on 2019/9/6.
 */
public class DynamicProxyHandler implements InvocationHandler {

    private Object object;

    DynamicProxyHandler(final Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("登录前动态代理的其它安全校验");
        Object result = method.invoke(object, args);
        System.out.println("登录后动态代理的其它工作");
        return result;
    }
}

 

测试类：

import java.lang.reflect.Proxy;

/**
 * Created by vMars on 2019/9/6.
 */
public class DynamicProxyTest {
    public static void main(String[] args) {
        Login login = new NormalLogin();
        login.login();

        Login proxyLogin = (Login) Proxy.newProxyInstance(Login.class.getClassLoader(),
                new Class[] {Login.class},
                new DynamicProxyHandler(login));
        proxyLogin.login();
    }
}

 

Java提供了一个 Proxy 类，其中的 newProxyInstance 方法可以生成某个对象的代理对象。

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException

该方法的有三个参数，它们分别表示：

• loader - 类加载器来定义代理类。一般我们用被代理类的类加载器。
• interfaces - 代理类实现的接口列表。指定我们要代理的接口。
• h - 调度方法调用的调用处理函数。通过自己编写一个实现 InvocationHandler 的类，实现自己所想要的业务。

 

当我们调用动态代理的方法时，都是会被拦截然后交给动态处理器的 invoke() 方法处理的，然后 invoke() 中根据传进来的 method 的名字做判断，执行不同的操作。

 

动态代理使用 JDK 的动态代理克服了静态代理需要编写代理类的缺点，减少了代理类的数量，相对降低了应用程序的复杂度。

 

3.3. CGLIB代理

CGLIB(Code Generation Library)是一个开源项目，是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。

它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。（百度百科）

和JDK的动态代理不同，CGLIB不需要接口，它会通过修改其字节码生成实体类的子类，所以如果实体类被 final 关键字所修饰那 CGLIB 将无法代理。

要使用 CGLIB 首先我们要导入相应的包，这里以 Maven 做例子，需要加入以下依赖：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>

 

CGLIB代理类：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * Created by vMars on 2019/9/6.
 */
public class CglibProxy implements MethodInterceptor {

    private Object target;

    public Object getInstance(final Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("登录前CGLIB代理的其它安全校验");
        Object result = methodProxy.invokeSuper(o, objects);
        System.out.println("登录后CGLIB代理的其它工作");
        return result;
    }
}

 

CGLIB测试类：

/**
 * Created by vMars on 2019/9/6.
 */
public class CglibTest {
    public static void main(String[] args) {
        Login login = new NormalLogin();
        CglibProxy cglibProxy = new CglibProxy();
        Login cglibLogin = (Login) cglibProxy.getInstance(login);
        cglibLogin.login();
    }
}

 

CGLIB 的代理不像 JDK 中的那般，需要通过实体类接口来实现代理，CGLIB 即便实体类没有接口也可以实现代理。

（在jdk 1.8 之前的版本里， JDK 代理的速度会慢于 CGLIB 的代理，但在 jdk 1.8 后 JDK 的代理已经快于 CGLIB 了）

 

参考

https://www.cnblogs.com/daniels/p/8242592.html

https://www.cnblogs.com/yueshutong/p/9500632.html

https://zhuanlan.zhihu.com/p/67041662