当前位置: 澳门新濠3559 > 编程 > 正文

至于优先级后面再说澳门新濠3559,  今天和大

时间:2019-10-06 23:49来源:编程
基于springboot的 约定优于配置 的原则,在多数情况下,启动一个应用时,基本上无需做太多的配置,应用就能正常启动。但在大部分开发环境下,添加额外配置是无所避免的,比如自定

基于springboot的约定优于配置的原则,在多数情况下,启动一个应用时,基本上无需做太多的配置,应用就能正常启动。但在大部分开发环境下,添加额外配置是无所避免的,比如自定义应用端口号(比较在机器比较少的情况下,一台机器还是需要部署多个应用的,当然利用docker的话,是可避免的,这是后话了)、mq的服务地址、缓存服务的服务地址、数据库的配置等,都或多或少的需要一些外部的配置项。

springboot配置详解

Author:SimpleWu

properteis文件属性参考大全

  今天和大家分享的是自定义配置信息的读取;近期有写博客这样的计划,分别交叉来写springboot方面和springcloud方面的文章,因为springboot预计的篇章很多,这样cloud的文章就需要等到很后面才能写了;分享这两种文章的原因主要是为了方便自己查找资料使用和对将要使用的朋友起到便捷作用;

  1. <strong>写在前面</strong>======通过阅读官方文档以及编写一些demo,个人认为spring boot的核心思想是约定大于配置以及使用java配置代替xml配置,简化繁琐的项目配置同时避免维护繁杂的xml文件。
  2. <strong>使用idea创建项目</strong>======

    澳门新濠3559 1

    这里创建一个web项目,查看pom文件,spring boot默认将项目打包成一个fat jar而不是war

springboot默认的全局配置文件名为application.properties或者application.yml(spring官方推荐使用的格式是.yml格式,目前官网都是实例都是使用yml格式进行配置讲解的),应用启动时会自动加载此文件,无需手动引入。除此之外还有一个bootstrap的全局文件,它的加载顺序在application配置文件之前,主要是用于在应用程序上下文的引导阶段,在后期讲解springCloudConfig时,主要是利用此特性,进行配置文件的动态修改,在此不表,在通常情况下,此两个配置文件是没有差别的,所以一般上都只需要配置application即可。

springboot默认加载配置

SpringBoot使用两种全局的配置文件,全局配置文件可以对一些默认配置进行修改。

  • application.properties
  • application.yml

这两个配置文件使我们springboot启动的时候回默认加载的配置文件。

配置文件放在src/main/resources目录或者类路径/config下,这个配置文件的路径是有优先级的,至于优先级后面再说。

首先这两个文件中properties这个文件不需要多说使我们经常使用的资源文件,可是这个Yml是什么呢?后面再说

  • @Value标记读取(默认可直接读取application.yml的节点)
  • 实体映射application.yml的节点
  • 实体映射自定义配置文件的节点
  • 实体映射多层级节点的值

application.properties配置文件支持自定义属性的支持,比如

配置信息

SpringBoot不需要添加复杂的web.xml或者spring.xml等配置文件,spring只有一个配置文件,也非必须的。

默认的配置文件是application.properties。

#修改端口号server.port=8888#定义项目的访问目录server.context-path=/springboot

我们使用IDEA需要注意,图就不截图太麻烦了:

如果properties文件中出现乱码,找到setting中,在file encoding中勾选Transparent native-to-asci conversion。

YAML文件

除了默认的properties文件,SpringBoot还提供另外一种配置文件yml,这种文件提供一种更加简洁的方式编写配置信息。

yml是YAML(YAML Ain‘t Markup Language)语言的文件,是一种标记语言,以数据为中心,比json、xml等更适合做配置文件,有想法的可以去网上搜搜资料学习下。

参考语法规范:

官方参考:

yml学习参考:

YAML基本语法:

  • 以键值对的方式表示属性。。
  • 使用缩进表示层级关系
  • 缩进时不允许使用Tab键,只允许使用空格。
  • 缩进的空格数目不重要,只要相同层级的元素左侧对齐即可。
  • 属性和值是大小写敏感的。

例子:

server:    port: 8081    servlet:        context-path: springboot

注意:【:后必须跟一个空格】,两种方式推荐使用yml方式配置项目。

YAML语法

YAML支持的三种数据结构。

  • 字面量:普通的值。(数字,字符串,布尔)
  • 对象:键值对的集合。
  • 数组:一组按次序排列的值。

字面量

YAML中字面量属于普通的值。以key: value来表示,value前必须带一个空格。

字面量,字符串默认不需要单双引号。

