SpringBoot3-spring常用配置

一：spring的常用配置

  1，bean的scope
  scope描述了spring容器如何新建bena的实例，spring的scope有以下几种，通过@Scope注解来实现
  1）Singleton：一个spring容器中只有一个bena的实例，此为spring的默认配置，全容器共享一个实例的bean。
  2）Prototype：每次调用新建一个bean的实例
  3）Request：web项目中，给每一个http request新建一个Bean实例
  4）Session ：web项目中，给每一个http session新建一个实例
  5）GlobalSession：这个只在portal应用中有用，给每一个global http session新建一个bean实例
   另外，在spring batch中还有一个Scope是使用@StepScope，用在批处理中，

  下面演示默认的single和Prototype，分别从Spring 容器中获得2次Bean，判断Bean的实例是否相等

   下面编写一个singleton的bean，代码如下：

   

package jack.ch2.scope;import org.springframework.stereotype.Service;/** * Created by jack on 2017/7/9. *///默认为Sinleton，相当于@Scope("singleton")@Servicepublic class DemoSingletonService {}

  下面编写一个prototype的bean：

package jack.ch2.scope;import org.springframework.context.annotation.Scope;import org.springframework.stereotype.Service;/** * Created by jack on 2017/7/9. */@Service@Scope("prototype")public class DemoPrototypeService {}

  下面是配置类：

package jack.ch2.scope;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;/** * Created by jack on 2017/7/9. */@Configuration@ComponentScan("jack.ch2.scope")public class ScopConfig {}

   下面是测试主类：

