接下来都是源码分析了，在分析之前必须了解一下代理模式。
什么是代理模式
代理模式是java常用的设计模式，他的特征是代理类与委托类有同样的接口，其他类想访问这个类必须先通过代理类。
在某些情况下，一个客户在访问一个对象之前想再前后做一些固定的操作，那么这个时候就适合用到代理模式。
比较常见的：中介、快递/外卖小哥、黄牛等
JAVA中的静态代理和动态代理
我们分别通过代码来演示静态代理和动态代理
1.先了解一下静态代理
//顶层接口
public interface Person {
void sayHello();
}
//代理工厂类 如果多一个其他的接口 那么也要多一个代理工厂实现类
public class PersonProxy implements Person {
private Person person;
public PersonProxy(Person person) {
this.person = person;
}
//静态代理 每多一个方法 就要写一遍重复的代码
public void sayHello() {
System.out.println("调用前");
person.sayHello();
System.out.println("调用后");
}
}
//实现类
public class PersonBoyImpl implements Person {
public void sayHello() {
System.out.println("hello 我是男孩");
}
}
//main方法调用
public static void main(String[] args) {
new PersonProxy(new PersonBoyImpl()).sayHello();
}
//执行打印的结果
调用前
hello 我是男孩
调用后
以上就是静态代理的实现，缺点很明显，就是每个接口都需要对应的代理工厂类，每个方法都需要去写一遍重复的代码
2.动态代理的两种方式演示
在Java中有两种生成代理的方式我们先来看第一种JDK代理（JDK动态代理必须要有实现接口）
2.1 JDK动态代理
- 上述静态代理中接口
Person和实现类BoyPerson不变 - 新建动态代理Handler类
//动态代理Handler类
public class PersonPoxyHandler implements InvocationHandler {
//保留原始类
Object target;
//创建代理类
public Object getInstance(Object target){
this.target = target;
Class<?> clazz = target.getClass();
//1.生成新的class类 方法名相同 JDK代理对象为接口
//2.通过实现接口创建
//3.回调类传了this ,而此类又实现了InvocationHandler,那么调用代理类的invoke会调到当前类
return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
//代理调用类
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("[JDK]代理调用之前");
//代理方法执行 此处传入原始类
Object result = method.invoke(target, args);
System.out.println("[JDK]代理调用之后");
return result;
}
}
- 接下来我们看下Main方法
public static void main(String[] args) throws Exception {
//传入实现类,实际上返回的对象已经是代理对象了
//如果是其他不同的类,传入不同的接口实现类就可拿到代理对象
Person person = (Person) new PersonPoxyHandler().getInstance(new BoyPerson());
person.sayHello();
}
//打印结果,具体原理看后面
[JDK]代理调用之前
hello 我是xxxx
[JDK]代理调用之后
因为此时拿到已经是代理类了，每次调用方法都会走到代理handler类的invoke方法
2.2 CGLIB动态代理
Cglib动态代理是基于字节码生成类，需要引入cglib包。
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.5</version>
</dependency>
- 新建一个class类GirlPerson类型
//新建一个类 里面就一个方法
public class GirlPerson{
public void sayHello() {
System.out.println("hello 我是Girl");
}
}
- Cglib的handler类，实现MethodInterceptor
/**
* cglib 动态代理 基于字节码生成类
* 需要引入cglib包
*/
public class CglibProxyHandler implements MethodInterceptor {
//通过字节码创建代理对象
public Object getInstance(Class<?> clazz){
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
//回调
enhancer.setCallback(this);
return enhancer.create();
}
//回调 因为创建时传的也是this
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("[CGLIB]代理调用之前");
//代理方法执行 o = 原始类 methodProxy/代理类方法 调用父类
Object result = methodProxy.invokeSuper(o, objects);
System.out.println("[CGLIB]代理调用之后");
return result;
}
}
- main方法执行
public static void main(String[] args) throws Exception {
//基于继承的形式创建的代理类,不用接口实现
GirgPerson instance = (GirgPerson)new CglibProxyHandler().getInstance(new GirgPerson().getClass());
instance.sayWorld();
}
//打印结果,具体原理看后面
[CGLIB]代理调用之前
hello 我是Girl
[CGLIB]代理调用之后
2.3 两者区别
- JDK代理是通过实现接口创建代理类，在创建的同时保存了原始类，在通过代理类调用同样的方法时，先经过代理对象invoke逻辑，然后在代理对象里面通过原始类调用对应的方法
- CGLIB代理时通过字节码重置，经过它生成的对象，内部的代码已经发生改变
上面不懂的不要紧,我准备了代理类生成的源码!
3.JDK动态代理源码分析
- 从创建代理对象开始,我们来一探究竟
//直接看 Proxy.newProxyInstance 这个方法
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
//克隆一下接口
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* Look up or generate the designated proxy class.
*/
//通过实现接口获得一个代理类
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
//获取代理类的构造方法
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
//实例化代理类 并通过构造方法传参 传入InvocationHandler
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
- 在main方法执行这几行代码，可以将生成的代理类保存下来
public static void main(String[] args) throws Exception {
Person person1 = new BoyPerson();
Class<?>[] interfaces = person1.getClass().getInterfaces();
byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy", interfaces);
FileOutputStream stream = new FileOutputStream(new File("D:/$Proxy.class"));
stream.write(bytes);
stream.flush();
stream.close();
}
- 接下来我们来看下$Proxy.class的内容到底是什么?
//我们实际拿到的是这个代理对象
public final class $Proxy extends Proxy implements Person {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
//构造类 通过newInstance(h) 直接将InvocationHandler传参直接到父类
public $Proxy(InvocationHandler var1) throws UndeclaredThrowableException {
super(var1);
}
//重点看这里
public final void sayHello() {
try {
//调用父类的h 然后调用的invoke对象
super.h.invoke(this, m3, (Object[])null);
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m3 = Class.forName("com.xxx.demo.动态代理.Person").getMethod("sayHello");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
从$Proxy.class代理类可以看到，通过构造方法将回调类（handler）传入代理类，然后代理会传入父类super，那么在调用方法时实际执行的是super.h.invoke()，自然就能调用到PersonPoxyHandler类实现的invoke方法了
4.CGLIB动态代理原理分析
- CGLIB就不去看代理类生成的源码了，采用的是继承原始类然后动态生成的字节码，直接看生成的代理类
public static void main(String[] args) throws Exception {
//在main方法第一行加上这句代码,就能保存到指定目录
//存储代理类
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\code");
//基于继承的形式创建的代理类,不用接口实现
GirgPerson instance = (GirgPerson)new CglibProxyHandler().getInstance(new GirgPerson().getClass());
instance.sayWorld();
}
- 接下来看生成的代理类，里面会有很多同名的方法，主要关注这个
//代理类对象调用方法
public final void sayHello() {
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (this.CGLIB$CALLBACK_0 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
if (var10000 != null) {
//回调类里面的实现方法,多的也不用展开说了
var10000.intercept(this, CGLIB$sayHello$1$Method, CGLIB$emptyArgs, CGLIB$sayHello$1$Proxy);
} else {
super.sayHello();
}
}
//set回调方法 就是handler
public void setCallbacks(Callback[] var1) {
this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
}
动态代理的两种方式及原理已经分析就到这里，还想研究更深层次的小伙伴自行了解哦！这里提一点，动态代理在以后的代码分析中起到至关重要的作用，务必学好学懂！
以上就是本章的全部内容了。
上一篇：线程池工作线程ForkJoin的使用
下一篇：SpringMvc手写简单实现篇 - IOC容器、DI依赖注入篇
读书破万卷，下笔如有神
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
