<>前言

代理模式不管是JDK,spring框架,还是日常的开发中几乎可以说无处不在,下面一张简图描述了代理这个模式的业务场景,有过一些开发经验的同学对这张图应该不难理解;

<>为什么需要代理

1、原有功能增强

举例来说,当现有的类的代码只能满足一些基本的功能,而这些功能满足不了新需求,但又不能改动以前的代码,这时候就可以考虑使用代理,通过代理类,扩展原有类的功能,客户端访问的入口只是聪目标对象切换到代理对象而已;

2、降低耦合

在程序设计时,需要遵循一个叫做“单一职责”的原则,该原则要求每个类功能尽可能单一,为什么要单一,因为只有功能单一这个类被改动的可能性才会最小。

现在突然接到需求,需要对现有类的增删改这样的事务性操作增加审计日志,很多人第一想到的是给每个增删改的地方增加日志,如果这样的类特别多,这就很折腾了,比较好的办法就是,使用代理类,在不对原来类修改的基础上,进行日志功能的扩展即可(spring
aop功能即是如此);

<>java中常用的代理模式

总结下来,java中常用的代理实现主要包括:

* jdk动态代理;
* cglib静态代理
<>一、JDK 动态代理

JDK 动态代理是基于拦截器和反射实现的,不需要第三方库支持,只需要 JDK 环境即可

* 必须实现 InvocationHandler 接口;
* 使用 Proxy.newProxyInstance 产生代理对象;
* 被代理的对象必须要实现接口;
* 内部采用asm技术动态生成字节码;
下面来看一个jdk动态代理的简单案例,深入理解下其用法
public class JdkProxyDemo { interface Foo{ void foo(); } static class Target
implements Foo{ @Override public void foo() { System.out.println(" target foo");
} } /** * jdk代理只能针对接口进行代理 * 内部采用asm技术动态生成字节码() * @param args */ public static
void main(String[] args) { Target target = new Target(); ClassLoader classLoader
= JdkProxyDemo.class.getClassLoader(); Foo proxy = (Foo)Proxy.newProxyInstance(
classLoader, new Class[]{Foo.class}, new InvocationHandler() { //proxy 代理对象自身
//method 正在执行的方法 //方法参数 @Override public Object invoke(Object proxy, Method
method, Object[] args) throws Throwable { System.out.println("before"); Object
result= method.invoke(target, args); //代理类返回的是目标方法执行的结果 System.out.println(
"after"); return result; } }); proxy.foo(); } }
运行这段代码,观察下效果

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces
, InvocationHandler h) throws IllegalArgumentException
代码本身很简单,最重要的就是Proxy.newProxyInstance 这个方法,理解这里面的几个参数至关重要,分别说明下几个参数的含义:

* classLoader,类加载器;
* interfaces,目标对象接口;
* InvocationHandler,真正完成相关方法反射代理的处理器;
JDK动态代理,其关键的步骤就是在InvocationHandler 中执行目标实现类的方法反射调用

由于JDK动态代理,底层是采用了asm字节码技术动态生成,我们无法通过debug源码的方式去学习,为了深入了解其原理,不妨模拟下其实现的过程吧;

要模拟这个过程,大概需要下面的这些准备:

* 接口和接口实现类;
* 自定义的invocationHandler;
* 自定义的Proxy对象(实现与目标类相同的接口);
1、自定义接口和实现
interface Foo{ void foo(); } static class Target implements Foo{ @Override
public void foo() { System.out.println(" target foo"); } }
2、自定义的invocationHandler;

通过上面的demo也可以看到,invocationHandler其实就是一个接口,真正执行时,需要传入到Proxy对象中,通过接口回调的方式实现,这里只需要参照JDK中的invocationHandler,定义好方法参数即可;
public interface MyInvocationHandler { Object invoke(Object proxy, Method
method, Object[] params); }
3、自定义的Proxy对象

这段代码的逻辑大致如下:

* 以构造的方式将自定义invocationHandler传入;
* 通过反射拿到目标接口的方法;
* 通过自定义invocationHandler的接口回调,通过反射完成代理逻辑实现; import java.lang.reflect.Method;
public class MyProxy implements SelfJdkProxy.Foo { private SelfJdkProxy.
MyInvocationHandler invocationHandler; public MyProxy(SelfJdkProxy.
MyInvocationHandler invocationHandler) { this.invocationHandler =
invocationHandler; } @Override public void foo() { try { Method foo =
SelfJdkProxy.Foo.class.getMethod("foo"); invocationHandler.invoke(this, foo, new
Object[0]); } catch (NoSuchMethodException e) { e.printStackTrace(); } }
@Override public int bar() { Method bar = null; Object result = null; try { bar
= SelfJdkProxy.Foo.class.getMethod("bar"); result = invocationHandler.invoke(
this, bar, new Object[0]); } catch (NoSuchMethodException e) { e.printStackTrace
(); } return (int) result; } }
运行上面的代码,观察效果,可以看到,输出效果是一样的,通过这个实现,我们简单模拟了JDK动态代理内部的简单实现;

