首先我们要明白代理的含义，假如有一天张三想要买衣服，他是不是有两种方式，第一：自己去生产衣服的地方买，第二：请一个代购，他只需要提要求，然后代购帮助他买，假设我自己就是一个代购，我知道一个工厂生产男装。
在代理中有三个重要的角色：被代理类，代理类，接口
在上面的例子中分别对应的就是，被代理类：生产男装的工厂，代理类：我自己，接口：提供服务
（如果这里都会了，请移步到下面动态代理原理分析）
静态代理
先说一下静态代理，静态代理是指在代码编写阶段就已经确定好了的，被代理类、代理类、接口这三个之间的关系
定义接口，里面包含一个提供服务的接口
-
public
interface Serve {
//一个提供服务的接口，工厂和代购都必须实现这个接口，提供服务
-
void service(float price);
//提供服务
-
}
定义一个被代理类，生产男装的工厂，他只负责生产让客户满意衣服
-
public
class RealityFactory implements Serve {
-
@Override
-
public void service(float price) {
-
System.out.println(
"根据您的要求，本工厂为您定制衣服，价格是：" + price);
-
}
-
}
定义一个代理类，相当于我自己，是一个代购，我会帮张三找到工厂，并告诉工厂张三的要求，把工厂生产出来的衣服邮寄到张三的家里
-
public
class Purchasing implements Serve {
-
Serve realityFactory;
-
public PurchasingAgency(Serve realityFactory) {
-
this.realityFactory= realityFactory;
//注入一个被代理类
-
}
-
@Override
-
public void service(float price) {
-
System.out.println(
"根据市场调研寻找到合适的工厂");
//前置增强
-
realityFactory.service(price);
//工厂只负责制作衣服
-
System.out.println(
"工厂制作完毕，我负责帮您邮寄到家");
//后置增强
-
}
-
}
测试一下
-
public
class Test{
-
public static void main(String[] args) {
-
Serve realityFactory =
new RealityFactory();
//定义被代理类工厂
-
Serve purchasing =
new Purchasing(realityFactory);
//定义代理类我自己，并将被代理类注入
-
purchasing.service(
20.0f);
//执行代理类的service方法,增强了被代理类作用
-
}
-
}
-
根据市场调研寻找到合适的工厂
-
根据您的要求，本工厂为您定制衣服，价格是：
20.0
-
工厂制作完毕，我负责帮您邮寄到家
通过静态代理我们可以看到，第一：被代理类实际上只有一个作用就是生产男装，但通过代理类代理之后，方法得到了增强，拥有了三个作用，寻找工厂，制作衣服，寄送衣服。第二：静态代理存在缺点，一个代理类只能为同一个接口的类提供增强，假如有不同的接口，你就需要定义很多的代理类，假如，有一天张三的老婆需要买衣服也找到了我，这样子，这个生产男装的工厂就没办法提供服务了，就需要新的工厂来提供服务。
动态代理
动态代理应运而生，它就可以帮我们解决接口不匹配的问题，可以为多个类提供增强
动态代理的底层原理就是通过反射动态构建了一个代理类，这样子就可以为每一个接口的
在例子中，动态代理类就相当于我自己开了一个代购公司，每次有客户来找我买衣服的时候，我就在公司里面找一个人来服务这个客户
在动态代理类中，接口和被代理类是和静态代理类一样的
定义接口，里面包含一个提供服务的接口，其子类生产男装
-
public
interface Serve {
//一个提供服务的接口，工厂必须实现这个接口，提供服务
-
void service(float price);
//提供服务
-
}
定义一个被代理类，生产男装的工厂，他只负责生产让客户满意衣服
-
public
class RealityFactory implements Serve {
-
@Override
-
public void service(float price) {
-
System.out.println(
"根据您的要求，本工厂为您定制男装，价格是：" + price);
-
}
-
}
主要就是下面不一样了，下面我们定义一个动态代理类，这里主要使用到两个主要的类：InvocationHandler和Proxy
InvocationHandler类提供真实的服务，最后实际执行的方法在InvocationHandler中，就相当于是一个我们的客户，为他们提供优质的服务
Proxy类用来动态的生成代理类，就相当于是代购公司中的职员，他们有丰富的资源，可以帮客户找到心仪的产品
定义一个动态代理类，必须实现InvocationHandler方法
-
public
class Mediation implements InvocationHandler{
//必须实现InvocationHandler接口
-
-
Object object;
//接收一个通用类
-
public Mediation(Object object) {
//将通用类注入
-
this.object = object;
-
}
-
@Override
-
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//增强方法
-
System.out.println(
"根据市场调研寻找到合适的工厂");
-
method.invoke(object, args);
//通过反射调用实际的方法，method为对应的方法，args为方法的参数，如果没有则为null
-
System.out.println(
"工厂制作完毕，我负责帮您邮寄到家");
-
return
null;
-
}
-
-
public Object getProxyInstance() {
//通过反射得到一个代理类的实例
-
return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(),
this);
-
}
-
}
测试一下
-
public
class Test{
-
public static void main(String[] args) {
-
Serve realityFactory =
new RealityFactory();
//实例化一个生产男装的工厂
-
Mediation mediation =
new Mediation(realityFactory);
//将这个工厂注入动态代理类
-
Serve serviceMediation = (Serve) mediation.getProxyInstance();
//通过Proxy类得到一个代理类的实例
-
serviceMediation.service(
20.0f);
//调用代理类的service方法，会将该方法映射到Mediation的invoke方法
-
}
-
}
结果
-
根据市场调研寻找到合适的工厂
-
根据您的要求，本工厂为您定制男装，价格是：
20.0
-
工厂制作完毕，我负责帮您邮寄到家
假如我们想要为另外一个接口代理呢？
定义另外一个接口，该接口是一个服务接口，其子类生产女装
-
public
interface ServeWomen {
//一个提供服务的接口，工厂必须实现这个接口，提供服务
-
void service(float price);
//提供服务
-
}
定义一个被代理类，假设这个类是一个工厂，主要生产女装
-
public
class WomenRealityFactory implements ServeWomen {
-
@Override
-
public void service(float price) {
-
System.out.println(
"根据您的要求，本工厂为您定制女装，价格是：" + price);
-
}
-
}
使用了动态代理，就不用再定义动态代理类，直接使用以前的动态代理类，写测试代码
-
public
class Test{
-
public static void main(String[] args) {
-
ServeWomen womenRealityFactory =
new WomenRealityFactory();
//实例化一个生产女装的工厂
-
Mediation mediation =
new Mediation(womenRealityFactory);
//将这个工厂注入动态代理类
-
ServeWomen serviceWomenMediation = (ServeWomen) mediation.getProxyInstance();
//通过Proxy类得到一个代理类的实例
-
serviceWomenMediation.service(
20.0f);
//调用代理类的service方法，会将该方法映射到Mediation的invoke方法
-
}
-
}
结果
-
根据市场调研寻找到合适的工厂
-
根据您的要求，本工厂为您定制女装，价格是：
20.0
-
工厂制作完毕，我负责帮您邮寄到家
使用动态代理的好处一下就体现出来了，只要编写了一次动态代理类，并且被代理类实现了一个接口，就可以为被代理类生成一个代理类的实例，这个就是JDK动态代理的实现方式。
JDK动态代理原理
在谈这个之前我们先来看看，一个类的生命周期
java源文件（.java文件）：编译之后，就变成java字节码文件
java字节码（.class文件）：类加载之后，变成一个Class对象
Class对象：实例化之后，变成一个实例对象
实例对象
卸载
到现在很多人很好奇，为什么通过Proxy类的静态方法newProxyInstance就可以得到一个ServeWomen的一个实例？通过Proxy类得到ServeWomen的实例到底是哪里来的？这个实例对象到底是哪个类实例化来的？
带着这些问题，我们开启Debug模式查看一下Proxy类生成的实例到底是哪个类，不看不知道，一看吓一跳，$Proxy0这个类是哪里来的？我们没有编写这个类啊，现在好了问题越来越复杂，我们只能去看一下Proxy类的静态方法newProxyInstance里面到底干了什么
我们点开newProxyInstance方法，我们传给了newProxyInstance方法三个参数：
ClassLoader loader，被代理类的类加载器
Class<?>[] interfaces，被代理类实现的接口的Class对象，可能有多个所以是数组
InvocationHandler h，动态代理类的实例
根据JDK代码里面的注释会发现，箭头指向的那一行代码就是核心的，生成代理类的代码，它把我们传递的类加载器和接口的Class对象往下面传递了，我们试着点进去
里面进行了接口数量的验证，重点代码就在get方法里面，我们试着点进去
首先在ConcurrentMap中查找是否之前已经创建过了，如果没有则自己去创建，我们点进去查看apply方法，这个方法是在接口里面定义的方法，按照下面的步骤查看实现类的定义
进到这个方法里面我们就看到了一个熟悉东西$Proxy，这个就是类的前缀，apply方法的前面进行了大量的验证重点代码在后面，我们滑到下面
根据代码的注释，我们很轻易的找到了生成Class对象的代码，底层就是这样子为你提供了一个实例对象，它直接跳过了java源文件，直接生成了.class文件，然后.class文件加载进入JVM，生成一个Class对象，然后通过Class对象生成一个实例对象
现在已经很清晰，既然可以找到生成.class文件的代码，那我们可不可以将.class文件保存到本地，然后通过反编译看一下这个类的源代码是怎么样的呢？当然可以
编写代码将.class文件保存到本地
-
public
class Bytecode {
-
public static void main(String[] args) {
-
String fileName =
"$ppp";
//class文件的名字
-
//这一句代码是在源码中找到的生成class文件的代码，第二个参数需要一个Class对象数组类型
-
byte[] classFile = ProxyGenerator.generateProxyClass(
-
fileName,
new Class[] {ServeWomen.class}, Modifier.FINAL);
-
-
FileOutputStream out =
null;
-
String filePath =
"G:\\"+fileName+
".class";
-
try {
-
out =
new FileOutputStream(filePath);
-
out.write(classFile);
//写入文件
-
out.flush();
-
}
catch (FileNotFoundException e) {
-
// TODO Auto-generated catch block
-
e.printStackTrace();
-
}
catch (IOException e) {
-
// TODO Auto-generated catch block
-
e.printStackTrace();
-
}
finally {
-
try {
-
if(out !=
null) {
-
out.close();
-
}
-
}
catch (IOException e) {
-
// TODO Auto-generated catch block
-
e.printStackTrace();
-
}
-
}
-
-
}
-
}
查看本地，果然保存下来了.class文件
使用反编译工具查看源码，源码如下
-
import com.sxt.server.dynamic.ServeWomen;
-
import java.lang.reflect.InvocationHandler;
-
import java.lang.reflect.Method;
-
import java.lang.reflect.Proxy;
-
import java.lang.reflect.UndeclaredThrowableException;
-
-
final
class $ppp extends Proxy implements ServeWomen {
-
private
static Method m1;
-
-
private
static Method m2;
-
-
private
static Method m3;
-
-
private
static Method m0;
-
-
public $ppp(InvocationHandler paramInvocationHandler) {
super(paramInvocationHandler); }
-
-
public final boolean equals(Object paramObject) {
-
try {
-
return ((Boolean)
this.h.invoke(
this, m1,
new Object[] { paramObject })).booleanValue();
-
}
catch (Error|RuntimeException error) {
-
throw
null;
-
}
catch (Throwable throwable) {
-
throw
new UndeclaredThrowableException(throwable);
-
}
-
}
-
-
public final String toString() {
-
try {
-
return (String)
this.h.invoke(
this, m2,
null);
-
}
catch (Error|RuntimeException error) {
-
throw
null;
-
}
catch (Throwable throwable) {
-
throw
new UndeclaredThrowableException(throwable);
-
}
-
}
-
-
public final void service(float paramFloat) {
-
try {
-
this.h.invoke(
this, m3,
new Object[] { Float.valueOf(paramFloat) });
-
return;
-
}
catch (Error|RuntimeException error) {
-
throw
null;
-
}
catch (Throwable throwable) {
-
throw
new UndeclaredThrowableException(throwable);
-
}
-
}
-
-
public final int hashCode() {
-
try {
-
return ((Integer)
this.h.invoke(
this, m0,
null)).intValue();
-
}
catch (Error|RuntimeException error) {
-
throw
null;
-
}
catch (Throwable throwable) {
-
throw
new UndeclaredThrowableException(throwable);
-
}
-
}
-
-
static {
-
try {
-
m1 = Class.forName(
"java.lang.Object").getMethod(
"equals",
new Class[] { Class.forName(
"java.lang.Object") });
-
m2 = Class.forName(
"java.lang.Object").getMethod(
"toString",
new Class[
0]);
-
m3 = Class.forName(
"com.sxt.server.dynamic.ServeWomen").getMethod(
"service",
new Class[] {
float.class });
-
m0 = Class.forName(
"java.lang.Object").getMethod(
"hashCode",
new Class[
0]);
-
return;
-
}
catch (NoSuchMethodException noSuchMethodException) {
-
throw
new NoSuchMethodError(noSuchMethodException.getMessage());
-
}
catch (ClassNotFoundException classNotFoundException) {
-
throw
new NoClassDefFoundError(classNotFoundException.getMessage());
-
}
-
}
-
}
我们发现这个类实现了我们自定义的接口ServeWomen，查看service方法，发现里面是h.invoke()，这个是不是很眼熟，是的，这个h，就是继承了Proxy类得到的，就是我们前面通过this传递下去的动态代理类的实例
所以当我们调用service方法时，实际上它调用的是，动态代理类中的invoke方法
你学会了没有/偷笑
转载：https://blog.csdn.net/OnlyloveCuracao/article/details/104889478