Spring5学习笔记（三、AOP开发）

最新推荐文章于 2023-04-27 10:59:00 发布
原创 最新推荐文章于 2023-04-27 10:59:00 发布 · 785 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #java

文章目录

静态代理设计模式

为什么需要代理设计模式?

问题

  • 在JavaEE分层开发中，哪个层次对于我们来讲最重要？
    DAO --> Service --> Controller
    JavaEE分层开发中，最为重要的是Service层。

  • Service层中包含了哪些代码？
    Service层 = 核心功能（几十上百行代码） + 额外功能（附加功能）
    核心功能：业务运算、DAO调用
    额外功能：不属于业务、可有可无、代码量很小（如事务、日志、性能、…）
    在这里插入图片描述

  • 额外功能书写在Service层中好不好？
    Service层的调用者的角度（Controller）：需要在Service层书写额外功能（事务）。
    软件设计者的角度：Service层不需要额外功能，因为不好维护。

  • 现实中的问题和解决办法：
    租房场景
    在这里插入图片描述
    租房场景改造
    在这里插入图片描述

代理设计模式

概念

通过代理类，为原始类(目标)增加额外的功能。
好处：利于原始类(目标)的维护。

名词解释

  1. 目标类(原始类)：指的是业务类（核心功能 --> 业务运算、DAO调用）
  2. 目标方法(原始方法)：目标类(原始类)中的方法就是目标方法（原始方法）。
  3. 额外功能(附加功能)：日志、事务、性能、…

代理开发的核心要素

代理类 = 目标类(原始类) + 额外功能 + 原始类(目标类)实现相同的接口（为了与目标类(原始类)的方法保持一致）

编码

在这里插入图片描述
静态代理：为每一个原始类，手动创建一个代理类（.java .class）

//代理类实现与原始类相同的接口，保证方法一致
public class UserServiceProxy implements UserService {
    //原始类
    private UserServiceImpl userService = new UserServiceImpl();

    @Override
    public void register(User user) {
        //额外功能
        System.out.println("-----log-----");
        //调用原始类中的方法
        userService.register(user);
    }

    @Override
    public boolean login(String name, String password) {
        //额外功能
        System.out.println("-----log-----");
        //调用原始类中的方法
        return userService.login(name, password);
    }
}

对于每个Service原始类都需要一个对应的代理类，代码冗余。

静态代理存在的问题

  1. 代理类文件数量过多，不利于项目的管理。
    UserServiceImpl --> UserServiceProxy
    OrderServiceImpl --> OrderServiceProxy
    …
  2. 额外功能维护性差
    代理类中，额外功能修改复杂（麻烦）。一百个就需要修改一百次。

Sring的动态代理开发

Spring动态代理的概念

概念：通过代理类，为原始类(目标)增加额外的功能。
好处：利于原始类(目标)的维护。

搭建开发环境

引入jar包

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.1.14.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.8.9</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.9</version>
    <scope>runtime</scope>
</dependency>

Spring动态代理的开发步骤

  1. 创建原始对象（目标对象）

    public class UserServiceImpl implements UserService {
    @Override
    public void register(User user) {
        //核心功能
        System.out.println("UserServiceImpl.register （业务运算+DAO调用）");
    }

    @Override
    public boolean login(String name, String password) {
        //核心功能
        System.out.println("UserServiceImpl.login");
        return true;
    }
}

    <bean id="userService" class="com.angenin.proxy.UserServiceImpl"/>

  2. 额外功能
    Spring提供了MethodBeforeAdvice接口，我们需要把额外功能书写在此接口的实现类的before方法中，这个实现类的before方法会在原始方法执行前先执行。

    public class Before implements MethodBeforeAdvice {
    //书写运行在原始方法之前的额外功能
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        //额外功能
        System.out.println("Before...before...");
    }
}

    <bean id="before" class="com.angenin.dynamic.Before"/>

  3. 定义切入点
    切入点：额外功能加入的位置。
    目的：由程序员根据自己的需要，决定额外功能加入给哪个原始方法。
    简单的测试：所有方法都作为切入点，都加入额外功能。

    <!--配置aop-->
<aop:config>
    <!--配置切入点，id可任意起，expression：切入点表达式，这里代表所有的方法-->
    <aop:pointcut id="pc" expression="execution(* *(..))"/>
