代理模式是一种结构型设计模式。结构型模式主要总结了一些类或对象组合在一起的经典结构，这些经典的结构可以解决特定应用场景的问题。结构型模式包括：代理模式、桥接模式、装饰器模式、适配器模式、门面模式、组合模式、享元模式。
代理模式的应用场景
- 业务系统的非功能性需求开发。比如：监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦，放到代理类中统一处理，让程序员只需要关注业务方面的开发。
- RPC、缓存中应用。RPC 框架也可以看作一种代理模式；假设我们要开发一个接口请求的缓存功能，对于某些接口请求，如果入参相同，在设定的过期时间内，直接返回缓存结果，而不用重新进行逻辑处理。
代理模式分为静态代理和动态代理。静态代理的代理对象，在程序编译时已经写好 Java 文件了，直接 new 一个代理对象即可。动态代理产生代理对象的时机是运行时动态生成，它没有 Java 源文件，直接生成字节码文件实例化代理对象。
静态代理的实现有两种：通过接口和通过继承。
静态代理 - 通过接口方式
类图
代码实现
UserService
1
2
3
4
5
| public interface UserService {
public Boolean login(String username, String password);
}
|
UserServiceImpl
1
2
3
4
5
6
7
8
| public class UserServiceImpl implements UserService {
@Override
public Boolean login(String username, String password) {
return "admin".equals(username) && "admin".equals(password);
}
}
|
UserServiceProxy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| 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;
}
}
|
Main
1
2
3
4
5
6
7
8
9
| 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);
}
}
|
静态代理 - 通过继承方式
类图
代码实现
UserService
1
2
3
4
5
| public interface UserService {
public Boolean login(String username, String password);
}
|
UserServiceImpl
1
2
3
4
5
6
7
8
| public class UserServiceImpl implements UserService {
@Override
public Boolean login(String username, String password) {
return "admin".equals(username) && "admin".equals(password);
}
}
|
UserServiceProxy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| 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;
}
}
|
Main
1
2
3
4
5
6
7
8
9
| 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 的反射语法）。
类图
UserService
1
2
3
4
5
| public interface UserService {
public Boolean login(String username, String password);
}
|
UserServiceImpl
1
2
3
4
5
6
7
8
| public class UserServiceImpl implements UserService {
@Override
public Boolean login(String username, String password) {
return "admin".equals(username) && "admin".equals(password);
}
}
|
DynamicProxyHandler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| 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;
}
}
|
DynamicProxy
1
2
3
4
5
6
7
8
9
10
| 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);
}
}
|
Main
1
2
3
4
5
6
7
8
9
10
| 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 自带的，而是第三方类库，感兴趣可以详细了解。
