什么叫代理模式？

代理模式是在不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类增加功能。代理对象在在原始类和代理类之间起到了中介作用。

代理模式的目的：

• 保护原始类；
• 增强原始类；

从设计原则来说是开闭原则，对修改关闭，对扩展开放。

我们在生活中的经常遇到这样的场景如：房屋中介、猎头等。

中介保护了我们的隐私，我们除了提供基本的房屋买卖、找工作等需求，中介会通过自己的资源、渠道等帮我们实现，我们本来的意愿并没有改变。

静态代理

了解下yxkong要通过贝壳去买房的过程。

买房的流程

/** * 买房要求 * @author yxkong * @create 2021/5/13 * @since 1.0.0 */ public interface BuyHouse { /** * 买房要求 * @param totalPrice 总价 */ public void buy(double totalPrice); }

yxkong买房实现，目标类（原始类）

public class YxkongBuyHouse implements BuyHouse { @Override public void buy(double totalPrice) { System.out.println(String.format("yxkong买了100平，三室总价为%s的房子",totalPrice)); } }

yxkong通过中介ke买房子的代理实现

public class KeBuyHouseProxy implements BuyHouse { private BuyHouse buyHouse; public KeBuyHouseProxy(BuyHouse buyHouse) { this.buyHouse = buyHouse; } @Override public void buy(double totalPrice) { System.out.println("ke先了解购房者的需求"); System.out.println("ke确认购买房屋"); System.out.println("ke帮忙砍价"); //最终执行还是yxkong自己买房，只不过在yxkong买房的基础上增加了一些其他功能 buyHouse.buy(totalPrice); System.out.println("ke收取买家手续费"); System.out.println("ke收取卖家手续费"); } }

这上面的代码实现就是一个静态代理的实现。静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类。

动态代理

那我们能不能不一个个的创建代理类来实现代理呢？答案肯定是可以的

JDK动态代理

jdk给我们提供了一套机制

原始类，还是原来的，我们用jdk实现动态代理

public class JDKBuyHouseHandler implements InvocationHandler { private Object targetObj; public JDKBuyHouseHandler(Object targetObj) { this.targetObj = targetObj; } private void beforeBuy(){ System.out.println("中介先了解购房者的需求"); System.out.println("中介确认购买房屋"); System.out.println("中介帮忙砍价"); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { beforeBuy(); Object obj = method.invoke(this.targetObj,args); afterBuy(); return obj; } private void afterBuy(){ System.out.println("中介收取买家手续费"); System.out.println("中介收取卖家手续费"); } } // 代理工厂，只要同一类型的事，我们只要一套流程机制 public class ProxyFactory { public Object createProxy(Object targetObj) { //1，获得目标对象的所有接口 Class[] interfaces = targetObj.getClass().getInterfaces(); //2，通过jdk的InvocationHandler定义代理的扩展模板handler处理器 JDKBuyHouseHandler handler = new JDKBuyHouseHandler(targetObj); //3,通过Proxy 利用目标对象的classLoader创建代理实例 return Proxy.newProxyInstance(targetObj.getClass().getClassLoader(), interfaces, handler); } public static void main(String[] args) { ProxyFactory proxyFactory = new ProxyFactory(); //中介可以代理鱼翔空，也可以代理别人的买房 BuyHouse buyHouse = (BuyHouse)proxyFactory.createProxy(new YxkongBuyHouse()); buyHouse.buy(1000000); } }输出结果 中介先了解购房者的需求 中介确认购买房屋 中介帮忙砍价 yxkong买了100平，三室总价为1000000.0的房子 中介收取买家手续费 中介收取卖家手续费

JDK Proxy采用字节码重组，重新生成新的对象来替代原始的对象以达到动态代理的目的，JDK Proxy生成对象的步骤如下：

• 通过实现InvocationHandler接口定义自己的InvocationHandler；
• 通过Proxy.newProxyInstance 获得动态代理对象（直接绕过了）

也可以通过Proxy.getProxyClass生成代理类，然后通过反射的机制获取实例和执行方法。

看下代码

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) { //InvocationHandler 必须存在 Objects.requireNonNull(h); // final Class<?>[] intfs = interfaces.clone(); /* * 创建代理类 */ Class<?> cl = getProxyClass0(loader, intfs); //获取代理类的构造器 final Constructor<?> cons = cl.getConstructor(constructorParams); //实例化 return cons.newInstance(new Object[]{h}); }

感兴趣的可以深入的翻一翻源码。

CGLIB 动态代理

不知大家发现了没，上面不管是静态代理还是动态代理，都需要目标对象必须实现接口。但是现实情况并不是所有的目标对象都是通过面向接口编程的。

这时，我们可以使用CGLIB，使用目标对象子类的方式实现代理。

CGLIB核心类

net.sf.cglib.proxy.Enhancer – 主要的增强类 net.sf.cglib.proxy.MethodInterceptor – 主要的方法拦截类，它是Callback接口的子接口，需要用户实现 net.sf.cglib.proxy.MethodProxy – JDK的java.lang.reflect.Method类的代理类，可以方便的实现对源对象方法的调用,如使用： Object o = methodProxy.invokeSuper(proxy, args);//虽然第一个参数是被代理对象，也不会出现死循环的问题。 net.sf.cglib.proxy.MethodInterceptor接口是最通用的回调（callback）类型，它经常被基于代理的AOP用来实现拦截（intercept）方法的调用。这个接口只定义了一个方法 public Object intercept(Object object, java.lang.reflect.Method method, Object[] args, MethodProxy proxy) throws Throwable; 第一个参数是代理对像，第二和第三个参数分别是拦截的方法和方法的参数。原来的方法可能通过使用java.lang.reflect.Method对象的一般反射调用，或者使用 net.sf.cglib.proxy.MethodProxy对象调用。net.sf.cglib.proxy.MethodProxy通常被首选使用，因为它更快。

还以买房为例

public class CglibBuyHouseProxy implements MethodInterceptor { @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { beforeBuy(); System.out.println(method.getName()); //spring的aop就是用这种方式 Object result = proxy.invoke(obj,args); // 这种方式不会纳入spring的ioc管理，因为执行的父方法 // Object result = proxy.invokeSuper(obj,args); afterBuy(); return result; } private void beforeBuy(){ System.out.println("中介先了解购房者的需求"); System.out.println("中介确认购买房屋"); System.out.println("中介帮忙砍价"); } private void afterBuy(){ System.out.println("中介收取买家手续费"); System.out.println("中介收取卖家手续费"); } public static void main(String[] args) { System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/Users/yxk/logs/"); CglibBuyHouseProxy proxy = new CglibBuyHouseProxy(); Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(YxkongBuyHouse.class); enhancer.setCallback(proxy); YxkongBuyHouse buyHouseProxy =(YxkongBuyHouse) enhancer.create(); buyHouseProxy.buy(1880000); } } CGLIB debugging enabled, writing to '/Users/yxk/logs/' 中介先了解购房者的需求 中介确认购买房屋 中介帮忙砍价 buy yxkong买了100平，三室总价为1880000.0的房子 中介收取买家手续费 中介收取卖家手续费

把接口去掉，也可以的，大家可以试试。

不管是jdk proxy还是cglib，都是在运行时执行的。

还有一种技术手段，我觉得也可以当成是动态代理的一种。

字节码增强技术。

比如利用byte-buddy。这种手段是在类加载的时候，通过插桩的方式增强目标类的功能。相对来说比较麻烦。

大家可以看下之前的线程池监控的实现。

线程池监控-bytebuddy-agent模式

如果你对文章比较满意，可以关注公众号：5ycode