SpringBoot+Thymeleaf+集成Swagger2+Druid数据监控

@

目录

• SpringBoot概述
  • 什么是Spring Boot
  • 为什么要学习Spring Boot
  • Spring Boot特点
  • Spring Boot功能
• SpringBoot 快速入门
  • 从零使用Maven搭建
  • spring boot 热部署
  • 父POM依赖管理
  • 编写配置
    • SpringBoot进行Java配置
• spring boot属性注入
  • SpringBoot单元测试
• 自动配置(SpringBoot运行原理)
• 搭建SSM应用
  • 准备工作
  • 静态资源访问
  • 日志级别
  • 拦截器
  • 配置JDBC
  • 添加Mybatis启动器
  • 编写mapper.xml
  • 编写service&&webController
  • 通用Mapper
• Thymeleaf
  • 特点
  • 使用
  • 基本使用
    • 表达式
• {...} : Message 表达式
  • URL
  • 字面值
  • 拼接
  • 运算符
  • 内联写法
  • 局部变量
  • 判断
  • 迭代
  • 内置对象
    • 环境相关对象
    • 全局对象功能
• strings：字符串工具类
• lists：List 工具类
• arrays：数组工具类
• sets：Set 工具类
• maps：常用Map方法。
• objects：一般对象类，通常用来判断非空
• bools：常用的布尔方法。
• execInfo：获取页面模板的处理信息。
• messages：在变量表达式中获取外部消息的方法，与使用＃{...}语法获取的方法相同。
• uris：转义部分URL / URI的方法。
• conversions：用于执行已配置的转换服务的方法。
• dates：时间操作和时间格式化等。
• calendars：用于更复杂时间的格式化。
• numbers：格式化数字对象的方法。
• aggregates：在数组或集合上创建聚合的方法。
• ids：处理可能重复的id属性的方法。
  • 布局
  • js模板
  • 日期
  • 设置默认主页
• Druid数据监控
• 集成Swagger2

什么是Spring Boot

http://spring.io/projects

SpringBoot是Spring项目中的一个子工程
与我们所熟知的Spring-framework 同属于spring的产品
设计目的是用来简化新Spring应用的初始搭建以及开发过程
最主要作用就是帮我们快速的构建庞大的spring项目，并且尽可能的减少一切xml配置
做到开箱即用，迅速上手，让我们关注与业务而非配置

为什么要学习Spring Boot

之前
	复杂的配置
	项目各种配置其实是开发时的损耗
	写配置挤占了写应用程序逻辑的时间

	混乱的依赖管理
	项目当中添加很多库已经很麻烦了
	还要知道这些库的哪个版本和其他库不会有冲突
	一旦选错了依赖的版本
	随之而来的不兼容问题就会造成项目的致命性伤害
 
 现在
 	Spring Boot 简化了基于Spring的应用开发
	只需要“run”就能创建一个独立的、生产级别的Spring应用
	Spring Boot为Spring平台及第三方库提供开箱即用的设置

Spring Boot特点

为所有 Spring 的开发者提供一个非常快速的、广泛接受的入门体验
开箱即用,通过简单的配置,简化了以前复杂配置操作
提供了一些大型项目中常见的非功能性特性，如内嵌服务器、安全、指标，健康检测、外部化配置等
无需 XML 配置

http://spring.io/projects/spring-boot

Spring Boot功能

以jar包方式独立运行（jar -jar xxx.jar）
内嵌Servlet容器（tomcat, jetty）,无需以war包形式部署到独立的servlet容器中
提供starter简化maven依赖包配置
自动装配bean(大多数场景)
提倡使用java配置和注解配置结合而无需xml配置

SpringBoot 快速入门

从零使用Maven搭建

1. 创建Maven工程
   
2. 引入springboot依赖

	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
    </parent>

3. 添加spring-boot启动器依赖

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

4. 编写启动类
   

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

5. 编写Controller直接访问
   

@RestController
public class HelloSpringBoot {
    @RequestMapping("/hello")
    public String hello(){
        return "hello";
    }
}

6. 直接访问
   

如遇到spring boot run启动时非常缓慢使用以下方法

1.在命令行中输入hostname 查询当前主机名称

