springboot学习代码汇总

springboot学习代码及配置文件

1、配置文件.

仅代码，没有过多介绍

启动类.

@SpringBootApplication
public class Springboot01ConfigApplication {

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

}

Dog.java.

@Component
@Data
public class Dog implements Serializable {

    private static final long serialVersionUID = 6427446484435308919L;
    private String nickName;
    private Integer age;

}

Person.java.

@Component
@ConfigurationProperties(prefix = "person")
@Validated //数据校验
public class Person implements Serializable {

    private static final long serialVersionUID = -531165355267377822L;


//    @Email(message = "不是一个邮件")
    private String name;
    private Integer age;
    private Boolean isFemale;
    private Date birthday;
    private Map<String, Object> hobbies;
    private List<String> card;
    private Dog dog;


    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Boolean getFemale() {
        return isFemale;
    }

    public void setFemale(Boolean female) {
        isFemale = female;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Map<String, Object> getHobbies() {
        return hobbies;
    }

    public void setHobbies(Map<String, Object> hobbies) {
        this.hobbies = hobbies;
    }

    public List<String> getCard() {
        return card;
    }

    public void setCard(List<String> card) {
        this.card = card;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", isFemale=" + isFemale +
                ", birthday=" + birthday +
                ", hobbies=" + hobbies +
                ", card=" + card +
                ", dog=" + dog +
                '}';
    }
}

application.yaml.

static/application.yaml

#server:
#  port: 8002

person:
  name: ${random.uuid}
  age: ${random.int}
  female: true
  birthday: 1999/2/14
  hobbies: {
    l1: "你好",l2: "不好"
  }
  card: [
    IDCard, BandCard, SchoolCard
  ]
  dog:
    #松散绑定
#    nick-name: liu
#    nick_name: liu
    nick_Name: liu
    age: 3

templates/application.yaml

#server:
#  port: 8003

resource/application.yaml

spring:
  profiles:
    active: test

---
spring:
  profiles: dev

server:
  port: 8000

---
spring:
  profiles: test

server:
  port: 8001

application.properties.

application.properties

# 多环境配置
spring.profiles.active=test

application-dev.properteis

server.port = 8080

application-test.properties

server.port = 8081

测试.

@SpringBootTest
class Springboot01ConfigApplicationTests {

    @Autowired
    private Person person;
    @Test
    void contextLoads() {
        System.out.println(person);
    }

}

pom.xml.

仅含依赖部分

<dependencies>
    <!-- configurationProperties注解需要依赖，没有这个就没有提示 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>

    <!--jsr3参数校验器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>

