AI 助理
备案控制台
开发者社区 云原生 微服务 文章 正文

分布式--Spring Boot 微服务框架

2018-04-23 2137
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
服务治理 MSE Sentinel/OpenSergo，Agent数量 不受限
云原生网关 MSE Higress，422元/月
注册配置 MSE Nacos/ZooKeeper，118元/月
简介： 1. Spring Boot1). 简介Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。

1. Spring Boot

1). 简介

Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。

2). 好处

（1）它是Spring的升级版，Spring容器能做到的事情，它都能做到，而且更简便，从配置形式上来说，SpringBoot完全抛弃了繁琐的XML文件配置方式，而是替代性地用注解方式来实现，虽然本质来说，是差不多的（类似包扫描，注解扫描，类加载之类）。
（2）SpringBoot集成的插件更多，从而使用很多服务，都只是引入一个依赖，几个注解和Java类就可以用了，具体的参考相关手册。
（3）在Web应用开发这一块，之前的应用一般来说是打包成war包，再发布到相关服务器容器下（例如Tomcat），虽然SpringBoot也可以这么做，但在SpringBoot下更常见的形式是将SpringBoot应用打包成可执行jar包文件。之所以这么做，源于你可以直接将SpringBoot应用看成是一个Java Application，其Web应用可以没有webapp目录（更不用说web.xml了），它推荐使用html页面，并将其作为静态资源使用。

3). Spring Boot是什么

Spring Boot不是一个框架，它是一种用来轻松创建具有最小或零配置的独立应用程序的方式。这是方法用来开发基于Spring的应用，但只需非常少的配置。它提供了默认的代码和注释配置，快速启动新的Spring项目而不需要太多时间。它利用现有的Spring项目以及第三方项目来开发生产就绪(投入生产)的应用程序。它提供了一组pom或gradle构建文件，可以使用它们添加所需的依赖项，并且还便于自动配置。
Spring Boot根据其类路径上的库自动配置所需的类。假设应用程序想要与数据库交互，如果在类路径上有Spring数据库，那么它会自动建立与数据源类的连接。


img_89c8883969591c73c2652007b8e34b9a.png
图1.png
4). 主要目标
  • 为所有Spring开发提供一个基本的，更快，更广泛的入门体验。
  • 开箱即用，但随着需求开始偏离默认值，快速启动。
  • 提供大型项目(例如嵌入式服务器，安全性，度量，运行状况检查，外部化配置)常见的一系列非功能特性。
  • 绝对没有代码生成以及不需要XML配置，完全避免XML配置。
  • 为了避免定义更多的注释配置(它将一些现有的 Spring Framework 注释组合成一个简单的单一注释)
  • 避免编写大量import语句。
  • 提供一些默认值，以便在短时间内快速启动新项目。
5). 新项目使用Spring Boot
  • 简化基于Java的应用程序开发，单元测试和集成测试过程。
  • 通过提供一些默认值来减少开发，单元测试和集成测试时间。
  • 提高生产力。
  • 当使用默认值时，Spring Boot有自己的看法。如果不指定详细信息，它将使用其自己的默认配置。如果想要持久化，但是没有在POM文件中指定任何东西，那么Spring Boot会- 将Hibernate带有HSQLDB数据库的配置作为JPA提供者。
  • 为大型项目(例如嵌入式服务器，安全性，度量，健康检查，外部化配置)提供许多非常常见的非功能特性/解决方案。
6). 优缺点

Spring Boot的优点：

  • 使用Java或Groovy开发基于Spring的应用程序非常容易。
  • 它减少了大量的开发时间并提高了生产力。
  • 它避免了编写大量的样板代码，注释和XML配置。
  • Spring Boot应用程序与其Spring生态系统(如Spring JDBC，Spring ORM，Spring Data，Spring Security等)集成非常容易。
  • 它遵循“自用默认配置”方法，以减少开发工作量。
  • 它提供嵌入式HTTP服务器，如Tomcat，Jetty等，以开发和测试Web应用程序非常容易。
  • 它提供CLI(命令行界面)工具从命令提示符，非常容易和快速地开发和测试Spring Boot(Java或Groovy)应用程序。
  • 它提供了许多插件来开发和测试Spring启动应用程序非常容易使用构建工具，如Maven和Gradle。
  • 它提供了许多插件，以便与嵌入式和内存数据库工作非常容易。

