软件设计模式(五)：代理模式

前言

代理模式是软件设计模式的重中之重，代理模式在实际应用比较多，比如Spring框架中的AOP。在这篇文章中荔枝将会梳理有关静态代理、动态代理的区别以及两种实现动态代理模式的方式。希望能对有需要的小伙伴有帮助~~~

文章目录

一、静态代理

静态代理其实比较容易理解，就是我们在扩充一个类方法的功能的时候不想改动原来类的结构，就可以使用代理的方式来实现，这种方式也类似装饰器模式，代理类还要求和委托类有共同的父类或父接口。

我们简单来看看一段demo：

在这段demo中，定义了一个Movable接口并被两个代理类和一个被代理类实现，在测试类中我们执行代理类和实现类中的move()方法。首先会调用TankLogProxy中的move并传入一个TankTimeProxy类对象，再调用TankTimeProxy.move()，之后会触发调用被代理类的move()方法，之后才会执行完之前代理类中剩下的代理方法。

package com.crj.proxy;

import java.util.Random;
/**
 * 静态代理
 */
public class Tank implements Movable {

    /**
     * 模拟坦克移动了一段儿时间
     */
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {

        new TankLogProxy(
                new TankTimeProxy(
                        new Tank()
                )
        ).move();
    }
}

class TankTimeProxy implements Movable {
    Movable m;

    public TankTimeProxy(Movable m) {
        this.m = m;
    }

    @Override
    public void move() {
        long start = System.currentTimeMillis();
        m.move();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

class TankLogProxy implements Movable {
    Movable m;

    public TankLogProxy(Movable m) {
        this.m = m;
    }

    @Override
    public void move() {
        System.out.println("start moving...");
        m.move();
        long end = System.currentTimeMillis();
        System.out.println("stopped!");
    }
}

interface Movable {
    void move();
}

这其实就是静态代理的过程，大家其实可以看到代理类的功能是我们提前写死的，对于不同类型的代理就需要不同的代理类了，这样可能会需要很多很多的代理类。所以我们需要通过一种方式来实现代理类的动态生成。

二、动态代理

在上文中荔枝提及分离代理行为和代理对象的需求，实现代理类能够代理不同类型的对象，这时候就需要借助动态代理的方式。Java中实现动态代理有两种方式：基于JDK反射机制实现动态代理、借助cglib。

2.1 基于反射实现动态代理

Java JDK实现动态代理的过程我们可以通过这么一张图来表示，在java.lang.reflect中其实提供了一个Proxy类，我们可以借助该类的newInstance()方法实现动态代理。

我们需要向Proxy.newInstance()方法传入三个参数：类加载对象、接口类和InvocationHandler调用处理对象。Java反射会默认调用InvocationHandler对象中的invoke()方法实现动态代理。

具体实现动态代理的实例demo如下：

package com.crj.proxy;


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Random;

public class Tank implements Movable {

    /**
     * 模拟坦克移动了一段儿时间
     */
    @Override
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Tank tank = new Tank();

        //reflection 通过二进制字节码分析类的属性和方法

        Movable m = (Movable)Proxy.newProxyInstance(Tank.class.getClassLoader(),
                new Class[]{Movable.class}, //tank.class.getInterfaces()
                new LogHander(tank)
        );

        m.move();
    }
}

class LogHander implements InvocationHandler {

    Tank tank;

    public LogHander(Tank tank) {
        this.tank = tank;
    }
    //getClass.getMethods[]
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("method " + method.getName() + " start..");
        Object o = method.invoke(tank, args);
        System.out.println("method " + method.getName() + " end!");
        return o;
    }
}



interface Movable {
    void move();
}

Java JDK反射机制实现动态代理是基于asm类来实现的，该类主要是通过直接修改字节码文件在类加载后直接将代理方法注入字节码文件中，该机制要求被代理类必须实现接口，这也是这种方法实现动态代理的缺点。

2.2 基于cglib实现动态代理

首先我们需要导入cglib依赖，在项目pom.xml文件中配置

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.2.12</version>
        </dependency>

该方法在Java中提供了一个继承自AbstractClassGenerator类的Enhancer类，在使用动态代理之前必须获得一个Enhancer对象，代理类必须继承一个MethodInterceptor接口并重写intercept方法。在测试类中我们需要设置好被代理对象的父类以及将代理类对象传入setCallback()中，最后调用Enhancer对象的create()方法即可在被代理对象执行方法时实现动态代理。下面给出一个实例demo：

package com.crj.cglib;

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

import java.lang.reflect.Method;
import java.util.Random;

/**
 * CGLIB实现动态代理不需要接口
 */
public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Tank.class);
        enhancer.setCallback(new TimeMethodInterceptor());
        Tank tank = (Tank)enhancer.create();
        tank.move();
    }
}

class TimeMethodInterceptor implements MethodInterceptor {

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

        System.out.println(o.getClass().getSuperclass().getName());
        System.out.println("before");
        Object result = null;
        result = methodProxy.invokeSuper(o, objects);
        System.out.println("after");
        return result;
    }
}

class Tank {
    public void move() {
        System.out.println("Tank moving claclacla...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Spring框架中的面向切面编程也是Java动态代理的一部分。

总结

Proxy模式荔枝已经梳理完成，到现在为止软件设计模式中的最常见的模式和最重点的几个模式已经梳理完成了，收获满满（至少水了几篇文章哈哈哈哈）。总之继续加油，争取明天结束软件设计模式的学习~~~

今朝已然成为过去，明日依然向往未来！我是小荔枝，在技术成长的路上与你相伴，码文不易，麻烦举起小爪爪点个赞吧哈哈哈~~~ 比心心♥~~~