    <!-- web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- lombok 需要安装插件 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!-- test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

所有的配置信息汇总.

# application配置文件
```properties

# ----------------------------------------
# 核心属性
# ----------------------------------------

# 文件编码
banner.charset= UTF-8
# 文件位置
banner.location= classpath:banner.txt


# 日志配置
# 日志配置文件的位置。 例如对于Logback的`classpath：logback.xml`
logging.config= 
# ％wEx#记录异常时使用的转换字。
logging.exception-conversion-word= 
# 日志文件名。 例如`myapp.log`
logging.file= 
# 日志级别严重性映射。 例如`logging.level.org.springframework =  DEBUG`
logging.level.*= 
# 日志文件的位置。 例如`/ var / log`
logging.path= 
# 用于输出到控制台的Appender模式。 只支持默认的logback设置。
logging.pattern.console= 
# 用于输出到文件的Appender模式。 只支持默认的logback设置。
logging.pattern.file= 
# 日志级别的Appender模式（默认％5p）。 只支持默认的logback设置。
logging.pattern.level= 
#注册日志记录系统的初始化挂钩。
logging.register-shutdown-hook= false


# AOP 切面
# 添加@EnableAspectJAutoProxy。
spring.aop.auto= true
# 是否要创建基于子类（CGLIB）的代理（true），而不是基于标准的基于Java接口的代理（false）。
spring.aop.proxy-target-class= false


# 应用程序上下文初始化器
# 应用指标。
spring.application.index= 
# 应用程序名称。
spring.application.name= 


# 国际化（消息源自动配置）
#
spring.messages.basename= messages
# 以逗号分隔的基础名称列表，每个都在ResourceBundle约定之后。
# 加载的资源束文件缓存到期，以秒为单位。 设置为-1时，软件包将永久缓存。
spring.messages.cache-seconds= -1
# 消息编码。
spring.messages.encoding= UTF-8
# 设置是否返回到系统区域设置，如果没有找到特定语言环境的文件。
spring.messages.fallback-to-system-locale= true


# REDIS (Redis 配置)
# 连接工厂使用的数据库索引。
spring.redis.database= 0
# Redis服务器主机。
spring.redis.host= localhost
# 登录redis服务器的密码。
spring.redis.password= 
# 给定时间池可以分配的最大连接数。 使用负值为无限制。
spring.redis.pool.max-active= 8
# 池中“空闲”连接的最大数量。 使用负值来表示无限数量的空闲连接。
spring.redis.pool.max-idle= 8
# 连接分配在池耗尽之前在抛出异常之前应阻止的最大时间量（以毫秒为单位）。 使用负值无限期地阻止。
spring.redis.pool.max-wait= -1
# 定义池中维护的最小空闲连接数。 此设置只有在正值时才有效果。
spring.redis.pool.min-idle= 0
# redis服务器端口
spring.redis.port= 6379
# redis服务器名称
spring.redis.sentinel.master=
# 
spring.redis.sentinel.nodes= 
# 连接超时（毫秒）。
spring.redis.timeout= 0


# 管理员 （Spring应用程序管理员JMX自动配置）
# 开启应用管理功能。
spring.application.admin.enabled= false
# JMX应用程序名称MBean。
spring.application.admin.jmx-name= org.springframework.boot:type= Admin,name= SpringApplication


# 自动配置
# 自动配置类排除。
spring.autoconfigure.exclude= 


# spring 核心配置
# 跳过搜索BeanInfo类。
spring.beaninfo.ignore= true


# spring 缓存配置
# 由底层缓存管理器支持的要创建的缓存名称的逗号分隔列表。
spring.cache.cache-names= 
# 用于初始化EhCache的配置文件的位置。
spring.cache.ehcache.config= 
# 用于创建缓存的规范。 检查CacheBuilderSpec有关规格格式的更多细节。
spring.cache.guava.spec= 
# 用于初始化Hazelcast的配置文件的位置。
spring.cache.hazelcast.config= 
# 用于初始化Infinispan的配置文件的位置。
spring.cache.infinispan.config= 
# 用于初始化缓存管理器的配置文件的位置。
spring.cache.jcache.config= 
# 用于检索符合JSR-107的缓存管理器的CachingProvider实现的完全限定名称。 只有在类路径上有多个JSR-107实现可用时才需要。
spring.cache.jcache.provider= 
# 缓存类型，默认情况下根据环境自动检测。
spring.cache.type= 


# spring配置 （配置文件应用侦听器）
# 配置文件位置。
spring.config.location= 
# 配置文件名。
spring.config.name= application


# hazelcast配置(Hazelcast是一个高度可扩展的数据分发和集群平台，提供了高效的、可扩展的分布式数据存储、数据缓存.)
# 用于初始化Hazelcast的配置文件的位置。
spring.hazelcast.config= 


# JMX
# JMX域名。
spring.jmx.default-domain= 
# 将管理bean暴露给JMX域。
spring.jmx.enabled= true
# MBean服务器bean名称。
spring.jmx.server= mbeanServer


# Email (MailProperties)  邮件属性
# 默认MimeMessage编码。
spring.mail.default-encoding= UTF-8
# SMTP服务器主机。 例如`smtp.example.com`
spring.mail.host= 
# 会话JNDI名称。 设置时，优先于其他邮件设置。
spring.mail.jndi-name= 
# 登录SMTP服务器的密码。
spring.mail.password= 
# SMTP服务器端口。
spring.mail.port= 
# 其他JavaMail会话属性。
spring.mail.properties.*= 
# SMTP服务器使用的协议。
spring.mail.protocol= smtp
# 测试邮件服务器在启动时可用。
spring.mail.test-connection= false
# 登录SMTP服务器的用户。
spring.mail.username= 


# 应用设置（spring应用）
# 用于在应用程序运行时显示横幅的模式。
spring.main.banner-mode= console
# 源（类名，包名或XML资源位置）包含在ApplicationContext中。
spring.main.sources= 
# 在Web环境中运行应用程序（默认情况下自动检测）。
spring.main.web-environment= 


# 文件编码（文件编码应用程序侦听器）
# 应用程序使用的预期字符编码。
spring.mandatory-file-encoding= 


# 输出
# 配置ANSI输出（可以是“detect”，“always”，“never”）-->“检测”，“永远”，“从不”
spring.output.ansi.enabled= detect


# PID文件（应用程序文件写入器）
# 如果使用ApplicationPidFileWriter但是无法写入PID文件，则失败。
spring.pid.fail-on-write-error= 
# 要写入的PID文件的位置（如果使用ApplicationPidFileWriter）。
spring.pid.file= 


#   简介（profiles 这个单词翻译过来就是这样... 没用过这个属性，有哪位大神用过请留言我改正，感谢。）
# 活动配置文件的逗号分隔列表。
spring.profiles.active= 
# 无条件地激活指定的逗号分隔的配置文件。
spring.profiles.include= 


# SendGrid（SendGrid自动配置）
# SendGrid帐号用户名
spring.sendgrid.username= 
# SendGrid帐号密码
spring.sendgrid.password= 
# SendGrid代理主机
spring.sendgrid.proxy.host= 
# SendGrid代理端口
spring.sendgrid.proxy.port= 


# ----------------------------------------
#   WEB属性
# ----------------------------------------


# 文件上传属性
# 启用对文件上传的支持。
multipart.enabled= true
# 将文件写入磁盘后的阈值。 值可以使用后缀“MB”或“KB”表示兆字节或千字节大小。
multipart.file-size-threshold= 0
# 上传文件的位置。
multipart.location= 
# 最大文件大小。 值可以使用后缀“MB”或“KB”表示兆字节或千字节大小。
multipart.max-file-size= 1Mb
# 最大请求大小。 值可以使用后缀“MB”或“KB”表示兆字节或千字节大小。
multipart.max-request-size= 10Mb


# 嵌入式服务器配置（服务器属性）
# 服务器应绑定到的网络地址。
server.address= 
# 如果启用响应压缩。
server.compression.enabled= false
# 从压缩中排除的用户代理列表。
server.compression.excluded-user-agents= 
# 应该压缩的MIME类型的逗号分隔列表。 例如`text / html，text / css，application / json`
server.compression.mime-types= 
# 执行压缩所需的最小响应大小。 例如2048
server.compression.min-response-size= 
# Servlet上下文初始化参数。 例如`server.context-parameters.a =  alpha`
server.context-parameters.*= 
# 应用程序的上下文路径。
server.context-path= 
# 显示应用程序的名称。
server.display-name= application
# 何时包含“stacktrace”属性。
server.error.include-stacktrace= never
# 错误控制器的路径。
server.error.path= /error
# 启动浏览器中出现服务器错误时显示的默认错误页面。
server.error.whitelabel.enabled= true
# JSP servlet的类名。
server.jsp-servlet.class-name= org.apache.jasper.servlet.JspServlet
# Init参数用于配置JSP servlet
server.jsp-servlet.init-parameters.*= 
# JSP servlet是否被注册
server.jsp-servlet.registered= true
# 服务器HTTP端口。
server.port= 8080
# 主调度程序servlet的路径。
server.servlet-path= /
# 会话cookie的注释。
server.session.cookie.comment= 
# 会话cookie的域。
server.session.cookie.domain= 
# “HttpOnly”标志为会话cookie。
server.session.cookie.http-only= 
# 会话cookie的最大时长（以秒为单位）。
server.session.cookie.max-age= 
# 会话cookie名称。
server.session.cookie.name= 
# 会话cookie的路径。
server.session.cookie.path= 
# 会话cookie的“安全”标志。
server.session.cookie.secure= 
# 重启之间持续会话数据。
server.session.persistent= false
# 用于存储会话数据的目录。
server.session.store-dir= 
# 会话超时（秒）。
server.session.timeout= 
# 会话跟踪模式（以下一个或多个：“cookie”，“url”，“ssl”）。
server.session.tracking-modes= 
# 支持SSL密码。
server.ssl.ciphers= 
# 客户端认证是否需要（“want”）或需要（“need”）。 需要信任存储。
server.ssl.client-auth= 
# ssl配置
server.ssl.enabled= 
server.ssl.key-alias= 
server.ssl.key-password= 
server.ssl.key-store= 
server.ssl.key-store-password= 
server.ssl.key-store-provider= 
server.ssl.key-store-type= 
server.ssl.protocol= 
server.ssl.trust-store= 
server.ssl.trust-store-password= 
server.ssl.trust-store-provider= 
server.ssl.trust-store-type= 
# 创建日志文件的目录。 可以相对于tomcat base dir或absolute。
server.tomcat.accesslog.directory= 
# 启用访问日志。
server.tomcat.accesslog.enabled= false
# 访问日志的格式化模式。
server.tomcat.accesslog.pattern= common
# 日志文件名前缀。
server.tomcat.accesslog.prefix= access_log
# 日志文件名后缀。
server.tomcat.accesslog.suffix= .log
# 在调用backgroundProcess方法之间延迟秒。
server.tomcat.background-processor-delay= 30
# Tomcat基本目录。 如果未指定，将使用临时目录。
server.tomcat.basedir= 
# 正则表达式匹配可信IP地址。
server.tomcat.internal-proxies= 10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|\\192\\.168\\.\\d{1,3}\\.\\d{1,3}|\\169\\.254\\.\\d{1,3}\\.\\d{1,3}|\\127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|\\172\\.1[6-9]{1}\\.\\d{1,3}\\.\\d{1,3}|\\172\\.2[0-9]{1}\\.\\d{1,3}\\.\\d{1,3}|\\172\\.3[0-1]{1}\\.\\d{1,3}\\.\\d{1,3}
# HTTP消息头的最大大小（以字节为单位）。
server.tomcat.max-http-header-size= 0
# 最大工作线程数。
server.tomcat.max-threads= 0
# 用于覆盖原始端口值的HTTP头的名称。
server.tomcat.port-header= X-Forwarded-Port
# 头文件，保存传入协议，通常命名为“X-Forwarded-Proto”。
server.tomcat.protocol-header= 
# 表示传入请求使用SSL的协议头的值。
server.tomcat.protocol-header-https-value= https
# 提取远程ip的HTTP头的名称。 例如`X-FORWARDED-FOR`
server.tomcat.remote-ip-header= 
# 用于解码URI的字符编码。
server.tomcat.uri-encoding= UTF-8
# 访问日志目录。
server.undertow.accesslog.dir= 
# 启用访问日志。
server.undertow.accesslog.enabled= false
# 访问日志的格式化模式。
server.undertow.accesslog.pattern= common
# 每个缓冲区的大小字节数。
server.undertow.buffer-size= 
# 每个区域的缓冲区数。
server.undertow.buffers-per-region= 
# 在Java堆之外分配缓冲区。
server.undertow.direct-buffers= 
# 为工作者创建的I / O线程数。
server.undertow.io-threads= 
# 工作线程数。
server.undertow.worker-threads= 
# 如果X-Forwarded- *头应该应用于HttpRequest。
server.use-forward-headers= 


# 自由标记（自由标记自动配置）
# 设置是否允许HttpServletRequest属性重写（隐藏）控制器生成的同名模型属性。
spring.freemarker.allow-request-override= false
# 设置是否允许HttpSession属性重写（隐藏）控制器生成的相同名称的模型属性。
spring.freemarker.allow-session-override= false
# 启用模板缓存。
spring.freemarker.cache= false
# 模板编码。
spring.freemarker.charset= UTF-8
# 检查模板位置是否存在。
spring.freemarker.check-template-location= true
# Content-Type值。
spring.freemarker.content-type= text/html
# 启用此技术的MVC视图分辨率。
spring.freemarker.enabled= true
# 设置在与模板合并之前是否应将所有请求属性添加到模型中。
spring.freemarker.expose-request-attributes= false
# 设置在与模板合并之前是否应将所有HttpSession属性添加到模型中。
spring.freemarker.expose-session-attributes= false
# 设置是否公开一个RequestContext供Spring 的宏库使用，名称为“springMacroRequestContext”。
spring.freemarker.expose-spring-macro-helpers= true
# 首选文件系统访问模板加载。 文件系统访问可以对模板更改进行热检测。
spring.freemarker.prefer-file-system-access= true
# 前缀，在构建URL时先查看名称。
spring.freemarker.prefix= 
# 所有视图的RequestContext属性的名称。
spring.freemarker.request-context-attribute= 
# 公开的FreeMarker密钥将被传递给FreeMarker的配置。
spring.freemarker.settings.*= 
# 后缀，在构建URL时附加到查看名称。
spring.freemarker.suffix= 
# 逗号分隔的模板路径列表。
spring.freemarker.template-loader-path= classpath:/templates/
# 可以解决的视图名称的白名单。
spring.freemarker.view-names= 


# groovr模板（Groovy模板自动配置）
# 设置是否允许HttpServletRequest属性重写（隐藏）控制器生成的同名模型属性。
spring.groovy.template.allow-request-override= false
# 设置是否允许HttpSession属性重写（隐藏）控制器生成的相同名称的模型属性。
spring.groovy.template.allow-session-override= false
# 启用模板缓存。
spring.groovy.template.cache= 
# 模板编码。
spring.groovy.template.charset= UTF-8
# 检查模板位置是否存在。
spring.groovy.template.check-template-location= true
# 请参阅GroovyMarkupConfigurer
spring.groovy.template.configuration.*= 
# Content-Type值。
spring.groovy.template.content-type= test/html
# 启用此技术的MVC视图分辨率。
spring.groovy.template.enabled= true
# 设置在与模板合并之前是否应将所有请求属性添加到模型中。
spring.groovy.template.expose-request-attributes= false
# 设置在与模板合并之前是否应将所有HttpSession属性添加到模型中。
spring.groovy.template.expose-session-attributes= false
# 设置是否公开一个RequestContext供Spring Spring的宏库使用，名称为“springMacroRequestContext”。
spring.groovy.template.expose-spring-macro-helpers= true
# 前缀，在构建URL时先查看名称。
spring.groovy.template.prefix= 
# 所有视图的RequestContext属性的名称。
spring.groovy.template.request-context-attribute= 
# 模板路径。
spring.groovy.template.resource-loader-path= classpath:/templates/
# 后缀，在构建URL时附加到查看名称。
spring.groovy.template.suffix= .tpl
# 可以解决的视图名称的白名单。
spring.groovy.template.view-names= 


# spring Hateoas 配置
# 指定应用程序/ hal + json响应是否应发送到接受application / json的请求。
spring.hateoas.use-hal-as-default-json-media-type= true


# HTTP 消息转换
# 首选JSON映射程序用于HTTP消息转换。 设置为“gson”强制使用Gson，当它和Jackson都在类路径上时。
spring.http.converters.preferred-json-mapper= jackson


# HTTP 编码（Http编码属性）
# HTTP请求和响应的字符集。 如果未明确设置，则添加到“Content-Type”头。
spring.http.encoding.charset= UTF-8
# 启用http编码支持。
spring.http.encoding.enabled= true
# 将编码强制到HTTP请求和响应上配置的字符集。
spring.http.encoding.force= true


# Jackson(解析json和序列化json) 配置
# 日期格式字符串或全限定日期格式类名。 例如`yyyy-MM-dd HH：mm：ss`。
spring.jackson.date-format= 
# Jones开/关功能，影响Java对象反序列化的方式。
spring.jackson.deserialization.*= 
# 关闭或者打开Jackson 功能
spring.jackson.generator.*= 
# Joda日期时间格式字符串。 如果未配置，如果配置了格式字符串，则“日期格式”将用作后备。
spring.jackson.joda-date-time-format= 
# 用于格式化的区域设置。
spring.jackson.locale= 
# jackson通用开/关功能。
spring.jackson.mapper.*= 
# Jackson 解析器的开/关功能。
spring.jackson.parser.*= 
# Jackson的PropertyNamingStrategy的一个常量。 也可以是PropertyNamingStrategy子类的完全限定类名。
spring.jackson.property-naming-strategy= 
# Jones开/关功能，影响Java对象序列化的方式。
spring.jackson.serialization.*= 
# 控制在序列化期间包含属性。 配置了Jackson的JsonInclude.Include枚举中的一个值。
spring.jackson.serialization-inclusion= 
# 格式化日期时使用的时区。 例如`America / Los_Angeles`
spring.jackson.time-zone= 


# Jersey 配置
# 作为应用程序的基本URI的路径。 如果指定，则覆盖“@ApplicationPath”的值。
spring.jersey.application-path= 
# jersey过滤器链顺序。
spring.jersey.filter.order= 0
#  init参数传递到Jersey通过servlet或过滤器。
spring.jersey.init.*= 
# jersey整合型。可以是“servlet”也可以是“filter”。
spring.jersey.type= servlet


# spring 视图分解器 配置
# 启用后退解析支持。
spring.mobile.devicedelegatingviewresolver.enable-fallback= false
# 启用设备视图解析器。
spring.mobile.devicedelegatingviewresolver.enabled= false
# 前缀，用于查看移动设备的名称。
spring.mobile.devicedelegatingviewresolver.mobile-prefix= mobile/
# 后缀，附加到查看移动设备的名称。
spring.mobile.devicedelegatingviewresolver.mobile-suffix= 
# 前缀，用于查看普通设备的名称。
spring.mobile.devicedelegatingviewresolver.normal-prefix= 
# 后缀，附加到查看普通设备的名称。
spring.mobile.devicedelegatingviewresolver.normal-suffix= 
# 前缀，用于查看平板设备的名称。
spring.mobile.devicedelegatingviewresolver.tablet-prefix= tablet/
# 后缀，附加到查看平板电脑设备的名称。
spring.mobile.devicedelegatingviewresolver.tablet-suffix= 


# 移动网站首选项 （站点首选项自动配置）
# 启用SitePreferenceHandler。
spring.mobile.sitepreference.enabled= true


# MUSTACHE模板（Mustache AutoConfiguration）
# 启用模板缓存。
spring.mustache.cache= false
# 模板编码。
spring.mustache.charset= UTF-8
# 检查模板位置是否存在。
spring.mustache.check-template-location= true
# Content-Type值
spring.mustache.content-type= text/html
# 启用此技术的MVC视图分辨率。
spring.mustache.enabled= true
# 前缀应用于模板名称。
spring.mustache.prefix= classpath:/templates/
# 后缀应用于模板名称。
spring.mustache.suffix= .html
# 可以解决的视图名称的白名单。
spring.mustache.view-names= 


# SPRING MVC (Web Mvc 配置)
# 异步请求处理超时之前的时间量（以毫秒为单位）。
spring.mvc.async.request-timeout= 
# 要使用的日期格式。 例如`dd / MM / yyyy`。
spring.mvc.date-format= 
# 发送TRACE请求到FrameworkServlet doService方法。
spring.mvc.dispatch-trace-request= false
# 发送OPTIONS请求到FrameworkServlet doService方法。
spring.mvc.dispatch-options-request= false
# 启用favicon.ico的解析。
spring.mvc.favicon.enabled= true
# 如果在重定向方案期间应该忽略“默认”模型的内容。
spring.mvc.ignore-default-model-on-redirect= true
# 要使用的区域设置。
spring.mvc.locale= 
# 将文件扩展名映射到内容协商的媒体类型。
spring.mvc.media-types.*= 
# 消息代码格式策略。 例如`PREFIX_ERROR_CODE`。
spring.mvc.message-codes-resolver-format= 
# 用于静态资源的路径模式。
spring.mvc.static-path-pattern= /**
# 如果没有发现处理程序来处理请求，则应抛出“NoHandlerFoundException”。
spring.mvc.throw-exception-if-no-handler-found= false
# Spring MVC视图前缀。
spring.mvc.view.prefix= 
# Spring MVC视图后缀。
spring.mvc.view.suffix= 


 #SPRING RESOURCES HANDLING（ResourceProperties）资源处理
spring.resources.add-mappings = true #启用默认资源处理。
spring.resources.cache-period = #由资源处理程序提供的资源的缓存期，以秒为单位。
spring.resources.chain.cache = true #在资源链中启用缓存。
spring.resources.chain.enabled = #启用Spring资源处理链。默认情况下禁用，除非启用了至少一个策略。
spring.resources.chain.html-application-cache = false #启用HTML5应用程序缓存清单重写。
spring.resources.chain.strategy.content.enabled = false #启用内容版本策略。
spring.resources.chain.strategy.content.paths = / ** #应用于版本策略的模式的逗号分隔列表。
spring.resources.chain.strategy.fixed.enabled = false #启用固定版本策略。
spring.resources.chain.strategy.fixed.paths = #应用于版本策略的逗号分隔的模式列表。
spring.resources.chain.strategy.fixed.version = #用于版本策略的版本字符串。
spring.resources.static-locations = classpath：/ META-INF / resources /，classpath：/ resources /，classpath：/ static /，classpath：/ public / #静态资源的位置。


 #SPRING SOCIAL（SocialWebAutoConfiguration）集群
spring.social.auto-connection-views = false #启用支持的提供程序的连接状态视图。


 #SPRING SOCIAL FACEBOOK（FacebookAutoConfiguration）
spring.social.facebook.app-id = #您的应用程序的Facebook应用程序ID
spring.social.facebook.app-secret = #你的应用程序的Facebook应用程序密码


 #SPRING SOCIAL LINKEDIN（LinkedInAutoConfiguration）
spring.social.linkedin.app-id = #您的应用程序的LinkedIn应用程序ID
spring.social.linkedin.app-secret = #您的应用程序的LinkedIn App Secret


 #SPRING SOCIAL TWITTER（TwitterAutoConfiguration）
spring.social.twitter.app-id = #你的应用程序的Twitter应用程序ID
spring.social.twitter.app-secret = #你的应用程序的Twitter App Secret


 #THYMELEAF Thymeleaf模板引擎配置
spring.thymeleaf.cache = true #启用模板缓存。
spring.thymeleaf.check-template-location = true #检查模板位置是否存在。
spring.thymeleaf.content-type = text / html #Content-Type值。
spring.thymeleaf.enabled = true #启用MVC Thymeleaf视图分辨率。
spring.thymeleaf.encoding = UTF-8 #模板编码。
spring.thymeleaf.excluded-view-names = #应该从解决方案中排除的视图名称的逗号分隔列表。
spring.thymeleaf.mode = HTML5 #应用于模板的模板模式。另请参见StandardTemplateModeHandlers。
spring.thymeleaf.prefix = classpath：/ templates / #在构建URL时预先查看名称的前缀。
spring.thymeleaf.suffix = .html #构建URL时附加查看名称的后缀。
spring.thymeleaf.template-resolver-order = #链中模板解析器的顺序。
spring.thymeleaf.view-names = #可以解析的视图名称的逗号分隔列表。


 #VELOCITY TEMPLATES（VelocityAutoConfiguration）
spring.velocity.allow-request-override = false #设置是否允许HttpServletRequest属性覆盖（隐藏）控制器生成的同名的模型属性。
spring.velocity.allow-session-override = false #设置是否允许HttpSession属性重写（隐藏）控制器生成的同名的模型属性。
spring.velocity.cache = #启用模板缓存。
spring.velocity.charset = UTF-8 #模板编码。
spring.velocity.check-template-location = true #检查模板位置是否存在。
spring.velocity.content-type = text / html #Content-Type值。
spring.velocity.date-tool-attribute = #在视图的Velocity上下文中公开的DateTool辅助对象的名称。
spring.velocity.enabled = true #启用此技术的MVC视图分辨率。
spring.velocity.expose-request-attributes = false #设置在与模板合并之前是否应将所有请求属性添加到模型中。
spring.velocity.expose-session-attributes = false #设置在与模板合并之前是否应将所有HttpSession属性添加到模型中。
spring.velocity.expose-spring-macro-helpers = true #设置是否公开一个RequestContext供Spring Spring的宏库使用，名称为“springMacroRequestContext”。
spring.velocity.number-tool-attribute = #在视图的Velocity上下文中公开的NumberTool帮助对象的名称。
spring.velocity.prefer-file-system-access = true #首选文件系统访问模板加载。文件系统访问可以对模板更改进行热检测。
spring.velocity.prefix = #前缀，用于在构建URL时查看名称。
spring.velocity.properties。* = #附加速度属性。
spring.velocity.request-context-attribute = #所有视图的RequestContext属性的名称。
spring.velocity.resource-loader-path = classpath：/ templates / #模板路径。
spring.velocity.suffix = .vm #构建URL时附加到查看名称的后缀。
spring.velocity.toolbox-config-location = #Velocity Toolbox配置位置。例如`/ WEB-INF / toolbox.xml'
spring.velocity.view-names = #可以解决的视图名称的白名单。






