Spring的AOP开发（基于ApsectJ的注解）

创建项目，导包

编写目标类并配置

创建OrderDao

package com.rick.aop.demo1;

public class OrderDao {
	public void save() {
		System.out.println("保存订单。。。。");
	}
	public void update() {
		System.out.println("修改订单。。。。");
	}
	public void delete() {
		System.out.println("删除订单。。。。");
	}
	public void find() {
		System.out.println("查询订单。。。。");
	}

}

配置文件

<?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"
	xmlns:tx="http://www.springframework.org/schema/tx"
	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.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx.xsd">

	<!-- 配置目标类 -->
	<bean id = "orderDao" class = "com.rick.aop.demo1.OrderDao"></bean>
</beans>

编写切面类并配置

创建MyAspectAnno类

package com.rick.aop.demo1;

/*
 * 注解方式的切面类
 */
public class MyAspectAnno {

	public void before() {
		System.out.println("前置增强====");
	}
}

配置文件

<!-- 配置切面类 -->
<bean id = "myAspect" class = "com.rick.aop.demo1.MyAspectAnno"></bean>

使用注解的AOP对象目标类进行增强

在配置文件中打开注解的AOP开发

<!-- 打开注解的AOP开发 -->
<aop:aspectj-autoproxy/>

在切面类上使用注解(修改MyAspectAnno 类)

由此类可见注解的方式开发快速，但是后期维护需要修改源代码！

package com.rick.aop.demo1;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/*
 * 注解方式的切面类
 */

@Aspect
public class MyAspectAnno {

	@Before(value="execution(* com.rick.aop.demo1.OrderDao.save(..))")
	public void before() {
		System.out.println("前置增强====");
	}
}

编写测试类

导入 spring-test   jar包

package com.rick.aop.demo1;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/*
 * 测试类
 */

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestDemo {
	@Resource(name = "orderDao")
	private OrderDao orderDao;
	@Test
	public void demo1() {
		orderDao.save();
		orderDao.update();
		orderDao.delete();
		orderDao.find();

	}

}

其他通知：

package com.rick.aop.demo1;

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;

/*
 * 注解方式的切面类
 */

@Aspect
public class MyAspectAnno {

	// 前置增强
	@Before(value = "execution(* com.rick.aop.demo1.OrderDao.save(..))")
	public void before() {
		System.out.println("前置增强====");
	}

	// 后置增强
	@AfterReturning("execution(* com.rick.aop.demo1.OrderDao.delete(..))")
	public void afterReturning() { // 后置还可以获得方法返回值，上一篇基于XML方式的文章已经说明此处不再赘述
		System.out.println("后置增强====");
	}

	// 环绕通知
	@Around("execution(* com.rick.aop.demo1.OrderDao.update(..))")
	public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
		System.out.println("环绕增强前====");
		Object object = joinPoint.proceed();
		System.out.println("环绕增强后====");
		return object;
	}

	// 异常抛出通知
	@AfterThrowing(value = "execution(* com.rick.aop.demo1.OrderDao.find(..))", throwing = "e")
	public void afterThrowing(Throwable e) {
		System.out.println("异常抛出增强====" + e.getMessage());
	}

	// 最终通知
	@After(value = "execution(* com.rick.aop.demo1.OrderDao.find(..))")
	public void after() {
		System.out.println("最终增强====");
	}
}

测试

Spring的注解的AOP的切入点的配置

修改MyAspectAnno类