一、
Aspect oritention programming(面向切面编程)，AOP是一种思想，高度概括的话是“横向重复，纵向抽取”，如何理解呢？举个例子：访问页面时需要权限认证，如果每个页面都去实现方法显然是不合适的，这个时候我们就可以利用切面编程。
每个页面都去实现这个方法就是横向的重复，我们直接从中切入，封装一个与主业务无关的权限验证的公共方法，这样可以减少系统的重复代码，降低模块之间的耦合度，简单的示意图如下：
二、应用场景
1.连接点（Joinpoint） 所谓连接点是指那些可能被拦截到的方法。例如：所有可以增加的方法
2.切点（Pointcut） 已经被增强的连接点
3.增强（Advice） 增强的代码
4.目标对象（Target） 目标类，需要被代理的类
5.织入（Weaving） 是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程
6.代理（Proxy） 一个类被AOP织入增强后，就产生出了一个结果类，它是融合了原类和增强逻辑的代理类。
7.切面（Aspect）切入点+通知
通知类型：Spring按照通知Advice在目标类方法的连接点位置，可以分为5类
-
-
后置通知（在目标方法执行后实施增强）
-
环绕通知（在目标方法执行前后实施增加）
-
异常抛出通知（在方法跑出异常时通知）
-
引介通知（在目标类中添加一些新的方法和属性）
四、实现原理
AOP的实现关键在于AOP框架自动创建的AOP代理。AOP代理主要分为两大类：
静态代理：使用AOP框架提供的命令进行编译，从而在编译阶段就可以生成AOP代理类，因此也称为编译时增强；静态代理一Aspectj为代表。
动态代理：在运行时借助于JDK动态代理，CGLIB等在内存中临时生成AOP动态代理类，因此也被称为运行时增强，Spring AOP用的就是动态代理。
4.1
//员工类 public class Employee { private Integer uid; public void setUid(Integer uid) { this.uid = uid; } public Integer getUid() { return uid; } private Integer age; private String name; public Integer getAge() { return age; } public String getName() { return name; } public void setAge(Integer age) { this.age = age; } public void setName(String name) { this.name = name; } }
员工接口：
//员工接口 public interface EmployeeService { //新增方法 void addEmployee(Employee employee); //删除方法 void deleteEmployee(Integer uid); }
员工实现：
//员工方法实现 public class EmployeeServiceImpl implements EmployeeService { @Override public void addEmployee(Employee employee) { System.out.println("新增员工"); } @Override public void deleteEmployee(Integer uid) { System.out.println("删除员工"); } }
事务类：
//事务类 public class MyTransaction { //开启事务 public void before(){ System.out.println("开启事务"); } //提交事务 public void after(){ System.out.println("提交事务"); } }
代理类：
//代理类 public class ProxyEmployee implements EmployeeService { // private EmployeeService employeeService; private MyTransaction myTransaction; public ProxyEmployee(EmployeeService employeeService,MyTransaction myTransaction) { this.employeeService=employeeService; this.myTransaction=myTransaction; } @Override public void addEmployee(Employee employee) { myTransaction.before(); employeeService.addEmployee(employee); myTransaction.after(); } @Override public void deleteEmployee(Integer uid) { myTransaction.before(); employeeService.deleteEmployee(uid); myTransaction.after(); } }
测试：
@Test public void fun1(){ MyTransaction transaction = new MyTransaction(); EmployeeService EmployeeService = new EmployeeServiceImpl(); //产生静态代理对象 ProxyEmployee proxy = new ProxyEmployee(EmployeeService, transaction); proxy.addEmployee(null); proxy.deleteEmployee(0); }
结果：
这是静态代理的实现方式，静态代理有明显的缺点：
1、代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。
2、如果接口增加一个方法，比如 EmployeeService增加修改 updateEmployee(）方法，则除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
4.2
public class ObjectInterceptor implements InvocationHandler { //目标类 private Object target; //切面类（这里指事务类） private MyTransaction transaction; //通过构造器赋值 public ObjectInterceptor(Object target,MyTransaction transaction){ this.target = target; this.transaction = transaction; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { this.transaction.before(); method.invoke(target,args); this.transaction.after(); return null; } }
测试：
@Test public void fun2(){ //目标类 Object target = new EmployeeServiceImpl (); //事务类 MyTransaction transaction = new MyTransaction(); ObjectInterceptor proxyObject = new ObjectInterceptor(target, transaction); /** * 三个参数的含义： * 1、目标类的类加载器 * 2、目标类所有实现的接口 * 3、拦截器 */ EmployeeService employeeService = (EmployeeService) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), proxyObject); employeeService.addEmployee(null); employeeService.deleteEmployee(0); }
结果：
五、
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" 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"> <!--目标类--> <bean name="employeeService" class="com.yuanqinnan.aop.EmployeeServiceImpl"></bean> <bean name="transaction" class="com.yuanqinnan.aop.MyTransaction"></bean> <aop:config> <aop:aspect ref="transaction"> <aop:pointcut id="pointcut" expression="execution(* com.yuanqinnan.aop.EmployeeServiceImpl..*(..))"/> <!-- 配置前置通知，注意 method 的值要和 对应切面的类方法名称相同 --> <aop:before method="before" pointcut-ref="pointcut"></aop:before> <!--配置后置通知，注意 method 的值要和 对应切面的类方法名称相同--> <aop:after-returning method="after" pointcut-ref="pointcut"/> </aop:aspect> </aop:config> </beans>
测试：
@Test public void fun3(){ ApplicationContext context = new ClassPathXmlApplicationContext("META-INF/applicationContext.xml"); EmployeeService employeeService = (EmployeeService) context.getBean("employeeService"); employeeService.addEmployee(null); }
结果：
补充：
1.aop:pointcut如果位于aop:aspect元素中，则命名切点只能被当前aop:aspect内定义的元素访问到，为了能被整个aop:config元素中定义的所有增强访问，则必须在aop:config下定义切点。
2.如果在aop:config元素下直接定义aop:pointcut，必须保证aop:pointcut在aop:aspect之前定义。aop:config下还可以定义aop:advisor，三者在aop:config中的配置有先后顺序的要求：首先必须是aop:pointcut，然后是aop:advisor，最后是aop:aspect。而在aop:aspect中定义的aop:pointcut则没有先后顺序的要求，可以在任何位置定义。
aop:pointcut：用来定义切入点，该切入点可以重用；
aop:advisor：用来定义只有一个通知和一个切入点的切面；
aop:aspect：用来定义切面，该切面可以包含多个切入点和通知，而且标签内部的通知和切入点定义是无序的；和advisor的区别就在此，advisor只包含一个通知和一个切入点。
3.在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut"切入点" 例如定义切入点表达式 execution(* com.sample.service.impl...(..)) execution()是最常用的切点函数，其语法如下所示：
整个表达式可以分为五个部分： (1)、execution(): 表达式主体。
(2)、第一个号：表示返回类型，
5.2
@Component @Aspect public class AopAspectJ { /** * 必须为final String类型的,注解里要使用的变量只能是静态常量类型的 */ public static final String EDP="execution(* com.yuanqinnan.aop.EmployeeServiceImpl..*(..))"; /** * 切面的前置方法 即方法执行前拦截到的方法 * 在目标方法执行之前的通知 * @param jp */ @Before(EDP) public void doBefore(JoinPoint jp){ System.out.println("=========执行前置通知=========="); } /** * 在方法正常执行通过之后执行的通知叫做返回通知 * 可以返回到方法的返回值 在注解后加入returning * @param jp * @param result */ @AfterReturning(value=EDP,returning="result") public void doAfterReturning(JoinPoint jp,String result){ System.out.println("===========执行后置通知============"); } /** * 最终通知：目标方法调用之后执行的通知（无论目标方法是否出现异常均执行） * @param jp */ @After(value=EDP) public void doAfter(JoinPoint jp){ System.out.println("===========执行最终通知============"); } /** * 环绕通知：目标方法调用前后执行的通知，可以在方法调用前后完成自定义的行为。 * @param pjp * @return * @throws Throwable */ @Around(EDP) public Object doAround(ProceedingJoinPoint pjp) throws Throwable{ System.out.println("======执行环绕通知开始========="); // 调用方法的参数 Object[] args = pjp.getArgs(); // 调用的方法名 String method = pjp.getSignature().getName(); // 获取目标对象 Object target = pjp.getTarget(); // 执行完方法的返回值 // 调用proceed()方法，就会触发切入点方法执行 Object result=pjp.proceed(); System.out.println("输出,方法名：" + method + ";目标对象：" + target + ";返回值：" + result); System.out.println("======执行环绕通知结束========="); return result; } /** * 在目标方法非正常执行完成, 抛出异常的时候会走此方法 * @param jp * @param ex */ @AfterThrowing(value=EDP,throwing="ex") public void doAfterThrowing(JoinPoint jp,Exception ex) { System.out.println("===========执行异常通知============"); } }
xml配置
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" 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"> <context:component-scan base-package="com.yuanqinnan.aop" ></context:component-scan> <!-- 声明spring对@AspectJ的支持 --> <aop:aspectj-autoproxy/> <!--目标类--> <bean name="employeeService" class="com.yuanqinnan.aop.EmployeeServiceImpl"></bean> </beans>
测试：
@Test public void fun4(){ ApplicationContext act = new ClassPathXmlApplicationContext("META-INF/applicationContext.xml"); EmployeeService employeeService = (EmployeeService) act.getBean("employeeService"); employeeService.addEmployee(null); }
结果：
pringAOP的知识就总结到这里