Java进阶之代理
Java中内置了java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来支持动态代理。
看之前我们先明白代理是什么？
代理就是被代理方授权给第三方来做被代理方的事情，这里的第三代理方就是被代理方的代理，哈哈哈。
代理方可以控制被代理方的访问，比如打官司，你要有事情，找我的代理律师，不要直接找我，但是代理律师和你谈的还是我的事情。
代理是一种设计模式，它为其他对象提供一种代理，以控制对这个对象的访问。
代码示例一下:
首先定义一个接口，接口可以为它的子类定义一种规范。
public interface IService {
void doSomething(int num);
}
然后实现类，这个类就是具体的业务操作，也就是我的事情
public class RealService implements IService {
public void doSomething(int num) {
System.out.println("解决我piao的事情,喜提【"+num+"】年缝纫机");
}
}
不用代理的情况下，我们就是直接被处理:
RealService me = new RealService();
me.doSomething(6);
这样的话，直接就上山干6年，么办法。
你肯定不想吧，你找个代理律师，这个piao的事情不直接找我RealService，我一句话不说，有事找我法务。
/**
* 建一个法务，代理律师，我可继承了IService，我也可以doSomething(num)
*/
public class ProxyService implements IService {
private IService realService;
public ProxyService(IService realService) {
this.realService = realService;
}
public void doSomething(int num) {
System.out.println("我是被代理方的代理律师，现在开始解决当事人piao问题");
System.out.println("哎，我的当事人是不满十八周岁,且初次违法，恳请法律减轻处罚! 减1年:"+num--);
System.out.println("哎，我的当事人对于自己的违法行为表现出深刻的悔过态度，承诺不再犯类似错误，恳请法律减轻处罚! 减1年:"+num--);
realService.doSomething(num);
System.out.println("事情解决，收取被代理方当事人报酬22万");
}
}
我们看通过上述代理类来解决这个事情:
// 新建业务类对象
IService realService = new RealService();
// 新建代理类对象，将业务类对象交给代理类代理
IService proxyService = new ProxyService(realService);
// 通过代理类去调用业务类的方法
proxyService.doSomething();
最后，本来要是直接面向业务类本身去doSomething(6)的话，体验卡有6年，但是使用代理后，减掉了2年。当然事后代理类还收取了报酬。
可以看到调用方法的前后都可以加一些业务类本身没有的骚操作，以达到业务类本身所不具有的功能。
以上是一个静态代理，静态代理在编译时就已经确定代理类和原始类的关系。通常，代理类和原始类实现相同的接口。代理类持有原始类的实例，并在其方法中调用原始类的方法，这样可以在调用前后添加额外的逻辑。
静态代理是有缺点的:
代码冗余：每个代理类都需要手动编写，如果接口方法很多，代理类会变得非常庞大。
灵活性差：一旦接口增加方法，所有代理类都需要修改，比如上面如果不只是piao了，还是强制piao，那就需要增加更多的骚操作方法来处理。
那么有没有一种更好的解决方案呢？
有，那就是动态代理！
动态代理中的代理类并不要求在编译期就确定，而且此时可能也不知道要代理哪些，可以在运行期动态生成，从而实现对目标对象的代理功能。
听起来好熟悉，是不是反射的时候就是这么说的: 编译期不确定，在运行期动态去操作类的实例，没错，Java动态代理底层也是用的反射机制。
使用Java动态代理:
要用java.lang.reflect.InvocationHandler接口来代替代理类继承的接口，这个接口只有一个invoke方法来支持传入要代理的method方法，并且使用反射去调用它。
要使用java.lang.reflect.Proxy类的newProxyInstance方法来创建代理类，三个参数分别是被代理业务类加载器、被代理业务类接口列表、代理类本身。
这样Java底层机制就会通过反射来完成代理。
class ProxyDong implements InvocationHandler {
private Object realService;
public Object proxy(Object obj) {
this.realService = obj;
return Proxy.newProxyInstance(
obj.getClass().getClassLoader(), // 被代理业务类加载器
obj.getClass().getInterfaces(), // 被代理业务类接口列表
this // 代理类本身
);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
int num = (int) args[0];
System.out.println("我是被代理方的代理律师，现在开始解决当事人piao问题，当前体验卡年数:"+num);
num--;
System.out.println("哎，我的当事人是不满十八周岁,且初次违法，恳请法律减轻处罚! 减1年后年数:"+num);
num--;
System.out.println("哎，我的当事人对于自己的违法行为表现出深刻的悔过态度，承诺不再犯类似错误，恳请法律减轻处罚! 减1年后年数:"+num);
method.invoke(this.realService, num);
System.out.println("事情解决，收取被代理方当事人报酬22万");
return null;
}
}
观察发现不管是动态代理还是静态代理，肯定是要让代理去持有被代理的业务类。
使用动态代理解决:
RealService me = new RealService();
IService proxyService = (IService) new ProxyDong().proxy(me);
proxyService.doSomething(6);
这就是Java的动态代理，动态代理的优势:
无需手动编写代理类：动态代理自动生成代理类，减少了代码量。
高度灵活：代理类可以在运行时动态创建，不受接口方法数量限制。
也就是说，真实的被代理的业务类发生改变了，比如我们业务类中新加一个qiang()方法，动态代理类也不用修改，直接使用的时候继续调用就可以执行那一套减年套路:
proxyService.qinag(10);
这就是动态代理的强大之处，它能够自动适应接口的变化，无需手动更新代理类。
这里的减年骚操作只是其中的一种，我们还有很多的应用场景:
访问控制：如安全代理确保只有特定用户可以访问敏感操作。
日志记录：记录方法调用的时间和参数，便于监控和调试。
事务管理：在方法调用前后开启和提交事务。
性能优化：如缓存代理缓存结果，减少数据库访问次数。
等等...web开发中的spring框架中的拦截器（Interceptors）、面向切面编程（AOP）等等都是代理模式。
END
