📝个人主页：哈__
期待您的关注
一、什么是代理模式
想要学代理模式，我们就要先弄清一个概念“什么是代理”？
在我们的现实生活中，你或许不少听过关于代理的名词，如：代理商。那什么又叫做代理商？让我一个词来形容就是中间商。
举个例子，在你买二手房的时候，你一般不会直接和业主去交谈，你或许会找一家二手房出租出售企业来寻找房源，你看上哪个房子后，由这位中间商来沟通房源的业主完成购买流程。这就是一个代理的例子。
再举个例子，在青青草原上举办了一场选美大赛，在喜羊羊的劝导下，美羊羊参加了这场比赛。当然结果对于美羊羊来说是十分完美的，美羊羊以158票的优势超越第二名的红太狼位居榜首。从此美羊羊成为了青青草原的大明星。
红太狼自然是不服，于是灰太狼和红太狼商量了一个计划，他们想要请美羊羊来参加一场由他们举办的模特比赛，美羊羊在接收到邀请后非常开心，直接就同意了他们的邀请。但这时作为经纪人的喜羊羊就不同意了，这明显是请君入瓮啊，于是喜羊羊就代替美羊羊推掉了他们的邀请。
如果没有喜羊羊，美羊羊去了之后的后果可想而知，这时就体现出了喜羊羊的重要性了。
二、Java中的静态代理
1.创建我们的美羊羊同意邀请的service层。go()方法也叫做目标方法。
public interface YangService {
void go();
}
public class YangServiceImpl implements YangService {
@Override
public 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();
@Override
public 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 {
@Override
public 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类型的对象。
![[StartingPoint][Tier1]Crocodile](https://img-blog.csdnimg.cn/img_convert/6a6e016ae303f164f5fb76e63ec0f07b.jpeg)