</aop:config>

  4. 组装（2和3的整合）

    <!--配置aop-->
<aop:config>
    <!--配置切入点，id可任意起，expression：切入点表达式，这里代表所有的方法-->
    <aop:pointcut id="pc" expression="execution(* *(..))"/>
    <!--组装：把额外功能和切入点进行整合，advice-ref：额外功能，pointcut-ref：切入点-->
    <!--切入点包含的所有方法执行前都会先执行before的额外功能-->
    <aop:advisor advice-ref="before" pointcut-ref="pc"/>
</aop:config>

  5. 调用
    获得Spring工厂创建的动态代理对象，并进行调用。此时，通过原始对象的id值获得的就是代理对象，生成的对象用原始类的接口类型进行接收。
    在这里插入图片描述
    在这里插入图片描述
    打断点debug后可以看到获得的userService对象为代理对象。

动态代理细节分析

  1. Spring创建的动态代理类在哪里？
    Spring框架在运行时，通过动态字节码技术，在JVM创建的，运行在JVM内部，等程序结束后，会和JVM一起消失。

    什么叫动态字节码技术？
    通过第三方动态字节码框架，在JVM中创建对应类的字节码，进而创建对象，当虛拟机结束，动态字节码跟着消失。
    在这里插入图片描述
    结论：动态代理不需要定义类文件，都是JⅥM运行过程中动态创建的，所以不会造成静态代理，类文件数量过多，影晌项目管理的问题。

  2. 动态代理编程简化代理的开发。
    在额外功能不改变的前提下，创建其他目标类(原始类)的代理对象时，只需要指定原始(目标)对象即可。

  3. 动态代理额外功能的维护性大大增强。

Spring动态代理详解

额外功能的详解

MethodBeforeAdvice分析

  1. MethodBeforeAdvice接口的作用：额外功能运行在原始方法执行之前，进行额外功能操作。
    public class Before implements MethodBeforeAdvice {
    /*
        作用：书写运行在原始方法之前的额外功能

        参数：
            Method：额外功能所增加给的那个原始方法（如：login方法、register方法）
            Object[]：额外功能所增加给的那个原始方法的参数（如login方法的String name, String password）
            Object：额外功能所增加给的那个原始对象（如UserServiceImpl）
     */
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        //额外功能
        System.out.println("Before...before...");
    }
}
  2. before方法的3个参数在实战中，该如何使用？
    before方法的参数，在实战中，会根据需要进行使用，不一定都会用到，也有可能都不用，实战开发中before的三个参数用得比较少。

MethodInterceptor（方法拦截器）

MethodBeforeAdvice --> 运行在原始方法之前
MethodInterceptor接口：额外功能可以根据需要运行在原始方法执行前、后、前后以及原始方法执行出现异常时执行，MethodInterceptor接口功能比MethodBeforeAdvice接口更加强大，所以更推荐使用MethodInterceptor接口。

//这里的MethodInterceptor是aop包下的那个
public class Around implements MethodInterceptor {
    /*
        invoke方法的作用：额外功能书写在invoke
              额外功能执行的时机   1. 原始方法之前
                                2. 原始方法之后
                                3. 原始方法之前 和 之后
                                4. 原始方法执行异常时
       调用参数methodInvocation的proceed()方法，可以让原始方法执行，所以我们可以在执行前写额外功能，也可以在之后写，或者都写
        参数：
            methodInvocation：额外功能所增加给的那个原始方法
        返回值：
            Object：原始方法执行后的返回值
     */
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        //额外功能1
        System.out.println("额外功能在原始方法执行前执行-------");
        //原始方法
        Object ret = methodInvocation.proceed();
        //额外功能2
        //System.out.println("额外功能在原始方法执行后执行-------");
		//返回的是原始方法执行后的返回值
        return ret;
    }
}

   <bean id="around" class="com.angenin.dynamic.Around"/>

   <!--配置aop-->
   <aop:config>
       <!--配置切入点，id可任意起，expression：切入点表达式，这里代表所有的方法-->
       <aop:pointcut id="pc" expression="execution(* *(..))"/>
       <!--组装：把额外功能和切入点进行整合，advice-ref：额外功能，pointcut-ref：切入点-->
       <aop:advisor advice-ref="around" pointcut-ref="pc"/>
   </aop:config>

