Spring之aop

最新推荐文章于 2025-03-18 15:55:16 发布

大佬员阿乐

最新推荐文章于 2025-03-18 15:55:16 发布

阅读量112

点赞数

文章标签： spring java 后端

本文链接：https://blog.youkuaiyun.com/m0_60390944/article/details/121106356

版权

一：AOP中关键性概念

一：概念

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

2、目标(Target)：被通知(被代理)的对象

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

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

5、切入点(Pointcut)：多个连接点的集合，定义了通知应该应用到那些连接点。(也将Pointcut理解成一个条件，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序)

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

aop:
不改动原有代码，实现日志添加功能

二：简介

1、AOP
即面向切面编程

2、AOP带来的好处
让我们可以 “专心做事”
案例：

   public void doSameBusiness (long lParam,String sParam){
     // 记录日志
     log.info("调用 doSameBusiness方法，参数是："+lParam);
     // 输入合法性验证
     if (lParam<=0){
          throws new IllegalArgumentException("xx应该大于0");
     }
     if (sParam==null || sParam.trim().equals("")){
          throws new IllegalArgumentException("xx不能为空");
     }
     // 异常处理
     try{ ...
     }catch(...){
     }catch(...){
     }
     // 事务控制
     tx.commit();
   }

3 、工具类org.springframework.aop.framework.ProxyFactoryBean用来创建一个代理对象,在一般情况下它需要注入以下三个属性：
proxyInterfaces：代理应该实现的接口列表(List)
interceptorNames：需要应用到目标对象上的通知Bean的名字。(List)
target：目标对象 (Object)

4、前置通知(org.springframework.aop.MethodBeforeAdvice)：在连接点之前执行的通知()

5、后置通知(org.springframework.aop.AfterReturningAdvice)：在连接点正常完成后执行的通知

6、环绕通知(org.aopalliance.intercept.MethodInterceptor)：包围一个连接点的通知，最大特点是可以修改返回值，由于它在方法前后都加入了自己的逻辑代码，因此功能异常强大。它通过MethodInvocation.proceed()来调用目标方法（甚至可以不调用，这样目标方法就不会执行）

7、异常通知(org.springframework.aop.ThrowsAdvice)：这个通知会在方法抛出异常退出时执行

8、适配器(org.springframework.aop.support.RegexpMethodPointcutAdvisor) 适配器=通知(Advice)+切入点(Pointcut)

案例：

1、常规业务代码

1.接口

package com.xly.aop.biz;
 
public interface IBookBiz {
	// 购书
	public boolean buy(String userName, String bookName, Double price);
 
	// 发表书评
	public void comment(String userName, String comments);
}

2.实体类

package com.xly.aop.biz.imp;
 
import com.xly.aop.biz.IBookBiz;
import com.xly.aop.exception.PriceException;
 
public class BookBizImpl implements IBookBiz {
 
	public BookBizImpl() {
		super();
	}
 
	public boolean buy(String userName, String bookName, Double price) {
		// 通过控制台的输出方式模拟购书
		if (null == price || price <= 0) {
			throw new PriceException("book price exception");
		}
		System.out.println(userName + " buy " + bookName + ", spend " + price);
		return true;
	}
 
	public void comment(String userName, String comments) {
		// 通过控制台的输出方式模拟发表书评
		System.out.println(userName + " say:" + comments);
	}
 
}

3.PriceException类

package com.xly.aop.exception;
 
public class PriceException extends RuntimeException {
 
	public PriceException() {
		super();
	}
 
	public PriceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
	}
 
	public PriceException(String message, Throwable cause) {
		super(message, cause);
	}
 
	public PriceException(String message) {
		super(message);
	}
 
	public PriceException(Throwable cause) {
		super(cause);
	}
	
}

4.测试及运行结果

package com.xly.aop.test;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.xly.aop.biz.IBookBiz;
 
public class AopTest {
	public static void main(String[] args) {
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("/spring-context.xml");
		IBookBiz bookBiz = (IBookBiz) applicationContext.getBean("bookBiz");
		bookBiz.buy("华子", "妈妈的朋友", 9.9);
		bookBiz.comment("华子", "真不错~~~~~ ");
	}
 
}

2.前置通知（前置通知的价值在于：创建session，开启事务）

package com.xly.aop.advice;
 