 #----------------------------------------
 #安全属性
 #----------------------------------------
 #SECURITY（SecurityProperties）
security.basic.authorize-mode = role #应用安全授权模式。
security.basic.enabled = true #启用基本身份验证。
security.basic.path = / ** #安全路径的逗号分隔列表。
security.basic.realm = Spring #HTTP基本的领域名称。
security.enable-csrf = false #启用跨站点请求伪造支持。
security.filter-order = 0 #安全过滤器连锁订单。
security.headers.cache = true #启用缓存控制HTTP头。
security.headers.content-type = true# 启用“X-Content-Type-Options”头。
security.headers.frame = true #启用“X-Frame-Options”标题。
security.headers.hsts = # HTTP严格传输安全（HSTS）模式（无，域，全部）。
security.headers.xss = true #启用跨站点脚本（XSS）保护。
security.ignored = #从默认安全路径中排除的路径的逗号分隔列表。
security.require-ssl = false #为所有请求启用安全通道。
security.sessions = stateless #会话创建策略（永远不会，if_required，无状态）。
security.user.name = user #默认用户名。
security.user.password = #默认用户名的密码。默认情况下，启动时会记录随机密码。
security.user.role = USER #为默认用户名授予角色。


 #SECURITY OAUTH2 CLIENT（OAuth2ClientProperties
security.oauth2.client.client-id = #OAuth2客户端ID。
security.oauth2.client.client-secret = #OAuth2客户机密码。默认生成随机密码


 #SECURITY OAUTH2 RESOURCES（ResourceServerProperties
security.oauth2.resource.id = #资源的标识符。
security.oauth2.resource.jwt.key-uri = #JWT令牌的URI。如果值不可用并且密钥是公共的，可以设置。
security.oauth2.resource.jwt.key-value = #JWT令牌的验证密钥。可以是对称秘密或PEM编码的RSA公钥。
security.oauth2.resource.prefer-token-info = true #使用令牌信息，可以设置为false以使用用户信息。
security.oauth2.resource.service-id = resource #
security.oauth2.resource.token-info-uri = #令牌解码端点的URI。
security.oauth2.resource.token-type = #使用userInfoUri时发送的令牌类型。
security.oauth2.resource.user-info-uri = #用户端点的URI。


