[Spring series] BeanFactory and ApplicationContext

This article topic

1. What are the specific implementations of IOC in Spring?
2. In what way are they accomplished?
3. If BeanFactory and ApplicationContext are containers, which one is the underlying IOC container? And what are the real situations they face?

public DispatcherServlet(WebApplicationContext webApplicationContext) {    
        super(webApplicationContext);    
        this.setDispatchOptionsRequest(true);
}Copy the code

BeanFactory

1. The BeanFactory API provides the underlying foundation for Spring’s IoC functionality.
2. BeanFactory follows the “open closed principle”, opening for external extension and closing for internal modification. It extends other frameworks with BeanFactoryAware/InitializingBean/DisposableBean.
3. BeanFactory is a core API, which means it’s very simple and has a lot of attention. The implementation of BeanFactory makes no assumptions about the configuration format or any component annotations to use. You can understand that it doesn’t require you to follow any rules or specifications to use Spring because of its abstractness, Compatible with the realization of the different style such as XmlBeanDefinitionReader and AutowiredAnnotationBeanPostProcessor and so on. So that’s what makes Spring’s container so flexible and extensible. You can say this if the interviewer asks you.

API

1. Does the BeanFactory interface only provide read functionality but no write functionality? In fact, these write functions will be left to its subclasses to implement;
2. However, BeanProvider is an implementation of deferred lookup and injection in Spring, which will be explained later
3. We can see that the BeanFactory provides either a name or requireType to fetch the Bean. Does that mean there are only two ways to find it? This is the topic we will cover next – Bean primitive metadata definition

Bean primitive metadata definition

1. Configure through annotations
2. Through the Java API
3. Configure through XML

public class UserService {
    @Autowireprivate 
    UserDao userDao;
}Copy the code

Like Java Configuration, we can also use @configuration / @bean / @import / @dependson, for example

@Configuration
public class SecurityConfig{
    @Bean public UserDao userDao() {
        returnnew UserDao(); }}Copy the code

<? xml version="1.0" encoding="UTF-8"? > <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="..." class="..."> <! -- collaborators and configurationfor this bean go here -->
    </bean>
</beans>Copy the code

ApplicationContext

1. I18n internationalization
2. There is a powerful Resource abstraction class called Resource and load the ResourceLoader to read URLS and files
3. Event monitoring mechanism
4. Multiple hierarchical contexts can be loaded

<? xml version="1.0" encoding="UTF-8"? > <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd"> 

    <bean id="userDao" class="com.jc.test01.dao.UserDao"> 
    </bean> 

</beans>Copy the code

/ / create and configure beans to create and configure BeansApplicationContext context = new ClassPathXmlApplicationContext ("services.xml"); // Retrieve configured Instance search by name + type UserDao UserDao = context.getBean("userDao", UserDao.class); List<String> userList = userdao.getUserNamelist (); // Use configured instance to call the method List<String> userList = userdao.getUserNamelist ();Copy the code

Inherit the figure

conclusion