2.到C盘Windows\System32\drivers\etc中找到host文件

3.注意事项: 127.0.0.1和local之间是两个tab 不是空格

spring boot 热部署

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

父POM依赖管理

所有jar包的版本统一管理
所有jar的依赖管理，其中包含springboot 给我们提供的很多的starter启动器

dependencyManage
定义了子项目中可能出现的各种依赖及其版本信息;使得子项目在需要的时候引入即可使用,且不再需要定义版本了

编写配置

springBoot默认使用servlet3.0 可以没有web.xml
没有任何的xml,我们想要做一些自定义的配置,比如数据库相关的信息,该如何配置?

Spring1.0时代：Spring配置都是xml格式
Spring2.0时代： 引入了注解,并未完全替代xml
Spring3.0及以后：3.0以后Spring的注解已经非常完善了
SpringBoot：使用Java配置

SpringBoot进行Java配置

springBoot当中java配置主要靠java类和一些注解代替xml

@Configuration：声明一个类作为配置类，代替xml文件
@Bean：声明在方法上，将方法的返回值加入Bean容器，代替标签
@value：属性注入
@PropertySource：指定外部属性文件，

引入druid依赖文件

 <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.23</version>
  </dependency>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mydb?characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456

创建配置类,引入jdbc.properties

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {

    @Value("${jdbc.url}")
    String url;
    @Value("${jdbc.driver}")
    String driverClassName;
    @Value("${jdbc.username}")
    String username;
    @Value("${jdbc.password}")
    String password;
    /*方法的返回值就是一个bean对象
     * 就可以使用@autoWare进行注入
     * */
    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

}

spring boot属性注入

1. 单独放到一个类当中
   把properties名称改为application.properties
   1.创建一个类 名为JdbcProperties

@ConfigurationProperties(prefix = "jdbc")
@Setter@Getter
public class JdbcProperties {

   private String username;
   private String url;
   private String driverClassName;
   private String password;

   public String getUsername() {
      return username;
   }

   public void setUsername(String username) {
      this.username = username;
   }

   public String getUrl() {
      return url;
   }

   public void setUrl(String url) {
      this.url = url;
   }

   public String getDriverClassName() {
      return driverClassName;
   }

   public void setDriverClassName(String driverClassName) {
      this.driverClassName = driverClassName;
   }

   public String getPassword() {
      return password;
   }

   public void setPassword(String password) {
      this.password = password;
   }
}

JdbcConfig

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {
    @Bean
    public DataSource dataSource(JdbcProperties jdbc) {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(jdbc.getUrl());
        dataSource.setDriverClassName(jdbc.getDriverClassName());
        dataSource.setUsername(jdbc.getUsername());
        dataSource.setPassword(jdbc.getPassword());
        return dataSource;
    }
}

2. 直接注入
   创建application.properties属性文件

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mydb?characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456

直接在方法上配置注解形式

3. 属性文件使用yaml文件方式
   配置文件除了使用application.properties类型,还可以是后缀名为:.yml或.yaml的类型，也会自动的加载
   YAML是一种简洁的非标记语言,是以数据为中心, 使用空白缩进,分行组织数据,
   从而使得表示更加简洁易读

示例

注意事项:
	如果有两个配置文件一个.properties和一个.yml
	会取两个并集,如果有相同的名称,会以properties为主

SpringBoot单元测试

1. 引入单元测试pom依赖

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

2. 编写测试类
   

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)//启动类的class
public class SpringTest {
    @Autowired
    private DataSource dataSource;

    @Test
    public void test(){
        System.out.println(dataSource);
    }
}

自动配置(SpringBoot运行原理)

使用SpringBoot之后，一个整合了SpringMVC的WEB工程开发非常简单，那些繁杂的配置都消失不见了，这是如何做到的？

1. 查看main方法的启动类
   
   注解：@SpringBootApplication
   run方法：SpringApplication.run()

2. @SpringBootApplication
   查看@SpringBootApplication源码
   
   在源码当中有3个比较重点的注解
   @SpringBootConfiguration查看源码
   
   在这个注解上面，又有一个@Configuration注解