 #SECURITY OAUTH2 SSO（OAuth2SsoProperties
security.oauth2.sso.filter-order = #如果不提供显式的WebSecurityConfigurerAdapter，则应用过滤器顺序
security.oauth2.sso.login-path = / login #登录页面的路径，即触发重定向到OAuth2授权服务器的路径




# ----------------------------------------
# DATA PROPERTIES 数据性能
# ----------------------------------------


# FLYWAY (FlywayProperties)
flyway.baseline-description = #
flyway.baseline-version = 1 #版本开始迁移
flyway.baseline-on-migrate = #
flyway.check-location = false #检查迁移脚本位置是否存在。
flyway.clean-on-validation-error = #
flyway.enabled = true #启用飞行路线。
flyway.encoding = #
flyway.ignore-failed-future-migration = #
flyway.init-sqls = #执行SQL语句，以便在获取连接后立即初始化连接。
flyway.locations = classpath：db / migration #迁移脚本的位置
flyway.out-of-order = #如果您希望Flyway创建自己的DataSource，则需要使用#path密码
flyway.placeholder-prefix = #
flyway.placeholder-replacement = #
flyway.placeholder-suffix = #
flyway.placeholders。* = #
flyway.schemas = #schemas来更新
flyway.sql-migration-prefix = V #
flyway.sql-migration-separator = #
flyway.sql-migration-suffix = .sql #
flyway.table = #
flyway.url = #要迁移的数据库的JDBC url。如果未设置，则使用主配置的数据源。
flyway.user = #登录要迁移的数据库的用户。
flyway.validate-on-migrate = #


# LIQUIBASE (LiquibaseProperties)
liquibase.change-log = classpath：/db/changelog/db.changelog-master.yaml #更改日志配置路径。
liquibase.check-change-log-location = true #检查更改日志位置是否存在。
liquibase.contexts = #使用逗号分隔的运行时上下文列表。
liquibase.default-schema = #默认数据库模式。
liquibase.drop-first = false #首先删除数据库模式。
liquibase.enabled = true #启用liquidibase支持。
liquibase.labels = #使用逗号分隔的运行时标签列表。
liquibase.parameters。* = #更改日志参数。
liquibase.password = #登录要迁移的数据库的密码。
liquibase.url = #要迁移的数据库的JDBC url。 如果未设置，则使用主配置的数据源。
liquibase.user = #登录要迁移的数据库的用户。



# DAO (PersistenceExceptionTranslationAutoConfiguration)
spring.dao.exceptiontranslation.enabled= true # 启用持久异常翻译后处理器。


# CASSANDRA (CassandraProperties)
spring.data.cassandra.cluster-name = #Cassandra群集的名称。
spring.data.cassandra.compression = #由Cassandra二进制协议支持的压缩。
spring.data.cassandra.connect-timeout-millis = #套接字选项：连接超时。
spring.data.cassandra.consistency-level = #查询一致性级别。
spring.data.cassandra.contact-points = localhost #集群节点地址的逗号分隔列表。
spring.data.cassandra.fetch-size = #查询默认的抓取大小。
spring.data.cassandra.keyspace-name = #要使用的密钥空间名称。
spring.data.cassandra.load-balancing-policy = #负载均衡策略的类名。
spring.data.cassandra.port = #Cassandra服务器端口。
spring.data.cassandra.password = #登录服务器的密码。
spring.data.cassandra.read-timeout-millis = #套接字选项：读取超时。
spring.data.cassandra.reconnection-policy = #重新连接策略类。
spring.data.cassandra.retry-policy = #重试策略的类名。
spring.data.cassandra.serial-consistency-level = #查询串行一致性级别。
spring.data.cassandra.ssl = false #启用SSL支持。
spring.data.cassandra.username = #登录用户的服务器。


# ELASTICSEARCH (ElasticsearchProperties)
spring.data.elasticsearch.cluster-name = elasticsearch #弹性搜索集群名称。
spring.data.elasticsearch.cluster-nodes = #集群节点地址的逗号分隔列表。 如果未指定，则启动客户端节点。
spring.data.elasticsearch.properties。* = #用于配置客户端的其他属性。
spring.data.elasticsearch.repositories.enabled = true #启用Elasticsearch存储库。


# MONGODB (MongoProperties)
spring.data.mongodb.authentication-database = #验证数据库名称。
spring.data.mongodb.database = test #数据库名称。
spring.data.mongodb.field-naming-strategy = #要使用的FieldNamingStrategy的完全限定名称。
spring.data.mongodb.grid-fs-database = #GridFS数据库名称。
spring.data.mongodb.host = localhost #Mongo服务器主机。
spring.data.mongodb.password = #登录mongo服务器的密码。
spring.data.mongodb.port = 27017 #Mongo服务器端口。
spring.data.mongodb.repositories.enabled = true #启用Mongo存储库。
spring.data.mongodb.uri = mongodb：// localhost / test #Mongo数据库URI。 设置时，主机和端口将被忽略。
spring.data.mongodb.username = #登录mongo服务器的用户。


# DATA REST (RepositoryRestProperties)
spring.data.rest.base-path = #由Spring Data REST用于公开存储库资源的基本路径。
spring.data.rest.default-page-size = #页面的默认大小。
spring.data.rest.enable-enum-translation = #通过Spring Data REST默认资源包启用枚举值转换。
spring.data.rest.limit-param-name = #指示一次返回多少结果的URL查询字符串参数的名称。
spring.data.rest.max-page-size = #最大页面大小。
spring.data.rest.page-param-name = #指示要返回的页面的URL查询字符串参数的名称。
spring.data.rest.return-body-on-create = #创建一个实体后返回响应体。
spring.data.rest.return-body-on-update = #更新实体后返回响应体。
spring.data.rest.sort-param-name = #指示排序结果的方向的URL查询字符串参数的名称。


# SOLR (SolrProperties)
spring.data.solr.host = http://127.0.0.1:8983/solr #Solr主机。 如果设置了“zk-host”，则被忽略。
spring.data.solr.repositories.enabled = true #启用Solr存储库。
spring.data.solr.zk-host = #ZooKeeper主机地址，格式为HOST：PORT。


# 数据源 配置 (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.continue-on-error = false #初始化数据库时发生错误时不要停止。
spring.datasource.data = #Data（DML）脚本资源引用。
spring.datasource.driver-class-name = #JDBC驱动程序的完全限定名称。默认情况下，根据URL自动检测。
spring.datasource.initialize = true #使用'data.sql'填充数据库。
spring.datasource.jmx-enabled = false #启用JMX支持（如果由底层池提供）。
spring.datasource.jndi-name = #数据源的JNDI位置。设置时，类，网址，用户名和密码将被忽略。
spring.datasource.max-active = #例如100
spring.datasource.max-idle = #例如8
spring.datasource.max等待=
spring.datasource.min-evictable空闲时间-米利斯=
spring.datasource.min-idle = 8
spring.datasource.name = testdb #数据源的名称。
spring.datasource.password = #登录数据库的密码。
spring.datasource.platform = all #在资源模式（schema - $ {platform} .sql）中使用的平台。
spring.datasource.schema = #Schema（DDL）脚本资源引用。
spring.datasource.separator =;  #语句分隔符在SQL初始化脚本中。
spring.datasource.sql-script-encoding = #SQL脚本编码。
spring.datasource.test-on-borrow = #例如`false`
spring.datasource.test-on-return = #例如`false`
spring.datasource.test-while-idle = #
spring.datasource.time-between-eviction-runs-millis = 1
spring.datasource.type = #要使用的连接池实现的完全限定名称。默认情况下，它是从类路径自动检测的。
spring.datasource.url = #数据库的JDBC url。
spring.datasource.username= 
spring.datasource.validation-query= 


# H2 Web Console (H2ConsoleProperties)  
spring.h2.console.enabled = false #启用控制台。
spring.h2.console.path = / h2-console #控制台可用的路径。


# JOOQ (JooqAutoConfiguration)
spring.jooq.sql-dialect=  # 与配置的数据源通信时使用的SQLDialect JOOQ。 例如`POSTGRES`


# JPA (JpaBaseConfiguration, HibernateJpaAutoConfiguration)
spring.data.jpa.repositories.enabled = true #启用JPA存储库。
spring.jpa.database = #目标数据库进行操作，默认情况下自动检测。可以使用“databasePlatform”属性设置。
spring.jpa.database-platform = #要运行的目标数据库的名称，默认情况下自动检测。可以使用“数据库”枚举来设置。
spring.jpa.generate-ddl = false #启动时初始化模式。
spring.jpa.hibernate.ddl-auto = #DDL模式。这实际上是“hibernate.hbm2ddl.auto”属性的快捷方式。使用嵌入式数据库时默认为“创建删除”，否则为“否”。
spring.jpa.hibernate.naming-strategy = #命名策略完全限定名。
spring.jpa.open-in-view = true #注册OpenEntityManagerInViewInterceptor。将JPA EntityManager绑定到线程以进行请求的整个处理。
spring.jpa.properties。* = #在JPA提供程序上设置的其他本机属性。
spring.jpa.show-sql = false #启用SQL语句的日志记录。


# JTA (JtaAutoConfiguration)
spring.jta。* = #技术特定配置
spring.jta.log-dir = #Transaction logs目录。


# ATOMIKOS
spring.jta.atomikos.connectionfactory.borrow-connection-timeout = 30 #从池中借用连接的超时（以秒为单位）。
spring.jta.atomikos.connectionfactory.ignore-session-transacted-flag = true #创建会话时是否忽略事务标志。
spring.jta.atomikos.connectionfactory.local-transaction-mode = false #是否需要本地事务。
spring.jta.atomikos.connectionfactory.maintenance-interval = 60 #池的维护线程运行之间的时间（以秒为单位）。
spring.jta.atomikos.connectionfactory.max-idle-time = 60 #从池中清除连接之后的时间（以秒为单位）。
spring.jta.atomikos.connectionfactory.max-lifetime = 0 #在被破坏之前可以将连接合并的时间（以秒为单位）。 0表示无限制。
spring.jta.atomikos.connectionfactory.max-pool-size = 1 #池的最大大小。
spring.jta.atomikos.connectionfactory.min-pool-size = 1 #池的最小大小。
spring.jta.atomikos.connectionfactory.reap-timeout = 0 #借用连接的收获超时（以秒为单位）。 0表示无限制。
spring.jta.atomikos.connectionfactory.unique-resource-name = jmsConnectionFactory #用于在恢复期间标识资源的唯一名称。
spring.jta.atomikos.datasource.borrow-connection-timeout = 30 #从池中借出连接的超时（秒）。
spring.jta.atomikos.datasource.default-isolation-level = #池提供的连接的默认隔离级别。
spring.jta.atomikos.datasource.login-timeout = #用于建立数据库连接的超时（以秒为单位）。
spring.jta.atomikos.datasource.maintenance-interval = 60 #池的维护线程运行之间的时间（以秒为单位）。
spring.jta.atomikos.datasource.max-idle-time = 60 #从池中清除连接之后的时间（以秒为单位）。
spring.jta.atomikos.datasource.max-lifetime = 0 #在被破坏之前可以将连接合并的时间（以秒为单位）。 0表示无限制。
spring.jta.atomikos.datasource.max-pool-size = 1 #池的最大大小。
spring.jta.atomikos.datasource.min-pool-size = 1 #池的最小大小。
spring.jta.atomikos.datasource.reap-timeout = 0 #借用连接的收获超时（以秒为单位）。 0表示无限制。
spring.jta.atomikos.datasource.test-query = #用于在返回连接之前验证连接的SQL查询或语句。
spring.jta.atomikos.datasource.unique-resource-name = dataSource #用于在恢复期间识别资源的唯一名称。


# BITRONIX
spring.jta.bitronix.connectionfactory.acquire-increment = 1 #生成池时要创建的连接数。
spring.jta.bitronix.connectionfactory.acquisition-interval = 1 #在获取无效连接后再次尝试获取连接之前等待的时间（以秒为单位）。
spring.jta.bitronix.connectionfactory.acquisition-timeout = 30 #从池中获取连接的超时（以秒为单位）。
spring.jta.bitronix.connectionfactory.allow-local-transactions = true #事务管理器是否允许混合XA和非XA事务。
spring.jta.bitronix.connectionfactory.apply-transaction-timeout = false #当XAResource被登记时，是否应该设置事务超时。
spring.jta.bitronix.connectionfactory.automatic-enlisting-enabled = true #资源是否应该被自动登记和删除。
spring.jta.bitronix.connectionfactory.cache-producer-consumer = true #是否生产和消费者应该被缓存。
spring.jta.bitronix.connectionfactory.defer-connection-release = true #提供程序是否可以在同一连接上运行许多事务，并支持事务交织。
spring.jta.bitronix.connectionfactory.ignore-recovery-failures = false #是否应忽略恢复失败。
spring.jta.bitronix.connectionfactory.max-idle-time = 60 #从池中清除连接之后的时间（以秒为单位）。
spring.jta.bitronix.connectionfactory.max-pool-size = 10 #池的最大大小。 0表示无限制。
spring.jta.bitronix.connectionfactory.min-pool-size = 0 #池的最小大小。
spring.jta.bitronix.connectionfactory.password = #用于连接到JMS提供程序的密码。
spring.jta.bitronix.connectionfactory.share-transaction-connections = false #ACCESSIBLE状态中的连接是否可以在事务的上下文中共享。
spring.jta.bitronix.connectionfactory.test-connections = true #从池中获取连接是否应该进行测试。
spring.jta.bitronix.connectionfactory.two-pc-ordering-position = 1 #在两阶段提交期间该资源应该采取的位置（始终为Integer.MIN_VALUE，始终为Integer.MAX_VALUE）。
spring.jta.bitronix.connectionfactory.unique-name = jmsConnectionFactory #用于在恢复期间标识资源的唯一名称。
spring.jta.bitronix.connectionfactory.use-tm-join = true启动XAResource时是否应使用TMJOIN。
spring.jta.bitronix.connectionfactory.user = #用于连接到JMS提供者的用户。
spring.jta.bitronix.datasource.acquire-increment = 1 #生成池时要创建的连接数。
spring.jta.bitronix.datasource.acquisition-interval = 1 #在获取无效连接后再尝试获取连接之前等待的时间（以秒为单位）。
spring.jta.bitronix.datasource.acquisition-timeout = 30 #从池中获取连接的超时（以秒为单位）。
spring.jta.bitronix.datasource.allow-local-transactions = true #事务管理器是否允许混合XA和非XA事务。
spring.jta.bitronix.datasource.apply-transaction-timeout = false #当XAResource被登记时，是否应该设置事务超时。
spring.jta.bitronix.datasource.automatic-enlisting-enabled = true #资源是否应该被登记和自动删除。
spring.jta.bitronix.datasource.cursor-holdability = #连接的默认游标保持性。
spring.jta.bitronix.datasource.defer-connection-release = true #数据库是否可以在同一连接上运行许多事务，并支持事务交织。
spring.jta.bitronix.datasource.enable-jdbc4-connection-test = #从池中获取连接时是否调用Connection.isValid（）。
spring.jta.bitronix.datasource.ignore-recovery-failures = false #是否应忽略恢复失败。
spring.jta.bitronix.datasource.isolation-level = #连接的默认隔离级别。
spring.jta.bitronix.datasource.local-auto-commit = #本地事务的默认自动提交模式。
spring.jta.bitronix.datasource.login-timeout = #用于建立数据库连接的超时（以秒为单位）。
spring.jta.bitronix.datasource.max-idle-time = 60 #从池中清除连接之后的时间（以秒为单位）。
spring.jta.bitronix.datasource.max-pool-size = 10 #池的最大大小。 0表示无限制。
spring.jta.bitronix.datasource.min-pool-size = 0 #池的最小大小。
spring.jta.bitronix.datasource.prepared-statement-cache-size = 0 #准备好的语句高速缓存的目标大小。 0禁用缓存。
spring.jta.bitronix.datasource.share-transaction-connections = false #ACCESSIBLE状态下的连接是否可以在事务的上下文中共享。
spring.jta.bitronix.datasource.test-query = #用于在返回连接之前验证连接的SQL查询或语句。
spring.jta.bitronix.datasource.two-pc-ordering-position = 1 #在两阶段提交期间该资源应该采取的位置（始终为Integer.MIN_VALUE，始终为Integer.MAX_VALUE）。
spring.jta.bitronix.datasource.unique-name = dataSource #用于在恢复期间标识资源的唯一名称。
spring.jta.bitronix.datasource.use-tm-join = true启动XAResource时是否应使用TMJOIN。



# EMBEDDED MONGODB (EmbeddedMongoProperties)
spring.mongodb.embedded.features = SYNC_DELAY #启用功能的逗号分隔列表。
spring.mongodb.embedded.version = 2.6.10 #Mongo使用版本。



# ----------------------------------------
# 整合属性
# ----------------------------------------

