spring的通知

一.基于注解

1.

package com.beans1;

public interface Calculator {

	public int add(int n,int m);
	public int sub(int n,int m);
	public int mul(int n,int m);
	public int div(int n,int m);
}

package com.beans1;

import org.springframework.stereotype.Component;

@Component("calculator")
public class CalculatorImpl implements Calculator {

	@Override
	public int add(int n, int m) {
		int result = n+m;
		return result;
	}

	@Override
	public int sub(int n, int m) {
		int result = n-m;
		return result;
	}

	@Override
	public int mul(int n, int m) {
		int result = n*m;
		return result;
	}

	@Override
	public int div(int n, int m) {
		int result = n/m;
		return result;
	}

}

　2.

package com.beans1;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;

//把类声明为切面 1.把切面放在ioc容器里   2.声明为一个切面 3.@order指定切面的优先级，值越小优先级越高
@Order(2)
@Aspect
@Component
public class LoggingAspect {

	/*定义一个方法，用于声明切入点表达式,该方法不需要添加其他的代码
	 * 1.同一个类下使用declareJoinPoint()
	 * 2.同一个包下LoggingAspect.declareJoinPoint()
	 * 3.不通包com.beans1.LoggingAspect.declareJoinPoint()
	 * */
	@Pointcut("execution(* com.beans1.Calculator.*(..))")
	public void declareJoinPoint(){}
	
	//声明为一个前置通知
	//执行：execution(public int com.beans1.Calculator.add(int, int))
	@Before("declareJoinPoint()")	
	public void before(JoinPoint joinpoint){
		String methodName = joinpoint.getSignature().getName();
		List<Object> arges =Arrays.asList(joinpoint.getArgs());
		System.out.println("this method before: "+methodName+" "+arges);
	}
	//声明为一个后置通知:无论方法是否异常，都会在方法后执行
	@After("declareJoinPoint()")
	public void after(JoinPoint joinpoint){
		String methodName = joinpoint.getSignature().getName();
		List<Object> arges =Arrays.asList(joinpoint.getArgs());
		System.out.println("this method after: "+methodName+" "+arges);
	}
	
	//程序正常执行结束受返回的值
	//返回通知可以访问方法的返回值
	
	@AfterReturning(value="declareJoinPoint()",returning="result")
	public void afterReturn(JoinPoint joinpoint,Object result){
		String methodName = joinpoint.getSignature().getName();
		List<Object> arges =Arrays.asList(joinpoint.getArgs());
		System.out.println("this method afterReturning: "+methodName+" "+arges+" "+result);
	}
	//异常通知
	@AfterThrowing(value="declareJoinPoint()",throwing="ex")
	public void afterThrowing(JoinPoint joinpoint,Exception ex){
		String methodName = joinpoint.getSignature().getName();
		List<Object> arges =Arrays.asList(joinpoint.getArgs());
		System.out.println("this method afterThrowing: "+methodName+" "+arges+" "+ex.getMessage());
	}
	
	/*
	 * 环绕通知需要携带ProceedingJoinPoint参数
	 * 环绕通知类似于动态代理的全过程 ProceedingJoinPoint 可以决定是否执行目标方法
	 * 且环绕通知必须有返回值，返回值为目标方法返回值
	 * */
	/*@Around(value="execution(* com.beans1.Calculator.*(..))")
	public Object around(ProceedingJoinPoint procceed){
		Object result  = null;
		String methodName = procceed.getSignature().getName();	
		List<Object> arges =Arrays.asList(procceed.getArgs());
		try {
			//前置通知
			System.out.println("this start:"+methodName+"  "+ arges);
			//执行目标方法
			result  = procceed.proceed();
			//后置通知
			System.out.println("this end:"+methodName+"  "+ arges);
		} catch (Throwable e) {
			//异常通知
			e.printStackTrace();
		}
		
		return result;
	}*/
}

　　3.

<?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:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		">
		<!-- 配置自动扫描的包 -->
		<context:component-scan base-package="com.beans1"></context:component-scan>
		<!-- 自动为匹配的类生成代理对象 -->
		<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

　　4.

package com.beans1;

import java.sql.SQLException;

import javax.sql.DataSource;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

	public static void main(String[] args) throws SQLException{
		ApplicationContext context =
				new  ClassPathXmlApplicationContext("applicationContext.xml");
		Calculator cal = (Calculator) context.getBean("calculator");
		int result = cal.add(1, 5);
		System.out.println(result);
		
		result = cal.div(10, 2);
		System.out.println(result);
	}

}

　二。基于xml

1.去掉上面所有注解

2.

<?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:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		">
		
	　　　　　<!--配置bean-->
		<bean id="calculator" class="com.beans1.CalculatorImpl"></bean>
		<bean id="loggingAspect" class="com.beans1.LoggingAspect"></bean>
		<bean id="validateAspect" class="com.beans1.ValidateAspect"></bean> 
		
		<!-- 配置aop -->
		<aop:config>
			<!-- 配置切点表达式 -->
			<aop:pointcut id="pointcut" expression="execution(* com.beans1.Calculator.*(..))" />
			<!-- 配置切面及通知 -->
			<aop:aspect ref="loggingAspect" order="2">
				<!--  
				<aop:before method="before"  pointcut-ref="pointcut"/>
				<aop:after method="after" pointcut-ref="pointcut"/>
				<aop:after-returning method="afterReturn" pointcut-ref="pointcut" returning="result"/>
				<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="ex"/>
				-->
				<aop:around method="around" pointcut-ref="pointcut" />
			</aop:aspect>
			<aop:aspect ref="validateAspect" order="1">
				<aop:before method="validateArgs" pointcut-ref="pointcut"/>			
			</aop:aspect>
		</aop:config>
</beans>