设计模式之代理模式

Lewis
2022-04-15 / 0 评论 / 21 阅读 / 正在检测是否收录...
代理模式是一种结构型设计模式。结构型模式主要总结了一些类或对象组合在一起的经典结构,这些经典的结构可以解决特定应用场景的问题。结构型模式包括:代理模式、桥接模式、装饰器模式、适配器模式、门面模式、组合模式、享元模式。

代理模式的应用场景

  • 业务系统的非功能性需求开发。比如:监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦,放到代理类中统一处理,让程序员只需要关注业务方面的开发。
  • RPC、缓存中应用。RPC 框架也可以看作一种代理模式;假设我们要开发一个接口请求的缓存功能,对于某些接口请求,如果入参相同,在设定的过期时间内,直接返回缓存结果,而不用重新进行逻辑处理。

  代理模式分为 静态代理动态代理 。静态代理的代理对象,在程序编译时已经写好 Java 文件了,直接 new 一个代理对象即可。动态代理产生代理对象的时机是运行时动态生成,它没有 Java 源文件,直接生成字节码文件实例化代理对象。

静态代理的实现有两种:通过接口和通过继承。

静态代理 - 通过接口方式

类图

l1zsv7kq.png

代码实现

public interface UserService {

    public Boolean login(String username, String password);

}
UserServiceImpl
public class UserServiceImpl implements UserService {

    @Override
    public Boolean login(String username, String password) {
        return "admin".equals(username) && "admin".equals(password);
    }

}
public class UserServiceProxy implements UserService {

    private final UserService userService;

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

    @Override
    public Boolean login(String username, String password) {
        long t1 = System.nanoTime();
        System.out.println("start login");
        Boolean result = userService.login(username, password);
        System.out.println("end login");
        long t2 = System.nanoTime();
        System.out.println("time: " + (t2 - t1) + "ns");
        return result;
    }

}
public class Main {

    public static void main(String[] args) {
        UserService userService = new UserServiceProxy(new UserServiceImpl());
        Boolean result = userService.login("admin", "admin");
        System.out.println("result: " + result);
    }

}

静态代理 - 通过继承方式
类图

l1zswtsd.png

public interface UserService {

    public Boolean login(String username, String password);

}
public class UserServiceImpl implements UserService {

    @Override
    public Boolean login(String username, String password) {
        return "admin".equals(username) && "admin".equals(password);
    }

}
public class UserServiceProxy extends UserServiceImpl {

    @Override
    public Boolean login(String username, String password) {
        long t1 = System.nanoTime();
        System.out.println("start login");
        Boolean result = super.login(username, password);
        System.out.println("end login");
        long t2 = System.nanoTime();
        System.out.println("time: " + (t2 - t1) + "ns");
        return result;
    }

}
public class Main {

    public static void main(String[] args) {
        UserService userService = new UserServiceProxy();
        Boolean result = userService.login("admin", "admin");
        System.out.println("result: " + result);
    }

}

动态代理

上面的代码实现有两个问题:

  • 我们需要在代理类中,将原始类中的所有的方法,都重新实现一遍,并且为每个方法都附加相似的代码逻辑。
  • 如果要添加的附加功能的类有不止一个,我们需要针对每个类都创建一个代理类。
     这时我们就需要用到动态代理(Dynamic Proxy),就是我们不事先为每个原始类编写代理类,而是在运行的时候,动态地创建原始类对应的代理类,然后在系统中用代理类替换掉原始类。

    如何实现动态代理呢?
    Java 语言本身就已经提供了动态代理的语法(实际上,动态代理底层依赖的就是 Java 的反射语法)。

    类图
    l1zsyrh5.png

public interface UserService {

    public Boolean login(String username, String password);
public class UserServiceImpl implements UserService {

    @Override
    public Boolean login(String username, String password) {
        return "admin".equals(username) && "admin".equals(password);
    }

}
public class DynamicProxyHandler implements InvocationHandler {

    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long t1 = System.nanoTime();
        System.out.println("start " + target.getClass().getName() + ":" + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("end " + target.getClass().getName() + ":" + method.getName());
        long t2 = System.nanoTime();
        System.out.println("time: " + (t2 - t1) + "ns");
        return result;
    }

}
public class DynamicProxy {

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

}
public class Main {

    public static void main(String[] args) {
        DynamicProxy proxy = new DynamicProxy();
        UserService userService = (UserService) proxy.createProxy(new UserServiceImpl());
        Boolean result = userService.login("admin", "admin");
        System.out.println("result: " + result);
    }

}

至此,我们已经实现了基于JDK的动态代理,JDK动态代理要求要代理的类必须实现接口,如果类没有实现接口,那么你可以尝试 CGLIB,它不是JDK自带的,而是第三方类库,感兴趣可以详细了解。

1

评论 (0)

取消