Interfaz BeanFactory y ApplicationContext y su diagrama de subclase
Esta es una parte del diagrama de clases de relaciones de Spring. A partir de este diagrama de clases, podemos ver aproximadamente la relación entre BeanFactory y ApplicationContext. BeanFactory es la clase base de ApplicationContext, y ApplicationContext tiene todas las funciones de BeanFactory. No solo eso, sino ApplicationContext también expande algunas funciones, agrega muchas funciones de contenedor avanzadas sobre la base del contenedor IOC simple de BeanFactory al heredar MessageSource, ResourceLoader y otras interfaces.
BeanFactory
Código fuente de BeanFactory
public interface BeanFactory {
// 根据指定名字获取IOC容器管理的Bean
Object getBean(String name) throws BeansException;
// 根据指定名字获取IOC指定的Bean, 并且对Bean的类型进行检查
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
Object getBean(String name, Object... args) throws BeansException;
// 根据类型获取IOC容器管理的Bean
<T> T getBean(Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
// 判断容器是否包含指定名字的Bean
boolean containsBean(String name);
// 判断指定名字的Bean是否是Singeton(单例)类型
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
// 判断指定名字的Bean是否是Prototype(多例)类型
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
// 查询指定名字的Bean的Class类型是否是特定的Class类型.
boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
// 查询指定名字的Bean的Class类型
@Nullable
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
// 查询指定名字的Bean的Class类型
@Nullable
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
@Nullable
Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
@Nullable
Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
// 查询指定名字的Bean的所有别名, 这些别名都是用户在BeanDefinition中定义的
String[] getAliases(String name);
Se puede ver que lo que se define aquí es solo una serie de métodos de interfaz, que proporcionan especificaciones de uso para el contenedor IOC. Sobre esta base, Spring también proporciona una serie de contenedores que se ajustan a la interfaz de contenedor IOC para que los utilicen los desarrolladores Tomamos la implementación de XmlBeanFactory como ejemplo para ilustrar el principio de diseño de IOC simple.
El diagrama de clases relacionado de XmlBeanFactory es el siguiente
En comparación con ApplicationContext, hay una característica muy obvia, es decir, XmlBeanFactory solo proporciona las funciones de contenedor IOC más básicas.
Código fuente de XmlBeanFactory
@Deprecated
@SuppressWarnings({
"serial", "all"})
public class XmlBeanFactory extends DefaultListableBeanFactory {
// BeanDefinition读取器
private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
public XmlBeanFactory(Resource resource) throws BeansException {
this(resource, null);
}
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
super(parentBeanFactory);
// 载入BeanDefinition
this.reader.loadBeanDefinitions(resource);
}
}
Como puede ver, para usar XmlBeanFactory, necesitamos pasar el objeto Resource, que es el recurso BeanDefinition, que es el archivo xml que solemos escribir. El lector BeanDefinition XmlBeanDefinitionReader cargará automáticamente nuestro BeanDefinition en el contenedor IOC para nuestro uso.
Usemos XmlBeanFactory:
@Test
public void test2 () {
ClassPathResource classPathResource = new ClassPathResource("application.xml");
XmlBeanFactory xmlBeanFactory = new XmlBeanFactory(classPathResource);
Object user = xmlBeanFactory.getBean("user");
System.out.println(user);
}
ApplicationContext
Discutimos el uso de ApplicationContext con ClassPathXmlApplicationContext
Diagrama de clase ClassPathXmlApplicationContext
Se puede ver en el diagrama de clases que, además de proporcionar funciones básicas de BeanFactory, ApplicationContext también proporciona a los usuarios los siguientes servicios adicionales, que pueden hacer que los usuarios sean más cómodos de usar.
- Admite diferentes fuentes de información. ApplicationContext amplía la interfaz MessageSource. Las funciones de extensión de estas fuentes de información pueden respaldar la realización de la internacionalización y proporcionar servicios para el desarrollo de versiones de aplicaciones en varios idiomas.
- Acceder a los recursos. Esta característica se refleja en el soporte para ResourceLoader y Resource, de modo que podemos obtener recursos de BeanDefinition desde diferentes lugares.
Uso de ClassPathXmlApplicationContext
@Test
public void test3 () {
ApplicationContext applicationContext = new FileSystemXmlApplicationContext("application.xml");
Object user = applicationContext.getBean("user");
System.out.println(user);
}
Resumir:
BeanFactory
BeanFactory es la interfaz original de Spring, la clase de implementación de la función para la estructura original es relativamente simple, el contenedor implementado por la interfaz BeanFactory se caracteriza por crear un objeto cada vez que se obtiene un objeto.
ApplicationContext
hereda la interfaz BeanFactory, tiene todas las funciones de BeanFactory y amplía muchas características avanzadas y crea todos los objetos cada vez que se inicia el contenedor.
El método para crear ApplicationContext:
cargue el archivo de configuración en la ruta de clase: ClassPathXmlApplicationContext ("applicationContext.xml");
cargue el archivo de configuración desde la ruta absoluta del disco duro: FileSystemXmlApplicationContext ("d:/xxx/yyy/xxx") ;
Conclusión
El rendimiento inicial de la computadora era bajo y la memoria era pequeña, por lo que la capacidad del contenedor de primavera era insuficiente. No todos los objetos se podían crear y colocar en el contenedor, por lo que se utilizó BeanFactory. Cuando se necesitaba un objeto, se creaba de nuevo. Con la mejora del hardware de la computadora Con el desarrollo, la memoria es cada vez más grande, por lo que Spring Framework introduce ApplicationContext, crea todos los objetos, los coloca en el contenedor y qué objeto usar se puede obtener del contenedor.
BeanFactory y ApplicationContext (detalles)
- La fábrica de Bean (com.springframework.beans.factory.BeanFactory) es la interfaz principal de Spring Framework, que proporciona un mecanismo de configuración de IoC avanzado.
- El contexto de la aplicación (com.springframework.context.ApplicationContext) se construye sobre BeanFactory.
En casi todas las aplicaciones, usamos ApplicationContext directamente en lugar del BeanFactory subyacente.
1. Arquitectura de la clase BeanFactory
BeanFactory : La interfaz se encuentra en la parte superior del árbol de estructura de clases. Su método principal es getBean(StringbeanName), que devuelve un Bean con un nombre específico del contenedor. Las funciones de BeanFactory se expanden continuamente a través de otras interfaces.
ListableBeanFactory : esta interfaz define varios métodos para acceder a la información básica de los beans en el contenedor, como verificar la cantidad de beans, obtener el nombre de configuración de un determinado tipo de bean, verificar si un determinado bean está incluido en el contenedor, etc. ;
HierarchicalBeanFactory : la interfaz del contenedor IoC en cascada padre-hijo, y el contenedor secundario puede acceder al contenedor principal a través del método de interfaz;
ConfigurableBeanFactory : es una interfaz importante que mejora la personalización del contenedor IoC. Define métodos como la configuración de cargadores de clases, editores de propiedades, postprocesadores de inicialización de contenedores, etc.;
AutowireCapableBeanFactory : define el método de ensamblar automáticamente el Bean en el contenedor de acuerdo con ciertas reglas (como coincidencia por nombre, coincidencia por tipo, etc.);
SingletonBeanRegistry : define un método que permite registrar un bean de instancia única en el contenedor durante el tiempo de ejecución;
BeanDefinitionRegistry : cada elemento de nodo en el archivo de configuración de Spring está representado por un objeto BeanDefinition en el contenedor de Spring, que describe la información de configuración del Bean. La interfaz BeanDefinitionRegistry proporciona un método para registrar manualmente el objeto BeanDefinition con el contenedor.
2. Arquitectura de clase de ApplicationContext
ApplicationContext se deriva de BeanFactory y proporciona más funciones para aplicaciones prácticas. En BeanFactory, muchas funciones deben implementarse mediante programación, pero en ApplicationContext se puede implementar a través de la configuración.
Las principales clases de implementación de ApplicationContext son ClassPathXmlApplicationContext y FileSystemXmlApplicationContext.La primera carga archivos de configuración desde la ruta de clase de forma predeterminada y la segunda carga archivos de configuración desde el sistema de archivos de forma predeterminada.
Las interfaces principales incluyen:
ApplicationEventPublisher : permita que el contenedor tenga la función de publicar eventos de contexto de la aplicación, incluidos eventos de inicio del contenedor, eventos de apagado, etc. Los beans que implementan la interfaz de monitoreo de eventos ApplicationListener pueden recibir eventos de contenedor y responder a los eventos. En la clase de implementación abstracta de ApplicationContext AbstractApplicationContext, podemos encontrar que hay un ApplicationEventMulticaster, que es responsable de guardar todos los oyentes, para notificar a estos oyentes de eventos cuando el contenedor genera eventos de contexto.
MessageSource : proporcione a la aplicación la función de acceso a mensajes internacionalizados i18n;
ResourcePatternResolver : todas las clases de implementación de ApplicationContext implementan una función similar a PathMatchingResourcePatternResolver, que puede cargar archivos de configuración de Spring a través de rutas de archivos de recursos de estilo Ant prefijadas.
LifeCycle : Spring 2.0 agrega esta interfaz Esta interfaz proporciona dos métodos de inicio () y parada (), que se utilizan principalmente para controlar el proceso de procesamiento asíncrono. En un uso específico, ApplicationContext y beans específicos implementan esta interfaz al mismo tiempo, y ApplicationContext pasará la información de inicio/detención a todos los beans que implementen esta interfaz en el contenedor para lograr la gestión y el control de JMX, la programación de tareas y otros fines. .
ConfigurableApplicationContext amplía ApplicationContext y agrega dos métodos principales: refresh() y close(), lo que permite que ApplicationContext tenga la capacidad de iniciar, actualizar y cerrar el contexto de la aplicación. Cuando se cierre el contexto de la aplicación, llame a refresh() para iniciar el contexto de la aplicación. En el estado ya iniciado, llame a refresh() para borrar la memoria caché y volver a cargar la información de configuración, y llame a close() para cerrar el contexto de la aplicación. Estos métodos de interfaz aportan comodidad al control y la gestión de contenedores.
Ejemplo de código:
ApplicationContext ctx =new ClassPathXmlApplicationContext("com/baobaotao/context/beans.xml");
ApplicationContext ctx =new FileSystemXmlApplicationContext("com/baobaotao/context/beans.xml");
ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{
"conf/beans1.xml","conf/beans2.xml"});
Hay una gran diferencia entre la inicialización de ApplicationContext y BeanFactory: BeanFactory no crea instancias de beans al inicializar el contenedor y no crea instancias del bean de destino hasta la primera vez que se accede a un bean; mientras que ApplicationContext crea instancias de todos los singletons al inicializar el contexto de la aplicación. instancia del Bean.