什么是AOP编程

AOP: Aspect Oriented Programming 面向切面编程。
　　面向切面编程(也叫面向方面)：Aspect Oriented Programming(AOP),是目前软件开发中的一个热点。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
　　AOP是OOP的延续，是（Aspect Oriented Programming）的缩写，意思是面向切面（方面）编程。
　　主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。
　　主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改 变这些行为的时候不影响业务逻辑的代码。


　　可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。
假设把应用程序想成一个立体结构的话，OOP的利刃是纵向切入系统，把系统划分为很多个模块（如：用户模块，文章模块等等），而AOP的利刃是横向切入系统，提取各个模块可能都要重复操作的部分（如：权限检查，日志记录等等）。由此可见，AOP是OOP的一个有效补充。
注意：AOP不是一种技术，实际上是编程思想。凡是符合AOP思想的技术，都可以看成是AOP的实现。

Aop**，** aspect object programming 面向切面编程
功能： 让关注点代码与业务代码分离！

aop术语

Aspect(切面):切入点+通知。
切面是通知和切入点的结合。现在发现了吧，没连接点什么事情，连接点就是为了让你好理解切点，搞出来的，明白这个概念就行了。通知说明了干什么和什么时候干（什么时候通过方法名中的before,after，around等就能知道），而切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。

joinPoint(连接点):目标对象,所有可以增强的方法。
这个更好解释了，就是spring允许你使用通知的地方，那可真就多了，基本每个方法的前，后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点.其他如aspectJ还可以让你在构造器或属性注入时都行，不过那不是咱关注的，只要记住，和方法有关的前前后后（抛出异常），都是连接点。

Advice(通知/增强):增强代码。
就是你想要的功能，也就是上面说的 安全，事物，日志等。你给先定义好把，然后在想用的地方用一下。

PointCut(切入点):目标对象,将要和已经增强的方法。
上面说的连接点的基础上，来定义切入点，你的一个类里，有15个方法，那就有几十个连接点了对把，但是你并不想在所有方法附近都使用通知（使用叫织入，以后再说），你只想让其中的几个，在调用这几个方法之前，之后或者抛出异常时干点什么，那么就用切点来定义这几个方法，让切点来筛选连接点，选中那几个你想要的方法。

Introduction(引入):声明某个方法或字段。
允许我们向现有的类添加新方法属性。这不就是把切面（也就是新方法属性：通知定义的）用到目标类中吗

Target(目标对象):被代理的对象
引入中所提到的目标类，也就是要被通知的对象，也就是真正的业务逻辑，他可以在毫不知情的情况下，被咱们织入切面。而自己专注于业务本身的逻辑。

AOP 代理(AOp Proxy) AOP框架创建的对象用来实现切面。
怎么实现整套aop机制的，都是通过代理，这个一会给细说。

Weaving(织入)：将通知应用到切入点的过程。
把切面应用到目标对象来创建新的代理对象的过程。

AOP底层实现原理

代理设计模式：
通过代理控制对象的访问,可以详细访问某个对象的方法，在这个方法调用处理，或调用后处理。既(AOP微实现) ,AOP核心技术面向切面编程。
image.png

代理模式应用场景：
SpringAOP、事物原理、日志打印、权限控制、远程调用、安全代理 可以隐蔽真实角色，执行时间

代理的分类：
静态代理(静态定义代理类)
动态代理(动态生成代理类)
Jdk自带动态代理
Cglib 、javaassist（字节码操作库）
_

静态代理

由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

_

静态代理代码：
  1. public interface IUserDao {
  2.     void save();
  3. }
  4. public class UserDao implements IUserDao {
  5.     public void save() {
  6.         System.out.println("已经保存数据...");
  7.     }
  8. }
  9. 代理类
  10. public class UserDaoProxy implements IUserDao {
  11.     private IUserDao target;
  13.     public UserDaoProxy(IUserDao iuserDao) {
  14.         this.target = iuserDao;
  15.     }
  17.     public void save() {
  18.         System.out.println("开启事物...");
  19.         target.save();
  20.         System.out.println("关闭事物...");
  21.     }
  23. }

动态代理

1.代理对象,不需要实现接口
2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
3.动态代理也叫做:JDK代理,接口代理

JDK动态代理：

1)原理：是根据类加载器和接口创建代理类（此代理类是接口的实现类，所以必须使用接口 面向接口生成代理，位于java.lang.reflect包下）
2)实现方式：
1. 通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(…);
2. 通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类Class clazz = Proxy.getProxyClass(classLoader,new Class[]{…});
3. 通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
4. 通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));

