Shulou(Shulou.com)05/31 Report--

This article to share with you is about what is Spring cycle dependence, Xiaobian think quite practical, so share to everyone to learn, I hope you can read this article after some harvest, not much to say, follow Xiaobian to see it.

What is circular dependence?

Literally, A depends on B while B depends on A, as above, or C depends on itself. And that's what it looks like at the code level.

@Component

public class A {

// A is injected with B

@Autowired

private B b;

}

---

@Component

public class A {

// A is injected with B

@Autowired

private B b;

}

---

//rely on yourself

@Component

public class C {

// C is injected into C

@Autowired

private C c;

}

Although the form of embodiment is different, it is actually a problem of circular dependence.

Under what circumstances can circular dependencies be handled?

Spring solves circular dependencies with preconditions

Beans with circular dependencies must be singletons, which is not required at all if they depend on prototypes.

Dependency injection can't all be constructor injection (can only resolve circular dependencies of setter methods, which is wrong)

1. AB is injected by setter method, the result is OK.

2. AB both adopt attribute Autowired injection result ok3. AB is injected by constructor method, and cyclic dependence appears. 4. The way to inject B in A is setter method, and the way to inject A in B is constructor 5. The method of injecting B into A is constructor, and the method of injecting A into B is setter method. Conclusion Whether the injection method of dependency solves AB interdependence (cyclic dependence) or not, setter method is used. AB interdependence (cyclic dependence) is injected automatically. AB interdependence (cyclic dependence) is injected automatically. AB interdependence (cyclic dependence) is injected automatically. Constructor is used. The way to inject B in A is setter method. The way to inject A in B is constructor AB interdependence (cyclic dependence). The way to inject A in B is setter method. The way to inject B in A is constructor. Spring creates beans according to natural ordering by default, A is created before B No

From the above test results we can see that circular dependencies can be resolved not only in the case of setter method injection, but also in the case of constructor injection.

Spring Cycle Dependency

The creation of Spring bean is essentially the creation of an object. Since it is an object, it must be understood that a complete object contains two parts: the instantiation of the current object and the instantiation of the object attributes. In Spring, instantiation of an object is achieved through reflection, and properties of an object are set in a certain way after the object is instantiated. This process can be understood as follows:

A rough drawing of the dependency flow diagram is as follows: getBean() in the diagram indicates that Spring's ApplicationContext.getBean() method is called, and the parameters in this method indicate the target object we are trying to obtain. The black arrow in the figure indicates the direction of the method call at the beginning. At the end, after returning the A object cached in Spring, it indicates that the recursive call has returned, which is represented by the green arrow. From the figure, we can clearly see that the a attribute of the B object is the semi-finished product A object injected in the third step, and the b attribute of the A object is the finished product B object injected in the second step. At this time, the semi-finished product A object also becomes the finished product A object, because its attributes have been set.

At this point, Spring's overall solution to the circular dependency problem has been relatively clear. There are only two things to understand about the overall process:

Spring recursively acquires the target bean and its dependencies;Spring instantiates a bean in two steps, first instantiating the target bean and then injecting attributes into it.

Combine these two points, that is, when Spring instantiates a bean, it first recursively instantiates all the beans it depends on, until a bean does not depend on other beans, then it will return the instance, and then recursively set the bean obtained to the attributes of each upper bean.

Spring Cycle Dependency Advanced

The general process of creating an object consists of three parts:

Instantiation: simple understanding is that a new object attribute injection: for the instantiation of the new object filled with attributes initialization: execution of the aware interface methods, initialization methods, complete the AOP proxy

Spring solves the above problems through "Level 3 Cache":

SingletonObjects: Level 1 cache stores all created singletons BeanearlySingletonObjects: objects that have been instantiated but have not yet been attribute injected and initialized singletonFactories: a single-instance factory exposed in advance. Level 2 cache stores objects obtained from this factory.

Then we move on to regular circular dependencies and circular dependencies with AOP.

ordinary circular dependency graph

Conclusion: Circular dependencies between beans without AOP As can be seen from the analysis of the above figure, in this case,"the third-level cache is useless"! So there's no such thing as increased efficiency.

Circular Dependency with AOP

With AOP is almost the same as without AOP, except that it stores functional interfaces in the third-level cache and returns proxy objects directly when needed. Meaning of Level 3 Cache:

❝

Proxy objects are generated in advance only when circular dependencies actually occur, otherwise only a factory is created and put into the third-level cache, but the object is not actually created through the factory.

❞

Is it possible to use level 2 cache instead of level 3 cache?

❝

Answer: No, contrary to Spring's design in combining AOP with Bean's lifecycle! Spring combines the lifecycle of AOP and beans (see figure below) itself through the postprocessor AnnotationAwareAspectJAutoProxyCreator, which completes the AOP proxy for the initialized Bean in the postProcessAfterInitialization method. If circular dependencies occur, there is no choice but to create a proxy for the Bean first, but in the absence of circular dependencies, the bean is designed to complete the proxy at the end of the lifecycle rather than immediately after instantiation.

❞

In the case of using a third-level cache, the creation process of A and B does not use a third-level cache, but directly in the second-level cache Conclusion: The only difference between the above two processes is that the time to create a proxy for A is different. In the case of using a third-level cache, the time to create a proxy for A is when A needs to be injected into B, while without using a third-level cache, it is necessary to create a proxy for A immediately after instantiation of A and then put it into the second-level cache. Level 3 cache cannot be speeded up!

Answer template Spring How to solve circular dependencies

A: Spring solves circular dependencies through a third-level cache, where the first-level cache is singleton objects, the second-level cache is early-exposed objects, and the third-level cache is early-exposed object factories.

When two classes A and B are cyclically referenced, after A is instantiated, it uses the instantiated object to create an object factory and add it to the third-level cache. If A is AOP proxied, then what is obtained through this factory is the object after A is proxied. If A is not AOP proxied, then what is obtained by this factory is the object instantiated by A.

When A performs attribute injection, it will create B, and B depends on A, so when creating B, it will call getBean(a) to obtain the required dependency. In this case, getBean(a) will obtain from the cache:

❝

Step 1: Get the factory in the third-level cache first;

Step 2: Call the getObject method of the object factory to get the corresponding object, and inject it into B after getting this object. Then B goes through its lifecycle, including initialization, post-processors, and so on.

Step 3: When B is created, B is injected into A, and A completes its entire life cycle. At this point, the circular dependency is over!

Interviewer: Why do you use Level 3 cache? Can L2 cache solve circular dependencies?❝

Answer: If you want to use a second level cache to resolve circular dependencies, it means that all beans must complete AOP proxies after instantiation, which violates the principles of Spring design. Spring was originally designed to complete AOP proxies at the last step of the Bean life cycle through the post-processor AnnotationAwareAspectJAutoProxyCreator, rather than AOP proxies immediately after instantiation.

The above is what is Spring cycle dependency, Xiaobian believes that some knowledge points may be what we see or use in our daily work. I hope you can learn more from this article. For more details, please follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.