面向切面编程的术语：
切面(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);
}
}