Spring5学习随笔-AOP系列Spring动态代理

学习视频：【孙哥说Spring5：从设计模式到基本应用到应用级底层分析，一次深入浅出的Spring全探索。学不会Spring？只因你未遇见孙哥】

第一章、静态代理设计模式

1.为什么需要代理设计模式

1.1问题

  • 在JavaEE分层开发中，那个层次对于我们来讲最重要

    Dao - - >Service - - > Controller

    Service层 是最为重要的（每个方法都是为了满足用户需求的功能），Dao是辅助Service完成业务处理的（访问、操作数据库），Controller是调用Service的。

  • Service层中包含了哪些代码？

    Service层中 = 核心功能（几十行 上百代码） + 额外功能（附加功能）

    1. 核心功能

      业务运输

      DAO调用

    2. 额外功能

      1. 不属于业务
      2. 可有可无
      3. 代码量少

      事务、日志、性能…

  • 额外功能写在Service层中好不好？

    站在Service层的调用者的角度（Controller）：需要在Service层书写额外功能（事务）。

    站在软件设计者的角度：Service层不需要额外功能（影响维护性）

  • 现实生活中的解决方式

2.代理设计模式

2.1 概念

2.2 名词解释

  1. 目标类、原始类

    指的是业务类（核心功能—>业务运算 DAO调用）

  2. 目标方法、原始方法

    目标类（原始类）中的方法 就是目标方法（原始方法）

  3. 额外功能（附加功能）

    日志、事务、性能

2.3 代理开发的核心要素

代理类 = 目标类(原始类) + 额外功能 + 原始类(目标类) 实现相同的接口

房东 --->public interface UserService{
							m1
							m2
					UserServiceImpl implements UserService{
							m1--->业务运算 DAO调用
							m2
					}
					UserServiceProxy implements UserService{
							m1
							m2
					}
				}

2.4 编码

静态代理：为每一个原始类，手工编写一个代理类（java.class)

1.5 静态代理存着的问题

1.静态类文件输了过多，不利于项目管理

UserServiceImpl UserServiceProxy

OrderServiceImpl OrderServiceProxy……..

2.额外功能维护性差

代理类中 额外功能修改复杂、麻烦

第二章、Spring的动态代理开发

1.Spring动态代理的概念

概念：通过代理类为原始类（目标类）增加额外功能

好处：利于原始类（目标类）的维护

主要在开发步骤和底层实现跟静态代理不一样。

2.搭建开发环境

<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.8</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.3</version>

3.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.baizhi.proxy.UserServiceImpl"/>

2.额外功能

MethodBeforeAdvice接口

1.额外功能书写在接口的实现中，运行在原始方法执行之前运行额外功能

public class Before implements MethodBeforeAdvice {
    /*
    作用：需要把运行在原始方法执行之前运行的额外功能，书写在before方法中
     */
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("-------method before advice log-------");

    }
}

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

  1. 定义切入点

    1. 切入点：额外功能加入的位置

    目的：由程序员根据自己的需要，决定额外功能加入给那个原始方法

    简单的测试：所有方法都做为切入点，都加入额外的功能。

<aop:config>
<!--        所有的方法 都作为切入点，加入额外功能 login register-->
        <aop:pointcut id="pc" expression="execution(* *(..))"/>
    </aop:config>

4.组装（2 3整合）

表达的含义：所有的方法 都加入 before的额外功能 第一个参数表示额外功能，第二个参数表示切入点
<aop:advisor advice-ref="before" pointcut-ref="pc"/>

5.调用

目的：获得Spring工厂创建的动态代理对象，并进行调用

ApplicationContext ctx = new ClassPathXmlApplicationContext(”/applicationContext.xml”)

注意：

1.Spring的工厂通过原始对象的id值获得的是代理对象

2.获得代理对象后，可以通过声明接口类型，进行对象的存储

UserService userService = (UserService)ctx.getBean(”userService”)

userService.login(””)

userService.register()

4.动态代理细节分析

1.Spring创建的动态代理类在哪里？

Spring框架在运行时，通过动态字节码技术码，在JVM创建的，运行在JVM内部，程序结束后，会和JVM一起消失。

什么叫动态字节码技术：通过第三方的动态字节码框架，在JVM中创建对应类的字节码，进而创建对象，当虚拟机结束，动态字节码跟着消失

结论：动态代理不需要定义类，都是JVM运行过程中动态创建的，所以不会造成静态代理，类文件数量过多，影响项目管理的问题

2.动态代理编程简化代理的开发

在额外功能不改变的前提下，创建其他目标类（原始类）的代理对象时，只需要指定原始（目标）对象即可。

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