<>二、cglib静态代理

JDK实现动态代理需要实现类通过接口定义业务方法,对于没有接口的类,如何实现动态代理呢,这就需要cglib了;

cglib采用了非常底层的字节码技术,其原理是通过字节码技术为一个类创建子类,并在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势织入横切逻辑。

下面先看一个简单的cglib使用案例

1、原始目标方法
/** * 原始目标方法 */ public class CglibTarget { public void save() { System.out.
println("save()"); } public void save(int i) { System.out.println("save(int)");
} public void save(long i) { System.out.println("save(long)"); } }
2、代理实现核心逻辑
/** * cglib代理是通过父子继承关系创建代理 * 代理对象自身是作为一个子类型的存在 */ public class CglibProxyDemo {
static class Target { public void foo() { System.out.println(" target foo"); } }
public static void main(String[] args) { Target target = new Target(); Target
proxy= (Target)Enhancer.create(Target.class, new MethodInterceptor() { // o :
代理类对象自身 //method : 代理类执行的方法 //args : 方法执行参数 //methodProxy :
方法代理【采用这个参数,可以避免使用方法反射进行调用,但是内部未使用反射】 @Override public Object intercept(Object o
, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { /*
System.out.println("before"); Object result = method.invoke(target, args);
System.out.println("after"); return result;*/ //methodProxy 使用 ,使用目标进行代理
/*System.out.println("before"); Object result =
methodProxy.invoke(target,args); System.out.println("after"); return result;*/
//methodProxy 使用 ,使用自身进行代理 System.out.println("before"); Object result =
methodProxy.invokeSuper(o,args); System.out.println("after"); return result; } }
); proxy.foo(); } }

cglib的使用相对JDK代理来说,显得更灵活,用起来也很方便,比较核心的地方在于通过调用CglibProxy这个方法的setMethodInterceptor,在回调接口中完成代理逻辑的实现;

这里需要说明的是, 在MethodInterceptor 接口回调方法中,提供了两种完成代理逻辑实现的方式,

* method.invoke(target,args); 基于反射实现;
* methodProxy.invoke(target,args); 直接调用目标类的方法;
* methodProxy.invokeSuper(o,args);直接调用目标类的方法;

需要特别注意的是,CGLib创建的动态代理对象性能比JDK创建的动态代理对象的性能高不少,但CGLib在创建代理对象时所花费的时间却比JDK多得多,所以对于单例对象,因无需频繁创建对象,用CGLib合适,反之,使用JDK方式要更为合适一些。同时,由于CGLib由于是采用动态创建子类的方法,对于final方法,无法进行代理。

同样来说,cglib底层的字节码技术的实现导致我们很难通过debug的方式去调试源码,下面来通过代码模拟上面的实现过程;

自定义一个类,模拟Enhancer 实现

整段代码逻辑做如下说明

* 注入MethodInterceptor ,模拟cglib的create方法中的Enhancer;
* 继承CglibTarget,即cglib采用的是继承目标类的方式完成代理;
* 将代理类中的方法重写,并通过methodInterceptor.intercept 完成接口回调;
* 将目标类中的方法,以静态代码块方式注入,避免每次调用重新实例化;
* 自定义saveSuper方法,模拟MethodProxy 的实现过程; /** * cglib的代理是基于继承,并重写父类方法进行增强 */
public class CglibProxy extends CglibTarget { private MethodInterceptor
methodInterceptor; public void setMethodInterceptor(MethodInterceptor
methodInterceptor) { this.methodInterceptor = methodInterceptor; } static Method
save0; static Method save1; static Method save2; static MethodProxy save0Proxy;
static MethodProxy save1Proxy; static MethodProxy save2Proxy; static { try {
save0= CglibTarget.class.getMethod("save"); save1 = CglibTarget.class.getMethod(
"save", int.class); save2 = CglibTarget.class.getMethod("save", long.class);
save0Proxy= MethodProxy.create(CglibTarget.class, CglibProxy.class, "()V",
"save", "saveSuper"); save1Proxy = MethodProxy.create(CglibTarget.class,
CglibProxy.class, "(I)V", "save1", "saveSuper"); save2Proxy = MethodProxy.create
(CglibTarget.class, CglibProxy.class, "(J)V", "save2", "saveSuper"); } catch (
NoSuchMethodException e) { throw new NoSuchMethodError(e.getMessage()); } }
public void saveSuper() { super.save(); } public void saveSuper(int i) { super.
save(i); } public void saveSuper(long i) { super.save(i); } @Override public
void save() { try { methodInterceptor.intercept(this, save0, new Object[0],
save0Proxy); } catch (Throwable throwable) { //throwable.printStackTrace();
throw new UndeclaredThrowableException(throwable); } } @Override public void
save(int i) { try { methodInterceptor.intercept(this, save1, new Object[]{i},
save1Proxy); } catch (Throwable throwable) { //throwable.printStackTrace();
throw new UndeclaredThrowableException(throwable); } } @Override public void
save(long i) { try { methodInterceptor.intercept(this, save2, new Object[]{i},
save2Proxy); } catch (Throwable throwable) { //throwable.printStackTrace();
throw new UndeclaredThrowableException(throwable); } } }
编写测试类
public class CglibTest { public static void main(String[] args) { CglibProxy
proxy= new CglibProxy(); CglibTarget target = new CglibTarget(); proxy.
setMethodInterceptor(new MethodInterceptor() { @Override public Object intercept
(Object o, Method method, Object[] args, MethodProxy methodProxy) throws
Throwable { System.out.println("before..."); //return
method.invoke(target,args); //return methodProxy.invoke(target,args); return
methodProxy.invokeSuper(o,args); } }); proxy.save(); } }
运行上面的代码,通过控制台输出结果,可以看到和上面的效果一致;

这里需要对这个MethodProxy稍作说明,通过上面的案例可以看到,cglib的回调逻辑中,不仅可以通过类似JDK的反射实现代理,还可以通过MethodProxy提供的invoke()或者invokeSuper()方式实现,之所以说,cglib在某些情况下比JDK代理高效,就在于通过MethodProxy的两个方法,将不走反射,而是直接调用目标类的方法;

<>三、spring中代理的使用

在spring框架中,使用代理模式比较典型的场景就是AOP的实现了,代理逻辑核心要点如下:

* 默认使用 JDK 动态代理,这样可以代理所有的接口类型;
* 如果目标对象没有实现任何接口,则默认采用CGLIB代理;
* 可强制使用CGLIB,指定proxy-target-class = “true” 或者
基于注解@EnableAspectJAutoProxy(proxyTargetClass = true)
下面以AOP的功能使用为入口,来感受下以上三点在AOP的代理中的实现,

来看下面这段以spring底层模拟实现的方式的AOP功能代码
import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.
intercept.MethodInvocation; import org.springframework.aop.aspectj.
AspectJExpressionPointcut; import org.springframework.aop.framework.ProxyFactory
; import org.springframework.aop.support.DefaultPointcutAdvisor; public class
SpringAopTest { public static void main(String[] args) { //1、定义切点
AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut(); pointcut.
setExpression("execution(* foo())"); //2、定义通知 MethodInterceptor advice = new
MethodInterceptor() { @Override public Object invoke(MethodInvocation
methodInvocation) throws Throwable { return methodInvocation.proceed(); } };
//3、定义切面 DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut,
advice); //4、创建代理 Target1 target1 = new Target1(); ProxyFactory proxyFactory =
new ProxyFactory(); proxyFactory.setTarget(target1); proxyFactory.addAdvisor(
advisor); F1 proxy = (F1)proxyFactory.getProxy(); //查看代理类的类型 System.out.println(
proxy.getClass()); proxy.foo(); proxy.bar(); } interface F1 { void foo(); void
bar(); } static class Target1 implements F1 { @Override public void foo() {
System.out.println("Target1 foo() ..."); } @Override public void bar() { System.
out.println("Target1 bar() ..."); } } static class Target2 implements F1 {
@Override public void foo() { System.out.println("Target2 foo() ..."); }
@Override public void bar() { System.out.println("Target2 bar() ..."); } } }
主要逻辑思路可以参考注释,然后运行这段代码,观察控制台效果

