1.Java实现AOP的几种方式
2.面试官：你讲讲AOP与OOP有什么区别？
3.ood/oop_ood和oop思想_什么是ooa ood oop
4.为什么spring中AOP 用的很少
5.76 张图，剖析 Spring AOP 源码，小白居然也能看懂，大神，请收下我的膝盖！
6.spring—AOP与事务

Java实现AOP的cms系统源码java几种方式

       （1）AOP的各种实现

       在编译器修改源代码、在运行期字节码加载前修改字节码或字节码加载后动态创建代理类的字节码。以下是各种实现机制的比较：

       类别分为静态AOP（包括静态织入）和动态AOP（包括动态代理、动态字节码生成、自定义类加载器、字节码转换）。

       静态织入：

       a、原理：在编译期，切面直接以字节码形式编译到目标字节码文件中 ；

       b、优点：对系统性能无影响；

       c、缺点：不够灵活；

       动态代理 ：

       a、原理：在运行期，目标类加载后，为接口动态生成代理类。将切面织入到代理类中；

       b、优点：更灵活；

       c、缺点：切入的关注点要实现接口；

面试官：你讲讲AOP与OOP有什么区别？

       AOP全称为Aspect Oriented Programming，是一种面向切面编程的模式。它与传统的面向对象编程（OOP）有本质的区别。OOP主要关注的是对象的行为和属性，通过封装、继承和多态等特性来实现代码的复用和模块化。而AOP则更侧重于关注点的分离，它可以将一些横跨业务逻辑的公共行为或职责抽取出来，形成独立的模块，从而降低代码的耦合度，提高代码的可维护性和可扩展性。

       AOP的核心思想是将业务逻辑中的横切关注点（如日志记录、性能监控、事务管理等）从核心业务代码中分离出来，通过预编译或运行时动态代理的python 源码包安装方式进行统一管理和维护。这使得在修改或扩展业务逻辑时，不必修改原有代码，只需要在AOP的配置中添加或修改切点即可。这种分离关注点的设计模式有助于提高开发效率，降低维护成本。

       AOP的应用场景通常包括但不限于日志记录、性能统计、安全控制、事务处理、异常处理等。例如，在一个APP模块结构中，按照OOP思想划分的“视图交互”、“业务逻辑”、“网络”等模块，若需要对所有模块的每个方法的执行时间进行监控，这正是AOP的典型应用场景。通过AOP，可以将监控逻辑与业务逻辑分离，无需在每个方法中重复实现监控代码，从而简化了代码结构，提高了代码的可维护性。

       AOP的实现方式主要有运行时、加载时和编译时三种，其中编译时实现（如AspectJ）是AOP技术中最常用的一种，它通过在编译阶段将切面代码编织到目标代码中，实现了对目标代码的动态增强。

       AspectJ是Java中的AOP实现，它包含两个核心组件：ajc编译器和weaver织入器。ajc编译器用于编译AspectJ的源代码，weaver则在编译或运行时将切面代码编织到目标代码中。在Android项目中使用AspectJ时，可以借助gradle插件来简化配置和集成过程。

       总之，AOP提供了一种更为灵活、FLASH源码下载电影高效的方式来管理程序中的关注点，与OOP相比，它更加专注于解耦和提高代码的可维护性。在实际开发中，合理运用AOP可以显著提升软件开发的效率和质量。

