JDK代理:
JDK动态代理其实也是基本接口实现的。因为通过接口指向实现类实例的多态方式,可以有效地将具体实现与调用解耦,便于后期的修改和维护。
- 创建"Car"接口:
package com.example.demo;
/**
* 定义Car接口
*/
public interface Car {
void whatCar();
}
2.创建"Mazda"类,实现接口"Car",并实现方法"whatCar":
package com.example.demo;
public class Mazda implements Car {
@Override
public void whatCar() {
System.out.println("I am Mazda");
}
}
3.创建一个动态代理类,需要实现InvocationHandler接口,代码中有详细注解:
package com.example.demo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 创建一个动态代理类,需要实现InvocationHandler接口
*/
public class CarInvocationHandler implements InvocationHandler{
//被代理对象 即真实对象
private Object target;
Object bind(Object target) {
this.target = target;
/* Proxy.newProxyInstance 参数解释:
* 第一个是类加载器,这里采用的是类本身的类加载器
* 第二个是把生成的动态代理对象下挂到哪些接口下,这里就是放在obj实现的接口下,在本文即Car接口
* 第三个是定义实现方法逻辑的代理类,哪个类的方法就将哪个类传进去
*/
return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
}
/**
* 代理方法:当我们使用了代理对象调度真实对象的方法后,它就会进入到invoke方法里面
* @param proxy 方法被调用的代理实例,被代理类
* @param method 当前调度对象
* @param args 用于方法调用的参数
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("----调用前处理");
//反射原有方法
Object invoke = method.invoke(target, args);
System.out.println("----调用后处理");
return invoke;
}
}
4.main方法进行测试:
public static void main(String[] args){
Mazda mazda = new Mazda();
CarInvocationHandler aih = new CarInvocationHandler();
//返回接口类型,类似与@Autowired
Car mazdaBind = (Car) aih.bind(mazda);
mazdaBind.whatCar();
}
当调用mazdaBind.whatCar()时,会进入到invoke()
这就是AOP实现的基本原理,只是Spring不需要开发人员自己维护。
5.输出结果:
CGLIB代理:
cglib动态代理通过实现子类的方式对目标类进行增强。
举个例子:
如果想知道谁是复仇者联盟(TheAvengers),就要找到尼克(AvengersMethodInterceptor),尼克再去找到英雄,让他告诉你他是哪个英雄。
1.创建"TheAvengers"类:
package com.example.demo;
public class TheAvengers {
public void whichHero(){
System.out.println("I am Iron Man");
}
}
2.创建"AvengersMethodInterceptor"类,实现MethodInterceptor接口,对被代理对象方法进行拦截:
package com.example.demo.cglib;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* cglib实现动态代理,对被代理对象方法进行拦截
*/
public class AvengersMethodInterceptor implements MethodInterceptor {
/*
* Object:cglib生成的代理对象
* Method:被代理对象的方法
* Object[]:方法参数
* MethodProxy:代理对象的方法
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("调用前");
Object obj = methodProxy.invokeSuper(o,objects); //invokeSuper:在指定的对象上调用原始(父类)方法。
System.out.println("调用后");
return obj;
}
}
3.创建"CGLIBTest"测试类:
package com.example.demo.cglib;
import org.springframework.cglib.proxy.Enhancer;
public class CGLIBTest {
public static void main(String[] args){
// 通过CGLIB动态代理获取代理对象的过程
Enhancer en = new Enhancer();
// 设置enhancer对象的父类
en.setSuperclass(TheAvengers.class);
// 设置enhancer的回调对象
en.setCallback(new AvengersMethodInterceptor());
// 创建代理对象
TheAvengers avengers = (TheAvengers)en.create();
// 通过代理对象调用目标方法
avengers.whichHero();
}
}
当通过代理对象调用目标方法(avengers.whichHero();)时,会进入到AvengersMethodInterceptor中的intercept方法。
4.结果如下:
大概流程
- 设置父类(目标类)、设置回调对象(方法拦截器),并生成代理类的字节码文件
- 使用ClassLoader将字节码文件加载到JVM
- 创建代理类实例对象,执行对象的目标方法
参考博客:
https://blog.csdn.net/yu_kang/article/details/88530016
https://www.cnblogs.com/godoforange/p/11587321.html