• J2EE基础：SpringAop的使用

    目录

    一、AOP所解决的问题 

     二、AOP的关键名称介绍

     AOP中关键性概念

     三、前置通知

    四、后置通知 

     五、环绕通知

    六、异常通知 

    七、过滤通知 （适配器）

    八、aop总结 

    AOP面向切面编程

     专业名词：通知、连接点、目标对象、切入点、代理、适配器

    日常开发通常的应用场景

    一、AOP所解决的问题 

    解决的问题：解决了需求的改变，造成了原有没必要改变的代码，需要去改变它；

    比如：书籍的增删改，本身只需要完成增删改的功能即可，这是如果需要添加日志功能，那么需要在原有的代码基础上，去修改添加日志功能，受牵连的方法就三个（add/edit/del）了; 

     二、AOP的关键名称介绍

     关于aop主要的功能就是写通知

     AOP中关键性概念

    目标(Target)：被通知(被代理)的对象        ——注1：完成具体的业务逻辑 

    连接点(Joinpoint)：程序执行过程中明确的点，如方法的调用，或者异常的抛出.

    通知(Advice)：在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)        ——注2：完成切面编程

    代理(Proxy)：将通知应用到目标对象后创建的对象(代理=目标+通知),

                 例子：外科医生+护士

    注3：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的

    切入点(Pointcut)：多个连接点的集合，定义了通知应该应用到那些连接点。

                     (也将Pointcut理解成一个条件 ，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序)

    适配器(Advisor)：适配器=通知(Advice)+切入点(Pointcut)

     三、前置通知

    实现org.springframework.aop.MethodBeforeAdvice接口

    买书、评论前加系统日志

    将相关资料导入

    接口类  BookBiz.java

    1. package com.zking.aop.biz;
    2.  
    3. public interface BookBiz {
    4. 	// 购书
    5. 	public boolean buy(String userName, String bookName, Double price);
    6.  
    7. 	// 发表书评
    8. 	public void comment(String userName, String comments);
    9. }

    上面的接口类有对应的实现类

    书籍的实现类 BookBizImpl.java

    1. package com.zking.aop.impl;
    2.  
    3. import com.zking.aop.biz.BookBiz;
    4. import com.zking.aop.exception.PriceException;
    5.  
    6. public class BookBizImpl implements BookBiz {
    7.  
    8. 	public BookBizImpl() {
    9. 		super();
    10. 	}
    11.  
    12. 	public boolean buy(String userName, String bookName, Double price) {
    13. 		// 通过控制台的输出方式模拟购书
    14. 		if (null == price || price <= 0) {
    15. //			当我们输入负数的时候就会抛出异常
    16. 			throw new PriceException("book price exception");
    17. 		}
    18. 		System.out.println(userName + " buy " + bookName + ", spend " + price);
    19. 		return true;
    20. 	}
    21.  
    22. 	public void comment(String userName, String comments) {
    23. 		// 通过控制台的输出方式模拟发表书评
    24. 		System.out.println(userName + " say:" + comments);
    25. 	}
    26.  
    27. }

    还有一个异常类  PriceException.java        因为通知里面有一个异常通知

    1. package com.zking.aop.exception;
    2.  
    3. public class PriceException extends RuntimeException {
    4.  
    5. 	public PriceException() {
    6. 		super();
    7. 	}
    8.  
    9. 	public PriceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
    10. 		super(message, cause, enableSuppression, writableStackTrace);
    11. 	}
    12.  
    13. 	public PriceException(String message, Throwable cause) {
    14. 		super(message, cause);
    15. 	}
    16.  
    17. 	public PriceException(String message) {
    18. 		super(message);
    19. 	}
    20.  
    21. 	public PriceException(Throwable cause) {
    22. 		super(cause);
    23. 	}
    24. 	
    25. }

    定义目标对象如图所示：

     写一类叫我的前置通知

    MyMethodBeforeAdvice.java

    1. package com.zking.aop.advice;
    2.  
    3. import java.lang.reflect.Method;
    4. import java.util.Arrays;
    5.  
    6. import org.springframework.aop.MethodBeforeAdvice;
    7.  
    8. /**
    9.  * 我的前置通知：用于目标方法被调用时之前日志收集
    10.  * @author 蒋文娟
    11.  *
    12.  * @date 2022年8月7日 上午11:06:19
    13.  */
    14. public class MyMethodBeforeAdvice implements MethodBeforeAdvice{
    15.  
    16.    /**
    17.     * @param arg0    目标方法
    18.     * @param args      目标方法所执行的参数
    19.     * @param arg2    目标对象
    20.     * @throws Throwable
    21.     */
    22.  
    23. 	@Override
    24. 	public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
    25. //		目标对象的类名
    26. 		String clzName = arg2.getClass().getName();
    27. //		当前调用的方法是
    28. 		String methName = arg0.getName();
    29. //		当前调用方法所传递参数
    30. 		String args = Arrays.toString(arg1);
    31. 		System.out.println("【系统日志】："+clzName+"."+methName+"被调用，传递的参数为："+args);
    32. 		
    33. 	}
    34.  
    35. }

    spring-context.xml 

    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4. 	xmlns:aop="http://www.springframework.org/schema/aop"
    5. 	xmlns:context="http://www.springframework.org/schema/context"
    6. 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    7. 		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
    8. 		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
    9.  
    10. 	
    11. 	<bean class="com.zking.aop.impl.BookBizImpl" id="bookBiz">bean>
    12. 	
    13. 	<bean class="com.zking.aop.advice.MyMethodBeforeAdvice" id="myBefore">bean>
    14. 	
    15. 	<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookproxy">
    16. 		
    17. 		<property name="target" ref="bookBiz">property>
    18. 		
    19. 		<property name="proxyInterfaces">
    20. 			<list>
    21. 				<value>com.zking.aop.biz.BookBizvalue>
    22. 			list>
    23. 		property>
    24. 		
    25. 		<property name="interceptorNames">
    26. 			<list>
    27. 				<value>myBeforevalue>
    28. 			list>
    29. 		property>
    30. 	bean>
    31. 	
    32. beans>

    测试

    Demo1.java

    1. package com.zking.aop.test;
    2.  
    3. import org.springframework.context.support.ClassPathXmlApplicationContext;
    4.  
    5. import com.zking.aop.biz.BookBiz;
    6.  
    7. public class Demo1 {
    8. 	@SuppressWarnings("resource")
    9. 	public static void main(String[] args) {
    10. 		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");
    11. 		BookBiz bean = (BookBiz) context.getBean("bookBiz");
    12. 		bean.buy("张三", "大话数据结构", 10.d);
    13. 		bean.comment("张三", "不愧是大话数据");
    14. 	}
    15.  
    16. }

     运行结果如图所示：

    我们在把上面的测试改换为这样如图所示： 

     

    在运行一下： 

    四、后置通知 

    实现org.springframework.aop.AfterReturningAdvice接口 

    买书返利（存在bug）

    MyAfterReturningAdvice.java

    1. package com.zking.aop.advice;
    2.  
    3. import java.lang.reflect.Method;
    4. import java.util.Arrays;
    5.  
    6. import org.springframework.aop.AfterReturningAdvice;
    7.  
    8. public class MyAfterReturningAdvice implements AfterReturningAdvice{
    9.  
    10.    /**
    11.     *
    12.     * @param arg0   目标方法的返回值
    13.     * @param arg1        目标方法
    14.     * @param args          目标方法的执行参数
    15.     * @param arg3        目标对象
    16.     * @throws Throwable
    17.     */
    18. 	@Override
    19. 	public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
    20. //		目标对象的类名
    21. 		String clzName = arg3.getClass().getName();
    22. //		当前调用的方法是
    23. 		String methName = arg1.getName();
    24. //		当前调用方法所传递参数
    25. 		String args = Arrays.toString(arg2);
    26. 		System.out.println("【买书返利】："+clzName+"."+methName+"被调用，传递的参数为："+args+";目标对象方法返回值为："+arg0);
    27.  
    28. 	}
    29.  
    30. }

    在去spring-context.xml配置 

     在去Demo1测试，测试结果如图所示：

     五、环绕通知

     环绕通知是等于前置通知+后置通知的

    实现org.aopalliance.intercept.MethodInterceptor接口

    类似拦截器，会包括切入点，目标类前后都会执行代码。

     

     MyMethodInterceptor.java代码块

    1. package com.zking.aop.advice;
    2.  
    3. import java.lang.reflect.Method;
    4. import java.util.Arrays;
    5.  
    6. import org.aopalliance.intercept.MethodInterceptor;
    7. import org.aopalliance.intercept.MethodInvocation;
    8. import org.springframework.cglib.proxy.MethodProxy;
    9.  
    10. /**
    11.  * 环绕通知=前置通知+后置通知
    12.  * @author 蒋文娟
    13.  *
    14.  * @date 2022年8月7日 下午12:01:03
    15.  */
    16. public class MyMethodInterceptor implements MethodInterceptor{
    17.  
    18. 	@Override
    19. 	public Object invoke(MethodInvocation arg0) throws Throwable {
    20. //		目标对象的类名
    21. 		String clzName = arg0.getThis().getClass().getName();
    22. //		当前调用的方法是
    23. 		String methName = arg0.getMethod().getName();
    24. //		当前调用方法所传递参数
    25. 		String args = Arrays.toString(arg0.getArguments());
    26. 		System.out.println("【环绕通知】："+clzName+"."+methName+"被调用，传递的参数为："+args);
    27. //		方法的返回值	执行目标方法	bookBiz.buy("张三","大话数据结构",10.0);
    28. 		Object rs = arg0.proceed();
    29. 		System.out.println("【环绕通知】：目标对象方法返回值为："+rs);
    30. 		return rs;
    31. 		
    32. 	}
    33. }

    配置也是跟上面一样的，这里我就简便张图片

    六、异常通知 

    当我们实现org.springframework.aop.ThrowsAdvice接口的时候，会没有要我们实现的方法

    出现异常执行系统提示，然后进行处理。价格异常为例

    关于过滤通知
     *     相较于前置通知、后置通知、环绕通知有一个非常大的区别
     *     前面三大通知都需要实现其中的方法
     *     环绕通知则不需要，但是，它的方法名又是固定的  

    价格异常类：MyThrowsAdvice.java 

    1. package com.zking.aop.advice;
    2.  
    3. import org.springframework.aop.ThrowsAdvice;
    4.  
    5. import com.zking.aop.exception.PriceException;
    6.  
    7. /**
    8.  * 关于过滤通知
    9.  * 	相较于前置通知、后置通知、环绕通知有一个非常大的区别
    10.  * 	前面三大通知都需要实现其中的方法
    11.  * 	环绕通知则不需要，但是，它的方法名又是固定的
    12.  * 
    13.  *	异常通知： 出现异常执行系统提示，然后进行处理。价格异常为例
    14.  * @author 蒋文娟
    15.  *
    16.  * @date 2022年8月7日 下午12:26:17
    17.  */
    18. public class MyThrowsAdvice implements ThrowsAdvice{
    19. 	
    20. 	public void afterThrowing(PriceException p) {
    21. 		System.out.println("【异常通知】：当价格发生异常，那么执行此处代码块！！！");
    22. 	}
    23.  
    24. }

    把上面的异常通知配置到文件里面去如图所示：

     

    Demo1测试类里面我们传递一个负数的参数如图所示：

    我们运行结果如图所示：

     报错那是肯定的，因为我们就价格不可能为负数

    七、过滤通知 （适配器）

    直接在配置文件里面配置org.springframework.aop.support.RegexpMethodPointcutAdvisor，因为过滤通知spring提供了，所以说不需要去写一个过滤通知类

    处理买书返利的bug

    spring-context.xml

    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4. 	xmlns:aop="http://www.springframework.org/schema/aop"
    5. 	xmlns:context="http://www.springframework.org/schema/context"
    6. 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    7. 		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
    8. 		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
    9.  
    10. 	
    11. 	<bean class="com.zking.aop.impl.BookBizImpl" id="bookBiz">bean>
    12. 	
    13. 	<bean class="com.zking.aop.advice.MyMethodBeforeAdvice" id="myBefore">bean>
    14. 	
    15. 	<bean class="com.zking.aop.advice.MyAfterReturningAdvice" id="myAfter">bean>
    16. 	
    17. 	<bean class="com.zking.aop.advice.MyMethodInterceptor" id="myMethod">bean>
    18. 	
    19. 	<bean class="com.zking.aop.advice.MyThrowsAdvice" id="myThrows">bean>
    20. 	
    21. 	<bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" id="myafterPlus">
    22. 		
    23. 		<property name="advice" ref="myAfter">property>
    24. 		
    25. 		<property name="pattern" value=".*buy">property>
    26. 	bean>
    27. 	
    28. 	<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
    29. 		
    30. 		<property name="target" ref="bookBiz">property>
    31. 		
    32. 		<property name="proxyInterfaces">
    33. 			<list>
    34. 				<value>com.zking.aop.biz.BookBizvalue>
    35. 			list>
    36. 		property>
    37. 		
    38. 		<property name="interceptorNames">
    39. 			<list>
    40. 				<value>myBeforevalue>
    41. 				
    42. 				<value>myafterPlusvalue>
    43. 				<value>myMethodvalue>
    44. 				<value>myThrowsvalue>
    45. 			list>
    46. 		property>
    47. 		
    48. 	bean>
    49. 	
    50. beans>

    测试，我们上面的bug就修复了，只有买书才会返利，评论不返利 

    八、aop总结 

    AOP的理解 

    1.AOP的理解

           面向切面编程

            专业名词：通知、连接点、目标对象、切入点、代理、适配器

                    通知：共性的非核心业务代码

                    连接点：具体的方法

                    目标对象：核心业务代码

                    切入点：连接点的集合

                    代理：目标+通知，共同完成业务

                    适配器：过滤通知，相当正则表达式

    主要作用：将核心的业务功能与非核心的业务功能进行 分离；

                       将核心的业务功能写到目标对象中，将非核心的业务功能写到通知中

    2.对通知的理解 

            分类：

                    前置通知、后置通知、环绕通知、异常通知、过滤通知

                            前置通知：目标方法调用前执行的

                            后置通知：目标方法调用后执行的

                            环绕通知：前置通知+后置通知

                            异常通知：目标方法调用产生异常，代码会进入异常通知中

                            过滤通知：筛选过滤掉目标方法（buy+commont）中无需代理的目标方法（buy）

    3.AOP的应用

    日常开发通常的应用场景

            事务管理：

                    事务的开启用到了前置通知

                    事务的提交用到了后置通知

                    事务的回滚用到了异常通知

                    事务：具备一致性；例如，，张三给李四转了200，那么张三的账户要减200，李四的账户要加200；要么同时成功要么同时失败，否则事务就不具备一致性

            日志：

                    可以在任何通知中是可以拿到     目标对象、方法、参数的，所以可以将这些  数据  入库；

     总结： 如果只有目标，则只会去做核心业务逻辑处理，不会收集日志；
               如果只有通知，则只会去做日志记录，不会执行核心业务逻辑；
               通知应用到目标上才能得到代理对象（通知+目标=代理）
               只有完整的代理对象才具备AOP的特性，而AOP的公共代码（日志收集）是写在通知中的！！

  • 相关阅读:
    2022年8月29日-2022年9月2日（ue4热更新视频教程学习）
    架构自治服务：构建数据驱动的架构洞察
    使用frp+nginx内网穿透并配置https
    华为机试真题 C++ 实现【等和子数组最小和】【2022.11 Q4新题】
    实践分享！GitLab CI/CD 快速入门
    MiniGUI和其他嵌入式Linux 上的图形及图形用户界面系统
    CentOS7安装squid代理服务器
    温控采集器对接-java版-modbus4j
    Servlet与设计模式
    使用卷积神经网络训练手写数字识别模型(CNN)
  • 原文地址：https://blog.csdn.net/weixin_67465673/article/details/126194112