基础知识
代理模式可以参考：
https://blog.youkuaiyun.com/coldstarry/article/details/120557445
讲解模式
什么是代理?
所谓代理,其实就是在访问实际对象时引入一定程度的间接性,因为这种间接性,就可以增加许多操作.
这通常需要代理和原有对象之间要有相同的行为.
举个小例子:
小时候都需要交班费,一般都是统一交给班长,再又班长交给老师,那班长其实就是学生的代理,因为班长和学生都有交班费的统一行为,同时,班长在将班费交给老师时,还可以进行一些额外的操作,比如说某某最近表现良好.这就是典型的代理.
代理的优点:
在不修改原代码的基础上，扩展和增强实现；
代码解耦，在代理中通过参数可以判断真实类，做出不同的响应或调用，灵活方便；
代理的分类:
主要分为静态代理和动态代理
动态代理目前又有两种主要的实现方式:jdk动态代理和cglib
静态代理
静态代理的最主要特征就是由程序员创建代理类,代理类在程序运行之前就已经确定生成.
举个小李子:
还是上面那个例子,班长代理学生去交班费
*** 创建一个公共接口 ***
//创建一个公共接口
public interface Person {
void submitMoney();
}
*** 创建学生类 ***
public class Student implements Person {
private String name;
public String getName() {
return name;
}
public Student(String name) {
this.name = name;
}
//交班费方法
public void submitMoney() {
System.out.println(name+"上交班费50元");
}
}
*** 创建学生代理类 ***
public class StudentProxys implements Person{
private Student student;
public StudentProxys(Student student) {
this.student = student;
}
public void submitMoney() {
System.out.println(student.getName()+"最近表现很好");
student.submitMoney();
}
}
*** 测试方法 **
public class test {
public static void main(String[] args) {
//创建学生对象
Student student = new Student("张三");
//创建代理对象
StudentProxys studentProxys = new StudentProxys(student);
//代理执行方法
studentProxys.submitMoney();
}
}
*** 输出结果 ***
张三最近表现很好
张三上交班费50元
优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展。
缺点：我们得为每一个服务都得创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。可以用动态代理解决这些问题
动态代理
动态代理的最大区别就是,在实现阶段不用关心代理类,代理类不是程序员写的,而是在运行时根据我们的"指示"动态生成的.
动态代理的实现方式通常有两种:jdk动态代理和cglib代理
原理
（1）JDK动态代理：会生成一个代理类，这个代理类实现了被代理类上的所有接口，代理类的每个方法都是空壳方法，在方法内部调用invoke方法来执行实际操作，类似于请求转发。
利用拦截器（必须实现InvocationHandler）加上反射机制生成一个代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理,代理类的父类是Proxy，继承接口
（2）Cglib动态代理：同样会生成一个代理类，这个代理类继承被代理类，并且重写被代理类的方法（不能是final修饰的方法，这也是Cglib不同通用的原因之一），代理类的每个方法都是空壳方法，在方法内部调用invoke方法来执行实际操作。
利用ASM框架，对代理对象类生成的class文件加载进来，通过修改其字节码生成子类来处理
Spring如何选择是用JDK还是cglib？
1、当bean实现接口时，会用JDK代理模式
2、当bean没有实现接口，用cglib实现
3、可以强制使用cglib（在spring配置中加入<aop:aspectj-autoproxy proxyt-target-class=”true”/>）
实现举例:
接口Bird
interface Bird{ // 我们想要代理的接口类，大鸟
void fly();
}
2.接口的实现类HuangLi
class HuangLi implements Bird{
@Override
public final void fly() {
System.out.println("黄鹂fly()...");
}
public void sound(){
System.out.println("黄鹂sound()...");
}
}
方法的执行处理器 JdkProxyHuangLiInvocation
public class JdkProxyHuangLiInvocation implements InvocationHandler {
private Object target;
public JdkProxyHuangLiInvocation(Object target){
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 我们需要增强的功能
System.out.println("doBefore...");
Object result = method.invoke(target, args);
System.out.println("doAfter..");
return result;
}
}
1.4 主类 MyJdkDynamicProxy
public class MyJdkDynamicProxy {
public static void main(String[] args) {
// 让jdk把生成的jdk动态代理类保存到文件中
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles",true);
// 1. JDK动态代理
HuangLi huangLi = new HuangLi(); // 需要被代理的对象
// JDK动态代理， 只能代理某个接口,但可以代理final修饰的方法
Bird huangLiProxy = (Bird)Proxy.newProxyInstance(huangLi.getClass().getClassLoader(),
huangLi.getClass().getInterfaces(), new JdkProxyHuangLiInvocation(huangLi));
huangLiProxy.fly();
// huangLiProxy.sound();
// 2. cglib动态代理
// 继承HuangLi这个类的同时，实现了HuangLi这个类实现的接口
// 由于cglib 是通过继承重写父类的方法实现的，所以代理不了被final修饰的方法
// 如果调用fianl方法将直接调用被代理对象的方法，而不走代理逻辑
// Cglib动态代理,
// HuangLi cglibProxy = (HuangLi) Enhancer.create(huangLi.getClass(), huangLi.getClass().getInterfaces(), new InvocationHandler() {
// @Override
// public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
// System.out.println("doBefore...");
// Object result = method.invoke(huangLi, args);
// System.out.println("doAfter..");
// return result;
// }
// });
// cglibProxy.fly();
// cglibProxy.sound();
}
}
注意事项及分析
在使用动态代理的时候会有一些限制,比如说,不能对private,static方法进行代理.这里进行一个小总结,并继续简单分析.
×即表示不可代理
√表示可以代理
为什么cglib不能代理private,final,static方法?
因为cglib代理类是通过继承被代理类实现的,如果方法被private修饰,那么子类是无法调用超类的私有方法的;如果被final修饰,那也就无法重写需要代理的方法,也是不行的; 如果被static修饰,从技术的角度是可以实现的,但是被排除了,因为从程序的设计角度来讲,静态方法是属于类的,而不是属于某个对象的.
为什么jdk动态代理不能代理private,static方法,而可以代理final方法?
在jdk动态代理中,代理类和被代理类需要实现共同的接口,去有相同的行为,那么private,static方法都是无法修饰接口方法的,也就自然行不通了.
那final也无法修饰接口方法,为什么可以呢?这是因为我们可以将子类的方法修改成final修饰的,并且这个操作并不改变这种重写关系.
所自动生成的代理类
JDK动态代理所生成字节码
// 继承Proxy，同时实现Bird接口
final class $Proxy0 extends Proxy implements Bird {
// 会被调用的Method对象
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
// 将 执行处理器传给父类Proxy的h属性
super(var1);
}
// 空壳方法，转发到invocationHandler.invoke方法
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);
}
}
// 空壳方法，转发到invocationHandler.invoke方法
public final void fly() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
// 空壳方法，转发到invocationHandler.invoke方法
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);
}
}
// 空壳方法，转发到invocationHandler.invoke方法
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 {
// jdk通过反射可以确定我们需要用到哪些方法，然后拿到对应的Method对象
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m3 = Class.forName("com.anhui.service.demo.proxy.Bird").getMethod("fly");
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());
}
}
}
Cglib动态代理
public class HuangLi$$EnhancerByCGLIB$$fdee7116 extends HuangLi implements Bird, Factory {
private boolean CGLIB$BOUND;
public static Object CGLIB$FACTORY_DATA;
private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
private static final Callback[] CGLIB$STATIC_CALLBACKS;
private InvocationHandler CGLIB$CALLBACK_0;
private static Object CGLIB$CALLBACK_FILTER;
private static final Method CGLIB$sound$0;
private static final Method CGLIB$equals$1;
private static final Method CGLIB$toString$2;
private static final Method CGLIB$hashCode$3;
private static final Method CGLIB$clone$4;
static void CGLIB$STATICHOOK1() {
CGLIB$THREAD_CALLBACKS = new ThreadLocal();
CGLIB$sound$0 = Class.forName("com.anhui.service.demo.proxy.HuangLi").getDeclaredMethod("sound");
CGLIB$equals$1 = Class.forName("java.lang.Object").getDeclaredMethod("equals", Class.forName("java.lang.Object"));
CGLIB$toString$2 = Class.forName("java.lang.Object").getDeclaredMethod("toString");
CGLIB$hashCode$3 = Class.forName("java.lang.Object").getDeclaredMethod("hashCode");
CGLIB$clone$4 = Class.forName("java.lang.Object").getDeclaredMethod("clone");
}
// sound方法被以重写的方式代理了
// 而 fly方法被final修饰了，无法被代理=》调用代理对象的 fly()方法将不会走代理逻辑
public final void sound() {
try {
InvocationHandler var10000 = this.CGLIB$CALLBACK_0;
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
var10000.invoke(this, CGLIB$sound$0, new Object[0]);
} catch (Error | RuntimeException var1) {
throw var1;
} catch (Throwable var2) {
throw new UndeclaredThrowableException(var2);
}
}
}
aop原理
其实就是通过代理实现.
在我们使用过程中会配置一个切面,和一个切点,切点中会配置一个路径,比如是* com.wind.Controller..(…).那么在spring进行容器注入的时候,就会将该路径下(Controller)的代理对象注入到容器当中,也就是存储在singleonObject(单例对象存储空间),一个concurrentHashMap中,
在我们注入对象的时候得到的就直接是代理对象,在执行代理对象的时候就可以做一些操作,前置处理,后置处理这些.
参考文章：
https://blog.youkuaiyun.com/wangliangluang/article/details/127337332
https://blog.youkuaiyun.com/qq_29012499/article/details/128113016
https://blog.youkuaiyun.com/cleble/article/details/127762440
扫一扫
2930
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