什么的额外功能需要在原始方法运行的前后都运行呢？事务等。

  • 额外功能运行在原始方法抛出异常时

    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        //额外功能1
        //System.out.println("额外功能在原始方法执行前执行-------");
        Object ret = null;
        try {
            //原始方法
            ret = methodInvocation.proceed();
        } catch (Throwable throwable) {
            System.out.println("额外功能在原始方法抛出异常时执行-------");
            throwable.printStackTrace();
        }
        //额外功能2
        //System.out.println("额外功能在原始方法执行后执行-------");
        return ret;
    }

    具体额外功能执行的时机，需要按照需求进行合理的安排。

  • MethodInterceptor影响原始方法的返回值

    原始方法的返回值，直接作为invoke方法的返回值返回，MethodInterceptor不会影响原始方法的返回值。
    不返回原始方法的返回值，就会影响到结果。

    @Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
    Object ret = methodInvocation.proceed();
	//return 1;
    return false;
}

切入点详解

切入点决定额外功能加入的位置（这里的位置指的是方法，切入哪些方法）。
<aop:pointcut id="pc" expression="execution(* *(..))"/>

execution(* *(..))：匹配了所有方法
execution()：切入点函数
* *(..)

切入点表达式

1. 方法切入点表达式

在这里插入图片描述

* *(..) --> 所有方法

* --> 修饰符 返回值
* --> 方法名
() --> 参数表
.. --> 对参数没有要求（参数有没有、有几个、什么类型都行）
  • 定义名为login的方法作为切入点：
    * login(..)
  • 定义名为login并且有两个字符串类型参数的方法作为切入点：
    * login(String,String)
注意：
	非java.lang包中的类型，必须写全限定类名
	如：* register(com.angenin.proxy.User)
	..可以和具体的参数类型连用
	如：* login(String,..)
	第一个参数为String类型的login方法
  • 精准方法切入点限定
    上面所讲解的方法切入点表达式不精准。
    如下图，不能精准到a包下的UserServiceImpl的第一个login方法。
    在这里插入图片描述
    精准切入
    在这里插入图片描述
    修饰符/返回值		包.类.方法(参数)
	*			com.baizhiedu.a.UserServiceImpl.login(String,String)
精准到a包下的UserServiceImpl的第一个login方法
2. 类切入点表达式

指定特定类作为切入点(额外功能加入的位置)，自然这个类中的所有方法，都会加上对应的额外功能。
在这里插入图片描述

  • 语法一
    a包下UserServiceImpl类中的所有方法都加入额外功能
* com.baizhiedu.a.UserServiceImpl.*(..)
  • 语法二
    忽略包
1. 类只存在一级包 com.UserServiceImpl
* *.UserServiceImpl.*(..)

2. 类存在多级包 com.baizhiedu.a.UserServiceImpl
* *..UserServiceImpl.*(..)
3. 包切入点表达式

指定包作为额外功能加入的位置，自然包中的所有类及其方法都会加入额外的功能。

  • 语法一
    切入点包中的所有类，下面这条表达式包括的类必须在proxy包中，即使在proxy的子包中也无法生效。
* com.baizhiedu.proxy.*.*(..)
  • 语法二
    切入点当前包及其子包都生效（多加一个点）
* com.baizhiedu.proxy..*.*(..)
    包切入点在实战中使用得更多，把相加额外功能的类放到同个包下即可。

切入点函数

切入点函数：用于执行切入点表达式。

  1. execution
    最为重要的切入点函数，功能最全。
    可以执行方法切入点表达式、类切入点表达式、包切入点表达式。

    弊端：execution执行切入点表达式，书写麻烦。
    注意：其他的切入点函数只是简化了execution书写的复杂度，在功能上完全一致。

  2. args
    作用：主要用于函数(方法)参数的匹配，关注点在于参数，忽略包、类和方法名。

    如：切入点为方法参数必须得是2个字符串类型的参数。

execution(* *(String,String))
替换后
args(String,String)

  3. within
    作用：主要用于进行类、包切入点表达式的匹配，关注点在于包名、类名，忽略方法名和参数。

    如：切入点为UserServiceImpl类。

