Spring AOP：面向切面编程，AspectJ，是基于注解的方法
面向切面编程的术语：
切面(Aspect): 横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象
通知(Advice): 切面必须要完成的工作
目标(Target): 被通知的对象
代理(Proxy): 向目标对象应用通知之后创建的对象
连接点（Joinpoint）：程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等，连接点是程序类中客观存在的事务
切点（pointcut）：每个类都拥有多个连接点，例如 ArithmethicCalculator类中 的所有方法实际上都是连接点，AOP 通过切点定位到特定的连接点
实现过程：
要在 Spring 中声明 AspectJ 切面, 只需要在 IOC 容器中将切面声明为 Bean 实例. 当在 Spring IOC 容器中初始化 AspectJ 切面之后, Spring IOC 容器就会为那些与 AspectJ 切面相匹配的 Bean 创建代理.
在 AspectJ 注解中, 切面只是一个带有 @Aspect 注解的 Java 类.
AspectJ 是基于注解的，支持 5 种类型的通知注解:
@Before: 前置通知, 在方法执行之前执行
@After: 后置通知, 在方法执行之后执行
@AfterRunning: 返回通知, 在方法返回结果之后执行
@AfterThrowing: 异常通知, 在方法抛出异常之后
@Around: 环绕通知, 围绕着方法执行
导入spring编程的架包多个：。。。。
-------------------------------------------------------------------------------
建立一个接口类：ArithmeticCalculator，其是抽象类，不能实例化
package com.atguigu.spring.aop.impl; public interface ArithmeticCalculator { //创建一个接口，其是抽象的类，不能实例化 int add(int i,int j); int sub(int i,int j); int mul(int i,int j); int div(int i,int j); }
创建一个类：ArithmeticCalculatorImpl 继承于接口 ArithmeticCalculator，为该类添加注解@Component("arithmeticCalculator")，并赋标识，
package com.atguigu.spring.aop.impl; import org.springframework.stereotype.Component; //@Component基本注解, 标识了一个受 Spring 管理的组件 @Component("arithmeticCalculator") public class ArithmeticCalculatorImpl implements ArithmeticCalculator { @Override public int add(int i, int j) { int result=i+j; return result; } @Override public int sub(int i, int j) { int result=i-j; return result; } @Override public int mul(int i, int j) { int result=i*j; return result; } @Override public int div(int i, int j) { int result=i/j; return result; } }
建立一个类：ArithmeticCalculatorLoggingProxy，为该类添加注解：@Order(2)，指定切面的优先级，值越小，优先级越大，@Aspect：为切面注解，面向切面编程，必须加；@Component：指是在IOC容器中的，为类中的方法添加不同的注解，前置通知，后置通知.....
package com.atguigu.spring.aop.impl; import java.util.Arrays; import org.aspectj.lang.JoinPoint; 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.springframework.stereotype.Component; /* * 面向切面编程：Spring AOP（其 是基于注解的spring的bean配置）: * @Component：指是在IOC容器中的 * @Aspect：为切面注解，面向切面编程，必须加； * 可以使用 @Order 注解指定切面的优先级, 值越小优先级越高 */
@Order(2)
@Aspect @Component public class ArithmeticCalculatorLoggingProxy { /* * @Before：为在执行该方法之前的---前置通知 * execution(public int com.atguigu.spring.aop.impl.ArithmeticCalculator.*(..)): * 是指，前置通知放在继承这个 接口(全类名为：com.atguigu.spring.aop.impl.ArithmeticCalculator) * 的类下的所有方法; * Joinpoint joinpoint:为连接点，获取连接细节信息 * */ @Before("execution(public int com.atguigu.spring.aop.impl.ArithmeticCalculator.*(..))") public void beforeMethod(JoinPoint joinPoint){ //获取方法名，和参数值，参数值要多个，所以用数组集合的方法 String methodName=joinPoint.getSignature().getName(); Object[] args=joinPoint.getArgs(); System.out.println("The method "+methodName+" begains "+Arrays.asList(args)); } //后置通知：在方法执行之后，无论该方法出现异常，都执行 @After("execution(public int com.atguigu.spring.aop.impl.ArithmeticCalculator.*(..))") public void afterMethod(JoinPoint joinPoint){ //获取方法名，和参数值 String methodName=joinPoint.getSignature().getName(); System.out.println("The method "+methodName+ " ends"); } //返回通知：是方法正常结束之后返回的代码，如果是非正常结束，抛出异常，如分母为0 //返回通知是可以访问到方法的返回值的，即是该方法的结果 @AfterReturning(value="execution(public int com.atguigu.spring.aop.impl.ArithmeticCalculator.*(..))" , returning="result") public void afterReturning(JoinPoint joinPoint,Object result){ //获取方法名，和参数值 String methodName=joinPoint.getSignature().getName(); System.out.println("The method "+methodName+ " *** ends :"+result); } //@AfterThrowing:异常通知,在目标方法出现异常时会执行的代码； //异常通知，可以访问到异常对象;且可以指定在出现特定异常时在执行通知代码 @AfterThrowing(value="execution(public int com.atguigu.spring.aop.impl.ArithmeticCalculator.*(..))" , throwing="e") public void afterThrowing(JoinPoint joinPoint, Exception e){ String methodName=joinPoint.getSignature().getName(); System.out.println("The method "+methodName+ " Exception :"+ e); } //@Around:环绕通知； //环绕通知需要携带 ProceedingJoinPoint 类型的参数. //环绕通知类似于动态代理的全过程: ProceedingJoinPoint 类型的参数可以决定是否执行目标方法. // 且环绕通知必须有返回值, 返回值即为目标方法的返回值 @Around("execution(public int com.atguigu.spring.aop.impl.ArithmeticCalculator.*(..))") public Object aroundMethod(ProceedingJoinPoint pjp){ Object result=null; //获取方法名 String methodName=pjp.getSignature().getName(); try { //前置通知,Arrays.asList(pjp.getArgs())为该方法的参数个数，为数组集合 System.out.println("The method "+methodName+" begains "+Arrays.asList(pjp.getArgs())); //执行目标方法 result=pjp.proceed(); //返回通知 System.out.println("The method "+methodName+ " ends with :"+result); } catch (Throwable e) { //异常通知 System.out.println("The method " +methodName+ " occurs exception "+ e); e.printStackTrace(); } //后置通知 System.out.println("The method " + methodName + " ends"); return result; } }
在上边的类中，定义一个方法，将方法上注解里面的"execution(public int com.atguigu.spring.aop.ArithmeticCalculator.*(..))"值，换成统一的"declareJointPointExpression()"，即可以简化注解里重复的代码，这里使用到了@Pointcut注解
/** * 定义一个方法, 用于声明切入点表达式. 一般地, 该方法中再不需要添入其他的代码. * 使用 @Pointcut 来声明切入点表达式. * 后面的其他通知直接使用方法名来引用当前的切入点表达式. */ @Pointcut("execution(public int com.atguigu.spring.aop.ArithmeticCalculator.*(..))") public void declareJointPointExpression(){}
建立一个spring bean configuration file的xml文件：applicationContext.xml
<!-- 配置自动扫描的包 -->
<context:component-scan base-package="com.atguigu.spring.aop.impl"></context:component-scan>
<!-- 配置自动为匹配aspectJ 的java类生成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
建立类：Main，进行测试：注意该类中 ArithmeticCalculator，是上边接口类,注解的内容是继承该接口的类 ArithmeticCalculatorImpl 的注解内容
package com.atguigu.spring.aop.impl; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Main { public static void main(String[] args) { ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml"); //ArithmeticCalculator,是一个接口类,注解的是继承该接口的类 ArithmeticCalculator impl=(ArithmeticCalculator) ctx.getBean("arithmeticCalculator"); System.out.println(impl.getClass().getName()); int result=impl.add(12,2); System.out.println(result); double result2=impl.div(12, 2); System.out.println(result2); } }
