设计模式--代理模式

简介

代理模式是指为其他对象提供一种代理，以控制对这个对象的访问，属于结构性模式。在某些情况下，一个对象不适合或者和不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介作用。

代理模式通用UML类图：

代理模式一般包含三种角色：

抽象主题角色（ISubject）:抽象主题类的主要职责是声明真实主题与代理的共同接口方法，该类可以是接口也可以是抽象类；

真实主题角色（RealSubject）：该类也被称为代理类，该类定义了代理所表示的真实对象，是负责执行系统真正的逻辑业务对象；

代理主题角色（Proxy）:也被称为代理类，其内部持有RealSubject的引用，因此具备完全的对RealSubject的代理权。客户端调用代理对象的方法，同时也被调用被代理对象的方法，但是会在代理对象前后增加一些处理代码。

在代码中，一般代理会被理解为代码增强，实际上就是在源代码逻辑前后增加一些代码逻辑，从而使调用者无感知。代理模式属于结构型模式，分为静态代理和动态代理。

代理模式的应用场景

事务代理、非侵入式日志监听等。

代理模式的主要目的：一是保护目标对象，二是增强目标对象。

代理模式的通用写法

创建代理主题角色ISubject类：

public interface ISubject {
    void request();
}

创建真实主题角色RealSubject类：

public class RealSubject implements ISubject {
    public void request() {
        System.out.println("real service is called.");
    }
}

创建代理主题角色Proxy类：

public class Proxy implements ISubject {

    private ISubject subject;

    public Proxy(ISubject subject){
        this.subject = subject;
    }

    public void request() {
        before();
        subject.request();
        after();
    }

    public void before(){
        System.out.println("called before request().");
    }

    public void after(){
        System.out.println("called after request().");
    }
}

客户端调用代码:

public class Client {

    public static void main(String[] args) {
        Proxy proxy = new Proxy(new RealSubject());
        proxy.request();
    }
}

静态模式（在业务中的应用）

业务场景：在分布式中，通常会对数据库镜像分库分表，分库分表之后使用Java操作就可能需要配置多个数据源，我们通过设置数据源路由来动态切换数据源。

Order订单类：

@Data
public class Order {
    private Object orderInfo;
    //订单创建时间进行按年分库
    private Long createTime;
    private String id;

}

创建OrderDao持久层操作类：

public class OrderDao {
    public int insert(Order order){
        System.out.println("OrderDao创建Order成功!");
        return 1;
    }
}

创建OrderService实现类：

public class OrderService implements IOrderService {
    private OrderDao orderDao;

    public OrderService(){
        //如果使用Spring应该是自动注入的
        //我们为了使用方便，在构造方法中将orderDao直接初始化了
        orderDao = new OrderDao();
    }

    public int createOrder(Order order) {
        System.out.println("OrderService调用orderDao创建订单");
        return orderDao.insert(order);
    }
}

使用静态代理，主要完成的功能是：根据订单创建时间自动按照年进行分库。通过代理对象来完成。创建数据源路由对象、创建路由数据源路由对象，使用ThreadLocal的单例实现DynamicDataSourceEntity类：

//动态切换数据源
public class DynamicDataSourceEntity {

    //默认数据源
    public final static String DEFAULE_SOURCE = null;

    private final static ThreadLocal<String> local = new ThreadLocal<String>();

    private DynamicDataSourceEntity(){}

    //清空数据源
    public static void clear() {
        local.remove();
    }

    //获取当前正在使用的数据源名字
    public static String get(){return  local.get();}

    //还原当前切换的数据源
    public static void restore(){
         local.set(DEFAULE_SOURCE);
    }

    //DB_2018
    //DB_2019
    public static void set(String source){local.set(source);}

    //根据年份动态设置数据源
    public static void set(int year){local.set("DB_" + year);}

}

创建切换数据源的代理类OrderServiceStaticProxy：

public class OrderServiceStaticProxy implements IOrderService {
    private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");

    private IOrderService orderService;
    public OrderServiceStaticProxy(IOrderService orderService) {
        this.orderService = orderService;
    }

    public int createOrder(Order order) {
        Long time = order.getCreateTime();
        Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
        System.out.println("静态代理类自动分配到【DB_" +  dbRouter + "】数据源处理数据" );
        DynamicDataSourceEntity.set(dbRouter);

        this.orderService.createOrder(order);
        DynamicDataSourceEntity.restore();

        return 0;
    }
}

