Spring - Bean Post Processors

o BeanPostProcessor interface define métodos de retorno de chamada que você pode implementar para fornecer sua própria lógica de instanciação, lógica de resolução de dependência, etc. Você também pode implementar alguma lógica personalizada depois que o contêiner Spring terminar de instanciar, configurar e inicializar um bean conectando uma ou mais implementações BeanPostProcessor .

Você pode configurar várias interfaces BeanPostProcessor e pode controlar a ordem em que essas interfaces BeanPostProcessor são executadas, definindo o order propriedade desde que o BeanPostProcessor implemente o Ordered interface.

Os BeanPostProcessors operam em instâncias de bean (ou objeto), o que significa que o contêiner Spring IoC instancia uma instância de bean e então as interfaces BeanPostProcessor fazem seu trabalho.

A ApplicationContext detecta automaticamente quaisquer beans que são definidos com a implementação do BeanPostProcessor faz a interface e registra esses beans como pós-processadores, para serem chamados apropriadamente pelo contêiner na criação do bean.

Exemplo

Os exemplos a seguir mostram como escrever, registrar e usar BeanPostProcessors no contexto de um ApplicationContext.

Vamos ter um Eclipse IDE funcionando e realizar as seguintes etapas para criar um aplicativo Spring -

Passos	Descrição
1	Crie um projeto com um nome SpringExample e crie um pacote com.tutorialspoint sob osrc pasta no projeto criado.
2	Adicione as bibliotecas Spring necessárias usando a opção Adicionar JARs externos conforme explicado no capítulo Exemplo do Spring Hello World .
3	Crie classes Java HelloWorld , InitHelloWorld e MainApp sob o pacote com.tutorialspoint .
4	Crie o arquivo de configuração do Beans Beans.xml sob osrc pasta.
5	A etapa final é criar o conteúdo de todos os arquivos Java e do arquivo de configuração do Bean e executar o aplicativo conforme explicado abaixo.

Aqui está o conteúdo de HelloWorld.java arquivo -

package com.tutorialspoint;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
   public void init(){
      System.out.println("Bean is going through init.");
   }
   public void destroy(){
      System.out.println("Bean will destroy now.");
   }
}

Este é um exemplo muito básico de implementação de BeanPostProcessor, que imprime um nome de bean antes e depois da inicialização de qualquer bean. Você pode implementar uma lógica mais complexa antes e depois da inicialização de um bean porque você tem acesso ao objeto do bean dentro de ambos os métodos de pós-processador.

Aqui está o conteúdo de InitHelloWorld.java arquivo -

package com.tutorialspoint;

import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.BeansException;

public class InitHelloWorld implements BeanPostProcessor {
   public Object postProcessBeforeInitialization(Object bean, String beanName) 
      throws BeansException {
      
      System.out.println("BeforeInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
   public Object postProcessAfterInitialization(Object bean, String beanName) 
      throws BeansException {
      
      System.out.println("AfterInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
}

A seguir está o conteúdo do MainApp.javaArquivo. Aqui você precisa registrar um gancho de desligamentoregisterShutdownHook()método que é declarado na classe AbstractApplicationContext. Isso garante um desligamento normal e chama os métodos de destruição relevantes.

package com.tutorialspoint;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
      context.registerShutdownHook();
   }
}

A seguir está o arquivo de configuração Beans.xml necessário para os métodos init e destroy -

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld"
      init-method = "init" destroy-method = "destroy">
      <property name = "message" value = "Hello World!"/>
   </bean>

   <bean class = "com.tutorialspoint.InitHelloWorld" />

</beans>

Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se estiver tudo bem com o seu aplicativo, ele imprimirá a seguinte mensagem -

BeforeInitialization : helloWorld
Bean is going through init.
AfterInitialization : helloWorld
Your Message : Hello World!
Bean will destroy now.