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 配置文件。

原文地址:https://www.cnblogs.com/zhujiabin/p/9856748.html