Spring AOP初步，面向切面编程的方法

main

package com.bin.aop;

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

public class Main {
	public static void main(String[] args) {
//		ArithmeticCalculator arithmeticCalculator = null;
//		arithmeticCalculator = new ArithmeticCalculatorImpl();
//		
//		int result = arithmeticCalculator.mul(4, 5);
//		System.out.println(result);
		
		//获得IOC容器
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		ArithmeticCalculator arithmeticCalculator  = ctx.getBean(ArithmeticCalculator.class);
		
		int result = arithmeticCalculator.add(2,6);
		System.out.println(result);
		
		result = arithmeticCalculator.div(12,2);
		System.out.println(result);
	}
}

ArithmeticCalculatorImpl

package com.bin.aop;

import org.springframework.stereotype.Component;

@Component
public class ArithmeticCalculatorImpl implements ArithmeticCalculator{

	@Override
	public int add(int i, int j) {
		int result = i+j;
		return result;
	}

	@Override
	public int sub(int i, int j) {
		int result = i-j;
		return result;
	}

	@Override
	public int mul(int i, int j) {
		int result = i*j;
		return result;
	}

	@Override
	public int div(int i, int j) {
		int result = i/j;
		return result;
	}

}

applicationContext

<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

<!-- 配置自动扫描的包 -->
<context:component-scan base-package="com.bin.aop"></context:component-scan>

<!-- 使AspjectJ 注解起作用 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

ArithmeticCalculator

package com.bin.aop;


public interface ArithmeticCalculator {
	
	int add(int i,int j);
	int sub(int i,int j);
	
	int mul(int i,int j);
	int div(int i,int j);
}

LoggingAspect：切面

package com.bin.aop;

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

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.weaver.tools.JoinPointMatch;
import org.springframework.stereotype.Component;

//把这个类声明成一个切面：需要把该类放到IOC容器中，再声明为一个切面
@Aspect
@Component
public class LoggingAspect {
	
	//声明该方法是一个前置通知:在目标方法开始之前执行
	@Before("execution(public int com.bin.aop.ArithmeticCalculator.*(int,int))")
	private void beforeMethod(JoinPoint joinPoint) {
		String methodName = joinPoint.getSignature().getName();
		List<Object> args = Arrays.asList(joinPoint.getArgs());
		
		
		System.out.println("the method "+ methodName +" begins with " + args);
	}
		
	//声明该方法是一个后置通知（无论是否发生异常）:在目标方法开始之后执行
	@After("execution(public int com.bin.aop.ArithmeticCalculator.*(int,int))")
	private void afterMethod(JoinPoint joinPoint) {
		String methodName = joinPoint.getSignature().getName();		
		System.out.println("the method "+ methodName +" ends with ");
	}
	
	//在方法正常结束后执行的代码
	//返回通知是可以访问到方法的返回值的
	@AfterReturning(value="execution(public int com.bin.aop.ArithmeticCalculator.*(..))"
			,returning="result")
	private void afterReturning(JoinPoint joinPoint,Object result) {
		String methodName = joinPoint.getSignature().getName();		
		System.out.println("the method "+ methodName +" ends with "+result);
	}
	
	//声明该方法是一个后置通知（无论是否发生异常）:在目标方法开始之后执行
	@AfterThrowing(value="execution(public int com.bin.aop.ArithmeticCalculator.*(int,int))",
			throwing="ex")
	private void afterThrowing(JoinPoint joinPoint,Exception ex) {
		String methodName = joinPoint.getSignature().getName();		
		System.out.println("the method "+ methodName +" occurs excetion "+ex);
	}
	
	/*
	//环绕通知需要携带ProceedingJoinPoint类型的参数
	//环绕通知类似于动态代理的全过程
	//ProceedingJoinPoint类型的参数可以决定是否执行目标方法，且环绕通知必须有返回值，返回值为目标方法的返回值
	@Around(value="execution(public int com.bin.aop.ArithmeticCalculator.*(int,int))")
	private Object aroundMethod(ProceedingJoinPoint pjd) {
		
		Object result = null;
		String methodName = pjd.getSignature().getName();
		//执行目标方法
		try {
			//前置通知
			System.out.println("the method "+ methodName+" begins with "+Arrays.asList(pjd.getArgs()));
			result = pjd.proceed();
			//返回通知
			System.out.println("the method "+ methodName +"  ends with "+result);
		} catch (Throwable e) {
			//e.printStackTrace();
			//异常通知
			System.out.println("the method "+ methodName +" occurs exception:"+e);
			throw new RuntimeException(e);
		}
		//后置通知
		System.out.println("the method "+methodName+" ends");
		return result;
	}
	*/
}