import java.lang.reflect.Method;
import java.util.Arrays;
 
import org.springframework.aop.MethodBeforeAdvice;
 
/**
 * 前置通知
 * 
 * 调用项目中的某一接口实现类的方式时，将类名.方法名，携带的参数，作为日志存储到数据库。
 * target：目标对象
 * method：被触发的目标对象的方法
 *  args：目标对象的目标方法携带的参数
 * @author Administrator
 *
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {
 
    public void before(Method method, Object[] args, Object target) throws Throwable {
        String targetName = target.getClass().getName();
        String methodName = method.getName();
        String params = Arrays.toString(args);
        String msg = "【系统日志】：正在调用->"+targetName+"."+methodName+",携带的参数："+params;
        System.out.println(msg);
 
    }
 
}

2.spring-context.xml（所有通知配置）

<?xml version="1.0" encoding="UTF-8"?>
<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"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
 
<!--本文件中配置整个项目中包含的所有javabean  目的在于spring统一管理-->
<bean name="userBiz1" class="com.xly.ioc.biz.impl.UserBizImpl"></bean>
<bean name="userBiz2" class="com.xly.ioc.biz.impl.UserBizImpl2"></bean>
<bean name="personAction" class="com.xly.ioc.web.PersonAction">
<property name="userBiz" ref="userBiz2"></property>
</bean>
<bean name="userAction" class="com.xly.ioc.web.UserAction"></bean>
 
<bean name="paramAction" class="com.xly.ioc.web.ParamAction">
<!--  1.set传参-->
<!-- <property name="name" value="影子1"></property>
<property name="age" value="18"></property>
<property name="hobby" >
<list>
<value>打羽毛球</value>
<value>追剧</value>
</list>
</property> -->
<constructor-arg name="name" value="影子2"></constructor-arg>
<constructor-arg  name="age" value="18"></constructor-arg>
<constructor-arg name="hobby" >
<list>
<value>打羽毛球</value>
<value>追剧</value>
</list>
</constructor-arg>
</bean>
<!--目标 -->
<bean name="bookBiz" class="com.xly.aop.biz.imp.BookBizImpl"></bean>
<!--前置通知  -->
<bean name="myBefore" class="com.xly.aop.advice.MyMethodBeforeAdvice"></bean>
<!--后置通知  -->
<bean name="myAfter"  class="com.xly.aop.advice.MyAfterReturningAdvice"></bean>
<!--环绕通知  -->
<bean name="myFilterAdvice" class="com.xly.aop.advice.MyMethodInterceptor"></bean>
<!--异常通知  -->
<bean name="myExceptionAdvice" class="com.xly.aop.advice.MyThrowsAdvice"></bean>
<!--过滤通知  -->
<bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"
        id="myAfter2">
        <property name="advice" ref="myAfter"></property>
        <!-- .*buy:[.*]任意字符0~n个，以buy结尾的方法 -->
        <!-- <property name="pattern" value=".*buy"></property> -->
        <property name="patterns">
            <list>
                <value>.*buy</value>
            </list>
        </property>
    </bean>
<!--生成代理对象  （目标+通知）-->
<bean class="org.springframework.aop.framework.ProxyFactoryBean"
        id="proxyFactoryBean">
        <!--ref 目标对象  -->
        <property name="target" ref="bookBiz"></property>
        <!-- 代理工厂生产的代理需要实现的接口列表 -->
        <property name="proxyInterfaces">
            <list>
                <value>com.xly.aop.biz.IBookBiz</value>
                
            </list>
        </property>
        <!--绑定的那些通知  -->
        <property name="interceptorNames">
            <list>
                <value>myBefore</value>
                <value>myAfter</value>
                <value>myAfter2</value>
                 <value>myFilterAdvice</value>
                 <value>myExceptionAdvice</value> 
            </list>
        </property>
    </bean>
</beans>

3.运行结果

package com.xly.aop.test;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.xly.aop.biz.IBookBiz;
 
public class AopTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("/spring-context.xml");
        IBookBiz bookBiz = (IBookBiz) applicationContext.getBean("proxyFactoryBean");
        bookBiz.buy("影子", "三国演义", 9.9);
        bookBiz.comment("影子", "真不错~~~~~ ");
    }
 
}

3.后置通知（后置通知价值在于：提交事务，关闭session）

package com.xly.aop.advice;
 
import java.lang.reflect.Method;
import java.util.Arrays;
 
import org.springframework.aop.AfterReturningAdvice;
 
/**
 * 后置通知
 * @author Administrator
 *
 */
