SpringBoot系列四：SpringBoot开发（改变环境属性、读取资源文件、Bean 配置、模版渲染、profile 配置）

时间 2020-05-08

标签 springboot 系列开发改变环境属性读取资源文件 bean 配置模版渲染 profile 栏目 Spring 繁體版

原文原文链接

声明：本文来源于MLDN培训视频的课堂笔记，写在这里只是为了方便查阅。css

一、概念html

SpringBoot 开发深刻java

二、具体内容 web

在以前已经基本上了解了整个 SpringBoot 运行机制，可是也须要清楚的认识到如下的问题，在实际的项目开发之中，尤为是 Java 的 MVC 版项目里面，全部的项目都必定须要知足于以下几点要求：spring

· 访问的端口不可以是 8080，应该使用默认的 80 端口；服务器

· 在项目之中为了方便进行数据的维护，建议创建一系列的*.properties 配置文件，例如：提示消息、跳转路径；app

· 全部的控制器如今都采用了 Rest 风格输出，可是正常来说，信息的显示应该交给页面（再也不是 JSP）负责完成；框架

· 在进行项目打包的时候应该考虑到不一样的 profile 配置（不一样的环境使用不一样的端口访问，如生产环境80端口，beta环境8090端口，dev环境8080端口）。jsp

2.一、改变环境属性maven

经过当前的执行能够发现，默认状况下，在 SpringBoot 里面启动 WEB 容器为 Tomcat：

INFO 4448 --- [ restartedMain] o.s.j.e.a.AnnotationMBeanExporter : Registering beans for JMX exposure on startup

INFO 4448 --- [ restartedMain] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)

从实际的开发来说，咱们的 WEB 部署项目若是是单独运行不可能运行在 8080 端口上。从正常来说咱们的服务器应该运行在80 端口上，因此若是要想修改这样的默认环境，则必须编写与之对应的配置文件，该配置文件必定要写在 classpath 之中，例如：项目中的“src/main/resources”就是一个 classpath 路径，那么在这个目录之中直接建立有一个 application.properties（文件名称绝对不要改变）。

范例：定义 application.properties 配置文件

1 # 设置Tomcat的运行服务所在端口
2 
3 server.port=80

随后从新运行程序会出现有以下的提示信息：“Tomcat started on port(s): 80 (http)”。

范例：若是有须要也能够配置 contextPath 的信息

# 设置Tomcat的运行服务所在端口
server.port=80
# 能够配置ContextPath访问路径，可是在实际开发之中是不可以进行配置的
server.context-path=/hello

此时的访问路径须要追加 contextPath 前缀：http://localhost/hello/；

严格来说在 SpringBoot、SpringCloud 里面可使用两类配置文件：application.properties、application.yml。

YAML 文件： 这是一种结构化的数据文件，其在不少的地方上都使用过，例如：Apache Storm 开发组件上进行配置的时候使用的就是yml 配置文件,该配置文件的全称（Yet Another Markup Languange、仍然是一种标记语言）。

范例：定义 application.yml 配置文件

server:
 port: 80 # 此处设置的服务的访问端口配置

若是 application.properties 和 application.yml 两个文件同时存在使用那个？

那么这个时候将优先进行application.properties配置文件的加载，若是如今两个配置项的做用冲突了，则以 properties 为主，若是不冲突，则以存在的为主。

在以前默认使用的 WEB 容器是 Tomcat 容器，实际上在 SpringBoot 里面若是用户有须要也能够将容器更换为 jetty 容器，若是如今要想使用这个容器，则只须要追加一些依赖便可：

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

若是在之后项目以微服务的方式进行打包发布的时候，强烈建议你们使用 jetty 服务进行发布。

2.二、读取资源文件

在实际的项目开发之中资源文件必定不可或缺，由于全部的提示文字信息都要求在资源文件之中进行定义，并且资源文件是实现国际化技术的主要手段。若是要想在 SpringBoot 里面进行资源文件的配置只须要作一些简单的 application.yml 配置便可，并且全部注入的资源文件均可以像最初的 Spring 处理那样直接使用 MessageSource 进行读取。

一、为了统一管理资源文件，在“src/main/resources”目录之中创建有一个 i18n 的存储目录；

二、在“src/main/resources/i18n”目录之中创建有两个资源文件：

· 创建 Messages.properties：

welcome.url=www.study.cn
welcome.msg=欢迎{0}光临！

· 创建 Pages.properties 配置文件：

member.add.page=/pages/back/admin/member/member_add.jsp
member.add.action=/pages/back/admin/member/member_add.action

三、修改 application.yml 配置文件：

spring:     # 表示该配置直接为Spring容器负责处理
  messages: # 表示进行资源配置
    basename: i18n/Messages,i18n/Pages  # 资源文件的名称
server:
  port: 80      # 此处设置的服务的访问端口配置

四、当执行完以上的配置以后会自动为用户建立 MessageSource 对象，那么用户在使用的时候直接注入此对象便可。

· 考虑到实际开发的标准型，因此如今建议建立一个父的控制器的抽象类；AbstractBaseController，然后在此抽象类之中进行资源读取类的配置；