缺点：jdk动态代理，必须是面向接口，目标业务类必须实现接口
**

  1. // 每次生成动态代理类对象时,实现了InvocationHandler接口的调用处理器对象 
  2. public class InvocationHandlerImpl implements InvocationHandler {
  3.     private Object target;// 这其实业务实现类对象，用来调用具体的业务方法
  4.     // 通过构造函数传入目标对象
  5.     public InvocationHandlerImpl(Object target) {
  6.         this.target = target;
  7.     }
  9.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  10.         Object result = null;
  11.         System.out.println("调用开始处理");
  12.         result = method.invoke(target, args);
  13.         System.out.println("调用结束处理");
  14.         return result;
  15.     }
  17.     public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException,
  18.             IllegalAccessException, IllegalArgumentException, InvocationTargetException {
  19.         // 被代理对象
  20.         IUserDao userDao = new UserDao();
  21.         InvocationHandlerImpl invocationHandlerImpl = new InvocationHandlerImpl(userDao);
  22.         ClassLoader loader = userDao.getClass().getClassLoader();
  23.         Class<?>[] interfaces = userDao.getClass().getInterfaces();
  24.         // 主要装载器、一组接口及调用处理动态代理实例
  25.         IUserDao newProxyInstance = (IUserDao) Proxy.newProxyInstance(loader, interfaces, invocationHandlerImpl);
  26.         newProxyInstance.save();
  27.     }
  29. }

CGLIB动态代理：

原理：利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

使用cglib[Code Generation Library]实现动态代理，并不要求委托类必须实现接口，底层采用asm字节码生成框架生成代理类的字节码
_
CGLIB动态代理相关代码：

  1. public class CglibProxy implements MethodInterceptor {
  2.     private Object targetObject;
  3.     // 这里的目标类型为Object，则可以接受任意一种参数作为被代理类，实现了动态代理
  4.     public Object getInstance(Object target) {
  5.         // 设置需要创建子类的类
  6.         this.targetObject = target;
  7.         Enhancer enhancer = new Enhancer();
  8.         enhancer.setSuperclass(target.getClass());
  9.         enhancer.setCallback(this);
  10.         return enhancer.create();
  11.     }
  13.     public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
  14.         System.out.println("开启事物");
  15.         Object result = proxy.invoke(targetObject, args);
  16.         System.out.println("关闭事物");
  17.         // 返回代理对象
  18.         return result;
  19.     }
  20.     public static void main(String[] args) {
  21.         CglibProxy cglibProxy = new CglibProxy();
  22.         UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDao());
  23.         userDao.save();
  24.     }
  25. }

CGLIB动态代理与JDK动态区别

java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
Spring中。
1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP
3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换
JDK动态代理只能对实现了接口的类生成代理，而不能针对类 。 CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法 。
因为是继承，所以该类或方法最好不要声明成final ，final可以阻止继承和多态。

AOP编程使用

注解版本实现AOP

  1. <aop:aspectj-autoproxy></aop:aspectj-autoproxy>  开启事物注解权限
  2. @Aspect                            指定一个类为切面类        
  3. @Pointcut("execution(* com.itmayiedu.service.UserService.add(..))")  指定切入点表达式
  4. @Before("pointCut_()")                前置通知: 目标方法之前执行
  5. @After("pointCut_()")                后置通知：目标方法之后执行（始终执行）
  6. @AfterReturning("pointCut_()")         返回后通知： 执行方法结束前执行(异常不执行)
  7. @AfterThrowing("pointCut_()")            异常通知:  出现异常时候执行
  8. @Around("pointCut_()")                环绕通知： 环绕目标方法执行
  1. @Component
  2. @Aspect
  3. public class AopLog {
  5.     // 前置通知
  6.     @Before("execution(* com.itmayiedu.service.UserService.add(..))")
  7.     public void begin() {
  8.         System.out.println("前置通知");
  9.     }
  11.     //
  12.     // 后置通知
  13.     @After("execution(* com.itmayiedu.service.UserService.add(..))")
  14.     public void commit() {
  15.         System.out.println("后置通知");
  16.     }
  18.     // 运行通知
  19.     @AfterReturning("execution(* com.itmayiedu.service.UserService.add(..))")
  20.     public void returning() {
  21.         System.out.println("运行通知");
  22.     }
  24.     // 异常通知
  25.     @AfterThrowing("execution(* com.itmayiedu.service.UserService.add(..))")
  26.     public void afterThrowing() {
  27.         System.out.println("异常通知");
  28.     }
  30.     // 环绕通知
  31.     @Around("execution(* com.itmayiedu.service.UserService.add(..))")
  32.     public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  33.         System.out.println("环绕通知开始");
  34.         proceedingJoinPoint.proceed();
  35.         System.out.println("环绕通知结束");
  36.     }
  37. }

XML方式实现AOP

