spring - AOP

什么是AOP编程

AOP: Aspect Oriented Programming 面向切面编程。 　面向切面编程(也叫面向方面)：Aspect Oriented Programming(AOP),是目前软件开发中的一个热点。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。

---

AOP中关键性概念

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

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

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

• 代理(Proxy)：将通知应用到目标对象后创建的对象(代理=目标+通知),
  例子：外科医生+护士
  注3：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的

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

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

---

学习目标

1. 前置通知
2. 后置通知
3. 环绕通知
4. 异常通知
5. 过滤通知

IBookBiz .java 接口

package com.hyf.aop.biz;

public interface IBookBiz {
	// 购书
	public boolean buy(String userName, String bookName, Double price);

	// 发表书评
	public void comment(String userName, String comments);
}

实现接口类

package com.hyf.aop.biz.impl;

import com.hyf.aop.Exception.PriceException;
import com.hyf.aop.biz.IBookBiz;

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

异常处理类

RuntimeException 运行时异常，只要程序报了这个错就会停止运行

package com.hyf.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);
	}
	
}

---

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

package com.hyf.aop.advice;

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

import org.springframework.aop.MethodBeforeAdvice;

/**
 * 前置通知
 * 买书、评论前加系统日志
 * @author 17628
 *
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {

	@Override
	public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
    // 在这里，可以获取到目标类的全路径以及方法参数，然后就可以将他们写到日志表里去
         // 类 地址
		String targe = arg2.getClass().getName();
		// 方法
		String methodName = arg0.getName(); 
		// 参数
		String args = Arrays.toString(arg1);
		
		// 加系统日志
		System.out.println("[前置通知：系统日志]："+targe+"类       "+methodName+" 方法 "+args+"参数");
	}
}

spring-context.xml

    <!-- 目标  -->
    <bean class="com.hyf.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!-- 前置通知  -->
    <bean class="com.hyf.aop.advice.MyMethodBeforeAdvice" id="myMethodBeforeAdvice"></bean>
    
    <!-- 利用目标+通知生成代理对象  -->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
        <!-- 目标对象  -->
        <property name="target" ref="bookBiz"></property>
        <!-- 代理应该实现的接口列表(List) -->
        <property name="proxyInterfaces">
              <list>
                   <value>com.hyf.aop.biz.IBookBiz</value>
              </list>
        </property>
        <!-- 需要应用到目标对象上的通知Bean的名字 拦截器  -->
        <property name="interceptorNames">
               <list>
                     <value>myMethodBeforeAdvice</value>
               </list>
        </property>        
    </bean>

测试：

public static void main(String[] args) {
	 ApplicationContext springContext = new ClassPathXmlApplicationContext("/spring-context.xml");
	 IBookBiz bean = (IBookBiz) springContext.getBean("bookProxy");
	 bean.buy("压缩", "java入门", 99.99);
	 bean.comment("压缩", "还可以");
}

---

后置通知(org.springframework.aop.AfterReturningAdvice)：在连接点正常完成后执行的通知
即：每调用一次buy方法打印：“[ 销售返利 ] [ 时间 ]返利3元。”

它比前置函数多了一个 参数 返回值 Object arg0

package com.hyf.aop.advice;

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

import org.springframework.aop.AfterReturningAdvice;

/**
 * 后置通知
 * @author 17628
 *
 */
public class MyAfterReturningAdvice implements AfterReturningAdvice {

	public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
		// 在这里，可以获取到目标类的全路径以及方法参数，然后就可以将他们写到日志表里去    
		String target = arg3.getClass().getName();
		//  方法
		String methodName = arg1.getName();
		//  参数
		String args2 = Arrays.toString(arg2);
		//  返回值 arg0
		
		
		System.out.println("【后置参数：买书返利】: 类地址  "+target+" 方法 "+methodName+" 参数 "+args2+" 返回值 "+arg0 );
		
	}
}

