Spring原理 AOP XML版

于 2022-05-26 11:28:44 发布
阅读量71 收藏
点赞数
文章标签： spring 代理模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwqgood/article/details/124981404
版权

AOP原理

概念：面向切面编程

不通过修改源代码增加程序的功能

使用动态代理来实现

（1）有接口的动态代理（JDK动态代理）

类和代理类都是这个接口的实现类

用代理对象来增强方法

使用Proxy类来创建代理对象：

在这里插入图片描述

ClassLoader loader:类加载器

Class<?>[] interfaces:类实现的接口（一个类可以实现多个接口）

InvocationHandle h 需要实现这个接口来实现动态代理的具体逻辑

将源对象作为构造方法的参数传入，作为代理类的属性，实现里面的invoke方法，里面有个参数Method，用method.invoke(obj,args)来执行源方法，obj是被操作的对象，args是参数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-65SULSlr-1653534630054)(D:/%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/picture/pMdgbtz7QwlfYRq.png)]

生成代理对象的具体过程：

1.先去查找缓存中是否已经生成了这个代理对象，没有再去生成代理对象

2.获取包的完全限定名，加上%Proxy前缀，然后加上一个编号num，得到这个代理类的名称

3.然后我们需要创建代理对象的构造器，也就是要生成代理对象的字节码文件：

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                packAge + "." + className, new Class[]{IProducer.class}, Modifier.PUBLIC);

IProducer是我们为了创建代理对象而创建的接口

4.生成的字节码文件：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.vincent;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public class LinTest extends Proxy implements IProducer {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;
    private static Method m4;

    public LinTest(InvocationHandler var1) throws  {
        super(var1);
    }

    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);
        }
    }

    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);
        }
    }

    public final float preSale(float var1) throws  {
        try {
            return (Float)super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    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);
        }
    }

    public final float afterSale(float var1) throws  {
        try {
            return (Float)super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("IProducer").getMethod("preSale", Float.TYPE);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m4 = Class.forName("IProducer").getMethod("afterSale", Float.TYPE);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

我们所有的方法都被当成一个Method变量存储起来：

在这里插入图片描述

在静态代码块中赋予他含义：

在这里插入图片描述

然后对每个方法都执行相同的逻辑：执行父类字段中的InvocationHandler类的对象的invoke方法，连Object中的方法也不例外

在这里插入图片描述

原来的方法会作为参数传入invoke方法，也就是我们实现动态代理时需要实现的逻辑：

	Proxy.newProxyInstance(User.class.getClassLoader(), new Class[]{user.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        });

因而通过这样的字节码生成后，最终这个对象的所有方法都会去执行invoke方法，至于原来的方法是否执行，取决于invoke中的逻辑。

5.生成代理对象

在生成这个代理对象时候需要调用构造方法：

在这里插入图片描述

也就是需要我们传入InvocationHandler类的对象，在newProxyInstance方法中使用构造器生成代理对象后返回给我们，至此，代理对象就生成完成了

实例：（toString方法也会被代理）

interface userInterfacr{
    public int geta(int a);
}
class User implements userInterfacr{
    @Override
    public int geta(int a){
        return a+1;
    }
}
public class MyProxy {
    public static void main(String[] args) {
        userInterfacr proxy = (userInterfacr) Proxy.newProxyInstance(User.class.getClassLoader(), new Class[]{userInterfacr.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("proxy");
                return null;
            }
        });
        System.out.println(proxy.toString());
    }
}
（2）无接口的动态代理（CGLIB动态代理）

创建当前类的子类，子类调用父类的方法

 
com/example/demo/cglibtest/Dog$$EnhancerByCGLIB$$4e9e4388.class
 
 
 
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
 
package com.example.demo.cglibtest;
 
import java.lang.reflect.Method;
import org.springframework.cglib.core.ReflectUtils;
import org.springframework.cglib.core.Signature;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Factory;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
 
public class Dog$$EnhancerByCGLIB$$4e9e4388 extends Dog implements 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 MethodInterceptor CGLIB$CALLBACK_0;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$call$0$Method;
    private static final MethodProxy CGLIB$call$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$equals$1$Method;
    private static final MethodProxy CGLIB$equals$1$Proxy;
    private static final Method CGLIB$toString$2$Method;
    private static final MethodProxy CGLIB$toString$2$Proxy;
    private static final Method CGLIB$hashCode$3$Method;
    private static final MethodProxy CGLIB$hashCode$3$Proxy;
    private static final Method CGLIB$clone$4$Method;
    private static final MethodProxy CGLIB$clone$4$Proxy;
 
    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.example.demo.cglibtest.Dog$$EnhancerByCGLIB$$4e9e4388");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$1$Method = var10000[0];
        CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
        CGLIB$toString$2$Method = var10000[1];
        CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
        CGLIB$hashCode$3$Method = var10000[2];
        CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
        CGLIB$clone$4$Method = var10000[3];
        CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
        CGLIB$call$0$Method = ReflectUtils.findMethods(new String[]{"call", "()Ljava/lang/String;"}, (var1 = Class.forName("com.example.demo.cglibtest.Dog")).getDeclaredMethods())[0];
        CGLIB$call$0$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "call", "CGLIB$call$0");
    }
 
    final String CGLIB$call$0() {
        return super.call();
    }
 
    public final String call() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }
 
        return var10000 != null ? (String)var10000.intercept(this, CGLIB$call$0$Method, CGLIB$emptyArgs, CGLIB$call$0$Proxy) : super.call();
    }
 
    final boolean CGLIB$equals$1(Object var1) {
        return super.equals(var1);
    }
 
    public final boolean equals(Object var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }
 
        if (var10000 != null) {
            Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy);
            return var2 == null ? false : (Boolean)var2;
        } else {
            return super.equals(var1);
        }
    }
 
    final String CGLIB$toString$2() {
        return super.toString();
    }
 
    public final String toString() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }
 
        return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy) : super.toString();
    }
 
    final int CGLIB$hashCode$3() {
        return super.hashCode();
    }
 
    public final int hashCode() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }
 
        if (var10000 != null) {
            Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy);
            return var1 == null ? 0 : ((Number)var1).intValue();
        } else {
            return super.hashCode();
        }
    }
 
    final Object CGLIB$clone$4() throws CloneNotSupportedException {
        return super.clone();
    }
 
    protected final Object clone() throws CloneNotSupportedException {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }
 
        return var10000 != null ? var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy) : super.clone();
    }
 
    public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch(var10000.hashCode()) {
        case -508378822:
            if (var10000.equals("clone()Ljava/lang/Object;")) {
                return CGLIB$clone$4$Proxy;
            }
            break;
        case 371634473:
            if (var10000.equals("call()Ljava/lang/String;")) {
                return CGLIB$call$0$Proxy;
            }
            break;
        case 1826985398:
            if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                return CGLIB$equals$1$Proxy;
            }
            break;
        case 1913648695:
            if (var10000.equals("toString()Ljava/lang/String;")) {
                return CGLIB$toString$2$Proxy;
            }
            break;
        case 1984935277:
            if (var10000.equals("hashCode()I")) {
                return CGLIB$hashCode$3$Proxy;
            }
        }
 
        return null;
    }
 
    public Dog$$EnhancerByCGLIB$$4e9e4388() {
        CGLIB$BIND_CALLBACKS(this);
    }
 
    public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }
 
    public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
        CGLIB$STATIC_CALLBACKS = var0;
    }
 
    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        Dog$$EnhancerByCGLIB$$4e9e4388 var1 = (Dog$$EnhancerByCGLIB$$4e9e4388)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (CGLIB$STATIC_CALLBACKS == null) {
                    return;
                }
            }
 
            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }
 
    }
 
    public Object newInstance(Callback[] var1) {
        CGLIB$SET_THREAD_CALLBACKS(var1);
        Dog$$EnhancerByCGLIB$$4e9e4388 var10000 = new Dog$$EnhancerByCGLIB$$4e9e4388();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }
 
    public Object newInstance(Callback var1) {
        CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
        Dog$$EnhancerByCGLIB$$4e9e4388 var10000 = new Dog$$EnhancerByCGLIB$$4e9e4388();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }
 
    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        Dog$$EnhancerByCGLIB$$4e9e4388 var10000 = new Dog$$EnhancerByCGLIB$$4e9e4388;
        switch(var1.length) {
        case 0:
            var10000.<init>();
            CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
            return var10000;
        default:
            throw new IllegalArgumentException("Constructor not found");
        }
    }
 
    public Callback getCallback(int var1) {
        CGLIB$BIND_CALLBACKS(this);
        MethodInterceptor var10000;
        switch(var1) {
        case 0:
            var10000 = this.CGLIB$CALLBACK_0;
            break;
        default:
            var10000 = null;
        }
 
        return var10000;
    }
 
    public void setCallback(int var1, Callback var2) {
        switch(var1) {
        case 0:
            this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
        default:
        }
    }
 
    public Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[]{this.CGLIB$CALLBACK_0};
    }
 
    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
    }
 
    static {
        CGLIB$STATICHOOK1();
    }
}