 #ACTIVEMQ（ActiveMQProperties）
spring.activemq.broker-url = #ActiveMQ代理的URL。 默认自动生成。 例如`tcp：// localhost：61616`
spring.activemq.in-memory = true #指定默认代理URL是否应在内存中。 如果指定了一个显式代理，则被忽略。
spring.activemq.password = #登录密码的代理。
spring.activemq.pooled = false #指定是否创建PooledConnectionFactory而不是常规的ConnectionFactory。
spring.activemq.user = #代理登录用户。


# ARTEMIS (ArtemisProperties)
spring.artemis.embedded.cluster-password = #群集密码。 默认情况下随机生成。
spring.artemis.embedded.data-directory = #日志文件目录。 如果持久性被关闭，则不需要。
spring.artemis.embedded.enabled = true #如果Artemis服务器API可用，启用嵌入式模式。
spring.artemis.embedded.persistent = false #启用持久存储。
spring.artemis.embedded.queues = #启动时要创建的队列的逗号分隔列表。
spring.artemis.embedded.server-id = #服务器ID。 默认情况下，使用自动递增的计数器。
spring.artemis.embedded.topics = #启动时要创建的主题的逗号分隔列表。
spring.artemis.host = localhost #Artemis代理主机。
spring.artemis.mode = #Artemis部署模式，默认情况下自动检测。 可以显式设置为“native”或“embedded”。
spring.artemis.port = 61616 #Artemis 中间件端口。


# SPRING BATCH(Batch 配置)
spring.batch.initializer.enabled = true #如果需要，在启动时创建所需的批处理表。
spring.batch.job.enabled = true #在启动时执行上下文中的所有Spring批处理作业。
spring.batch.job.names = #在启动时执行的作业名称的逗号分隔列表（例如`job1，job2`）。 默认情况下，执行在上下文中找到的所有作业。
spring.batch.schema = classpath：org / springframework / batch / core / schema - @@ platform @@。sql #用于初始化数据库模式的SQL文件的路径。
spring.batch.table-prefix = #所有批次元数据表的表前缀。


# HORNETQ (HornetQ 配置)
spring.hornetq.embedded.cluster-password = #集群密码。 默认情况下随机生成。
spring.hornetq.embedded.data-directory = #日志文件目录。 如果持久性被关闭，则不需要。
spring.hornetq.embedded.enabled = true #如果HornetQ服务器API可用，启用嵌入式模式。
spring.hornetq.embedded.persistent = false #启用持久存储。
spring.hornetq.embedded.queues = #启动时要创建的队列的逗号分隔列表。
spring.hornetq.embedded.server-id = #服务器ID。 默认情况下，使用自动递增的计数器。
spring.hornetq.embedded.topics = #在启动时创建的主题的逗号分隔列表。
spring.hornetq.host = localhost #HornetQ代理主机。
spring.hornetq.mode = #HornetQ部署模式，默认情况下自动检测。 可以显式设置为“native”或“embedded”。
spring.hornetq.port = 5445 #HornetQ代理端口。


# JMS (Jms 配置)
# 连接工厂JNDI名称。 设置时，优先于其他连接工厂自动配置。
spring.jms.jndi-name= 
# 容器的确认模式。 默认情况下，监听器被自动确认处理。
spring.jms.listener.acknowledge-mode= 
# 启动时自动启动容器。
spring.jms.listener.auto-startup= true
# 最小并发消费者数。
spring.jms.listener.concurrency= 
# 最大并发消费者数。
spring.jms.listener.max-concurrency= 
# 指定默认的目的地类型是否为主题。
spring.jms.pub-sub-domain= false


# RABBIT (Rabbit 配置)
# 客户端应连接到的逗号分隔的地址列表。
spring.rabbitmq.addresses = 
spring.rabbitmq.dynamic =  true # 创建一个AmqpAdmin bean。
spring.rabbitmq.host =  localhost# RabbitMQ主机。
spring.rabbitmq.listener.acknowledge-mode = # 容器的确认模式。
spring.rabbitmq.listener.auto-startup =  true# 启动时自动启动容器。
spring.rabbitmq.listener.concurrency = # 最少消费者数。
spring.rabbitmq.listener.max-concurrency = # 最大消费者数。
spring.rabbitmq.listener.prefetch = # 在单个请求中要处理的消息数。它应该大于或等于事务大小（如果使用）。
spring.rabbitmq.listener.transaction-size = # 在事务中要处理的消息数。为了获得最佳结果，它应该小于或等于预取计数。
spring.rabbitmq.password = # 登录以对代理进行身份验证。
spring.rabbitmq.port =  5672# RabbitMQ端口。
spring.rabbitmq.requested-heartbeat = # 请求的心跳超时，以秒为单位;零为无。
spring.rabbitmq.ssl.enabled =  false# 启用SSL支持。
spring.rabbitmq.ssl.key-store =  # 保存SSL证书的密钥存储区的路径。
spring.rabbitmq.ssl.key-store-password = # 用于访问密钥库的密码。
spring.rabbitmq.ssl.trust-store = # 保存SSL证书的Trust存储。
spring.rabbitmq.ssl.trust-store-password = # 用于访问信任存储的密码。
spring.rabbitmq.username = # 登录用户对代理进行身份验证。
spring.rabbitmq.virtual-host = # 连接到代理时使用的虚拟主机。


# 端点配置（EndpointCorsProperties）
# 设置是否支持凭据。 未设置时，不支持凭据。
endpoints.cors.allow-credentials= 
# 在请求中允许的头文件逗号分隔列表。 '*'允许所有标题。
endpoints.cors.allowed-headers= 
# 逗号分隔的允许的方法列表。 '*'允许所有方法。
endpoints.cors.allowed-methods= GET
# 逗号分隔的起始列表允许。 '*'允许所有来源。 未设置时，禁用CORS支持。
endpoints.cors.allowed-origins= 
# 包含在响应中的标题的逗号分隔列表。
endpoints.cors.exposed-headers= 
# 客户端可以缓存飞行前请求的响应时间（秒）。
endpoints.cors.max-age= 1800


# JMX ENDPOINT (EndpointMBeanExportProperties) （端点MBean导出属性）
# JMX域名。 如果设置为'spring.jmx.default-domain'的值初始化。
endpoints.jmx.domain= 
# 启用所有端点的JMX导出。
endpoints.jmx.enabled= true
# 附加静态属性以附加到表示端点的MBean的所有对象名称。
endpoints.jmx.static-names= 
# 确保在发生冲突时修改ObjectNames。
endpoints.jmx.unique-names= false


# JOLOKIA  JOLOKIA 配置
# 见Jolokia手册
jolokia.config.*= 


# 管理HTTP服务器（管理服务器属性）
# 在每个响应中添加“X-Application-Context”HTTP头。
management.add-application-context-header= true
# 管理端点应绑定到的网络地址。
management.address= 
# 管理端点上下文路径。 例如`/ actuator`
management.context-path= 
# 管理端点HTTP端口。 默认使用与应用程序相同的端口。
management.port= 
# 启用安全性
management.security.enabled= true
# 访问管理端点所需的角色。
management.security.role= ADMIN
# 会话创建策略使用（always，never，if_required，stateless）（总是，永远，if_required，无状态）。
management.security.sessions= stateless


# HEALTH INDICATORS (previously health.*)
# 启用数据库运行状况检查
management.health.db.enabled= true
# 启用默认的健康指标。
management.health.defaults.enabled= true
# 启用磁盘空间运行状况检查。
management.health.diskspace.enabled= true
# 用于计算可用磁盘空间的路径。
management.health.diskspace.path= 
# 应该可用的最小磁盘空间（以字节为单位）。
management.health.diskspace.threshold= 0
# 启用弹性搜索健康检查。
management.health.elasticsearch.enabled= true
# 逗号分隔的索引名称。
management.health.elasticsearch.indices= 
# 等待群集响应的时间（以毫秒为单位）。
management.health.elasticsearch.response-timeout= 100
# 启用JMS健康检查。
management.health.jms.enabled= true
# 启用邮件运行状况检查。
management.health.mail.enabled= true
# 启用MongoDB健康检查。
management.health.mongo.enabled= true
# 启用RabbitMQ运行状况检查。
management.health.rabbit.enabled= true
# 启用Redis健康检查。
management.health.redis.enabled= true
# 启用Solr运行状况检查。
management.health.solr.enabled= true
# 按照严重性的顺序，以逗号分隔的健康状态列表。
management.health.status.order= DOWN, OUT_OF_SERVICE, UNKNOWN, UP


# TRACING ((TraceProperties) 跟踪性能
# 跟踪中包含的项目。
management.trace.include= request-headers,response-headers,errors


# 远程 shell配置
# 验证类型。 根据环境自动检测。
shell.auth= simple
# JAAS域。
shell.auth.jaas.domain= my-domain
# 验证密钥的路径。 这应该指向一个有效的“.pem”文件。
shell.auth.key.path= 
# 登录用户。
shell.auth.simple.user.name= user
# 登录用户的密码。
shell.auth.simple.user.password= 
# 登录到CRaSH控制台的所需的角色，以逗号分隔列表。
shell.auth.spring.roles= ADMIN
# 用于查找命令的模式。
shell.command-path-patterns= classpath*:/commands/**,classpath*:/crash/commands/**
# 扫描更改并在必要时更新命令（以秒为单位）。
shell.command-refresh-interval= -1
# 用于查找配置的模式。
shell.config-path-patterns= classpath*:/crash/*
# 逗号分隔的要禁用的命令列表。
shell.disabled-commands= jpa*,jdbc*,jndi*
# 禁用逗号分隔的插件列表。 默认情况下，根据环境禁用某些插件。
shell.disabled-plugins= 
# 用户被提示再次登录后的毫秒数。
shell.ssh.auth-timeout = 
# 启用CRaSH SSH支持。
shell.ssh.enabled= true
# 未使用的连接关闭之后的毫秒数。
shell.ssh.idle-timeout = 
# SSH服务器密钥路径。
shell.ssh.key-path= 
# SSH端口。
shell.ssh.port= 2000
# 启用CRaSH telnet支持。 如果TelnetPlugin可用，默认情况下启用。
shell.telnet.enabled= false
# Telnet端口。
shell.telnet.port= 5000


# GIT 信息配置
# 生成的git信息属性文件的资源引用。
spring.git.properties= 


# 标准出口
# 模式，告诉聚合器如何从源存储库中的键。
spring.metrics.export.aggregate.key-pattern= 
# 全局存储库的前缀如果处于活动状态。
spring.metrics.export.aggregate.prefix= 
# 导出刻度之间以毫秒为单位的延迟。 按照这种延迟，指标将按计划导出到外部来源。
spring.metrics.export.delay-millis= 5000
# 标志以启用度量标准导出（假设MetricWriter可用）。
spring.metrics.export.enabled= true
# 要排除的度量名称列表。 应用后包括。
spring.metrics.export.excludes= 
# 要包含的度量名称的模式列表。
spring.metrics.export.includes= 
# redis存储库导出的密钥（如果活动）。
spring.metrics.export.redis.key= keys.spring.metrics
# redis存储库的前缀 如果处于活动状态。
spring.metrics.export.redis.prefix= spring.metrics
# 标志基于不导出不变的度量值来关闭任何可用的优化。
spring.metrics.export.send-latest= 
# 主机的statsd服务器接收导出的指标。
spring.metrics.export.statsd.host= 
# 接收导出指标的statsd服务器端口。
spring.metrics.export.statsd.port= 8125
# statsd导出指标的前缀。
spring.metrics.export.statsd.prefix= 
# 每个MetricWriter bean名称具有特定的触发器属性。
spring.metrics.export.triggers.*= 


# ----------------------------------------
# DEVTOOLS属性
# ----------------------------------------

# DEVTOOLS（开发工具属性）
# 启用一个livereload.com兼容的服务器。
spring.devtools.livereload.enabled= true
#  # Server port.
spring.devtools.livereload.port= 35729
# 应该排除的触发完全重新启动的其他模式。
spring.devtools.restart.additional-exclude= 
# 观看更改的附加路径。
spring.devtools.restart.additional-paths= 
# 启用自动重启功能。
spring.devtools.restart.enabled= true
# 应该排除的模式触发完全重新启动。
spring.devtools.restart.exclude= META-INF/maven/**,META-INF/resources/**,resources/**,static/**,public/**,templates/**,**/*Test.class,**/*Tests.class,git.properties
# 轮询类路径更改之间等待的时间量（以毫秒为单位）。
spring.devtools.restart.poll-interval= 1000
# 触发重新启动之前没有任何类路径更改所需的安静时间量（以毫秒为单位）。
spring.devtools.restart.quiet-period= 400
# 更改后的特定文件的名称将触发重新启动检查。 如果未指定任何类路径文件更改将触发重新启动。
spring.devtools.restart.trigger-file= 


# 远程开发工具属性
# 用于处理远程连接的上下文路径。
spring.devtools.remote.context-path= /.~~spring-boot!~
# 启用远程调试支持。
spring.devtools.remote.debug.enabled= true
# 本地远程调试服务器端口。
spring.devtools.remote.debug.local-port= 8000
# 用于连接到远程应用程序的代理主机。
spring.devtools.remote.proxy.host= 
# 用于连接到远程应用程序的代理端口。
spring.devtools.remote.proxy.port= 
# 启用远程重启。
spring.devtools.remote.restart.enabled= true
# 建立连接所需的共享密钥（需要启用远程支持）。
spring.devtools.remote.secret= 
# HTTP头用于传输共享密钥。
spring.devtools.remote.secret-header-name= X-AUTH-TOKEN
```

2、Web开发.

启动类.

@SpringBootApplication
public class Springboot02WebApplication {

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

}

Config.

LoginHandlerInterceptor.java.

public class LoginHandlerInterceptor implements HandlerInterceptor{
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Object loginUser = request.getSession().getAttribute("loginUser");
        if (loginUser == null){
            request.setAttribute("msg", "没有权限，请先登录");
            request.getRequestDispatcher("/index.html").forward(request,response);
            return false;
        }
        return true;
    }
}

MyLocaleResolver.java.

public class MyLocaleResolver implements LocaleResolver {
    @Override
    public Locale resolveLocale(HttpServletRequest request) {
        Locale defaultLocale = Locale.getDefault();
        String lang = request.getParameter("lang");
        if (!StringUtils.isEmpty(lang)){
            String[] s = lang.split("_");
            System.out.println(lang);
            defaultLocale = new Locale(s[0], s[1]);
        }
        return defaultLocale;
    }

    @Override
    public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale) {

    }
}

MyMvcConfig.java

@Configuration
@EnableWebMvc
public class MyMvcConfig implements WebMvcConfigurer {

    @Bean
    public LocaleResolver localeResolver(){
        return new MyLocaleResolver();
    }


    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        // 视图跳转
        registry.addViewController("/index.html").setViewName("index");
        registry.addViewController("/main.html").setViewName("dashboard");
        registry.addViewController("/list.html").setViewName("list");
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginHandlerInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns("/index.html","/","/css/**","/js/**","/img/**","/user/login");
    }
}

// 自定
class MyViewResolver implements ViewResolver {
    @Override
    public View resolveViewName(String viewName, Locale locale) throws Exception {
        return null;
    }
} 

controller.

EmployeeController.java.

@Controller
public class EmployeeController {

    @Autowired
    private EmployeeDao employeeDao;

    @Autowired
    private DepartmentDao departmentDao;

    @RequestMapping("/emps")
    public String list(Model model){
        Collection<Employee> employees = employeeDao.getEmployees();
        model.addAttribute("list", employees);
        return "list";
    }

    @GetMapping("/emp/add")
    public String toAdd(Model model){
        Collection<Department> departments = departmentDao.getDepartments();
        model.addAttribute("departments",departments);
        return "add";
    }

    @PostMapping("/emp/add")
    public String add(Employee employee){
        employeeDao.save(employee);
        return "redirect:/emps";
    }

    @GetMapping("/emp/edit/{id}")
    public String toEdit(@PathVariable("id") Integer id, Model model){
        Collection<Department> departments = departmentDao.getDepartments();
        Employee employee = employeeDao.getEmployeeById(id);
        model.addAttribute("employee", employee);
        model.addAttribute("departments", departments);

        return "edit";
    }

    @PostMapping("/emp/edit")
    public String edit(Employee employee){
        employeeDao.save(employee);
        return "redirect:/emps";
    }

    @GetMapping("/emp/delete/{id}")
    public String delete(@PathVariable("id") Integer id){
        employeeDao.delete(id);
        return "redirect:/emps";
    }
}

HelloController.java.

@Controller
public class HelloController {

    @RequestMapping("hello")
    public String hello(Model model){
        List<String> list = new ArrayList<>();
        list.add("first row");
        list.add("second row");
        list.add("third row");

        Map<String, Object> map = new HashMap<>();
        map.put("name","liuyou");
        map.put("age", 12);
        map.put("isFemale",true);

        model.addAttribute("msg","<h2>thymeleaf play</h2>");
        model.addAttribute("list",list);
        model.addAttribute("map",map);
        return "hello";
    }

IndexController.java.

@Controller
public class IndexController {


    @RequestMapping(value = {"/"})
    public String index(){
        return "index";
    }
}

LoginController

@Controller
public class LoginController {

    @PostMapping("/user/login")
    public String login(@RequestParam("username") String username, @RequestParam("password") String password, Model model, HttpSession session){
        if (!StringUtils.isEmpty(username) && username.equals("liuyou")){
            session.setAttribute("loginUser",username);
            return "redirect:/main.html";
        }
        model.addAttribute("msg","用户名或密码错误！");
        return "index";
    }

    @GetMapping("/user/logout")
    public String logout(HttpSession session){
        session.invalidate();
        return "redirect:/index.html";
    }
}

dao.

DepartmentDao.java.

@Repository
public class DepartmentDao {

    //模拟数据表(事先存在的 -- static)  <索引, 记录>
    private static Map<Integer, Department> departments = null;

    static {
        departments = new HashMap<>();

        departments.put(101, new Department(101,"教学部"));
        departments.put(102, new Department(102,"市场部"));
        departments.put(103, new Department(103,"教研部"));
        departments.put(104, new Department(104,"运营部"));
        departments.put(105, new Department(105,"后勤部"));
    }

    // 以下 是 dao的操作 只是没有数据库的连接 和 释放

    // 获取所有部门信息
    public Collection<Department> getDepartments(){
        return departments.values();
    }

    // 通过id获取部门
    public Department getDepartmentById(Integer id){
        return departments.get(id);
    }
}

EmployeeDao.java.

@Repository
public class EmployeeDao {
    //模拟数据表(事先存在的 -- static)  <索引, 记录>
    private static Map<Integer, Employee> employees = null;

    @Autowired
    private DepartmentDao departmentDao;

    // 主键自增
    private static Integer initId = 6;


    static {
        employees = new HashMap<>();

        employees.put(1, new Employee(1,"AA","123@qq.com",1,new Date(),new Department(101,"教学部")));
        employees.put(2, new Employee(2,"BB","345@qq.com",0,new Date(),new Department(102,"市场部")));
        employees.put(3, new Employee(3,"CC","234@qq.com",1,new Date(),new Department(103,"教研部")));
        employees.put(4, new Employee(4,"DD","456@qq.com",0,new Date(),new Department(104,"运营部")));
        employees.put(5, new Employee(5,"EE","146@qq.com",1,new Date(),new Department(105,"后勤部")));
    }

    // 以下 是 dao的操作 只是没有数据库的连接 和 释放

    // 获取所有员工信息
    public Collection<Employee> getEmployees(){
        return employees.values();
    }

    // 通过id获取员工
    public Employee getEmployeeById(Integer id){
        return employees.get(id);
    }

    // 添加 一个员工
    public void save(Employee employee){
        if (employee.getId() == null) {
            employee.setId(initId++);
        }
        // 外键
        employee.setDepartment(departmentDao.getDepartmentById(employee.getDepartment().getId()));

        employees.put(employee.getId(),employee);
    }

    // 删除 一个员工
    public void delete(Integer id){
        employees.remove(id);
    }
}

pojo.

Department.java.

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Department implements Serializable {
    private static final long serialVersionUID = 6619420117724195L;

    private Integer id;
    private String departmentName;
}

Employee.java.

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Employee implements Serializable {
    private static final long serialVersionUID = -5357243432996969444L;

    private Integer id;
    private String lastName;
    private String email;
    private Integer gender; // 0 : 女 1 : 男
    private Date birth;

    private Department department;
}

i18n.

login.properties.

login.btn=登录
login.password=密码
login.remember=记住我
login.tip=请登录
login.username=用户名

login_en_US.properties.

login.btn=login in
login.password=Password
login.remember=Remember me
login.tip=Please sign in
login.username=username

login_zh_CN.properties.

login.btn=登录
login.password=密码
login.remember=记住我
login.tip=请登录
login.username=用户名

静态资源文件.

链接：https://pan.baidu.com/s/1i5fMFV0v-aBF8T-VNEfR8g
提取码：12jd
复制这段内容后打开百度网盘手机App，操作更方便哦

application.yaml.

server:
  port: 8000
  servlet:
    context-path: /

# thymeleaf 缓存 关掉
spring:
  thymeleaf:
    cache: false
# 国际化配置文件的 真实位置
  messages:
    basename: i18n.login

  mvc:
    locale:

    format:
      date:

pom.xml.

<dependencies>
    <!-- web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- thymeleaf -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <!-- lombok 需要安装插件 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!-- test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

3、Data.

启动类.

@SpringBootApplication
public class DataApplication {

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

}

Config.

DruidConfig.java.

@Configuration
public class DruidConfig {

    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druidDataSource(){
        return new DruidDataSource();
    }

    // 后台监控 这个相当于 Web.xml
    // 因为 SpringBoot 内置了 servlet容器，所以没有web.xml
    // 替代方法 ServletRegistrationBean
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(),"/druid/*");

        // 后台需要有人登陆，账号密码配置
        HashMap<String,String> initParameters = new HashMap<>();
        // 增加配置
        initParameters.put("loginUsername","admin");// 这两个是固定的
        initParameters.put("loginPassword","123456");

        // 允许谁可以访问 后面是ip地址
        initParameters.put("allow","");
        // 禁止谁访问 initParameters.put("名字","ip") deny

        bean.setInitParameters(initParameters); //设置初始化参数
        return bean;
    }

    // filter
    @Bean
    public FilterRegistrationBean webStatFilter(){
        // 创建过滤器
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());

        // 可以过滤的请求
        bean.addUrlPatterns("/*");
        // 忽略
        bean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        return bean;
    }
}

Controller.

JDBCController.java.

@RestController
public class JDBCController {

    @Autowired
    JdbcTemplate jdbcTemplate;

    // 查询数据库的所以信息
    @RequestMapping("/userList")
    public List<Map<String, Object>> userList(){
        String sql = "select * from mybatis.user";
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
        return maps;
    }

    @RequestMapping("/addUser")
    public String addUser(){
        String sql = "insert into mybatis.user(name,pwd) values('heihei','buheihei')";

        Integer update = jdbcTemplate.update(sql);
        return update.toString();
    }

    @RequestMapping("/updateUser")
    public String updateUser(){
        String sql = "update mybatis.user set name = ?,pwd = ? where id = ?";

        // 参数
        Object[] params = {"kaikai","liuminkai",2};

        Integer update = jdbcTemplate.update(sql, params);
        return update.toString();
    }

    @RequestMapping("/deleteUser")
    public String deleteUser(){
        String sql = "delete from mybatis.user where id = ?";

        Integer update = jdbcTemplate.update(sql, 1);
        return update.toString();
    }
}

application.properties.

# 数据库连接
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=mysql
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# 指定数据源
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

# druid 数据源专有配置
spring.datasource.druid.initial-size=5
spring.datasource.druid.min-idle=5
spring.datasource.druid.max-active=20
spring.datasource.druid.max-wait=60000
spring.datasource.druid.time-between-eviction-runs-millis=60000
spring.datasource.druid.min-evictable-idle-time-millis=300000
spring.datasource.druid.validation-query=SELECT 1 FROM DUAL
spring.datasource.druid.test-while-idle=true
spring.datasource.druid.test-on-borrow=false
spring.datasource.druid.test-on-return=false
spring.datasource.druid.pool-prepared-statements=true

# 配置监控统计拦截的filters、stat:监控统计、log4j:日志记录、wall、防御sql注入
# 使用日志 需要导入 log4j
spring.datasource.druid.filters=stat,wall,log4j
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20
spring.datasource.druid.use-global-data-source-stat=true
spring.datasource.druid.connection-properties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

测试.

@SpringBootTest
class DataApplicationTests {

    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
        // 查看默认的数据源 class com.zaxxer.hikari.HikariDataSource
        System.out.println(dataSource.getClass());

        // 获取数据库的连接
        Connection connection = dataSource.getConnection();

        // xxx Template : SpringBoot 写好的Bean 可以直接用
        // jdbcTemplate
        // redisTemplate\
        // ...

        // 关闭连接
        connection.close();
    }

}

pom.xml.

<dependencies>
    <!-- druid -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.24</version>
    </dependency>
    <!-- log4j -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
    <!-- jdbc -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <!-- web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- mysql connector -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- lombok 需要按装插件 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!-- test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

4、mybatis.

启动类.

@SpringBootApplication
public class MybatisApplication {

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

}

Controller.

@RestController
public class UserController {

    @Autowired
    private UserMapper userMapper;

    @RequestMapping("/add")
    public String addUser(){
        User user = new User(null,"大漂亮","木有");
        userMapper.addUser(user);
        return "add ok";
    }

    @RequestMapping("/delete/{id}")
    public String deleteUser(@PathVariable("id") Integer id){
        userMapper.deleteUser(id);
        return "delete ok";
    }

    @RequestMapping("/update/{id}")
    public String update(@PathVariable("id") Integer id){
        User user = new User(id,"小娘炮","木有");
        userMapper.updateUser(user);
        return "update ok";
    }

    @RequestMapping("/query")
    public List<User> query(){
        return userMapper.queryUserList();
    }

    @RequestMapping("/query/{id}")
    public User query(@PathVariable("id") Integer id){
        return userMapper.queryUserById(id);
    }
}

mapper.

UserMapper.java

@Mapper //表示这是一个mybatis 的 mapper类 ： Dao
@Repository // spring容器接管
public interface UserMapper {

    List<User> queryUserList();

    User queryUserById(Integer id);

    Integer addUser(User user);

    Integer updateUser(User user);

    Integer deleteUser(Integer id);
}

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.liuyou.mapper.UserMapper">
    <insert id="addUser" parameterType="user">
        insert into mybatis.user(name, pwd)
        values(#{name},#{pwd})
    </insert>

    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user
        where
        id = #{id}
    </delete>

    <update id="updateUser" parameterType="user">
        update mybatis.user
        <set>
            <if test="name != null">
                name = #{name},
            </if>
            <if test="pwd != null">
                pwd = #{pwd},
            </if>
        </set>
        where
        id = #{id}
    </update>

    <select id="queryUserList" resultType="user">
        select * from mybatis.user
    </select>

    <select id="queryUserById" parameterType="int" resultType="user">
        select * from mybatis.user
        where id = #{id}
    </select>

</mapper>

pojo.

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String name;
    private String pwd;
}

application.properties.

# 数据库连接
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=mysql
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
# 指定数据源


# MyBatis
# 别名
mybatis.type-aliases-package=com.liuyou.pojo 
# 本地配置文件
#mybatis.config-location=
# 绑定Mapper.xml 注意：classpath: 后别跟 /
mybatis.mapper-locations=classpath:mapper/*.xml

测试.

@SpringBootTest
class MybatisApplicationTests {

    @Autowired
    DataSource dataSource;


    @Test
    void contextLoads() {
        System.out.println(dataSource.getClass());
    }

}

pom.xml.

<dependencies>
    <!--jdbc-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <!-- web -->
    <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.1.3</version>
    </dependency>
    <!-- mysql connector -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- lombok 需要安装插件 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!-- test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

5、SpringSecurity.

启动类.

@SpringBootApplication
public class SecurityApplication {

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

}

Config.

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    // 授权
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 首页所有人都可以访问 功能页只有对应 有权限的人才能访问
        // 请求授权的规则
        http.authorizeRequests()
                .antMatchers("/").permitAll()
                .antMatchers("/level1/**").hasRole("vip1")
                .antMatchers("/level2/**").hasRole("vip2")
                .antMatchers("/level3/**").hasRole("vip3");

        // 没有权限默认会跳到登录页面
        http.formLogin()
                .loginPage("/toLogin") // 定制登录页 没有权限自动跳到这个登录页
                .loginProcessingUrl("/login") // 表单提交 如果只有loginPage 那么跳转和表单都是同一个url
//                .failureForwardUrl("/toLogin") // 失败跳转 url
                .failureUrl("/toLogin")
                .successForwardUrl("/index.html") // 成功跳转 url
                .usernameParameter("username") // 设定 表单中的 用户名的 name
                .passwordParameter("password"); // 设定 表单中的 密码的 name


        //
        // cors csrf
        http.csrf().disable();


        // 注销  点击注销 会 出现 404 -- 需要关闭csrf
        /*
            触发注销发生的URL(默认为“/logout”)。如果CSRF保护
            如果启用(默认)，则请求也必须是POST。这意味着
            默认的POST“/注销”是必须触发注销。如果CSRF保护是
            禁用，那么任何HTTP方法都是允许的。
         */
        http.logout()
                .logoutUrl("/logout")
                .logoutSuccessUrl("/");