public class MyAfterReturningAdvice implements AfterReturningAdvice {
 
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        String targetName = target.getClass().getName();
        String methodName = method.getName();
        String params = Arrays.toString(args);
        String msg = "【返利通知：返利3元】：正在调用->" + targetName + "." + methodName + ",携带的参数：" + params + ";目标对象所调用的方法的返回值："
                + returnValue;
        System.out.println(msg);
    }
 
}

2.配置

<!--后置通知  -->
<bean name="myAfter"  class="com.zy.aop.advice.MyAfterReturningAdvice"></bean>
 
<!--绑定的那些通知  -->
<property name="interceptorNames">
            <list>
                <value>myBefore</value>
                <value>myAfter</value>
                
            </list>
        </property>

3结果

4.环绕通知（包含了前置通知和后置通知）

invocation可以执行被代理的目标对象的业务方法
Object returnValue = invocation.proceed();

package com.xly.aop.advice;
 
import java.lang.reflect.Method;
import java.util.Arrays;
 
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
 
/**
 * 环绕通知
 * @author Administrator
 *
 */
public class MyMethodInterceptor implements MethodInterceptor {
 
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Object target = invocation.getThis();
        Method method = invocation.getMethod();
        Object[] args = invocation.getArguments();
        // a.jsp window.open(b.jsp)
        // b.jsp xxx->返回object->b.jsp window.close();window.getArguments;
        String targetName = target.getClass().getName();
        String methodName = method.getName();
        String params = Arrays.toString(args);
        String msg = "【环绕通知】：正在调用->" + targetName + "." + methodName + ",携带的参数：" + params;
        System.out.println(msg);
        //invocation可以执行被代理的目标对象的业务方法
        Object returnValue = invocation.proceed();
        String msg2 = "【环绕通知】：目标对象所调用的方法的返回值：" + returnValue;
        System.out.println(msg2);
        return returnValue;
    }
 
}

2.配置

<!--环绕通知  -->
<bean name="myFilterAdvice" class="com.xly.aop.advice.MyMethodInterceptor"></bean>
<!--绑定的那些通知  -->
        <property name="interceptorNames">
            <list>
                <value>myBefore</value>
                <value>myAfter</value>
               
                 <value>myFilterAdvice</value>
            
            </list>
        </property>

3.结果

5.异常通知（处理失败的业务逻辑代码,可以将数据进行回滚）

package com.xly.aop.advice;
 
import org.springframework.aop.ThrowsAdvice;
 
import com.xly.aop.exception.PriceException;
 
 
 
/**
 * 异常通知
 * 一定要实现这个接口
 * 一定要叫这个方法名
 * @author Administrator
 *
 */
public class MyThrowsAdvice implements ThrowsAdvice {
    public void afterThrowing( PriceException ex ) {
        System.out.println("价格输入有误，购买失败，请重新输入！！！");
    }
}

2.配置

<!--异常通知  -->
<bean name="myExceptionAdvice" class="com.xly.aop.advice.MyThrowsAdvice"></bean>
<!--绑定的那些通知  -->
        <property name="interceptorNames">
            <list>
                
                 <value>myExceptionAdvice</value> -->
            </list>

3.运行结果

6、过滤通知（并不是所有的表都需要系统日志，因此需要过滤）

1.配置

<!--过滤通知  -->
<bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"
        id="myAfter2">
        <property name="advice" ref="myAfter"></property>
        <!-- .*buy:[.*]任意字符0~n个，以buy结尾的方法 -->
        <!-- <property name="pattern" value=".*buy"></property> -->
        <property name="patterns">
            <list>
                <value>.*buy</value>
            </list>
        </property>
    </bean>
 
 
<!--绑定的那些通知  -->
        <property name="interceptorNames">
            <list>
                <value>myBefore</value>
           <!--      <value>myAfter</value> -->
               
                 <value>myFilterAdvice</value>
                 <value>myAfter2</value>
                 <value>myExceptionAdvice</value> 
            </list>
        </property>

2.结果