Spring AOP的五大通知

Spring AOP的五大通知

直接案例看一哈，解释也在里面

首先一个接口，里面若干方法

package com.ym.dao;
public interface IMathEnt {
	public int  addUser(int i,int j);
	public int  subUser(int i,int j);
	public int 	rideUser(int i,int j);
	public int 	exceptUser(int i,int j);
}

这里接口的实现类整一个DMathEnt 类

package com.ym.dao.impl;

import com.ym.dao.IMathEnt;

public class DMathEnt implements IMathEnt {

	@Override
	public int addUser(int i, int j) {
		int ret=i+j;
		System.out.println("执行的方法是：addUser=>>> 结果为：" +ret );
		return ret;
	}

	@Override
	public int subUser(int i, int j) {
		int ret=i-j;
		System.out.println("执行的方法是：subUser=>>> 结果为：" +ret );
		return ret;
	}

	@Override
	public int rideUser(int i, int j) {
		int ret=i*j;
		System.out.println("执行的方法是：rideUser=>>> 结果为：" +ret );
		return ret;
	}

	@Override
	public int exceptUser(int i, int j) {
		int ret=i/j;
		System.out.println("执行的方法是：exceptUser=>>> 结果为：" +ret );
		return ret;
	}

}

然后在整一个 ObjectAspect 类 （qie面）

package com.ym.pointcut;
import java.util.Arrays;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
public class ObjectAspect {

	/*这里说哈 JoinPoint joinpoint 参数，都放在参数列表第一个，这样不会报错*/

	
	//写通知  前置通知
	public void methodBegin(JoinPoint joinpoint){
		//获取签名参数 ：joinPiint传递的参数形式
		
		Signature signature	=joinpoint.getSignature();
		//方法传递的实际参数
		Object[] args=joinpoint.getArgs();
		
		System.out.println("[前置通知] 执行了方法：["+signature.getName()+"]参数列表为："+Arrays.asList(args));
	}
	//返回通知
	public void methodReturn(JoinPoint joinpoint,Object resutl){
		//获取签名参数 ：joinPiint传递的参数形式
		Signature signature	=joinpoint.getSignature();
		String methodName=signature.getName();
		
		System.out.println("[返回通知] 执行了方法：["+methodName+"]返回结果为："+resutl);
	}
	//返回异常通知
	public void methodThrow(JoinPoint joinpoint,ArithmeticException throwable){
		//获取签名参数 ：joinPiint传递的参数形式
		String methodName	=joinpoint.getSignature().getName();
		String message=throwable.getMessage();
		
		System.out.println("[异常通知] 执行了方法：["+methodName+"]返回异常信息为："+message);
	}
	//后置通知
	
	public void methodFinallEnd(JoinPoint joinpoint){
		//获取签名参数 ：joinPiint传递的参数形式
		String methodName	=joinpoint.getSignature().getName();
		System.out.println("[后置通知] 执行了方法：["+methodName+"]");
	}
	
	//环绕通知
		public Object myArround(ProceedingJoinPoint joinPoint){
			//获取签名参数 ：joinPiint传递的参数形式
			String methodName = joinPoint.getSignature().getName();
					
			//获取参数
			Object[] args = joinPoint.getArgs();
			
			System.out.println("[环绕通知] 执行了方法：["+methodName+"]开始执行的参数为："+Arrays.asList(args));
			
			Object resutl = null;
			
			try {
				resutl = joinPoint.proceed();
				//执行result表示 方法执行 结束
				System.out.println("[环绕通知] 执行了方法：["+methodName+"]正常结束，结果为："+resutl+"【环绕通知】");
				
			} catch (Throwable e) {
				System.out.println("[环绕通知] 执行了方法：["+methodName+"]抛出异常，异常信息为："+e.getMessage()+"【环绕通知】");
			}finally{
				System.out.println("[环绕通知] 执行了方法：["+methodName+"]最终结束");
			}
			return resutl;
		}
	
}