CGLIB动态代理无需编写接口，是基于父子类来实现的，使用ASM字节码生成技术，运行效率比较高，然后在生成的字节码中，我们可以看到，他对比JDK动态代理生成了有一些默认值的操作，避免一些空指针异常：

equals会默认返回false，hashcode默认返回0

前置概念

连接点
可以被增强的方法
切入点
实际被真正增强的方法

通知(增强)

实际增加的代码逻辑就是通知
通知类型:
前置通知
后置通知
环绕通知
异常通知
最终通知

切面

将通知应用到切入点的过程
AspectJ和Spring一起使用的框架

切入点表达式:对哪些方法进行增强

execution(权限注释符 返回类型 类的全路径 方法名称 (参数列表))
返回类型可以不写

*com.demo.dao.BookDao.add(..)对add方法进行增强
*com.demo.dao.BookDao.*(..)对这个类的所有方法进行增强
*com.demo.dao.*.*(..)对dao里所有包进行增强
注解的执行顺序:

Around前面
Before
procceed()
afterReurn/afterThrowing
After
Around后面
需要在切片类上加上
@Aspect和@Component
方法上面的增强注解都有一个属性值值value="execution()"来指定增强的方法
也可以把公共切入点提取出来:
定义一个方法，加上注解@PointCut(value=“execution()”)
然后增强注解的value中，写上这个方法的名称即可(加上括号)

带有@Around注解的方法中，可以通过Signature signature = joinPoint.getSignature();方法获取方法的相关信息

需要开启代理以及配置扫描路径：

在这里插入图片描述

多个增强类可以设置优先级:

@Order(1)值约小，优先级越高
值大(优先级低)的会被值小(优先级高)的当成方法，包在proceed中执行
(值大的在外层，值小的在内层)

通过用xml配置文件代替注解：（不常用）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tZb8XgCS-1653534630059)(D:/%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/picture/image-20220421185202643.png)]
在这里插入图片描述

使用注解进行配置：

在这里插入图片描述

在yml中配置：
在这里插入图片描述
resource目录即为classpath目录

pskyfly
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值