Spring Boot的限制:

  • 将现有或传统的Spring Framework项目转换为Spring Boot应用程序是一个非常困难和耗时的过程。它仅适用于全新Spring项目。

2. Spring Boot

1). 入门

Spring Boot项目归根只是一个常规的Spring项目，只是利用了Spring Boot启动程序和自动配置。要创建Spring Boot应用程序的方法，Spring团队(The Pivotal Team)提供了以下三种方法。

可以使用Spring Boot开发两种基于Spring的应用程序：

  • 基于Java的应用程序
  • 基于Groovy的应用程序
img_9dd4de66ba2a702c5164ea79755e6211.png
图2.png
2). Spring Boot CLI

I. 下载并解压

img_6df58e8d514fd4bf3c89838b5eefa9b3.png
图3.png

在Windows系统中命令提示符中设置Spring Boot CLI环境变量：
右键“我的电脑”->”高级系统设置”->”高级”->”环境变量”->选择”PATH”并新建并加上面的路径 D:\distribution\spring-2.0.2.RELEASE\bin;
img_04b6791835cd96d5420a8d958e2dd796.png
图4.png

验证：

spring --version
img_8b5470a1bbd97b7eda495db3a4f339b3.png
图5.png

II. spring 命令语法查看spring --help

img_aec46ca25d13b66c623c6d21dd4fccb3.png
图6.png

III. 创建HelloWorld.groovy文件

@RestController
class HelloWorld {
    @RequestMapping("/")
    String hello() {
        "Hello mazaiting."
    }
}
img_3da9dd6886ad0623d85dee5c805f8e5c.png
图6.png

IV. 运行

spring run HelloWorld.groovy
img_3dd749ef811b54d52df412d08f1dbe63.png
图7.png

V. 测试
在浏览器输入http://localhost:8080/即可访问

img_51fdd20c3acb0794c84300f260783166.png
图8.png

3). Maven 安装Spring Boot
    <!-- Inherit defaults from Spring Boot -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
    </parent>

    <!-- Add typical dependencies for a web application -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
4). Eclipse 使用 Spring Boot

I. 在pom.xml文件中添加SpringBoot的依赖

<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.mazaiting</groupId>
    <artifactId>SpringBootTest</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>SpringBootTest</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <!-- Spring-Boot -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- Spring-Boot -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

II. 创建HelloWorld类

@RestController
@EnableAutoConfiguration
public class HelloWorld {

    @RequestMapping("/")
    String home() {
        return "Hello mazaiting";
    }
    
    public static void main(String[] args) {
        SpringApplication.run(HelloWorld.class, args);
    }
}

III. 执行结果

img_0ff9e04ba0d9740e33971772c48ef622.png
图9.png

在浏览器输入 http://localhost:8080/
img_e535d58d58da944647d5c27b933e4885.png
图10.png

IV. 注解解释

  • @RestController: 构造型注释, 指定控制器，Spring会在处理传入的Web请求时考虑它.
  • @RequestMapping：注解提供了“路由”信息。它告诉Spring任何带有路径“/”的HTTP请求应该映射到home方法。[@RestController](https://github.com/RestController "@RestController")注解告诉Spring将生成的字符串直接返回给调用者。
  • @EnableAutoConfiguration: 允许自动配置

V. 创建可执行的jar包

  • 在pom.xml的project节点下添加
    <build>
        <plugins>
            <!-- 用于创建可执行jar -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
  • 在项目的根目录下执行dos命令mvn package
    img_a00b396a689a35ca32c7d9327dba0bec.png
    图11.png

    img_614c3ba643116154624a8bcb13f02a0d.png
    图12.png
  • 执行完成后\SpringBootTest\target\目录下生成SpringBootTest-0.0.1-SNAPSHOT.jar文件
    img_15df398658f15883a3fe00afe74d2304.png
    图13.png
  • 执行java -jar target/SpringBootTest-0.0.1-SNAPSHOT.jar命令运行，并在浏览器输入http://localhost:8080/，同样可看到执行效果.
5). Spring Boot JSP 实例

I. 创建Maven Web项目


img_8cc10084d694653e47284831aca2ce1e.png
图14.png