package cn.study.microboot.util.controller;

import java.util.Locale;

import javax.annotation.Resource;

import org.springframework.context.MessageSource;

public abstract class AbstractBaseController {
    @Resource
    private MessageSource messageSource; // 自动注入此资源对象
    public String getMessage(String key, String... args) {
        return this.messageSource.getMessage(key, args, Locale.getDefault()); 
    }
}

五、在控制器的子类之中读取以上的配置信息：

package cn.study.microboot.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import cn.mldn.microboot.util.controller.AbstractBaseController;

@RestController
public class MessageController extends AbstractBaseController {
    @RequestMapping(value = "/echo", method = RequestMethod.GET)
    public String echo(String mid) {
        System.out.println("【*** 访问地址 ***】" + super.getMessage("member.add.action"));
        return super.getMessage("welcome.msg", mid);
    }
}

六、编写一个 junit 测试类，来测试以上的控制器程序是否正确：

package cn.study.microboot.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;

import cn.mldn.microboot.StartSpringBootMain;
import cn.mldn.microboot.controller.MessageController;

@SpringBootTest(classes = StartSpringBootMain.class)
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
public class TestMessageController {
    @Resource
    private MessageController messageController;
    @Test
    public void testEcho() {
        System.out.println(this.messageController.echo("lgs"));
    }
}

输出：

【*** 访问地址 ***】/pages/back/admin/member/member_add.action
欢迎lgs光临！

经过 SpringBoot 执行能够清楚的发现，在 SpringBoot 里面全部对象信息的注入配置操做，都直接经过一行简单的字符串实现了，并且最终也可以保持与以前一样的运行效果。

2.三、Bean 配置

在使用 Spring 进行开发配置的时候有两类选择：*.xml 配置文件、配置的 Bean（@Configure），因而在 SpringBoot 的开发世界里面，为了继续崇尚所谓的“零配置”，提供有一种简单的支持，也就是说若是如今你真的有配置须要经过*.xml 文件编写，可是又不想出现配置文件的话，这个时候最简单的作法就是使用 Bean 的方式来进行类的配置。

前提：该配置程序的 Bean 所在的包必须是程序启动类所在包的子包之中，这样才能够自动扫描到。

1.在传统的开发中咱们通常使用注解@service和@Resource便可完成bean的配置和注入

2.在SpringBoot中使用@Configuration和@Bean配置bean

package cn.study.microboot.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import cn.mldn.microboot.service.impl.MessageServiceImpl;

@Configuration    // 此处为配置项
public class ServiceConfig {
    @Bean(name="configService")        // 此处返回的是一个Spring的配置Bean，与xml的“<bean>”等价
    public MessageServiceImpl getMessageService() {    // 方法名称随便写
        return new MessageServiceImpl() ;
    }
}

此时采用了自动扫描 Bean 的模式来进行了相关对象的配置。

三、 SSM 或 SSH 开发框架出现的时间比较长，如今迁移到 SpringBoot 之中，那么若是说如今你已经有一个很是完善的 xml 配置文件出现了，那么难道还须要将整个的 xml 配置文件转换为 Bean 配置吗？为了防止这类状况出现， SpringBoot 也支持有配置文件的读取，例如：下面建立一个 spring-common.xml 配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="messageService" class="cn.mldn.microboot.service.impl.MessageServiceImpl" />
</beans>

四、随后能够在程序启动类上使用 xml 进行配置加载：

package cn.study.microboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;
@SpringBootApplication    // 启动SpringBoot程序，然后自带子包扫描
@ImportResource(locations={"classpath:spring-common.xml"})
public class StartSpringBootMain {
    public static void main(String[] args) throws Exception {
        SpringApplication.run(StartSpringBootMain.class, args);
    }
}

若是此时所配置的两个 bean 都没有名字那么在进行注入的时候必定会出现重复的错误，而这个错误在新版本里面将其作了完善，不过若是要想在开发之中准确的注入指定的对象，则须要使用名字完成：

@Resource(name="messageService")
private IMessageService messageService ;

2.四、模版渲染

在以前所见到的信息显示发现都是以 Rest 风格进行显示，可是很明显在实际的开发之中，全部数据的显示最终都应该交由页面完成，可是这个页面并非*.jsp 页面，而是普通的*.html 页面，并且最为重要的是，此处所使用的渲染的页面采用的是模版方式的显示，而在 Java 开发行业，对于前台的显示模版常见的一共有三类技术：FreeMarker、Velocity、thymeleaf（推荐使用），因而下面就利用 thymeleaf 实现一个简单的模版渲染操做。

一、若是要想在项目之中去使用 thymeleaf 模版，那么应该首先进行相关支持依赖库的导入，修改 pom.xml 配置文件：

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

二、本次的开发依然要经过一个控制层跳转到页面之中进行信息显示。在 SpringMVC 的时代使用的是 ModelAndView 传递，而现在在 SpringBoot 里面若是要传递直接在方法中定义一个 Model 参数便可。

package cn.study.microboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import cn.mldn.microboot.util.controller.AbstractBaseController;

