spring框架之 AOP

最新推荐文章于 2024-10-05 11:27:00 发布

Soul717

最新推荐文章于 2024-10-05 11:27:00 发布

阅读量164

点赞数

文章标签： spring

本文链接：https://blog.csdn.net/Soul717/article/details/83756488

版权

AOP
切面编程，就是在你项目原有的功能基础上，通过AOP去添加新的功能，这些功能是建立在原有功能的基础上的，而且原有的功能并不知道你已经添加了新的功能。比如说，你去ATM取钱，取钱是一个功能，取完钱后向你的手机发送一条取钱信息，这就是新加的功能。

AOP就是在某一个类或方法执行前后打个标记，声明在执行到这里之前要先执行什么，执行完这里之后要接着执行什么。插入了新的执行方法。

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP中关键性概念 (用一个拼图举例)

1.连接点(Joinpoint)：(碎片与碎片连接的地方,凹凸槽)
程序执行过程中明确的点，如方法的调用，或者异常的抛出. (原项目要执行的方法或抛出的异常)

2.目标(Target)：(中间的有显著特征的那块)
被通知(被代理)的对象
用于完成具体的业务逻辑代码(原项目具体的实现类)

3.通知/处理(Advice)：(指除了中间的拼图的其他的碎片 )
在某个特定的连接点上执行的动作 (指要插入的新增功能的具体方法)，同时Advice也是程序代码的具体实现
完成切面编程(负责AOP代码)

4.代理(Proxy)：(拼好的拼图)
将通知应用到目标对象后创建的对象(代理=目标+通知),
注3：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的

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

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

一个工具类加五大通知

工具类org.springframework.aop.framework.ProxyFactoryBean用来创建一个代理对象,在一般情况下它需要注入以下三个属性：

target：目标对象 (Object)
proxyInterfaces：代理应该实现的接口列表(List) (产出的代理必定要实现目标对象所实现的接口)
interceptorNames：需要应用到目标对象上的通知Bean的名字。(List)

五大通知

前置通知(实现org.springframework.aop.MethodBeforeAdvice接口)：在连接点之前执行的通知()
案例：买书、评论前加系统日志

package com.zking.aop.advice;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.springframework.aop.MethodBeforeAdvice;

/**
 * 前置通知     在买书,评论前添加 日志
 * @author Administrator
 *
 */
public class myMethodBeforeAdvice implements MethodBeforeAdvice{

	public void before(Method method, Object[] params, Object target) throws Throwable {
		String targetName=target.getClass().getName();//目标对象
		String methodName=method.getName();//方法
		String param=Arrays.toString(params);//参数
		String msg="[前置系统日志]:"+targetName+"."+methodName+",携带的参数为:"+param;
        System.out.println(msg);
	}

	

}

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

案例：在线购书系统中，要求不修改BookBizImpl代码的情况下增加下功能：
对买书的用户进行返利：每买本书返利3元。(后置通知)
即：每调用一次buy方法打印：“[销售返利][时间]返利3元。”

package com.zking.aop.advice;
import java.lang.reflect.Method;
import java.util.Arrays;

import org.springframework.aop.AfterReturningAdvice;
/**
 * 后置通知  买书返利(有bug)
 * @author Administrator
 *
 */
public class myAfterReturningAdvice implements AfterReturningAdvice{

	public void afterReturning(Object returnValue, Method method, Object[] params, Object target) throws Throwable {
		String targetName=target.getClass().getName();//目标对象
		String methodName=method.getName();//方法
		String param=Arrays.toString(params);//参数
		String msg="[后置通知 销售返利][时间]返利3元]:"+targetName+"."+methodName+",携带的参数为:"+param+",目标对象返回值:"+returnValue;
        System.out.println(msg);
		
	}

}

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

这个接口里面没有定义方法，我们要求我们的类必须实现afterThrows这个方法