II. 在pom文件中添加依赖

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mazaiting</groupId>
    <artifactId>SpringBoot-JSP</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringBoot-JSP Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <!-- Spring-Boot -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
    </parent>
    <!-- 配置Java版本 -->
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- Spring-Boot： This is a web application  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Tomcat embedded container-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <!-- Need this to compile JSP -->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <scope>provided</scope>
        </dependency>
         <!-- JSTL for JSP -->
        <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>       
        <!-- https://mvnrepository.com/artifact/taglibs/standard -->
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>

        <!-- Optional, test for static content, bootstrap CSS-->
        <dependency>
            <groupId>org.webjars</groupId>
            <artifactId>bootstrap</artifactId>
            <version>3.3.7</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>SpringBoot-JSP</finalName>
        <plugins>
            <!-- Package as an executable jar/war -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

实现依赖关系：mvn dependency:tree

img_01c550f8a9e69e0d6b75ee9f1a251a84.png
图15.png

III. SpringBootServletInitializer执行传统的WAR部署运行SpringApplication

// 注解为SpringBoot应用
@SpringBootApplication
public class SpringBootWebApplication extends SpringBootServletInitializer{
    
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(SpringBootWebApplication.class);
    }
    
    public static void main(String[] args) {
        SpringApplication.run(SpringBootWebApplication.class, args);
    }
    
}

IV. 创建控制器

@Controller
public class WelcomeController {
    
    // 注入应用配置 application.properties
    @Value("${welcome.message}")
    private String message = "Hello World";
    
    @RequestMapping("/")
    public String welcome(Map<String, Object> model) {
        model.put("message", this.message);
        return "welcome";
    }
}

V. welcome.jsp页面

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" isELIgnored="false"%>
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE html>
<html lang="en">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <!-- 链接bootstrap -->
        <!-- 
            href中的内容写为：webjars/bootstrap/3.3.7/css/bootstrap.css
            加载地址为：http://localhost:8080/SpringBoot-JSP/webjars/bootstrap/3.3.7/css/bootstrap.css
            href中的内容写为：/webjars/bootstrap/3.3.7/css/bootstrap.css
            加载地址为：http://localhost:8080/webjars/bootstrap/3.3.7/css/bootstrap.css
            使用中建议写为webjars/bootstrap/3.3.7/css/bootstrap.css
        -->
        <link rel="stylesheet" type="text/css" href="webjars/bootstrap/3.3.7/css/bootstrap.css"/>
        <%-- <spring:url value="/css/main.css" var="springCss"/>
        <link href="${springCss}" rel="stylesheet"/> --%>
        <script type="text/javascript" src="webjars/jquery/1.11.1/jquery.min.js"></script>
        <c:url value="/css/main.css" var="jstlCss"></c:url>
        <link href="${jstlCss }" rel="stylesheet"/>
        <title>SpringBootTest</title>
    </head>
    <body> 
        <nav class="navbar navbar-inverse">
            <div class="container">
                <div class="navbar-header">
                    <a class="navbar-brand" href="#">Spring Boot</a>
                </div>
            </div>
            <div id="navbar" class="collapse navbar-collapse">
                <ul class="nav nav-bar-nav">
                    <li class="active"><a href="#">Home</a></li>
                    <li><a href="#about">About</a></li>
                </ul>
            </div>
        </nav>
        <div class="container">
            <div class="starter-template">
                <h1>Spring Boot Web JSP Example</h1>
                <h2>Message: ${message }</h2>
            </div>
        </div>
        <script type="text/javascript" src="webjars/bootstrap/3.3.7/js/bootstrap.min.js"></script>
    </body>
</html>

注

href中的内容写为：webjars/bootstrap/3.3.7/css/bootstrap.css
加载地址为：http://localhost:8080/SpringBoot-JSP/webjars/bootstrap/3.3.7/css/bootstrap.css

href中的内容写为：/webjars/bootstrap/3.3.7/css/bootstrap.css
加载地址为：http://localhost:8080/webjars/bootstrap/3.3.7/css/bootstrap.css

使用中建议写为webjars/bootstrap/3.3.7/css/bootstrap.css

main.css

h1 {
    color: #00F;
}
h2 {
    color: #F00;
}

