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

1、概念

    SpringBoot 开发深入

2、具体内容

在之前已经基本上了解了整个 SpringBoot 运行机制，但是也需要清楚的认识到以下的问题，在实际的项目开发之中，尤其是 Java 的 MVC 版项目里面，所有的项目都一定需要满足于如下几点要求：

· 访问的端口不能够是 8080，应该使用默认的 80 端口；

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

· 所有的控制器现在都采用了 Rest 风格输出，但是正常来讲，信息的显示应该交给页面（不再是 JSP）负责完成；

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

2.1、改变环境属性

通过当前的执行可以发现，默认情况下，在 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 配置文件

# 设置Tomcat的运行服务所在端口
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.2、读取资源文件

在实际的项目开发之中资源文件一定不可或缺，因为所有的提示文字信息都要求在资源文件之中进行定义，而且资源文件是 实现国际化技术的主要手段。如果要想在 SpringBoot 里面进行资源文件的配置只需要做一些简单的 application.yml 配置即可，而且 所有注入的资源文件都可以像最初的 Spring 处理那样直接使用 MessageSource 进行读取。

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

2、 在“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

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

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

4、 当执行完以上的配置之后会自动为用户创建 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()); 
    }
}

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

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);
    }
}

6、 编写一个 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.3、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 的模式来进行了相关对象的配置。

3、 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>

4、 随后可以在程序启动类上使用 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.4、模版渲染

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

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

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

2、 本次的开发依然要通过一个控制层跳转到页面之中进行信息显示。在 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
    }
}

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

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

 4、 编写 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>

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

 6、 如果现在我们所定义的要访问的页面不是通过控制器跳转的怎么办？那么为了解决这样的问题，可以考虑在 thymeleaf 所在的 父路径之中“src/main/view”建立一个 static 的子目录，该目录保存的是所有静态页面；

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

 7、 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.5、profile 配置

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

1、 基于 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 里面可以方便的实现这种切换。

2、 此时所有的 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；

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

但是很多的公司应该去更换为自己的图标，所以这个时候可以单独准备出一个 ico 配置文件，可以将这个配置文件拷贝到 “src/main/view/static/images”目录之中，随后在页面之中进行引入：

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

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

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

spring.profiles.active=beta

 如果现在将开发程序打成*.jar 文件的话，也同样可以在执行的时候使用“--spring.profiles.active=beta”动态指派不同的 profile 配置文件。