Introdução detalhada ao ciclo de vida do feijão da primavera

Como a estrutura leve e poderosa mais popular em Java, a primavera foi calorosamente recebida por programadores. É muito necessário entender com precisão o ciclo de vida do feijão da primavera. Geralmente usamos o ApplicationContext como contêiner de mola. Aqui, também estamos falando sobre o ciclo de vida dos feijões no ApplicationContext. De fato, o Beanfactory é semelhante, mas o processador precisa ser registrado manualmente.

1. Fluxo de fluxo do ciclo de vida:

O ciclo de vida completo de um feijão de primavera começa com a criação de um recipiente de mola até que o contêiner de mola destrua o feijão, que contém uma série de pontos -chave.

Se o contêiner registrar as várias interfaces acima, o programa será realizado de acordo com o processo acima. As funções de cada interface serão explicadas em detalhes abaixo.

2. Classificação de vários métodos de interface

O ciclo de vida completo de um feijão passa por várias chamadas de método, que podem ser divididas nas seguintes categorias:

1. Método de Bean: isso inclui os métodos chamados pelo próprio feijão e os métodos especificados através do método init-method e Destroy no arquivo de configuração.

2. Método da interface do ciclo de vida no nível do feijão: isso inclui métodos de interface como beannameraware, beanfactoryware, inicializandoBean e diosablebean

3. Método da interface do ciclo de vida no nível do contêiner: isso inclui duas implementações de interface: InstanciaçãoeBeanPostProcessor e BeanPostProcessor. Sua classe de implementação é geralmente chamada de "pós -processador".

4. Método da interface do pós -processador de fábrica: inclui os aspectos de ASCUTJWeavingEnabler, ConfigurationClassPostProcessor, customAUTOWIRECONFIGURADOR e outros métodos de interface pós -processador de fábrica muito úteis. Os pós-processadores de fábrica também são no nível do contêiner. Chamado imediatamente após a aplicação do arquivo de configuração de montagem de contexto.

3. Demo

Vamos demonstrar o ciclo de vida do feijão da primavera com um simples feijão de primavera.

