首先我们需要明白Java的代理模式能做什么?给我们带来的好处是什么?
代理模式:一个最大的优点就是隐藏目标类、对目标类的访问都是通过代理类来实现。
带来的好处:通过代理访问目标对象,那么在代理中就可以对目标对象进行扩展。 在不修改目标对象源码的基础上,通过代理可以实现对目标对象进行扩展。比如Spring AOP就是基于代理模式的思想实现的。在切面前,切面后去实现一些逻辑处理比如日志打印,或者是对目标对象一些功能的扩展等。我们无需修改目标对象。
接下来我们看下:Java代理模式实现的3种方式
1.静态代理
2.JDK动态代理(也称接口代理)
3.cglib动态代理(也称子类代理)
首先我们看下代理模式的结构图
上图可以看到一个比较重要的是:目标对象与代理对象都实现一个业务接口。并且代理对象持有目标对象的引用。
接下来我们来看下静态代理与动态代理的区分:
静态代理:由程序员创建或特定工具自动生成源代码,也就是在编译时就已经将接口、被代理类、代理类等确定下来。在程序运行之前,代理类的.class文件就已经生成。
动态代理:代理类在程序运行时创建的代理方式被成为动态代理。
接下来我们看下静态代理具体的实现场景
根据上面的结构图:我们假设一个场景,学生教班费给老师。老师派一个任务给到班长。让班长去收班费:那么班长就是学生的一个代理。代理收班费:
首先:我们需要定义一个接口:
public interface Student{
//上交班费
void handleFee();
}
定义目标类:
public class TargetStudent implements Student{
private String name;
public TargetStudent (String name) {
this.name = name;
}
@Override
public void handleFee() {
System.out.println(name + "上交班费50元");
}
}
定义代理类:
public class StudentsProxy implements Person{
//被代理的学生
TargetStudent stu;
public StudentsProxy(Person stu) {
// 只代理目标学生对象
if(stu.getClass() == TargetStudent .class) {
this.stu = (Student)stu;
}
}
//代理上交班费,调用被代理学生的上交班费行为
public void handleFee() {
stu.handleFee();
}
}
客户端调用
public class StaticProxyTest {
public static void main(String[] args) {
//被代理的学生张三,他的班费上交有代理对象monitor(班长)完成
Person zhangsan = new Student("张三");
//生成代理对象,并将张三传给代理对象
Person proxy= new StudentsProxy(zhangsan);
//班长代理上交班费
proxy.handleFee();
}
}
静态代理的代码大家应该很好理解:真正上交班费的是班长代理对象:
看完静态代理的实现,我们看下动态代理:
相比于静态代理, 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理,而不用修改每个代理类中的方法。 比如说,想要在每个代理的方法前都加上一个处理方法:
//代理上交班费,调用被代理学生的上交班费行为
public void handleFee() {
call();
stu.handleFee();
}
如果针对上交班费的时候,老师让我们叫张三同学去她办公室,调用一个call方法、叫李四同学去打扫卫生、那么这还需要针对不同的学生,在交班费的时候有不同的处理逻辑,这个时候,我们就会频繁的去更改上交班费的实现逻辑,显得很麻烦。这个时候我们就需要用到动态代理了。
首先我们还是定义接口类
public interface Student{
//上交班费
void handleFee();
}
定义目标类:
public class TargetStudent implements Student{
private String name;
public TargetStudent(String name) {
this.name = name;
}
@Override
public void handleFee() {
System.out.println(name + "上交班费50元");
}
}
接口与目标类的实现与静态代理的方式差不太多。
主要的差异点,在与代理类的生成
public class StuInvocationHandler<T> implements InvocationHandler {
/**
* invocationHandler持有的被代理对象
*/
T target;
public StuInvocationHandler(T target){
this.target = target;
}
/**
* proxy:代表动态代理对象
* method:代表正在执行的方法
* args:代表调用目标方法时传入的实参
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = method.invoke(target, args);
return result;
}
}
客户端调用
public class ProxyClient {
public static void main(String[] args) {
//创建一个实例对象,这个对象是被代理的对象
Student zhangSan = new TargetStudent("张三");
//创建一个与代理对象相关联的InvocationHandler
InvocationHandler stuHandler = new StuInvocationHandler<Student>(zhangSan);
//创建一个代理对象stuProxy来代理zhangsan,代理对象的每个执行方法都会替换执行Invocation中的invoke方法
Student stuProxy = (Student) Proxy.newProxyInstance(Student.class.getClassLoader(), new Class<?>[]{Student.class}, stuHandler);
//代理执行上交班费的方法
stuProxy.handleFee();
}
}
创建了一个需要被代理的学生张三,将zhangsan对象传给了stuHandler中,我们在创建代理对象stuProxy时,将stuHandler作为参数了的,上面也有说到所有执行代理对象的方法都会被替换成执行invoke方法,也就是说,最后执行的是StuInvocationHandler中的invoke方法。
动态代理的优势在于可以很方便的对代理类的函数进行统一的处理,而不用修改每个代理类中的方法。是因为所有被代理执行的方法,都是通过在InvocationHandler中的invoke方法调用的,所以我们只要在invoke方法中统一处理,就可以对所有被代理的方法进行相同的操作了。例如,这里的方法计时,所有的被代理对象执行的方法都会被计时,然而我只做了很少的代码量。
接下来我们针对动态代理的原理进行分析:
看proxyClient客户端的代码:我们可以看到:
第一步:我们创建了目标对象的实例。
第二步:我们创建了一个和目标对象相关联的InvocationHandler 对象。
第三步:生成代理对象。
第四步:通过代理对象访问目标对象的方法。
我们从生成代理对象开始分析:
其生成的原理:通过java的反射生成一个proxy的类文件存放在内存中,并有缓存处理。
返回利用java的反射技术。获取到一个代理对象proxy 的实例。
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//通过类加载器获取到代理的class文件。并用反射生成proxy实例
//如果缓存中有,就从缓存中返回,如果没有,就在内存中新生成一个proxy的class文件返回
return proxyClassCache.get(loader, interfaces);
}
明白代理对象生成后,我们来看下,Proxy类与接口InvocationHandler之间的关系:
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import proxy.Person;
public final class $Proxy0 extends Proxy implements Person {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
/**
*注意这里是生成代理类的构造方法,方法参数为InvocationHandler类型,看到这,是不是就有点明白
*为何代理对象调用方法都是执行InvocationHandler中的invoke方法,而InvocationHandler又持有一个
*被代理对象的实例,不禁会想难道是....? 没错,就是你想的那样。
*
*super(paramInvocationHandler),是调用父类Proxy的构造方法。
*父类持有:protected InvocationHandler h;
*Proxy构造方法:
* protected Proxy(InvocationHandler h) {
* Objects.requireNonNull(h);
* this.h = h;
* }
*
*/
public $Proxy0(InvocationHandler paramInvocationHandler)
throws
{
super(paramInvocationHandler);
}
//这个静态块本来是在最后的,我把它拿到前面来,方便描述
static
{
try
{
//看看这儿静态块儿里面有什么,是不是找到了handleFee方法。请记住handleFee通过反射得到的名字m3,其他的先不管
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("proxy.Person").getMethod("handleFee", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
return;
}
catch (NoSuchMethodException localNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundException localClassNotFoundException)
{
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
/**
*
*这里调用代理对象的handleFee方法,直接就调用了InvocationHandler中的invoke方法,并把m3传了进去。
*this.h.invoke(this, m3, null);这里简单,明了。
*来,再想想,代理对象持有一个InvocationHandler对象,InvocationHandler对象持有一个被代理的对象,
*再联系到InvacationHandler中的invoke方法。嗯,就是这样。
*/
public final void handleFee()
throws
{
try
{
this.h.invoke(this, m3, null);
return;
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
从上面proxy Class文件生成的逻辑中,我们可以明白在代理对象的构造器中传入了一个InvocationHandler 对象,这就是为什么newProxyInstance方法的时候需要传入一个InvocationHandler对象.
另外:
JDK和CGLIB动态代理总结
JDK动态代理只能对实现了接口的类生成代理,而不能针对类 ,使用的是 Java反射技术实现,生成类的过程比较高效。
CGLIB是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法 ,使用asm字节码框架实现,相关执行的过程比较高效,生成类的过程可以利用缓存弥补,因为是继承,所以该类或方法最好不要声明成final
JDK代理是不需要第三方库支持,只需要JDK环境就可以进行代理,使用条件:实现InvocationHandler + 使用Proxy.newProxyInstance产生代理对象 + 被代理的对象必须要实现接口
CGLib必须依赖于CGLib的类库,但是它需要类来实现任何接口代理的是指定的类生成一个子类,覆盖其中的方法,是一种继承但是针对接口编程的环境下推荐使用JDK的代理;
参考文献:
https://blog.csdn.net/xiaofeng10330111/article/details/105633821