execution(* *..UserServiceImpl.*(..))
替换后
within(*..UserServiceImpl)

如：切入点为proxy包下及其子包的所有类

execution(* com.baizhiedu.proxy..*.*(..))
替换后
within(com.baizhiedu.proxy..*)

  4. @annotation
    作用：为具有特殊注解的方法加入额外功能。

    自定义一个Log注解。

    @Target(ElementType.METHOD) //决定在什么位置起作用（这里是在方法上起作用）
@Retention(RetentionPolicy.RUNTIME) //决定在什么时候起作用（这里在运行时起作用）
public @interface Log {}

    为UserServiceImpl类的register方法加上@Log注解。

    <aop:config>
	<!--@annotation括号里为注解的全限定类名-->
    <aop:pointcut id="pc" expression="@annotation(com.angenin.proxy.Log)"/>
    <aop:advisor advice-ref="around" pointcut-ref="pc"/>
</aop:config>
切入点函数的逻辑运算

指的是 整合多个切入点函数一起配合工作，进而完成更为复杂的需求。

  • and 与操作

    案例：方法名为login，并且参数为2个字符串。

execution(* login(String,String))
替换后
execution(* login(..)) and args(String,String)

注意：与操作不能用于同种类型的切入点函数，因为and需要同时满足。
如：login方法和register方法都作为切入点（这样写是错误的，可以换成or）
execution(* login(..)) and execution(* register(..))

  • or 或操作

    案例：login方法和register方法都作为切入点

execution(* login(..)) or execution(* register(..))

AOP开发

AOP的概念

  • AOP（Aspect Oriented Programing）面向切面编程 = Spring动态代理开发
    以切面为基本单位的程序开发，通过切面间的彼此协同，相互调用，完成程序的构建。
    切面 = 切入点 + 额外功能

  • OOP（Object Oritened Programing）面向对象编程 Java
    以对象为基本单位的程序开发，通过对象间的彼此协同，相互调用，完成程序的构建。

  • POP（Procedure Oriented Programing）面向过程(方法、函数)编程 C语言
    以过程为基本单位的程序开发，通过过程间的彼此协同，相互调用，完成程序的构建。

AOP的概念：

  • 本质就是Spring的动态代理开发，通过代理类为原始类增加额外功能。
  • 好处：利于原始类的维护。
  • 注意：AOP是基于OOP的，所以AOP不可能取代OOP，AOP是OOP为了解耦而做的补充。

AOP的开发步骤

  1. 原始对象
  2. 额外功能（MethodInterceptor）
  3. 切入点
  4. 组装切面（额外功能 + 切入点）

切面的名词解释

切面 = 切入点 + 额外功能

几何学
	面 = 点 + 形同的性质

在这里插入图片描述

AOP的底层实现原理

核心问题

  1. AOP如何创建动态代理类？（动态字节码技术）
  2. Spring工厂如何加工创建代理对象？为什么通过原始对象的id值，获得的是代理对象？

动态代理类的创建

1. JDK的动态代理

Proxy.newProxyInstance方法参数详解
在这里插入图片描述
在这里插入图片描述

关于类加载器:
首先得了解类加载器的作用，及其对象生成的过程。
在这里插入图片描述
根据老师讲的内容画的图，如果画得不对不好，麻烦各位请指出来。
在这里插入图片描述>在这里插入图片描述
因为代理类没有字节码文件，所以JVM没有给它生成它的类加载器，需要借用其他类的类加载器，所以Proxy.newProxyInstance的第一个参数为其他类的类加载器（原始类或者其他类都可以）。

在这里插入图片描述

  1. 原始对象直接创建。
  2. 额外功能由InvocationHandler接口的invoke方法解决。
  3. 相同接口由原始对象获取其Class，再获取其实现的接口。

InvocationHandler的invoke与MethodInterceptor的invoke对比：
在这里插入图片描述
代码实现