package jack.ch2.scope;import jack.ch1.bean.JavaConfig;import jack.ch1.bean.UseFunctionService;import org.springframework.context.annotation.AnnotationConfigApplicationContext;/** * Created by wj on 2017/7/09. */public class MainTest4 {    public static void main(String [] args){        //AnnotationConfigApplicationContext作为spring容器，接受一个配置类作为参数        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ScopConfig.class);       DemoSingletonService s1 = context.getBean(DemoSingletonService.class);       DemoSingletonService s2 = context.getBean(DemoSingletonService.class);       DemoPrototypeService p1 = context.getBean(DemoPrototypeService.class);       DemoPrototypeService p2 = context.getBean(DemoPrototypeService.class);       System.out.println("s1与s2是否相等："+s1.equals(s2));        System.out.println("p1与p2是否相等："+p1.equals(p2));        context.close();    }}

   运行测试程序，测试结果如下：

二：spring EL和资源调用

 spring EL-Spring表达式语言，支持在xml和注解中使用表达式，类似于jsp的EL表达式语言
 spring开发中经常涉及调用各种资源的情况，包含普通文件，网址，配置文件，系统环境变量等，我们可以使用  spring表达式语言实现资源的注入
 spring主要在注解@Vavle的参数中使用表达式
 下面演示一下几种情况
  1）注入普通字符串
  2）注入操作系统属性
  3）注入表达式运算结果
  4）注入其他Bean的属性
  5）注入文件内容
  6）注入网址内容
  7）注入属性文件

 示例：

 1，准备，增加commons-io可简化文件相关的操作，本例使用commons-io将file转换成字符串：

<!--增加commons-io可简化文件相关操作-->        <dependency>            <groupId>commons-io</groupId>            <artifactId>commons-io</artifactId>            <version>2.3</version>        </dependency>

  在

jack.ch2.el包下新建test.txt，内容随意

  test.txt比如内容如下：

这是test.txt里面的内容，随便写点啥吧

  在jack.ch2.el包下新建test.properties，内容如下：

book.author=jackbook.name=no book name

   注意，我是使用IDEA开发的，上面两个文件其实是放在resources目录下：

   2，需被注入的bean

package jack.ch2.el;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.Bean;import org.springframework.stereotype.Service;/** * Created by jack on 2017/7/9. */@Servicepublic class DemoService {    //注入普通字符串    @Value("其他类属性")    private String another;    public String getAnother() {        return another;    }    public void setAnother(String another) {        this.another = another;    }}

  3，配置类：

package jack.ch2.el;import org.apache.commons.io.IOUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.PropertySource;import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;import org.springframework.core.env.Environment;import org.springframework.core.io.Resource;/** * Created by jack on 2017/7/9. */@Configuration@ComponentScan("jack.ch2.el")//注入配置文件需要使用@PropertySource指定文件地址，若使用@Value注入，则要配置一个PropertySourcesPlaceholderConfigurer的bean//注意，@ @Value("${book.name}")使用的是$而不是#//注入Properties还可以从Environment中获得@PropertySource("classpath:jack/ch2/el/test.properties")public class ElConfig {    //注入普通字符串    @Value("I Love YOU ROLE!")    private String normal;    //注入操作系统属性    @Value("#{systemProperties['os.name']}")    private String osName;    //注入表达式结果    @Value("#{T(java.lang.Math).random()*100.0}")    private double randomNumber;    //注入其他的bean属性    @Value("#{demoService.another}")    private String fromAnother;    //注入文件资源    @Value("classpath:jack/ch2/el/test.txt")    private Resource testFile;    //注入网址资源    @Value("http://www.baidu.com")    private Resource testUrl;    //注入配置文件    @Value("${book.name}")    private String bookNmame;    //注入环境    @Autowired    private Environment environment;    @Bean    public static PropertySourcesPlaceholderConfigurer propertyConfigure(){        return new PropertySourcesPlaceholderConfigurer();    }    public void outputResource(){        try {            System.out.println(normal);            System.out.println(osName);            System.out.println(randomNumber);            System.out.println(fromAnother);            System.out.println(IOUtils.toString(testFile.getInputStream()));            System.out.println(IOUtils.toString(testUrl.getInputStream()));            System.out.println(bookNmame);            System.out.println(environment.getProperty("book.author"));        }catch (Exception e){            e.printStackTrace();            System.out.println(e);        }    }}

  测试程序如下：

package jack.ch2.el;import jack.ch2.scope.DemoPrototypeService;import jack.ch2.scope.DemoSingletonService;import jack.ch2.scope.ScopConfig;import org.springframework.context.annotation.AnnotationConfigApplicationContext;/** * Created by jack on 2017/7/09. */public class MainTest5 {    public static void main(String [] args){        //AnnotationConfigApplicationContext作为spring容器，接受一个配置类作为参数        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ElConfig.class);        ElConfig elConfig = context.getBean(ElConfig.class);        elConfig.outputResource();        context.close();    }}

  测试结果如下：

   pom.xml的配置如下：

   

<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0"         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">    <modelVersion>4.0.0</modelVersion>    <groupId>com.jack</groupId>    <artifactId>springstudy1</artifactId>    <version>1.0-SNAPSHOT</version>    <!--定义属性-->    <properties>        <java.version>1.8</java.version>    </properties>    <!--添加依赖-->    <dependencies>        <!--添加spring框架依赖包-->        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-context</artifactId>            <version>4.1.6.RELEASE</version>        </dependency>        <!--spring的aop支持-->        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-aop</artifactId>            <version>4.1.6.RELEASE</version>        </dependency>        <!--aspectj支持-->        <dependency>            <groupId>org.aspectj</groupId>            <artifactId>aspectjrt</artifactId>            <version>1.8.5</version>        </dependency>        <dependency>            <groupId>org.aspectj</groupId>            <artifactId>aspectjweaver</artifactId>            <version>1.8.5</version>        </dependency>        <!--增加commons-io可简化文件相关操作-->        <dependency>            <groupId>commons-io</groupId>            <artifactId>commons-io</artifactId>            <version>2.3</version>        </dependency>    </dependencies>    <!--添加插件-->    <build>        <plugins>            <plugin>                <groupId>org.apache.maven.plugins</groupId>                <artifactId>maven-compiler-plugin</artifactId>                <version>2.3.2</version>                <configuration>                    <source>${java.version}</source>                    <target>${java.version}</target>                </configuration>            </plugin>        </plugins>    </build></project>

三：Bean的初始化和销毁

    在我们实际开发的时候，经常会遇到在bean使用之前或者之后做一些必要的操作，spring 对bean的生命周期的操作提供了支持。在使用java配置和注解配置下提供如下两种方式：

   1）java配置方式：使用@Bean的initMethod和destroyMethod（相当于xml配置的init-method和destory-method）

   2）注解方式：利用JSR-250的@PostConstruct和@PreDestroy

   1，增加JSR250支持：

 <!--增加JSR250支持-->        <dependency>            <groupId>javax.annotation</groupId>            <artifactId>jsr250-api</artifactId>            <version>1.0</version>        </dependency>

   2，使用@Bean形式的bean

package jack.ch2.prepost;/** * Created by jack on 2017/7/10. * 使用@Bean形式的Bean初始化和销毁方法 */public class BeanWayService {    //构造函数之后执行    public void init() {        System.out.println("@Bean-init-method");    }    //构造函数    public BeanWayService() {        super();        System.out.println("初始化构造函数-BeanWayService");    }    //bean销毁之前执行    public void destroy() {        System.out.println("@Bean-destroy-method");    }}

   3，使用JSR250形式的bean：

package jack.ch2.prepost;import javax.annotation.PostConstruct;import javax.annotation.PreDestroy;/** * Created by jack on 2017/7/10. */public class JSR250WayService {    //注解方式，注解初始化方法，在构造函数之后执行    @PostConstruct    public void init(){        System.out.println("jsr250-init-method");    }    //构造函数    public JSR250WayService() {        System.out.println("初始化构造函数-JSR250WayService");    }    //注解方法，注解销毁方法，在bean销毁之前执行    @PreDestroy    public void destroy(){        System.out.println("jsr250-destroy-method");    }}

    4，配置类

package jack.ch2.prepost;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;/** * Created by jack on 2017/7/10. * bean 的初始化和销毁的java配置 */@Configuration//@ComponentScan("com.jack.ch2.prepost")public class PrePostConfig {    //initMethod和destroyMethod指定BeanWayService类的init和destroy方法在构造之后，bean销毁之前执行    @Bean(initMethod = "init",destroyMethod = "destroy")    public BeanWayService beanWayService(){        return new BeanWayService();    }    @Bean    public JSR250WayService jsr250WayService(){        return new JSR250WayService();    }}

     5，测试方法如下：

package jack.ch2.prepost;import jack.ch2.el.ElConfig;import org.springframework.context.annotation.AnnotationConfigApplicationContext;/** * Created by jack on 2017/7/09. */public class MainTest6 {    public static void main(String [] args){        //AnnotationConfigApplicationContext作为spring容器，接受一个配置类作为参数        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(PrePostConfig.class);        //initMethod和destroyMethod指定        BeanWayService beanWayService = context.getBean(BeanWayService.class);        JSR250WayService jsr250WayService = context.getBean(JSR250WayService.class);        context.close();    }}

    运行程序，输入如下：

    可见init方法和destory方法在构造方法之后，bean销毁之前执行。

四：Profile

     Profile为在不同环境下使用不同的配置提供了支持（开发环境下的配置和生产环境下的配置不同，比如数据库）

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

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

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

    下面看一个演示：

  定义一个DemoBean类

package jack.ch2.profile;/** * Created by jack on 2017/7/10. */public class DemoBean {    private String content;    public DemoBean(String content) {        super();        this.content = content;    }    public String getContent() {        return content;    }    public void setContent(String content) {        this.content = content;    }}

    配置Profile

package jack.ch2.profile;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.Profile;/** * Created by jack on 2017/7/10. */@Configurationpublic class ProfileConfig {    @Bean    @Profile("dev")//Profile为dev时实例化devDemoBean    public DemoBean devDemoBean(){        return new DemoBean("from development pfofile");    }    @Bean    @Profile("prod")//Profile为prod时实例化prodDemoBean    public DemoBean prodDemoBean(){        return new DemoBean("from  production profile");    }}

   测试程序如下：

package jack.ch2.profile;import jack.ch2.prepost.BeanWayService;import jack.ch2.prepost.JSR250WayService;import jack.ch2.prepost.PrePostConfig;import org.springframework.context.annotation.AnnotationConfigApplicationContext;/** * Created by jack on 2017/7/09. */public class MainTest7 {    public static void main(String [] args){        //AnnotationConfigApplicationContext作为spring容器，接受一个配置类作为参数        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();        //先将活动的Profile设置为prod        context.getEnvironment().setActiveProfiles("prod");        //后置注册Bean配置类，不然会报bean未定义的错误        context.register(ProfileConfig.class);        //刷新容器        context.refresh();        DemoBean demoBean = context.getBean(DemoBean.class);        System.out.println(demoBean.getContent());        context.close();    }}

  运行程序，结果如下：

  将context.getEnvironment().setActiveProfiles("prod");设置为context.getEnvironment().setActiveProfiles("dev");效果如下：

五：事件（Application Event）

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

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

     1）自定义事件，基础ApplicationEvent

     2）定义事件监听器，实现ApplicationListener

     3）使用容器发布事件

     示例如下：

    自定义事件：

package jack.ch2.event;import org.springframework.context.ApplicationEvent;/** * Created by jack on 2017/7/11. * 自定义事件,继承ApplicationEvent */public class DemoEvent extends ApplicationEvent {    private String msg;    public DemoEvent(Object source,String msg) {        super(source);        this.msg = msg;    }    public String getMsg() {        return msg;    }    public void setMsg(String msg) {        this.msg = msg;    }}

事件监听：

package jack.ch2.event;import org.springframework.context.ApplicationListener;import org.springframework.stereotype.Component;/** * Created by jack on 2017/7/11. * 事件监听，实现ApplicationListener接口，并指定监听的事件类型 */@Componentpublic class DemoListener implements ApplicationListener<DemoEvent>{    //使用onApplicationEvent方法对消息进行接受处理    @Override    public void onApplicationEvent(DemoEvent demoEvent) {        String msg = demoEvent.getMsg();        System.out.println("我(bean-demoListener)接收到了bean-demoPublisher发布的消息："+msg);    }}

事件发布类：

package jack.ch2.event;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.ApplicationContext;import org.springframework.stereotype.Component;/** * Created by jack on 2017/7/11. * 事件发布类 */@Componentpublic class DemoPublisher {    //注入ApplicationContext用来发布事件    @Autowired    ApplicationContext applicationContext;    public void publish(String msg){        //使用ApplicationContext的publishEvent方法来发布        applicationContext.publishEvent(new DemoEvent(this,msg));    }}

配置类：

package jack.ch2.event;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;/** * Created by jack on 2017/7/11. * 配置类 */@Configuration@ComponentScan("jack.ch2.event")public class EventConfig {}

 测试代码：

package jack.ch2.event;import jack.ch2.profile.DemoBean;import jack.ch2.profile.ProfileConfig;import org.springframework.context.annotation.AnnotationConfigApplicationContext;/** * Created by jack on 2017/7/11. */public class MainTest8 {    public static void main(String [] args){        //AnnotationConfigApplicationContext作为spring容器，接受一个配置类作为参数        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(EventConfig.class);        DemoPublisher demoPublisher = context.getBean(DemoPublisher.class);        demoPublisher.publish("hello application event");        context.close();    }}

  运行程序，输出如下：