1. Primeiro de tudo, é um feijão simples de primavera, que chama os próprios métodos de interface do ciclo de vida no nível do feijão. Por uma questão de conveniência de demonstração, ele implementa quatro interfaces: Beannameaware, BeanFactoryAware, InicializandoBean e DiposableBean. Existem 2 métodos ao mesmo tempo, correspondentes ao método init-method e destruição de <Bean> no arquivo de configuração. do seguinte modo:

 pacote springbeantest; importar org.springframework.beans.beansexception; importar org.springframework.beans.Factory.BeanFactory; importação org.springframework.bean.factory.beanfactoryWare; importar org.springframework.bean.factory.beannamAware; org.springframework.beans.factory.disposableBean; importar org.springframework.beans.factory.initializingBean;/** * @author qsk */classe pública Pessoa implementa BeanFactoryWare, beannameareware, initializandoBean, desnudaban {String Nome; endereço de string privado; telefone privado int; Beanfactory Beanfactory privado; String Private String Beanname; public Person () {System.out.println ("【Construtor】 Call Instantiação do construtor da pessoa"); } public string getName () {return name; } public void setName (nome da string) {System.out.println ("【Atributo de injeção】 Nome do atributo de injeção"); this.name = nome; } public string getAddress () {retornar endereço; } public void setAddress (endereço da string) {System.out.println ("【Atributo de injeção】 Endereço do atributo de injeção"); this.address = endereço; } public int getPhone () {return telefone; } public void setPhone (int telefone) {System.out.println ("【Atributo de injeção】 Atributo de injeção Telefone"); this.phone = telefone; } @Override public String tostring () {return "pessoa [endereço =" + endereço + ", nome =" + nome + ", telefone =" + telefone + "]"; } // Este é o método da interface BeanFactoryAware @Override public void setBeanFactory (BeanFactory arg0) lança beansexception {System.out .println ("【BeanFactoryAware Interface】 Chamada BeanFactoryAare.setBeanFactory ()); this.BeanFactory = arg0; } // Este é o método da interface do beannameaware @Override public void setBeanName (String arg0) {System.out.println ("【Interface de Beannameauware】 Call BeanNameaware.SetBeanName ()"); this.beanname = arg0; } // Este é o método da interface inicializandoBean @Override public void depoisPropertiEsset () lança a exceção {System.out .println ("【InitializingBean Interface】 Chamada InitializingBean.AfterPropertiESSET ()"); } // Este é o método de interface dieSibleBean @Override public void Destroy () lança Exceção {System.out.println ("【Interface DiPosibleBean】 Chamada DiposibeBean.Destory ()"); } // Método de inicialização especificado através da propriedade init-method de <Bean> public void myinit () {System.out.println ("【init-method】 Chame o método de inicialização especificado pela propriedade init-method de <ean>"); } // Método de inicialização especificado pela propriedade Destroy-Method do <Bean> public void myDestory () {System.out.println ("【Destruir-method】 Chame o método de inicialização especificado pela propriedade Destroy-Modod of <Bean>"); }}

2. Em seguida, é demonstrar o método da interface do BEANPOSTPROCESSOR, como segue:

 pacote SpringBeanTest; importar org.springframework.beans.beansexception; importar org.springframework.beans.factory.config.beanPostProcessor; classe pública mybeanPostProcessor implementa BeanPostProcess {public myBeanProcessor () {) (); System.out.println ("Este é o construtor de classe de implementação do BEANPOSTProcessor !!"); // TODO construtor gerado automaticamente Stub} @Override Public Object PostprocessaFterinitialization (Object arg0, string arg1) lança beansexception {System.out .println ("bEanPostProcessor Método da interface pós-ProcessAfterinitialização faz alterações na propriedade!"); retornar arg0; } @Override Public Object PostprocessBeForeInitialization (objeto arg0, string arg1) lança beansexception {System.out .println ("Método da interface do beanpostProcessor pós -procedesBeforeinitialização altera a propriedade!"); retornar arg0; }}

Como mencionado acima, a interface BeanPostProcessor inclui dois métodos pós -processadosfterinitialização e pós -processamento parainitialização. O primeiro parâmetro desses dois métodos é o objeto Bean a ser processado e o segundo parâmetro é o nome do feijão. O valor de retorno também é o objeto Bean a ser processado. Preste atenção aqui.

3. A interface instantiationAwareBeanPostProcessor é essencialmente uma subinterface do BEANPOSTPROCESSOR. Geralmente, herdamos o adaptador InstantiationAwareBeanPostProcessor Adaptador fornecido pelo Spring para usá -lo, como segue:

 pacote springbeantest; importar java.beans.propertyDescriptor; importar org.springframework.beans.beansception; importação org.springframework.beans.propertyValues; importareBeanProcessWorkwork.BeanS.Config.InStiatiationAréBeanTeanPeanProcessWork.BeanS.Config.InStiatiationAréBeanTeanPeanProcesswork.BeanS.Config.InStiatiância MyInstantiationAWareBeanPostProcessor estende instantaiçãoeeBeanPostProcesorAdapter {public myInstantiationAWareBeanPostProcessor () {super (); System.out .println ("Este é o construtor de classe de implementação do instanciação deeBeanPostProcessorAdapter !!"); } // Ligue para @Override Public Object PostprocessBeforeInstantiation (classe beansclass, string beanname) lança beansexception {System.out .println ("instantiatiowarebeanpostprocessor chama o método pós -processe para a finalidade"); retornar nulo; } // Método da interface, ligue para @Override Public Object Postprocessafterinitialization (objeto Bean, String beanname) lança beansexception {System.out .println ("InstantiationAwareBeanPostPROCESSOR CHAM ele Retornar Bean; } // Ligue para @Override Public PropertyValues ​​PostprocessPropertyValues ​​(PropertyValues ​​Pvs, PropertyDescriptor [] PDS, Object Bean, String Beanname) lança Beansexception {System.out .Println ("InstantationAwareBeanProcessor Calls PostPropertyvalues ​​Methodues; retornar PVs; }}

Existem 3 métodos para isso, e o segundo método, pós -processáriofterinitialização, é reescrever o método do beanPostProcessor. O terceiro método, PostProcessPropertyValues, é usado para operar propriedades, e o valor de retorno também deve ser um objeto PropertyValues.

4. Demonstre o método da interface pós -processador de fábrica, como segue:

 pacote springbeanTest; importar org.springframework.beans.beansexception; importar org.springframework.beans.factory.config.beanndefinition; importar org.springframework.bean.factory.config.beeanfactoryPostProcessor; importar; org.springframework.beans.factory.config.configurableListableBeanFactory; classe pública myBeanFactoryPostProcessor implementa BeanFactoryPostProcessor {public myBeanFactoryPostProcessor () {super (); System.out.println ("Este é o construtor de classe de implementação do BeanFactoryPostProcessor !!"); } @Override public void postprocessBeanFactory (ConfigurableListableBeanFactory arg0) lança beansexception {System.out .println ("BeanFactoryPostProcessor chama o método postprocessBeanFactory"); BeandEfinition bd = arg0.getbeandEfinition ("pessoa"); bd.getPropertyValues ​​(). AddPropertyValue ("telefone", "110"); }}

5. O arquivo de configuração é o seguinte Beans.xml, o que é muito simples. Ao usar o ApplicationContext, o processador não precisa ser registrado manualmente:

 <? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-bans-3.xsd"> <bean id = "beanpostprocor"> id="instantiationAwareBeanPostProcessor"> </bean> <bean id="beanFactoryPostProcessor"> </bean> <bean id="person" init-method="myInit" destroy-method="myDestory" scope="singleton" p:name="Zhang San" p:address="Guangzhou" p:phone="15900000000" /> </ Beans>

6. Teste o seguinte:

 pacote springbeantest; importar org.springframework.context.applicationContext; importar org.springframework.context.support.classPathXMLApplicationContext; ApplicationContext Factory = new ClassPathXMLApplicationContext ("SpringBeAntest/beans.xml"); System.out.println ("Inicialização do contêiner com sucesso"); // obtenha preson e use pessoa pessoa = factory.getbean ("pessoa", pessoa.class); System.out.println (pessoa); System.out.println (pessoa); System.out.println ("Comece fechar o contêiner agora!"); ((ClassPathXMLApplicationContext) Factory) .RegisterShutDownHook (); }}

Feche o contêiner usando o método do gancho que é na verdade abstractApplicationContext.

Vamos dar uma olhada nos resultados:

 Start initializing the container now 2014-5-18 15:46:20 org.springframework.context.support.AbstractApplicationContext prepareRefresh information: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@19a0c7c: startup date [Sun May 18 15:46:20 CST 2014]; Raiz do contexto Hierarquia2014-5-18 15:46:20 org.springframework.beans.factory.xml.xmlBeandEfinition Reader LoadBeandEfinitions Informações: Carregando definições de grãos do Recurso do Recurso de Classe [SpringBeNestest/Bean.xml] ! BeanFactoryPostProcessor Chamadas PostprocessBeanFactory Method Este é o construtor de classe de implementação do BEANPOSTPROCESSOR! ! Este é o construtor de classe de implementação do instanciação e a classe de implementação! ! 2014-5-18 15:46:20 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletonsInformation: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@9934d4: defining beans [BeanPostProcessor, InstantiationWareBeanPostProcessor, BeanFactoryPostProcessor, Pessoa]; root of factory hierarchyInstantiationAwareBeanPostProcessor calls postProcessBeforeInstantiation method [Constructor] Call Person's constructor InstantiationAwareBeanPostProcessor calls postProcessPropertyValues ​​​​method [Injecting attribute] Injecting attribute address [Injecting attribute] Injecting attribute name [Injecting attribute] Injecting attribute phone [BeanNameAware interface] Calling Beannameaware.setBeanName () [interface beanFactoryAWare] Calling beanfactoryAware.setBeanFactory () BeanPostProcessor Method Post ProcessBeforeinitialization Altera o atributo! [Inicializando interfaceBean] Chamada InitializingBean.AFterPropertiESSET () [Init-Method] Chame o método de inicialização especificado pela propriedade Init-Method de <Bean>, método de interface do BEANPOSTPROCESSOR Postprocessafterinitialização para alterar a propriedade! InstanciaçãoeeBeanPostProcessor chama o método de pós -processáriofterinitialização. O contêiner é inicializado com sucesso. Pessoa [Endereço = Guangzhou, Nome = Zhang San, Telefone = 110] Agora comece a fechar o contêiner! 【Interface DostibleBean】 Chamada DiposibleBean.Destory () 【Destruir-method】 Chame o método de inicialização especificado pela propriedade Destroy-Method de <Bean>

O exposto acima é uma compilação das informações sobre o ciclo de vida do feijão java de primavera. Continuaremos a adicionar informações relevantes no futuro. Obrigado pelo seu apoio a este site!