ood/oop_ood和oop思想_什么是ooa ood oop

       面向对象编程（OOP）的核心在于封装、继承和多态，通过抽象实体及其属性和行为，形成清晰高效的逻辑单元。

       与之相比，面向方面编程（AOP）聚焦于业务处理过程中的“切面”，即处理过程中的某个步骤或阶段，以实现逻辑过程各部分间的低耦合性。通过AOP，可以在不修改源代码的情况下，给程序动态添加功能，实现灵活性与可扩展性。

       AOP的名称容易产生误导，实际上，Aspect（方面）指的是逻辑过程的外在特性在不同观察角度下的体现，而非传统意义上的“方面”。因此，更准确的译法是“面向切面编程”。与OOP相比，AOP关注点在于处理过程中的特定环节，而OOP则侧重于实体及其属性和行为的抽象。

       在实际应用中，AOP和OOP可以互补。例如，对于“雇员”实体的封装，OOP能有效实现；而对于“权限检查”这一动作，AOP能提供更高效的支持。OOP通过接口实现功能，但修改接口可能引发连锁问题；AOP则通过修改Aspect，实现动态功能添加，c 小游戏 源码维护系统稳定性。

       应用AOP的场景，如实现并发访问共享数据，可以借助数据对象（Data Class）和访问类。通过引入锁（Lock）机制，确保同一时刻只有一个访问类能访问数据对象。由于Java的单继承限制，具体访问类难以同时继承数据对象和其它父类，这时AOP能提供解决方案，通过Aspect实现动态功能添加，灵活管理访问逻辑。

为什么spring中AOP 用的很少

       spring AOP不是用反射实现的，而bean的创建一般是这样做的。

        spring里主要通过Java动态代理接口、cglib生成子类、AspectJ这三种方式来实现AOP。

       é€šè¿‡AOP进行声明式事务管理应该是大家用的最多的吧。像权限校验和日志记录虽然也具备一定的横切性需求，但好像很少拿spring来做，权限控制框架倒是可以考虑与spring进行集成，细粒度的日志记录则根本无法真正利用AOP来做，原因在于业务方法记录日志的位置是不统一的，从而无法确定切入点。

       ä½†spring利用AOP还是干了不少事情的，随便翻看源码你都可以发现它们的影子。举个例子，spring里有一个javax.sql.DataSource的代理类TransactionAwareDataSourceProxy，它利用java的动态代理在运行时替换了原生DataSource的getConnection等诸多方法，最重要的是它使你的遗留系统具备了与spring集成并使用spring事务管理的能力，而这一切你只需要一个简单的配置，你并不知道spring在后台为你做了这些事情。

       AOP是一种很有用的编程理念，语言和工具不应成为我们程序员思想的束缚，即使项目不用spring AOP你也可以在适当的契机把spring里好的想法拿来用，甚至你觉得不好还可以改造它，这样我们才能真正成为工具的主人而不是奴仆。

张图，剖析 Spring AOP 源码，小白居然也能看懂，大神，请收下我的膝盖！

       本文将简要介绍AOP（面向切面编程）的基础知识与使用方法，并深入剖析Spring AOP源码。首先，我们需要理解AOP的基本概念。

       1. **基础知识

**

       1.1 **什么是AOP？

**

       AOP全称为Aspect Oriented Programming，即面向切面编程。AOP的思想中，周边功能（如性能统计、日志记录、事务管理等）被定义为切面，核心功能与切面功能独立开发，然后将两者“编织”在一起，这就是AOP的核心。

       AOP能够将与业务无关、却为业务模块共同调用的逻辑封装，减少系统重复代码，降低模块间的耦合度，有利于系统的可扩展性和可维护性。

       1.2 **AOP基础概念

**

       解释较为官方，android l 源码下载以下用“方言”解释：AOP包括五种通知分类。

       1.3 **AOP简单示例

**

       创建`Louzai`类，添加`LouzaiAspect`切面，并在`applicationContext.xml`中配置。程序入口处添加`"睡觉"`方法并添加前置和后置通知。接下来，我们将探讨Spring内部如何实现这一过程。

       1.4 **Spring AOP工作流程

**

       为了便于理解后面的源码，我们将整体介绍源码执行流程。整个Spring AOP源码分为三块，结合示例进行讲解。

       第一块是前置处理，创建`Louzai`Bean前，遍历所有切面信息并存储在缓存中。第二块是后置处理，创建`Louzai`Bean时，主要处理两件事。第三块是执行切面，通过“责任链+递归”执行切面。

       2. **源码解读

**

       注意：Spring版本为5.2..RELEASE，否则代码可能不同！这里，我们将从原理部分开始，逐步深入源码。

       2.1 **代码入口

