SpringBoot

最新推荐文章于 2022-04-26 10:13:28 发布

单眼皮女孩i

最新推荐文章于 2022-04-26 10:13:28 发布

阅读量205

点赞数

本文链接：https://blog.csdn.net/weixin_44889526/article/details/121174190

版权

SpringBoot

1、SpringBoot入门
2、配置详解
3、Springboot整合其他框架
4、日志
5、补充
- 附件A（配置)
- 附件B

1、SpringBoot入门

什么是SpringBoot？

Spring 诞生时是 Java 企业版（Java Enterprise Edition，JEE，也称 J2EE）的轻量级代替品。无需开发重量级的 Enterprise JavaBean（EJB），Spring 为企业级 Java 开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的 Java 对象（Plain Old Java Object， POJO）实现了 EJB 的功能。
虽然 Spring 的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring 用 XML 配置，而且是很多 XML 配置。Spring 2.5 引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式 XML 配置。Spring 3.0 引入了基于 Java 的配置，这是一种类型安全的可重构配置方式，可以代替 XML。所有这些配置都代表了开发时的损耗。因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间。和所有框架一样，Spring 实用，但与此同时它要求的回报也不少。
除此之外，项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够
让人头痛的了，你还要知道这些库的哪个版本和其他库不会有冲突，这难题实在太棘手。并且，依赖管理也是一种损耗，添加依赖不是写应用程序代码。一旦选错了依赖的版本，随之而来的不兼容问题毫无疑问会是生产力杀手。

Spring Boot 让这一切成为了过去。
Spring Boot 是 Spring 社区较新的一个项目。该项目的目的是帮助开发者更容易的创建基于 Spring 的应用程序和服务，让更多人的人更快的对 Spring 进行入门体验，为 Spring 生态系统提供了一种固定的、约定优于配置风格的框架。

Spring Boot 具有如下特性：
（1）为基于 Spring 的开发提供更快的入门体验
（2）开箱即用，没有代码生成，也无需 XML 配置。同时也可以修改默认值来满足特定的需求。
（3）提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。
（4）Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式。

Spring Boot 入门小Demo

起步依赖

创建 Maven 工程 springboot_demo 打包方式是jar war ，，，
在 pom.xml 中添加如下依赖
在这里面我继续父依赖，这那相关的依赖jar包都会传递进来，版本也做了统一

	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
        <relativePath/>
    </parent>

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

我们会惊奇地发现，我们的工程自动添加了好多好多 jar 包
在这里插入图片描述
而这些 jar 包是我们做开发时需要导入的 jar 包。因为这些 jar 包被我们刚才引入的 spring-boot-starter-web 所引用了，所以我们引用 spring-boot-starter-web 后会自动把依赖传递过来。
其中就是因为这个jar包帮我们来集成了很多配置

引导类

只需要创建一个引导类 .其实也叫启动类

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

简单解释一下：
@SpringBootApplication 其实就是以下三个注解的总和
@Configuration：用于定义一个配置类
@EnableAutoConfiguration ：Spring Boot 会自动根据你 jar 包的依赖来自动配置项目。
@ComponentScan：告诉 Spring 哪个 packages 的用注解标识的类会被 spring 自动扫描并且装入 bean 容器。
范围：扫描启动类所在的包及其子包下所有的注解

启动

直接run
在这里插入图片描述

快速创建并启动

在这里插入图片描述

2、配置详解

SpringMVC实现hello SpringBoot的输出

我们现在开始使用 spring MVC 框架，实现 json 数据的输出。如果按照我们原来的做法，需要在 web.xml 中添加一个 DispatcherServlet 的配置，再添加一个 spring 的配置文件，配置文件中需要添加如下配置
但是我们用 SpringBoot，这一切都省了。我们直接写 Controller 类
@RestController是一个组合注解
@Controller
@ResponseBody 用与返回字符串或json数据

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String hello(){
        return "hello  SpringBoot";
    }
}

我们运行启动类来运行程序
在浏览器地址栏输入 http://localhost:8080/hello 即可看到运行结果
在这里插入图片描述

application.properties配置文件

在 src/main/resources 下创建 application.properties 或者更加简洁的application.yml文件
#修改 tomcat 启动端口

server.port=8081
#默认根路径/ 可以修改成自己的项目路径
server.servlet.context-path=/springboot

重新运行引导类。地址栏输入http://localhost:8088/springboot/hello
在这里插入图片描述

application.yml文件

在这里插入图片描述

yaml是一种直观的能够被计算机识别的数据序列化格式，容易被人类阅读，yaml类似于xml，但语法更简洁；
它是一种冒号，空格，换行的数据格式，后缀可以是yml,也可以是yaml
如果两个application.properties和application.yml同时存在，优先加载application.properties
优先级：properties>yml>yaml
在这里插入图片描述