1） 引入jar文件 【aop 相关jar， 4个】
2） 引入aop名称空间
3）aop 配置
_

  • 配置切面类 （重复执行代码形成的类）

  • aop配置
     拦截哪些方法 / 拦截到方法后应用通知代码_ ```java

    1.   <!-- 定义一个切入点表达式： 拦截哪些方法 -->
    2.   <aop:pointcut expression="execution(* com.itmayiedu.service.UserService.*(..))"
    3.       id="pt" />
    4.   <!-- 切面 -->
    5.   <aop:aspect ref="aop">
    6.       <!-- 环绕通知 -->
    7.       <aop:around method="around" pointcut-ref="pt" />
    8.       <!-- 前置通知： 在目标方法调用前执行 -->
    9.       <aop:before method="begin" pointcut-ref="pt" />
    10.       <!-- 后置通知： -->
    11.       <aop:after method="after" pointcut-ref="pt" />
    12.       <!-- 返回后通知 -->
    13.       <aop:after-returning method="afterReturning"
    14.           pointcut-ref="pt" />
    15.       <!-- 异常通知 -->
    16.       <aop:after-throwing method="afterThrowing"
    17.           pointcut-ref="pt" />
    18.   </aop:aspect>

public class AopLog2 {

  1. // 前置通知
  2. public void begin() {
  3.     System.out.println("前置通知");
  4. }
  6. //
  7. // 后置通知
  8. public void commit() {
  9.     System.out.println("后置通知");
  10. }
  12. // 运行通知
  13. public void returning() {
  14.     System.out.println("运行通知");
  15. }
  17. // 异常通知
  18. public void afterThrowing() {
  19.     System.out.println("异常通知");
  20. }
  22. // 环绕通知
  23. public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  24.     System.out.println("环绕通知开始");
  25.     proceedingJoinPoint.proceed();
  26.     System.out.println("环绕通知结束");
  27. }

}

  1. <a name="PEZYp"></a>
  2. #### AOP编程应用场景
  3. 日志记录，性能统计，安全控制，事务处理，异常处理
  7. <a name="yGThU"></a>
  8. #### Spring事务使用
  9. 事务基本特性：
  11. **⑴  原子性（Atomicity）**<br />　　原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。<br />**⑵  一致性（Consistency）**<br />　一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。<br />　　拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。<br />**⑶  隔离性（Isolation）**<br />　　隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。<br />　　即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。<br />　　关于事务的隔离性数据库提供了多种隔离级别，稍后会介绍到。<br />**⑷  持久性（Durability）**<br />持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。<br />例如我们在使用JDBC操作数据库时，在提交事务方法后，提示用户事务操作完成，当我们程序执行完成直到看到提示后，就可以认定事务以及正确提交，即使这时候数据库出现了问题，也必须要将我们的事务完全执行完成，否则就会造成我们看到提示事务处理完毕，但是数据库因为故障而没有执行事务的重大错误。
  13. <a name="zDszl"></a>
  14. ### 事务控制分类
  15. <a name="1tPeW"></a>
  16. #### 编程式事务控制
  17. _ 自己手动控制事务，就叫做编程式事务控制。_<br />_    Jdbc代码：_<br />_         Conn.setAutoCommite(false);  // 设置手动控制事务_<br />_    Hibernate代码：_<br />_         Session._[_begin_]()_Transaction();    // 开启一个事务_<br />_【细粒度的事务控制： 可以对指定的方法、指定的方法的某几行添加事务控制】_<br />_  (比较灵活，但开发起来比较繁琐： 每次都要开启、提交、回滚.)_<br />_
  18. <a name="wObkw"></a>
  19. #### 声明式事务控制
  20. _Spring提供了对事务的管理, 这个就叫声明式事务管理。_<br />_    Spring提供了对事务控制的实现。用户如果想用Spring的声明式事务管理，只需要在配置文件中配置即可；
  21. 不想使用时直接移除配置。这个实现了对事务控制的最大程度的解耦。_<br />_    Spring声明式事务管理，核心实现就是基于Aop。_<br />_    【粗粒度的事务控制： 只能给整个方法应用事务，不可以对方法的某几行应用事务。】_<br />_    (因为aop拦截的是方法。)_<br />_ _<br />_    Spring声明式事务管理器类：_<br />_    Jdbc技术：DataSourceTransactionManager_<br />_    Hibernate技术：HibernateTransactionManager_
  24. <a name="bPyAg"></a>
  25. #### 手写Spring事务框架
  26. **编程事务实现**<br />[概述：]()<br />_所谓编程式事务指的是通过编码方式实现事务，即类似于JDBC编程实现事务管理。管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。_<br />_<br />案例：<br />使用编程事务实现手动事务
  28. 使用编程事务实现，手动事务 begin、commit、rollback
  29. ```java
  30. @Component
  31. public class TransactionUtils {
  33.     @Autowired
  34.     private DataSourceTransactionManager dataSourceTransactionManager;
  36.     // 开启事务
  37.     public TransactionStatus begin() {
  38.         TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
  39.         return transaction;
  40.     }
  42.     // 提交事务
  43.     public void commit(TransactionStatus transactionStatus) {
  44.         dataSourceTransactionManager.commit(transactionStatus);
  45.     }
  47.     // 回滚事务
  48.     public void rollback(TransactionStatus transactionStatus) {
  49.         dataSourceTransactionManager.rollback(transactionStatus);
  50.     }
  51. }
  53. @Service
  54. public class UserService {
  55.     @Autowired
  56.     private UserDao userDao;
  57.     @Autowired
  58.     private TransactionUtils transactionUtils;
  60.     public void add() {
  61.         TransactionStatus transactionStatus = null;
  62.         try {
  63.             transactionStatus = transactionUtils.begin();
  64.             userDao.add("wangmazi", 27);
  65.             int i = 1 / 0;
  66.             System.out.println("我是add方法");
  67.             userDao.add("zhangsan", 16);
  68.             transactionUtils.commit(transactionStatus);
  69.         } catch (Exception e) {
  70.             e.printStackTrace();
  71.         } finally {
  72.             if (transactionStatus != null) {
  73.                 transactionStatus.rollbackToSavepoint(transactionStatus);
  74.             }
  75.         }
  77.     }
  78. }

