基于注解的 AOP 配置

第一步：在 spring 配置文件中开启 spring 对注解 AOP 的支持

aop:aspectj-autoproxy <aop:aspectj-autoproxy />

第二步：在配置文件中指定 spring 要扫描的包

<context:component-scan base-package="com.itheima"></context:component-scan>

第三步：把通知类也使用注解配置

/**
* 事务控制类
* @author
* @Company
*/
@Component("txManager")
public class TransactionManager {
//定义一个 DBAssit
@Autowired
private DBAssit dbAssit ;
}

第四步：在通知类上使用@Aspect 注解声明为切面

第五步：在增强的方法上使用注解配置通知

第六步：在增强的方法上使用注解配置通知

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

//开启事务
@Before("execution(* com.itheima.service.impl..(..))")
public void beginTransaction() {
try {
dbAssit.getCurrentConnection().setAutoCommit(false);
} catch (SQLException e) {
e.printStackTrace();
}
}

说明：@AfterReturning 、@AfterThrowing 、@After 运用方式同理

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

/**
* 环绕通知
* @param pjp
* @return
/
@Around("execution( com.itheima.service.impl..(..))")
public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值 Object rtValue = null;
try {
//获取方法执行所需的参数
Object[] args = pjp.getArgs();

//前置通知：开启事务
beginTransaction();

//执行方法
rtValue = pjp.proceed(args);
//后置通知：提交事务
commit();
}catch(Throwable e) {
//异常通知：回滚事务
rollback();
e.printStackTrace();
}finally {
//最终通知：释放资源
release();
}
return rtValue;
}

第七步：切入点表达式注解

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

@Pointcut("execution(* com.itheima.service.impl..(..))")
private void pt1() {}

引用方式：

/**
* 环绕通知
* @param pjp
* @return
*/
@Around("pt1()")//注意：千万别忘了写括号
public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值
Object rtValue = null;
try {
//获取方法执行所需的参数
Object[] args = pjp.getArgs();
//前置通知：开启事务
beginTransaction();
//执行方法
rtValue = pjp.proceed(args);
//后置通知：提交事务
commit();
}catch(Throwable e) {
//异常通知：回滚事务
rollback();
e.printStackTrace();
}finally {
//最终通知：释放资源
release();
}
return rtValue;
}

第八步：不使用 XML的配置方

@Configuration
@ComponentScan(basePackages="com.itheima")
@EnableAspectJAutoProxy //开启注解式AOP支持---->aop:aspectj-autoproxy <aop:aspectj-autoproxy />
public class SpringConfiguration { }

例子：

@Component(value = "txManager")
@Aspect //切面类
public class TransactionManager {

@Autowired
private ConnectionUtils connectionUtils;

@Pointcut("execution(* com.atguigu.account.service.impl..(..))")
public void pt1(){}

/**
* 开启事物
*/

public void beginTransaction(){
System.out.println("beginTransaction...开启事物......!");
try {
connectionUtils.getThreadConnection().setAutoCommit(false);
} catch (Exception e) {
e.printStackTrace();
}
}

/**
*提交事务
*/

public void commit(){
System.out.println("commit....提交事务......!");
try {
connectionUtils.getThreadConnection().commit();
} catch (Exception e) {
e.printStackTrace();
}
}

/**
*回滚事物
*/

public void rollback(){
System.out.println("rollback....回滚......!");
try {
connectionUtils.getThreadConnection().rollback();
} catch (Exception e) {
e.printStackTrace();
}
}

/**
*释放连接
*/

public void release(){
System.out.println("release....释放.....!");
try {
connectionUtils.getThreadConnection().close();//还回连接池中
connectionUtils.removeConnection();
} catch (Exception e) {
e.printStackTrace();
}
}

@Around("pt1()")
public Object aroundAdvice(ProceedingJoinPoint pjp){
Object rtValue = null;
try {
//1.获取参数
Object[] args = pjp.getArgs();
//2.开启事务
this.beginTransaction();
//3.执行方法
rtValue = pjp.proceed(args);
//4.提交事务
this.commit();

//返回结果
return rtValue;

}catch (Throwable e){
//5.回滚事务
this.rollback();
throw new RuntimeException(e);
}finally {
//6.释放资源
this.release();
}
}
}