zoukankan      html  css  js  c++  java
  • Spring常用配置

    概述

      本文主要讲解Spring的一些常用配置,使用Java Bean来配置。

      需要注意的均写在注释里面了。


    配置Bean的Scope

     1 package com.wisely.highlight_spring4.ch2.scope;
     2 
     3 import org.springframework.context.annotation.Scope;
     4 import org.springframework.stereotype.Service;
     5 
     6 /**
     7  * 编写Prototype的bean
     8  */
     9 @Service
    10 @Scope("prototype")//声明scope为prototype,每次调用新建一个bean的实例
    11 //@Scope("singleton")//一个spring容器中只有一个bean的实例,是spring的默认配置,全容器共享一个实例
    12 //@Scope("request")//web项目中,给每一个http request新建一个bean的实例
    13 //@Scope("session")//web项目中,给每一个http session新建一个bean实例
    14 //@Scope("globalSession")//只在portal应用中有用,给每一个global http session新建一个bean实例
    15 public class DemoPrototypeService {
    16 
    17 }
    编写Prototype的bean
     1 package com.wisely.highlight_spring4.ch2.scope;
     2 
     3 import org.springframework.stereotype.Service;
     4 
     5 /**
     6  * 编写Singleton的bean
     7  */
     8 @Service //默认为Singleton,相当于@Scope("singleton")
     9 public class DemoSingletonService {
    10 
    11 }
    编写Singleton的bean
     1 package com.wisely.highlight_spring4.ch2.scope;
     2 
     3 import org.springframework.context.annotation.ComponentScan;
     4 import org.springframework.context.annotation.Configuration;
     5 
     6 /**
     7  * 配置类
     8  */
     9 @Configuration
    10 @ComponentScan("com.wisely.highlight_spring4.ch2.scope")
    11 public class ScopeConfig {
    12 
    13 }
    配置类
     1 package com.wisely.highlight_spring4.ch2.scope;
     2 
     3 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
     4 
     5 public class Main {
     6     public static void main(String[] args) {
     7         AnnotationConfigApplicationContext context =
     8                 new AnnotationConfigApplicationContext(ScopeConfig.class); 
     9         DemoSingletonService s1 = context.getBean(DemoSingletonService.class);
    10         DemoSingletonService s2 = context.getBean(DemoSingletonService.class);
    11         DemoPrototypeService p1 = context.getBean(DemoPrototypeService.class);
    12         DemoPrototypeService p2 = context.getBean(DemoPrototypeService.class);
    13         System.out.println("s1与s2是否相等:"+s1.equals(s2));
    14         System.out.println("p1与p2是否相等:"+p1.equals(p2));
    15         context.close();
    16     }
    17 }
    运行

    Spring EL和资源调用配置

     1 package com.wisely.highlight_spring4.ch2.el;
     2 
     3 import org.springframework.beans.factory.annotation.Value;
     4 import org.springframework.stereotype.Service;
     5 
     6 /**
     7  * 需被注入的类
     8  */
     9 @Service
    10 public class DemoService {
    11     //注入普通字符串
    12     @Value("其他类的属性")
    13     private String another;
    14 
    15     public String getAnother() {
    16         return another;
    17     }
    18 
    19     public void setAnother(String another) {
    20         this.another = another;
    21     }
    22     
    23 }
    需被注入的类
     1 package com.wisely.highlight_spring4.ch2.el;
     2 
     3 import org.apache.commons.io.IOUtils;
     4 import org.springframework.beans.factory.annotation.Autowired;
     5 import org.springframework.beans.factory.annotation.Value;
     6 import org.springframework.context.annotation.Bean;
     7 import org.springframework.context.annotation.ComponentScan;
     8 import org.springframework.context.annotation.Configuration;
     9 import org.springframework.context.annotation.PropertySource;
    10 import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
    11 import org.springframework.core.env.Environment;
    12 import org.springframework.core.io.Resource;
    13 
    14 /**
    15  * 配置类
    16  */
    17 @Configuration
    18 @ComponentScan("com.wisely.highlight_spring4.ch2.el")
    19 //指定配置文件地址
    20 @PropertySource("classpath:com/wisely/highlight_spring4/ch2/el/test.properties")
    21 public class ElConfig {
    22     //注入普通字符串
    23     @Value("I Love You!")
    24     private String normal;
    25     //注入操作系统属性
    26     @Value("#{systemProperties['os.name']}")
    27     private String osName;
    28     //注入表达式结果
    29     @Value("#{ T(java.lang.Math).random() * 100.0 }")
    30     private double randomNumber;
    31     //注入其他bean属性
    32     @Value("#{demoService.another}")
    33     private String fromAnother;
    34     //注入文件资源
    35     @Value("classpath:com/wisely/highlight_spring4/ch2/el/test.txt")
    36     private Resource testFile;
    37     //注入网址资源
    38     @Value("http://www.baidu.com")
    39     private Resource testUrl;
    40     //注入配置文件
    41     @Value("${book.name}")
    42     private String bookName;
    43     @Autowired
    44     private Environment environment;
    45     /**
    46      * 如果使用@Value注入配置文件,则要配置一个PropertySourcesPlaceholderConfigurer
    47      */
    48     @Bean
    49     public static PropertySourcesPlaceholderConfigurer propertyConfigure() {
    50         return new PropertySourcesPlaceholderConfigurer();
    51     }
    52 
    53     public void outputResource() {
    54         try {
    55             System.out.println(normal);
    56             System.out.println(osName);
    57             System.out.println(randomNumber);
    58             System.out.println(fromAnother);
    59             System.out.println(IOUtils.toString(testFile.getInputStream()));
    60             System.out.println(IOUtils.toString(testUrl.getInputStream()));
    61             System.out.println(bookName);
    62             System.out.println(environment.getProperty("book.author"));
    63         } catch (Exception e) {
    64             e.printStackTrace();
    65         }
    66     }
    67 }
    配置类
     1 package com.wisely.highlight_spring4.ch2.el;
     2 
     3 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
     4 
     5 public class Main {
     6     
     7     public static void main(String[] args) {
     8          AnnotationConfigApplicationContext context =
     9                     new AnnotationConfigApplicationContext(ElConfig.class);
    10          
    11          ElConfig resourceService = context.getBean(ElConfig.class);
    12          
    13          resourceService.outputResource();
    14          
    15          context.close();
    16     }
    17 
    18 }
    运行

    Bean的初始化和销毁

     1 package com.wisely.highlight_spring4.ch2.prepost;
     2 
     3 /**
     4  * 使用@Bean形式的Bean
     5  */
     6 public class BeanWayService {
     7     public void init() {
     8         System.out.println("@Bean-init-method");
     9     }
    10 
    11     public BeanWayService() {
    12         super();
    13         System.out.println("初始化构造函数-BeanWayService");
    14     }
    15 
    16     public void destroy() {
    17         System.out.println("@Bean-destory-method");
    18     }
    19 }
    使用@Bean形式的Bean
     1 package com.wisely.highlight_spring4.ch2.prepost;
     2 
     3 import javax.annotation.PostConstruct;
     4 import javax.annotation.PreDestroy;
     5 
     6 /**
     7  * 使用JSR250形式的bean
     8  */
     9 public class JSR250WayService {
    10     //@PostConstruct:在构造函数执行完之后执行
    11     @PostConstruct
    12     public void init(){
    13         System.out.println("jsr250-init-method");
    14     }
    15     public JSR250WayService() {
    16         super();
    17         System.out.println("初始化构造函数-JSR250WayService");
    18     }
    19     //@PreDestroy:在bean销毁之前执行
    20     @PreDestroy
    21     public void destroy(){
    22         System.out.println("jsr250-destory-method");
    23     }
    24 
    25 }
    使用JSR250形式的bean
     1 package com.wisely.highlight_spring4.ch2.prepost;
     2 
     3 import org.springframework.context.annotation.Bean;
     4 import org.springframework.context.annotation.ComponentScan;
     5 import org.springframework.context.annotation.Configuration;
     6 
     7 /**
     8  * 配置类
     9  */
    10 @Configuration
    11 @ComponentScan("com.wisely.highlight_spring4.ch2.prepost")
    12 public class PrePostConfig {
    13     //指定BeanWayService的init方法和destroy方法在构造函数之后/bean销毁之前执行。
    14     @Bean(initMethod="init",destroyMethod="destroy")
    15     BeanWayService beanWayService(){
    16         return new BeanWayService();
    17     }
    18     
    19     @Bean
    20     JSR250WayService jsr250WayService(){
    21         return new JSR250WayService();
    22     }
    23 
    24 }
    配置类
     1 package com.wisely.highlight_spring4.ch2.prepost;
     2 
     3 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
     4 
     5 public class Main {
     6     
     7     public static void main(String[] args) {
     8         AnnotationConfigApplicationContext context =
     9                 new AnnotationConfigApplicationContext(PrePostConfig.class);
    10         
    11         BeanWayService beanWayService = context.getBean(BeanWayService.class);
    12         JSR250WayService jsr250WayService = context.getBean(JSR250WayService.class);
    13         
    14         context.close();
    15     }
    16 
    17 }
    运行

    Profile

      Profile为在不同环境下使用不同的配置提供了支持(开发环境下的配置和生产环境下的配置肯定是不同的,例如数据库的配置)。

      有三种方式可以配置环境

        1)通过设定Environment的ActiveProfiles来设定当前context需要使用的配置环境。在开发中使用@Profile注解类或方法,达到在不同情况下选择实例化不同的Bean。

        2)通过设置jvm的spring.profiles.active参数来设置配置环境。

        3)Web项目设置在Servlet的context parameter中。

    1 <!--Servlet3.0及以上-->
    2 <servlet>
    3     <servlet-name>dispatcher</servlet-name>
    4     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    5     <init-param>
    6         <param-name>spring.profiles.active</param-name>
    7         <param-value>production</param-value>
    8     </init-param>
    9 </servlet>
    1 /**
    2  * Servlet3.0及以上
    3  */
    4 public class WebInit implements WebApplicationInitializer {
    5     @Override
    6     public void onStartup(ServletContext context) throws ServletException {
    7         container.setInitParameter("spring.profiles.default", "dev");
    8     }
    9 }
     1 package com.wisely.highlight_spring4.ch2.profile;
     2 
     3 /**
     4  * 示例bean
     5  */
     6 public class DemoBean {
     7 
     8     private String content;
     9 
    10     public DemoBean(String content) {
    11         super();
    12         this.content = content;
    13     }
    14 
    15     public String getContent() {
    16         return content;
    17     }
    18 
    19     public void setContent(String content) {
    20         this.content = content;
    21     }
    22     
    23 }
    示例bean
     1 package com.wisely.highlight_spring4.ch2.profile;
     2 
     3 import org.springframework.context.annotation.Bean;
     4 import org.springframework.context.annotation.Configuration;
     5 import org.springframework.context.annotation.Profile;
     6 
     7 /**
     8  * Profile配置
     9  */
    10 @Configuration
    11 public class ProfileConfig {
    12     @Bean
    13     @Profile("dev")//Profile为dev时实例化devDemoBean
    14     public DemoBean devDemoBean() {
    15         return new DemoBean("from development profile");
    16     }
    17 
    18     @Bean
    19     @Profile("prod")//Profile为prod时实例化prodDemoBean
    20     public DemoBean prodDemoBean() {
    21         return new DemoBean("from production profile");
    22     }
    23 
    24 }
    Profile配置
     1 package com.wisely.highlight_spring4.ch2.profile;
     2 
     3 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
     4 
     5 public class Main {
     6 
     7     public static void main(String[] args) {
     8           AnnotationConfigApplicationContext context =  
     9                   new AnnotationConfigApplicationContext();
    10           
    11           context.getEnvironment().setActiveProfiles("dev");//先将活动的profile设置为dev
    12           context.register(ProfileConfig.class);//然后注册bean配置类,不然会报bean未定义的错误
    13           context.refresh(); //刷新容器
    14           
    15           DemoBean demoBean = context.getBean(DemoBean.class);
    16           
    17           System.out.println(demoBean.getContent());
    18           
    19           context.close();
    20     }
    21 }
    运行

    事件(Application Event)

      spring的事件为bean和bean之间的消息通信提供了支持。当一个bean处理完一个任务之后,希望另外一个bean知道并能做出相应的处理,这时我们就需要让另外一个bean监听当前bean所发送的事件。

      spring的事件需要遵循如下流程:

        1)自定义事件,继承ApplicationEvent。

        2)定义事件监听器,实现ApplicationListener。

        3)使用容器发布事件。

     1 package com.wisely.highlight_spring4.ch2.event;
     2 
     3 import org.springframework.context.ApplicationEvent;
     4 
     5 /**
     6  * 自定义事件
     7  */
     8 public class DemoEvent extends ApplicationEvent{
     9     private static final long serialVersionUID = 1L;
    10     private String msg;
    11     public DemoEvent(Object source,String msg) {
    12         super(source);
    13         this.msg = msg;
    14     }
    15     public String getMsg() {
    16         return msg;
    17     }
    18     public void setMsg(String msg) {
    19         this.msg = msg;
    20     }
    21 }
    自定义事件
     1 package com.wisely.highlight_spring4.ch2.event;
     2 
     3 import org.springframework.context.ApplicationListener;
     4 import org.springframework.stereotype.Component;
     5 
     6 /**
     7  * 事件监听器,实现ApplicationListener接口,并指定监听的事件类型
     8  */
     9 @Component
    10 public class DemoListener implements ApplicationListener<DemoEvent> {
    11 
    12     /**
    13      * 使用onApplicationEvent方法对消息进行接收处理
    14      * @param event
    15      */
    16     public void onApplicationEvent(DemoEvent event) {
    17         String msg = event.getMsg();
    18         System.out.println("我(bean-demoListener)接受到了bean-demoPublisher发布的消息:"+ msg);
    19     }
    20 }
    事件监听器,实现ApplicationListener接口,并指定监听的事件类型
     1 package com.wisely.highlight_spring4.ch2.event;
     2 
     3 import org.springframework.beans.factory.annotation.Autowired;
     4 import org.springframework.context.ApplicationContext;
     5 import org.springframework.stereotype.Component;
     6 
     7 /**
     8  * 事件发布类
     9  */
    10 @Component
    11 public class DemoPublisher {
    12     @Autowired
    13     ApplicationContext applicationContext;//注入ApplicationContext用来发布事件
    14 
    15     public void publish(String msg){
    16         //使用ApplicationContext的publishEvent方法发布事件
    17         applicationContext.publishEvent(new DemoEvent(this, msg));
    18     }
    19 }
    事件发布类
     1 package com.wisely.highlight_spring4.ch2.event;
     2 
     3 import org.springframework.context.annotation.ComponentScan;
     4 import org.springframework.context.annotation.Configuration;
     5 
     6 @Configuration
     7 @ComponentScan("com.wisely.highlight_spring4.ch2.event")
     8 public class EventConfig {
     9 
    10 }
    配置类
     1 package com.wisely.highlight_spring4.ch2.event;
     2 
     3 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
     4 public class Main {
     5     public static void main(String[] args) {
     6          AnnotationConfigApplicationContext context =
     7                     new AnnotationConfigApplicationContext(EventConfig.class);
     8          DemoPublisher demoPublisher = context.getBean(DemoPublisher.class);
     9          demoPublisher.publish("hello application event");
    10          context.close();
    11     }
    12 }
    运行
  • 相关阅读:
    Moment.js 超棒Javascript日期处理类库
    java模拟http/https post请求
    Mysql中int和varchar类型
    ssh免密码登录
    Linux优雅退出问题
    Jenkins的权限控制和Rundeck的远程认证
    Jenkins系统+独立部署系统
    Nginx基本介绍
    初窥项目构建
    Rundeck概况
  • 原文地址:https://www.cnblogs.com/gaofei-1/p/8698101.html
Copyright © 2011-2022 走看看