安卓如何判断组件有循环依赖
❶ 安卓android的components指什么,谢谢
安卓Android平台指纹性格测试是一款依据指纹测试性格的应用,因为世界上绝对找不到两个指毕团纹完全相同的人,所以“指纹薯纯”就被当做犯罪侦查上的重要线索手手橘之一。虽
❷ 关于安卓手机桌面上面的小组件怎么添加和修改。。
1、打开手机界面
❸ 安卓开发线程和进程讲解
本教程为大家介绍安卓开发中的线程和进程，安卓平台中当首次启动运行一个组件的时候，Android会相应的启动了一个进程。默认的，所有的组件和程序运行在这个进程和线程中，也可以安排组件在其他的进程或者线程中运行。
进程：组件运行的进程由manifest file控制。组件的节点activity, service, receiver, 和 provider 都包含一个 process 属性。这个属性可以设置组件运行的进程：可以配置组件在一个独立进程运行，或者多个组件在同一个进程运行。甚至可以多个程序在一个进程中运行——如果这些程序共享一个User ID并给定同样的权限。 节点也包含 process 属性，用来设置程序中所有组件的默认进程。
所有的组件在此进程的主线程中实例化，系统对这些组件的调用从主线程中分离。并非每个对象都会从主线程中分离。一般来说，响应例如View.onKeyDown()用户操作的方法和通知的方法也在主线程中运行。这就表示，组件被系统调用的时候不应该长时间运行或者阻塞操作(如网络操作或者计算大量数据)，因为这样会阻塞进程中的其他组件。可以把这类操作从主线程中分离。
当更加常用的进程无法获取足够内存,Android可能会关闭不常用的进程。下次启动程序的时候会重新启动进程。
当决定哪个进程需要被关闭的时候， Android会考虑哪个对用户更加有用。如Android会倾向于关闭一个长期不显示在界面的旦颂歼进程来支持一个经常显示在界面的进程。
线程：即使为组件分配了不同的进程，有时候也需要再分配线程。比如用户界面需要很快对用户进行响应，因此某些费时的操作，如网络连接、下载或者非常占用服务器时间的操作应该放到其他线程。
线程通过java的标准对象Thread 创建. Android 提供了很多方便的管理线程的方法：— Looper 在线程中运行一个消息循环; Handler 传递一个消息; HandlerThread 创建一个带有消息循环的线程。
远程调用Remote procere calls
Android有一个远程调用(RPCs) 的轻量级机制— 通过这个机制，方法可以在本地调用，在远程执行(在其他进程执行)，还可以返回一个值。要实现这个需求，必须分解方法调用，并且所有要传递的数据必须是操作系统可以访问的级别。从本地的进程和内存地址传送到远程的进程和内存地樱正址并在远程处理和返回。返回值必须向相反的方向传递。Android提供了做以上操作的代码，所以开发者可以专注于实现RPC的接口。
一个RPC接口只能包含方法。所有的方法都是同步执行的(直到远程方法返回，本地方法才结束阻塞)，没有返回值的时候也是如此。
简单来说，这个机制是这样的：使用IDL (interface definition language)定义你想要实现的接口， aidl 工具可以生成用于java的接口定义，本地和远程都要使用这个定义。它包含2个类，
inner类包含了所有的管理远程程序(符合IDL描述的接口)所需要的代码。所有的inner类实现了IBinder 接口.其中一个在本地使用，可以不管它的代码;另外一个叫做Stub继承了 Binder 类。为了实现远程调用，这个类包含RPC接口。开发者可以继承Stub类来实现需要的方法。
一般来说，远程进程会被一个service管理(因为service可以通知操作系统这个进程的信息并和其他进程通信)，它也会包含aidl 工具产生的接口文件，Stub类实现了远处那个方法。服务的客户端只需要aidl 工具产生的接口文件。
以下是如何连接服务和客户端调用：
·服务的客户端(本地)会实现onServiceConnected() 和onServiceDisconnected() 方法，这样，当客户端连接或者断开连接的时候可以获取到通知。通过 bindService() 获取到服务的连接。
· 服务的 onBind() 方法中可以接收或者拒绝连接，取决它收到的intent (intent通过 bindService()方法连接到服务). 如果服务接收了连接，会返回一个Stub类的实例.
· 如果服务接受了连接，Android会调用客户端的onServiceConnected() 方法，模冲并传递一个Ibinder对象(系统管理的Stub类的代理)，通过这个代理，客户端可以连接远程的服务。
以上的描述省略很多RPC的机制。请参见Designing a Remote Interface Using AIDL 和 IBinder 类。
线程安全的方法
在某些情况下，方法可能调用不止一个的线程，因此需要注意方法的线程安全。
对于可以远程调用的方法，也要注意这点。当一个调用在Ibinder对象中的方法的程序启动了和Ibinder对象相同的进程，方法就在Ibinder的进程中执行。但是，如果调用者发起另外一个进程，方法在另外一个线程中运行，这个线程在和IBinder对象在一个线程池中;它不会在进程的主线程中运行。例如，一个service从主线程被调用onBind() 方法，onBind() 返回的对象(如实现了RPC的Stub子类)中的方法会被从线程池中调用。因为一个服务可能有多个客户端请求，不止一个线程池会在同一时间调用IBinder的方法。因此IBinder必须线程安全。
简单来说，这个机制是这样的：使用IDL (interface definition language)定义你想要实现的接口， aidl 工具可以生成用于java的接口定义，本地和远程都要使用这个定义。它包含2个类，
inner类包含了所有的管理远程程序(符合IDL描述的接口)所需要的代码。所有的inner类实现了IBinder 接口.其中一个在本地使用，可以不管它的代码;另外一个叫做Stub继承了 Binder 类。为了实现远程调用，这个类包含RPC接口。开发者可以继承Stub类来实现需要的方法。
一般来说，远程进程会被一个service管理(因为service可以通知操作系统这个进程的信息并和其他进程通信)，它也会包含aidl 工具产生的接口文件，Stub类实现了远处那个方法。服务的客户端只需要aidl 工具产生的接口文件。
以下是如何连接服务和客户端调用：
·服务的客户端(本地)会实现onServiceConnected() 和onServiceDisconnected() 方法，这样，当客户端连接或者断开连接的时候可以获取到通知。通过 bindService() 获取到服务的连接。
· 服务的 onBind() 方法中可以接收或者拒绝连接，取决它收到的intent (intent通过 bindService()方法连接到服务). 如果服务接收了连接，会返回一个Stub类的实例.
· 如果服务接受了连接，Android会调用客户端的onServiceConnected() 方法，并传递一个Ibinder对象(系统管理的Stub类的代理)，通过这个代理，客户端可以连接远程的服务。
线程安全的方法
在某些情况下，方法可能调用不止一个的线程，因此需要注意方法的线程安全。
对于可以远程调用的方法，也要注意这点。当一个调用在Ibinder对象中的方法的程序启动了和Ibinder对象相同的进程，方法就在Ibinder的进程中执行。但是，如果调用者发起另外一个进程，方法在另外一个线程中运行，这个线程在和IBinder对象在一个线程池中;它不会在进程的主线程中运行。例如，一个service从主线程被调用onBind() 方法，onBind() 返回的对象(如实现了RPC的Stub子类)中的方法会被从线程池中调用。因为一个服务可能有多个客户端请求，不止一个线程池会在同一时间调用IBinder的方法。因此IBinder必须线程安全。
简单来说，一个content provider 可以接收其他进程的数据请求。即使ContentResolver和ContentProvider类没有隐藏了管理交互的细节，ContentProvider中响应这些请求的方法(query(), insert(), delete(), update(), and getType() )— 是在content provider的线程池中被调用的，而不是ContentProvider的本身进程。因为这些方法可能是同时从很多线程池运行的，所以这些方法必须要线程安全。
❹ 如何组织应用程序的结构
适用于应用程序使用的软件设计和构架总结软件架构一般定义为应用程序的结构。在定义这些结构的时候，软件架构师的目标就是使用不同级别的抽象，通过根据关注点把功能进行分割来最小化复杂度。我们会从最高层的抽象以及不同的关注点开始研究。因为设计的过程中需要不断深入这些层次、扩展关注点直到定义了结构为止。内容目标概览概要步骤第一步——选择我们的分层策略第二步——定义层之间的接口第三步——选择我们的部署策略第四步——选择通讯协议其它资源目标找出并选择分层策略定义层之间的接口找出并选择部署策略选择合适的通讯协议概览在开始应用程序设计的时候，我们第一个任务就是关注最高层次的抽象并且开始把功能分组到不同的层中。然后，我们需要根据我们所设计的应用程序的类型为每一层定义公共的接口。在定义了层和接口之后我们就需要决定应用程序是如何部署的。最后，最后一个步骤包含选择会用于在应用程序不同逻辑层和物理侍巧枯层之间通讯的协议。概要步骤第一步——选择我们的分层策略第二步——定义层之间的接口第三步——选择我们的部署策略第四步——选择通讯协议第一步——选择我们的分层策略层表示组件按照不同关注点的逻辑分组。例如，业务逻辑表示应该分组到某层的一个关宽族注点。这可能是应用程序最初设计中最重要的一个抉择。然而，有很多种方式可以把功能进行分层。在完成了本步骤之后你应该能理解如何来组织应用程序的分层结构。下图演示了用于大多数业务应用程序设计的主要层。在这个示例中，功能按照表现逻辑、服务逻辑、业务逻辑和数据访问逻辑进行分组。如果服务没有公开的话，就不需要服务层，那么我们应该只有表现、业务和数据访问层。 这只是一个示例，不是对应用程序进行分层的唯一方式。然而，一般来说分层在软件设计中很常见。底层的操作系统设计使用了RING的方式，RING0（内核）表示最低的层，它可以直接访问诸如CPU和内存等硬件资源。设备驱动作为外层RING通过RING0提供的接口和硬件进行交互。应用程序代码包含在最外部的RING中，它们通过设备驱动来和硬件交互。除了层，我们还有一些功能会跨越层，它们通常称作横切。此类功能包含诸如日志以及异常管理等。有不同的方式来处理这种功能，比如公共类库、使用元数据直接在编译输出中插入横切代码的面向方面编程（AOP）等。在为应用程序选择分层策略的时候，如下事项是我们需要考虑的关键点：决定我们是否需要层选择我们需要的层决定我们是否需要合并层决定层之间交互的规则决定我们是否需要层在大多数情况下总是需要把功能进行分层。然而，在有些特例下不需要。例如，如果我们构建一个非常小的应用程序，可能就会考虑在用户界面事件处理程序中实现表现、业务逻辑以及数据访问功能。此外，一些软件工程师会认为跨层边界或增加层带来的开销会对性能有负面影响。 是否使用分层的决定说白了就是性能对可维护性。虽然不使用分层可以提升性能，因为所有的东西都紧密耦合在了一起。但是，这种耦合会严重影响应用程序的扩展和维护能力。说实话，对可扩展性和可维护性的影响远比获得的那一点性能的提升重大。不管怎么始终应该考虑分层，我们的目标其实是决定应用程序需要怎么样合适的分层。选择我们需要的层有几种不同的方式来把功能进行分层。例如一种分层的方式就是表现、服务和数据访问。许多关注业务领域的面向对象设计使用又一种不同的分层策略，最底层用于基础结构代码，提供类似数据访问的支持。上面一层就是领域层，用于包含业务领域对象，最顶层包含应用程序代码。对于使用微软.NET Framework开发的大多数业务应用程序来说，按照表现、服务、业务以及数据访问对功能进行分组是不错的选择。下面描述了每一层中的一些组件，以及什么时候不需要这层。表现-这层包含用于处理用户接口请求以及呈现用户接口输出的组件。如果我们的应用程序没有用户接口的话就不需要表现层。服务-这层包含用于处理服务请求的组件。例如，对于使用Windows Communication Foundation (WCF)的应用程序，我们就会找到定义契约的组件、用于实现接口以及提供在实现类和外部契约类之间提供转换支持的组件。如果我们的应用程序不提供服老洞务，则不需要在设计中包含服务层。Business业务-这层包含用于处理表现或服务层请求的组件。在这层中的组件包括业务处理、业务实体以及业务工作流。在一些情况下，我们不需要有任何的业务层并且只需要从数据源获取数据，也就是说这种情况下不需要业务层。数据访问-这层包含用于管理和数据源交互的组件。例如，使用ADO.NET的话在数据访问层中就会有连接和命令组件。如果我们的应用程序不使用外部数据的话那么我们就不需要实现数据访问层。决定我们是否需要合并层例如，应用程序具有很有限的业务规则并且主要关注验证的话可以在一层中实现业务和表现逻辑。在以下情况考虑合并层： 如果我们的业务规则很有限，在一层中实现业务和表现逻辑是合理的。如果我们的应用程序从服务获取数据并且显示数据，可以直接为表现层添加服务引用并且直接使用服务数据。这样的话就可以合并数据访问和表现。 如果数据访问服务直接访问数据库中的表或视图的话可以考虑在服务层中实现数据访问功能。还有一些适用于合并分层的示例。然而，基本准则是我们总是应该把功能分层。在一些情况下，层只不过是一层调用并且没有提供什么功能。然而，如果把功能进行分离的话我们就可以在影响很小或没有影响的情况下扩展其功能。决定层之间的交互规则分层策略带来的一个问题是我们需要定义层之间如何交互的规则。指定这样的一种交互规则的主要原因是最小化依赖以及消除循环引用。例如，如果两个层依赖另外那个层的组件就很可能带来循环依赖。最常见的准则是只允许层之间的单向交互。从上到下的交互–比较高的层可以和其下层进行交互，但是低层不可以和其上的层进行交互。在设计中总是应该强制这样的准则来避免层之间的循环依赖。紧密交互 –每一层只能直接和其下的层进行交互。这个准则可以强制严格的关注分离，应该每一层只知道其直接下属层。这个准则的好处是对某一层的修改只会影响其直接上层。松散交互–高层可以跳过一些层直接和底层进行交互。这可以增加性能，但是也会增加依赖。换句话说，对底层的修改可能会影响其上的多个层。考虑使用紧密交互规则：如果我们设计的应用程序会不断修改来增加新的功能，并且我们希望最小化改变的影响。如果我们设计的应用程序可能会跨物理层进行分布。考虑使用松散交互规则：如果我们设计的应用程序肯定不会跨物理层进行分布。例如是安装在客户机上的独立富客户端应用程序。如果我们设计一个很小的应用程序，影响多层的改动工作量不大。检查点在结束本步骤之前，你应该可以回答如下问题：你是否找到了应用程序需要的功能并且把功能分层？你是否定义了层之间如何交互的规则？第二步——定义层之间的接口对于为层定义接口，最主要的原则是在层之间使用松散耦合。意思就是层不应该公开内部组件让其它层来依赖。而是，层的接口应该设计为最小的依赖性，提供公共接口并且隐藏层中组件的细节。隐藏细节叫做抽象，有很多种方式实现抽象。如下设计方式用来为层定义接口：抽象接口 –可以通过定义抽象基类或类型定义来实现。基类或类型定义了所有层消费者用于和层进行交互的公共接口。通过使用实现抽象接口的测试对象，有的时候又叫做mock对象，可以增进可测试性。公共设计类型 –许多设计模式定义表示不同层中接口的对象类型。这些对象类型提供了一个抽象，它隐藏了层中的细节。例如，表数据入口模式定义了表示数据库中表的对象类型。这些对象负责实现和数据库交互的必要SQL代码。对象的消费者不需要知道使用的SQL甚至不需要知道连接数据库和执行命令的细节。依赖倒置 –这是一种编程模式，抽象接口定义在任何层的外部或不依赖于任何层。层不依赖于公共接口，而不是一个层依赖于另一个层。依赖注入模式是依赖导致的常见实现方式。通过依赖注入组件，一层可以通过使用公共抽象接口来注入到其它层的组件中。基于消息 –基于消息的接口可以用于提供层之间的交互，而不是直接和组件进行交互。有多种消息解决方案，比如web服务和支持跨机器和进程边界的微软消息队列。然而，你也可以组合抽象接口和用于定义要交互的数据结构的公共消息类型。 基于消息最主要的区别是层之间的交互使用公共结构，它封装了交互的细节。这个结构可以定义操作、数据架构、错误契约、安全信息以及其它和层之间通讯相关的细节。考虑使用抽象接口：如果你希望使用接口具体实例来实现不同行为的能力。如果你希望使用mock对象来增加应用程序的可测试性。考虑使用公共设计类型：如果你在为层中的接口实现设计模式。许多设计模式基于抽象接口，然而，一些基于具体类。如果你希望一种快捷而简单的方式实现层接口。比如表数据入口模式。考虑使用依赖导致：如果你希望提供最大的可测试性，这个方式允许你诸如具体的测试类到设计中的不用层中。考虑使用基于消息的：如果你要实现一个web应用程序并且在表现层和业务层中定义接口。如果你有一个应用程序层需要支持多个客户端类型。如果你希望提供跨物理和进程边界交互。如果你希望以公共接口进行交互。如果你要和一个无状态的接口进行交互，状态信息使用消息进行携带。 对于web应用程序表现层和业务逻辑层之间的交互推荐使用基于消息的接口。一般通过使用Windows Communication Foundation (WCF)或提供公共消息类型的抽象接口来实现。在表现层和业务层之间使用基于消息的接口的原因是因为web应用程序的业务层不维护调用间的状态。换句话说，每一次表现层和业务层中的调用都代表一个新的上下文。通过使用基于消息的接口我们可以随请求传递上下文信息并且为表现层中的异常和错误处理提供一种公共的模型。检查点在结束本步骤之前，你应该可以回答如下问题：你是否需要使用抽象接口提供测试性？你的接口是否需要提供跨进程和机器边界交互？你的业务层是否需要支持多个客户端类型？你是否会使用基于消息的接口在web应用程序的表现层和业务层之间进行交互？第三步——选择部署策略对于大多数解决方案中都可以找到几种常见的模式，它们表示了应用程序的部署结构。如果要为我们的应用程序决定最佳部署解决方案，首先需要了解常见的模式。在理解了不同的模式之后，然后你就可以考虑场景、需求以及安全约束来选择某一种或多种模式。客户端-服务器这个模式表示具有两个主要组件：客户端和服务器的基本结构。对于这种情况，客户端和服务器可以在相同机器上也可以跨越两个机器。如下示例演示了常见的web应用程序场景，客户端和web服务器进行交互。N层这个模式表示应用程序组件跨域一个或多个服务器的结构。下图表示了2层部署，所有应用程序代码位于客户端而数据库位于分离的服务器中。3层在3层设计中，客户端和部署在独立服务器的应用程序软件进行交互，和数据库进行交互的应用程序服务器也是单独的服务器。这是许多web应用程序和web服务常见的模式。 4层对于这种情况，web服务器从物理上和应用服务器分离。这么做通常处于安全的目的，web服务器部署在隔离区域（DMZ）中而应用程序服务器位于不同的子网。我们一般会在客户端和web层以及web层和应用层或业务逻辑层之间假设2道防火墙。考虑客户端服务器或2层： 如果我们在开发一个需要访问应用服务器的客户端。 如果我们在开发一个访问外部数据库的独立客户端。考虑3层： 如果我们在开发基于局域网的应用程序，所有服务器都在一个私有网络中。 如果我们在开发基于Internet的应用程序，并且安全需求不约束在公共的web/应用服务器中实现业务逻辑。考虑4层： 如果安全需求规定业务逻辑不能在DMZ中部署业务逻辑。 如果我们的应用程序使用服务器上的资源很厉害并且我们希望把功能分离到另一个服务器。在大多数情况下推荐让所有的应用程序代码放在相同服务器。任何需要跨物理边界的需求都会影响性能因为数据需要在这些边界进行序列化。然而，有一些情况下我们需要跨服务器分离功能。此外，根据服务器的位置我们可以选择性能最优化的通讯协议。检查点在结束本步骤之前，你应该可以回答如下问题： 安全需求是否规定业务逻辑不能部署在公开的DMZ中？ 我们是否在开发独立的只需要访问数据库的客户端？ 我们是否在开发web应用程序或web服务？ 我们是否在开发有多个客户端的应用程序？ 第四步——选择通讯协议说到设计中用于跨逻辑层或物理层进行通讯的物理协议，通讯协议的选择对我们应用程序的性能起巨大作用。选择通讯协议的一个主要的地方就是使用服务和数据库进行交互。 Windows Communication Foundation (WCF) –直接支持四种协议： HTTP –用于在Internet上公开的服务。 TCP –用于在网络内部署的服务。 NamedPipes –用于服务和其使用者部署在同一服务器的服务。 MessageQueue –用于通过微软消息队列实现进行访问的服务。 Database –支持和WCF一样的许多协议。 HTTP –用于在Internet上公开的数据库。 TCP –用于在网络内部署的数据库。
❺ 安卓项目 如何让一个mole依赖于另一个mole
androidStudio(后面简称AS)在导入一个外部的本地mole时，AS采用的是复制一份到当前项目目录下这种策略。这种方式在开发一个项目时并不会有什么大问题，不过，在多个项目都引用同一个或几个mole时就会出现大问题，这种公用的mole通常都是框架类或工具类mole，如果每个项目都复制一份mole到自己项目目录下，如果某天发现mole中有几个bug需要修改，你就会发现，你不得不去每个目录下修改mole，如果是修改的东西比较多的话，绝对是欲哭无泪。
上述就是研究多项目依赖同一个mole这个问题的起因，下面直接说说怎么解决（目前官方似乎没有直接支持的方法，不过我相信以后肯定会支持），首先为了方便维护，我们新建一个项目，这个项目下只有公用的mole,不放任何application
❻ 使用abp框架如何避免循环依赖
使用abp框架避免循环依赖胡郑衫首先定义两个相互通过构造器注入依赖的bean，如下。
1、最有效、最直接的办法就是重新设计，将组件的结构设计裤腔的更明确，避免循环依赖。
2、使用set注入只有构造方法是在上下文加载时就要求被注入，容易出现循环依赖，所以我们可以使用其他注入方式进行依赖注入，set注入与构造注入丛基不同。
3、使用Lazy，通过延迟加载的方式防止循环依赖，也就是它没有完全的初始化，而是创建一个代理将它注入另一个，只有第一次使用它时才会创建。
❼ IOC之getBean()以及循环依赖
众所周知，getBean是spring中实际获取Bean实例的方法，那么，getBean除了我们人为拿到beanFactory然后执行getBean()逻辑之外，还有哪里会调用呢？
一个比较重要的入口就是refresh方法，spring容器创建后，会调用refresh()方法来刷新上下文，而其中的就会通过getBean()来创建非延迟加载的bean实例。
preInstantiateSingletons中就是做一些是否需要通过getBean()提前获取bean的逻辑判断：
比较重要的getBean()的入口就是这里了，下键培面来看下 getBean()中做了什么。
getBean()中直接调用了doGetBean方法，这是spring 的一贯风格，一般do打头的方法才是真正做事情的方法。
这里面有一个比较关注的点就是，非单例模式下，对循环依赖的判断 ，主要是三个方法：
用于注册的容器是一个ThreadLocal，而存储内容 如果只有一个beanName的话就是一个string ，而当一个线程生产多个bean实例时，就会转为一个set来存储所有创建中的beanName,这样 就可以 通过方法判断，当前需要生成的bean是否已经在创建中，如果已经在创建中，就可以判断发生了循环依赖，这时就会直接报错。
ps. 可以往下先看整个createBean的流程，反过来再看这里，可能会更好理解一点。
在非单例模式下，spring是无法解决循环依赖的，所以当判断发生了循环依赖时，就会直接报错 ，而在单例模式下，spring会采取一定的手段尝试解决循环依赖，所以单例模式下的循环依赖的判断与敬弊其他情况走了不同的逻辑（构造方法的单例模式循环依赖无法解决）：
createBean中是实际创建实例的逻辑了，判断是否无法解决的循环依赖是在getSingleton方法中完成的：
其中 singletonFactory.getObject(); 其实就是外面我们传进来的createBean方法，是用于实际的创建对象的，而对循环依赖的判断是通过这几个方法解决的：
关于 inCreationCheckExclusions 我们先不管，这里判断循环依赖主要用到的是singletonsCurrentlyInCreation这个set，如果是普通的属性依赖即：
在创建A的时候，会通过addSingletonFactory这个方法将A提前暴露出去，然后，在populateBean中，发现需要B，这个时候B也会走到populateBean方法，然后又通过getBean方法获取A，由于A已经提前暴露了（在getBean就可以直接从三级缓存拿到A的引用，而不用走beforeSingletonCreation的逻辑），所以B可以直接拿到A的引用从而解决了循环依赖。
而如果A和B是构造方法中互相依赖的话：
这个时候，情况又会大不一样，在创建A的时候，会首先实例化A对象，在实例化的过程中，发现依赖了B（A提前暴露的逻辑是在实例化之后的，所以这个时候，A不会被添加到三级缓存中），这个时候就通过getBean获取B对象，然后B对象实例化，发现依赖了A，从而再次通过getBean获取A对象，由于A对象没有在三级缓存中，所以会执行到上稿稿唯面说的beforeSingletonCreation方法中，可以想象到此时!this.singletonsCurrentlyInCreation.add(beanName)方法一定是true，从而抛出异常，这也就是为什么在spring单例模式下无法解决构造方法循环依赖的原因。
可以看到 这里又是一堆逻辑，我们把经历放在重点上也就是doCreateBean：
整个方法有四个关键点 ：
非单例模式：
单例模式(构造器循环依赖)：
单例模式（属性循环依赖）：
❽ Spring是如何解决循环依赖的
你需要我，我需要你就是循环依赖
在Spring中使用的三级缓存来解决循环依赖问题，这里的缓存其实就是Map对象
当获取一个Bean时会先从缓存中查找是否有相应的Bean。
1 创建A实例
2 将A实例（半初始化，属性没有填充）暴露放入缓存中
3 填充A实例的属性
4 A实例属性依赖B对象
5 创建B对象实例
6 填充B实例属性
7 B实例属性依赖A对象
8 将上面已经暴露到三级缓存中的A对象注入给B实例
在获取A对象的时候执行上面27.1中的getSingleton方法，会将三级缓存中A这个半初始化状态的对象移除，将其存入到二级缓存中。
9 B实例Bean的创建工作继续执行初始化方法
B如果需要AOP代理？最终B对象是个代理对象。B到此就完全的初始化完了，B的依赖对象A此时是个半初始化状态的对象
10 B实例对象保存到一级缓存
最终B实例创建，初始化都执行完后会将自身加入到一级缓存同时清除二级，三级缓存
11 A实例Bean创建继续执行
如果B是被AOP代理的那么此时的A实例注入的B对象就是一个代理对象。
12 A实例Bean执行初始化方法
13 A继续执行上面的10步骤
三级缓存解决问题：循环依赖+AOP问题
只用一，二级缓存：
从上面罗列的步骤看似乎很是完美解决了循环依赖问题，接下来我们看看加入AOP的场景
假如A，B两个对象最终都是要被AOP代理的
执行到这里，A中依赖的B是代理对象没有问题，但是B中依赖的A对象是原始对象；这就不正确了应该依赖的A也必须是代理对象才是。
引入三级缓存：
三级缓存引入了ObjectFactory对象，在获取对象的时候，是调用ObjectFactory#getObject方法。
而这个getObject方法的实现实际执行的是getEarlyBeanReference方法，再来回顾下：
在创建实例时先将其存入三级缓存中：
getEarlyBeanReference方法就是提前创建代理对象
如果开启了AOP代理后
通过getEarlyBeanReference方法提前创建代理对象。这样就解决了循环依赖时AOP代理问题。保证获取的都是同一个对象。
其实引入三级缓存还解决了一个问题就是延迟代理对象的创建，如果不应用ObjectFactory方式那么我们需要不管需不需要都要先创建代理对象，而引入ObjectFactory可以在注入的时候先暴露的是ObjectFactory只有在调用getObject方法的时候才去创建真正的代理对象（避免了所有Bean都强制创建代理对象）。当没有被代理时可以直接返回原始对象，如果被代理会提前创建代理对象。
不用二级直接是用一，三级缓存？
假设场景：A 依赖 B，B 依赖 A、C，C 依赖 A
如果这样会出现不同的代理对象，每次调用getObject都会创建不同的代理对象（在上面的场景中如果只用一，三级缓存那么 B 依赖 A会通过getObject获取一个代理对象Proxy$1，接着注入C的时候 C中又依赖A，那这时候又从getObject获取对象那么返回的将又会是一个新的代理对象Proxy$2；在这个过程中A对象就出现了2个不一样的对象了，这肯定是错误的）。而引入二级缓存也就解决了这个问题。只有二级缓存没有的时候才从三级缓存汇总获取（如果需要则创建代理对象，然后保存到二级缓存中，二级缓存中已经是提前创建了代理对象（如果需要代理））。
当一个Bean完全的创建完以后放入一级缓存中，此时会吧二级三级中的缓存清除。
完毕！！！！
SpringMVC参数统一验证方法
SpringBoot多数据源配置详解
SpringCloud Nacos 整合feign
Spring AOP动态代理失效的解决方法@Transactional为何会失效
SpringBoot配置文件你了解多少？
SpringBoot邮件发送示例 Springboot面试题整理附答案
SpringBoot项目查看线上日志
在Spring Cloud 中你还在使用Ribbon快来试试Load-Balancer
SpringBoot分库分表sharding-sphere3