Yml数据格式：
对象：

数组：

纯量：

参数：

name: lisi
person :
  name: ${name}
  age: 20
  address:
    - beijing
    - shanghai

在这里插入图片描述

读取自定义配置文件信息

在 src/main/resources 下的 application.yml 增加配置

方式一：
@使用Environment对象

    @Autowired
    private Environment environment;


    @Test
    void contextLoads() {
//        System.out.println(config);
//        System.out.println(getHello);

        String userName = environment.getProperty("person.name");
        String userName2 = environment.getProperty("user2.name");
        String address = environment.getProperty("address2[0]");
        String msg1 = environment.getProperty("msg1");
        String msg2 = environment.getProperty("msg2");

        System.out.println(userName);
        System.out.println(userName2);
        System.out.println(address);
        System.out.println(msg1);
        System.out.println(msg2);

    }

方式二：
使用@Value注解

   @Value("${person.name}")
    private String userName;
    @Value("${address2[0]}")
    private String address;
    @Value("${msg1}")
    private String msg1;
    @Value("${msg2}")
    private String msg2;

方式三：
使用@ConfigurationPropertis注解：把配置信息和对象属性绑定起来

加依赖

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

实体类

@Data
@ToString
@Component  //自动化注入bean到 Spring容器中
@ConfigurationProperties(prefix = "person")
public class Person {

    private String name;
    private int age;
    private String[] address;

}

测试

    @Autowired
    private Person person;
    
    System.out.println(person);

在这里插入图片描述

多环境配置文件

在这里插入图片描述

多profile文件方式

在这里插入图片描述

这里springboot默认加载application.properties文件，需要在默认文件中把其他的配置文件进行激活

#激活开发环境
spring.profiles.active=dev

注意细节：
如果激活和本配置文件配置信息相同，优化走激活（引入）

yml多文档方式

用三个横杠隔开不同配置，每段内容是一个文档

#多文档
---
server:
  port: 8081
spring:
  config:
    activate:
      on-profile: dev

---
server:
  port: 8082
spring:
  config:
    activate:
      on-profile: online

---
server:
  port: 8083
spring:
  config:
    activate:
      on-profile: test

虚拟机参数激活

在这里插入图片描述

命令行参数

在这里插入图片描述
打包运行：
打开jar包所在目录，shift+右键-》在此地打开powershell窗口

默认

指定

配置加载顺序

内部配置加载顺序

在这里插入图片描述
注意：多个配置文件效果是互补的

外部配置加载顺序

加载外部配置文件：spring.config.location
在这里插入图片描述
Tip:用处：外部和内部配置互补，项目打包好后不用修改配置文件重新打包，只需要把要修改的配置写到外部文件即可

自定义banner

启动Spring Boot项目后会看到这样的图案：
在这里插入图片描述
这个图片其实是可以自定义的：
1.打开网站：
自定义网.
https://www.bootschool.net/ascii-art/chinese

拷贝生成的字符到一个文本文件中，并且将该文件命名为banner.txt
将banner.txt拷贝到项目的resources目录中：

3、Springboot整合其他框架

整合junit

注：新版本默认整合Junit5
整合junit4
在这里插入图片描述
注意：
需要导入Junit4依赖包
测试类如果是主包或主包的子包下可以不用指定启动类

@SpringBootTest
@RunWith(SpringRunner.class)

 @Test
    public void contextLoads() {}

Mybatis整合springboot

添加mybatis整合springboot的依赖包

		<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

也可以在创建项目时选择

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.hisoft</groupId>
    <artifactId>mybatis-springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mybatis-springboot</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--mybatis启动器-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

实例
在这里插入图片描述
application.properties配置

#引入数据源
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/db_1?timeZone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=123456

#mybatis
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.hisoft.pojo
#开启驼峰匹配
mybatis.configuration.map-underscore-to-camel-case=true

在这里插入图片描述

在这里插入图片描述
运行：

Springboot2 集成redis

在这里插入图片描述

pom.xml 添加

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

yml配置

application.properties:

#redis配置
spring.redis.host=192.168.187.222
spring.redis.port=6379
# 时间格式
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss

spring:
  redis:
    database: 0
    host: 192.168.187.222
    port: 6379
    password: 123456
    jedis:
      pool:
        #最大连接数
        max-active: 8
        #最大阻塞等待时间
        max-wait: -1
        #最大空闲
        max-idle: 9
        #最小空间
        min-idle: 0
    #连接超时时间
    timeout: 10000

RedisTemplate 配置，重写key和value的序列化