双引号:会转义字符,特殊字符会被转义。(name: "SimpleWun lisi" //输出:SimpleWu换行 lisi)

单引号:不会转义字符,特殊字符不会被转义。(name: 'SimpleWun lisi' //输出:SimpleWun lisi)

server:  port: 8081

对象、Map

在YAML中,对象和Map都是以键值对的方式表示。在下一行来编写属性和值得关系,注意缩进。

users:  firstName: SimpleWu  email: lovelyWu98k@gmail.com

对象还有另一种写法,看到这种写法是不是想到了JSON?

users: {    firstName: zhangsan,    email: lovelyWu98k@gmail.com}

数组

用-值得方式来表示数组中的一个元素。

users:    - SimpleWu    - lovelyWu98k@gmail.com    - addressisnot

另外一种写法,还是像JSON

users: [SimpleWu,lovelyWu98k@gmail.com,addressisnot]

@Value标记读取(默认可直接读取application.yml的节点)

  首先在默认application.yml配置文件中自定义如下节点信息:

1 shenniu:
2   name: 神牛003

  然后通过@Value标记来直接获取属性值,为了更好的展示数据到界面上定义了一个/conf/name接口:

1     @Value("${shenniu.name}")
2     private String name;
3 
4     @GetMapping("/conf/defname")
5     public String getDefName() {
6         return this.name;
7     }

  运行后效果如:

  澳门新濠3559 2

<groupId>com.jd</groupId> <artifactId>sblearn</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging>
blog.address=https://blog.lqdev.cnblog.author=oKong
将配置映射到实体类

springboot支持我们直接将properties或者yml中的属性映射到某个实体类,看例子。

mysql:    url: jdbc:mysql:///springboot    port: 3306    user: root    pass: root

假如在资源中我们现在有个mysql的链接信息,我们如何将它映射到实体类中去呢?

有两种方式:

  • @ConfigurationProperties指定从配置文件中读取属性,prefix指定对应yaml文件中的名称。
  • @Value获取配置的属性值

@ConfigurationProperties

使用IDEA当我们添加了@ConfigurationProperties注解后,在页面上回出现一个错误提示,我们需要加入依赖。

<dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-configuration-processor</artifactId>    <optional>true</optional></dependency>

编写JAVA类MySQLInfo.java

//java类@ConfigurationProperties(prefix = "mysql")@Componentpublic class MySQLInfo {    private String url;    private Integer port;    private String user;    private String pass;    //省略getset}

我们只需要指定prefix即可,他就会加载我们yml配置前置为mysql的属性。

@Value

如果我们使用这个注解来获取属性使用方式是:

//java类@Componentpublic class MySQLInfo {    @Value("${mysql.url}")    private String url;    @Value("${mysql.port}")    private Integer port;    @Value("${mysql.user}")    private String user;    @Value("${mysql.pass}")    private String pass;    //省略getset}

注意如果需要使用表达式只有@Value才可以,@Value("#至于优先级后面再说澳门新濠3559,  今天和大家分享的是自定义配置信息的读取。{10*2}) 结果为:20

两种方式的区别:

@ConfigurationProperties @Value
功能 批量注入配置文件中的属性 一个个指定
松散绑定 支持 属性名必须完全匹配
SPEL表达式 不支持 支持
JSR303效验 支持 不支持
复杂类型 支持 不支持

两种方式的适用场合:

当只需要为某个值提供注入时,推荐使用@Value方式。

当需要对整个对象的整体进行赋值时,使用@ConfigurationProperties。

实体映射application.yml的节点

  要用实体类映射出默认配置文件值,仅仅只需要加一个属性名称前缀就行了,当然这仅仅针对于application.yml默认文件里面的属性:

 1 @Configuration
 2 @ConfigurationProperties(prefix = "shenniu")
 3 public class ShenniuConf {
 4 
 5     private String name;
 6 
 7     public String getName() {
 8         return name;
 9     }
10 
11     public void setName(String name) {
12         this.name = name;
13     }
14 
15     private Url url;
16 
17     public Url getUrl() {
18         return url;
19     }
20 
21     public void setUrl(Url url) {
22         this.url = url;
23     }
24 
25     private String des;
26 
27     public String getDes() {
28         return des;
29     }
30 
31     public void setDes(String des) {
32         this.des = des;
33     }
34 
35     public static class Url {
36 
37         private String blogurl;
38 
39         public String getBlogurl() {
40             return blogurl;
41         }
42 
43         public void setBlogurl(String blogurl) {
44             this.blogurl = blogurl;
45         }
46 
47     }
48 }

  实体类我多增加了几个属性,为了后面测试方便;要对application.yml做配置映射只需要加上 @ConfigurationProperties(prefix = "shenniu") 标记,prefix的值对应自定义配置文件属性的前缀;这里增加/conf/name接口输出映射出对象的值:

1 @Autowired
2     private ShenniuConf shenniuConf;
3 
4     @GetMapping("/conf/name")
5     public String getName() {
6         return shenniuConf.getName();
7     }

  同样得到了和@Values注解一样的效果,这就表示实体和配置文件自定义属性匹配成功了,主要实体属性名称应该和配置文件节点名称保持一致;

  澳门新濠3559 3

打包成可执行jar需要引入spring boot的插件

然后可通过@Value("${blog.author}")的形式获取属性值。

加载外部配置文件

如果我们将所有的配置信息都写在application.yml文件中,则到时候yml文件会变得非常庞大,不太方便我们进行维护。

我们可以对配置中的内容进行拆分,拆分到多个文件中。这样就提高了配置的可维护性。

引入外部配置文件:

  1. @PropertySource(value={"classpath:student.properties"})
  2. @ImportResource(locations={"classpath:spring.xml"}
  3. @Configuration和@Bean方式。(SpringBoot推荐方式)

第一种方式:@ProperSource方式:需要注入的类的前面使用该注解。

第二种方式:@ImportResource方式首先添加一个spring的配置文件,在里面添加需要映射的类。在启动的SpringBootApplication前面使用该注解

第三种方式:@Configuration和@Bean方式添加一个自定义配置类。

//第三种方式@Configurationpublic class MyConfig {    //将方法的返回值添加到容器中;容器中这个组件默认的id就是方法名    @Bean    public MySQLInfo mySQLInfo(){        System.out.println("配置类@Bean给容器中添加组件了...");        return new MySQLInfo();    }}

切换多个外部配置文件

真实环境中,有时候需要配置多个配置文件,可以使用spring.profile.active来进行切换。

比如现在我们有三个配置文件:

  • application.yml
  • application-dev.yml
  • application-prod.yml

我们在application.yml中通过spring.profile.active = dev来选择需要加装的配置文件。

或者我们可以通过maven将项目打成jar包通过命令行使用以下命令来指定环境

java –jar springboot02-0.0.1-SHAPSHOT.jar –spring.profiles.active=dev

文档块

在yml文档中,可以适用---来将一个文档拆分为多个文档块。可以在不同文档块中分别定义不同的环境。

然后通过spring.profiles=xxx来对文档块进行命名。最后通过第一个文档块制定spring.profiles.active=xxx来指定到底激活哪个文档块。

#application.ymlspring:   profiles:      active: dev #指定激活dev文档---server:    port: 8081spring:    profiles: dev #给文档命名为dev

配置文件加载位置和顺序

springboot启动会扫描一下位置的配置文件作为springboot的默认配置文件。

  1. 项目路径下的config文件夹
  2. 项目路径下
  3. classpath路径下config文件夹
  4. classpath路径下

以上是按照优先级从高到低的顺序,所有位置的文件都会被加载,如果冲突的情况,高优先级配置内容会覆盖低优先级配置内容。如果不冲突,形成互补配置。

我们也可以通过配置spring.config.location来改变默认配置。使用命令行方式加载,否则优先级不够。

java –jar xxxx.jar –spring.config.location=配置文件路径

外部配置加载顺序

pringBoot也可以从以下位置加载配置;优先级从高到低,高优先级的配置覆盖低优先级的配置,所有配置形成互补配置。

  1. 命令行参数
  2. 来自java:comp/env的JNDI属性
  3. Java系统属性(System.getProperties
  4. 操作系统环境变量
  5. RandomValuePropertySource配置的random.*属性值
  6. jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
  7. jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
  8. jar包外部的application.properties或application.yml(不带spring.profile)配置文件
  9. jar包内部的application.properties或application.yml(不带spring.profile)配置文件
  10. @Configuration注解类上的@PropertySource
  11. 通过SpringApplication.setDefaultProperties指定的默认属性

官方参考文档:

实体映射自定义配置文件的节点

  读取application.yml中属性值很简单,有时候需要自定义自己的配置文件,如这里我的my.properties,文件内容如下:

1 shenniu.des=我爱祖国
2 shenniu.url.blogurl=http://www.a.com

  映射的实体还是用上面的,不过实体上需要增加注解 @PropertySource("classpath:my.properties") 表示自定义文件源,并且同样需要prefix来指定节点前缀;我们增加如下展示接口:

1 @Autowired
2     private ShenniuConf shenniuConf;
3 
4     @GetMapping("/conf/des")
5     public String getDes() {
6         return shenniuConf.getDes();
7     }

  澳门新濠3559 4

<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
@RestControllerpublic class DemoController { @Value("${blog.address}") String address; @Value("${blog.author}") String author; @Value("${blog.desc}") String desc; @RequestMapping public String demo() { return desc; }}
springboot自动配置

SpringBoot启动会加载大量的自动配置类

我们看我们需要的功能有没有SpringBoot默认写好的自动配置类;

我们再来看这个自动配置类中到底配置了哪些组件;(只要我们要用的组件有,我们就不需要再来配置了)

给容器中自动配置类添加组件的时候,会从properties类中获取某些属性。我们就可以在配置文件中指定这些属性的值;

自动配置原理:SpringBoot启动的时候,加载主配置类,开启了自动配置功能@EnableAutoConfiguration。

利用EnableAutoConfigurationImportSelector给容器中导入一些组件。

导入的文件在都配置在文件META‐INF/spring.factories中的EnableAutoConfiguration属性来获取的。每一个这样的 xxxAutoConfiguration类都是容器中的一个组件,都加入到容器中;用他们来做自动配置。

每一个自动配置类进行自动配置功能;

根据当前不同的条件判断,决定这个配置类是否生效?

这些组件的属性是从对应的properties类中获取的,这些类里面的每一个属性又是和配置文件绑定的;

所有在配置文件中能配置的属性都是在xxxxProperties类中封装者‘;配置文件能配置什么就可以参照某个功能对应的这个属性类

实体映射多层级节点的值

  通常自定义配置节点都有层级关系,那我们实体有怎么来获取到不同层级的属性值呢,事实上只需要在实体类里面通过类层级关系来表示就行了,如上面ShenniuConf实体里面的Url实体类属性;

  澳门新濠3559 5

  这里添加一个测试接口:

1     @Autowired
2     private ShenniuConf shenniuConf;
3     
4     @GetMapping("/conf/myconf")
5     public ShenniuConf getBlogurl() {
6         return shenniuConf;
7     }

  不出意外能得到如下结果:

  澳门新濠3559 6

项目配置可以继承starter-parent,通常只需要指定parent的版本,其他需要的starter版本parent都会给出相应的版本

这里提醒下,在填写一些默认的比如,数据库属性时,可使用alt /的方式,IDE会自动显示提示,避免了手动嵌入属性值或者忘记属性的尴尬。

<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.4.RELEASE</version> </parent>

澳门新濠3559 7image

启动一个spring boot web项目还需要依赖

关于自定义属性时,特别是一些公用包,会使用到属性值时,建议在创建additional-spring-configuration-metadata.json属性元文件,这样在使用上述快捷方式时,会进行提示,包括属性名和属性说明,这样也方便调用者询问属性名是啥。

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId></dependency>

澳门新濠3559 8image澳门新濠3559 9image

这里解释一下starter,starter包含了需要的各种依赖也可以包含代码以及配置的元数据,由于有了starter,我们使用的时候就无需再去添加各种依赖,同时starter有许多默认的配置,比如默认使用内置tomcat,默认使用的端口号,默认的上下文路径,我们就无需再配置。

相关configuration-metadata说明可查看:

  1. <strong>认识代码和配置文件</strong>======项目的目录如下所示:澳门新濠3559 10项目创建过后,idea会生成一个spring boot启动类,启动类需要被@SpringBootApplication注解,同时在main函数里面启动应用(注:这是jar包的启动方式,如果使用本地tomcat war包启动,代码有差别)。

在配置文件中,各个属性参数可进行引用的,比如:

blog.address=https://blog.lqdev.cnblog.author=oKongblog.desc=${blog.author},${blog.address}
import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplicationpublic class SblearnApplication { public static void main(String[] args) { SpringApplication.run(SblearnApplication.class, args); }}

最后blog.desc的值即可:oKong,https://blog.lqdev.cn。利用此特性,并可实现一些特殊的功能。比如后期讲解spring cloud时,注册eurka注册中心的实例名时,并会使用类似如下配置,使得实例名一眼就知道哪台服务地址:

看一看@SpringBootApplication,该注解源代码如下,注意Java doc最后一句,该注解等价于@Configuration,@EnableAutoConfiguration,@ComponentScan

eureka.instance.instance-id=${spring.cloud.client.ipAddress}:${server.port}
/** * Indicates a {@link Configuration configuration} class that declares one or more * {@link Bean @Bean} methods and also triggers {@link EnableAutoConfiguration * auto-configuration} and {@link ComponentScan component scanning}. This is a convenience * annotation that is equivalent to declaring {@code @Configuration}, * {@code @EnableAutoConfiguration} and {@code @ComponentScan}. * * @author Phillip Webb * @author Stephane Nicoll * @since 1.2.0 */@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Inherited@SpringBootConfiguration@EnableAutoConfiguration@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })public @interface SpringBootApplication 

这里需要注意,由于springboot在读取properties文件时,使用的是PropertiesPropertySourceLoader类进行读取,默认读取的编码是ISO 8859-1,故在默认的配置文件中使用中文时,会出现乱码,此时可以将中文转成Unicode编码或者使用yml配置格式(默认就支持utf-8),再不济可以将作为配置写入到一个自定义配置文件,利用@PropertySource注解的encoding属性指定编码

第一是通过@SpringBootConfiguration表明该注解是一个@configuration注解的替代物,@configuration注解的部分java doc如下,可以看出该注解是告诉spring容器可以读取类里面被@Bean注解的方法并生成相应的bean。不难看出,如果启动类里面不包含需要添加到容器的bean,那么@SpringBootConfiguration可以省略

Spring Boot的属性配置文件中可以通过${random}来产生int值、long值或者string字符串,来支持属性的随机值。

* Indicates that a class declares one or more {@link Bean @Bean} methods and * may be processed by the Spring container to generate bean definitions and * service requests for those beans at runtime, for example: * * <pre > * @Configuration * public class AppConfig { * * @Bean * public MyBean myBean() { * // instantiate, configure and return bean ... * } * }
# 随机字符串.blog.value=${random.value}# 随机int.blog.number=${random.int}# 随机long.blog.bignumber=${random.long}# 10以内的随机数.blog.test1=${random.int}# 1-20的随机数.blog.test2=${random.int[1,20]}

@EnableAutoConfiguration则是告诉spring boot使用上下文自动配置,spring boot将会尽可能聪明的配置应用需要的bean。@ComponentScan则是扫描启动类路径下所有的bean,因此启动类要放在类路径最外层,保证所有bean都被扫描到。再看resource目录,分别包含static映射静态资源,templates包含模板文件,以及项目配置属性文件application.properties,此时配置文件为空。此时web项目已经可以启动,从这里至少可以看出,spring boot启用了内置tomcat帮我们完成配置,同时也不需要配置web.xml和spring mvc的一些基础配置,比如静态资源路径,mvc注解驱动

在多数情况下,配置信息基本上都是放入application.properties澳门新濠3559,文件中,但在一些场景下,比如某个配置项比较多时,为了分开存放,也可自定义配置文件,如my.properties。由于自定义的文件,系统不会自动加载,这个时候就需要手动引入了。利用@PropertySource注解既可以引入配置文件,需要引入多个时,可使用@PropertySources设置数组,引入多个文件。

<!-- 添加MVC注解模式 --> <mvc:annotation-driven/> <!-- 映射静态资源 --> <mvc:resources location="/WEB-INF/statics/" mapping="/resource/**"/>
@SpringBootApplication@PropertySource(value="classpath:my.properties",encoding="utf-8")public class Chapter3Application { public static void main(String[] args) { SpringApplication.run(Chapter3Application.class, args); }}

此外还将resources目录下的资源文件打包到了jar/war,不需要在pom里面另行配置。

虽然使用@Value()方式,能方便的引入自定义的属性值,但在多某个配置项属于某一配置时,希望对应到一个实体配置类中,springboot也提供了支持。利用@ConfigurationProperties属性,即可完成my.properties配置文件:

  1. <strong>spring boot的属性配置</strong>======spring boot的属性配置具有一定的优先级别,这里直接给出官方文档的内容:
config.code=codeconfig.name=趔趄的猿config.hobby[0]=看电影config.hobby[1]=旅游

实体类:

1. home目录下的devtools全局设置属性( ~/.spring-bootdevtools.properties ,如果devtools激活)。2. 测试用例上的@TestPropertySource注解。3. 测试用例上的@SpringBootTest#properties注解。4. 命令行参数5. 来自 SPRING_APPLICATION_JSON 的属性(环境变量或系统属性中内嵌的内联JSON)。6. ServletConfig 初始化参数。7. ServletContext 初始化参数。8. 来自于 java:comp/env 的JNDI属性。9. Java系统属性(System.getProperties。10. 操作系统环境变量。11. RandomValuePropertySource,只包含 random.* 中的属性。12. 没有打进jar包的Profile-specific应用属性( application-{profile}.properties 和YAML变量)。13. 打进jar包中的Profile-specific应用属性( application-{profile}.properties 和YAML变量)。14. 没有打进jar包的应用配置( application.properties 和YAML变量)。15. 打进jar包中的应用配置( application.properties 和YAML变量)。16. @Configuration 类上的 @PropertySource 注解。17. 默认属性(使用 SpringApplication.setDefaultProperties 指定)。
@Component//@EnableConfigurationProperties(value= {Config.class})@ConfigurationProperties(prefix="config")@Datapublic class Config { String code; String name; List<String> hobby;}

划重点,4在15,16确保了可以在命令行可以根据环境选择哪一个配置文件以及特定的属性配置。spring boot支持yml文件进行配置,个人比较支持这种新的方式,简洁明了。spring会加载application.yml,如果想要加载特定文件可以在application.yml里面提供如下配置:

这里可直接加入@Component使其在启动时被自动扫描到,或者使用@EnableConfigurationProperties注解注册此实体bean.其次,在引入@ConfigurationProperties时,IDE会提示你引入spring-boot-configuration-processor依赖,前面提到,在自定义属性时,创建additional-spring-configuration-metadata.json可进行属性提示,而此依赖功能类似,会编译时自动生成spring-configuration-metadata.json文件,此文件主要给IDE使用,用于提示使用。添加后在配置文件点击属性时,会自动跳转到对应绑定的实体类中

#需要额外引入其他配置文件的时候可以通过spring.profiles.include=a,b,其中a,b代表配置文件“-”后的部分,比如#applicaition-important.yml,那么就应该使用importantspring: profiles: active: dev include: important,log

澳门新濠3559 11image

这里在项目中已经存在application-dev.yml,application-important.yml,以及application-log.yml。该配置表示要激活application-dev.yml(默认是激活application-default.yml),同时引入application-important.yml,application-log.yml。也可以在命令行通过--spring.profiles.active=dev来进行激活。3.1 <strong>yml的使用</strong>

配置了以下配置,然后利用List<String>就能获取hobby的值了。

yml文件采用key:value的形式,比起properties文件更加简洁和直观,注意的是冒号后面需要一个空格。yml文件中可以引入已经定义的属性,如果是yml文件中的属性通过${}引入,如果是pom文件中的属性则使用@@,如下:

config.code=codeconfig.name=趔趄的猿config.hobby[0]=看电影config.hobby[1]=旅游
production: devboot: word: hey   ${production} name: jasonenv: basic: @env.demo.basic@

<profiles> <profile> <id>all-env</id> <activation> <activeByDefault>true</activeByDefault> </activation> <properties> <env.demo.basic>demo-basic-prop</env.demo.basic> </properties> </profile> </profiles>

澳门新濠3559 12image

spring boot可以使用random.*为配置文件生成随机值,这种方式利于测试

  • 个人QQ:499452441
  • 微信公众号:lqdevOps
my: secret: ${random.value} number: ${random.int} bignumber: ${random.long} number.less.than.ten: ${random.int} number.in.range: ${random.int[1024,65536]}

澳门新濠3559 13公众号

使用规则是random.int*语法是 OPEN value CLOSE ,此处 OPEN,CLOSE 可以是任何字符,并且 value,max 是整数。如果提供 max ,那么 value 是最小值, max 是最大值。3-3 <strong>属性值的使用</strong>

个人博客:

项目中的属性值都保存在上下文的enviroment中,要使用属性值有三种方式,第一种是使用@Value进行注入:

@Value("${env.basic}")private String basicProp;

第二种是使用@ConfigurationProperties通过在类或者方法上进行注解,参数prefix表示属性名的前缀,spring将会尽可能的将以拥有该前缀的数值型注入到类和方法返回对象中,下面注解到类上时,boot.word以及boot.name将可以注入到BootProperties类的实例上面。@ConfigurationProperties还可以和java提供的一些校验注解搭配使用,比如@NotEmpty

@ConfigurationProperties(prefix = "boot")@Componentpublic class BootProperties { @NotEmpty private String word; @NotEmpty private String name; public String getWord() { return word; } public BootProperties setWord(String word) { this.word = word; return this; } public String getName() { return name; } public BootProperties setName(String name) { this.name = name; return this; }

注解到方法上时,属性值将会注入到返回对象之中,比如下面datasource的配置,只要在配置文件中写好datasource相应的属性配置,@ConfigurationProperties就可以完成自动注入。

@Bean("masterDataSource") @Primary @ConfigurationProperties(prefix = "masterDb.dataSource") public DataSource getMasterDataSource() throws SQLException { DruidDataSource druidDataSource = new DruidDataSource(); //masterDataSourceProperties.setPropertyForDruid(druidDataSource); return druidDataSource; }

第三种方式是通过enviroment访问,如下通过实现了ApplicationContextAware接口,spring启动时将会调用setApplicationContext方法获取应用上下文,应用上下文可以访问项目的各种属性,包括java环境变量以及属性文件中加入的属性等

@Componentpublic class LocalApplicationContext implements ApplicationContextAware{ private static ApplicationContext applicationContext; @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.applicationContext = applicationContext; } public static String getPropertyByName(String name){ return applicationContext.getEnvironment().getProperty; } public static <T> T getBeanByName(String beanName){ return  applicationContext.getBean; } public static <T> T getBeanByType(Class<T> type){ return applicationContext.getBean; }}

某些组件对spring boot的支持不够好或者使用了自定义的一些xml标签,仍然需要通过xml文件进行配置,可以使用@ImportResource注解,方式如下,注意这里还需要使用@Configuration注解,有了它spring才回去扫描这个类。这样,jsf.xml中定义的bean都将注入到spring容器。

@Configuration@ImportResource(locations = {"classpath:jsf.xml"})public class AdditionalBeanConfig {}

在代码中也可以引入properties文件和yml文件,这里需要注意的是sprint boot暂时还不支持通过注解引入yml文件,通过@PropertySources或者@PropertySource都可以引入properties文件。

@Configuration//@PropertySources({@PropertySource, @PropertySource@PropertySource("classpath:/important.properties")public class ImportantProperty {}

如果一定要通过代码引入yml文件可以采用如下方式,首先定义yml文件的初始化器

/** * Created by admin360buyad on 2017-06-12. * 通过实现ApplicationContextInitializer来添加其他的yml文件,不过这种方式硬编码了 */public class YmlApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> { @Override public void initialize(ConfigurableApplicationContext applicationContext) { Resource resource = applicationContext.getResource( "classpath:/important.yml"); YamlPropertySourceLoader yamlPropertySourceLoader = new YamlPropertySourceLoader(); try { PropertySource<?> propertySource = yamlPropertySourceLoader .load("importantyml", resource, null); applicationContext.getEnvironment().getPropertySources() .addLast(propertySource); } catch (IOException e) { e.printStackTrace(); } }}

接下来在应用初始化时注册到应用

springApplication.addInitializers(new YmlApplicationContextInitializer;

不过以上两种方式不推荐使用,因为硬编码了。3-5 <strong>使用@Profile决定加载时机</strong>

@Profile可以作用到任何 的@Component 或 @Configuration,使得他们只有在特定的配置文件被激活时才会被spring进行处理。比如ProductionConfiguration类只有当spring.profiles.active=production时才会被spring处理。

@Configuration@Profile("production")public class ProductionConfiguration {// ...}
  1. <strong>springapplication的启动</strong>=========一般情况下我们按照如下的方式启动springapplication,启动前我们可以设置一些相关的属性,比如是否启用banner,是否设置web环境以及添加特定的初始化器
@SpringBootApplicationpublic class SelfDefApplication{ public static void main(String[] args) { SpringApplication springApplication = new SpringApplication(SelfDefApplication.class); springApplication.setBannerMode(Banner.Mode.OFF); //springApplication.setWebEnvironment; //springApplication.addInitializers(new YmlApplicationContextInitializer; springApplication.run; //bootByBuilder; }

我们看看构造函数的代码,通过java doc可以明白spring可以根据我们传入的sources来加载相关的bean。

/** * Create a new {@link SpringApplication} instance. The application context will load * beans from the specified sources (see {@link SpringApplication class-level} * documentation for details. The instance can be customized before calling * {@link #run(String...)}. * @param sources the bean sources * @see #run(Object, String[]) * @see #SpringApplication(ResourceLoader, Object...) */ public SpringApplication(Object... sources) { initialize; }

第二种方式是可以通过SpringApplicationBuilder的流式API进行创建,实质上底层都将调用SpringApplication的构造方法

public static void bootByBuilder(String[] args){ System.out.println("boot by builder"); new SpringApplicationBuilder(SelfDefApplication.class) .bannerMode(Banner.Mode.OFF) .run; }

前面两种方式都是使用内置的tomcat启动,我们可以通过配置文件或者自定义EmbeddedServletContainerCustomizer来设置tomcat的参数。

server: port: 8082

@Configurationpublic class CustomServletConfig { @Bean public EmbeddedServletContainerCustomizer getServletContainer(){ return new EmbeddedServletContainerCustomizer() { @Override public void customize(ConfigurableEmbeddedServletContainer container) { container.setPort; } }; }}

如果需要本地tomcat启动则需要继承SpringBootServletInitializer类,并且重写configure方法,将启动类添加到SpringApplicationBuilder的sources之中。通过这种方式启动自定义的SpringApplication类的main方法将不会得到执行。在代码中或者配置文件中设置的tomcat属性也会被自己配置的tomcat本身属性覆盖。

@Override protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) { builder.sources(this.getClass.bannerMode(Banner.Mode.OFF); return super.configure; }

除此之外我们需要在pom文件中排除tomcat的starter同时引入servlet的jar包

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <exclusions> <!--去掉内置tomcat--> <exclusion> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> </dependency>

如果想要在应用启动后做一些事情有三种方法,第一种是往bean的构造函数注入ApplicationArgumentsApplicationArguments是封装了命令行启动参数的对象

@Componentpublic class ApplicationArgumentsBean { @Autowired public ApplicationArgumentsBean(ApplicationArguments applicationArguments){ Set<String> names = applicationArguments.getOptionNames(); for(String name : names){ System.out.println(name   ":"   applicationArguments.getOptionValues; } }}

第二种方式是实现ApplicationRunner接口

@Component@Orderpublic class ApplicationRunnerImple implements ApplicationRunner { @Override public void run(ApplicationArguments args) throws Exception { Set<String> names = args.getOptionNames(); for(String name : names){ System.out.println(name   ":"   args.getOptionValues; } }}

第三种方式是实现CommandLineRunner接口,@Order会决定加载顺序,与ApplicationRunner 接口不同的是,CommandLineRunner的run方法参数是原始的命令行参数字符串

@Component@Orderpublic class CommandLineRunnerImpl implements CommandLineRunner{ @Override public void run(String... args) throws Exception { System.out.println("application has booted, the args is "); for(String arg : args){ System.out.println; } }}
  1. <strong>使用Log4j2</strong>=========springboot默认使用logback作为日志系统,如果想要使用log4j2需要从starter中exclude掉logging部分,同时引入Log4j2的starter
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <exclusions> <!--去掉boot自带的日志系统使用Log4j--> <exclusion> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-logging</artifactId> </exclusion> <!--去掉内置tomcat--> <exclusion> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> </exclusion> </exclusions></dependency><dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-log4j2</artifactId></dependency>

去掉Logging的starter过后也去掉了springboot本身需要的日志jar包,需要在pom中引入

<!--boot默认的日志系统是这个,去掉log的starter后需要重新引入--> <dependency> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> <version>1.2</version> </dependency>

关于Log4j2的配置文件可以使用xml也可以使用yml,使用yml的时候需要额外的添加一个jar包依赖,这样springboot才能解析yml中的配置

<!--解析log4j2.yml--> <dependency> <groupId>com.fasterxml.jackson.dataformat</groupId> <artifactId>jackson-dataformat-yaml</artifactId> <version>2.8.8</version> </dependency>

一个log4j2的简单配置如下:

Configuration: status: info appenders: Console: name: STDOUT PatternLayout: Pattern: "%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" Loggers: Root: level: info AppenderRef: ref: STDOUT

如果我们想看springboot使用了哪些默认配置,将日志级别该为debug就可看到,这里给出一部分日志内容:

Positive matches:----------------- DataSourceAutoConfiguration matched: - @ConditionalOnClass found required classes 'javax.sql.DataSource', 'org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) DataSourceAutoConfiguration#dataSourceInitializer matched: - @ConditionalOnMissingBean (types: org.springframework.boot.autoconfigure.jdbc.DataSourceInitializer; SearchStrategy: all) did not find any beans (OnBeanCondition) DataSourceConfiguration.Tomcat matched: - @ConditionalOnClass found required class 'org.apache.tomcat.jdbc.pool.DataSource'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) - @ConditionalOnProperty (spring.datasource.type=org.apache.tomcat.jdbc.pool.DataSource) matched (OnPropertyCondition) DataSourcePoolMetadataProvidersConfiguration.TomcatDataSourcePoolMetadataProviderConfiguration matched: - @ConditionalOnClass found required class 'org.apache.tomcat.jdbc.pool.DataSource'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) DataSourceTransactionManagerAutoConfiguration matched: - @ConditionalOnClass found required classes 'org.springframework.jdbc.core.JdbcTemplate', 'org.springframework.transaction.PlatformTransactionManager'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) DataSourceTransactionManagerAutoConfiguration.DataSourceTransactionManagerConfiguration matched: - @ConditionalOnSingleCandidate (types: javax.sql.DataSource; SearchStrategy: all) found a primary bean from beans 'masterDataSource', 'clusterDataSource' (OnBeanCondition) DefaultValidatorConfiguration#defaultValidator matched: - @ConditionalOnMissingBean (types: javax.validation.Validator,org.springframework.validation.Validator; SearchStrategy: all) did not find any beans (OnBeanCondition) DispatcherServletAutoConfiguration matched: - @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) - @ConditionalOnWebApplication  found StandardServletEnvironment (OnWebApplicationCondition) DispatcherServletAutoConfiguration.DispatcherServletConfiguration matched: - @ConditionalOnClass found required class 'javax.servlet.ServletRegistration'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) - Default DispatcherServlet did not find dispatcher servlet beans (DispatcherServletAutoConfiguration.DefaultDispatcherServletCondition) DispatcherServletAutoConfiguration.DispatcherServletRegistrationConfiguration matched: - @ConditionalOnClass found required class 'javax.servlet.ServletRegistration'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) - DispatcherServlet Registration did not find servlet registration bean (DispatcherServletAutoConfiguration.DispatcherServletRegistrationCondition) DispatcherServletAutoConfiguration.DispatcherServletRegistrationConfiguration#dispatcherServletRegistration matched: - @ConditionalOnBean (names: dispatcherServlet; types: org.springframework.web.servlet.DispatcherServlet; SearchStrategy: all) found beans 'dispatcherServlet', 'dispatcherServlet' (OnBeanCondition) EmbeddedServletContainerAutoConfiguration matched: - @ConditionalOnWebApplication  found StandardServletEnvironment (OnWebApplicationCondition) EmbeddedServletContainerAutoConfiguration.EmbeddedTomcat matched: - @ConditionalOnClass found required classes 'javax.servlet.Servlet', 'org.apache.catalina.startup.Tomcat'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) - @ConditionalOnMissingBean (types: org.springframework.boot.context.embedded.EmbeddedServletContainerFactory; SearchStrategy: current) did not find any beans (OnBeanCondition) ErrorMvcAutoConfiguration matched: - @ConditionalOnClass found required classes 'javax.servlet.Servlet', 'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) - @ConditionalOnWebApplication  found StandardServletEnvironment (OnWebApplicationCondition) ErrorMvcAutoConfiguration#basicErrorController matched: - @ConditionalOnMissingBean (types: org.springframework.boot.autoconfigure.web.ErrorController; SearchStrategy: current) did not find any beans (OnBeanCondition) ErrorMvcAutoConfiguration#errorAttributes matched: - @ConditionalOnMissingBean (types: org.springframework.boot.autoconfigure.web.ErrorAttributes; SearchStrategy: current) did not find any beans (OnBeanCondition) ErrorMvcAutoConfiguration.DefaultErrorViewResolverConfiguration#conventionErrorViewResolver matched: - @ConditionalOnBean (types: org.springframework.web.servlet.DispatcherServlet; SearchStrategy: all) found bean 'dispatcherServlet'; @ConditionalOnMissingBean (types: org.springframework.boot.autoconfigure.web.DefaultErrorViewResolver; SearchStrategy: all) did not find any beans (OnBeanCondition) ErrorMvcAutoConfiguration.WhitelabelErrorViewConfiguration matched: - @ConditionalOnProperty (server.error.whitelabel.enabled) matched (OnPropertyCondition) - ErrorTemplate Missing did not find error template view (ErrorMvcAutoConfiguration.ErrorTemplateMissingCondition) ErrorMvcAutoConfiguration.WhitelabelErrorViewConfiguration#beanNameViewResolver matched: - @ConditionalOnMissingBean (types: org.springframework.web.servlet.view.BeanNameViewResolver; SearchStrategy: all) did not find any beans (OnBeanCondition) ErrorMvcAutoConfiguration.WhitelabelErrorViewConfiguration#defaultErrorView matched: - @ConditionalOnMissingBean (names: error; SearchStrategy: all) did not find any beans (OnBeanCondition) GenericCacheConfiguration matched: - Cache org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration automatic cache type (CacheCondition) GuavaCacheConfiguration matched: - @ConditionalOnClass found required classes 'com.google.common.cache.CacheBuilder', 'org.springframework.cache.guava.GuavaCacheManager'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) - Cache org.springframework.boot.autoconfigure.cache.GuavaCacheConfiguration automatic cache type (CacheCondition) HttpEncodingAutoConfiguration matched: - @ConditionalOnClass found required class 'org.springframework.web.filter.CharacterEncodingFilter'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) - @ConditionalOnWebApplication  found StandardServletEnvironment (OnWebApplicationCondition) - @ConditionalOnProperty (spring.http.encoding.enabled) matched (OnPropertyCondition) HttpEncodingAutoConfiguration#characterEncodingFilter matched: - @ConditionalOnMissingBean (types: org.springframework.web.filter.CharacterEncodingFilter; SearchStrategy: all) did not find any beans (OnBeanCondition) HttpMessageConvertersAutoConfiguration matched: - @ConditionalOnClass found required class 'org.springframework.http.converter.HttpMessageConverter'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) HttpMessageConvertersAutoConfiguration.StringHttpMessageConverterConfiguration matched: - @ConditionalOnClass found required class 'org.springframework.http.converter.StringHttpMessageConverter'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) HttpMessageConvertersAutoConfiguration.StringHttpMessageConverterConfiguration#stringHttpMessageConverter matched: - @ConditionalOnMissingBean (types: org.springframework.http.converter.StringHttpMessageConverter; SearchStrategy: all) did not find any beans (OnBeanCondition) JacksonAutoConfiguration matched: - @ConditionalOnClass found required class 'com.fasterxml.jackson.databind.ObjectMapper'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) JacksonAutoConfiguration.Jackson2ObjectMapperBuilderCustomizerConfiguration matched: - @ConditionalOnClass found required classes 'com.fasterxml.jackson.databind.ObjectMapper', 'org.springframework.http.converter.json.Jackson2ObjectMapperBuilder'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) JacksonAutoConfiguration.JacksonObjectMapperBuilderConfiguration matched: - @ConditionalOnClass found required classes 'com.fasterxml.jackson.databind.ObjectMapper', 'org.springframework.http.converter.json.Jackson2ObjectMapperBuilder'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) JacksonAutoConfiguration.JacksonObjectMapperBuilderConfiguration#jacksonObjectMapperBuilder matched: - @ConditionalOnMissingBean (types: org.springframework.http.converter.json.Jackson2ObjectMapperBuilder; SearchStrategy: all) did not find any beans (OnBeanCondition) JacksonAutoConfiguration.JacksonObjectMapperConfiguration matched: - @ConditionalOnClass found required classes 'com.fasterxml.jackson.databind.ObjectMapper', 'org.springframework.http.converter.json.Jackson2ObjectMapperBuilder'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition) JacksonAutoConfiguration.JacksonObjectMapperConfiguration#jacksonObjectMapper matched: - @ConditionalOnMissingBean (types: com.fasterxml.jackson.databind.ObjectMapper; SearchStrategy: all) did not find any beans (OnBeanCondition)
  1. <strong>配置Mybatis双数据源</strong>=========这里数据源使用druid,数据库使用mysql,引入mybatis的starter,pom配置如下:
<!--数据库--> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.0.29</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.3.0</version> </dependency>

为了使用双数据源,在配置文件中我们设置两套数据库配置,一套是master,一套是cluster,前缀分别使用masterDb.dataSource和clusterDb.dataSource,同时给出两套不同的mybatis别名和mapper文件路径的配置。

masterDb: dataSource: url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8 username: root password: 123456 driverClassName: com.mysql.jdbc.Driver filters: stat maxActive: 20 initialSize: 1 maxWait: 60000 minIdle: 1 timeBetweenEvictionRunsMillis: 60000 minEvictableIdleTimeMillis: 300000 validationQuery: select 'x' testWhileIdle: true testOnBorrow: false testOnReturn: false poolPreparedStatements: true maxOpenPreparedStatements: 20 mapperLocations: classpath:mapper/master/*.xml typeAliasesPackage: com.example.domain.masterclusterDb: dataSource: url: jdbc:mysql://127.0.0.1:3306/seckill?useUnicode=true&characterEncoding=utf8 username: root password: 123456 driverClassName: com.mysql.jdbc.Driver filters: stat maxActive: 20 initialSize: 1 maxWait: 60000 minIdle: 1 timeBetweenEvictionRunsMillis: 60000 minEvictableIdleTimeMillis: 300000 validationQuery: select 'x' testWhileIdle: true testOnBorrow: false testOnReturn: false poolPreparedStatements: true maxOpenPreparedStatements: 20 mapperLocations: classpath:mapper/cluster/*.xml typeAliasesPackage: com.example.domain.cluster basePackage: com.example.dao.cluster

将配置引入到代码中仍然是通过@Configuration注解的配置类,第一点需要注意的是这里我们需要引入@MapperScan注解,给出dao层包的位置,mybatis会自动实现该路径下的所有接口,实现方式是根据类名与同名的mapper文件匹配,将类里面的方法名和mapper文件内的sql语句匹配并以此实现该接口,典型的约定大于配置哈!第二点是可以看出完成mybatis的配置需要数据源的配置,sessionfactory的配置以及事务管理器的配置。第三点是增加@Primary注解表明该数据源配置为最高优先,在cluster的配置中不需要改注解。第四点是注意使用不同的bean名称。这样我们已经可以在一个应用中使用两套数据源配置了。

/** * Created by admin360buyad on 2017-06-07. * 多数据源配置,配置主数据源 * spring容器可以自动识别哪些Bean需要先装配,下面的代码中,spring首先会注入masterDataSource * 接下来才是masterSqlSessionFactory和masterDataSourceTm */@Configuration@MapperScan(basePackages = "com.example.dao.master", sqlSessionFactoryRef = "masterSqlSessionFactory")public class MasterDbConfig { /** * mybatis自动扫描该包下的domain并且根据类名的首字母小写设置别名 */ @Value("masterDb.dataSource.typeAliasPackage") private String typeAliasPackage; /** * mybatis mapper文件的地址 */ @Value("masterDb.dataSource.mapperLocations") private String mapperLocations; @Bean("masterDataSource") @Primary @ConfigurationProperties(prefix = "masterDb.dataSource") public DataSource getMasterDataSource() throws SQLException { DruidDataSource druidDataSource = new DruidDataSource(); //masterDataSourceProperties.setPropertyForDruid(druidDataSource); return druidDataSource; } @Bean("masterSqlSessionFactory") @Primary public SqlSessionFactory getMasterSqlSessionFactory(@Qualifier("masterDataSource") DataSource dataSource) throws Exception { SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean(); factoryBean.setDataSource(dataSource); factoryBean.setTypeAliasesPackage(typeAliasPackage); factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver() .getResources(mapperLocations)); return factoryBean.getObject(); } @Bean("masterDataSourceTm") @Primary public DataSourceTransactionManager getTransactionManager(@Qualifier("masterDataSource") DataSource dataSource) throws SQLException { return new DataSourceTransactionManager(dataSource); }}
  1. <strong>配置velocity</strong>=========springboot的最新版本默认已经不支持velocity,所以需要我们通过@Configuration自动配置,首先引入velocity的starter
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-velocity</artifactId> <version>1.4.6.RELEASE</version></dependency>

接下来是配置类,我们需要提供VelocityViewResolver和VelocityConfigurer两个bean。这里对VelocityViewResolver使用了@Order表明spring mvc会尝试首先使用该viewResolver来返回请求(如果存在比1的值更低的order将具有更高优先级),所有的viewResolver都将被ContentNegotiatingViewResolver管理,ContentNegotiatingViewResolver本身不对请求处理,只负责管理其他viewResolver,并且在其初始化时将获取spring容器中所有的viewResolver

@Configurationpublic class VelocityConfig { @Bean("velocityViewResolver") @Order public ViewResolver getViewResolver(){ VelocityViewResolver resolver = new VelocityViewResolver(); resolver.setSuffix; return resolver; } @Bean("velocityConfigurer") public VelocityConfigurer getVelocityConfigurer(){ VelocityConfigurer configurer = new VelocityConfigurer(); configurer.setResourceLoaderPath("classpath:/templates/"); configurer.setConfigLocation(new PathMatchingResourcePatternResolver() .getResource("classpath:/properties/velocity.properties")); return configurer; }}
  1. <strong>spring mvc的一些配置</strong>=========spring mvc静态资源的配置可以写在配置文件
resources: static-locations: classpath:/statics/ mvc: static-path-pattern: /resource/**

下载上传的限制也可以

spring: http: multipart: max-file-size: 2MB

spring boot提供了很多默认的mvc配置,如果我们想要修改都可以通过在配置温江中自己配置。

  1. <strong>springboot测试</strong>=========一个简单的spring boot测试代码如下所示
@RunWith(SpringRunner.class)@SpringBootTest(classes = DemoApplication.class, webEnvironment = SpringBootTest.WebEnvironment.MOCK)public class DemoApplicationTests { @Autowired private HobbyDao hobbyDao; @Test public void contextLoads() { } @Test public void testHobbyDao(){ System.out.println(JSON.toJSONString(hobbyDao.selectAllHobby; }}

第一步通过@RunWith配置SpringRunner,第二步则是通过@SpringBootTest注解配置测试的启动信息,先看第一个参数classes,其java doc如下,可以看出其作用是通过参数类加载一个spring的上下文,如果改参数未指定将在该测试类内部寻找可加载的配置类

/** * The <em>annotated classes</em> to use for loading an * {@link org.springframework.context.ApplicationContext ApplicationContext}. Can also * be specified using * {@link ContextConfiguration#classes() @ContextConfiguration(classes=...)}. If no * explicit classes are defined the test will look for nested * {@link Configuration @Configuration} classes, before falling back to a * {@link SpringBootConfiguration} search. * @see ContextConfiguration#classes() * @return the annotated classes used to load the application context */

第二个参数是webEnvironment ,java doc如下,意思是我们创建web环境的类型,默认是一个mock,选项包括

/** * Creates a {@link WebApplicationContext} with a mock servlet environment or a * regular {@link ApplicationContext} if servlet APIs are not on the classpath. */ MOCK, /** * Creates an {@link EmbeddedWebApplicationContext} and sets a * {@code server.port=0} {@link Environment} property (which usually triggers * listening on a random port). Often used in conjunction with a * {@link LocalServerPort} injected field on the test. */ RANDOM_PORT, /** * Creates an {@link EmbeddedWebApplicationContext} without defining any * {@code server.port=0} {@link Environment} property. */ DEFINED_PORT, /** * Creates an {@link ApplicationContext} and sets * {@link SpringApplication#setWebEnvironment} to {@code false}. */ NONE;

该注解还包括如下两个参数用于自定义一些需要使用的属性配置

/** * Alias for {@link #properties()}. * @return the properties to apply */ @AliasFor("properties") String[] value() default {}; /** * Properties in form {@literal key=value} that should be added to the Spring * {@link Environment} before the test runs. * @return the properties to add */ @AliasFor String[] properties() default {};

编辑:编程 本文来源:至于优先级后面再说澳门新濠3559,  今天和大

关键词: 澳门新濠3559