public class TestJdkProxy {
    public static void main(String[] args) {
        //代理创建3要素：1.原始对象；2.额外功能；3.代理对象和原始对象实现相同的接口。

        // 1.创建原始对象
        UserServiceImpl userService = new UserServiceImpl();

        // 2.JDK创建动态代理

        //这里为了下面来起来整洁一点，单独拿开，平时用匿名内部类即可
        InvocationHandler handler = new InvocationHandler() {
            /*
            InvocationHandler的invoke方法：
                作用：用于书写额外功能，额外功能运行在原始方法执行前、后、前后、抛出异常
                参数：
                    proxy：忽略即可，代表的是代理对象
                    method：原始方法（增加额外功能的那个原始方法）
                    args：原始方法的参数

                method.invoke方法：执行原始方法，返回原始方法执行后的结果，
                    第一个参数为原始对象
                    第二个参数为原始方法的参数
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("----proxy  log-----");
                //传入原始对象和原始方法的参数
                //这里需要注意，内部类使用外部类的变量时，外部类的变量需要用final来修饰
                Object ret = method.invoke(userService, args);
                //返回原始方法执行后的结果
                return ret;
            }
        };
        /*
            第一个参数为借用的类加载器（任意类都可以）
            第二个参数为原始类实现的接口，通过获取原始对象的class再获取接口（userService.getClass().getInterfaces()）
            第三个参数为InvocationHandler接口，在此接口的invoke方法中书写额外功能
         */
        UserService userServiceProxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(),
                                userService.getClass().getInterfaces(), handler);

        //因为InvocationHandler接口是一个函数式接口，所以可以使用Lambda表达式，代码变得更加简洁（因为main方法的参数同样为args，所以需要改一下）
//        UserService userServiceProxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(),
//                userService.getClass().getInterfaces(), (proxy, method, argss) -> {
//                    System.out.println("----log-----");
//                    return method.invoke(userService, argss);
//                });
        
        userServiceProxy.login("angenin", "123456");
        userServiceProxy.register(new User());
    }
}
2. CGlib的动态代理

CGlib创建动态代理的原理：父子继承创建代理对象，原始类作为父类，代理类作为子类，这样既可以保证二者方法一致，同时在代理类中提供新的实现（额外功能 + 原始方法）。

在这里插入图片描述
在这里插入图片描述
CGlib编码实现

public class TestCglib {
    public static void main(String[] args) {
        // 1.创建原始对象
        UserService userService = new UserService();

        /*
           2. 通过Cglib方式创建动态代理对象

            JDK动态代理：Proxy.newProxyInstance(classloader,interface,invocationhandler)
            Cglib动态代理：
                设置类加载器： Enhancer.setClassloader()   --> 同样，借用任意一个类的类加载器
                设置父类：    Enhancer.setSuperClass()
                设置额外功能： Enhancer.setCallback()  --> 实现接口MethodInterceptor
                Enhancer.create() ---> 创建代理
         */
        Enhancer enhancer = new Enhancer();
        //设置类加载器
        enhancer.setClassLoader(userService.getClass().getClassLoader());
        //设置父类
        enhancer.setSuperclass(userService.getClass());
        //这里的MethodInterceptor接口是spring的cglib包下的那个
        //可以用匿名内部类，这里只是为了看起来简洁
        MethodInterceptor interceptor = new MethodInterceptor() {
            //这里的intercept方法 等同于 InvocationHandler的invoke方法
            @Override
            public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("------cglib  log------");
                //这里调用method的invoke和前面的JDK动态代理一样
                Object ret = method.invoke(userService, args);
                return ret;
            }
        };
        //设置额外功能
        enhancer.setCallback(interceptor);

        //创建代理
        UserService userServiceProxy  = (UserService) enhancer.create();
        userServiceProxy.login("angenin", "123456");
        userServiceProxy.register(new User());
    }
}
总结
1. JDK动态代理	Proxy.newProxyInstance()	通过接口创建代理的实现类
2. Cglib动态代理	Enhancer					通过继承父类创建的代理类

代理都是为了面向切面服务的。

Spring工厂如何加工原始对象

思路分析
在这里插入图片描述
BeanPostProcessor在上一篇文章里讲到。

编码实现：

  1. 实现 BeanPostProcessor 进行加工
    public class ProxyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        //返回生成的理对象
        return Proxy.newProxyInstance(bean.getClass().getClassLoader(), bean.getClass().getInterfaces(), (proxy, method, args) -> {
            System.out.println("----new log-----");
            //返回原始类的执行结果
            return method.invoke(bean, args);
        });
    }
}
  2. 配置文件中对 BeanPostProcessor 进行配置
    <bean id="userService" class="com.angenin.factory.UserServiceImpl"/>