package com.hisoft.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        RedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer); // key序列化
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer()); // value序列化
        redisTemplate.setHashKeySerializer(stringSerializer); // Hash key序列化
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer()); // Hash value序列化
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

RedisService工具类

package com.hisoft.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class RedisService {
    @Autowired
    private RedisTemplate redisTemplate;

    public void setObj(final String key, Object obj, long timeout) {
        redisTemplate.opsForValue().set(key, obj, timeout, TimeUnit.SECONDS);
    }

    public Object getObj(final String key) {
        Object o = redisTemplate.opsForValue().get(key);
        return o;
    }


}

UserService实现类

package com.hisoft.service;

import com.hisoft.mapper.UserMapper;
import com.hisoft.pojo.User;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service
public class UserService {

    @Resource
    private UserMapper userMapper;

    @Resource
    private RedisService redisService;

    public List<User> getAll(){
        return userMapper.getAll();
    }

    public User queryUserById(Long id){
        User user = (User) redisService.getObj("user:" + id);
        if (user == null) {
            System.out.println("数据库查询。。。。");
            user = userMapper.queryUserById(id);
            redisService.setObj("user:" + id,user,60*2);
        }
        return user;
    }


}

SpringBoot整合thymeleaf

概述

Thymeleaf 是一个跟 Velocity、FreeMarker 类似的模板引擎，它可以完全替代 JSP 。相较与其他的模板引擎，它有如下三个极吸引人的特点
Thymeleaf 在有网络和无网络的环境下皆可运行，即它可以让美工在浏览器查看页面的静态效果，也可以让程序员在服务器查看带数据的动态页面效果。这是由于它支持 html 原型，然后在 html 标签里增加额外
的属性来达到模板 + 数据的展示方式。浏览器解释 html 时会忽略未定义的标签属性，所以 thymeleaf 的模板可以静态地运行；当有数据返回到页面时，Thymeleaf 标签会动态地替换掉静态内容，使页面动态显示。
Thymeleaf 开箱即用的特性。它提供标准和 Spring 标准两种方言，可以直接套用模板实现 JSTL、 OGNL 表达式效果，避免每天套模板、改 JSTL、改标签的困扰。同时开发人员也可以扩展和创建自定义的方言。
Thymeleaf 提供 Spring 标准方言和一个与 SpringMVC 完美集成的可选模块，可以快速的实现表单绑定、属性编辑器、国际化等功能。

为什么要用thymeleaf？

如果希望以 Jar 形式发布模块则尽量不要使用 JSP 相关知识，这是因为 JSP 在内嵌的 Servlet 容器上运行有一些问题 (内嵌 Tomcat、 Jetty 不支持 Jar 形式运行 JSP，Undertow 不支持 JSP)。

Spring Boot 中推荐使用 Thymeleaf 作为模板引擎，因为 Thymeleaf 提供了完美的 Spring MVC 支持

Spring Boot 提供了大量模板引擎，包括：
FreeMarker
Groovy
Mustache
Thymeleaf
Velocity
Beetl

整合Thymeleaf

引入Thymeleaf依赖

 <!--thymeleaf启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

创建Thymeleaf模板

在templates下新建index.html,内容如下：

<!doctype html>
<!--注意：引入thymeleaf的名称空间-->
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <p th:text="'hello SpringBoot'">hello thymeleaf</p>
</body>
</html>

Thymeleaf相关全局配置

spring:
  thymeleaf:
    enabled: true  #开启thymeleaf视图解析
    encoding: utf-8  #编码
    prefix: classpath:/templates/  #前缀
    cache: false  #是否使用缓存
    mode: HTML  #严格的HTML语法模式
	suffix: .html  #后缀名

Thymeleaf常用标签（8个）

1、th:text 用于文本的显示,并且可以进行简单的计算

 <p>用户信息页</p>
    <table>
        <tr>
            <th>id</th>
            <th>姓名</th>
            <th>密码</th>
            <th>生日</th>
        </tr>

        <tr>
            <td th:text="${user.id}"></td>
            <td th:text="${user.userName}"></td>
            <td th:text="${user.password}"></td>
            <td th:text="${user.birthday}"></td>
        </tr>
    </table>

    <p th:text="2+7"></p>

2、 th:utext 用于html的文本替换,常用于富文本编辑器编辑后的内容显示到前台页面上。

<p th:utext="${article.content}"></p> -> <p>my name is <b>maliming</b></p>

3、 th:if 用于判断条件,还可以多条件 and,or(二元操作符)，!,not非(一元操作符)。

<div th:if="${user} != null">show</div>如果user对象为空则不显示，不为空则显示 -> <div>show</div>