通过控制台输出结果,可以大致得出下面几点结论,

* AOP技术底层采用了代理实现;
* 如果目标类实现了接口,spring默认情况下使用的是JDK代理;
* 可以通过修改ProxyConfig中的属性proxyTargetClass 值来改变代理方式;

根据这个属性的不同,将会产生下面几种代理方式

* proxyTargetClass = false; 目标实现了接口,采用JDK代理实现;
* proxyTargetClass = false; 目标没有实现接口,采用cglib实现;
* proxyTargetClass = true; 总是使用cglib实现;

关于上面这几点,我们来通过上面代码的微调来观察效果,上面为什么会输出的是cglib的代理呢?因为在程序中并没有设置这个属性,因此被判断为并未实现接口,所以走的是cglib代理,

调整1:设置代理类的接口

再次运行上面的代码,这次走的就是JDK动态代理

调整2:设置proxyTargetClass 属性为true

再次运行上面的代码,这次走的就是cglib代理

技术
©2019-2020 Toolsou All rights reserved,
TypeScript:函数类型接口8道大厂指针笔试题让你秒杀指针!!!MySQL 日期时间加减mysql 查询条件之外的数据_mysql 查询符合条件的数据查linux的操作系统版本,如何查看Linux操作系统版本?将String类型转换成Map数据类型使用uuid做MySQL主键,被老板,爆怼一顿C语言中的字符串函数和字符函数linux服务器中毒排查--基础篇C# ASCII码字符转换