Spring Aop 初探（3）

来源：互联网发布：数控车床圆弧编程实例编辑：程序博客网时间：2024/05/16 01:20

只是为了自己更容易记住，理解相关内容，所以写了一篇简单的文章，主要还是参考前辈的大作完成。各位高手勿喷，博客仅用于个人练习。

前面两篇都是通过代码的方式实现 Spring AOP 的相关内容，这篇文章和前面一篇稍微有点差异，后面会具体分析。

1. 创建maven工程，pom 文件主要内容如下：

<dependencies>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>

<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.9</version>
</dependency>
</dependencies>

这个文件的内容，与前面几个文件的内容基本相同，完成pom文件后，通过maven update下载相应的 jar

2. 创建一个接口 ArithmeticCalculator，主要内容如下：

package com.tanj.test.service;
public interface ArithmeticCalculator {
public int add(int i, int j);
public int sub(int i, int j);
public int mul(int i, int j);
public int div(int i, int j);
}

3. 创建对应接口的类，ArithmeticCalculatorImpl：

package com.tanj.test.service;
import org.springframework.stereotype.Component;
@Component
public class ArithmeticCalculatorImpl implements ArithmeticCalculator {
@Override
public int add(int i, int j) {
return i+j;
}
@Override
public int sub(int i, int j) {
return i-j;
}
@Override
public int mul(int i, int j) {
return i*j;
}
@Override
public int div(int i, int j) {
return i/j;
}
}

4. 创建Spring的配置文件applicationContext.xml ：

5. 创建aspect 文件，切面文件ArithmeticAspect：

package com.tanj.test.service;
import java.util.Arrays;
import java.util.List;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class ArithmeticAspect {
/**
* 声明切入点表达式，一般在该方法中不再添加其他代码。
* 使用@Pointcut来声明切入点表达式。
* 后面的通知直接使用方法名来引用当前的切入点表达式。
*/
@Pointcut("execution(public int com.tanj.test.service.ArithmeticCalculator.*(..))")
public void declareJoinPointExpression() {}

/**
*前置通知，在目标方法开始之前执行。
*@Before("execution(public int com.tanj.test.service.ArithmeticCalculator.add(int, int))")这样写可以指定特定的方法。
* @param joinpoint
*/
@Before("declareJoinPointExpression()")
//这里使用切入点表达式即可。后面的可以都改成切入点表达式。如果这个切入点表达式在别的包中，在前面加上包名和类名即可。
public 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);
}

/**
*后置通知，在目标方法执行之后开始执行，无论目标方法是否抛出异常。
*在后置通知中不能访问目标方法执行的结果。
* @param joinpoint
*/
@After("execution(public int com.tanj.test.service.ArithmeticCalculator.*(int, int))")
public void afterMethod(JoinPoint joinpoint) {
String methodName = joinpoint.getSignature().getName();
//List<Object>args = Arrays.asList(joinpoint.getArgs()); 后置通知方法中可以获取到参数
System.out.println("后置通知：The method "+ methodName +" ends ");
}

/**
*返回通知，在方法正常结束之后执行。
*可以访问到方法的返回值。
* @param joinpoint
* @param result 目标方法的返回值
*/
@AfterReturning(value="execution(public int com.tanj.test.service.ArithmeticCalculator.*(..))", returning="result")
public void afterReturnning(JoinPoint joinpoint, Object result) {
String methodName = joinpoint.getSignature().getName();
System.out.println("返回通知：The method "+ methodName +" ends with " + result);
}
/**
*异常通知。目标方法出现异常的时候执行，可以访问到异常对象，可以指定在出现特定异常时才执行。
*假如把参数写成NullPointerException则只在出现空指针异常的时候执行。
* @param joinpoint
* @param e
*/
@AfterThrowing(value="execution(public int com.tanj.test.service.ArithmeticCalculator.*(..))", throwing="e")
public void afterThrowing(JoinPoint joinpoint, Exception e) {
String methodName = joinpoint.getSignature().getName();
System.out.println("异常通知：The method "+ methodName +" occurs exception " + e);
}
}

6. 创建测试类MainTest:

package com.tanj.test.service;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainTest {
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
ArithmeticCalculator arithmeticCalculator = (ArithmeticCalculator)context.getBean("arithmeticCalculator");
int result = arithmeticCalculator.add(4, 6);
System.out.println(result);
result = arithmeticCalculator.sub(4, 6);
System.out.println(result);
System.out.println(result);
result = arithmeticCalculator.mul(4, 6);
System.out.println(result);
System.out.println(result);
result = arithmeticCalculator.div(4, 2);
System.out.println(result);
}
}

7. 运行main 方法，可以看到结果。

注意：

1. 没有采用上一篇文章中的方式进行处理，采用了另外一种方式，其实本篇和上一篇基本相同，只不过换了一种方式实现。

参考的博客如下：

http://shamrock.blog.51cto.com/2079212/1557639，

本文与参考的博客稍微有点差异，改动少许即可完成博客中案例，注意红色标注部分：

改动处1：applicationContext.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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd">
<aop:aspectj-autoproxy />
<context:component-scan base-package="com.tanj.test.service"></context:component-scan>



</beans>

改动处2：MainTest：

public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

//ArithmeticCalculator arithmeticCalculator = (ArithmeticCalculator)context.getBean("arithmeticCalculator");
ArithmeticCalculator arithmeticCalculator = context.getBean(ArithmeticCalculator.class);
int result = arithmeticCalculator.add(4, 6);
System.out.println(result);
result = arithmeticCalculator.sub(4, 6);
System.out.println(result);
System.out.println(result);
result = arithmeticCalculator.mul(4, 6);
System.out.println(result);
System.out.println(result);
result = arithmeticCalculator.div(4, 2);
System.out.println(result);
}

改动3，另外就是在定义实现类的时候，用了注解 @Component 的方式，所以可以采用自动扫描的方式实现。即不需要在Spring的配置文件中进行显示定义，只需要指定扫描的目录即可。

阅读全文

0 0