Spring 简明教程

Spring - Java Based Configuration

到目前为止，你知道我们如何使用 XML 配置文件配置 Spring Bean。如果你熟悉 XML 配置，那么真的没有必要学习如何继续基于 Java 的配置，因为你可以使用任何可用的配置来实现相同的结果。

基于 Java 的配置选项使你能够在没有 XML 的情况下编写大部分 Spring 配置，但借助本章中解释的几个基于 Java 的注释来实现。

@Configuration & @Bean Annotations

使用 @Configuration 注释类表示该类可被 Spring IoC 容器用作 Bean 定义的来源。 @Bean 注释告诉 Spring 一个使用 @Bean 注释的方法将返回一个对象，该对象应注册为 Spring 应用程序上下文中的 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，并且它创建并返回实际 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();
}

Example

让我们准备一个可用的 Eclipse IDE，然后执行以下步骤来创建一个 Spring 应用程序−

Steps

Description

1

使用 SpringExample 创建一个项目，并在创建的项目 src 文件夹下创建 com.tutorialspoint 包。

2

使用 Add External JARs 选项添加必需的 Spring 库，如 Spring Hello World Example 章节中所述。

3

由于使用基于 Java 的注释，因此还需要从 Java 安装目录添加 CGLIB.jar 和可从 asm.ow2.org 下载的 ASM.jar 库。

4

在 com.tutorialspoint 包下，创建 Java 类 HelloWorldConfig、HelloWorld 和 MainApp。

5

最后一步是创建所有 Java 文件和 Bean 配置文件的内容，并按如下所述运行应用程序。

以下是 HelloWorldConfig.java 文件的内容

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

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

以下是 HelloWorld.java 文件的内容

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 文件的内容

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

一旦完成创建所有源文件并添加了所需的附加库，即可运行应用程序。需要了解的是，不需要任何配置文件。如果一切正常，将在应用程序中打印以下消息 -

Your Message : Hello World!

Injecting Bean Dependencies

当 @Bean 彼此依赖时，表达依赖关系就像让一个 bean 方法调用另一个 bean 方法一样简单，如下所示 -

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 通过构造函数注入接收 bar 的引用。现在，考虑另一个工作示例。

Example

让我们准备一个可用的 Eclipse IDE，然后执行以下步骤来创建一个 Spring 应用程序−

Steps

Description

1

使用 SpringExample 创建一个项目，并在创建的项目 src 文件夹下创建 com.tutorialspoint 包。

2

使用 Add External JARs 选项添加必需的 Spring 库，如 Spring Hello World Example 章节中所述。

3

由于使用基于 Java 的注释，因此还需要从 Java 安装目录添加 CGLIB.jar 和可从 asm.ow2.org 下载的 ASM.jar 库。

4

在 com.tutorialspoint 包下，创建 Java 类 TextEditorConfig、TextEditor、SpellChecker 和 MainApp。

5

最后一步是创建所有 Java 文件和 Bean 配置文件的内容，并按如下所述运行应用程序。

以下是 TextEditorConfig.java 文件的内容

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 文件的内容

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 的内容

package com.tutorialspoint;

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

以下是 MainApp.java 文件的内容

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.

The @Import Annotation

@Import 注释允许从另一个配置类加载 @Bean 定义。考虑 ConfigA 类，如下所示 -

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

可将上述 Bean 声明导入另一个 Bean 声明，如下所示 -

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

现在，与实例化上下文时需要指定 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);
}

Lifecycle Callbacks

@Bean 注释支持指定任意初始化和销毁回调方法，非常类似于 bean 元素上的 Spring XML 的 init-method 和 destroy-method 属性 -

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

Specifying Bean Scope

默认范围是 singleton，但就像下面一样，可以用 @Scope 注释覆盖它 -

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