<div th:if="${user} != null and ${otherUser} != null">show</div>

运算符还可以写在${}里<div th:if="${user.number > 100}">show</div> -> <div>show</div> 运算符放在了 {} 内部, 此时整个 {} 内的表达式用 ognl/spel 引擎计算; 如果运算符放在外部, 那么 thymeleaf 引擎负责计算。
4、th:unless 用于判断条件，与th:if作用相反。

<div th:unless="${user} != null">show</div>如果user对象不为空则不显示，为空则显示 -> <div>show</div>

5、th:switch th:case 用于多个同等级相同目的判断,多选一时使用。

<div th:switch="${user.name}">
    <p th:case="maliming">first</p>若${user.name}中的值为maliming则显示，否则不显示
    <p th:case="${otherUser.name}">second</p>
</div>

6、th:action 用于定义后台控制器的路径，表单的提交地址，相当于标签的action属性

<form th:action="@{user/login}" method="post"></form>

7、th:each 用于遍历集合中的对象，相当于jstl中的<c:forEach>标签。
List集合循环遍历

<tr th:each="user,userStat:${messages.list}">
    <td th:text="${user.name}"></td>
    <td th:text="userStat.index"></td>
</tr>

<table>
        <tr>
            <th>id</th>
            <th>姓名</th>
            <th>密码</th>
            <th>生日</th>
        </tr>

        <tr th:each="user,userStat:${userList}">
            <td th:text="${user.id}"></td>
            <td th:text="${user.userName}"></td>
            <td th:text="${user.password}"></td>
            <td th:text="${user.birthday}"></td>
        </tr>
    </table>

其中的user是临时变量，相当于for(User user : users)中的user，userStat称为状态变量，属性有index:当前迭代对象的index(从0开始计算),count: 当前迭代对象的index(从1开始计算), size:被迭代对象的大小,current:当前迭代变量,even/odd:布尔值，当前循环是否是偶数/奇数(从0开始计算), first:布尔值，当前循环是否是第一个,last:布尔值，当前循环是否是最后一个。

Map集合循环遍历

<div th:each="map:${maps}" th:text="${map}"></div>

数组循环遍历

<tr>
    <td th:each="array:${arrays}" th:text="${array}"></td>
</tr>

8、 th:value 用于属性赋值。

<option th:value="${user.name}"></option> -> <option value="maliming"></option>

静态资源访问

在我们开发Web应用的时候，需要引用大量的js、css、图片等静态资源。
Spring Boot默认提供静态资源目录位置需置于classpath下，目录名需符合如下规则：
/static
/public
/resources
/META-INF/resources

举例：我们可以在src/main/resources/目录下创建static，在该位置放置一个图片文件。启动程序后，尝试访问http://localhost:8080/imgs/d.jpg。如能显示图片，配置成功。

4、日志

Spring Boot对各种日志框架都做了支持，我们可以通过配置来修改默认的日志的配置：默认日志框架是logback

#设置日志级别
#print sql
logging.level.com.hisoft=DEBUG
#print logging
logging.level.org.springframework=DEBUG

5、补充

附件A（配置)

