【Spring AOP，35岁以后的Java程序员出路在哪里

最新推荐文章于 2024-03-13 08:05:45 发布

m0_60452110

最新推荐文章于 2024-03-13 08:05:45 发布

阅读量243

点赞数

分类专栏：程序员文章标签：后端面试 java

本文链接：https://blog.csdn.net/m0_60452110/article/details/119578687

版权

程序员专栏收录该内容

53 篇文章 0 订阅

订阅专栏

*   *   [方法切入点](about:blank#_348)

    *   [类切入点](about:blank#_390)

    *   [包切入点（实战中用的多）](about:blank#_407)

*   [切入点函数（execution、args、within）](about:blank#executionargswithin_420)

*   *   [exectuion](about:blank#exectuion_424)

    *   [args](about:blank#args_434)

    *   [within](about:blank#within_448)

    *   [@annotation](about:blank#annotation_471)

    *   [切入点函数的逻辑运算（and、or）](about:blank#andor_485)

更多内容请查看笔记目录：【Spring 5.x】学习笔记汇总

静态代理设计模式

===========================================================================

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

在 JavaEE 分层开发开发中，哪个层次对于我们来讲最重要？Service 层

Service 层中包含了哪些代码？

核心功能（代码量较多）：业务运算，DAO 调用
额外功能（附加功能，不属于业务，可有可无，代码量小）：事务、日志、性能 …

额外功能书写在 Service 层好不好?

Service 层的调用者的角度（Controller)：需要在 Service 层书写额外功能。
软件设计者：Service 层不需要额外功能。

拿现实生活中的例子来做对比，解决方案是 引入一个代理。

在这里插入图片描述

2. 代理设计模式

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

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

名词解释

目标类 / 原始类：指的是 业务类 (核心功能 --> 业务运算、DAO调用)

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

额外功能 / 附加功能：日志、事务、性能 …

代理开发的核心要素

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


房东 --- 目标类

public interface UserService {

	m1

	m2

}

public UserServiceImpl implements UserServiceImpl {

	m1 ---> 业务运算、调用DAO

	m2 

}

----------------------------------------------------

中介 --- 代理类：要实现目标类相同的接口

public UserServiceProxy implements UserService {

	m1

	m2

}

静态代理编码

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


public class User {}

public interface UserService {

void register(User user);

boolean login(String name, String password);

}


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 业务运算 + DAO");

        return true;

    }

}

/**

静态代理类编码实现

public class UserServiceProxy implements UserService { // 实现原始类相同的接口

private UserService 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);

}

}




### [](https://gitee.com/vip204888/java-p7)静态代理存在的问题



1.  **静态类文件数量过多，不利于项目管理**  

    `UserServiceImpl`、`UserServiceProxy`  

    `OrderServiceImpl`、`OrderServiceProxy`  

    …

2.  **额外功能维护性差**：在代理类中修改额外功能较为麻烦



[](https://gitee.com/vip204888/java-p7)Spring 动态代理开发

================================================================================



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

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



[](https://gitee.com/vip204888/java-p7)搭建开发环境

-------------------------------------------------------------------------

org.springframework

spring-aop

5.1.14.RELEASE

org.aspectj

aspectjrt

1.8.9

org.aspectj

aspectjweaver

1.8.13




[](https://gitee.com/vip204888/java-p7)Spring 动态代理的开发步骤(5步)

---------------------------------------------------------------------------------------



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

public interface UserService {

void register(User user);

boolean login(String name, String password);

}


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 业务运算 + DAO");

        return true;

    }

} 

```



2.  额外功能 `MethodBeforeAdvice` 接口



```

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

    }

}




3.  定义 **切入点**：额外功能的加入  

    目的: 由程序员根据自己的需要，决定额外功能加入给哪个原始方法(register、login)

<!--目的: 由程序员根据自己的需要，决定额外功能加入给哪个原始方法(register、login)-->

<aop:config>

    <aop:pointcut id="pc" expression="execution(* * (..))"/>

</aop:config>




4.  组装（2、3 整合）

<beans xmlns=“http://www.springframework.org/schema/beans”

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xmlns:aop="http://www.springframework.org/schema/aop"

   xsi:schemaLocation="http://www.springframework.org/schema/beans

                       http://www.springframework.org/schema/beans/spring-beans.xsd

                       http://www.springframework.org/schema/aop

                       https://www.springframework.org/schema/aop/spring-aop.xsd">



<bean id="userService" class="com.yusael.aop.UserServiceImpl"/>

<!-- 额外功能 -->

<bean id="before" class="com.yusael.aop.Before"/>



<!--切入点:额外功能的加入-->

<!--目的：由程序员根据自己的需要，决定额外功能加入给哪个原始方法(register、login)-->

<aop:config>

    <aop:pointcut id="pc" expression="execution(* * (..))"/>

    <!--表达的含义: 所有的方法 都加入before的额外功能-->

    <aop:advisor advice-ref="before" pointcut-ref="pc"/>

</aop:config>




5.  调用  

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

    注意：

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

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

/**

用于测试动态代理

@Test

public void test1() {

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");

UserService userService = (UserService) ctx.getBean("userService");

userService.login("admin", "1234");

userService.register(new User());

}




[](https://gitee.com/vip204888/java-p7)动态代理细节分析

---------------------------------------------------------------------------



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



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



什么是 **动态字节码技术**？



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



结论：



*   **动态代理不需要定义类文件，都是 JVM 运行过程中动态创建的**；  

    所以不会造成静态代理的缺点：类⽂件数量过多，影响项目管理的问题。



![在这里插入图片描述](https://img-blog.csdnimg.cn/20200527211524289.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ==,size_16,color_FFFFFF,t_70)



* * *



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



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



* * *



动态代理使得 **额外功能的维护性大大增强**。



[](https://gitee.com/vip204888/java-p7)动态代理开发详解

===========================================================================



[](https://gitee.com/vip204888/java-p7)额外功能的详解

--------------------------------------------------------------------------



### [](https://gitee.com/vip204888/java-p7)MethodBeforeAdvice 分析



1.  `MethodBeforeAdvice` 接口作用：额外功能运行在原始方法执行之前，进行额外功能操作。

public class Before implements MethodBeforeAdvice {

/**

 * 作用: 把需要运行在原始方法执行之前运行的额外功能, 书写在 before 方法中

 *

 * Method: 额外功能所增加给的那个原始方法

 *                          login

 *                          register

 *                          --------

 *                          showOrder

 *

 * Object[]:  额外功能所增加给的那个原始方法的参数

 *                          String name,String password

 *                          User

 *                          --------

 *

 * Object: 额外功能所增加给的那个原始对象

 *                          UserServiceImpl

 *                          ---------------

 *                          OrderServiceImpl

 */

@Override

public void before(Method method, Object[] objects, Object o) throws Throwable {

    System.out.println("---new method before advice log---");

}

}




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

    `before` 方法的参数，在实战中，会根据需要进行使用，不⼀定都会用到，也有可能都不用。  

    孙哥：”我用了 15 年 Spring 一次都没有用到过这个。"



### [](https://gitee.com/vip204888/java-p7)MethodInterceptor（方法拦截器）



`methodinterceptor` 接口：额外功能可以根据需要运行在原始方法执行 **前、后、前后**。



*   参数：`MethodInvocation`：额外功能所增加给的那个原始方法 (login, register)

*   返回值：`Object`：原始方法的返回值 (没有就返回 null)

*   `invocation.proceed()`：原始方法运行



额外功能运行在原始方法 **之前**：

public class Around implements MethodInterceptor {

@Override

public Object invoke(MethodInvocation methodInvocation) throws Throwable {

    System.out.println("---额外功能运行在原始方法执行之前---");

    Object ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值

    return ret;

}

}




额外功能运行在原始方法 **之后**：

public class Around implements MethodInterceptor {

@Override

public Object invoke(MethodInvocation methodInvocation) throws Throwable {

    Object ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值

    System.out.println("---额外功能运行在原始方法执行之后---");

    return ret;

}

}




额外功能运行在原始方法 **之前、之后**：

public class Around implements MethodInterceptor {

@Override

public Object invoke(MethodInvocation methodInvocation) throws Throwable {

	System.out.println("---额外功能运行在原始方法执行之前---");

    Object ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值

    System.out.println("---额外功能运行在原始方法执行之后---");

    return ret;

}

}




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

public class Around implements MethodInterceptor {

@Override

public Object invoke(MethodInvocation methodInvocation) throws Throwable {

面试题总结

面试文件获取方式：戳这里免费下载（助你面试无忧）

其它面试题（springboot、mybatis、并发、java中高级面试总结等）

terceptor {

@Override

public Object invoke(MethodInvocation methodInvocation) throws Throwable {

	System.out.println("---额外功能运行在原始方法执行之前---");

    Object ret = methodInvocation.proceed(); // 原始方法运行, 获取原始方法的返回值

    System.out.println("---额外功能运行在原始方法执行之后---");

    return ret;

}

}




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

public class Around implements MethodInterceptor {

@Override

public Object invoke(MethodInvocation methodInvocation) throws Throwable {

面试题总结

面试文件获取方式：戳这里免费下载（助你面试无忧）

其它面试题（springboot、mybatis、并发、java中高级面试总结等）

[外链图片转存中…(img-3R4dfUqt-1628598989177)]

[外链图片转存中…(img-aIcALVIY-1628598989180)]

m0_60452110

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Spring AOP，35岁以后的Java程序员出路在哪里

* * [方法切入点](about:blank#_348) * [类切入点](about:blank#_390) * [包切入点（实战中用的多）](about:blank#_407)* [切入点函数（execution、args、within）](about:blank#executionargswithin_420)* * [exectuion](about:blank#exectuion_424) * [args](about:bla
复制链接

扫一扫