Spring 基于 Java 的配置

基于 Java 的配置

到目前為止，你已經(jīng)看到如何使用 XML 配置文件來配置 Spring bean。如果你熟悉使用 XML 配置，那么我會說，不需要再學(xué)習(xí)如何進行基于 Java 的配置是，因為你要達到相同的結(jié)果，可以使用其他可用的配置。

基于 Java 的配置選項，可以使你在不用配置 XML 的情況下編寫大多數(shù)的 Spring，但是一些有幫助的基于 Java 的注解，解釋如下：

@Configuration 和 @Bean 注解

帶有 @Configuration 的注解類表示這個類可以使用 Spring IoC 容器作為 bean 定義的來源。@Bean 注解告訴 Spring，一個帶有 @Bean 的注解方法將返回一個對象，該對象應(yīng)該被注冊為在 Spring 應(yīng)用程序上下文中的 bean。最簡單可行的 @Configuration 類如下所示：

package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class HelloWorldConfig {
   @Bean 
   public HelloWorld helloWorld(){
      return new HelloWorld();
   }
}

上面的代碼將等同于下面的 XML 配置：

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

在這里，帶有 @Bean 注解的方法名稱作為 bean 的 ID，它創(chuàng)建并返回實際的 bean。你的配置類可以聲明多個 @Bean。一旦定義了配置類，你就可以使用 AnnotationConfigApplicationContext 來加載并把他們提供給 Spring 容器，如下所示：

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

你可以加載各種配置類，如下所示：

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

例子

讓我們在恰當?shù)奈恢檬褂?Eclipse IDE，然后按照下面的步驟來創(chuàng)建一個 Spring 應(yīng)用程序：

這里是 HelloWorldConfig.java 文件的內(nèi)容：

package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class HelloWorldConfig {
   @Bean 
   public HelloWorld helloWorld(){
      return new HelloWorld();
   }
}

這里是 HelloWorld.java 文件的內(nèi)容：

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

下面是 MainApp.java 文件的內(nèi)容：

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

一旦你完成了創(chuàng)建所有的源文件并添加所需的額外的庫后，我們就可以運行該應(yīng)用程序。你應(yīng)該注意這里不需要配置文件。如果你的應(yīng)用程序一切都正常，將輸出以下信息：

Your Message : Hello World!

注入 Bean 的依賴性

當 @Beans 依賴對方時，表達這種依賴性非常簡單，只要有一個 bean 方法調(diào)用另一個，如下所示：

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

這里，foo Bean 通過構(gòu)造函數(shù)注入來接收參考基準?，F(xiàn)在，讓我們看到一個正在執(zhí)行的例子：

例子:

讓我們在恰當?shù)奈恢檬褂?Eclipse IDE，然后按照下面的步驟來創(chuàng)建一個 Spring 應(yīng)用程序：

這里是 TextEditorConfig.java 文件的內(nèi)容：

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

這里是 TextEditor.java 文件的內(nèi)容：

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

下面是另一個依賴的類文件 SpellChecker.java 的內(nèi)容：

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

}

下面是 MainApp.java 文件的內(nèi)容：

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

一旦你完成了創(chuàng)建所有的源文件并添加所需的額外的庫后，我們就可以運行該應(yīng)用程序。你應(yīng)該注意這里不需要配置文件。如果你的應(yīng)用程序一切都正常，將輸出以下信息：

Inside SpellChecker constructor.
Inside TextEditor constructor.
Inside checkSpelling.

@Import 注解:

@import 注解允許從另一個配置類中加載 @Bean 定義?？紤] ConfigA 類，如下所示：

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

你可以在另一個 Bean 聲明中導(dǎo)入上述 Bean 聲明，如下所示：

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

現(xiàn)在，當實例化上下文時，不需要同時指定 ConfigA.class 和 ConfigB.class，只有 ConfigB 類需要提供，如下所示：

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

生命周期回調(diào)

@Bean 注解支持指定任意的初始化和銷毀的回調(diào)方法，就像在 bean 元素中 Spring 的 XML 的初始化方法和銷毀方法的屬性：

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

指定 Bean 的范圍：

默認范圍是單實例，但是你可以重寫帶有 @Scope 注解的該方法，如下所示：

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