这个注解的作用就是声明当前类是一个配置类
然后Spring会自动扫描到添加了@Configuration的类
读取其中的配置信息
而@SpringBootConfiguration是来声明当前类是SpringBoot应用的配置类，项目中只能有一个。所以一般我们无需自己添加。

@EnableAutoConfiguration

开启自动配置
告诉SpringBoot基于所添加的依赖，去“猜测”你想要如何配置Spring。
比如我们引入了spring-boot-starter-web，而这个启动器中帮我们添加了tomcat、SpringMVC的依赖
此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了！
SpringBoot内部对大量的第三方库或Spring内部库进行了默认配置
这些配置是否生效，取决于我们是否引入了对应库所需的依赖
如果有那么默认配置就会生效
我们使用SpringBoot构建一个项目，只需要引入所需框架的依赖，配置就可以交给SpringBoot处理了

@ComponentScan

配置组件扫描的指令
提供了类似与< context:component-scan>标签的作用
通过basePackageClasses或者basePackages属性来指定要扫描的包。
如果没有指定这些属性，那么将从声明这个注解的类所在的包开始，扫描包及子包
而我们的@SpringBootApplication注解声明的类就是main函数所在的启动类，
因此扫描的包是该类所在包及其子包。因此，一般启动类会放在一个比较前的包目录中。

搭建SSM应用

准备工作

1.创建表

CREATE TABLE `tb_hero` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) DEFAULT NULL,
  `profession` varchar(255) DEFAULT NULL,
  `phone` varchar(255) DEFAULT NULL,
  `email` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8;
INSERT INTO `tb_hero` VALUES (1, '鲁班', '射手', '13499887733', '12341241@qq.com');
INSERT INTO `tb_hero` VALUES (2, '李白', '刺客', '18977665521', 'libai@163.com');
INSERT INTO `tb_hero` VALUES (30, '阿轲', '刺客', '18977665997', 'aike@qq.com');
INSERT INTO `tb_hero` VALUES (40, '德玛', '肉盾', '13700997665', 'demaxiya.126.com');
INSERT INTO `tb_hero` VALUES (50, '亚索', '战士', '13586878987', 'yasuo@qq.com');
INSERT INTO `tb_hero` VALUES (60, '奶妈', '辅助', '13398909089', 'nama@qq.com');
INSERT INTO `tb_hero` VALUES (70, '剑圣', '刺客', '13398909088', 'jiansheng@163.com');
INSERT INTO `tb_hero` VALUES (80, '盖伦', '肉盾', '15923242231', 'gailun@126.com');
INSERT INTO `tb_hero` VALUES (90, '锤石', '辅助', '13398908900', '8888@163.com');
INSERT INTO `tb_hero` VALUES (10, '阿木', '辅助', '13398908928', '13398908928@qq.com');

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.23</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

2. 编写启动类

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

3. 编写pojo类

@Data
public class TbHero {
    private Integer id;
    private String username;
    private String profession;
    private String phone;
    private String email;
}

4. 配置相关属性 application.yml
   1. 配置端口号
   2. 配置SpringMVC初始化

server:
  port: 80

spring:
  mvc:
    servlet:
      load-on-startup: 1

静态资源访问

由于没有了web-inf目录,如果直接把静态资源类似图片等信息放到resource是无法访问到的
默认情况下,它是在以下目录当中进行查找静态资源文件
META-INF/resources
resources/static
resources/public
resources/resources

所以要自己手动在resource文件当中创建静态资源目录
在创建resource目录下创建static目录存放静态资源文件

日志级别

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

@RestController
public class hello {
    private  static final Logger log = LoggerFactory.getLogger(hello.class);
    @RequestMapping("/hello")
    public String hello(){
        log.info("hello----info");
        log.debug("hello----debug");
        return "hello";
    }
}

默认是info级别
设置日志级别

logging:  #日志
  level:  #级别
    com.dj.Controller: debug    #包名:级别

logging:  #日志
  level:  #级别
    com.dj.Controller: debug    #包名:级别
  path: "D:/test.log" #日志输出到文件 文件目录

使用注解驱动日志
添加lombok

		<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>

在类上添加@Slf4j注解
@RestController
@Slf4j