在 spring-context.xml 中 需要配置的

 <!-- 后置通知 -->
    <bean class="com.hyf.aop.advice.MyAfterReturningAdvice" id="myAfterReturningAdvice"></bean>
<!-- 需要应用到目标对象上的通知Bean的名字 拦截器  -->
        <property name="interceptorNames">
               <list>
                     <value>myMethodBeforeAdvice</value>
                     <value>myAfterReturningAdvice</value>
               </list>
        </property>        

测试
还是上面那个测试方法

---

环绕通知
org.aopalliance.intercept.MethodInterceptor
类似拦截器，会包括切入点，目标类前后都会执行代码。

package com.hyf.aop.advice;

import java.util.Arrays;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
 
/**
 * 环绕通知
 * 包含了前置和后置通知
 * @author 17628
 *
 */
public class MyMethodInterceptor implements MethodInterceptor {
	@Override
	public Object invoke(MethodInvocation arg0) throws Throwable {
       String target = arg0.getThis().getClass().getName();
       String methodName = arg0.getMethod().getName();
       String args = Arrays.toString(arg0.getArguments());
	   System.out.println("【环绕通知调用前】: 类地址  "+target+" 方法 "+methodName+" 参数 "+args);

//       arg0.proceed() 调用目标对象的方法
       Object proceed = arg0.proceed();
	   System.out.println("【环绕通知调用后】:  返回值 "+proceed );
		return proceed;
	}
}

   <!-- 环绕通知 -->
    <bean class="com.hyf.aop.advice.MyMethodInterceptor" id="myMethodInterceptor"></bean>

 <!-- 需要应用到目标对象上的通知Bean的名字 拦截器  -->
        <property name="interceptorNames">
               <list>
                     <value>myMethodInterceptor</value>
               </list>
        </property>      

同上 测试方法

---

异常通知
org.springframework.aop.ThrowsAdvice
出现异常执行系统提示，然后进行处理。价格异常为例

这个接口里面没有定义方法，我们要求我们的类必须实现afterThrows这个方法
public void afterThrowing( [Method method,] [Object args,] [Object target,] Throwable throwable );
前面三个参数都是可选的，只有第三个参数是必须的,同时我们还可以在同一个类中定义这个方法的多个版本，如：
public void afterThrowing( MyException1 ex ) {}
public void afterThrowing( MyException2 ex ) {}
具体那个方法被调用则根据具体的Exception来判断，由AOP容器自动识别 执行

package com.hyf.aop.advice;

import org.springframework.aop.ThrowsAdvice;

import com.hyf.aop.Exception.PriceException;

public class MyThrowsAdvice implements ThrowsAdvice {
     public void afterThrowing(PriceException ex) {
    	 System.out.println("异常通知 ：当价格发生异常，那么执行此代码块");
     }
}

 <!-- 异常通知  -->
    <bean class="com.hyf.aop.advice.MyThrowsAdvice" id="myThrowsAdvice"></bean>

<property name="interceptorNames">
               <list>
                     <value>myMethodBeforeAdvice</value>
                     <value>myAfterReturningAdvice</value>
                     <value>myMethodInterceptor</value>
                     <value>myThrowsAdvice</value>
               </list>
        </property>        

---

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

针对与 后置通知进行过滤

  <!--过滤通知  -->
    <bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" id="myAfterReturningAdvicePlus">
         
         <property name="advice" ref="myAfterReturningAdvice"></property>
         <property name="pattern" value=".*buy"></property>
    </bean>


 <!-- 需要应用到目标对象上的通知Bean的名字 拦截器  -->
        <property name="interceptorNames">
               <list>
                     <value>myMethodBeforeAdvice</value>
                    <!--  <value>myAfterReturningAdvice</value> 把后置通知注释 -->
                    <!-- 这个代表 后置通-->
                     <value>myAfterReturningAdvicePlus</value>
                     <value>myMethodInterceptor</value>
                     <value>myThrowsAdvice</value>
               </list>
        </property>