第三章、Spring动态代理详解

1.额外功能的详解

  • MethodBeforeAdvice分析

    1. MethodBeforeAdvice接口作用：额外功能运行在原始方法执行之前，进行额外功能操作
    public class Before implements MethodBeforeAdvice {
    /*
    作用：需要把运行在原始方法执行之前运行的额外功能，书写在before方法中
    参数详解：
            Method:指的是额外功能所增加的原始方法
            Object[]:原始方法的所有参数，也就是method对应的参数
            Object：代表原始对象（method对应的原始对象）
     */
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("Before:执行方法："+method+"，"+method.getName());
    }

}

    1. before方法的3个参数在实战中，该如何使用

      before方法的参数，在实战中，会根据需要进行使用，不一定都会用到。（跟Servlet中的service（HttpRequest，HttpRespon）方法中的参数一样看情况使用）

  • MethodInterceptor（方法拦截器）

    methodinterceptor接口：额外功能可以书写在原始方法之前、之后

    public class Arround implements MethodInterceptor {
    /*
        invoke方法的作用：把额外功能书写在invoke当中
                         额外功能就可以运行在原始方法之前、之后
        确定：原始方法怎么运行
        参数：MethodInvocation：额外功能所增加给的原始方法
        返回值：Object：原始方法的返回值
     */

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("------interceptor 额外功能 log--------");
        Object ret = invocation.proceed();
        return ret;
    }
}

  1. 什么样的额外功能 运行在原始方法执行之前、之后呢？

    事务

  2. 额外功能运行在原始方法抛出异常的时候

    public Object invoke(MethodInvocation invocation) throws Throwable {
    Object ret = null;
    try {
        ret = invocation.proceed();
    } catch (Throwable throwable) {
        System.out.println("------interceptor 额外功能 log--------");
        throwable.printStackTrace();
    }
    return ret;
}

  3. MethodInterceptor影响原始方法的返回值

    原始方法的返回值，直接作为invoke方法的返回值返回，不会被MethodInterceptor影响，

    MethodInterceptor要改变原始方法的返回值只需要修改return返回值即可。

2.切入点详解

切入点决定了额外功能加入的位置/方法

  1. execution() 切入点函数
    • *(..) 切入点表达式

2.1 切入点表达式

  1. 方法切入点表达式

    • *(..) —>为什么能匹配所有方法

    • ———》 修饰符 返回值

    • ———》方法名

    () ——》参数表

    .. ——》对参数没有要求

    • 定义login方法作为切入点

      • login(..)

    • 定义login方法且有两个字符串类型的参数作为切入点

      • login(String,String)

      注意：非java.lang包中的类型，必须要写全限定名

      • register(com.baizhi.proxy.User)

    • 精准方法切入点限定

      一定要在第二个*（方法名）写全限定名：包.类.方法(参数)

      • com.baizhi.proxy.UserService(String,String)

  2. 类切入点

    指定特定类作为切入点，自然这个类中的所有方法，都会加入对应的额外功能

    • 语法1

      * com.baizhi.proxy.UserServiceImpl.*(..))

    • 语法2

      类只存在一级包

      * *.UserServiceImpl.*(..)

      类存在多级包

      * *..UserServiceImpl.*(..)

  3. 包切入点表达式

    • 语法1

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

      (* com.baizhi.proxy.*.*(..)

      多级包：(* com.baizhi.proxy..*.*(..)

2.2 切入点函数

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

  1. execution

    最为重要的切入点函数，功能最全。可以执行方法、类、包切入点表示等

    弊端：execution执行切入点表达式，书写麻烦

    注意：其他的切入点函数 仅是简化execution书写复杂度，功能上完全一致

  2. args

    作用：主要用于函数(方法)参数的匹配

    切入点：例如方法参数必须得是2个字符串类型的参数：args(String,String)

  3. within

    作用：主要用于进行类、包切入点表达式的匹配

    切入点：用UserServiceImpl这个类举例

    within(*..UserServiceImpl)

    包切入点

    within(com.baizhi.proxy..*)

  4. @annotation

    作用：为具有特殊注解的方法加入额外功能

    @annotation(com.baizhi.Log)

  5. 切入点函数的逻辑运算

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

    • and与操作 同时执行

      案例 login 同时 参数 2个字符串

      execution(* login(..)) and args(String,String)

      注意：与操作不能用于同种类型的切入点函数

    • or或操作

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

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

下一章：Spring5学习随笔-AOP底层实现（JDK、CGlib）、实现切面（@Aspect）

posted @ 2023-11-18 11:51  扬眉剑出鞘  阅读(434)  评论(0)  编辑  收藏  举报