Spring
  • [Spring]Spring 教程
  • [Spring]Spring 体系结构
  • [Spring]Spring 环境配置
  • [Spring]Spring Hello World 实例
  • [Spring]Spring IoC 容器
  • [Spring]Spring BeanFactory 容器
  • [Spring]Spring ApplicationContext 容器
  • [Spring]Spring Bean 定义
  • [Spring]Spring Bean 作用域
  • [Spring]Spring Bean 生命周期
  • [Spring]Spring Bean 后置处理器
  • [Spring]Spring Bean 定义继承
  • [Spring]Spring 依赖注入
  • [Spring]Spring 基于构造函数的依赖注入
  • [Spring]Spring 基于设值函数的依赖注入
  • [Spring]Spring 注入内部 Beans
  • [Spring]Spring 注入集合
  • [Spring]Spring Beans 自动装配
  • [Spring]Spring 自动装配 ‘byName’
  • [Spring]Spring 自动装配 ‘byType’
  • [Spring]Spring 由构造函数自动装配
  • [Spring]Spring 基于注解的配置
  • [Spring]Spring @Required 注释
  • [Spring]Spring @Autowired 注释
  • [Spring]Spring @Qualifier 注释
  • [Spring]Spring JSR-250 注释
  • [Spring]Spring 基于 Java 的配置
  • [Spring]Spring 中的事件处理
  • [Spring]Spring 中的自定义事件
  • [Spring]Spring 框架的 AOP
  • [Spring]Spring 中基于 AOP 的 XML架构
  • [Spring]Spring 中基于 AOP 的 @AspectJ
  • [Spring]Spring JDBC 框架
  • [Spring]Spring JDBC 示例
  • [Spring]Spring 中 SQL 的存储过程
  • [Spring]Spring 事务管理
  • [Spring]Spring 编程式事务管理
  • [Spring]Spring 声明式事务管理
  • [Spring]Spring Web MVC 框架
  • [Spring]Spring MVC Hello World 例子
  • [Spring]Spring MVC 表单处理例子
  • [Spring]Spring 页面重定向例子
  • [Spring]Spring 静态页面例子
  • [Spring]Spring 异常处理例子
  • [Spring]Spring 使用 Log4J 记录日志
  • 直达腾讯云服务器
    腾讯云服务器,数据库,短信等热销产品限量秒杀;新购爆款3折起;
    腾讯云数据库MySQL入门机型仅12元/月
    腾讯云云服务器新购特惠,最低2折起,1核1G3年仅794.73元,即0.73元/日。
    腾讯云国际顶级CA机构SSL证书8.8折,云解析买一年最高送半年!
    腾讯云为数百万企业和开发者提供安全、稳定的云服务器、云数据库、CDN等云服务
    腾讯云服务器安全可靠高性能,多种配置供您选择
    腾讯云数据库性能卓越稳定可靠,为您解决数据库运维难题
    阿里云服务器入口
    180天免费用腾讯云服务器马上领取
    您当前位置:狗鱼MySQL教程 >> 服务端编程 >> Spring >> Spring 基于 Java 的配置
    Spring 基于 Java 的配置
    更新日期: 2017年08月04日 来源: 本站原创 作者: 佚名 阅读:
    上一篇Spring JSR-250 注释 下一篇:Spring 中的事件处理

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

    例子

    让我们在恰当的位置使用 eclipse IDE,然后按照下面的步骤来创建一个 Spring 应用程序:

    步骤 描述
    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 类 HelloWorldConfigHelloWorldMainApp
     
    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!

    注入 Bean 的依赖性

    当 @Beans 依赖对方时,表达这种依赖性非常简单,只要有一个 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 通过构造函数注入来接收参考基准。现在,让我们看到一个正在执行的例子:

    例子:

    让我们在恰当的位置使用 Eclipse IDE,然后按照下面的步骤来创建一个 Spring 应用程序:

    步骤 描述
    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 类 TextEditorConfigTextEditorSpellCheckerMainApp
    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.

    @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 a() {
          return new A(); 
       }
    }

    现在,当实例化上下文时,不需要同时指定 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 的初始化方法和销毁方法的属性:

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

    感觉本站内容不错,读后有收获?

    我要小额赞助,鼓励提供更好的内容教程

    上一篇Spring JSR-250 注释 下一篇:Spring 中的事件处理
    Copyright 2013-2017 Powered by 狗鱼MySQL教程,All Rights Reserved.
    广州相如计算机科技有限有限公司 版权所有 粤ICP备08130661号-4
    售前咨询:020-38667011 手机:13711588918