public class hello {
//    private  static final Logger log = LoggerFactory.getLogger(hello.class);
    @RequestMapping("/hello")
    public String hello(){
        log.info("hello----info");
        log.debug("hello----debug");
        return "hello";
    }
}

拦截器

1. 创建一个类实现HandlerInterceptor接口
2. 实现HandlerInterceptor里面的方法
   

@Slf4j
public class MyInterceptor implements HandlerInterceptor   {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.debug("MyInterceptor----preHandle");
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

3. 编写配置类实现WebMvcConfigurer接口
   

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");//拦截所有请求
    }
}

注解扫描-自动配置完成
包扫描-内部自带了包扫描
视图解析器-springboot当中不支持jsp,无需配置

配置JDBC

1.添加jdbc启动器

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

2.添加Mysql数据库驱动

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
</dependency>

3.配置连接参数

server:
  port: 80
spring:
  mvc:
    servlet:
      load-on-startup: 1
  datasource: #数据库连接信息 Spring
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springbootssm?characterEncoding=utf-8
    username: root
    password: 123456

logging:  #日志
  level:  #级别
    com.dj: debug    #包名:级别

添加Mybatis启动器

spring-boot没有给Mybatis写启动器,Mybaits自己写了启动器
https://github.com/mybatis/spring-boot-starter

添加Mybatis启动器

		<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>

配置mapper文件地址