**

       从`getBean()`函数开始，进入创建Bean的逻辑。

       2.2 **前置处理

**

       主要任务是遍历切面信息并存储。

       这是重点！请务必注意！获取切面信息流程结束，后续操作都从缓存`advisorsCache`获取。

       2.2.1 **判断是否为切面

**

       执行逻辑为：判断是否包含切面信息。

       2.2.2 **获取切面列表

**

       进入`getAdvice()`，生成切面信息。

       2.3 **后置处理

**

       主要从缓存拿切面，与`Louzai`方法匹配，创建AOP代理对象。

       进入`doCreateBean()`，执行后续逻辑。

       2.3.1 **获取切面

**

       首先，查看如何获取`Louzai`的切面列表。

       进入`buildAspectJAdvisors()`，方法用于存储切面信息至缓存`advisorsCache`。随后回到`findEligibleAdvisors()`，从缓存获取所有切面信息。

       2.3.2 **创建代理对象

**

       有了`Louzai`的切面列表，开始创建AOP代理对象。

       这是重点！请仔细阅读！这里有两种创建AOP代理对象方式，我们选择使用Cglib。

       2.4 **切面执行

**

       通过“责任链+递归”执行切面与方法。

       这部分逻辑非常复杂！接下来是“执行切面”最核心的逻辑，简述设计思路。

       2.4.1 **第一次递归

**

       数组第一个对象执行`invoke()`，参数为`CglibMethodInvocation`。

       执行完毕后，继续执行`CglibMethodInvocation`的`process()`。

       2.4.2 **第二次递归

**

       数组第二个对象执行`invoke()`。

       2.4.3 **第三次递归

**

       数组第三个对象执行`invoke()`。

       执行完毕，退出递归，查看`invokeJoinpoint()`执行逻辑，即执行主方法。回到第三次递归入口，继续执行后续切面。

       切面执行逻辑已演示，直接查看执行方法。

       流程结束时，依次退出递归。

       2.4.4 **设计思路

**

       这部分代码研究了大半天，因为这里不是纯粹的责任链模式。

       纯粹的责任链模式中，对象内部有一个自身的`next`对象，执行当前对象方法后，启动`next`对象执行，直至最后一个`next`对象执行完毕，或中途因条件中断执行，责任链退出。

       这里`CglibMethodInvocation`对象内部无`next`对象，通过`interceptorsAndDynamicMethodMatchers`数组控制执行顺序，依次执行数组中的对象，直至最后一个对象执行完毕，责任链退出。

       这属于责任链，实现方式不同，后续会详细剖析。下面讨论类之间的关系。

       主对象为`CglibMethodInvocation`，继承于`ReflectiveMethodInvocation`，`process()`的核心逻辑在`ReflectiveMethodInvocation`中。

       `ReflectiveMethodInvocation`的`process()`控制整个责任链的执行。

       `ReflectiveMethodInvocation`的`process()`方法中，包含一个长度为3的数组`interceptorsAndDynamicMethodMatchers`，存储了3个对象，分别为`ExposeInvocationInterceptor`、`MethodBeforeAdviceInterceptor`、`AfterReturningAdviceInterceptor`。

       注意！这3个对象都继承了`MethodInterceptor`接口。

       每次`invoke()`调用时，都会执行`CglibMethodInvocation`的`process()`。

       是否有些困惑？别着急，我将再次帮你梳理。

       对象与方法的关系：

       可能有同学疑惑，`invoke()`的参数为`MethodInvocation`，没错！但`CglibMethodInvocation`也继承了`MethodInvocation`，可自行查看。

       执行逻辑：

       设计巧妙之处在于，纯粹的责任链模式中，`next`对象需要保证类型一致。但这里3个对象内部没有`next`成员，不能直接使用责任链模式。怎么办呢？就单独设计了`CglibMethodInvocation.process()`，通过无限递归`process()`实现责任链逻辑。

       这就是我们为什么要研究源码，学习优秀的设计思路！

       3. **总结