<bean id="proxyBeanPostProcessor" class="com.angenin.factory.ProxyBeanPostProcessor"/>
  3. 测试
    public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext4.xml");
        UserService userService = (UserService) ctx.getBean("userService");
        userService.login("angenin", "123456");
        userService.register(new User());
    }
}

基于注解的AOP开发

基于注解的AOP开发步骤

  1. 原始对象
    public class UserServiceImpl implements UserService {

    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register （业务运算+DAO调用）");
    }

    @Override
    public boolean login(String name, String password) {
        System.out.println("UserServiceImpl.login");
        return true;
    }
}
  2. 切面类（额外功能 + 切入点 + 组装）
    /*
    1. 原版的额外功能
        public class MyAround implements MethodInterceptor {
            public Object invoke(MethodInvocation invocation) {
                return invocation.proceed();
            }
        }

    2. 切入点
        <aop:config
            <aop:pointcut id="" expression="execution(* login(..))"/>
 */

@Aspect //加上@Aspect注解代表这个类是切面类
public class MyAspect {
    //加上@Around注解后，此时的 around方法 相当于 MethodInterceptor接口的invoke方法
    //方法名和任意起，这里的参数 ProceedingJoinPoint 对应 原先的参数 MethodInvocation
    @Around("execution(* login(..))")   //对应aop:pointcut标签
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("----log-----");
        Object ret = joinPoint.proceed();
        return ret;
    }
}

    <bean id="userService" class="com.angenin.aspect.UserServiceImpl"/>
<!-- 切面类：额外功能 + 切入点 -->
<bean id="around" class="com.angenin.aspect.MyAspect"/>
<!-- 告知Spring基于注解进行AOP开发 -->
<aop:aspectj-autoproxy/>
  3. 测试
    public class TestAspectProxy {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext4.xml");
        UserService userService = (UserService) ctx.getBean("userService");
        userService.login("angenin", "123456");
        userService.register(new User());
    }
}

细节

1. 切入点复用

切入点复用：在切面类中定义一个空方法，在其上面加上@Pointcut注解，通过这种方式定义切入点表达式，后续更加有利于切入点的复用。

@Aspect
public class MyAspect {
    //创建空方法，提取出切入点表达式
    @Pointcut("execution(* login(..))")
    public void myPointcut(){}

    @Around(value = "myPointcut()")   //引用空方法的切入点函数
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("----log-----");
        Object ret = joinPoint.proceed();
        return ret;
    }

    @Around("myPointcut()")   //引用空方法的切入点表达式
    public Object around2(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("----tx-----");
        Object ret = joinPoint.proceed();
        return ret;
    }
}

2. 动态代理的创建方式

AOP底层实现的2种代理创建方式：

  1. JDK：通过实现接口，做新的实现类方式，创建代理对象。
  2. Cglib：通过继承父类，做新的子类，创建代理对象。

在这里插入图片描述
默认情况下，AOP底层应用JDK动态代理创建的方式。

切换为Cglib：

  1. 基于注解AOP开发
    只需要在aop:aspectj-autoproxy标签中加入proxy-target-class="true"即可。
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    在这里插入图片描述
  2. 传统的AOP开发
    在aop:config标签上加上proxy-target-class="true"即可，只是加的位置不同而已，属性都是同一个。
    <aop:config proxy-target-class="true">
...
</aop:config>

AOP开发中的一个坑

坑：在同一个业务类中，进行业务方法间的相互调用，只有最外层的方法，才是加入了额外功能(内部的方法，通过普通的方式调用，都调用的是原始方法)。如果想让内层的方法也调用代理对象的方法，需要实现AppicationContextAware接口，通过其setApplicationContext方法获得工厂对象，进而获得代理对象，调用方法，加入额外功能。

原始类：