Spring Boot 应用启动器
spring Boot应用启动器具体如下：
1）spring-boot-starter 这是Spring Boot的核心启动器，包含了自动配置、日志和YAML。
2）spring-boot-starter-actuator 帮助监控和管理应用。
3）spring-boot-starter-amqp 通过spring-rabbit来支持AMQP协议（Advanced Message Queuing Protocol）。
4）spring-boot-starter-aop 支持面向方面的编程即AOP，包括spring-aop和AspectJ。
5）spring-boot-starter-artemis 通过Apache Artemis 支持 JMS的API（Java Message Service API）。
6）spring-boot-starter-batch 支持Spring Batch，包括HSQLDB数据库。
7）spring-boot-starter-cache 支持Spring的Cache抽象。
8）spring-boot-starter-cloud-connectors 支持Spring Cloud Connectors，简化了在像Cloud Foundry或Heroku这样的云平台上连接服务。
9）spring-boot-starter-data-elasticsearch 支持ElasticSearch搜索和分析引擎，包括spring-data-elasticsearch。
10）spring-boot-starter-data-gemfire 支持GemFire分布式数据存储，包括spring-data-gemfire。
11）spring-boot-starter-data-jpa 支持JPA（Java Persistence API），包括spring-data-jpa、spring-orm、hibernate。
12）spring-boot-starter-data-MongoDB 支持MongoDB数据，包括spring-data-mongodb。
13）spring-boot-starter-data-rest 通过spring-data-rest-webmvc，支持通过REST暴露Spring Data数据仓库。
14）spring-boot-starter-data-solr 支持Apache Solr搜索平台，包括spring-data-solr。
15）spring-boot-starter-freemarker 支持FreeMarker模板引擎。
16）spring-boot-starter-groovy-templates 支持Groovy模板引擎。
17）spring-boot-starter-hateoas 通过spring-hateoas支持基于HATEOAS的RESTful Web服务。
18）spring-boot-starter-hornetq 通过HornetQ支持 JMS。
19）spring-boot-starter-integration 支持通用的spring-integration模块。
20）spring-boot-starter-jdbc 支持JDBC数据库。
21）spring-boot-starter-jersey 支持Jersey RESTful Web 服务框架。
22）spring-boot-starter-jta-atomikos 通过Atomikos支持JTA分布式事务处理。
23）spring-boot-starter-jta-bitronix 通过Bitronix支持JTA分布式事务处理。
24）spring-boot-starter-mail 支持javax.mail模块。
25）spring-boot-starter-mobile 支持spring-mobile。
26）spring-boot-starter-mustache 支持Mustache模板引擎。
27）spring-boot-starter-Redis 支持Redis键值存储数据库，包括spring-redis。
28）spring-boot-starter-security 支持spring-security。
29）spring-boot-starter-social-facebook 支持spring-social-facebook
30）spring-boot-starter-social-linkedin 支持pring-social-linkedin
31）spring-boot-starter-social-twitter 支持pring-social-twitter
32）spring-boot-starter-test 支持常规的测试依赖，包括JUnit、Hamcrest、Mockito 以及 spring-test模块。
33）spring-boot-starter-thymeleaf 支持Thymeleaf模板引擎，包括与Spring的集成。
34）spring-boot-starter-velocity 支持Velocity模板引擎。
35）spring-boot-starter-web S支持全栈式Web开发，包括Tomcat和spring-webmvc。
36）spring-boot-starter-websocket 支持WebSocket开发。
37）spring-boot-starter-ws 支持Spring Web Services。

Spring Boot应用启动器面向生产环境的还有2种，具体如下：
1）spring-boot-starter-actuator 增加了面向产品上线相关的功能，比如测量和监控。
2）spring-boot-starter-remote-shell 增加了远程ssh shell的支持。
最后，Spring Boot应用启动器还有一些替换技术的启动器，具体如下：
1）spring-boot-starter-jetty 引入了Jetty HTTP引擎（用于替换Tomcat）。
2）spring-boot-starter-log4j 支持Log4J日志框架。
3）spring-boot-starter-logging 引入了Spring Boot默认的日志框架Logback。
4）spring-boot-starter-tomcat 引入了Spring Boot默认的HTTP引擎Tomcat。
5）spring-boot-starter-undertow 引入了Undertow HTTP 引擎（用于替换Tomcat）。

附件B

Spring Boot 配置文件 application.properties
#########COMMON SPRING BOOT PROPERTIES
######CORE PROPERTIES===
#SPRING CONFIG (ConfigFileApplicationListener)

spring.config.name= # config file name (default to ‘application’)
spring.config.location= # location of config file

#PROFILES
spring.profiles= # comma list of active profiles

#APPLICATION SETTINGS (SpringApplication)
spring.main.sources=
spring.main.web-environment= # detect by default
spring.main.show-banner=true
spring.main…= # see class for all properties

#LOGGING
logging.path=/var/logs
logging.file=myapp.log
logging.config=

#IDENTITY (ContextIdApplicationContextInitializer)
spring.application.name=
spring.application.index=

#EMBEDDED SERVER CONFIGURATION (ServerProperties)
server.port=8080
server.address= # bind to a specific NIC
server.session-timeout= # session timeout in seconds
server.context-path= # the context path, defaults to ‘/’
server.servlet-path= # the servlet path, defaults to ‘/’
server.tomcat.access-log-pattern= # log pattern of the access log
server.tomcat.access-log-enabled=false # is access logging enabled
server.tomcat.protocol-header=x-forwarded-proto # ssl forward headers
server.tomcat.remote-ip-header=x-forwarded-for
server.tomcat.basedir=/tmp # base dir (usually not needed, defaults to tmp)
server.tomcat.background-processor-delay=30; # in seconds
server.tomcat.max-threads = 0 # number of threads in protocol handler
server.tomcat.uri-encoding = UTF-8 # character encoding to use for URL decoding

#SPRING MVC (HttpMapperProperties)
http.mappers.json-pretty-print=false # pretty print JSON
http.mappers.json-sort-keys=false # sort keys
spring.mvc.locale= # set fixed locale, e.g. enUK
spring.mvc.date-format= # set fixed date format, e.g. dd/MM/yyyy
spring.mvc.message-codes-resolver-format= # PREFIXERRORCODE / POSTFIXERROR_CODE
spring.view.prefix= # MVC view prefix
spring.view.suffix= # … and suffix
spring.resources.cache-period= # cache timeouts in headers sent to browser
spring.resources.add-mappings=true # if default mappings should be added