**

       本文首先介绍了AOP的基本概念与原理，通过示例展示了AOP的应用。之后深入剖析了Spring AOP源码，分为三部分。

       本文是Spring源码解析的第三篇，感觉是难度较大的一篇。图解代码花费了6个小时，整个过程都沉浸在代码的解析中。

       难度不在于抠图，而是“切面执行”的设计思路，即使流程能走通，将设计思想总结并清晰表达给读者，需要极大的耐心与理解能力。

       今天的源码解析到此结束，有关Spring源码的学习，大家还想了解哪些内容，欢迎留言给楼仔。

spring—AOP与事务

        title: spring——AOP与事务.md

        date: -- ::

        categories: [Spring]

        tags: [AOP,事务]

        toc: true

        先列出源码中比较重点的几个类：

        1、<aop:before method="before" pointcut-ref="myMethods"/>包装成一个advisor

        2、AspectJAwareAdvisorAutoProxyCreator，当实例化所有bean都会执行到AspectJAwareAdvisorAutoProxyCreatorç±»

        它会检测bean是否advisor以及advice存在，如果有就说明这个bean有切面，有切面那么就会生成代理

        3、jdk的代理，bean里面的所有advisor加入到proxyFactory。

        4、jdkDynamicProxy invoke，拿到bean里面的所有Interceptor，会循环proxyFactory里面的所有advisor

        里面有advice，里面的advice有两种类型，要么是advice，要么是MethodInterceptor类型的

        5、当代理对象调用方式，是一个MethodInterceptor类型的类的链式调用过程，直到容器的大小和索引一致的时候调用JoinPoint目标方法

        before：this.advice.before(),invocation.processd();

        装配参数，切面里面before方法的method对象，method.getParamterTypes()[0]

        最终会把advice封装成MethodInterceptor类型的对象

        程序执行的某个特定位置：如类开始初始化前、类初始化后、类某个方法调用前、调用后、方法抛出异常后。一个类或一段程序代码拥有一些具有边界性质的特定点，这些点中的特定点就称为“连接点”。Spring仅支持方法的连接点，即仅能在方法调用前、方法调用后、方法抛出异常时以及方法调用前后这些程序执行点织入增强。连接点由两个信息确定：第一是用方法表示的程序执行点；第二是用相对点表示的方位。

        每个程序类都拥有多个连接点，如一个拥有两个方法的类，这两个方法都是连接点，即连接点是程序类中客观存在的事物。AOP通过“切点”定位特定的连接点。连接点相当于数据库中的记录，而切点相当于查询条件。切点和连接点不是一对一的关系，一个切点可以匹配多个连接点。在Spring中，切点通过org.springframework.aop.Pointcut接口进行描述，它使用类和方法作为连接点的查询条件，Spring AOP的规则解析引擎负责切点所设定的查询条件，找到对应的连接点。其实确切地说，不能称之为查询连接点，因为连接点是方法执行前、执行后等包括方位信息的具体程序执行点，而切点只定位到某个方法上，所以如果希望定位到具体连接点上，还需要提供方位信息。

        增强是织入到目标类连接点上的一段程序代码，在Spring中，增强除用于描述一段程序代码外，还拥有另一个和连接点相关的信息，这便是执行点的方位。结合执行点方位信息和切点信息，我们就可以找到特定的连接点。

        增强逻辑的织入目标类。如果没有AOP，目标业务类需要自己实现所有逻辑，而在AOP的帮助下，目标业务类只实现那些非横切逻辑的程序逻辑，而性能监视和事务管理等这些横切逻辑则可以使用AOP动态织入到特定的连接点上。

        引介是一种特殊的增强，它为类添加一些属性和方法。这样，即使一个业务类原本没有实现某个接口，通过AOP的引介功能，我们可以动态地为该业务类添加接口的实现逻辑，让业务类成为这个接口的实现类。

        织入是将增强添加对目标类具体连接点上的过程。AOP像一台织布机，将目标类、增强或引介通过AOP这台织布机天衣无缝地编织到一起。根据不同的实现技术，AOP有三种织入的方式：

        a、编译期织入，这要求使用特殊的Java编译器。

        b、类装载期织入，这要求使用特殊的类装载器。

        c、动态代理织入，在运行期为目标类添加增强生成子类的方式。

        Spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。

        一个类被AOP织入增强后，就产出了一个结果类，它是融合了原类和增强逻辑的代理类。根据不同的代理方式，代理类既可能是和原类具有相同接口的类，也可能就是原类的子类，所以我们可以采用调用原类相同的方式调用代理类。

        切面由切点和增强（引介）组成，它既包括了横切逻辑的定义，也包括了连接点的定义，Spring AOP就是负责实施切面的框架，它将切面所定义的横切逻辑织入到切面所指定的连接点中。

        advisor： pointCut advice

        一类功能的增强

        around方法里面代码切面

        事务切面

        缓存切面

        日志切面

        事务（Transaction），一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作；这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；事务是一组不可再分割的操作集合（工作逻辑单元）。

        大致流程形如

        数据库事务拥有几大特性：

        事务的四大特性：

        事务是数据库的逻辑工作单位，事务中包含的各操作要么都做，要么都不做

        事 务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。因此当数据库只包含成功事务提交的结果时，就说数据库处于一致性状态。如果数据库系统 运行中发生故障，有些事务尚未完成就被迫中断，这些未完成事务对数据库所做的修改有一部分已写入物理数据库，这时数据库就处于一种不正确的状态，或者说是 不一致的状态。

        一个事务的执行不能其它事务干扰。即一个事务内部的操作及使用的数据对其它并发事务是隔离的，并发执行的各个事务之间不能互相干扰。

        也称永久性，指一个事务一旦提交，它对数据库中的数据的改变就应该是永久性的。接下来的其它操作或故障不应该对其执行结果有任何影响。

        个人理解，事务在Spring中是借助AOP技术来实现的，可以作为AOP中的一个事务切面。spring源码对事务的处理逻辑，自己研究吧！

        ORM框架中以Mybatis为例，事务处理就是用到了一个类Transaction，部分源码如下

        可以看出Transaction管理的就是一个connection，而connection我们很清楚是与用户会话挂钩的。

        那么关系就是Transaction 管理Connection ，而connection与 用户session一对一存在。

        在springBoot中，只需要加入POM就可以了，配合注解使用即可。

        接下来就是事务的控制了。

        首先事务有几大传播属性：

        其中最常见的，用得最多就 PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、 PROPAGATION_NESTED 这三种。事务的传播属性是 spring 特有的，是 spring 用来控制方法事务的一种手段，说直白点就是用来控制方法是否使用同一事务的一种属性，以及按照什么规则回滚的一种手段。

        下面用代码演示这三种属性的机制：

        事务的默认属性就是required，通过Transactional.java中的Propagation propagation() default Propagation.REQUIRED; 可以看出。

        这种情况就是事务1，事务2 都加入到了事务0中。不管是1，2哪个事务抛出异常，事务0都会回滚。数据添加会失败。

        这种情况就是：

        事务0（required） {

        ​ 事务1 （REQUIRES_NEW）

        ​ 事务2

        }

        此时。

        情况a：

        1、如果只是事务2出现了异常，那么事务1会提交，事务2加入到事务0中会回滚。

        2、如果只是事务1出现了异常，那么事务1会回滚，向上层事务0抛异常，事务2会加入到事务0中，这时都会回滚。

        情况b：

        如果事务1，事务2都是REQUIRES_NEW传播属性。那么结果就是：

        1、如果事务1，抛出了异常，那么事务2是不会执行的，那么事务0必然回滚。

        2、如果事务2，抛出异常，那么事务1会提交，表中会有数据。事务2有异常回滚并抛出，事务0回滚。

        NESTED属性其实就是创建了回滚点，有异常时，会回滚到指定的回滚点。

        在这通过代码测试，出现一种情况是，无论事务1，事务2哪个有异常，数据都不会插入成功，原因是，不论是事务1还是事务2都会向事务0抛出异常，事务0捕获到异常后，执行rollback()方法，这就操作成了，事务的全部回滚。

        如果想要事务1和事务2 想要根据自己的回滚点回滚，那么事务0必须自己处理异常，不让spring捕获到这个异常，那么就满足了。把代码改成这种：

        Jack大佬提供了，伪代码分析法。

        按照Spring源码的事务处理逻辑，伪代码大致为：