@Controller
public class MessageController extends AbstractBaseController {
    @RequestMapping(value = "/show", method = RequestMethod.GET)
    public String show(String mid, Model model) {
        model.addAttribute("url", "www.study.cn"); // request属性传递包装
        model.addAttribute("mid", mid); // request属性传递包装
        return "message/message_show"; // 此处只返回一个路径， 该路径没有设置后缀，后缀默认是*.html
    }
}

三、如今的控制器之中使用的是“@Controller”注解，因此此时执行该控制器的方法后会进行跳转处理。若是如今要进行跳转页面的定义，有严格要求：在CLASSPATH路径下（src/main/resources、src/main/view）必须创建有一个templates的目录，在这个目录里面保存有thymeleaf的全部相关页面，这些页面能够按照文件目录保存；

创建一个源代码目录：src/main/view；

四、编写 message_show.html 页面（重要提示：该页面编写的时候全部的元素必定要完结）

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>SpringBoot模版渲染</title>
<meta http-equiv="Content-Type" content="text/html;charset=UTF-8"/>
</head>
<body>
<p th:text="'官方网站：' + ${url}"/>
<p th:text="'用户名：' + ${mid}"/>
</body>
</html>

五、运行服务，然后输入访问路径：http://localhost/show?mid=lgs；

六、若是如今咱们所定义的要访问的页面不是经过控制器跳转的怎么办？那么为了解决这样的问题，能够考虑在 thymeleaf 所在的父路径之中“src/main/view”创建一个 static 的子目录，该目录保存的是全部静态页面；

在之后的实际开发之中，像 js、css、images 等信息文件都要求放在 static 目录里面。

七、 thymeleaf 默认的访问的页面路径的后缀为*.html，那么也能够经过修改 application.yml 配置文件进行变动：

spring:     # 表示该配置直接为Spring容器负责处理
  thymeleaf:
    suffix: .htm
  messages: # 表示进行资源配置
    basename: i18n/Messages,i18n/Pages  # 资源文件的名称
server:
  port: 80      # 此处设置的服务的访问端口配置

这个时候你须要修改“src/main/view/templates/message”下的 message_show.html 页面为 message_show.htm 才能够正常访问。

2.五、profile 配置

在实际的开发之中，因为开发（dev）、测试（beta）、运行（product）的环境不一样，有可能须要选择不一样的配置文件，因此在 SpringBoot 里面充分的考虑到了此类问题，那么就专门提供有多个 profile 配置，可是对于多 profile 配置必定给要区分出是 yml 还是 properties，这两种资源的配置是不一样的。

一、基于 yml 实现 profile 的配置处理：

· 在使用 yml 配置文件的时候全部可使用的 profile 配置项都要求在一个文件之中编写；

spring:
  profiles:
    active: product
---
spring:
  messages:
    basename: i18n/Messages,i18n/Pages
  profiles: dev
server:
  port: 8080
---
spring:
  messages:
    basename: i18n/Messages,i18n/Pages
  profiles: beta
server:
  port: 9090
---
spring:
  messages:
    basename: i18n/Messages,i18n/Pages
  profiles: product
server:
  port: 80

最初进行 profile 切换的处理能够经过 maven 的编译工具动态选择，可是在 Spring 里面能够方便的实现这种切换。

二、此时全部的 thymeleaf 页面都保存在“src/main/view”目录之中，并且全部的 SpringBoot 配置文件（*.yml）这个文件也应该都一块儿输出到 jar 文件里面，那么就须要配置一个资源的引用，修改“microboot”中的 pom.xml 配置文件：

<resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.yml</include>
                    <include>**/*.xml</include>
                    <include>**/*.tld</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                    <include>**/*.tld</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/view</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>

三、随后能够将项目进行打包处理，在打包以后也能够动态切换 profile 配置；

· Maven 打包：clean package；

· 随后若是如今要使用默认的 profile 就正常执行：java -jar microboot.jar；

· 难道之后每一次访问都须要从新打包吗？也就是说为了方便用户的动态进行 profile 切换，能够在程序执行的时候设置一个执行的处理参数：java -jar microboot.jar --spring.profiles.active=beta；

四、【趣味问题】如今当运行完成以后你会发现程序之中默认采用的图标是 Spring 的图标。

可是不少的公司应该去更换为本身的图标，因此这个时候能够单独准备出一个 ico 配置文件，能够将这个配置文件拷贝到 “src/main/view/static/images”目录之中，随后在页面之中进行引入：

<link rel="icon" type="image/x-icon" href="/images/study.ico"/>

五、在进行 profile 配置的时候特别须要注意一点，若是你使用的是 application.properties 配置，这样的配置处理过程是不同的，也就是说若是你基于属性文件完成配置，那么就须要编写多个属性文件内容：

随后仍是须要有一个公共的 application.properties 配置文件出现，用于指派可使用的 profile 配置：

spring.profiles.active=beta

若是如今将开发程序打成*.jar 文件的话，也一样能够在执行的时候使用“--spring.profiles.active=beta”动态指派不一样的 profile 配置文件。