代理模式(Java)

代理模式属于结构型设计模式，它主要是在不改变原始类代码的情况下，通过引入代理类给原始类附加功能。

静态代理

记录代码运行时间

/*
 * 记录代码运行时间
 */ 
class Logger {
    public static void record(long startTime, long endTime){
        System.out.println("共用时"+ (endTime - startTime) + "毫秒");
    }
}

interface IUserService {
    void add();
}

class UserServiceImpl implements IUserService {

    @Override
    public void add() {
        try {
            //休眠一下，模拟正常操作
            Thread.sleep((long) (Math.random() * 1000));
            System.out.println("用户添加操作执行成功");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class UserServiceProxy implements IUserService {

    private IUserService userService;

    public UserServiceProxy(IUserService userService) {
        this.userService = userService;
    }

    @Override
    public void add() {
        long startTime = System.currentTimeMillis();
        userService.add();
        long endTime = System.currentTimeMillis();
        Logger.record(startTime, endTime);
    }
}

class UserServiceProxyTest {
    public static void main(String[] args) {
        IUserService userService = new UserServiceProxy(new UserServiceImpl());
        userService.add();
    }
}

输出: 
用户添加操作执行成功
共用时601毫秒

静态代理比较简单，但是存在一个问题，如果我们有100个类都要记录运行时间，那就需要创建100个代理类，维护成本太高，并且每个代理类得代码逻辑都是一样的。那该怎么解决找个问题呢？我们可以使用动态代理来解决，下面先看下Java提供的动态代理的用法。

JDK动态代理

/*
 * 记录代码运行时间
 */
class Logger implements InvocationHandler {

    private Object proxyObject;

    /*
     * 动态创建代理类
     */ 
    public Object createProxy(Object proxyObject){
        this.proxyObject = proxyObject;
        Class clazz = proxyObject.getClass();
        return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object obj = method.invoke(proxyObject, args);
        long endTime = System.currentTimeMillis();
        System.out.println("共用时"+ (endTime - startTime) + "毫秒");
        return obj;
    }
}

interface IUserService {
    void add();
}

class UserServiceImpl implements IUserService {

    @Override
    public void add() {
        try {
            //休眠一下，模拟正常操作
            Thread.sleep((long) (Math.random() * 1000));
            System.out.println("用户添加操作执行成功");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


class UserServiceProxyTest {
    public static void main(String[] args) {
        Logger logger = new Logger();
        UserServiceImpl userService = new UserServiceImpl();
        IUserService userServiceProxy = (IUserService)logger.createProxy(userService);
        userServiceProxy.add();
    }
}
输出:
用户添加操作执行成功
共用时166毫秒

使用JDK动态代理我们就不需要再为每个需要记录运行时间的类创建代理类，Java会动态为我们创建对应的代理类。