VI. 在/src/main/resources/目录下创建application.properties及application-dev.properties、application-prod.properties、application-test.properties。

  • application-dev.properties：用于开发环境
  • application-test.properties：用于测试环境
  • application-prod.properties：用于生产环境

在application.properties文件中配置使用哪一类型的配置文件, prefix和suffix配置视图层的前后缀。

spring.mvc.view.prefix: /jsp/
spring.mvc.view.suffix: .jsp
spring.profiles.active= dev

application-dev.properties

welcome.message: Hello mazaiting1

application-test.properties

welcome.message: Hello mazaiting2

application-prod.properties

welcome.message: Hello mazaiting3

VII. 代码结构


img_d7364552d7367d9dc8899271b631bbdf.png
图16.png

VIII. 运行测试一：在SpringBootWebApplication类上右键Run As -> Java Application, 在浏览器中输入http://localhost:8080/

img_ab403be2c16f19e00fc6cdea5345bdf8.png
图17.png

IX.. 运行测试二：在项目的根目录下，在命令提示符输入mvn spring-boot:run，然后在浏览器输入http://localhost:8080/也可呈现效果

img_0d4028cfd76454c93fb8d4ff55000378.png
图18.png

X. 运行测试三：在工程右键-> Run As -> Run on Server部署在Tomcat容器中, 然后再浏览器中输入http://localhost:8080/SpringBoot-JSP/即可访问

img_5c1ac138199bd3159730961066a8b673.png
图19.png

XI. JSP限制
不能创建可执行jar来运行这个嵌入式Tomcat + JSP Web示例，因为Tomcat中有一个硬编码文件模式。

6). Spring Boot创建war包，并部署在Tomcat

I. 使用命令提示符进入项目根目录

mvn clean package
img_e0d2e4eba8adfcbc2060ef169c65904f.png
图20.png

II. 执行成功后，项目的\SpringBoot-JSP\target\目录下出现SpringBoot-JSP.war

img_7ef6b4ee539162251aeafd88c706dbd2.png
图21.png

7). Spring Boot + Thymeleaf 模板引擎 -- 可执行JAR文件

I. 引入依赖

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mazaiting</groupId>
    <artifactId>SpringBoot-Thymeleaf</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringBoot-Thymeleaf Maven Webapp</name>
    <url>http://maven.apache.org</url>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.2.RELEASE</version>
    </parent>
    <!-- Java版本 -->
    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

        <!-- hot swapping, disable cache for template, enable live reload -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- Optional, for bootstrap -->
        <dependency>
            <groupId>org.webjars</groupId>
            <artifactId>bootstrap</artifactId>
            <version>3.3.7</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>SpringBoot-Thymeleaf</finalName>
        <plugins>
            <!-- Package as an executable jar/war -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

spring-boot-devtools有助于禁用缓存并启用热插拔，以便开发人员总是看到最后的更改。尝试修改Thymeleaf模板或属性文件，刷新浏览器以查看更改立即生效。
II. 创建SpringBootWebApplication

@SpringBootApplication
public class SpringBootWebApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootWebApplication.class, args);
    }
}

III. 创建WelcomeController

@Controller
public class WelcomeController {
    @Value("${welcome.message}")
    private String message= "Hello World";
    
    @RequestMapping("/")
    public String welcome(Map<String, Object> model){
        model.put("message", this.message);
        return "welcome";
    }
}

IV. Thymeleaf +资源+静态文件

  • welcome.html
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
        <title>Spring Boot Thymeleaf Hello World 示例</title>
        <link rel="stylesheet" type="text/css" href="webjars/bootstrap/3.3.7/css/bootstrap.css"/>
        <link rel="stylesheet" th:href="@{/css/main.css}" href="../../css/main.css"/>
        <script type="text/javascript" src="webjars/jquery/1.11.1/jquery.min.js"></script>
    </head>
    <body>
        <nav class="navbar navbar-inverse">
            <div class="container">
                <div class="navbar-header">
                    <a class="navbar-brand" href="#">Spring Boot</a>
                </div>
                <div id="navbar" class="collapse navbar-collapse">
                    <ul class="nav navbar-nav">
                        <li class="avtive"><a href="#">首页</a></li>
                        <li><a href="#about">关于</a></li>
                    </ul>
                </div>
            </div>
        </nav>
        <div class="container">
            <div class="starter-template">
                <h1>Spring Boot Web Thymeleaf 示例</h1>
                <h2>
                    <span th:text="'Message: ' + ${message}"></span>
                </h2>
            </div>
        </div>
        <script type="text/javascript" src="webjars/bootstrap/3.3.7/js/bootstrap.min.js"></script>
    </body>