AOP技术封装手动事务

  1. @Component
  2. @Aspect
  3. public class AopTransaction {
  4.     @Autowired
  5.     private TransactionUtils transactionUtils;
  7.     // // 异常通知
  8.     @AfterThrowing("execution(* com.itmayiedu.service.UserService.add(..))")
  9.     public void afterThrowing() {
  10.         System.out.println("程序已经回滚");
  11.         // 获取程序当前事务 进行回滚
  12.         TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
  13.     }
  15.     // 环绕通知
  16.     @Around("execution(* com.itmayiedu.service.UserService.add(..))")
  17.     public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  18.         System.out.println("开启事务");
  19.         TransactionStatus begin = transactionUtils.begin();
  20.         proceedingJoinPoint.proceed();
  21.         transactionUtils.commit(begin);
  22.         System.out.println("提交事务");
  23.     }
  25. }

使用事务注意事项

事务是程序运行如果没有错误,会自动提交事物,如果程序运行发生异常,则会自动回滚。
如果使用了try捕获异常时.一定要在catch里面手动回滚。
事务手动回滚代码
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
_

声明事务实现

概述
管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中。
显然声明式事务管理要优于编程式事务管理，这正是spring倡导的非侵入式的开发方式。

声明式事务管理使业务代码不受污染，一个普通的POJO对象，只要加上注解就可以获得完全的事务支持。和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。
_
XML实现声明
注解版本声明

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  3.     xmlns:context="http://www.springframework.org/schema/context"
  4.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.          http://www.springframework.org/schema/beans/spring-beans.xsd
  7.           http://www.springframework.org/schema/context
  8.          http://www.springframework.org/schema/context/spring-context.xsd
  9.          http://www.springframework.org/schema/aop
  10.          http://www.springframework.org/schema/aop/spring-aop.xsd
  11.          http://www.springframework.org/schema/tx
  12.           http://www.springframework.org/schema/tx/spring-tx.xsd">
  15.     <!-- 开启注解 -->
  16.     <context:component-scan base-package="com.itmayiedu"></context:component-scan>
  17.     <!-- 1. 数据源对象: C3P0连接池 -->
  18.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  19.         <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  20.         <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
  21.         <property name="user" value="root"></property>
  22.         <property name="password" value="root"></property>
  23.     </bean>
  25.     <!-- 2. JdbcTemplate工具类实例 -->
  26.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  27.         <property name="dataSource" ref="dataSource"></property>
  28.     </bean>
  30.     <!-- 配置事物 -->
  31.     <bean id="dataSourceTransactionManager"
  32.         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  33.         <property name="dataSource" ref="dataSource"></property>
  34.     </bean>
  35.     <!-- 开启注解事物 -->
  36.     <tx:annotation-driven transaction-manager="dataSourceTransactionManager" />
  37. </beans>

用法

  1. @Transactional
  2.     public void add() {
  3.         userDao.add("wangmazi", 27);
  4.         int i = 1 / 0;
  5.         System.out.println("我是add方法");
  6.         userDao.add("zhangsan", 16);
  7.     }

Spring事物传播行为

Spring中事务的定义：
Propagation（key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。）有以下选项可供使用：
PROPAGATION_REQUIRED—支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS—支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY—支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW—新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED—以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER—以非事务方式执行，如果当前存在事务，则抛出异常。
_

SpringIOC原理

_