Spring注解驱动开发二狗子让我给他讲讲@EnableAspectJAutoProxy注解

       在配置类上添加@EnableAspectJAutoProxy注解，能够开启注解版的AOP功能。这意味着，如果在AOP中要启用注解版的AOP功能，就需要在配置类上添加@EnableAspectJAutoProxy注解。让我们来看看@EnableAspectJAutoProxy注解的源码，如下所示。

       从源码可以看出，@EnableAspectJAutoProxy注解使用@Import注解引入了AspectJAutoProxyRegister.class对象。那么，AspectJAutoProxyRegistrar是做什么的呢？我们点击到AspectJAutoProxyRegistrar类的源码中，如下所示。

       可以看到AspectJAutoProxyRegistrar类实现了ImportBeanDefinitionRegistrar接口。我们回顾ImportBeanDefinitionRegistrar接口的定义，如下所示。

       通过ImportBeanDefinitionRegistrar接口，我们可以实现将自定义的组件添加到IOC容器中。也就是说，@EnableAspectJAutoProxy注解使用AspectJAutoProxyRegistrar对象自定义组件，并将相应的组件添加到IOC容器中。

       在AspectJAutoProxyRegistrar类的registerBeanDefinitions()方法中设置断点，我们以debug的方法来运行AopTest类的testAop()方法。当程序运行到断点位置时，我们可以看到程序已经暂停，IDEA的左下角显示了方法的调用栈。

       在registerBeanDefinitions()方法中，首先调用AopConfigUtils类的registerAspectJAnnotationAutoProxyCreatorIfNecessary()方法来注册registry。在registerAspectJAnnotationAutoProxyCreatorIfNecessary()方法中，直接调用了重载的registerAspectJAnnotationAutoProxyCreatorIfNecessary()方法。在重载的registerAspectJAnnotationAutoProxyCreatorIfNecessary()方法中，传入了AnnotationAwareAspectJAutoProxyCreator.class对象。

       在registerOrEscalateApcAsRequired()方法中，接收到的Class对象的类型为：org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator。然后，我们继续跟进代码。

       在registerOrEscalateApcAsRequired()方法中，首先判断registry是否包含org.springframework.aop.config.internalAutoProxyCreator类型的bean。接下来，我们继续看代码。

       最终，AopConfigUtils类的registerOrEscalateApcAsRequired()方法中，会通过registry调用registerBeanDefinition()方法注册组件，并注册的bean的名称为org.springframework.aop.config.internalAutoProxyCreator。

       接下来，我们继续看AspectJAutoProxyRegistrar类的registerBeanDefinitions()源码。我们通过AnnotationConfigUtils类的attributesFor方法来获取@EnableAspectJAutoProxy注解的信息。接下来，我们继续判断proxyTargetClass属性的值是否为true，如果为true则调用AopConfigUtils类的forceAutoProxyCreatorToUseClassProxying()方法；继续判断exposeProxy属性的值是否为true，如果为true则调用AopConfigUtils类的forceAutoProxyCreatorToExposeProxy()方法。

       综上所述，向Spring的配置类上添加@EnableAspectJAutoProxy注解后，会向IOC容器中注册AnnotationAwareAspectJAutoProxyCreator。

       了解了这些之后，我们就可以关注「冰河技术」微信公众号，后台回复不同的关键字获取相应的PDF文档。这些文档都是由冰河原创并整理的超硬核教程，包括《深入浅出Java 种设计模式》、《Java8新特性教程》和《亿级流量下的分布式限流解决方案》，都是面试必备的资料。

       最后，如果你觉得这篇文章对你有帮助，别忘了点个赞，给个在看和转发，让更多的人看到，一起学习，一起进步！