再然后：applicationContext.xml里面这样配置：

<beans
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	<!-- 注意这里“xmlns:aop”是新添加的哦 -->
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
						http://www.springframework.org/schema/beans/spring-beans-4.1.xsd						
						http://www.springframework.org/schema/aop
						http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
						">
	<!-- 通知对象 -->
	<bean id="objAspect" class="com.ym.pointcut.ObjectAspect"></bean>
	<!-- 切面配置 -->
	<aop:config>
		<!--切点配置 -->
									<!--
										  execution(*com.ym.dao.*.*(..)))  
										 第一个*表示任意返回值  
										 第二个*表示com.ym.dao包中所有类  
										 第三个*表示以所有的方法  
										（..）表示任意参数  
								也可以这样表示： 
										 execution(* com.ym.dao.*.add*(..))  
										 第一个*表示任意返回值  
										 第二个*表示com.ym.dao包中所有类  
										 第三个*表示以add开头的所有方法  
									    （..）表示任意参数  
										 这里说哈execution括号里面的意思： “com.ym.dao.下面的所有的子包，所有的类，所有的方法”
									-->

		<!-- 
			  切入点表达式
			  符合切入点表达式的类要产生代理对象
			  expression就是切入点表达式
			  id 标示符
		 -->
		<aop:pointcut expression="execution(* com.ym.dao.*.*(..))" id="pc"/>
		<!--
			 前置通知（before）：在目标方法执行之前执行
	
			后置通知（after）：在目标方执行完成后执行，如果目标方法异常，则后置通知不再执行
	
			异常通知（after-throwing）：目标方法抛出异常的时候执行
	
			返回通知（after-returning）；不管目标方法是否有异常都会执行，相当于try。。catch。。finally中的finally
	
			环绕通知（round）：可以控制目标方法是否执行 
		-->
		<!-- 切面的通知引入 ，要按照下面的顺序写，不然出错 -->


		<aop:aspect ref="objAspect">
			<!-- 
				前置通知:
				  	 	 1、在目标方法执行之前
				   		 2、前置通知中，方法有一个参数JoinPoint
			 -->
			<aop:before method="methodBegin" pointcut-ref="pc"/>
			<!-- 
				返回通知:
						  1、在目标方法执行之后
						  2、能够获取目标方法的返回值 returning="resutl" resutl就是返回通知中的参数名称
			 -->
			<aop:after-returning method="methodReturn" pointcut-ref="pc" returning="resutl"/>
			<!-- 
				异常通知:
			          	1、获取目标方法抛出的异常信息
						2、throwing="throwable"
			 -->
			<aop:after-throwing method="methodThrow" pointcut-ref="pc" throwing="throwable"/>
			<!-- 
				后置通知:
					   1、在目标方法执行之后
			 -->
			<aop:after method="methodFinallEnd" pointcut-ref="pc"/>
			<!-- 
				环绕通知:
					  	1、能够控制目标方法的执行
					  	2、环绕通知可以有返回值，这个返回值就是代理对象的方法的返回值
					  	3、前置通知和后置通知只能在目标方法执行之前和之后加代码，但是不能控制目标方法的执行
			 -->
			<aop:around method="myArround" pointcut-ref="pc"/>
		</aop:aspect>
	
	</aop:config>
	
	<!-- 创建通知类对象 实现类 -->
	<bean id="dMathEnt" class="com.ym.dao.impl.DMathEnt"></bean>
	<bean id="dUserInfo" class="com.ym.dao.impl.DUserInfo"></bean>
</beans>

最后来个测试类

package com.ym.test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.ym.dao.IMathEnt;
public class TestDemo {
	public static void main(String[] args) {
		/*获取配置 spring环境*/
		BeanFactory bf = new  ClassPathXmlApplicationContext("applicationContext.xml");
		//获取接口对象
		IMathEnt imath = bf.getBean("dMathEnt",IMathEnt.class);
		imath.addUser(20, 5);
		//imath.exceptUser(20, 0);
	}
}