</html>
  • main.css
h1 {
    font-size: 20pt;
}
h2 {
    font-size: 16pt;
}
  • application.properties
welcome.message: Hello, mazaiting

  • 目录结构


    img_bc6f230acf46b6ecc2c5d329f6c53426.png
    图22.png

V. 运行方式一：运行SpringBootWebApplication，浏览器输入http://localhost:8080/

img_dfb8c8358322287a66df4c84b6fd395a.png
图23.png

VI. 运行方式二：在命令提示符的项目根目录下执行mvn spring-boot:run，浏览器输入http://localhost:8080/即可显示效果
VII. 运行方式三：在命令提示符的项目根目录下执行mvn clean package，创建可执行jar包，运行jar包，浏览器输入http://localhost:8080/即可显示效果。想要生成jar包，在pom.xml文件中，一定有此行<packaging>war</packaging>

8). Spring Boot 非Web应用--命令行应用

I. 创建Maven的普通Java工程，并在pom.xml文件中添加依赖

<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.mazaiting</groupId>
    <artifactId>SpringBoot-Console</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>SpringBoot-Console</name>
    <url>http://maven.apache.org</url>
    <!-- Spring-Boot -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- Package as an executable jar/war -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

II. 创建HelloService服务

@Service
public class HelloMessageService {
    
    @Value("${name}")
    private String name;

    public String getMessage() {
        return getMessage(name);
    }
    
    public String getMessage(String name) {
        return "Hello " + name;
    }
    
}

III. application.properties内容

name=mazaiting

IV. SpringBootConsoleApplication应用

@SpringBootApplication
public class SpringBootConsoleApplication implements CommandLineRunner{

    @Autowired
    private HelloMessageService helloService;
    
    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(SpringBootConsoleApplication.class);
        application.setBannerMode(Banner.Mode.OFF);
        application.run(args);
    }
    
    @Override
    public void run(String... args) throws Exception {
        if (args.length > 0) {
            System.out.println(helloService.getMessage(args[0].toString()));
        } else {
            System.out.println(helloService.getMessage());
        }
    }

}

V. 目录结构


img_76cff001110805903d04c3a8662a6928.png
图24.png

VI. 运行

  • 生成jar包
mvn package
  • 运行1
java -jar target/SpringBoot-Console-0.0.1-SNAPSHOT.jar

结果：Hello mazaiting

  • 运行2
java -jar target/SpringBoot-Console-0.0.1-SNAPSHOT.jar spring-boot

结果：Hello spring-boot

9). Spring Boot 属性配置

I. pom.xml文件

<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.mazaiting</groupId>
    <artifactId>SpringBoot-Config</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>SpringBoot-Config</name>
    <url>http://maven.apache.org</url>
    <!-- Spring-Boot -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- Spring-Boot： This is a web application  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- Package as an executable jar/war -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

II. @Value使用

@Component
@PropertySource("classpath:global.properties")
public class GlobalProperties {

    @Value("${thread-pool}")
    private int threadPool;

    @Value("${email}")
    private String email;

    //getters and setters

}

III. ConfigurationProperties

@Component
@PropertySource("classpath:global.properties")
@ConfigurationProperties
public class GlobalProperties {

    private int threadPool;
    private String email;

    //getters and setters

}

IV. 配置文件
global.properties文件

email=zaitingma@foxmail.com
thread-pool=12

application.properties文件

#Logging
logging.level.org.springframework.web=ERROR
logging.level.com.mazaiting=DEBUG

#Global 
email=1425941077@qq.com
thread-pool=10

#App
app.menus[0].title=Home
app.menus[0].name=Home
app.menus[0].path=/
app.menus[1].title=Login
app.menus[1].name=Login
app.menus[1].path=/login

app.compiler.timeout=5
app.compiler.output-folder=/temp/

app.error=/error/

