Quando desenvolvemos aplicativos com base na primavera, geralmente colocamos a configuração do banco de dados no arquivo de propriedades.
Resumo dos pontos de conhecimento envolvidos na análise de código:
1.NamesPaceHandler analisa o namespace personalizado no arquivo de configuração XML
2.ContextNamesPaceHandler Relacionado ao contexto Relacionado, aqui define o analisador específico para analisar o propriedade de propriedade do imóvel
3.BeandEfinitionParser analisa a interface da definição de feijão
4.BeanFactoryPostProcessor Depois de carregar a definição do feijão, ele pode ser modificado.
5.PropertySourcesPlaceHoldConfigurer lida com os espaços reservados na definição de feijão
Vamos dar uma olhada no uso específico primeiro
Uso da propriedade
Configurar o arquivo de propriedades no arquivo XML
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/Context/spring-context-4.2.xsd "<Contexto: Property-Tholders Location =" ClassPath: Foo.Properties "
Dessa forma, o arquivo /src/main/resources/foo.properties será carregado pela primavera
Se você deseja usar vários arquivos de configuração, você pode adicionar o campo de pedido para classificar
Use PropertySource para anotar a configuração
A Spring 3.1 adicionou a anotação @PropertySource para facilitar a adição de arquivos de propriedade ao ambiente.
@Configuration @PropertySource ("ClassPath: Foo.Properties") Public Class PropertiesWithJavaconfig {@Bean Public Static PropertySourcesPlaceHoldConFigurer PropertySourcesPlateHoldConfigurer () {Return NOVA PropertySourcesplaceHoldConfigurer (); }}Injeção e uso de propriedades
1. Use @value Anotation para obter em Java
@Value ("$ {jdbc.url}") private string jdbcurl;Você também pode adicionar um valor padrão
@Value ("$ {jdbc.url: ADefaulturl}") private String jdbcurl;1. Obtenha -o no arquivo de configuração XML da primavera
<bean id = "DataSource"> <propriedade name = "url" value = "$ {jdbc.url}" /> < /bean>Análise do código -fonte
Carregamento de informações de configuração de propriedades
A primavera iniciará o trabalho de inicialização do contêiner através do abstratoApplicationContext#Atualizar na inicialização e, durante esse período, o LoadBeandEfinitions será confiado para analisar o arquivo de configuração XML.
O Void final protegido refreshBeanFactory () lança beansexception {if (hasBeanFactory ()) {DestroyBeans (); CloseBeanFactory (); } tente {defaultListableBeanFactory beanFactory = CreateBeanFactory (); beanFactory.SetSerializationId (getId ()); PersonalizeBeanFactory (BeanFactory); LoadBeandEfinitions (BeanFactory); sincronizado (this.BeanFactoryMonitor) {this.BeanFactory = beanFactory; }} catch (ioexception ex) {lança nova ApplicationContextexception ("Erro de E/S analisando a fonte de definição do feijão para" + getDisplayName (), ex); }}LoadBeandEfinitions através da delegação de camada por camada, encontre o DefaultBeandEfinitionDocumentReader#parsebeanCinition para analisar o feijão específico
Void protegido parsebeandEfinitions (elemento root, delegate beandefinitionparserDelegate delegado) {if (delegate.isdefaultNamespace (root)) {nodelist nl = root.getChildNodes (); for (int i = 0; i <nl.getLength (); i ++) {nó nó = nl.item (i); if (nó instanceof elemento) {elemento ele = (elemento) nó; if (delegate.isdefaultNamespace (ele)) {parsedefaultElement (ele, delegado); } else {delegate.parsecustomElement (ELE); }}}} else {delegate.parsecustomElement (root); }} Como essa não é uma definição de classe padrão, ele confia beandefinitionparserDelegate para analisar
Encontre o processador correspondente através do NamespaceHandler para encontrar o contextNamesPaceHandler e, em seguida, encontre o PropertyPlaceHolderBeanDeFinitionParser Análise por meio de análise por meio do ID
@Override public void init () {// Este é o analisador que estamos procurando por RegisterBeandEfinitionParser ("Property-placeholder", New PropertyPlaceHolderBeandEfinitionParser ()); RegisterBeanDefinitionParser ("Property-Override", New PropertyOverrideBeandEfinitionParser ()); RegisterBeanDefinitionParser ("Anotation-Config", novo AnoTationConfigBeanDefinitionParser ()); RegisterBeanDefinitionParser ("Component-Scan", New ComponentsCanBeaNDeFinitionParser ()); RegisterBeanDefinitionParser ("Woar-time-Weaver", novo loadTimeWeaverbeanDefinitionParser ()); RegisterBeanDefinitionParser ("Spring-Configurado", New SpringConfiguredBeandEfinitionParser ()); RegisterBeanDefinitionParser ("MBean-Export", New MBeanExportBeanDefinitionParser ()); RegisterBeanDefinitionParser ("MBean-Server", New MBeanserverbeandEfinitionParser ()); } PropertyPlaceHolderBeanDefinitionParser é o foco desta rodada de análise de código.
Vamos dar uma olhada na classe dos pais.
1.BeandEfinitionParser
Usado por DefaultBeanDefinitionDocumentReader para analisar tags personalizadas
Apenas uma API de Parse que analisa o elemento é definido aqui
interface pública beandefinitionparser {beandefinition parse (elemento elemento, parsercontext parserContext);} 2.AbstractBeanDefinitionParser
A implementação abstrata padrão da interface BeandEfinitionParser. A primavera é boa nisso. Ele fornece muitas APIs convenientes aqui e usa o padrão de design do método de modelo para fornecer ganchos de implementação personalizados para subclasses.
Vamos dar uma olhada na lógica de processamento específica quando analisa: ligue para o Parseiinternal Parse do gancho
3. AbstractSingleBeandEfinitionParser
Analisar, definir a classe pai abstrata de uma única beandefinition
No parseiinternal, parse parentname, beansclass, fonte; e encapsular usando o BEANDefinitionBuilder
4. AbstractPropertyLoadingBeandEfinitionParser
Analisar propriedades relacionadas à propriedade, como localização, propriedades-ref, codificação de arquivos, ordem etc.
5.PropertyPlaceholderBeanDefinitionParser
Não há muitas coisas para lidar aqui, basta configurar o modo inore-unResolVable e System-Properties
Arquivo de propriedades de carregamento, instanciação do feijão
Em seguida, vamos dar uma olhada quando este feijão for instanciado. Existem dois tipos de instanciação de classes gerais. Um é instanciado quando o sistema singleton é iniciado; O outro é instanciado quando o não-singleton (ou o carregamento preguiçoso de singleton) quando o getbean é instanciado.
O gatilho aqui é através do BeanfcatoryPostProcessor.
BeanFactoryPostProcessor modifica a definição do feijão antes da instanciação do feijão. Por exemplo, os espaços reservados na definição de feijão são resolvidos aqui e as propriedades que estamos usando agora também são resolvidas aqui.
Isso é implementado por meio do pós -ProcessorRegistrationDelegate#InvokeBeanFactoryPostProcessors.
Digitalize o abessador do BeanFactoryPost no contêiner, encontre o PropertySourcesplaceholdConfigurer necessário aqui e instanciá -lo através do getBean do contêiner
Void protegido InvokeBeanFactoryPostProcessors (ConfigurableListableBeanFactory BeanFactory) {postprocessorRegistrationDelegate.invokeBeanFactoryPostProcessors (BeanFactory, getBeanFactoryPostProcessors ()); }Após a instanciação do PropertySourcesPlaceHoldConfigurer, ela será acionada diretamente e as informações carregadas.
OrderComparator.Sort (PriorityOrderEdPostProcessors); InvokeBeanFactoryPostProcessors (PriorityOrderEdPostprocessors, BeanFactory);
Vamos dar uma olhada no sistema de herança de propriedadesourcesplaceholderconfigurer
1.BeanFactoryPostProcessor
Defina uma interface para modificar as propriedades da definição de feijão em um contêiner. Sua classe de implementação é instanciada antes que as classes gerais sejam usadas e as propriedades de outras classes sejam modificadas.
Isso é obviamente diferente do BEANPOSTPROCESSOR, que modifica as instâncias do feijão.
2.PropertiesLoaderSupport
Classe abstrata que carrega arquivos de propriedades.
A lógica de carregamento específica aqui é confiar PropriedadesloadRutils#FillProperties para implementar
3.PropertyResourceConfigurer
A substituição de espaço reservado na definição de feijão é implementado por esta classe abstrata.
Implementar BeanFactoryPostProcessor#PostprocessBeanFactory, iterate sobre a definição de classe no contêiner e modifique -o
Como modificá -lo é implementado, entregando -o a uma subclasse através do Process Properties do gancho
4.PlaceHoldConfiguresUpport
Use o padrão de design do visitante para atualizar as propriedades através do BeandEfinitionVisitor e StringValueResolver
StringValueResolver é uma interface que converte dados do tipo String. A implementação da API que realmente atualiza as propriedades está realmente em
Propertyplaceholderhelper#parsestringValue
5.PropertySourcesplaceHoldConfigurer
Substituir o processo de análise de definição da API pós -processador pós -processador
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.