#THYMELEAF (ThymeleafAutoConfiguration)
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
spring.thymeleaf.mode=HTML5
spring.thymeleaf.encoding=UTF-8
spring.thymeleaf.content-type=text/html # ;charset= is added
spring.thymeleaf.cache=true # set to false for hot refresh

#FREEMARKER (FreeMarkerAutoConfiguration)
spring.freemarker.allowRequestOverride=false
spring.freemarker.allowSessionOverride=false
spring.freemarker.cache=true
spring.freemarker.checkTemplateLocation=true
spring.freemarker.contentType=text/html
spring.freemarker.exposeRequestAttributes=false
spring.freemarker.exposeSessionAttributes=false
spring.freemarker.exposeSpringMacroHelpers=false
spring.freemarker.prefix=
spring.freemarker.requestContextAttribute=
spring.freemarker.settings.*=
spring.freemarker.suffix=.ftl
spring.freemarker.templateEncoding=UTF-8
spring.freemarker.templateLoaderPath=classpath:/templates/
spring.freemarker.viewNames= # whitelist of view names that can be resolved

#GROOVY TEMPLATES (GroovyTemplateAutoConfiguration)
spring.groovy.template.allowRequestOverride=false
spring.groovy.template.allowSessionOverride=false
spring.groovy.template.cache=true
spring.groovy.template.configuration.*= # See Groovy’s TemplateConfiguration
spring.groovy.template.contentType=text/html
spring.groovy.template.prefix=classpath:/templates/
spring.groovy.template.suffix=.tpl
spring.groovy.template.templateEncoding=UTF-8
spring.groovy.template.viewNames= # whitelist of view names that can be resolved

#VELOCITY TEMPLATES (VelocityAutoConfiguration)
spring.velocity.allowRequestOverride=false
spring.velocity.allowSessionOverride=false
spring.velocity.cache=true
spring.velocity.checkTemplateLocation=true
spring.velocity.contentType=text/html
spring.velocity.dateToolAttribute=
spring.velocity.exposeRequestAttributes=false
spring.velocity.exposeSessionAttributes=false
spring.velocity.exposeSpringMacroHelpers=false
spring.velocity.numberToolAttribute=
spring.velocity.prefix=
spring.velocity.properties.*=
spring.velocity.requestContextAttribute=
spring.velocity.resourceLoaderPath=classpath:/templates/
spring.velocity.suffix=.vm
spring.velocity.templateEncoding=UTF-8
spring.velocity.viewNames= # whitelist of view names that can be resolved

#INTERNATIONALIZATION (MessageSourceAutoConfiguration)
spring.messages.basename=messages
spring.messages.cacheSeconds=-1
spring.messages.encoding=UTF-8

#SECURITY (SecurityProperties)
security.user.name=user # login username
security.user.password= # login password
security.user.role=USER # role assigned to the user
security.require-ssl=false # advanced settings …
security.enable-csrf=false
security.basic.enabled=true
security.basic.realm=Spring
security.basic.path= # /**
security.headers.xss=false
security.headers.cache=false
security.headers.frame=false
security.headers.contentType=false
security.headers.hsts=all # none / domain / all
security.sessions=stateless # always / never / if_required / stateless
security.ignored=false

#DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.name= # name of the data source
spring.datasource.initialize=true # populate using data.sql
spring.datasource.schema= # a schema (DDL) script resource reference
spring.datasource.data= # a data (DML) script resource reference
spring.datasource.platform= # the platform to use in the schema resource (schema-${platform}.sql)
spring.datasource.continueOnError=false # continue even if can’t be initialized
spring.datasource.separator=; # statement separator in SQL initialization scripts
spring.datasource.driverClassName= # JDBC Settings…
spring.datasource.url=
spring.datasource.username=
spring.datasource.password=
spring.datasource.max-active=100 # Advanced configuration…
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=10
spring.datasource.validation-query=
spring.datasource.test-on-borrow=false
spring.datasource.test-on-return=false
spring.datasource.test-while-idle=
spring.datasource.time-between-eviction-runs-millis=
spring.datasource.min-evictable-idle-time-millis=
spring.datasource.max-wait-millis=

#MONGODB (MongoProperties)
spring.data.mongodb.host= # the db host
spring.data.mongodb.port=27017 # the connection port (defaults to 27107)
spring.data.mongodb.uri=mongodb://localhost/test # connection URL
spring.data.mongo.repositories.enabled=true # if spring data repository support is enabled

