设计模式-代理模式

设计模式-代理模式

代理模式(Proxy Design Pattern)在不改变原有业务代码的情况下,通过引入代理类来给原始类附加功能,一般分为静态代理和动态代理。

案例分析

如果有一个 UserServiceImpl 类,我们希望统计其中的每个方法执行耗时。

java 复制代码
public class UserServiceImpl {

    public void test() {
        IntStream.rangeClosed(1, 100).forEach(i -> {
            if (i % 10 == 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

}

我们很容易想到的就是创建一个 UserServiceImpl 的示例,在调用前后记录时间并计算差值

java 复制代码
public class Main {

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        UserServiceImpl userService = new UserServiceImpl();
        userService.test();
        long end = System.currentTimeMillis();
        System.out.println("test耗时:" + (end - start) + "ms");
    }

}

但是一方面如果方法很多,那么所有的位置都需要加上这样的代码,另一方面这些与业务无关的代码有可能未来取消或改动,如果每次变化都修改源代码,会使程序出错的可能性变大,因此我们希望不改动原始代码来实现。

基于继承的代理实现
java 复制代码
public class UserServiceImplProxy extends UserServiceImpl{

    @Override
    public void test() {
        long start = System.currentTimeMillis();
        super.test();
        long end = System.currentTimeMillis();
        System.out.println("test耗时:" + (end - start) + "ms");
    }

}

public class Main {

    public static void main(String[] args) {
        UserServiceImpl proxy = new UserServiceImplProxy();
        proxy.test();
    }

}

我们使 UserServiceImplProxy 类继承 UserServiceImpl 类,使用完全相同的接口,这样在创建对象时利用多态特性,父类对象指向子类实例,就可以在不改动原始代码的情况下增加记录接口调用时间的日志。

基于接口的代理实现

首先定义 UserService 接口及实现类 UserServiceImpl

java 复制代码
public interface UserService {

    void test();

}

public class UserServiceImpl implements UserService {

    @Override
    public void test() {
        IntStream.rangeClosed(1, 100).forEach(i -> {
            if (i % 10 == 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

}

我们创建一个新的类 UserServiceImplProxy 也实现这个接口

java 复制代码
public class UserServiceImplProxy implements UserService {

    private UserServiceImpl userService;

    public UserServiceImplProxy(UserServiceImpl userService) {
        this.userService = userService;
    }

    @Override
    public void test() {
        long start = System.currentTimeMillis();
        userService.test();
        long end = System.currentTimeMillis();
        System.out.println("test耗时:" + (end - start) + "ms");
    }

}

在 Proxy 代理类中,通过注入或构造器等把默认实现类传入,这样也可以达到我们的目的。

动态代理

在上述的两种实现中,不难看出这些都需要我们创建一些新的类,当类的数量很多时这是个很大的工作量,而且会影响编译和启动速度,动态代理可以在运行的过程中动态生成这样的类。

java 复制代码
public interface UserService {
    void test();
}

public class UserServiceImpl implements UserService {
    @Override
    public void test() {
        IntStream.rangeClosed(1, 100).forEach(i -> {
            if (i % 10 == 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

以下是生成动态代理对象的代码:

java 复制代码
public class DynamicProxy {

    public Object createProxy(Object proxiedObject) {
        Class<?>[] interfaces = proxiedObject.getClass().getInterfaces();
        DynamicProxyHandler handler = new DynamicProxyHandler(proxiedObject);
        return Proxy.newProxyInstance(proxiedObject.getClass().getClassLoader(), interfaces, handler);
    }

    private class DynamicProxyHandler implements InvocationHandler {

        private Object proxiedObject;

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

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            long startTimestamp = System.currentTimeMillis();
            Object result = method.invoke(proxiedObject, args);
            long endTimeStamp = System.currentTimeMillis();
            long responseTime = endTimeStamp - startTimestamp;
            String apiName = proxiedObject.getClass().getName() + ":" + method.getName();
            System.out.println("执行:" + apiName + "耗时:" + responseTime + "ms");
            return result;
        }
    }

}

测试代码:

java 复制代码
public class Main {

    public static void main(String[] args) {
        DynamicProxy serviceImplProxy = new DynamicProxy();
        UserService userService = (UserService)serviceImplProxy.createProxy(new UserServiceImpl());
        userService.test();
    }

}

动态代理其实就是在运行过程中动态地创建原始类对应的代理类,然后在系统中用代理类替换掉原始类。

我们常说 Spring AOP 就是基于动态代理实现的,同时 Spring 的事务中也用到了动态代理,那么看完上述的实现过程自然也知道了为什么 private 修饰的方法事务无法失效了~

相关推荐
YA3336 小时前
java设计模式八、组合模式
java·设计模式·组合模式
Yeniden11 小时前
设计模式>原型模式大白话讲解:就像复印机,拿个原件一复印,就得到一模一样的新东西
java·设计模式·原型模式·1024程序员节
成钰13 小时前
设计模式简介
设计模式
成钰14 小时前
设计模式之抽象工厂模式:最复杂的工厂模式变种
java·设计模式·抽象工厂模式
Asort15 小时前
JavaScript设计模式(二十三)——访问者模式:优雅地扩展对象结构
前端·javascript·设计模式
xiaoye370816 小时前
23种设计模式之策略模式
设计模式·策略模式
数据知道17 小时前
Go语言设计模式:建造者模式详解
设计模式·golang·建造者模式
崎岖Qiu17 小时前
【设计模式笔记11】:简单工厂模式优缺分析
java·笔记·设计模式·简单工厂模式
你的人类朋友1 天前
设计模式有哪几类?
前端·后端·设计模式