Spring 基于Java的配置



  • 基于Java的配置

    到目前为止,您已经了解了我们如何使用XML配置文件配置Spring bean。如果您对XML配置感到满意,那么实际上不需要学习如何进行基于Java的配置,因为使用两种可用的配置都将获得相同的结果。基于Java的配置选项使您无需XML即可编写大多数Spring配置,但借助本章中介绍的基于Java的注解很少。
  • @Configuration和@Bean注解

    用@Configuration注解类表示该类可以由Spring IoC容器用作Bean定义的源。@Bean注解告诉Spring 使用@Bean注解的方法将返回一个对象,该对象应在Spring应用程序上下文中注册为Bean。最简单的@Configuration类如下所示-
    package com.jc2182;
    import org.springframework.context.annotation.*;
    
    @Configuration
    public class HelloWorldConfig {
       @Bean 
       public HelloWorld helloWorld(){
          return new HelloWorld();
       }
    }
    
    上面的代码将等效于以下XML配置
    <beans>
       <bean id = "helloWorld" class = "com.jc2182.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();
    }
    
  • 实例

    假设我们拥有一个运行良好的Eclipse IDE,并采取以下步骤来创建一个Spring应用程序:
    1. 创建一个名称为SpringExample的项目,并在创建的项目的src文件夹下创建一个包com.jc2182
    2. 使用“添加外部JAR”选项添加所需的Spring库,如“Spring Hello World示例”一章中所述。
    3. 在com.jc2182包下创建Java类HelloWorldConfig, HelloWorld 和 MainApp。
    4. 最后一步是创建所有Java文件和Bean配置文件的内容,然后按以下说明运行应用程序。
    以下是HelloWorldConfig.java内容。
    package com.jc2182;
    
    public class TextEditor {
       private SpellChecker spellChecker;
       
       // a setter method to inject the dependency.
       public void setSpellChecker(SpellChecker spellChecker) {
          System.out.println("Inside setSpellChecker." );
          this.spellChecker = spellChecker;
       }
       
       // a getter method to return spellChecker
       public SpellChecker getSpellChecker() {
          return spellChecker;
       }
       public void spellCheck() {
          spellChecker.checkSpelling();
       }
    }
    
    这是HelloWorld.java文件的内容
    package com.jc2182;
    
    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.jc2182;
    
    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!
    
  • 注入Bean依赖关系

    package com.jc2182;
    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的引用。现在让我们来看另一个工作示例。
    我们拥有一个运行良好的Eclipse IDE,并采取以下步骤来创建一个Spring应用程序:
    1. 创建一个名称为SpringExample的项目,并在创建的项目的src文件夹下创建一个包com.jc2182
    2. 使用“添加外部JAR”选项添加所需的Spring库,如“Spring Hello World示例”一章中所述。
    3. 在com.jc2182包下创建Java类TextEditorConfig, TextEdit , SpellChecker 和 MainApp。
    4. 最后一步是创建所有Java文件和Bean配置文件的内容,然后按以下说明运行应用程序。
    以下是TextEditorConfig.java内容。
    package com.jc2182;
    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.jc2182;
    
    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.jc2182;
    
    public class SpellChecker {
       public SpellChecker(){
          System.out.println("Inside SpellChecker constructor." );
       }
       public void checkSpelling(){
          System.out.println("Inside checkSpelling." );
       }
    }
    
    以下是MainApp.java文件的内容。
    package com.jc2182;
    
    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.
    
  • @Import注解

    @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);
    }
    
  • 生命周期回调

    @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();
       }
    }
    
  • 指定Bean作用域

    默认范围是singleton,但是您可以使用@Scope注释覆盖此作用域,如下所示:
    @Configuration
    public class AppConfig {
       @Bean
       @Scope("prototype")
       public Foo foo() {
          return new Foo();
       }
    }