Spring之注解版AOP的使用案例

AOP：【动态代理】
 *         指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；
 * 
 * 1、导入aop模块；Spring AOP：(spring-aspects包)
 * 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx）
 * 3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行；
 *         通知方法：
 *             前置通知(@Before)：logStart：在目标方法(div)运行之前运行
 *             后置通知(@After)：logEnd：在目标方法(div)运行结束之后运行（无论方法正常结束还是异常结束）
 *             返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行
 *             异常通知(@AfterThrowing)：logException：在目标方法(div)出现异常以后运行
 *             环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）
 * 4、给切面类的目标方法标注何时何地运行（通知注解）；
 * 5、将切面类和业务逻辑类（目标方法所在类）都加入到容器中;
 * 6、必须告诉Spring哪个类是切面类(给切面类上加一个注解：@Aspect)
 * [7]、给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】
 *         在Spring中很多的 @EnableXXX;
 * 
 * 关键三步：
 *  1）、将业务逻辑组件和切面类都加入到容器中；告诉Spring哪个是切面类（@Aspect）
 *  2）、在切面类上的每一个通知方法上标注通知注解，告诉Spring何时何地运行（切入点表达式）
 *  3）、开启基于注解的aop模式；@EnableAspectJAutoProxy

---

1、pom.xml中导入Spring AOP的spring-aspects包

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
			<version>4.3.12.RELEASE</version>
		</dependency>

2、定义一个业务逻辑类（MathCalculator.java）

在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx）

package com.atguigu.aop;

public class MathCalculator {
	
	public int div(int i,int j){
		System.out.println("MathCalculator...div...");
		return i/j;	
	}

}

3、定义一个日志切面类（LogAspects.java）

切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行；
 *         通知方法：
 *             前置通知(@Before)：logStart：在目标方法(div)运行之前运行
 *             后置通知(@After)：logEnd：在目标方法(div)运行结束之后运行（无论方法正常结束还是异常结束）
 *             返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行
 *             异常通知(@AfterThrowing)：logException：在目标方法(div)出现异常以后运行
 *             环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）

给切面类上加一个注解：@Aspect，告诉Spring哪个类是切面类；

在切面方法中，根据参数，可以获取目标方法的参数，方法名称及抛出的具体的异常信息；

注意：切点表达式有很多种写法，可参考spring的官方文档；

          JoinPoint一定要出现在参数表的第一位；

package com.atguigu.aop;

import java.util.Arrays;

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;

/**
 * 切面类
 * @author lfy
 * 
 * @Aspect： 告诉Spring当前类是一个切面类
 *
 */
@Aspect
public class LogAspects {
	
	//抽取公共的切入点表达式
	//1、本类引用
	//2、其他的切面引用
	@Pointcut("execution(public int com.atguigu.aop.MathCalculator.*(..))")
	public void pointCut(){};
	
	//@Before在目标方法之前切入；切入点表达式（指定在哪个方法切入）
	@Before("pointCut()")
	public void logStart(JoinPoint joinPoint){
		Object[] args = joinPoint.getArgs();
		System.out.println(""+joinPoint.getSignature().getName()+"运行。。。@Before:参数列表是：{"+Arrays.asList(args)+"}");
	}
	
	@After("com.atguigu.aop.LogAspects.pointCut()")
	public void logEnd(JoinPoint joinPoint){
		System.out.println(""+joinPoint.getSignature().getName()+"结束。。。@After");
	}
	
	//JoinPoint一定要出现在参数表的第一位
	@AfterReturning(value="pointCut()",returning="result")
	public void logReturn(JoinPoint joinPoint,Object result){
		System.out.println(""+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:运行结果：{"+result+"}");
	}
	
	@AfterThrowing(value="pointCut()",throwing="exception")
	public void logException(JoinPoint joinPoint,Exception exception){
		System.out.println(""+joinPoint.getSignature().getName()+"异常。。。异常信息：{"+exception+"}");
	}

}

4、定义配置类

将切面类和业务逻辑类（目标方法所在类）都加入到容器中;

给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】

package com.atguigu.config;



import org.aopalliance.aop.Advice;
import org.aopalliance.intercept.MethodInterceptor;
import org.springframework.aop.Advisor;
import org.springframework.aop.Pointcut;
import org.springframework.aop.framework.AopInfrastructureBean;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

import com.atguigu.aop.LogAspects;
import com.atguigu.aop.MathCalculator;


@EnableAspectJAutoProxy
@Configuration
public class MainConfigOfAOP {
	 
	//业务逻辑类加入容器中
	@Bean
	public MathCalculator calculator(){
		return new MathCalculator();
	}

	//切面类加入到容器中
	@Bean
	public LogAspects logAspects(){
		return new LogAspects();
	}
}

5、测试

注意：spring容器中的组件才能使用spring提供的aop功能；

package com.atguigu.test;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.atguigu.aop.MathCalculator;
import com.atguigu.bean.Boss;
import com.atguigu.bean.Car;
import com.atguigu.bean.Color;
import com.atguigu.bean.Red;
import com.atguigu.config.MainConfigOfAOP;
import com.atguigu.config.MainConifgOfAutowired;
import com.atguigu.dao.BookDao;
import com.atguigu.service.BookService;

public class IOCTest_AOP {
	
	@Test
	public void test01(){
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
		
		//1、不要自己创建对象
//		MathCalculator mathCalculator = new MathCalculator();
//		mathCalculator.div(1, 1);
		MathCalculator mathCalculator = applicationContext.getBean(MathCalculator.class);
		
		mathCalculator.div(1, 1);
		
		applicationContext.close();
	}

}

结果：

说明：已获取到目标方法参数列表，方法名称和运行结果；并在目标方法执行前、后进行了拦截；

如果抛出异常，传入1除以0，结果：

说明：已在目标方法运行结束后获取到了异常信息；

 

======以下于你或许是个好消息======

 

好消息就是：欢迎访问下面的博客网站哈哈哈......

 

网站名称：Java学习笔记网 (点击进入)

url：https://www.javaxxbj.com/ (点击进入)

网站特点：

1. java主要网站的导航目录
2. 你可以记录自己的博客，并可以控制显示和隐藏，可利于管理啦！！！
3. 可以添加收藏各个网站的链接！！！
4. 甚至也可以文章收藏，点赞，关注，查看我的消息等功能哦！！1

看一小点点的截图：

或可一试哦！