package com.zking.aop.advice;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class myMethodInterceptor implements MethodInterceptor{
/ /类似过滤器，会包括切入点，目标类前后都会执行代码
	public Object invoke(MethodInvocation invocation) throws Throwable {
		Object target = invocation.getThis(); 
		Method method = invocation.getMethod();
		Object[] params = invocation.getArguments();
		String targetName=target.getClass().getName();//目标对象
		String methodName=method.getName();//方法
		String param=Arrays.toString(params);//参数
		String msg="[环绕通知升级日志]:"+targetName+"."+methodName+",携带的参数为:"+param;
       	System.out.println(msg);
        Object returnValue = invocation.proceed();
		String msg2="[环绕通知升级日志]:"+returnValue;
	     System.out.println(msg2);
		return returnValue;
	}

}

异常通知(org.springframework.aop.ThrowsAdvice)：
这个通知会在方法这个通知会在方法
抛出异常退出时执行
案例：书本价格为负数时抛出一个异常，通过异常通知取消此订单价格

价格异常类
package com.zking.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);
	}
	
}

通知

package com.zking.aop.advice;

import org.springframework.aop.ThrowsAdvice;

import com.zking.aop.exception.PriceException;

public class myThrowsAdvice implements ThrowsAdvice {
	

	public void afterThrowing(PriceException ex ) {
		 System.out.println("价格错误,请重新输入");
	}  
   
}

适配器

(org.springframework.aop.support.RegexpMethodPointcutAdvisor) 适配器=通知(Advice)+切入点(Pointcut)
案例：通过适配器解决发书评时也返利的问题
.*buy
直接在spring-context.xml中配置

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:apo="http://www.springframework.org/schema/apo"
	xmlns:context="http://www.springframework.org/schema/context"
	default-autowire="byName"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd">
         
  
 <!-- ###########################  AOP  ########################### --> 
  
 <!-- 目标对象 --> 
  <bean class="com.zking.aop.bizImpl.BookBizImpl" id="BookBiz"></bean>
  
  <!--前置通知 -->
  <bean class="com.zking.aop.advice.myMethodBeforeAdvice" id="myMethodBeforeAdvice"></bean>
  <!--后置通知 -->
  <bean class="com.zking.aop.advice.myAfterReturningAdvice" id="myAfterReturningAdvice"></bean>
  <!--环绕通知 -->
  <bean class="com.zking.aop.advice.myMethodInterceptor" id="myMethodInterceptor"></bean>
  <!--异常通知 -->
  <bean class="com.zking.aop.advice.myThrowsAdvice" id="myThrowsAdvice"></bean>
 
  <!-- 过滤通知(适配器)   -->
  <bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" id="myAfterReturningAdvice2">
    <property name="advice" ref="myAfterReturningAdvice"></property>
   
     <!--  *.buy代表了 以buy结尾的方法都会切入后置通知,.*代表任意字符0~n -->
    <!-- <property name="pattern" value=".*buy"></property>过滤规则
   -->
   <property name="patterns">
        <list> 
          <value>.*buy</value>
        </list>
   </property>
  </bean>
  
  
  <!-- 生成代理 -->
   <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="myProxyFactoryBean">
      <property name="target" ref="BookBiz"></property><!--1.找到目标对象  -->
      <property name="proxyInterfaces"><!-- 2.找到代理应该实现的接口列表(List)  (生产出的代理必定要实现 目标对象所实现的接口)-->
        <list>
           <value> com.zking.aop.biz.BookBiz</value>
        </list>
      </property>
      <property name="interceptorNames"><!--3.需要应用到目标对象上的通知Bean的名字。(List)  -->
          <list>
            <value>myMethodBeforeAdvice</value><!--前置通知:在买书,评论前添加 日志 -->
             <!-- <value>myAfterReturningAdvice</value> --><!-- 后置通知  买书返利(有bug) -->
            <value>myMethodInterceptor</value><!-- 环绕通知   -->
            <value>myThrowsAdvice</value> <!--异常通知   价格异常-->
            <value>myAfterReturningAdvice2</value><!-- 过滤通知   处理买书返利的bug -->
         </list>
      </property>
      
   </bean>
   
   
   
</beans>