Spring-AOP配置-注解方式

常用注解

@Aspect
作用：
把当前类声明为切面类。

@Before
作用：
把当前方法看成是前置通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用。

@AfterReturning
作用：
把当前方法看成是最终通知。报异常，就不执行
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用。

@AfterThrowing
作用：
把当前方法看成是异常通知。只有报异常才执行
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用。

@After
作用：
把当前方法看成是后置通知。不管报不报异常都执行
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用。

@Around
作用：
把当前方法看成是环绕通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用。

@Pointcut
作用：
指定切入点表达式
属性：
value：指定表达式的内容

配置环境

UserService 接口

package com.ywq.spring.service;

import com.ywq.spring.pojo.User;

public interface UserService {
	void insert(User user);
	void update(User user);
}

业务层UserServiceImpl 实现类

package com.ywq.spring.service.impl;

import com.ywq.spring.pojo.User;
import com.ywq.spring.service.UserService;

@Service
public class UserServiceImpl implements UserService{
	
	public void insert(User user) {
		System.out.println("---调用DAO层保存方法---");
	}
	public void update(User user) {
		System.out.println("---调用DAO层修改方法---");
	}
}

切面类

package com.ywq.spring;

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.stereotype.Component;

@Component
@Aspect //在此类中可以使用注解进行aop的相关配置 <aop:aspect>
public class TransactionManagerHandler {
	
	//<aop:pointcut expression="execution( * com.ywq.spring.service..*.*(..))" id="当前方法名就是id"/>
	@Pointcut("execution( * com.ywq.spring.service..*.*(..))")
	public void pointcut() {}
	
	@Before("pointcut()") //<aop:before method="begin" pointcut-ref="pt"/>
	public void begin() {
		System.out.println("开启事务");
	}
	
	@AfterReturning("pointcut()")//<aop:after-returning method="commit" pointcut-ref="pt"/> 
	public void commit() {
		System.out.println("提交事务");
	}
	
	//<aop:after-throwing  throwing="e"  method="rollback" pointcut-ref="pt"/>
	@AfterThrowing(pointcut="pointcut()",throwing="ex")
	public void rollback(Throwable ex) {
		System.out.println("注解的回滚事务 : " + ex.getMessage());
	}
	
	@After("pointcut()")//<aop:after method="close"  pointcut-ref="pt"/>
	public void close() {
		System.out.println("关闭session");
	}
	
	//环绕增强
	@Around("pointcut()") //<aop:around method="allInOne" pointcut-ref="pt"/>
	public Object allInOne(ProceedingJoinPoint pjp) {
		Object result = null;
		try {
			System.out.println("开启事务------");
			//执行被代理对象当前需要执行业务方法
			result = pjp.proceed();
			System.out.println("提交事务------");
		} catch (Throwable ex) {
			System.out.println("------回滚事务 : " + ex.getMessage());
		}finally {
			System.out.println("关闭session------");
		}
		return result;
	}
}

AOPxml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    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
    ">
   <!-- 配置spring的包扫描 -->
   <context:component-scan base-package="com.ywq.spring"/>	
   <!-- 使用注解配置AOP配置配置自动注入AOP -->
   <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

纯注解配置

package com.ywq.spring.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.ywq.spring")
@EnableAspectJAutoProxy //开启aop注解配置
public class SpringConfig {

}

测试代码

package com.ywq.spring.test;

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;

import com.ywq.spring.pojo.User;
import com.ywq.spring.service.impl.UserServiceImpl;

@RunWith(SpringJUnit4ClassRunner.class)
//读取Spring配置文件 xml
//@ContextConfiguration("classpath:applicationContext.xml")
//读取Spring配置文件 java类做配置文件
@ContextConfiguration(classes = {SpringConfig.class})
public class UserServiceTest {

	@Resource
	private UserServiceImpl service;

	@Test
	public void testSave() {
		User user = new User(null, "张三", "zhangsan@qq.com");
		service.insert(user);
	}

	@Test
	public void testUpdate() {
		User user = new User(1, "李四", "lisi@qq.com");
		service.update(user);
	}
}