#JPA (JpaBaseConfiguration, HibernateJpaAutoConfiguration)
spring.jpa.properties.*= # properties to set on the JPA connection
spring.jpa.openInView=true
spring.jpa.show-sql=true
spring.jpa.database-platform=
spring.jpa.database=
spring.jpa.generate-ddl=false # ignored by Hibernate, might be useful for other vendors
spring.jpa.hibernate.naming-strategy= # naming classname
spring.jpa.hibernate.ddl-auto= # defaults to create-drop for embedded dbs
spring.data.jpa.repositories.enabled=true # if spring data repository support is enabled

#SOLR (SolrProperties})
spring.data.solr.host=http://127.0.0.1:8983/solr
spring.data.solr.zkHost=
spring.data.solr.repositories.enabled=true # if spring data repository support is enabled

#ELASTICSEARCH (ElasticsearchProperties})
spring.data.elasticsearch.cluster-name= # The cluster name (defaults to elasticsearch)
spring.data.elasticsearch.cluster-nodes= # The address(es) of the server node (comma-separated;
if not specified starts a client node)
spring.data.elasticsearch.local=true # if local mode should be used with client nodes
spring.data.elasticsearch.repositories.enabled=true # if spring data repository support is
enabled

#FLYWAY (FlywayProperties)
flyway.locations=classpath:db/migrations # locations of migrations scripts
flyway.schemas= # schemas to update
flyway.initVersion= 1 # version to start migration
flyway.prefix=V
flyway.suffix=.sql
flyway.enabled=true
flyway.url= # JDBC url if you want Flyway to create its own DataSource
flyway.user= # JDBC username if you want Flyway to create its own DataSource
flyway.password= # JDBC password if you want Flyway to create its own DataSource

#LIQUIBASE (LiquibaseProperties)
liquibase.change-log=classpath:/db/changelog/db.changelog-master.yaml
liquibase.contexts= # runtime contexts to use
liquibase.default-schema= # default database schema to use
liquibase.drop-first=false
liquibase.enabled=true

#JMX
spring.jmx.enabled=true # Expose MBeans from Spring

#ABBIT (RabbitProperties)
spring.rabbitmq.host= # connection host
spring.rabbitmq.port= # connection port
spring.rabbitmq.addresses= # connection addresses (e.g. myhost:9999,otherhost:1111)
spring.rabbitmq.username= # login user
spring.rabbitmq.password= # login password
spring.rabbitmq.virtualhost=
spring.rabbitmq.dynamic=

#REDIS (RedisProperties)
spring.redis.host=localhost # server host
spring.redis.password= # server password
spring.redis.port=6379 # connection port
spring.redis.pool.max-idle=8 # pool settings …
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1

#ACTIVEMQ (ActiveMQProperties)
spring.activemq.broker-url=tcp://localhost:61616 # connection URL
spring.activemq.user=
spring.activemq.password=
spring.activemq.in-memory=true # broker kind to create if no broker-url is specified
spring.activemq.pooled=false

#HornetQ (HornetQProperties)
spring.hornetq.mode= # connection mode (native, embedded)
spring.hornetq.host=localhost # hornetQ host (native mode)
spring.hornetq.port=5445 # hornetQ port (native mode)
spring.hornetq.embedded.enabled=true # if the embedded server is enabled (needs
hornetq-jms-server.jar)
spring.hornetq.embedded.serverId= # auto-generated id of the embedded server (integer)
spring.hornetq.embedded.persistent=false # message persistence
spring.hornetq.embedded.data-directory= # location of data content (when persistence is enabled)
spring.hornetq.embedded.queues= # comma separate queues to create on startup
spring.hornetq.embedded.topics= # comma separate topics to create on startup
spring.hornetq.embedded.cluster-password= # customer password (randomly generated by default)

#JMS (JmsProperties)
spring.jms.pub-sub-domain= # false for queue (default), true for topic

#SPRING BATCH (BatchDatabaseInitializer)
spring.batch.job.names=job1,job2
spring.batch.job.enabled=true
spring.batch.initializer.enabled=true
spring.batch.schema= # batch schema to load

#AOP
spring.aop.auto=
spring.aop.proxy-target-class=

#FILE ENCODING (FileEncodingApplicationListener)
spring.mandatory-file-encoding=false

#SPRING SOCIAL (SocialWebAutoConfiguration)
spring.social.auto-connection-views=true # Set to true for default connection views or false if
you provide your own

#SPRING SOCIAL FACEBOOK (FacebookAutoConfiguration)
spring.social.facebook.app-id= # your application’s Facebook App ID
spring.social.facebook.app-secret= # your application’s Facebook App Secret