        // 开启记住我功能 cookie 默认保存2周
        http.rememberMe()
                .rememberMeParameter("remember") // 表单中 记住我 的 name
                .rememberMeCookieName("rememberme"); // cookie 的名字
    }

    // 认证
    // springboot 2.1.x 可以直接使用
    // 密码编码 -- PasswordEncode -- 明文密码 可能会被反编译获取
    // 在Spring Security 5.0+ 新增了很多加密方法
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 内存中 虚拟数据
        auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder())
                .withUser("liuyou").password(new BCryptPasswordEncoder().encode("liuyou")).roles("vip1")
                .and()
                .withUser("root").password(new BCryptPasswordEncoder().encode("root")).roles("vip1","vip2","vip3");

        // 数据库
//        auth.jdbcAuthentication()
    }
}

Controller.

@Controller
public class RouterController {

    @RequestMapping({"/","/index","/index.html"})
    public String index(){
        return "index";
    }

    @RequestMapping("/toLogin")
    public String toLogin(){
        return "views/login";
    }


    @RequestMapping("/level1/{id}")
    public String level1(@PathVariable("id") Integer id){
        return "views/level1/" + id;
    }

    @RequestMapping("/level2/{id}")
    public String level2(@PathVariable("id") Integer id){
        return "views/level2/" + id;
    }

