Spring - Configuração Baseada em Java

Até agora, você viu como configuramos os beans Spring usando o arquivo de configuração XML. Se você está confortável com a configuração XML, então realmente não é necessário aprender como proceder com a configuração baseada em Java, pois você vai obter o mesmo resultado usando qualquer uma das configurações disponíveis.

A opção de configuração baseada em Java permite que você escreva a maior parte de sua configuração Spring sem XML, mas com a ajuda de algumas anotações baseadas em Java explicadas neste capítulo.

@Configuration e @Bean Annotations

Anotando uma classe com o @Configurationindica que a classe pode ser usada pelo contêiner Spring IoC como uma fonte de definições de bean. o@Beana anotação diz ao Spring que um método anotado com @Bean retornará um objeto que deve ser registrado como um bean no contexto do aplicativo Spring. A classe @Configuration mais simples possível seria a seguinte -

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class HelloWorldConfig {
   @Bean 
   public HelloWorld helloWorld(){
      return new HelloWorld();
   }
}

O código acima será equivalente à seguinte configuração XML -

<beans>
   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" />
</beans>

Aqui, o nome do método é anotado com @Bean funciona como o ID do bean e cria e retorna o bean real. Sua classe de configuração pode ter uma declaração para mais de um @Bean. Depois que suas classes de configuração forem definidas, você pode carregá-las e fornecê-las ao contêiner Spring usando AnnotationConfigApplicationContext da seguinte maneira -

public static void main(String[] args) {
   ApplicationContext ctx = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
   
   HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
   helloWorld.setMessage("Hello World!");
   helloWorld.getMessage();
}

Você pode carregar várias classes de configuração da seguinte forma -

public static void main(String[] args) {
   AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();

   ctx.register(AppConfig.class, OtherConfig.class);
   ctx.register(AdditionalConfig.class);
   ctx.refresh();

   MyService myService = ctx.getBean(MyService.class);
   myService.doStuff();
}

Exemplo

Vamos ter um Eclipse IDE funcionando e seguir os seguintes passos 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	Como você está usando anotações baseadas em Java, também precisa adicionar CGLIB.jar do diretório de instalação do Java e a biblioteca ASM.jar , que pode ser baixada de asm.ow2.org .
4	Crie classes Java HelloWorldConfig , HelloWorld e MainApp sob o pacote com.tutorialspoint .
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 HelloWorldConfig.java Arquivo

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class HelloWorldConfig {
   @Bean 
   public HelloWorld helloWorld(){
      return new HelloWorld();
   }
}

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);
   }
}

A seguir está o conteúdo do MainApp.java Arquivo

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext ctx = 
         new AnnotationConfigApplicationContext(HelloWorldConfig.class);
   
      HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
      helloWorld.setMessage("Hello World!");
      helloWorld.getMessage();
   }
}

Quando terminar de criar todos os arquivos de origem e adicionar as bibliotecas adicionais necessárias, deixe-nos executar o aplicativo. Você deve observar que não há nenhum arquivo de configuração necessário. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem -

Your Message : Hello World!

Injetando Dependências de Feijão

Quando @Beans tem dependências entre si, expressar que a dependência é tão simples quanto ter um método de bean chamando outro da seguinte maneira -

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class AppConfig {
   @Bean
   public Foo foo() {
      return new Foo(bar());
   }
   @Bean
   public Bar bar() {
      return new Bar();
   }
}

Aqui, o foo bean recebe uma referência a bar por meio da injeção do construtor. Agora, vejamos outro exemplo de trabalho.

Exemplo

Vamos ter um Eclipse IDE funcionando e seguir os seguintes passos 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	Como você está usando anotações baseadas em Java, também precisa adicionar CGLIB.jar do diretório de instalação do Java e a biblioteca ASM.jar , que pode ser baixada de asm.ow2.org .
4	Crie classes Java TextEditorConfig , TextEditor , SpellChecker e MainApp no pacote com.tutorialspoint .
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 TextEditorConfig.java Arquivo

package com.tutorialspoint;
import org.springframework.context.annotation.*;

@Configuration
public class TextEditorConfig {
   @Bean 
   public TextEditor textEditor(){
      return new TextEditor( spellChecker() );
   }

   @Bean 
   public SpellChecker spellChecker(){
      return new SpellChecker( );
   }
}

Aqui está o conteúdo de TextEditor.java Arquivo

package com.tutorialspoint;

public class TextEditor {
   private SpellChecker spellChecker;

   public TextEditor(SpellChecker spellChecker){
      System.out.println("Inside TextEditor constructor." );
      this.spellChecker = spellChecker;
   }
   public void spellCheck(){
      spellChecker.checkSpelling();
   }
}

A seguir está o conteúdo de outro arquivo de classe dependente SpellChecker.java

package com.tutorialspoint;

public class SpellChecker {
   public SpellChecker(){
      System.out.println("Inside SpellChecker constructor." );
   }
   public void checkSpelling(){
      System.out.println("Inside checkSpelling." );
   }
}

A seguir está o conteúdo do MainApp.java Arquivo

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext ctx = 
         new AnnotationConfigApplicationContext(TextEditorConfig.class);

      TextEditor te = ctx.getBean(TextEditor.class);
      te.spellCheck();
   }
}

Inside SpellChecker constructor.
Inside TextEditor constructor.
Inside checkSpelling.

A anotação @Import

o @Importa anotação permite carregar definições @Bean de outra classe de configuração. Considere uma classe ConfigA da seguinte maneira -

@Configuration
public class ConfigA {
   @Bean
   public A a() {
      return new A(); 
   }
}

Você pode importar a declaração Bean acima em outra declaração Bean da seguinte maneira -

@Configuration
@Import(ConfigA.class)
public class ConfigB {
   @Bean
   public B b() {
      return new B(); 
   }
}

Agora, em vez de precisar especificar ConfigA.class e ConfigB.class ao instanciar o contexto, apenas ConfigB precisa ser fornecido da seguinte maneira -

public static void main(String[] args) {
   ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);
   
   // now both beans A and B will be available...
   A a = ctx.getBean(A.class);
   B b = ctx.getBean(B.class);
}

Callbacks do ciclo de vida

A anotação @Bean suporta a especificação de métodos de retorno de chamada de inicialização e destruição arbitrários, bem como os atributos init-method e destroy-method do Spring XML no elemento bean -

public class Foo {
   public void init() {
      // initialization logic
   }
   public void cleanup() {
      // destruction logic
   }
}
@Configuration
public class AppConfig {
   @Bean(initMethod = "init", destroyMethod = "cleanup" )
   public Foo foo() {
      return new Foo();
   }
}

Especificando o Escopo do Feijão

O escopo padrão é singleton, mas você pode substituí-lo pela anotação @Scope da seguinte maneira -

@Configuration
public class AppConfig {
   @Bean
   @Scope("prototype")
   public Foo foo() {
      return new Foo();
   }
}