Interface BeanFactory e ApplicationContext e seu diagrama de subclasses
Esta é uma parte do diagrama de classes de relacionamento do Spring. A partir deste diagrama de classes, podemos ver aproximadamente o relacionamento entre BeanFactory e ApplicationContext. BeanFactory é a classe base de ApplicationContext e ApplicationContext tem todas as funções de BeanFactory. Não apenas isso, mas ApplicationContext também expande algumas funções, ele adiciona muitos recursos avançados de contêiner com base no contêiner IOC simples de BeanFactory, herdando MessageSource, ResourceLoader e outras interfaces.
BeanFactory
Código-fonte 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);
Pode-se ver que o que está definido aqui é apenas uma série de métodos de interface, que fornecem especificações de uso para o contêiner IOC. Com base nisso, o Spring também fornece uma série de contêineres em conformidade com a interface de contêiner IOC para uso dos desenvolvedores.Tomamos a implementação de XmlBeanFactory como um exemplo para ilustrar o princípio de design do IOC simples.
O diagrama de classe relacionado de XmlBeanFactory é o seguinte
Comparado com ApplicationContext, há um recurso muito óbvio, ou seja, XmlBeanFactory fornece apenas as funções de contêiner IOC mais básicas.
Código-fonte 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 você pode ver, para usar o XmlBeanFactory, precisamos passar o objeto Resource, que é o recurso BeanDefinition, que é o arquivo xml que normalmente escrevemos. O leitor BeanDefinition XmlBeanDefinitionReader carregará automaticamente nosso BeanDefinition no contêiner IOC para nosso uso.
Vamos usar 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 o uso de ApplicationContext com ClassPathXmlApplicationContext
Diagrama de classe ClassPathXmlApplicationContext
Pode-se ver no diagrama de classes que, além de fornecer as funções básicas do BeanFactory, o ApplicationContext também fornece aos usuários os seguintes serviços adicionais, que podem tornar o uso mais conveniente para os usuários.
- Suporta diferentes fontes de informação. ApplicationContext estende a interface MessageSource. As funções de extensão dessas fontes de informação podem suportar a realização da internacionalização e fornecer serviços para o desenvolvimento de versões multilíngues de aplicativos
- Acessar recursos. Esse recurso é refletido no suporte para ResourceLoader e Resource, para que possamos obter recursos BeanDefinition de 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 é a interface original do spring.A função de classe de implementação para a estrutura original é relativamente simples.O container implementado pela interface BeanFactory é caracterizado por criar um objeto toda vez que um objeto é obtido.
ApplicationContext
herda a interface BeanFactory, tem todas as funções de BeanFactory e estende muitos recursos avançados e cria todos os objetos sempre que o contêiner é iniciado.
O método de criação do ApplicationContext:
carregue o arquivo de configuração no caminho da classe: ClassPathXmlApplicationContext (“applicationContext.xml”);
carregue o arquivo de configuração no caminho absoluto do disco rígido: FileSystemXmlApplicationContext (“d:/xxx/yyy/xxx”) ;
Conclusão
O desempenho inicial do computador era baixo e a memória era pequena, então a capacidade do contêiner de primavera era insuficiente. Todos os objetos não podiam ser criados e colocados no contêiner, então o BeanFactory era usado. Quando um objeto era necessário, ele era criado novamente Com a melhoria do hardware do computador Com o desenvolvimento, a memória está ficando cada vez maior, então o spring framework apresenta o ApplicationContext, cria todos os objetos, coloca-os no container, e qual objeto usar pode ser obtido do container.
BeanFactory e ApplicationContext (detalhes)
- A fábrica Bean (com.springframework.beans.factory.BeanFactory) é a interface central da estrutura Spring, que fornece um mecanismo avançado de configuração de IoC.
- O contexto do aplicativo (com.springframework.context.ApplicationContext) é construído sobre o BeanFactory.
Em quase todos os aplicativos, usamos o ApplicationContext diretamente em vez do BeanFactory subjacente.
1. Arquitetura da classe BeanFactory
BeanFactory : A interface está localizada no topo da árvore de estrutura de classes. Seu método principal é getBean(StringbeanName), que retorna um Bean com um nome específico do container. As funções de BeanFactory são continuamente expandidas através de outras interfaces.
ListableBeanFactory : Esta interface define vários métodos para acessar as informações básicas dos beans no container, como verificar a quantidade de beans, obter o nome da configuração de um determinado tipo de bean, verificar se um determinado bean está incluso no container, etc. ;
HierarchicalBeanFactory : a interface do contêiner IoC em cascata pai-filho, e o contêiner filho pode acessar o contêiner pai por meio do método de interface;
ConfigurableBeanFactory : É uma interface importante que melhora a customização do contêiner IoC. Define métodos como configuração de carregadores de classe, editores de propriedade, pós-processadores de inicialização de contêiner, etc.;
AutowireCapableBeanFactory : Define o método de montagem automática do Bean no container de acordo com certas regras (como correspondência por nome, correspondência por tipo, etc.);
SingletonBeanRegistry : define um método que permite que um bean de instância única seja registrado no contêiner durante o tempo de execução;
BeanDefinitionRegistry : Cada elemento de nó no arquivo de configuração Spring é representado por um objeto BeanDefinition no contêiner Spring, que descreve as informações de configuração do Bean. A interface BeanDefinitionRegistry fornece um método para registrar manualmente o objeto BeanDefinition com o contêiner.
2. Arquitetura de classes de ApplicationContext
ApplicationContext é derivado de BeanFactory e fornece mais funções para aplicações práticas. No BeanFactory, muitas funções precisam ser implementadas programaticamente, mas no ApplicationContext isso pode ser implementado por meio de configuração.
As principais classes de implementação de ApplicationContext são ClassPathXmlApplicationContext e FileSystemXmlApplicationContext. A primeira carrega arquivos de configuração do caminho de classe por padrão e a última carrega arquivos de configuração do sistema de arquivos por padrão.
As principais interfaces incluem:
ApplicationEventPublisher : permite que o contêiner tenha a função de publicar eventos de contexto do aplicativo, incluindo eventos de inicialização do contêiner, eventos de desligamento, etc. Beans que implementam a interface de monitoramento de eventos ApplicationListener podem receber eventos de contêiner e responder aos eventos. Na classe abstrata de implementação ApplicationContext, AbstractApplicationContext, podemos verificar que existe um ApplicationEventMulticaster, que é responsável por salvar todos os ouvintes, de modo a notificar esses ouvintes de evento quando o contêiner gerar eventos de contexto.
MessageSource : fornece ao aplicativo a função de acesso a mensagens internacionalizadas i18n;
ResourcePatternResolver : Todas as classes de implementação ApplicationContext implementam uma função semelhante a PathMatchingResourcePatternResolver, que pode carregar arquivos de configuração do Spring por meio de caminhos de arquivo de recurso estilo Ant prefixados.
LifeCycle : esta interface é adicionada pelo Spring 2.0. Esta interface fornece dois métodos de start() e stop(), que são usados principalmente para controlar o processo de processamento assíncrono. Em uso específico, essa interface é implementada por ApplicationContext e beans específicos ao mesmo tempo, e ApplicationContext passará as informações de início/parada para todos os beans que implementam essa interface no contêiner para obter gerenciamento e controle de JMX, agendamento de tarefas e outros propósitos .
ConfigurableApplicationContext estende ApplicationContext e adiciona dois métodos principais: refresh() e close(), permitindo que ApplicationContext tenha a capacidade de iniciar, atualizar e fechar o contexto do aplicativo. Quando o contexto do aplicativo for fechado, chame refresh() para iniciar o contexto do aplicativo.No estado já iniciado, chame refresh() para limpar o cache e recarregar as informações de configuração e chame close() para fechar o contexto do aplicativo. Esses métodos de interface trazem comodidade para o controle e gerenciamento de contêineres.
Exemplo 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"});
Há uma grande diferença entre a inicialização de ApplicationContext e BeanFactory: BeanFactory não instancia beans ao inicializar o contêiner e não instancia o bean de destino até a primeira vez que um bean é acessado; enquanto ApplicationContext instancia todos os singletons ao inicializar o contexto do aplicativo. instância do Bean.