定义
代理模式(Proxy)：为其它对象提供一种代理以控制对这个对象的访问。
类图
实现要点
-
代理类实现被代理类实现的相同接口，来保证代理类和被代理类功能一致
-
代理类保存一个被代理类的引用，实际调用改引用来实现接口
Java示例
接口：
public interface UserService {
boolean sign(String name);
}
被代理类：
public class UserServiceImpl implements UserService {
@Override
public boolean sign(String name) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + " signin");
return true;
}
}
代理类：
public class StaticProxy implements UserService {
private UserServiceImpl userServiceImpl;
public StaticProxy(UserServiceImpl userServiceImpl) {
this.userServiceImpl = userServiceImpl;
}
@Override
public boolean sign(String name) {
System.out.println("StaticProxy=>sign start");
long start = System.currentTimeMillis();
boolean result = userServiceImpl.sign(name);
System.out.println("StaticProxy=>sign end, cost " + (System.currentTimeMillis() - start) + "ms");
return result;
}
public static void main(String[] args) {
UserServiceImpl userServiceImpl = new UserServiceImpl();
StaticProxy proxy = new StaticProxy(userServiceImpl);
proxy.sign("cdfive");
}
}
输出结果：
StaticProxy=>sign start
cdfive signin
StaticProxy=>sign end, cost 200ms
这里的StaticProxy类实现了被代理类UserServiceImpl相关的接口UserService，通过一个变量保存了被代理类的引用UserServiceImpl；
接口实现里，调用UserServiceImpl的sign方法，并在调用前后打印了日志以及耗时情况。
这种用一个代理类对业务接口的实现类进行包装，称之为静态代理。
优点：简单直观
缺点：如果其他业务接口也需要类似处理，比如打印日志及耗时，按这种方式则需要每个接口类添加一个代理类，并且多个代理类存在代码重复。
JDK动态代理
JDK动态代理是代理类不是编码阶段创建，而是在程序调用时，JVM根据传进来的业务实现类对象以及方法名，动态地创建了一个代理类的class文件并被字节码引擎执行，然后通过该代理类对象进行方法调用。
实现方式：利用JDK提供的java.lang.reflect包下的相关类实现，包括：InvocationHandler、Proxy、Method。
示例1：
public class JDKDynamicProxy {
public static void main(String[] args) {
UserService userService = new UserServiceImpl();
UserService proxy = (UserService) Proxy.newProxyInstance(UserService.class.getClassLoader(), new Class<?>[]{UserService.class},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("JDKDynamicProxy=>" + method.getName() + " start");
long start = System.currentTimeMillis();
Object result = method.invoke(userService, args);
System.out.println("JDKDynamicProxy=>" + method.getName() + " end, cost " + (System.currentTimeMillis() - start) + "ms");
return result;
}
});
proxy.sign("cdfive");
}
}
通过Proxy类的静态方法：public static Object Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)方法创建代理对象；
其中第3个参数是一个接口：
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}
通过Object result = method.invoke(userService, args);来调用实际对象方法，注意invoke的第1个参数为实际被代理类的对象。
示例2：
public class JDKDynamicProxyFactory implements InvocationHandler {
private Object target;
public <T> T bind(Object target) {
this.target = target;
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("JDKDynamicProxy=>" + method.getName() + " start");
long start = System.currentTimeMillis();
Object result = method.invoke(target, args);
System.out.println("JDKDynamicProxy=>" + method.getName() + " end, cost " + (System.currentTimeMillis() - start) + "ms");
return result;
}
}
public class JDKDynamicProxy2 {
public static void main(String[] args) {
UserServiceImpl userServiceImpl = new UserServiceImpl();
JDKDynamicProxyFactory proxyFactory = new JDKDynamicProxyFactory();
UserService userService = proxyFactory.bind(userServiceImpl);
userService.sign("cdfive");
}
}
示例2对做了一个小优化：
封装了一个通用的JDKDynamicProxyFactory类，它实现InvocationHandler 接口；
保存了target引用，通过定义的bind方法返回实际被代理对象；// 注：这里bind方法的返回值没有定义为Object，而是通过泛型<T> T定义，这样避免了使用时进行强制转换。
实现的invoke方法逻辑不变。
通过这种方式支持不同接口对象代理，并且消除了使用时的重复代码。
比如另一个业务接口实现XxxServiceImpl，也可以用proxyFactory.bind(xxxServiceImpl)绑定来进行代理。