    @RequestMapping("/level3/{id}")
    public String level3(@PathVariable("id") Integer id) {
        return "views/level3/" + id;
    }
}

静态资源及页面.

链接：https://pan.baidu.com/s/124Hj819hAjobn5MHaExN_Q
提取码：bd92
复制这段内容后打开百度网盘手机App，操作更方便哦

pom.xml.

<dependencies>
    <!-- thymeleaf -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <!-- security -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <!-- web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
     <!-- thymeleaf-security -->
    <dependency>
        <groupId>org.thymeleaf.extras</groupId>
        <artifactId>thymeleaf-extras-springsecurity5</artifactId>
        <version>3.0.4.RELEASE</version>
    </dependency>
    <!-- lombok 需要安装插件 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!-- test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

6、shiro.

(1)hello.

Quickstart.java.

//import org.apache.shiro.SecurityUtils;
//import org.apache.shiro.authc.*;
//import org.apache.shiro.mgt.DefaultSecurityManager;
//import org.apache.shiro.realm.text.IniRealm;
//import org.apache.shiro.session.Session;
//import org.apache.shiro.subject.Subject;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
//原来的路径是 import org.apache.shiro.ini.IniSecurityManagerFactory;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
//原来的路径是 import org.apache.shiro.lang.util.Factory;
import org.apache.shiro.util.Factory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author liuminkai
 * @version 1.0
 * @datetime 2020/10/1 11:02
 * @decription
 **/

public class Quickstart {

    private static final transient Logger log = LoggerFactory.getLogger(Quickstart.class);


    public static void main(String[] args) {

        // The easiest way to create a Shiro SecurityManager with configured
        // realms, users, roles and permissions is to use the simple INI config.
        // We'll do that by using a factory that can ingest a .ini file and
        // return a SecurityManager instance:

        // Use the shiro.ini file at the root of the classpath
        // (file: and url: prefixes load from files and urls respectively):
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = factory.getInstance();

//        DefaultSecurityManager securityManager = new DefaultSecurityManager();
//        IniRealm iniRealm = new IniRealm("classpath:shiro.ini");
//        securityManager.setRealm(iniRealm);

        // for this simple example quickstart, make the SecurityManager
        // accessible as a JVM singleton.  Most applications wouldn't do this
        // and instead rely on their container configuration or web.xml for
        // webapps.  That is outside the scope of this simple quickstart, so
        // we'll just do the bare minimum so you can continue to get a feel
        // for things.
        SecurityUtils.setSecurityManager(securityManager);

        // Now that a simple Shiro environment is set up, let's see what you can do:

        // 获取当前用户对象
        Subject currentUser = SecurityUtils.getSubject();

        // 通过当前用户拿到session（shiro的）
        Session session = currentUser.getSession();
        session.setAttribute("someKey", "aValue"); // 存值
        String value = (String) session.getAttribute("someKey"); // 取值
        if (value.equals("aValue")) {
            log.info("Retrieved the correct value! [" + value + "]");
        }

        // 测试当前用户 是否被认证
        if (!currentUser.isAuthenticated()) {
            // 通过 账号和密码 生成 令牌
            UsernamePasswordToken token = new UsernamePasswordToken("lonestarr", "vespa");
            token.setRememberMe(true); // 记住我
            try {
                currentUser.login(token); // 执行登录操作
            } catch (UnknownAccountException uae) { // 用户不存在
                log.info("There is no user with username of " + token.getPrincipal());
            } catch (IncorrectCredentialsException ice) { // 密码不对
                log.info("Password for account " + token.getPrincipal() + " was incorrect!");
            } catch (LockedAccountException lae) { // 密码锁定
                log.info("The account for username " + token.getPrincipal() + " is locked.  " +
                        "Please contact your administrator to unlock it.");
            }
            // ... catch more exceptions here (maybe custom ones specific to your application?
            catch (AuthenticationException ae) { // 认证失败
                //unexpected condition?  error?
            }
        }

        //say who they are:
        //print their identifying principal (in this case, a username):
        // 获取当前用户的认证
        log.info("User [" + currentUser.getPrincipal() + "] logged in successfully.");

        //test a role:
        if (currentUser.hasRole("schwartz")) {
            log.info("May the Schwartz be with you!");
        } else {
            log.info("Hello, mere mortal.");
        }

        //test a typed permission (not instance-level)
        // 粗粒度权限 *
        if (currentUser.isPermitted("lightsaber:wield")) {
            log.info("You may use a lightsaber ring.  Use it wisely.");
        } else {
            log.info("Sorry, lightsaber rings are for schwartz masters only.");
        }

        //a (very powerful) Instance Level permission:
        // 细粒度权限 指定
        if (currentUser.isPermitted("winnebago:drive:eagle5")) {
            log.info("You are permitted to 'drive' the winnebago with license plate (id) 'eagle5'.  " +
                    "Here are the keys - have fun!");
        } else {
            log.info("Sorry, you aren't allowed to drive the 'eagle5' winnebago!");
        }

        //all done - log out!
        // 注销
        currentUser.logout();
        // 结束
        System.exit(0);
    }
}

log4j.properties.

log4j.rootLogger=INFO, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n

# General Apache libraries
log4j.logger.org.apache=WARN

# Spring
log4j.logger.org.springframework=WARN

# Default Shiro logging
log4j.logger.org.apache.shiro=INFO

# Disable verbose logging
log4j.logger.org.apache.shiro.util.ThreadContext=WARN
log4j.logger.org.apache.shiro.cache.ehcache.EhCache=WARN

shiro.ini.

[users]
# user 'root' with password 'secret' and the 'admin' role
root = secret, admin
# user 'guest' with the password 'guest' and the 'guest' role
guest = guest, guest
# user 'presidentskroob' with password '12345' ("That's the same combination on
# my luggage!!!" ;)), and role 'president'
presidentskroob = 12345, president
# user 'darkhelmet' with password 'ludicrousspeed' and roles 'darklord' and 'schwartz'
darkhelmet = ludicrousspeed, darklord, schwartz
# user 'lonestarr' with password 'vespa' and roles 'goodguy' and 'schwartz'
lonestarr = vespa, goodguy, schwartz

# -----------------------------------------------------------------------------
# Roles with assigned permissions
#
# Each line conforms to the format defined in the
# org.apache.shiro.realm.text.TextConfigurationRealm#setRoleDefinitions JavaDoc
# -----------------------------------------------------------------------------
[roles]
# 'admin' role has all permissions, indicated by the wildcard '*'
admin = *
# The 'schwartz' role can do anything (*) with any lightsaber:
schwartz = lightsaber:*
# The 'goodguy' role is allowed to 'drive' (action) the winnebago (type) with
# license plate 'eagle5' (instance specific id)
goodguy = winnebago:drive:eagle5

pom.xml.

<dependencies>
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-core</artifactId>
        <version>1.4.0</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>jcl-over-slf4j</artifactId>
        <version>1.7.30</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.12</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
</dependencies>

(2)springboot.

启动类.

@SpringBootApplication
public class Shiro02SpringbootApplication {

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

}

Config.

ShiroConfig.java.

package com.liuyou.config;

import at.pollux.thymeleaf.shiro.dialect.ShiroDialect;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @author liuminkai
 * @version 1.0
 * @datetime 2020/10/1 15:22
 * @decription
 **/
@Configuration
public class ShiroConfig {

    // 1.创建 realm对象，需要自定义
    @Bean
    public UserRealm userRealm(){
        return new UserRealm();
    }

    // 2.DefaultWebSecurityManager
    @Bean(name = "securityManager")
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("userRealm") UserRealm userRealm){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 关联UserRealm
        securityManager.setRealm(userRealm);
        return securityManager;
    }

    // 3.ShiroFilterFactoryBean
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(@Qualifier("securityManager") DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
        // 设置安全管理器
        bean.setSecurityManager(defaultWebSecurityManager);

        //添加shiro过滤器
        /*
            anon：无需认证就可以访问
            authc：必须认证才能访问

            user：必须拥有 记住我 功能才能用
            perms：拥有对某个资源的权限 才能访问
            role：拥有了某个角色 才能访问
         */
        Map<String, String> filterMap = new LinkedHashMap<>();

        /*
            请求的过滤 在这里
            认证在 UserRealm 里
            这里只是 保证 哪些页面或请求 只有 登录认证成功后 才能进入
         */
        //  请求过滤（认证过滤）
        // 支持通配符 * 即 /user/*
        filterMap.put("/add","authc"); // 请求 路径/add 时 必须需要通过 认证(即登录)
        filterMap.put("/update","authc");
        filterMap.put("/list","authc");


        /*
            权限过滤 在这里
            授权在 UserRealm 里
            这里 用于 区分 不同用户使用的功能 不同
         */
        //  权限过滤（授权过滤）
        filterMap.put("/add","perms[user:add]");// 必须拥有user:add权限才能访问
        filterMap.put("/update","perms[user:update]");
        filterMap.put("/list","perms[user:list]");

        bean.setFilterChainDefinitionMap(filterMap);

        /*
             认证失败 跳到的页面
         */
        // 设置 登录页
        bean.setLoginUrl("/toLogin"); // 如果 没有认证 就会根据这个路径跳到登录页
        /*
            用户没有改权限 跳该页面
         */
        // 设置 未授权页
        bean.setUnauthorizedUrl("/unauthorized");

        // 登录成功url
//        bean.setSuccessUrl();
        return bean;
    }


    // 整合ShiroDialect : 用于整合 shiro thymeleaf
    @Bean
    public ShiroDialect getShiroDialect(){
        return new ShiroDialect();
    }
}

UserRealm.java.

package com.liuyou.config;

import com.liuyou.pojo.User;
import com.liuyou.service.UserService;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Collections;

/**
 * @author liuminkai
 * @version 1.0
 * @datetime 2020/10/1 15:24
 * @decription
 **/
// 自定义的UserRealm 需要继承 AuthorizingRealm
public class UserRealm extends AuthorizingRealm {

    @Autowired
    UserService userService;

    // 授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("授权");
        /*
            过滤 在ShiroConfig
            授权 在这里 主要是 给不同的用户 赋予对应的 权限
         */
        // 
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

        // 获取当前登录的对象
        Subject subject = SecurityUtils.getSubject();
        User currentUser = (User) subject.getPrincipal(); // 获取登录用户(需要认证 中传递过来)

        // 赋予权限（从数据库中读取权限 -- 然后赋予当前用户权限）
        info.addStringPermission(currentUser.getPerms());

        return info;
    }

    // 认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("认证");

        /*
            过滤 在ShiroConfig
            登录 在controller
            认证 在这里 主要是 对用户密码做确认
         */
        // 数据库中取密码 或 内存中 这里伪造
//        String name = "root";
//        String pwd = "root";

        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;

        // 连接真实的数据库
        User user = userService.queryUserByName(token.getUsername());
        // 用户认证
        if (user == null){ // 没有用户
            return null; // 抛出异常 UnknownAccountException
        }

        // 设置session 过时了
//        Subject subject = SecurityUtils.getSubject();
//        Session session = subject.getSession();
//        session.setAttribute("loginUser",user);

        // 密码认证， shiro 帮我们做了 （密码加密了）
        /*
            principal(主要的,资本): 用户 认证的一些信息(这里 一般传用户信息 当然可以传别的)
            credentials(证书): 密码
            realmName(区域名):
         */
        return new SimpleAuthenticationInfo(user,user.getPwd(),"");
    }
}

Controller.

package com.liuyou.controller;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpSession;

/**
 * @author liuminkai
 * @version 1.0
 * @datetime 2020/10/1 15:03
 * @decription
 **/
@Controller
public class MyController {

    @RequestMapping("/")
    public String index(Model model){
        model.addAttribute("msg","shiro index");
        return "index";
    }

    @RequestMapping("/list")
    public String list(){
        return "list";
    }
    @RequestMapping("/add")
    public String add(){
        return "add";
    }
    @RequestMapping("/update")
    public String update(){
        return "update";
    }

    @RequestMapping("/toLogin")
    public String toLogin(){
        return "login";
    }

    @RequestMapping("login")
    public String login(String username, String password,Model model){
        // 获取当前用户
        Subject subject = SecurityUtils.getSubject();
        // 封装用户的登录数据
        UsernamePasswordToken token = new UsernamePasswordToken(username, password);

        // 用户登录
        try {
            subject.login(token);
        }  catch (UnknownAccountException uae) { // 用户不存在
            model.addAttribute("msg", "用户名错误");
            return "index";
        } catch (IncorrectCredentialsException ice) { // 密码不对
            model.addAttribute("msg", "密码不对");
            return "index";
        } catch (LockedAccountException lae) { // 密码锁定
            model.addAttribute("msg", "密码锁定");
            return "index";
        } catch (AuthenticationException e) {
            e.printStackTrace();
        }
        return "index";
    }