public class UserServiceImpl implements UserService, ApplicationContextAware {
    private ApplicationContext ctx;
    //通过实现 ApplicationContextAware 接口，通过 setApplicationContext方法 获取项目中的IOC工厂对象
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.ctx = applicationContext;
    }

    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register （业务运算+DAO调用）");

        // 模拟同一个业务类不同的业务方法间相互调用的情况
        // 此时调用的是原始对象的login，不是代理对象，所以只有核心功能，没有额外功能
        // 但是我们在这里调用的目的是要有额外功能+核心功能的
        // 由于IOC工厂是重量级资源，一个应用最好只创建一个，所以不能在这里再创建一个工厂
        // 实现 ApplicationContextAware 接口，可以获取到项目中的IOC工厂对象
        //this.login("angenin", "11");
        
        //通过工厂对象创建代理对象，再调用login方法，实现额外功能+核心功能
        UserService userService = (UserService) ctx.getBean("userService");
        userService.login("angenin", "11");
    }

    @Override
    public boolean login(String name, String password) {
        System.out.println("UserServiceImpl.login");
        return true;
    }
}

AOP阶段知识总结

在这里插入图片描述

下一篇：Spring5学习笔记（四、持久层整合与事务处理）

学习视频(p63-p107)：https://www.bilibili.com/video/BV185411477k?p=63