注： 如果在application.properties文件中有与global.properties中有相同的属性，取值时则取application.properties中的配置
V. 对应的java文件
AppProperties.java

@Component
//prefix app, find app.* values
@ConfigurationProperties("app") 
public class AppProperties {
    private String error;
    private List<Menu> menus = new ArrayList<>();
    private Compiler compiler = new Compiler();
    
    public String getError() {
        return error;
    }

    public void setError(String error) {
        this.error = error;
    }

    public List<Menu> getMenus() {
        return menus;
    }

    public void setMenus(List<Menu> menus) {
        this.menus = menus;
    }

    public Compiler getCompiler() {
        return compiler;
    }

    public void setCompiler(Compiler compiler) {
        this.compiler = compiler;
    }

    public static class Menu {
        private String name;
        private String path;
        private String title;
        
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getPath() {
            return path;
        }

        public void setPath(String path) {
            this.path = path;
        }

        public String getTitle() {
            return title;
        }

        public void setTitle(String title) {
            this.title = title;
        }

        @Override
        public String toString() {
            return "Menu [name=" + name + ", path=" + path + ", title=" + title + "]";
        }
    }
    
    public static class Compiler {
        private String timeout;
        private String outputFolder;
        public String getTimeout() {
            return timeout;
        }
        public void setTimeout(String timeout) {
            this.timeout = timeout;
        }
        public String getOutputFolder() {
            return outputFolder;
        }
        public void setOutputFolder(String outputFolder) {
            this.outputFolder = outputFolder;
        }
        @Override
        public String toString() {
            return "Compiler [timeout=" + timeout + ", outputFolder=" + outputFolder + "]";
        }
    }

    @Override
    public String toString() {
        return "AppProperties [error=" + error + ", menus=" + menus + ", compiler=" + compiler + "]";
    }
}

GlobalProperties.java

@Component
@PropertySource("classpath:global.properties")
public class GlobalProperties {
    @Value("${thread-pool}")
    private int threadPool;
    @Value("${email}")
    private String email;
    public int getThreadPool() {
        return threadPool;
    }
    public void setThreadPool(int threadPool) {
        this.threadPool = threadPool;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    @Override
    public String toString() {
        return "GlobalProperties [threadPool=" + threadPool + ", email=" + email + "]";
    }
}

VI. 应用入口SpringBootWebApplication

@SpringBootApplication
public class SpringBootWebApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootWebApplication.class, args);
    }
}

VII. 控制器

@Controller
public class WelcomeController {
    private static final Logger LOGGER = LoggerFactory.getLogger(WelcomeController.class);
    private GlobalProperties global;
    private AppProperties app;
    
    @Autowired
    public void setApp(AppProperties app) {
        this.app = app;
    }
    
    @Autowired
    public void setGlobalProperties(GlobalProperties global) {
        this.global = global;
    }
    
    @RequestMapping("/")
    public String welcome(Map<String, Object> model) {
        String globalProperties = global.toString();
        String appProperties = app.toString();
        
        LOGGER.debug("Welcome {}, {}", app, global);
        
        model.put("message", appProperties + globalProperties);
        return "welcome";
    }
    
}

VIII. 运行SpringBootWebApplication，浏览器输入http://localhost:8080/，查看控制台

2018-05-14 13:07:22.056 DEBUG 4228 --- [nio-8080-exec-3] com.mazaiting.config.WelcomeController   : 
Welcome AppProperties [error=/error/, menus=[Menu [name=Home, path=/, title=Home], 
Menu [name=Login, path=/login, title=Login]], compiler=Compiler [timeout=5, outputFolder=/temp/]],
 GlobalProperties [threadPool=10, email=1425941077@qq.com]

IX. 验证

@Component
@ConfigurationProperties
public class GlobalProperties {

    @Max(5)
    @Min(0)
    private int threadPool;

    @NotEmpty
    private String email;

    //getters and setters
}
10). 配置文件中配置logging
#Logging
# log level 日志等级
logging.level.org.springframework.web=ERROR
logging.level.com.mazaiting=DEBUG
# log file 日志文件存放路径
#logging.file=${java.io.tmpdir}/application.log
# output to a file 存放路径
logging.file=C:/Users/Administrator/Desktop/mylog.log
# pattern 格式化文件内容
logging.pattern.file="%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"

