【版权声明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权）
https://developer.aliyun.com/article/1631770
出自【进步*于辰的博客】参考笔记一，P83。
代理模式分为静态代理和动态代理，比较简单，直接上示例，一目了然。为降低大家阅读成本，所有示例的打印结果都相同：
打开事务
转账金额：100
关闭事务
1
大家可自行cp测试。
静态代理
1：面向接口、目标类与代理类实现于同一接口。
// 目标类和代理类的公共接口
interface IService {
int transfer(int account);
}
// 目标类
class Target implements IService {
public int transfer(int account) {
System.out.println("转账金额：" + account);
return 1;
}
}
// 代理类
class Proxy implements IService {
private Target tar;
public Proxy(Target tar) {
this.tar = tar;
}
public int transfer(int account) {
System.out.println("打开事务");
int x = tar.transfer(account);
System.out.println("关闭事务");
return x;
}
}
class Test {
public static void main(String[] args) {
Proxy proxy = new Proxy(new Target());
int x = proxy.transfer(100);
System.out.println(x);
}
}
2：面向继承、代理类继承于目标类。
class Target {
public int transfer(int account) {
System.out.println("转账金额：" + account);
return 1;
}
}
class Proxy extends Target {
public int transfer(int account) {
System.out.println("打开事务");
int x = super.transfer(account);
System.out.println("关闭事务");
return x;
}
}
class Test {
public static void main(String[] args) {
Proxy proxy = new Proxy();
int x = proxy.transfer(100);
System.out.println(x);
}
}
动态代理
静态代理需要手动创建代理类，冗余。换个思路，反射可以根据Class信息创建实例，故可以通过反射为目标对象创建代理对象，则无需创建代理类，这就是“动态代理”。
JDK动态代理
面向接口，是JDK自带的。
interface IService {
int transfer(int account);
}
class Target implements IService {
public int transfer(int account) {
System.out.println("转账金额：" + account);
return 1;
}
}
class Test {
public static void main(String[] args) {
Target tar = new Target();
/**
* 通过 Proxy.newProxyInstance() 创建代理对象。
* 第一个参数是目标对象的类加载器，指定为哪个目标对象创建代理对象；
* 第二个参数是目标对象实现的接口，指定目标对象和代理对象的公共接口；
* 第三个参数是拦截器对象，指定用哪个拦截器来创建代理对象，需要实现 InvocationHandler 接口。
*/
// 由于 proxyInstance 是通过反射创建，存储于JVM，匿名（文末说明），故上转为 IService
IService proxyInstance = (IService) Proxy.newProxyInstance(tar.getClass().getClassLoader(),
tar.getClass().getInterfaces(),
new InvocationHandler() {
/**
* 代理（调用 transfer()）时执行的方法
* @param proxy 代理对象，即 proxyInstance，暂不知如何使用
* @param method 目标对象的 Method 的 class 对象
* @param args 目标对象的 Method 的形参数组
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("打开事务");
// invoke() 是反射中 Method 对象执行时调用的方法，故动态代理是通过反射调用目标对象被代理的方法
Object result = method.invoke(tar, args);
System.out.println("关闭事务");
return result;
}
});
int x = proxyInstance.transfer(100);
System.out.println(x);
}
}
可以使用Lambda表达式省略new InvocationHandler()。
Cglib动态代理
面向继承，基于Spring。
class Target {
public int transfer(int account) {
System.out.println("转账金额：" + account);
return 1;
}
}
// 动态代理类（拦截器）
class DynamicProxy implements MethodInterceptor {
private Object tar;
public DynamicProxy(Object tar) {
this.tar = tar;
}
public Object createProxy() {
Enhancer proxy = new Enhancer();// Enhancer 类是一种类生成器
proxy.setCallback(this);// 设置拦截器，即自身
proxy.setSuperclass(tar.getClass());// 设置父类，指定为哪个目标对象创建代理对象
return proxy.create();// 创建代理对象
}
/**
* 代理（调用 transfer()）时执行的方法
* @param proxy 代理对象，即 proxyInstance，暂不知如何使用
* @param method 目标对象的 Method 的 class对象
* @param args 目标对象的 Method 的参数数组
* @param methodProxy 代理方法，即 Target.transfer()，暂不知如何使用
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("打开事务");
Object result = method.invoke(tar, args);
System.out.println("关闭事务");
return result;
}
}
class Test {
public static void main(String[] args) {
Target target = new Target();
Target proxyInstance = (Target) new DynamicProxy(target).createProxy();
int x = proxyInstance.transfer(100);
System.out.println(x);
}
}
同样可以使用Lambda表达式优化，不过代理对象的创建（proxy.create()）需要对Enhancer 类的属性进行一些设置，故进行了封装。
注意：两种动态代理都可以拦截所有方法，如：toString()、hashcode()。但不能拦截由final修饰的方法，如：getClass()。
扩展
JDK动态代理的核心是“面向接口”，实际上并不需要目标对象（公共接口的实现），也就是这样：
interface IService {
int transfer(int account);
}
class Test {
public static void main(String[] argx) {
Class z1 = IService.class;
IService proxyInstance = (IService) Proxy.newProxyInstance(z1.getClassLoader(),
new Class[] {
z1 },
(proxy, method, args) -> {
System.out.println("打开事务");
System.out.println("关闭事务");
return 1;
});
int x = proxyInstance.transfer(100);
System.out.println(x);
}
}
没有目标对象，还是代理模式吗？又有什么意义？
Mybatis为Mapper接口创建代理对象使用的就是这种方式，不需要为Mapper接口创建实现类，我寻得一篇文章 → 一文搞懂Java动态代理：为什么Mybatis Mapper不需要实现类？（转发），那位博主讲述得狠详细，大家自行转站学习，我在此就不赘述了。
最后
本文中的例子是为了阐述静态代理和动态代理的实现思想、方便大家理解而简单举出的，不一定有实用性，仅是抛砖引玉。
本文完结。