mybatis:
  mapper-locations: mapper/*.xml  #mapper存放位置
  type-aliases-package: com.dj.pojo #别名

mapper接口扫描


驼峰命名法

编写mapper.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.dj.Mapper.HelloMapper">


    <select >
        select* from tb_hero
    </select>
</mapper>

编写service&&webController

注意：mysql8的连接URL需要加上
useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=false
示例：

spring:
  datasource: #数据库连接信息 Spring
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springbootssm?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=false
    username: root
    password: 123456

通用Mapper

https://github.com/abel533/Mapper

介绍

通用Mapper都可以极大的方便开发人员。 可以随意的按照自己的需要选择通用方法， 还可以很方便的开发自己的通用方法。
极其方便的使用MyBatis单表的增删改查。
支持单表操作，不支持通用的多表联合查询。

1.引入启动器

<dependency>
     <groupId>tk.mybatis</groupId>
     <artifactId>mapper-spring-boot-starter</artifactId>
     <version>2.1.5</version>
</dependency>

在启动类上 使用tk开头的MapperScan

2.使用时, 直接在接口上继承Mapper<实体类>

在实体类上

@Transient : 表示这个字段在查询时不需要这个字段

使用通用mapper实现添加功能
service接口

实现类

Thymeleaf

介绍
	SpringBoot并不推荐使用jsp
	Thymeleaf 是一个跟 Velocity、FreeMarker 类似的模板引擎，它可以完全替代 JSP

特点

1. 动静结合
   Thymeleaf 在有网络和无网络的环境下皆可运行
   它可以让美工在浏览器查看页面的静态效果，也可以让程序员在服务器查看带数据的动态页面效果
   这是由于它支持 html 原型，然后在 html 标签里增加额外的属性来达到模板+数据的展示方式
   浏览器解释 html 时会忽略未定义的标签属性，所以 thymeleaf 的模板可以静态地运行；
   当有数据返回到页面时，Thymeleaf 标签会动态地替换掉静态内容，使页面动态显示。

2. 开箱即用
   它提供标准和spring标准两种方言，可以直接套用模板实现JSTL、 OGNL表达式效果
   ，避免每天套模板、该jstl、改标签的困扰。同时开发人员也可以扩展和创建自定义的方言。

3. 多方言支持
   Thymeleaf 提供spring标准方言和一个与 SpringMVC 完美集成的可选模块，
   可以快速的实现表单绑定、属性编辑器、国际化等功能。

4. 与SpringBoot完美整合
   与SpringBoot完美整合，SpringBoot提供了Thymeleaf的默认配置，
   并且为Thymeleaf设置了视图解析器，我们可以像以前操作jsp一样来操作Thymeleaf。

使用

添加启动器

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

创建模板文件夹

SpringBoot会自动为Thymeleaf注册一个视图解析器ThymeleafViewResolver
还配置了模板文件（html）的位置，与jsp类似的前缀+ 视图名 + 后缀风格：
与解析JSP的InternalViewResolver类似，Thymeleaf也会根据前缀和后缀来确定模板文件的位置：

在配置文件中 配置缓存,编码
在resources下创建templates文件夹
创建html

编写controller跳转页面

在html显示

xmlns:th="http://www.thymeleaf.org"

缓存配置

spring: 
	thymeleaf: 
    	cache: false #缓存
    	mode: HTML5
    	encoding: utf-8 #编码

基本使用

引入名称空间

<html lang="en" xmlns:th="http://www.thymeleaf.org">

表达式

${}:变量表达式

<h1 th:text="${name}">大标题</h1>
<h1 th:text="${hero.getUsername()}">大标题</h1>

*{}：选择变量表达式

<h1 th:object="${hero}">
    <p th:text="*{username}"></p>
    <p th:text="*{profession}"></p>
    <p th:text="*{phone}"></p>
    <p th:text="*{email}"></p>
</h1>

{...} : Message 表达式

URL

绝对网址
绝对URL用于创建到其他服务器的链接,它们需要指定一个协议名称(http://或https????/)开头

<a th:href="@{https://www.baidu.com/}">百度</a>

上下文相关URL
与Web应用程序根相关联URL

<a th:href="@{/hello}">跳转</a>
<img th:src="@{/logo.png}" alt="">

与服务器相关URL
服务器相关的URL与上下文相关的URL非常相似

<a th:href="@{~/hello}">跳转</a>

携带参数

<a th:href="@{/hello(id=1,name='joker')}">跳转传参</a>

字面值

有的时候，我们需要在指令中填写基本类型如：字符串、数值、布尔等，并不希望被Thymeleaf解析为变量，这个时候称为字面值。

字符串字面值

数字字面值

布尔字面值
布尔类型的字面值是true或false

拼接

普通字符串与表达式拼接的情况

字符串字面值需要用''，拼接起来非常麻烦，Thymeleaf对此进行了简化，使用一对|即可

运算符

算术操作符 + - * / %

比较运算 >, <, >= and <=
但是>, <不能直接使用，因为xml会解析为标签
> gt
< lt
>= ge
<= le

三元运算
conditon ? then : else


默认表达式

内联写法

局部变量

判断

th:if

th:unless

th:switch

迭代

stat对象包含以下属性

index，从0开始的角标
count，元素的个数，从1开始
size，总元素个数
current，当前遍历到的元素
even/odd，返回是否为奇偶，boolean值
first/last，返回是否为第一或最后，boolean值

内置对象

环境相关对象

${#ctx} 上下文对象，可用于获取其它内置对象。
${#vars}: 上下文变量。
${#locale}：上下文区域设置。
${#request}: HttpServletRequest对象。
${#response}: HttpServletResponse对象。
${#session}: HttpSession对象。
${#servletContext}: ServletContext对象。

全局对象功能

strings：字符串工具类

lists：List 工具类

arrays：数组工具类

sets：Set 工具类

maps：常用Map方法。

objects：一般对象类，通常用来判断非空

bools：常用的布尔方法。

execInfo：获取页面模板的处理信息。

messages：在变量表达式中获取外部消息的方法，与使用＃{...}语法获取的方法相同。

uris：转义部分URL / URI的方法。

conversions：用于执行已配置的转换服务的方法。

dates：时间操作和时间格式化等。

calendars：用于更复杂时间的格式化。

numbers：格式化数字对象的方法。

aggregates：在数组或集合上创建聚合的方法。

ids：处理可能重复的id属性的方法。

示例
${#strings.abbreviate(str,10)} str截取0-10位，后面的全部用…这个点代替，注意，最小是3位
${#strings.toUpperCase(name)}

判断是不是为空:null: 

<span th:if="${name} != null">不为空</span> 

<span th:if="${name1} == null">为空</span> 

判断是不是为空字符串: “” 

<span th:if="${#strings.isEmpty(name1)}">空的</span>

 

判断是否相同： 

<span th:if="${name} eq 'jack'">相同于jack,</span> 

<span th:if="${name} eq 'ywj'">相同于ywj,</span> 

<span th:if="${name} ne 'jack'">不相同于jack,</span>

 

不存在设置默认值： 

<span th:text="${name2} ?: '默认值'"></span> 

是否包含(分大小写): 

<span th:if="${#strings.contains(name,'ez')}">包ez</span> 

<span th:if="${#strings.contains(name,'y')}">包j</span> 

是否包含（不分大小写） 

<spanth:if="${#strings.containsIgnoreCase(name,'y')}">包</span> 

${#strings.startsWith(name,'o')} 

${#strings.endsWith(name, 'o')} 

${#strings.indexOf(name,frag)}// 下标 

${#strings.substring(name,3,5)}// 截取 

${#strings.substringAfter(name,prefix)}// 从 prefix之后的一位开始截取到最后,比如 (ywj,y) = wj, 如果是(abccdefg,c) = cdefg//里面有2个c,取的是第一个c 

${#strings.substringBefore(name,suffix)}// 同上，不过是往前截取 

${#strings.replace(name,'las','ler')}// 替换 

${#strings.prepend(str,prefix)}// 拼字字符串在str前面 

${#strings.append(str,suffix)}// 和上面相反，接在后面 

${#strings.toUpperCase(name)} 

${#strings.toLowerCase(name)} 

${#strings.trim(str)} 

${#strings.length(str)} 

${#strings.abbreviate(str,10)}//  str截取0-10位，后面的全部用…这个点代替，注意，最小是3位

布局

方式1
nav 头部标签

引入标签

方式2

引入方式
th:insert
	将公共的标签及内容插入到指定标签当中
th:replace
	将公共的标签替换指定的标签
th:include
	将公共标签的内容包含到指定标签当中

传值

js模板

模板引擎不仅可以渲染html，也可以对JS中的进行预处理。而且为了在纯静态环境下可以运行
在script标签中通过th:inline="javascript"来声明这是要特殊处理的js脚本

日期

设置默认主页

Druid数据监控

		 <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.23</version>
        </dependency>

application.yaml配置druid连接池

其他相关配置文件

	initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    #   配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

创建配置文件,关联配置
DruidConfig

配置Druid的监控

@Configuration
public class DruidConfig {

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

    //1. 配置servlet
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
        HashMap<String, Object> map = new HashMap<>();
        map.put("loginUsername","admin");//登录用户名
        map.put("loginPassword","1234");//密码
        map.put("allow","");//允许访问所有
        bean.setInitParameters(map);
        return bean;

    }
    //2. 配置Filter
    @Bean
    public FilterRegistrationBean  webStatFilter(){
        FilterRegistrationBean bean = new FilterRegistrationBean(new WebStatFilter());
        HashMap<String, Object> map = new HashMap<>();
        map.put("exclusions","*.js,*.css*,/druid/");//排除过滤
        bean.setInitParameters(map);
        bean.setUrlPatterns(Arrays.asList("/*"));
        return bean;
    }
}

在地址栏中输入http://localhost/druid/进入监控页面

集成Swagger2

Swagger2简介
1.随项目自动生成强大RESTful API文档，减少工作量
2.API文档与代码整合在一起，便于同步更新API说明
3.页面测试功能来调试每个RESTful API

1.添加依赖

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

2.创建Swagger2配置类

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.dj"))// 指定扫描包下面的注解
                .paths(PathSelectors.any())
                .build();

    }
    // 创建api的基本信息
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("集成Swagger2构建RESTful APIs")
                .description("集成Swagger2构建RESTful APIs")
                .termsOfServiceUrl("https://www.baidu.com")
                .contact("joker_dj")
                .version("1.0.0")
                .build();
    }
}

在地址栏输入
http://localhost/swagger-ui.html#/

常见Api

@Api(value="用户controller",tags={"用户操作接口"})

Api 用在类上，说明该类的作用。可以标记一个Controller类做为swagger 文档资源

@ApiOperation(value="获取用户信息",notes="注意问题点",httpMethod="GET")

用在方法上，说明方法的作用，每一个url资源的定义,使用方式

@ApiImplicitParam(name="id",value="用户id",dataType="Long", paramType = "path")

参数说明

@ApiIgnore()

忽略方法

调试接口