#SPRING SOCIAL LINKEDIN (LinkedInAutoConfiguration)
spring.social.linkedin.app-id= # your application’s LinkedIn App ID
spring.social.linkedin.app-secret= # your application’s LinkedIn App Secret

#SPRING SOCIAL TWITTER (TwitterAutoConfiguration)
spring.social.twitter.app-id= # your application’s Twitter App ID
spring.social.twitter.app-secret= # your application’s Twitter App Secret

#SPRING MOBILE SITE PREFERENCE (SitePreferenceAutoConfiguration)
spring.mobile.sitepreference.enabled=true # enabled by default

#SPRING MOBILE DEVICE VIEWS (DeviceDelegatingViewResolverAutoConfiguration)
spring.mobile.devicedelegatingviewresolver.enabled=true # disabled by default
spring.mobile.devicedelegatingviewresolver.normalPrefix=
spring.mobile.devicedelegatingviewresolver.normalSuffix=
spring.mobile.devicedelegatingviewresolver.mobilePrefix=mobile/
spring.mobile.devicedelegatingviewresolver.mobileSuffix=
spring.mobile.devicedelegatingviewresolver.tabletPrefix=tablet/
spring.mobile.devicedelegatingviewresolver.tabletSuffix=

######ACTUATOR PROPERTIES===

#MANAGEMENT HTTP SERVER (ManagementServerProperties)
management.port= # defaults to ‘server.port’
management.address= # bind to a specific NIC
management.contextPath= # default to ‘/’

#ENDPOINTS (AbstractEndpoint subclasses)
endpoints.autoconfig.id=autoconfig
endpoints.autoconfig.sensitive=true
endpoints.autoconfig.enabled=true
endpoints.beans.id=beans
endpoints.beans.sensitive=true
endpoints.beans.enabled=true
endpoints.configprops.id=configprops
endpoints.configprops.sensitive=true

endpoints.configprops.enabled=true
endpoints.configprops.keys-to-sanitize=password,secret
endpoints.dump.id=dump
endpoints.dump.sensitive=true
endpoints.dump.enabled=true
endpoints.env.id=env
endpoints.env.sensitive=true
endpoints.env.enabled=true
endpoints.health.id=health
endpoints.health.sensitive=false
endpoints.health.enabled=true
endpoints.info.id=info
endpoints.info.sensitive=false
endpoints.info.enabled=true
endpoints.metrics.id=metrics
endpoints.metrics.sensitive=true
endpoints.metrics.enabled=true
endpoints.shutdown.id=shutdown
endpoints.shutdown.sensitive=true
endpoints.shutdown.enabled=false
endpoints.trace.id=trace
endpoints.trace.sensitive=true
endpoints.trace.enabled=true

#MVC ONLY ENDPOINTS
endpoints.jolokia.path=jolokia
endpoints.jolokia.sensitive=true
endpoints.jolokia.enabled=true # when using Jolokia
endpoints.error.path=/error

#JMX ENDPOINT (EndpointMBeanExportProperties)
endpoints.jmx.enabled=true
endpoints.jmx.domain= # the JMX domain, defaults to ‘org.springboot’
endpoints.jmx.unique-names=false
endpoints.jmx.enabled=true
endpoints.jmx.staticNames=

#JOLOKIA (JolokiaProperties)
jolokia.config.*= # See Jolokia manual

#REMOTE SHELL
shell.auth=simple # jaas, key, simple, spring
shell.command-refresh-interval=-1
shell.command-path-pattern= # classpath:/commands/, classpath:/crash/commands/
shell.config-path-patterns= # classpath:/crash/
shell.disabled-plugins=false # don’t expose plugins
shell.ssh.enabled= # ssh settings …
shell.ssh.keyPath=
shell.ssh.port=
shell.telnet.enabled= # telnet settings …
shell.telnet.port=
shell.auth.jaas.domain= # authentication settings …
shell.auth.key.path=
shell.auth.simple.user.name=
shell.auth.simple.user.password=
shell.auth.spring.roles=

#GIT INFO
spring.git.properties= # resource ref to generated git info properties file

单眼皮女孩i

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringBoot

SpringBoot1、SpringBoot入门什么是SpringBoot？Spring Boot 入门小Demo起步依赖引导类启动快速创建并启动2、配置详解SpringMVC实现hello SpringBoot的输出application.properties配置文件application.yml文件读取自定义配置文件信息多环境配置文件多profile文件方式yml多文档方式虚拟机参数激活命令行参数配置加载顺序内部配置加载顺序外部配置加载顺序自定义banner3、Springboot整合其他框架整合jun
复制链接

扫一扫