Spring AOP是基于动态代理设计模式实现的，相对的就有静态代理
动态代理和静态代理
静态代理
对于静态代理，一个代理类只能代理一个对象，如果有多个对象需要被代理，就需要多个代理类。
1.接口
public interface Animail {
void eat();
}
2.委托类
public class Bird implements Animail{
@Override
public void eat() {
System.out.println("bird eat eat eat");
}
}
3.代理类
public class BirdProxy implements Animail{
private Animail bird;
public BirdProxy(Animail bird) {
this.bird = bird;
}
@Override
public void eat() {
System.out.println("代理前");
bird.eat();
System.out.println("代理后");
}
}
4.测试类
public class Main {
public static void main(String[] args) {
Animail bird = new Bird();
Animail birdProxy = new BirdProxy(bird);
birdProxy.eat();
}
}
这边代理和实现类需要实现同一个接口或者继承同一个类，原因：如果A用户传入具体实现类，后续后端如果要代理该对象，则前端需要传入新的代理类对象，失去了代理设计模式的核心。反之，如果A用户传入的对象实现了接口或者继承了某个类，A用户无需重新传入新的代理对象，后端基于接口或父类实现动态代理。
代理模式：
![]()
image.png
image.png
动态代理
JDK动态代理
1. 接口
public interface Person {
void say();
}
2.委托类
public class Boy implements Person {
@Override
public void say() {
System.out.println("boy say say say");
}
}
3.代理配置类
public class PersonInvocationHandler implements InvocationHandler {
/**
* 被代理类
*/
private Object target;
/**
* 生成代理类
*
* @param target
* @return
*/
public Object buildProxyObject(Object target) {
this.target = target;
//该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
//第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
//第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口
//第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法
//根据传入的目标返回一个代理对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("调用前");
Object result = method.invoke(target, args);
System.out.println("调用后");
return result;
}
}
4.测试类
public class Main {
public static void main(String[] args) {
Boy boy = new Boy();
PersonInvocationHandler personInvocationHandler = new PersonInvocationHandler();
Person proxy = (Person) personInvocationHandler.buildProxyObject(boy);
proxy.say();
}
}
控制台输出正常，但是当我打断点后发现控制台重复输出我invoke方法中的方法，如下图
image.png
image.png
原因是因为在IDEA debug模式下，会调用委托类的toString()方法，但是此时委托类已被代理，所以会执行代理类中的invoke()方法。我重写委托类的toString()方法验证了这个结论。参考：https://stackoverflow.com/questions/42972312/intellij-idea-debug-enter-method-multiple-times
image.png
CGLIB动态代理
1. 委托类
public class Cat {
public void cry() {
System.out.println("猫叫了~~~");
}
}
2.委托类拦截器
public class CatInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("调用前处理");
Object invokeSuper = methodProxy.invokeSuper(o, objects);
System.out.println("调用后处理");
return invokeSuper;
}
}
3.测试方法
public class Main {
public static void main(String[] args) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Cat.class);
enhancer.setCallback(new CatInterceptor());
Cat proxy = (Cat) enhancer.create();
proxy.cry();
}
}
核心代码
protected Object create(Object key) {
try {
ClassLoader loader = this.getClassLoader();
Map<ClassLoader, AbstractClassGenerator.ClassLoaderData> cache = CACHE;
AbstractClassGenerator.ClassLoaderData data = (AbstractClassGenerator.ClassLoaderData)cache.get(loader);
if (data == null) {
Class var5 = AbstractClassGenerator.class;
synchronized(AbstractClassGenerator.class) {
cache = CACHE;
data = (AbstractClassGenerator.ClassLoaderData)cache.get(loader);
if (data == null) {
Map<ClassLoader, AbstractClassGenerator.ClassLoaderData> newCache = new WeakHashMap(cache);
data = new AbstractClassGenerator.ClassLoaderData(loader);
newCache.put(loader, data);
CACHE = newCache;
}
}
}
this.key = key;
Object obj = data.get(this, this.getUseCache());
return obj instanceof Class ? this.firstInstance((Class)obj) : this.nextInstance(obj);
} catch (Error | RuntimeException var9) {
throw var9;
} catch (Exception var10) {
throw new CodeGenerationException(var10);
}
}
这边就不做演示了