代码下载

文章标签：
Java
Spring
前端开发
Apache
JavaScript
关键词：
Spring boot
分布式框架
Spring boot框架
Spring框架
Spring微服务
凌浩雨
目录
相关文章
高端源码库
|
24天前
|
数据采集 监控 前端开发
二级公立医院绩效考核系统源码，B/S架构，前后端分别基于Spring Boot和Avue框架
医院绩效管理系统通过与HIS系统的无缝对接，实现数据网络化采集、评价结果透明化管理及奖金分配自动化生成。系统涵盖科室和个人绩效考核、医疗质量考核、数据采集、绩效工资核算、收支核算、工作量统计、单项奖惩等功能，提升绩效评估的全面性、准确性和公正性。技术栈采用B/S架构，前后端分别基于Spring Boot和Avue框架。
高端源码库
58 5
龙大吉
|
1月前
|
Java API 数据库
构建RESTful API已经成为现代Web开发的标准做法之一。Spring Boot框架因其简洁的配置、快速的启动特性及丰富的功能集而备受开发者青睐。
【10月更文挑战第11天】本文介绍如何使用Spring Boot构建在线图书管理系统的RESTful API。通过创建Spring Boot项目，定义`Book`实体类、`BookRepository`接口和`BookService`服务类，最后实现`BookController`控制器来处理HTTP请求，展示了从基础环境搭建到API测试的完整过程。
龙大吉
48 4
土木林森
|
1月前
|
XML JSON API
ServiceStack：不仅仅是一个高性能Web API和微服务框架，更是一站式解决方案——深入解析其多协议支持及简便开发流程，带您体验前所未有的.NET开发效率革命
【10月更文挑战第9天】ServiceStack 是一个高性能的 Web API 和微服务框架，支持 JSON、XML、CSV 等多种数据格式。它简化了 .NET 应用的开发流程，提供了直观的 RESTful 服务构建方式。ServiceStack 支持高并发请求和复杂业务逻辑，安装简单，通过 NuGet 包管理器即可快速集成。示例代码展示了如何创建一个返回当前日期的简单服务，包括定义请求和响应 DTO、实现服务逻辑、配置路由和宿主。ServiceStack 还支持 WebSocket、SignalR 等实时通信协议，具备自动验证、自动过滤器等丰富功能，适合快速搭建高性能、可扩展的服务端应用。
土木林森
109 3
众所周知
|
1月前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 实现动态路由和菜单功能，快速搭建前后端分离的应用框架
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 实现动态路由和菜单功能，快速搭建前后端分离的应用框架。首先，确保开发环境已安装必要的工具，然后创建并配置 Spring Boot 项目，包括添加依赖和配置 Spring Security。接着，创建后端 API 和前端项目，配置动态路由和菜单。最后，运行项目并分享实践心得，包括版本兼容性、安全性、性能调优等方面。
众所周知
153 1
龙大吉
|
1月前
|
Java API 数据库
Spring Boot框架因其简洁的配置、快速的启动特性及丰富的功能集而备受开发者青睐
本文通过在线图书管理系统案例，详细介绍如何使用Spring Boot构建RESTful API。从项目基础环境搭建、实体类与数据访问层定义，到业务逻辑实现和控制器编写，逐步展示了Spring Boot的简洁配置和强大功能。最后，通过Postman测试API，并介绍了如何添加安全性和异常处理，确保API的稳定性和安全性。
龙大吉
38 0
m1a6
|
28天前
|
前端开发 Java 数据库连接
Spring 框架：Java 开发者的春天
Spring 框架是一个功能强大的开源框架，主要用于简化 Java 企业级应用的开发，由被称为“Spring 之父”的 Rod Johnson 于 2002 年提出并创立，并由Pivotal团队维护。
m1a6
43 1
Spring 框架：Java 开发者的春天
蓝易云
|
10天前
|
存储 运维 安全
Spring运维之boot项目多环境(yaml 多文件 proerties)及分组管理与开发控制
通过以上措施，可以保证Spring Boot项目的配置管理在专业水准上，并且易于维护和管理，符合搜索引擎收录标准。
蓝易云
21 2
喜欢猪猪
|
19天前
|
机器学习/深度学习 自然语言处理 并行计算
DeepSpeed分布式训练框架深度学习指南
【11月更文挑战第6天】随着深度学习模型规模的日益增大，训练这些模型所需的计算资源和时间成本也随之增加。传统的单机训练方式已难以应对大规模模型的训练需求。
喜欢猪猪
64 3
java冯坚持
|
1月前
|
SQL JSON Java
mybatis使用三：springboot整合mybatis，使用PageHelper 进行分页操作，并整合swagger2。使用正规的开发模式：定义统一的数据返回格式和请求模块
这篇文章介绍了如何在Spring Boot项目中整合MyBatis和PageHelper进行分页操作，并且集成Swagger2来生成API文档，同时定义了统一的数据返回格式和请求模块。
java冯坚持
56 1
mybatis使用三：springboot整合mybatis，使用PageHelper 进行分页操作，并整合swagger2。使用正规的开发模式：定义统一的数据返回格式和请求模块
东方睿赢
|
21天前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个前后端分离的应用框架，实现动态路由和菜单功能
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个前后端分离的应用框架，实现动态路由和菜单功能。首先，确保开发环境已安装必要的工具，然后创建并配置 Spring Boot 项目，包括添加依赖和配置 Spring Security。接着，创建后端 API 和前端项目，配置动态路由和菜单。最后，运行项目并分享实践心得，帮助开发者提高开发效率和应用的可维护性。
东方睿赢
38 2
云原生