测试代码：

public class DbRouteProxyTest {
    public static void main(String[] args) {
        try {
            Order order = new Order();

            order.setCreateTime(new Date().getTime());

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
            Date date = sdf.parse("2020/03/01");
            order.setCreateTime(date.getTime());
            IOrderService orderService = (IOrderService)new OrderServiceStaticProxy(new OrderService());
            orderService.createOrder(order);

        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

运行结果：

静态代理类自动分配到【DB_2020】数据源处理数据
OrderService调用orderDao创建订单
OrderDao创建Order成功!

类图：

动态代理和静态代理的思路基本一致，但是动态代理功能更强大，业务扩展性强。

动态代理（在业务场景中的应用）

创建动态代理类OrderServiceDynamicProxy：

public class OrderServiceDynamicProxy implements InvocationHandler {

    private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");

    Object proxyObj;
    public Object getInstance(Object proxyObj) {
        this.proxyObj = proxyObj;
        Class<?> clazz = proxyObj.getClass();
        return Proxy.newProxyInstance(new GPClassLoader(),clazz.getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before(args[0]);
        Object object = method.invoke(proxyObj,args);
        after();
        return object;
    }

    private void after() {
        System.out.println("Proxy after method");
        //还原成默认的数据源
        DynamicDataSourceEntity.restore();
    }

    //target 应该是订单对象Order
    private void before(Object target) {
        try {
            //进行数据源的切换
            System.out.println("Proxy before method");

            //约定优于配置
            Long time = (Long) target.getClass().getMethod("getCreateTime").invoke(target);
            Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
            System.out.println("静态代理类自动分配到【DB_" + dbRouter + "】数据源处理数据");
            DynamicDataSourceEntity.set(dbRouter);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

测试类：

public class DbRouteProxyTest {
    public static void main(String[] args) {
        try {
            Order order = new Order();

            order.setCreateTime(new Date().getTime());

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
            Date date = sdf.parse("2020/03/01");
            order.setCreateTime(date.getTime());

            IOrderService orderService = (IOrderService)new OrderServiceDynamicProxy().getInstance(new OrderService());
            orderService.createOrder(order);
        }catch (Exception e){
            e.printStackTrace();
        }

    }

}

结果

Proxy before method
静态代理类自动分配到【DB_2020】数据源处理数据
OrderService调用orderDao创建订单
OrderDao创建Order成功!
Proxy after method

从结果上看依然达到了相同的效果。但是，使用动态代理上线之后，我们不仅能实现Order的数据动态代理路由，还可以实现其他任何类的数据源路由。当然，有个必须实现getCreateTime()方法，因为路由规则是根据时间来运算的。

jdk动态代理原理实现

jdk动态代理生成对象的步骤：

1）获取被代理对象的引用，并获取它的所有接口，反射获取。

2）JDK动态代理类重新生成一个新的类。同时新的类要实现被代理类实现的多有接口。

3）动态生成java代码，新加的业务逻辑方法由一定的逻辑代码调用。

4）编译新生成java代码.class文件。

5）重新加载到JVM中运行。

我们将内存中的对象字节通过文件流输出到一个新的.class文件，然后利用反编译工具查看其源代码。

public class JDKProxyTest {
    public static void main(String[] args) {
        try {
            IPerson instance = new JdkProxy().getInstance(new Customer());
            instance.findLove();

            byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Zhangsan.class});
            FileOutputStream os = new FileOutputStream("D:\\Program Files\\jad\\$Proxy0.class");
            os.write(bytes);
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

使用jad反编译$Proxy0.class文件，打开后可以看到如下内容：

public final class $Proxy0 extends Proxy
    implements Customer
{

    public $Proxy0(InvocationHandler invocationhandler)
    {
        super(invocationhandler);
    }

    public final boolean equals(Object obj)
    {
        try
        {
            return ((Boolean)super.h.invoke(this, m1, new Object[] {
                obj
            })).booleanValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }
    
    ...
}

这里面的继承Proxy，重写方法 都是JDK帮我们完成的。

手写实现JDK代理模式

创建IPerson类：

public interface IPerson {

    void findLove();

    void buyInsure();

}

创建Human类：

public class Human implements IPerson {

    @Override
    public void findLove() {
        System.out.println("寻找爱情");
    }

    @Override
    public void buyInsure() {
        System.out.println("buy insure");
    }
}

创建MyInvocationHandler接口

public interface MyInvocationHandler {

    Object invoke(Object MyProxy, Method method, Object[] args) throws Throwable;

}

创建MyProxy类：

public class MyProxy {

    public static final String ln = "\r\n";

    public static Object newProxyInstance(MyClassLoader classLoader, Class<?>[] interfaces, MyInvocationHandler h) {

        try {
            //动态生成源代码.java文件
            String src = generateSrc(interfaces);

            //Java文件输出磁盘
            String filePath = MyProxy.class.getResource("").getPath();
            File f = new File(filePath + "$Proxy0.java");
            FileWriter fw = new FileWriter(f);
            fw.write(src);
            fw.flush();
            fw.close();

            //把生成的.java文件编译成.class文件
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null);
            Iterable iterable = manager.getJavaFileObjects(f);
            JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, null, null, iterable);
            task.call();
            manager.close();

            //把编译生成的.class文件加载到JVM中
            Class proxyClass = classLoader.findClass("$Proxy0");
            Constructor constructor = proxyClass.getConstructor(MyInvocationHandler.class);
            f.delete();

            //返回字节码重组以后的新的代理对象
            return constructor.newInstance(h);
        } catch (Exception e) {
            e.printStackTrace();
        }


        return null;
    }

    private static String generateSrc(Class<?>[] interfaces) {

        StringBuffer sb = new StringBuffer();

        sb.append(MyProxy.class.getPackage() + ";" + ln);
        sb.append("import "+ interfaces[0].getName() + ";" + ln);
        sb.append("import java.lang.reflect.*;" + ln);
        sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
        sb.append("MyInvocationHandler h;" + ln);
        sb.append("public $Proxy0(MyInvocationHandler h) {" + ln);
        sb.append("this.h = h;" + ln);
        sb.append("}" + ln);

        for (Method m : interfaces[0].getMethods()) {
            Class<?>[] params = m.getParameterTypes();

            StringBuffer paramNames = new StringBuffer();
            StringBuffer paramValues = new StringBuffer();
            StringBuffer paramClasses = new StringBuffer();

            for (int i = 0; i < params.length; i++) {
                Class clazz = params[i];
                String type = clazz.getName();
                String paramName = toLowerFirstCase(clazz.getSimpleName());
                paramNames.append(type + " " + paramName);
                paramValues.append(paramNames);
                paramClasses.append(clazz.getName() + ".class");
                if (i > 0 && i < params.length - 1) {
                    paramNames.append(",");
                    paramClasses.append(",");
                    paramValues.append(",");
                }
            }

            sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "(" + paramNames.toString() + ") {" + ln);
            sb.append("try{" + ln);
            sb.append("Method m = " + interfaces[0].getName() + ".class.getMethod (\"" + m.getName() +
                    "\",new Class[]{" + paramClasses.toString() + "});" + ln);

            sb.append((hasReturnValue(m.getReturnType()) ? "return " : "") +
                    getCaseCode("this.h.invoke(this, m , new Object[]{" + paramValues + "})", m.getReturnType()) + ";" + ln);
            sb.append("}catch(Error _ex) { }" + ln);
            sb.append("catch(Throwable throwable)" + ln);
            sb.append("{" + ln);
            sb.append("throw new UndeclaredThrowableException(throwable);" + ln);
            sb.append("}" + ln);
            sb.append(getReturnEmptyCode(m.getReturnType()));
            sb.append("}");
        }
        sb.append("}" + ln);
        return sb.toString();
    }

    private static Map<Class, Class> mappings = new HashMap<Class, Class>();
    static {
        mappings.put(int.class, Integer.class);
    }

    private static String getReturnEmptyCode(Class<?> returnClass) {
        if(mappings.containsKey(returnClass)){
            return "return 0;";
        }else if(returnClass == void.class){
            return "";
        }else{
            return "return null;";
        }
    }

    private static boolean hasReturnValue(Class<?> returnClass) {

        return returnClass != void.class;
    }

    private static String getCaseCode(String code, Class<?> returnClass) {

        if(mappings.containsKey(returnClass)){
            return "((" + mappings.get(returnClass).getName() + ")" + code + ")." +returnClass.getSimpleName() + "Value()";
        }
        return code;
    }

    private static String toLowerFirstCase(String src) {
        char[] chars = src.toCharArray();
        chars[0] += 32;
        return String.valueOf(chars);
    }

}

创建MyClassLoader类：

public class MyClassLoader extends ClassLoader {

    private File classPathFile;

    protected MyClassLoader() {
        String path = MyClassLoader.class.getResource("").getPath();
        this.classPathFile = new File(path);
    }

    protected Class<?> findClass(String name) throws ClassNotFoundException {

        String className = MyClassLoader.class.getPackage().getName() + "." + name;
        if (classPathFile != null) {
            File classFile = new File(classPathFile, name.replaceAll("\\.", "/") + ".class");
            if (classFile.exists()) {
                FileInputStream in = null;
                ByteArrayOutputStream out = null;

                try {
                    in = new FileInputStream(classFile);
                    out = new ByteArrayOutputStream();
                    byte[] buff = new byte[1024];
                    int len;
                    while ((len = in.read(buff)) != -1) {
                        out.write(buff, 0, len);
                    }
                    return defineClass(className, out.toByteArray(), 0, out.size());
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    if(null != in){
                        try {
                            in.close();
                        }catch (IOException e){
                            e.printStackTrace();
                        }
                    }

                    if(out != null){
                        try{
                            out.close();
                        }catch (IOException e){
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
        return null;
    }
}

创建Intermediary类

public class Intermediary implements MyInvocationHandler {

    private Object target;

    public Object getInstance(Object target) throws Throwable {
        this.target = target;
        Class<?> clazz = target.getClass();
        return MyProxy.newProxyInstance(new MyClassLoader(), clazz.getInterfaces(), this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        before();
        Object result = method.invoke(this.target, args);
        after();
        return result;
    }

    private void after() {
        System.out.println("我是中介：开始找妹子");
    }

    private void before() {
        System.out.println("找到了 等你去找妹子");
    }
}

客户端测试代码

public class JDKHandTest {
    public static void main(String[] args) throws Throwable {
        IPerson obj = (IPerson) new Intermediary().getInstance(new Human());
        System.out.println(obj.getClass());
        obj.findLove();
    }
}

CGLib代理调用API及与与原理分析

以中介为例，创建CglibIntermediary类：

public class CglibIntermediary implements MethodInterceptor {

    public Object getInstance(Class<?> clazz) throws Exception{

        Enhancer enhancer = new Enhancer();
        //设置新类的父类
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        before();
        Object obj = methodProxy.invokeSuper(o, objects);
        after();
        return obj;
    }

    private void before() {
        System.out.println("我是中介：开始找妹子");
    }
    
    private void after() {
        System.out.println("找到了 等你去找妹子");
    }
}

创建单身用户

public class Customer implements IPerson {

    @Override
    public void findLove() {
        System.out.println("寻找爱情");
    }

    @Override
    public void buyInsure() {
        System.out.println("buy insure");
    }
}

CGLib代理的目标对象不需要实现任何接口，它是通过动态继承目标对象实现动态代理的。

public class CglibTest {

    public static void main(String[] args) throws Exception {

        Customer instance = (Customer)new CglibIntermediary().getInstance(Customer.class);
        instance.findLove();
    }
}

CGLib代理的实现原理是怎么样的呢？

将CGLib代理后的.class文件写入磁盘，然后反编译一下。

public static void main(String[] args) throws Exception {

    //利用cglib代理可以将本地.class文件写到本地磁盘上
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D://cglib_proxy_class/");
    Customer instance = (Customer)new CglibIntermediary().getInstance(Customer.class);
    instance.findLove();
}

重新执行代码，我们会发现在指定目录多了三个.class文件。

通过调试发现，第二个.class为CGLib代理生成的代理类，继承了Customer类。

会发现这个子类重写了Customer类的所有方法。

调用过程为：代理对象调用this.findLove()方法-->调用拦截器-->methodProxy.invokeSuper()-->CGLIB$findLove$0-->被代理对象findLove()方法。

另外我们发现拦截器MethodInterceptor中就是由MethodProxy的invokeSuper()方法调用代理方法，MethodProxy非常关键。

查看MethodProxy的invokeSuper()方法:

public Object invokeSuper(Object obj, Object[] args) throws Throwable {
    try {
        init();
        FastClassInfo fci = fastClassInfo;
        return fci.f2.invoke(fci.i2, obj, args);
    } catch (InvocationTargetException e) {
        throw e.getTargetException();
    }
}

private static class FastClassInfo
{
    FastClass f1;
    FastClass f2;
    int i1;
    int i2;
}

private static class CreateInfo
{
    ....
}

上面代码就是获取代理类对应的FastClass，并执行代理方法。刚才三个.class除了第二个，其他两个都是代理FastClass类。

CGLib代理执行执行方法的效率之所以比JDK的高，是因为CGLib采用了FastClass机制，它的原理简单来说：为代理类和被代理类各生成一个类，这个类会为代理类或被代理类的方法分配一个index(int类型)；这个index当做一个参数，FastClass就可以直接定位要调用的方法并直接进行调用，省去了反射调用，所以效率要比JDK代理通过反射调用高。

FastClass类的解析

反编译看一下FastClass类：

public int getIndex(Signature signature)
{
    String s = signature.toString();
    s;
    s.hashCode();
    JVM INSTR lookupswitch 11: default 223

        goto _L1 _L2 _L3 _L4 _L5 _L6 _L7 _L8 _L9 _L10 _L11 _L12

        ...

        JVM INSTR pop ;
    return -1;
}

//根据index直接定位执行方法
public Object invoke(int i, Object obj, Object aobj[])
    throws InvocationTargetException
{
    (Customer)obj;
    i;
    JVM INSTR tableswitch 0 10: default 161

        goto _L1 _L2 _L3 _L4 _L5 _L6 _L7 _L8 _L9 _L10 _L11 _L12
 _L2:
        findLove();
        return null;
_L3:
        buyInsure();
        return null;
_L4:
    ...
        
    InvocationTargetException();
    throw ;
    _L1:
    throw new IllegalArgumentException("Cannot find matching method/constructor");
}

FastClass并不是跟代理一起生成的，而是在第一次执行MethodProxy的invoke()或invokeSuper()方法时生成的，并放在缓存中。

//MethodProxy的invoke()或invokeSuper()方法都调用了init()方法
private void init() {
    if (fastClassInfo == null) {
        synchronized (initLock) {
            if (fastClassInfo == null) {
                CreateInfo ci = createInfo;
                FastClassInfo fci = new FastClassInfo();
                //如果在缓存中就取出，没有就在缓存中生成新的FastClass
                fci.f1 = helper(ci, ci.c1);
                fci.f2 = helper(ci, ci.c2);
                //获取方法的index
                fci.i1 = fci.f1.getIndex(sig1);
                fci.i2 = fci.f2.getIndex(sig2);
                fastClassInfo = fci;
            }
        }
    }
}

CGLib和JDK动态代理对比

(1) JDK动态代理实现了被代理对象的接口，CGLib代理继承了被代理对象。
(2) JDK动态代理和CGLib代理都在运行期生成字节码，JDK动态代理直接写Class字节码，CGLib代理使用ASM框架写Class字节码，
CGLib代理实现更复杂，生成代理类比JDK动态代理效率低。
(3) JDK动态代理调用代理方法是通过反射机制调用的，CGLib代理是通过FastClass机制直接调用方法的，CGLib代理的执行效率更高。

静态代理和动态代理的本质区别

(1) 静态代理只能通过手动完成代理操作，如果被代理类增加了新的方法，代理类需要同步增加，违背开闭原则。
(2) 动态代理采用在运行时动态生成代码的方法，取消了对被代理类的限制，遵循开闭原则。
(3) 若动态代理要对目标类的增强进行扩展，结合策略模式，只需要增加策略类即可完成，无须修改代码。

代理模式的优缺点

优点：
(1) 代理模式能将代理对象与真实被调用目标对象分离。
(2) 在一定程度上降低系统的耦合性，扩展性好。
(3) 可以起到保护目标对象的作用。
(4) 可以增强目标对象的功能。
缺点：
(1) 代理模式会造成系统设计中类的数量增加。
(2) 在客户端和目标对象中增加一个代理对象，会导致请求处理速度变慢。
(3) 增加系统的复杂度。