📝个人主页：哈__
期待您的关注
一、什么是代理模式
想要学代理模式，我们就要先弄清一个概念“什么是代理”？
在我们的现实生活中，你或许不少听过关于代理的名词，如：代理商。那什么又叫做代理商？让我一个词来形容就是中间商。
举个例子，在你买二手房的时候，你一般不会直接和业主去交谈，你或许会找一家二手房出租出售企业来寻找房源，你看上哪个房子后，由这位中间商来沟通房源的业主完成购买流程。这就是一个代理的例子。
再举个例子，在青青草原上举办了一场选美大赛，在喜羊羊的劝导下，美羊羊参加了这场比赛。当然结果对于美羊羊来说是十分完美的，美羊羊以158票的优势超越第二名的红太狼位居榜首。从此美羊羊成为了青青草原的大明星。
红太狼自然是不服，于是灰太狼和红太狼商量了一个计划，他们想要请美羊羊来参加一场由他们举办的模特比赛，美羊羊在接收到邀请后非常开心，直接就同意了他们的邀请。但这时作为经纪人的喜羊羊就不同意了，这明显是请君入瓮啊，于是喜羊羊就代替美羊羊推掉了他们的邀请。
如果没有喜羊羊，美羊羊去了之后的后果可想而知，这时就体现出了喜羊羊的重要性了。
二、Java中的静态代理
1.创建我们的美羊羊同意邀请的service层。go()方法也叫做目标方法。
public interface YangService {void go();
}public class YangServiceImpl implements YangService {@Overridepublic void go() {System.out.println("美羊羊想要同意邀请");}
}2.创建一个喜羊羊检查意图和拒绝他们的邀请的类（喜羊羊可能是多个人的经纪人，所以把他的功能单独抽取）。这些方法我也会称作增强方法。
public class DaoTransaction{public void beforeCheck(){System.out.println("喜羊羊检查灰太狼的意图");}public void afterCheck(){System.out.println("喜羊羊拒绝他们的邀请");}}3.我们创建一个代理类，这个类就相当于灰太狼和红太狼直接向喜羊羊发出了邀请，美羊羊太火，他们无法直接接触到美羊羊。这里要实现美羊羊功能的接口，因为喜羊羊要对美羊羊的一切行动做出处理。看下边的代码，美羊羊在同意之前要经过喜羊羊的检查，同意之后还要被喜羊羊拒绝。
public class XiYyProxy implements YangService {DaoTransaction daoTransaction = new DaoTransaction();YangServiceImpl yangService = new YangServiceImpl();@Overridepublic void go() {daoTransaction.beforeCheck();yangService.go();daoTransaction.afterCheck();}
}4.主程序。
public static void main(String[] args) {XiYyProxy xiYyProxy = new XiYyProxy();xiYyProxy.go();}
三、Jdk动态代理
我们上边写的是静态代理，你可以看到，我们的代码只能让喜羊羊作为美羊羊一个人的经纪人，静态代理有着这么几个特点。
- 目标角色固定
- 在应用程序执行前就得到目标角色
- 代理对象会增强目标对象的行为
- 有可能存在多个代理 引起"类爆炸"（缺点）
如果灰太狼邀请的不是美羊羊，那我们的代码就毫无用处了，所以我们使用动态代理来实现功能。
我们创建这样的一个service，我们上边写的是YangService，为了区分我们创建一个YangTwoService，这里我弄得不太规范，重在让大家理解。
public interface YangTwoService {void go();
}public class YangTwoServiceImpl implements YangTwoService {@Overridepublic void go() {System.out.println("沸羊羊同意参加健美比赛");}
}那如果我们想要喜羊羊作为沸羊羊的经纪人拒绝掉这个比赛呢？还按照上边的代理方式吗？这就太费事费力了。我们这样想，我们把喜羊羊作为代理的过程抽取出来，到底要代理谁我们后期决定，只要传入一个参数确认是谁，这样我们的代码就简化很多了。
创建JdkProxyHandler。
public class JdkProxyHandler implements InvocationHandler {//这是我们要代理的目标对象 到底是谁Object object;// 这是从喜羊羊那里抽取出来的方法DaoTransaction daoTransaction;public JdkProxyHandler(Object o,DaoTransaction daoTransaction){this.object = o;this.daoTransaction = daoTransaction;}@Override//proxy--代理类 method--目标方法 args--目标方法的参数public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object o = new Object();//我们只对go方法进行处理，喜羊羊不能管得太多if(method.getName().equals("go")){daoTransaction.beforeCheck();o = method.invoke(object,args);daoTransaction.afterCheck();}else{o = method.invoke(object,args);}return o;}
}主方法。
public class Main {public static void main(String[] args) {DaoTransaction daoTransaction = new DaoTransaction();YangServiceImpl yangService = new YangServiceImpl();YangTwoServiceImpl yangTwoService = new YangTwoServiceImpl();JdkProxyHandler proxy1 = new JdkProxyHandler(yangService,daoTransaction);JdkProxyHandler proxy2 = new JdkProxyHandler(yangTwoService,daoTransaction);YangService proxyYang = (YangService) Proxy.newProxyInstance(yangService.getClass().getClassLoader(), yangService.getClass().getInterfaces(), proxy1);YangTwoService proxyYangTwo = (YangTwoService) Proxy.newProxyInstance(yangTwoService.getClass().getClassLoader(), yangTwoService.getClass().getInterfaces(), proxy2);proxyYang.go();proxyYangTwo.go();}
}看不懂没关系，我接下来会将Jdk动态代理的过程。我先来解释一下上边的代码。
创建我们的Handler，在上边我们能够看到，我们的逻辑处理都是在这个对象里的，这个对象很重要，你到底是如何让喜羊羊去处理的，都是靠这个JdkProxyHandler类(自定义)实现。每只不同的羊都有自己的对象。
JdkProxyHandler proxy1 = new JdkProxyHandler(yangService,daoTransaction);这行代码才是真正创建我们的代理对象，也就是相当于我们上边静态代理创建的XiYyProxy对象，我们调用美羊羊和沸羊羊的go方法，都通过这个proxyYang对象 。
YangService proxyYang = (YangService) Proxy.newProxyInstance(yangService.getClass().getClassLoader(), yangService.getClass().getInterfaces(), proxy1);下边这行代码就是调用我们创建出来的代理对象来处理我们的逻辑。
proxyYang.go(); 
四、Jdk动态代理解析
我们生成一下Jdk动态代理在编译后生成的class文件的反编译结果来查看一下。下边的代码就是为了生成我们的class文件的。
public static void saveProxyClass(String path) throws IOException {byte[] $proxy1s = ProxyGenerator.generateProxyClass("$Proxy1", YangServiceImpl.class.getInterfaces());FileOutputStream out = null;try{out = new FileOutputStream(new File(path+"$Proxy1.class"));out.write($proxy1s);}catch (Exception e){e.printStackTrace();}finally {if(out == null){try {out.flush();out.close();}catch (Exception e){e.printStackTrace();}}}}在main方法中调用这个方法。注意：一定要修改saveProxyClass的路径，我直接生成到根目录下了！！！！！！
public static void main(String[] args) throws IOException {DaoTransaction daoTransaction = new DaoTransaction();YangServiceImpl yangService = new YangServiceImpl();YangTwoServiceImpl yangTwoService = new YangTwoServiceImpl();JdkProxyHandler proxy1 = new JdkProxyHandler(yangService,daoTransaction);JdkProxyHandler proxy2 = new JdkProxyHandler(yangTwoService,daoTransaction);YangService proxyYang = (YangService) Proxy.newProxyInstance(yangService.getClass().getClassLoader(), yangService.getClass().getInterfaces(), proxy1);YangTwoService proxyYangTwo = (YangTwoService) Proxy.newProxyInstance(yangTwoService.getClass().getClassLoader(), yangTwoService.getClass().getInterfaces(), proxy2);proxyYang.go();proxyYangTwo.go();saveProxyClass("你的真实路径");}
查看文件。
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//import com.my.proxy.service.YangService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;public final class $Proxy1 extends Proxy implements YangService {private static Method m1;private static Method m2;private static Method m3;private static Method m0;public $Proxy1(InvocationHandler var1) throws {super(var1);}public final boolean equals(Object var1) throws {try {return (Boolean)super.h.invoke(this, m1, new Object[]{var1});} catch (RuntimeException | Error var3) {throw var3;} catch (Throwable var4) {throw new UndeclaredThrowableException(var4);}}public final String toString() throws {try {return (String)super.h.invoke(this, m2, (Object[])null);} catch (RuntimeException | Error var2) {throw var2;} catch (Throwable var3) {throw new UndeclaredThrowableException(var3);}}public final void go() throws {try {super.h.invoke(this, m3, (Object[])null);} catch (RuntimeException | Error var2) {throw var2;} catch (Throwable var3) {throw new UndeclaredThrowableException(var3);}}public final int hashCode() throws {try {return (Integer)super.h.invoke(this, m0, (Object[])null);} catch (RuntimeException | Error var2) {throw var2;} catch (Throwable var3) {throw new UndeclaredThrowableException(var3);}}static {try {m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));m2 = Class.forName("java.lang.Object").getMethod("toString");m3 = Class.forName("com.my.proxy.service.YangService").getMethod("go");m0 = Class.forName("java.lang.Object").getMethod("hashCode");} catch (NoSuchMethodException var2) {throw new NoSuchMethodError(var2.getMessage());} catch (ClassNotFoundException var3) {throw new NoClassDefFoundError(var3.getMessage());}}
}我们来分块讲解一下，先看下边的static静态块，这个块在类被加载的时候自动执行里边的代码。
我去，这不就是反射吗把我的YangServiceImpl类中继承的Object类中的方法都给我反射出来了，同时还把我的YangService接口中的方法go()也给我反射出来了。
static {try {m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));m2 = Class.forName("java.lang.Object").getMethod("toString");m3 = Class.forName("com.my.proxy.service.YangService").getMethod("go");m0 = Class.forName("java.lang.Object").getMethod("hashCode");} catch (NoSuchMethodException var2) {throw new NoSuchMethodError(var2.getMessage());} catch (ClassNotFoundException var3) {throw new NoClassDefFoundError(var3.getMessage());}}在看看我们的go()方法调用。我去，这个super.h.invoke(this,m3,(Object[])null)是啥啊，我带你先弄清h是啥。
public final void go() throws {try {super.h.invoke(this, m3, (Object[])null);} catch (RuntimeException | Error var2) {throw var2;} catch (Throwable var3) {throw new UndeclaredThrowableException(var3);}}我们往上看看这个代理类的构造函数。你明白了吗？h就是我们传给父类的InvocationHandler类型的对象，也就是我们上边自己创建的JdkProxyHandler类。
public $Proxy1(InvocationHandler var1) throws {super(var1);}那这个go方法还用点进去吗？我们上边的JdkProxyHandler已经写清楚了。
现在你是否了解了Jdk动态代理？它是通过反射实现的，将目标接口中的方法进行反射，然后我们的代理类拿到这些方法，每当我们执行目标接口中的方法的时候，都会通过我们的代理类进行反射调用，具体如何调用，就是通过我们创建的InvocationHandler类型的对象。