    @RequestMapping("/unauthorized")
    @ResponseBody
    public String unauthorized(){
        return "unauthorized";
    }

    @RequestMapping("/logout")
    public String logout(){
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        return "redirect:/toLogin";
    }

//    @RequestMapping("/logout")
//    public String logout(HttpSession session){
//        session.invalidate();
//        return "redirect:/toLogin";
//    }
}

Service.

public interface UserService {
    User queryUserByName(String name);
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    UserMapper userMapper;

    @Override
    public User queryUserByName(String name) {
        return userMapper.queryUserByName(name);
    }
}

mapper.

UserMapper.java.

@Mapper
@Repository
public interface UserMapper {

    User queryUserByName(String name);
}

UserMapper.xml.

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.liuyou.mapper.UserMapper">
    <select id="queryUserByName" parameterType="string" resultType="user">
        select * from mybatis.user
        where
        name = #{name}
    </select>
</mapper>

pojo.

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String name;
    private String pwd;
    private String perms;
}

页面.

链接：https://pan.baidu.com/s/19D9cLcO5XURdK2E4VeQ4ug
提取码：kna9
复制这段内容后打开百度网盘手机App，操作更方便哦

application.properties.

# 数据库连接
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=mysql
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# 指定数据源
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

# druid 数据源专有配置
spring.datasource.druid.initial-size=5
spring.datasource.druid.min-idle=5
spring.datasource.druid.max-active=20
spring.datasource.druid.max-wait=60000
spring.datasource.druid.time-between-eviction-runs-millis=60000
spring.datasource.druid.min-evictable-idle-time-millis=300000
spring.datasource.druid.validation-query=SELECT 1 FROM DUAL
spring.datasource.druid.test-while-idle=true
spring.datasource.druid.test-on-borrow=false
spring.datasource.druid.test-on-return=false
spring.datasource.druid.pool-prepared-statements=true

# 配置监控统计拦截的filters、stat:监控统计、log4j:日志记录、wall、防御sql注入
# 使用日志 需要导入 log4j
spring.datasource.druid.filters=stat,wall,log4j
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=20
spring.datasource.druid.use-global-data-source-stat=true
spring.datasource.druid.connection-properties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500


# mybatis配置
mybatis.type-aliases-package=com.liuyou.pojo
mybatis.mapper-locations=classpath:mapper/*.xml

pom.xml.

<dependencies>
    <dependency>
        <groupId>com.github.theborakompanioni</groupId>
        <artifactId>thymeleaf-extras-shiro</artifactId>
        <version>2.0.0</version>
    </dependency>

    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.3</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.24</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-spring-boot-web-starter</artifactId>
        <version>1.6.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </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>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

7、swagger.

启动类.

@SpringBootApplication
public class SwaggerApplication {

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

}

Config.

package com.liuyou.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.core.env.Profiles;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

import javax.print.Doc;
import java.util.ArrayList;

/**
 * @author liuminkai
 * @version 1.0
 * @datetime 2020/10/4 12:09
 * @decription
 **/
@Configuration
@EnableSwagger2 // 开启swagger2
public class SwaggerConfig {

    // 配置了Swagger的Docket的Bean实例
    @Bean
    public Docket docket(Environment environment){

        // 设置要显示的 Swagger 环境 -- 当然可以使用 注解代替
        Profiles profiles = Profiles.of("dev", "test");// 希望测试环境 和 开发环境 显示
        boolean flag = environment.acceptsProfiles(profiles);// 会会检测当前环境是否是 以上环境 是返回true，否则返回false

        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                // 配置接口扫描
                .select()
                /*
                    apis:
                       RequestHandlerSelectors 配置扫描接口的方式
                            basePackage(): 按指定包扫描api接口
                            any(): 扫描全部
                            none(): 不扫描
                            withMethodAnnotation(): 扫描方法上的带指定注解的api接口， 如@GetMapping修饰方法
                            withClassAnnotation(): 扫描类上的带指定注解的类上的api接口，如@RestController修饰类下所有的api接口
                 */
                .apis(RequestHandlerSelectors.basePackage("com.liuyou.controller"))
                /*
                    paths:
                        PathSelectors 路径筛选 -- 这里是url请求路径
                            ant(): ant pattern 筛选url路径
                            none(): 不筛选 -- 不会匹配 任何url路径  导致 No operations defined in spec!
                            any(): 筛选所有 -- 所有url路径
                            regex(): 正则表达式

                    一般用 apis 中 的 basePackage 就够了
                 */
//                .paths(PathSelectors.none())
                .build()
                // 配置分组
                .groupName("liuyou")
                .enable(flag);
    }

    @Bean
    public Docket docket1(){
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("group1");
    }

    // 配置Swagger信息 apiInfo
    private ApiInfo apiInfo(){
        Contact contact = new Contact("liuyou-website", "http://www.liuminkai.top", "111@qq.com"); // 作者信息
        return new ApiInfo(
                "xxx的Swagger信息标题", // 标题
                "详细描述", // 描述
                "1.0", // 版本
                "urn:tos", // 所属组 的 名字
                 contact, // 作者信息
                "Apache 2.0", // 许可证
                "http://www.apache.org/licenses/LICENSE-2.0", // 许可证url
                new ArrayList()
        );
    }
}

public class test {

    public static void main(String[] args) {
        AntPathMatcher ant = new AntPathMatcher();

        System.out.println(ant.match("/com/**", "/com/aa/b.java"));
        System.out.println(ant.match("/com/{var:[0-9]}", "/com/1"));
        System.out.println(ant.match("/com/{[0-9]}", "/com/1"));
        System.out.println(ant.match("/com/[0-9]", "/com/1"));
    }
}

Controller.

/**
 * @author liuminkai
 * @version 1.0
 * @datetime 2020/10/4 12:09
 * @decription
 **/
@RestController
@Api(value = "hello控制类",tags = {"类的作用：接收请求，跳转页面"})
public class HelloController {
    @RequestMapping("/hello")
    @ApiOperation(value = "接收hello，跳转到hello.html", notes = "注意：请求方法不做要求")
    public String hello(@ApiParam(name = "id",value = "ID")Integer id){
        return "hello";
    }

    // 只要我们的接口中，返回值中存在实体类，它就会被扫描到Swagger中
    @ApiImplicitParams({
            @ApiImplicitParam(name = "username", value = "用户名", dataType = "String"),
            @ApiImplicitParam(name = "password", value = "密码", dataType = "String")
    })
//    @ApiResponse()
    @RequestMapping("/user")
    public User user(String username, String password){
        return new User();
    }
}

pojo.

@Data
@NoArgsConstructor
@AllArgsConstructor
@ApiModel("用户类")
public class User implements Serializable {
    private static final long serialVersionUID = 5978016955197106792L;
    @ApiModelProperty("账号")
    private String username;
    @ApiModelProperty("密码")
    private String password;
}

index.html.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>你好,你好</h1>
</body>
</html>

application.properties.

spring.profiles.active=dev

application-dev.properties.

server.port=8000

spring.thymeleaf.cache=false

# 数据库连接
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=mysql

application-prod.properties.

server.port=8000

spring.thymeleaf.cache=false

# 数据库连接
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=mysql

pom.xml

<dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>2.9.2</version>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>2.9.2</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <version>2.1.1.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </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>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

8、dubbo_zookeeper.

consumer-server.

启动类.

@SpringBootApplication
public class ConsumerServerApplication {

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

}

Service.

TicketService.java.

@Service
public interface TicketService {
    String getTicket();
}

UserService.java.

@Service // 加入到spring容器中
public class UserService {

    @DubboReference // 引用 两种识别 1. pom坐标  2.包路径相同 接口名相同(这里第二种)
    TicketService ticketService;

    public void buyTicket(){
        String ticket = ticketService.getTicket();
        System.out.println(ticket);
    }
}

测试.

@SpringBootTest
class ConsumerServerApplicationTests {

    @Autowired
    private UserService userService;

    @Test
    void contextLoads() {
        userService.buyTicket();
    }

}

application.properties.

server.port=8000

# 拿服务 -- 暴露自己的名字
dubbo.scan.base-packages=consumer-server
# 注册中心的地址
dubbo.registry.address=zookeeper://127.8.8.1:2181

pom.xml.

<dependencies>
    <!-- 导入dubbo + zookeeper -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
        <version>2.7.8</version>
    </dependency>
    <!-- zkclient -->
    <dependency>
        <groupId>com.github.sgroschupf</groupId>
        <artifactId>zkclient</artifactId>
        <version>0.1</version>
    </dependency>
    <!-- 日志会冲突 -->
    <!-- 引入zookeeper -->
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-framework</artifactId>
        <version>4.2.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-recipes</artifactId>
        <version>4.2.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.4.9</version>
        <!-- 排除slf4j-log4j12 -->
        <exclusions>
            <exclusion>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </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>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

provider-server.

启动类.

@SpringBootApplication
public class ProviderServerApplication {

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

}

Service.

public interface TicketService {

    String getTicket();
}

//zookeeper：服务注册与发现

@Service
@DubboService // 可以被扫描到，只要我们一启动就自动注册到服务中心
public class TicketServiceImpl implements TicketService {
    @Override
    public String getTicket() {
        return "hello,Dubbo";
    }
}

application.properties.

server.port=8001


# dubbo配置
# 服务应用名
dubbo.application.name=provider-server
# 注册中心地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
# 服务注册
dubbo.scan.base-packages=com.liuyou.service

pom.xml.

<dependencies>
    <!-- 导入dubbo + zookeeper -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
        <version>2.7.8</version>
    </dependency>
    <!-- zkclient -->
    <dependency>
        <groupId>com.github.sgroschupf</groupId>
        <artifactId>zkclient</artifactId>
        <version>0.1</version>
    </dependency>
    <!-- 日志会冲突 -->
    <!-- 引入zookeeper -->
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-framework</artifactId>
        <version>4.2.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-recipes</artifactId>
        <version>4.2.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.4.9</version>
        <!-- 排除slf4j-log4j12 -->
        <exclusions>
            <exclusion>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
            </exclusion>
        </exclusions>
    </dependency>


    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </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>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

9、task.

启动类.

@EnableAsync
@EnableScheduling
@SpringBootApplication
public class TaskApplication {

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

}

Controller.

AsyncController.java.

@RestController
public class AsyncController {

    @Autowired
    AsyncService asyncService;

    @RequestMapping("/hello")
    public String async(){
        asyncService.hello();
        return "OK";
    }
}

Service.

AsyncService.java.

@Service
public class AsyncService {

    @Async
    public void hello(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("数据正在处理...");
    }
}

ScheduledService.java.

@Service
public class ScheduledService {

    // cron表达式 计划任务
    // 秒(0-59)  分(0-59)  时(0-23)  日(1-31)  月(1-12)  星期(0-7,0和7表示的都是星期日)
    /*
        *: 所有
        /: 每  ==>   * / 2 每2个单位  ==>  1 / 2 从第一个单位开始，每两个单位发生一次
        -: 数字到数字
        ,: 分开几个离散的数字
        ?: 不指定值 -- 用于 日 和 星期
        #: 确定每个月的第几个星期几  2#3 每月第二个星期三
     */
    @Scheduled(cron = "0 12 0 * * ?")
    public void hello(){
        System.out.println("hello");
    }
}

测试.

@SpringBootTest
class TaskApplicationTests {

    @Autowired
    JavaMailSenderImpl mailSender;

    @Test
    void contextLoads1() {

        // 简单邮件发送
        SimpleMailMessage simple = new SimpleMailMessage();

        simple.setSubject("liuyou 真帅");
        simple.setText(".......");

        simple.setFrom("1748616711@qq.com");
        simple.setTo("1423928650@qq.com");

        mailSender.send(simple);
    }

    @Test
    void contextLoads2() throws MessagingException {

        // 复杂邮件发送
        MimeMessage mime = mailSender.createMimeMessage();

        // 组装
//        MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mime);
        MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mime,true);// 多文本上传（附件）
//        MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mime,true,"utf-8");// 编码

        mimeMessageHelper.setSubject("一个标题");
        mimeMessageHelper.setText("<mark>html文本</mark>",true);

        // 附件
        mimeMessageHelper.addAttachment("xiao.jpg",new File("C:\\Users\\14239\\Desktop\\新Hadoop\\pandownload\\SSM\\springboot-08-task\\src\\main\\resources\\xiao.jpg"));

        mimeMessageHelper.setFrom("1748616711@qq.com");
        mimeMessageHelper.setTo("1423928650@qq.com");

        mailSender.send(mime);
    }

}

application.properties.

spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=mysql


# 邮件配置
spring.mail.username=1748616711@qq.com
spring.mail.password=emgpznatyunmccbd
spring.mail.host=smtp.qq.com
# 开启加密验证（qq）
spring.mail.properties.mail.smtp.ssl.enable=true

pom.xml.

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

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </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>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>