SpringBoot3-spring常用配置

最新推荐文章于 2024-08-15 14:24:45 发布

修炼中的菜鸟

最新推荐文章于 2024-08-15 14:24:45 发布

阅读量1.2k

点赞数

分类专栏： spring boot spring4 spring springboot和springcloud 文章标签： spring spring boot java 配置框架

本文链接：https://blog.csdn.net/j903829182/article/details/74906948

版权

spring boot 同时被 3 个专栏收录

71 篇文章 0 订阅

订阅专栏

springboot和springcloud

61 篇文章 7 订阅

订阅专栏

spring4

13 篇文章 0 订阅

订阅专栏

一：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")
@Service
public 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=jack
book.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.
 */
@Service
public 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.
 */
@Configuration
public 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接口，并指定监听的事件类型
 */
@Component
public 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.
 * 事件发布类
 */
@Component
public 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();
    }
}

运行程序，输出如下：