Factory Pattern BeanFactory and Application Context in the Spring Framework
There are two implementation methods for the factory pattern in the Spring framework: BeanFactory and Application Context.
1. BeanFactory:
BeanFactory is the infrastructure of the Spring framework, which is an implementation of the factory pattern used to manage and retrieve bean objects in applications. BeanFactory provides the following features:
-Instantiating objects: Instantiating bean objects through configuration files or annotations;
-Manage objects: Manage the lifecycle of bean objects, such as setting property values, calling initialization methods, and destroying methods for bean objects;
-Get Object: Retrieve the corresponding Bean object based on its name or type.
The core methods of the BeanFactory interface include: getBean (String name), getBean (Class<T>requiredType), and containsBean (String name).
2. Application Context:
Application Context is a sub interface of BeanFactory, which has been extended and enhanced based on BeanFactory. Compared to BeanFactory, Application Context provides more functions and features, including:
-Internationalization support: providing support for multilingual environments;
-Event propagation: supports event publishing and monitoring;
-Resource management: Provide unified resource management, such as access to resources such as file systems, class paths, and URLs;
-AOP support: Supports facet oriented programming.
The core implementation classes of Application Context are AnnotationConfigApplication Context and ClassPathXmlApplication Context, which are used for application environments based on annotation and XML configuration, respectively.
The following is a complete source code example of the factory mode in the Spring framework:
1. Usage example of BeanFactory:
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
public class BeanFactoryExample {
public static void main(String[] args) {
//Load Configuration File
BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
//Get bean object
HelloWorld helloWorld = (HelloWorld) factory.getBean("helloWorld");
System.out.println(helloWorld.getMessage());
}
}
2. Usage examples of Application Context:
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class ApplicationContextExample {
public static void main(String[] args) {
//Load Configuration Class
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
//Get bean object
HelloWorld helloWorld = context.getBean(HelloWorld.class);
System.out.println(helloWorld.getMessage());
}
}
Summary:
The factory pattern in the Spring framework provides powerful Dependency injection and bean management functions through BeanFactory and ApplicationContext. BeanFactory is the infrastructure of Spring, providing basic bean management functions; Application Context has been extended on the basis of BeanFactory, providing more features and functions, such as internationalization support, event propagation, and AOP support. Developers can choose suitable implementation methods based on specific needs.