MethodInterceptor;方法调用拦截器;使用:打印操作日志,阿里sentinal接入用于服务降级
C_Wangjq的博客
04-07 706
文章目录Interface MethodInterceptorinvoke(MethodInvocation invocation)使用场景 Interface MethodInterceptor org.aopalliance.intercept.MethodInterceptor invoke(MethodInvocation invocation) 这是一个函数接口，因此可以用作...
Spring学习笔记——AOP
qq_47102228的博客
04-11 828
Spring AOP，AspectJ
Spring源代码解析（七）：Spring AOP中对拦截器调用的实现
weixin_33725272的博客
09-30 253
前面我们分析了Spring AOP实现中得到Proxy对象的过程，下面我们看看在Spring AOP中拦截器链是怎样被调用的，也就是Proxy模式是怎样起作用的，或者说Spring是怎样为我们提供AOP功能的； 在JdkDynamicAopProxy中生成Proxy对象的时候： Java代码  return Proxy.newProxyInstance(classLoader, proxiedIn...
Spring事务原理分析(三)--事务代理调用过程
weixiaohuai的博客
02-11 2609
目录 一、概述 二、事务代理调用过程分析 三、createTransactionIfNecessary()创建事务 四、invocation.proceedWithInvocation()执行增强方法 五、commitTransactionAfterReturning(txInfo)提交事务 六、completeTransactionAfterThrowing(txInfo, ex)异常回滚事务 七、总结 一、概述 通过前面一篇文章，我们已经了解了AOP切面织入生成代理对象的过程，当B
spring的MethodInterceptor方法
西北狼的博客
12-10 735
spring的MethodInterceptor方法
Java面试题（六）
2301_77822280的博客
04-27 95
3、在类中定义 ThreadLocal 的成员变量，并将需要的可变成员变量保存在 ThreadLocal 中，ThreadLocal 本身就具备线程隔离的特性，这就相当于为每个线程提供了一个独立的变量副本，每个线程只需要操作自己的线程副本变量，从而解决线程安全问题。属性赋值 PopulateBean()会对bean的依赖属性进行填充，@AutoWired注解注入的属性就发生这个阶段，假如我们的bean有很多依赖的对象，那么spring会依次调用这些依赖的对象进行实例化，注意这里可能会有循环依赖的问题。
spring aop 学习笔记
05-27
本学习笔记将深入探讨Spring AOP的核心概念、工作原理以及实际应用。 1. **核心概念** - **切面（Aspect）**：切面是关注点的模块化，包含业务逻辑之外的横切关注点，如日志、事务管理。 - **连接点（Join Point...
SpringAOP学习笔记
01-27
,文章属于基础级文章，适合入门级的小伙伴，它的概念，应用场景，实现原理及Spring的AOP的开发。全称:面向切面编程(AspectOrientedProgramming),通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。...
Spring Aop 学习笔记
03-25
Spring Aop 学习笔记
Spring AOP学习笔记
03-01
NULL 博文链接：https://linres.iteye.com/blog/281221
跟着小马哥学系列之 Spring AOP（ ReflectiveMethodInvocation/CglibMethodInvocation 详解）
qq_42419406的博客
05-15 2294
跟着小马哥学系列之 Spring AOP（ MethodInvocation 详解）简介类图相关接口或者类介绍JoinpointInvocationMethodInvocationProxyMethodInvocationReflectiveMethodInvocationCglibMethodInvocation 学好路更宽，钱多少加班。 ——小马哥 简介 大家好，我是小马哥成千上万粉丝中的一员！2019年8月有幸在叩丁狼教育举办的猿圈活动中知道有这么一位大咖，从此结下了不解之缘！此系列在多次学习极客
Spring笔记——AOP（注解方式）
11-02 6819
在Java EE应用中，常常通过AOP来处理一些具有横切性质的系统级服务，如事务管理、安全检查、缓存、对象池管理等。1.AOP的基本概念AOP从程序运行角度考虑程序的流程，提取业务处理过程的切面。AOP面向的是程序运行中各个步骤，希望以更好的方式来组合业务处理的步骤。 AOP框架并不与特定的代码耦合，AOP框架能处理程序中特定切入点（Pointcut），而不与具体某个具体类耦合。AOP框架具有如下
Spring源码学习（十四）-- AOP底层源码解析下
学习笔记
02-09 907
ProxyFactory选择cglib或jdk动态代理原理 OrderService target = new OrderService(); ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.setTarget(target); proxyFactory.setInterfaces(OrderInterface.class); proxyFactory.addAdvice(new MethodIntercepto
spring 事物处理机制
xianchengzi的专栏
06-16 1993
ReflectiveMethodInvocation.proceed() 首先需要运行在实物上下文环境，service的调用都是动态代理，例子中的是jdk动态代理，然后进过一系列的拦截器， 调用proceed() 最后调用 invokeJoinpoint() 最后执行目标类的方法 调用关系：Daemon Thread [http-bio-8080-exec-2] (Suspended)
使用MethodInterceptor实现AOP
kongls08的专栏
05-18 2万+
1. 先写出业务对象接口及实现业务对象。   Java代码   public interface Interface {       public void hello();   }      这里写俩个实现。 Java代码   public class InterfaceImpl implements Inter
使用方法拦截器MethodInterceptor和AOP统一处理log
热门推荐
Clement-Xu的专栏
06-12 3万+
对每个接口的请求记录log的方法有很多种，比如用filter、mvc interceptor、method interceptor等。如果需要记录请求消息的payload，前两种不适用。下面介绍第三种的实现方法。 第一步：引入包依赖 org.aspectj aspectjweaver 1.8.6 com.fasterxml.ja
Spring AOP MethodInvocation拦截器调用原理
bugpool的博客
04-03 1万+
前言 通过对JdkDynamicAopProxy的invoke方法的探究，发现invoke的核心是： 由匹配当前方法的advisor，例如与当前方法所匹配的所有before、afterReturning等增强，再将这些增强组成拦截器链 // 生产拦截器链 MethodInvocation invocation = new ReflectiveMethodInvocation(pro...
拦截器（Interceptor）中的invocation.invoke()是什么意思？
cruise技术博客
08-16 1万+
关于在Struts2的自定义的验证拦截器（Interceptor）中的invocation.invoke()是什么意思？ package com.xjtu.interceptor; import com.opensymphony.xwork2.ActionContext; import com.opensymphony.xwork2.ActionInvocation; im
【Spring】AOP：源码流程（中）方法调用
菜鸡也有大佬梦
02-22 716
Advice 拦截器链获取 在为AopProxy代理对象配置拦截器的实现中，有一个取得拦截器的配置过程，这个过程是由 DefaultAdvisorChainFactory 实现的，这个工厂类负责生成拦截器链，在它的 getInterceptorsAndDynamicInterceptionAdvice方法中，有一个适配器和注册过程，通过配置Spring 预先设计好的拦截器，Spring 加入了它对AOP实现的处理。 // AdvisedSupport public List<Object> ge
Spring 2.5学习笔记：IoC与AOP详解
学习笔记介绍了基于注解的Spring AOP编程，并提供了使用示例。 4. **配置和实战**： - 分别探讨了基于XML的配置和注解驱动的配置方式。例如，基于XML的Spring AOP编程示例和事务管理的配置，包括基于注解的事务...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值