Spring's IOC
synopsis
First of all, the official website has this sentence: Spring Framework implementation of the Inversion of Control (IoC) principle. This sentence translates to: Spring implementation of the Inversion of Control (IOC) principle, from which it can be concluded that Inversion of Control (IOC) is a principle called Inversion of Control (IoC), and Spring implements it. And the most common way to realize this principle or design principle is also the way Spring Framework uses is called Dependency Injection, which is Dependency Injection (DI). Therefore, we want to talk about IOC is actually to talk about Spring is how to implement IOC and DI, specifically with what, how to do.
- Inversion of control: the entire process of creating and destroying objects of a class is handed over to the IOC container to be managed
- Dependency Injection: we inject specific beans into the IOC container through several injection methods.
Bean
Beans are an important concept in Spring's implementation of IOC, as stated on the official website:
In Spring, the objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container.
Through this sentence we can see that the bean is actually instantiated by the Spring IOC container, assembly, management of the object. That is to say, the creation and management of objects do not have to worry about, these are left to the Spring Framework IOC container to manage, which is the idea of reversal of control, and bean is the object we inject. When to instantiate the bean will not be written in the program, that is, we do not need to instantiate the object, only need to use the time to get on the line, this way not only so that we do not have to spend effort to manage the object, but also to avoid some of our own wrong instantiation of the object caused by memory problems.
Bean life cycle
- Single instance: the object is created when the container is created, accompanied by the container has been in the survival state, and the object is destroyed when the container is destroyed
- Multiple instances: when the object is used to create a new object, along with the use of the object has been in the survival state, when the object is not used within a certain period of time by the GC recycled
Ways to inject beans
- Constructor injection: the default is a non-parametric constructor, if it is injected in a non-parametric way, there must be a valid non-parametric constructor in the class, otherwise an exception will be reported.
- Setter method injection: Instantiated objects are injected through the Setter method of the class.
- Field injection: through the name of the field directly to the field to inject the value, you can also directly inject the bean, the two beans for the reference relationship
Injecting relevant annotations
- @Autowired: auto assembly of objects by type, if a type corresponds to more than one object then you can use @Qualifier, the role of @Qualifier is to be able to auto assembly by name
- @Resource: this annotation is first assembled by name, if name is not declared then it is assembled according to the type of the class, in the reverse order of @Autowired
- @Bean: mainly used in @Configuration annotated classes, can also be used in @Component annotated classes, we can see by looking at the @Bean meta-annotation, he can only be used in other annotations or methods of the class, the default name of the bean for the name of the method, but also can be customized with the name and aliases
- @Component: a way to mark a class as a Spring-managed component, this annotation can be used to turn an ordinary java class into a bean in an IOC container. this annotation is a generic annotation that can be used to mark any type of component, he has several commonly used, used in different scenarios, such as: @Repository, @Service, @Controller and so on. Service, @Controller, etc.
BeanFactory
BeanFactory is the essence of Spring IOC, his existence solves the production of beans in the management, and Spring will also be the bean of the various life cycle stages of the management interface is exposed to us, we only need to implement these interfaces then in the bean's life cycle stage, spring will call our interface implementation to the bean to make the corresponding processing.
Spring uses BeanDefinitionReader to scan our project for classes that use @Component or @Configuration annotations, get the BeanDefintiions, and register them in the BeanFactory. The BeanFactory stores information about the bean in a conCurrentHashMap, where the key is the name of the bean and the Value is the BeanDefintiions, which are the metadata of the bean, such as the class name, whether it is abstract or not, and other definitions.
Implementation of BeanFactory implementation class has a variety of specific details and trade-offs you can refer to the source code or the official documentation to view the
summarize
Here we actually have a Spring IOC already have an understanding of their own, in fact, is that we will be injected into the container in a different way class, we only need to get the code in the bean and then go to use it, as for the object's lifecycle are handed over to our IOC container to manage.
Thank you for your visit, Spring IOC details there are many, each point can be taken out to write a separate blog, so this blog to a more concise introduction to the main, you want to explore the deeper details can be combined with the official documentation of the introduction and the source code to understand, well do not say nonsense, thank you again to all the big brother can see here, if the article by any problem welcome to all of you! Thank you!