微服务

热门文章

最新文章

  • 1
    微服务（Microservice）那点事
  • 2
    2019年5月下旬最值得一读的9本技术书籍（微服务架构、算法、大数据等书籍）！
  • 3
    微服务网关Zuul迁移到Spring Cloud Gateway
  • 4
    ASP.NET Core微服务之基于Consul实现服务治理（1）
  • 5
    鹰眼跟踪、限流降级，EDAS的微服务解决之道
  • 6
    微服务架构如何实现网站服务垂直化拆分
  • 7
    从 SOA 到微服务，企业分布式应用架构在云原生时代如何重塑？
  • 8
    Java微服务开发指南 -- 使用Spring Boot构建微服务
  • 9
    (十) Spring Cloud构建分布式微服务架构 - SSO单点登录之OAuth2.0登录认证(1)
  • 10
    Istio从懵圈到熟练 – 二分之一活的微服务
  • 1
    JVM进阶调优系列(10)敢向stop the world喊卡的G1垃圾回收器 | 有必要讲透
    9
  • 2
    JVM进阶调优系列(9)大厂面试官:内存溢出几种？能否现场演示一下？| 面试就那点事
    67
  • 3
    热联集团：从 APISIX 迁移到云原生网关
    49
  • 4
    阿里云微服务引擎 MSE 及 云原生 API 网关 2024 年 10 月产品动态
    41
  • 5
    java.util的Collections类
    41
  • 6
    JVM进阶调优系列(8)如何手把手，逐行教她看懂GC日志？| IT男的专属浪漫
    80
  • 7
    无障碍工具条本地化安装部署
    41
  • 8
    服务器磁盘爆满？别慌，教你轻松清理！
    95
  • 9
    JVM进阶调优系列(6)一文详解JVM参数与大厂实战调优模板推荐
    113
  • 10
    JVM进阶调优系列(5)CMS回收器通俗演义一文讲透FullGC
    58

    • 相关课程

    更多
  • 微服务实战-RocketMQ Binder
  • 微服务实战-服务熔断 - Sentinel
  • 微服务实战-Service Mesh与Istio
  • 微服务实战-服务注册与发现 - Nacos Discovery
  • 分布式文件存储系统技术及实现
  • 分布式协调系统 Zookeeper 快速入门

    • 相关电子书

    更多
  • 基于社区的分布式 风险感知模型
  • 如何利用Redisson分布式化传统Web项目
  • FLASH:大规模分布式图计算引擎及应用

    • 相关实验场景

    更多
  • 体验PolarDB-X透明分布式
  • 通过EDAS实现K8s微服务应用的金丝雀发布
  • SAE极速部署弹性微服务商城
  • 基于MSE实现微服务的全链路灰度
  • 快速玩转Dubbo生态之限流降级篇（Sentinel）
  • 快速上手使用Dubbo进行远程调用
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)