SpringBoot

简介

简化SSM框架进行的开发过程。采用了大量默认配置简化开发过程。

Spring四大核心

1、自动配置
2、起步依赖
3、Actuator
4、命令行界面

springboot代码

代码必须写在Application类所在同级目录或下级目录。

核心配置文件properties

# 设置内嵌Tomcat端口号
server.port=8081

#设置上下文根
server.servlet.context-path=/sprinboot

核心配置文件application.yml

后缀名可以为yml也可以为yaml
注意格式

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

注：当有application.properties和application.yml都存在时，会优先读取application.properties。

多环境下的核心配置文件

工作中开发的环境：开发环境、测试环境、准生产环境、生产环境。
创建多个配置文件，命名格式为：application-dev、application-test…

主核心配置文件application.properties 在这里设置选用那个配置文件

#springboot主核心配置文件
#激活使用的配置文件
spring.profiles.active=dev

同时读取多配置文件1

此方法仅适用于 .properties文件，需要放在类路径下，否则value = "db.properties"处需要写全路径。

@SpringBootApplication
@PropertySources({
        @PropertySource(value = "db.properties", ignoreResourceNotFound = true,encoding = "UTF-8")
})
public class PropertiesApplication {
    public static void main(String[] args) {
        SpringApplication.run(PropertiesApplication.class, args);
    }
}

同时读取多配置文件2

此方法仅适用于application-xxx命名的配置文件读取

#springboot主核心配置文件
#激活使用的配置文件
spring.profiles.active=dev1,dev2,...

获取自定义配置

springboot在核心配置文件application.properties自定义配置。
例如在application.properties定义了school.name=school
只需在代码中使用，如下代码就能取到

    @Value("${school.name}")
    private String schoolname;

将自定义配置映射到对象

application.properties中定义了

school.name=school
school.website=school.com

abc.name=abc
abc.website=abc.com

在使用的时候需要

@Component
@ConfigurationProperties(prefix = "school")
public class School {
    private String name;
    private String website;

    public String getName() {
        return name;
    }

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

    public String getWebsite() {
        return website;
    }

    public void setWebsite(String website) {
        this.website = website;
    }
}

这样在Controller可以自动注入

@Controller
public class IndexController {
    @Autowired
    private School school;

    @RequestMapping("/say")
    public @ResponseBody String say(){
        return "hello:"+school.getName();
    }
}

SpringBoot集成JSP

在main目录下新建webapp文件夹，shifr+ctrl+alt+s 进入project settings，找到模块的Web，找到Web Resource Directories ，右边+号，找到刚才创建的webapp，点击ok之后，回到上一层界面，点击右下角create artifact。
创建完成之后，webapp文件夹图标会多个蓝点。

加入依赖

		<!--引入SpringBoot内嵌Tomcat对jsp的解析依赖-->
		<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
		</dependency>

在build标签下指定编译位置

		<!--
			SpringBoot默认推荐使用的前端引擎是thymeleaf
			现在我们要使用springBoot集成jsp，手动指定jsp最后编译的路径
			而且springboot集成jsp编译jsp的路径是springboot规定好的位置META-INF/resources
		-->
		<resources>
			<resource>
				<!--源文件夹-->
				<directory>src/main/webapp</directory>
				<!--指定编译到META-INF/resources-->
				<targetPath>META-INF/resources</targetPath>
				<!--指定源文件夹要进行编译的内容-->
				<includes>
					<include>*.*</include>
				</includes>
			</resource>
		</resources>

在application.properties中配置视图解析器

#配置视图解析器
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

SpringBoot集成MyBatis

1、新建springboot项目
2、添加依赖：
a、mysql驱动
b、mybatis依赖

		<!--mysql驱动-->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>

		<!--myBatis整合SpringBoot的起步依赖-->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.0.0</version>
		</dependency>

3、使用MyBatis提供的逆向工程生成实体类bean，映射文件，Dao接口：
a、模块目录下新建GeneratorMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
    <!--指定连接数据库的JDBC 驱动包所在位置，指定到你本机的完整路径：根据具体情况修改-->
    <classPathEntry location="D:\PROGRAM\MySQL\mysql-connector-java-8.0.20\mysql-connector-java-8.0.20.jar"/>
    <!--配置table表信息内容体，targetRuntime 指定采用MyBatis3的版本-->
    <context id="tables" targetRuntime="MyBatis3">
        <!--抑制生成注释，由于生成的注释都是英文的，可以不让它生成-->
        <commentGenerator>
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!--配置数据库连接信息：根据具体情况修改-->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/springboot?serverTimezone=UTC"
                        userId="root"
                        password="123456">
            <property name="nullCatalogMeansCurrent" value="true"/>

        </jdbcConnection>


        <!--生成model类，targetPackage指定model类的包名，targetProject指定生成的model放在哪个工程下面：根据具体情况修改-->
        <javaModelGenerator targetPackage="com.daihan.springboot.model"
                            targetProject="src/main/java">
            <property name="enableSubPackages" value="false"/>
            <property name="trimStrings" value="false"/>
        </javaModelGenerator>
        <!--生成MyBatis的Mapper.xml文件，targetPackage指定mapper.xml文件的包名，targetProject指定生成的mapper.xml放在哪个工程下面-->
        <sqlMapGenerator targetPackage="com.daihan.springboot.mapper"
                         targetProject="src/main/java">
            <property name="enableSubPackages" value="false"/>
        </sqlMapGenerator>
        <!--生成MyBatis的Mapper接口类文件,targetPackage指定Mapper接口类的包名，targetProject指定生成的Mapper接口放在哪个工程下面-->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.daihan.springboot.mapper"
                             targetProject="src/main/java">
            <property name="enableSubPackages" value="false"/>
        </javaClientGenerator>


        <!--数据库表名及对应的Java模型类名-->
        <table tableName="t_Student" domainObjectName="Student"
               enableCountByExample="false"
               enableUpdateByExample="false"
               enableDeleteByExample="false"
               enableSelectByExample="false"
               selectByExampleQueryId="false" />
    </context>
</generatorConfiguration>

b、加入插件

			<!--Mybatis代码自动生成插件-->
			<plugin>
				<groupId>org.mybatis.generator</groupId>
				<artifactId>mybatis-generator-maven-plugin</artifactId>
				<version>1.3.6</version>
				<configuration>
					<!--配置文件位置-->
					<configurationFile>GeneratorMapper.xml</configurationFile>
					<verbose>true</verbose>
					<overwrite>true</overwrite>
				</configuration>
			</plugin>

c、点击右侧maven，使用插件mybatis-generator
生成mapper接口和配置文件，model

4、新建web包，在此包下写Controller

5、新建service包，在此包下写sercive接口，并写实现类加注解@Service，调用Mapper

6、（重点）mapper包里面的接口加@Mapper，或在启动类Application加@MapperScan(basePackages=“com.daihan.springboot.mapper”)

7、（重点）在pom文件加上资源指定，否则XXXMapper.xml不会被编译进target目录下

		<resources>
			<resource>
				<directory>src/main/java</directory>
				<includes>
					<include>**/*.xml</include>
				</includes>
			</resource>
		</resources>

8、将application.rpoperties改为application.yml
或者将整个工程编码方法改为UTF-8，然后标黄的地方重新写

Mapper映射文件常放位置（重要）

1、XXXMapper接口同一目录
2、resources目录下创建mapper目录，把mapper映射文件XXXmapper.xml放入其中。
在核心配置文件application.yml中指定MyBatis映射文件路径

mybatis:
  mapper-locations: classpath:mapper/*.xml

配置Druid

#以项目为例
#只需要在原本的配置文件中添加双横线中的内容就可
 
server:
  port: 8010
#======================================================================================
spring:
  application:
    name: project #指定此SpringBoot应用的名称
  datasource:
    username: ******  #账户
    password: ******  #密码
    url: jdbc: ********************************** #数据库连接地址
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    druid: # 以下可以使用默认配置，即什么也不写了
      initial-size: 5                                       # 初始化大小
      min-idle: 10                                          # 最小连接数
      max-active: 20                                        # 最大连接数
      max-wait: 60000                                       # 获取连接时的最大等待时间
      min-evictable-idle-time-millis: 300000                # 一个连接在池中最小生存的时间，单位是毫秒
      time-between-eviction-runs-millis: 60000              # 多久才进行一次检测需要关闭的空闲连接，单位是毫秒
      filters: stat                                         # 配置扩展插件：stat-监控统计，log4j-日志，wall-防火墙（防止SQL注入），去掉后，监控界面的sql无法统计   ,wall
      validation-query: SELECT 1                            # 检测连接是否有效的 SQL语句，为空时以下三个配置均无效
      test-on-borrow: true                                  # 申请连接时执行validationQuery检测连接是否有效，默认true，开启后会降低性能
      test-on-return: true                                  # 归还连接时执行validationQuery检测连接是否有效，默认false，开启后会降低性能
      test-while-idle: true                                 # 申请连接时如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效，默认false，建议开启，不影响性能
      stat-view-servlet:
        enabled: true                                       # 是否开启 StatViewServlet
        allow: 127.0.0.1                                    # 访问监控页面 白名单，默认127.0.0.1
        deny: 192.168.56.1                                  # 访问监控页面 黑名单
        login-username: admin                               # 访问监控页面 登陆账号
        login-password: admin                               # 访问监控页面 登陆密码
      filter:
        stat:
          enabled: true                                     # 是否开启 FilterStat，默认true
          log-slow-sql: true                                # 是否开启 慢SQL 记录，默认false
          slow-sql-millis: 5000                             # 慢 SQL 的标准，默认 3000，单位：毫秒
          merge-sql: false                                  # 合并多个连接池的监控数据，默认false
 
 #========================================================================================

SpringBoot项目下使用事务

事务只跟DML语句（增、删、改）有关
在方法上加注解@Transactional

常用注解

@RestController

当某个XXXController的所有方法的返回值全是json对象的话，可以用@RestController代替@Controller，这样这个Controller的方法就不用@ResponseBody注解了。
相当于控制层类上加@Controller + 方法上加@ResponseBody

@GetMapping

要求只接受Get方式访问，可以使用@RequestMapping(value=“/xxx”,method = RequestMethod.GET)。也可以使用@GetMapping
类似的，@PostMapping，@DeleteMapping，@PutMapping

通常，查询用get，新增用post，删除用delete，修改用put

REST ful

@PathVariable

例子：018
Controller中的方法，加注释

    @RequestMapping("/student/detail/{id}/{age}")
    public Object student1(@PathVariable("id") Integer id,
                           @PathVariable("age")Integer age){
        Student student = new Student();
        student.setId(id);
        student.setAge(age);
        return student;
    }

但是会出现以下问题：

    @RequestMapping("/student/detail/{id}/{age}")
    public Object student1(@PathVariable("id") Integer id,
                           @PathVariable("age")Integer age){
        Student student = new Student();
        student.setId(id);
        student.setAge(age);
        return student;
    }
        @RequestMapping("/student/detail/{id}/{status}")
    public Object student2(@PathVariable("id") Integer id,
                           @PathVariable("status")Integer status){
        Student student = new Student();
        student.setId(id);
        student.setAge(status);
        return student;
    }

会出现请求路径迷糊（请求冲突）的错误。
通常在RESTful风格中方法的请求会按照增删改查的请求方式来区分，使用@GetMapping，@PostMapping，@DeleteMapping，@PutMapping，而不是@RequestMapping
如果还混淆，也可以改为@DeleteMapping("/student/detail/{id}/{status}")和@DeleteMapping("/student/{id}/detail/{status}")

RESTful风格还要求请求路径中使用名词，最好不要使用动词

一般传的参数不是数据库表的字段，可以不用斜杠

SpringBoot集成Redis

1、添加依赖

		<!--springboot集成Redis的起步依赖-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
			<version>2.3.3.RELEASE</version>
		</dependency>

2、springboot核心配置文件添加redis配置
spring.redis.host=192.168.244.131
spring.redis.port=6379

3、在Service层中，自动注入RedisTemplate<Object,Object> redisTemplate

package com.daihan.springboot.service.Impl;

import com.daihan.springboot.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class StudentServiceImpl implements StudentService {
    @Autowired
    private RedisTemplate<Object,Object> redisTemplate;

    @Override
    public void put(String key, String value) {
        redisTemplate.opsForValue().set(key,value);
    }
}

Springboot集成Dubbo

1、接口工程：存放实体bean业务接口
2、服务提供者：业务接口的实现类，调用数据持久层
		-添加依赖：dubbo，注册中心，接口工程
		-配置服务提供者核心配置文件
3、服务消费者：处理浏览器客户端发送的请求，从注册中心调用服务提供者所提供的服务
		-添加依赖：dubbo，注册中心，接口工程
		-配置服务消费者核心配置文件

依赖

		<!--dubbo集成springboot框架起步依赖-->
		<dependency>
			<groupId>com.alibaba.spring.boot</groupId>
			<artifactId>dubbo-spring-boot-starter</artifactId>
			<version>2.0.0</version>
		</dependency>
		<!--注册中心-->
		<dependency>
			<groupId>com.101tec</groupId>
			<artifactId>zkclient</artifactId>
			<version>0.10</version>
		</dependency>
		<!--接口工程-->
		<dependency>
			<groupId>com.daihan.springboot</groupId>
			<artifactId>020-springboot-dubbo-interface</artifactId>
			<version>1.0-SNAPSHOT</version>
		</dependency>

接口工程020：
声明接口

provider模块021：
实现接口方法，加上注解
@Component
@Service(interfaceClass = StudentService.class,version = “1.0.0”,timeout = 15000)//要用dubbo的

#设置内嵌Tomcat端口号
server.port=8081
#设置上下文根
server.servlet.context-path=/

#设置dubbo的配置
spring.application.name=021-springboot-dubbo-provider
#当前工程是服务提供者
spring.dubbo.server=true
#设置注册中心
spring.dubbo.registry=zookeeper://localhost:2181

还要在程序启动入口加上注解@EnableDubboConfiguration//开启dubbo配置

consumer模块022：
Controller调用接口工程的接口的方法
配置文件

#设置内嵌Tomcat端口号
server.port=8080
#设置上下文根
server.servlet.context-path=/

#设置dubbo的配置
spring.application.name=022-springboot-dubbo-consumer
#设置注册中心
spring.dubbo.registry=zookeeper://localhost:2181

还要在程序启动入口加上注解@EnableDubboConfiguration//开启dubbo配置

SpringBoot集成Dubbo，Redis，SSM，JSP

1、接口工程：存放实体bean业务接口
2、服务提供者：业务接口的实现类，调用数据持久层
		-添加依赖：dubbo，注册中心，接口工程，MyBatis，MySql驱动，Redis
		-配置服务提供者核心配置文件
				-配置连接数据库
				-配置连接Redis
				-配置连接dubbo
3、服务消费者：处理浏览器客户端发送的请求，从注册中心调用服务提供者所提供的服务
		-添加依赖：dubbo，注册中心，接口工程，解析JSP页面的依赖
		-配置服务消费者核心配置文件
				-配置视图解析器
				-配置dubbo

注：
GeneratorMapper.xml文件下，javaModelGenerator标签的，targetProject 改为接口工程的绝对路径（类路径：D:\JAVACODE\SpringBoot\023-springboot-dubbo-ssm-interface\src\main\java）
执行逆向工程之后，model下的实体类在接口工程模块下，mapper文件在provider模块下

代码：023-025

SpringBoot创建非web工程

两种方式

关闭springboot工程的启动logo

028-

@SpringBootApplication
public class Application {

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

		//获取入口Springboot类
		SpringApplication springApplication=new SpringApplication(Application.class);
		//设置它的属性
		springApplication.setBannerMode(Banner.Mode.OFF);

		springApplication.run(args);
	}

}

修改springboot工程的启动logo

029-
从网站下载改写的字体 https://www.bootschool.net/ascii
在resources目录下创建banner.txt文件，将新logo放入即可。

拦截器和过滤器

参考

拦截器Interceptor和过滤器Filter的区别在于：
1、拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。
2、Filter的使用要依赖于Tomcat等容器，导致它只能在web程序中使用；Interceptor依赖Spring，可以使用在非web程序。
3、

访问流程：Tomcat——Filter——Servlet——Interceptor——Controller——Service——Mapper

使用拦截器Interceptor

1、定义一个拦截器，实现HandlerInterceptor接口，实现HandlerInterceptor接口的三个方法：
preHandle() ：这个方法将在请求处理之前进行调用。注意：如果该方法的返回值为false ，将视为当前请求结束，不仅自身的拦截器会失效，还会导致其他的拦截器也不再执行。
postHandle()：只有在 preHandle() 方法返回值为true 时才会执行。会在Controller 中的方法调用之后，DispatcherServlet 返回渲染视图之前被调用。 有意思的是：postHandle() 方法被调用的顺序跟 preHandle() 是相反的，先声明的拦截器 preHandle() 方法先执行，而postHandle()方法反而会后执行。
afterCompletion()：只有在 preHandle() 方法返回值为true 时才会执行。在整个请求结束之后， DispatcherServlet 渲染了对应的视图之后执行。

@Component
public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        System.out.println("Interceptor 前置");
        return true;
    }

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

        System.out.println("Interceptor 处理中");
    }

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

        System.out.println("Interceptor 后置");
    }
}

2、创建一个配置类，将自定义好的拦截器处理类进行注册，并通过addPathPatterns、excludePathPatterns等属性设置需要拦截或需要排除的 URL。

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
        registry.addInterceptor(new MyInterceptor1()).addPathPatterns("/**");
    }
}

使用过滤器Filter

使用步骤：
1、实现Filter接口
2、实现init()、doFilter()、destroy()方法。其中doFilter()方法是干活的。

两种方式
1、案例033：注解方式
2、案例034：配置文件类

注：路径例如 /user/* 不能/user/**

示例：
注解方式：

@Component
@Order(1)
@WebFilter(urlPatterns = "/*")
public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("MyFilter");
        // 要继续处理请求，必须添加 filterChain.doFilter()
        filterChain.doFilter(servletRequest,servletResponse);
    }
}

配置类方式：
定义MyFilter类实现Filter接口，重写三个方法之后：

@Configuration
public class FilterConfig {
    @Bean
    public FilterRegistrationBean registerMyFilter(){
        FilterRegistrationBean<MyFilter> bean = new FilterRegistrationBean<>();
        bean.setOrder(1);
        bean.setFilter(new MyFilter());
        // 匹配"/hello/"下面的所有url
        bean.addUrlPatterns("/hello/*");
        return bean;
    }
    @Bean
    public FilterRegistrationBean registerMyAnotherFilter(){
        FilterRegistrationBean<MyAnotherFilter> bean = new FilterRegistrationBean<>();
        bean.setOrder(2);
        bean.setFilter(new MyAnotherFilter());
        // 匹配所有url
        bean.addUrlPatterns("/*");
        return bean;
    }
}

使用Servlet（了解）

创建servlet继承HttpServlet
在web.xml配置文件中使用servlet servlet-mapping

两种方式：
1、案例031：注解方式->@WebServlet , @ServletComponentScan
2、案例032：通过配置文件类注册组件

设置字符编码

两种方式：

war包

pom文件中的resources需要修改

启动类要继承SpringBootServletInitializer

启动war包：
把war包放入Tomcat的webapps目录下
启动tomcat
访问，地址前要加上war包的包名

jar包

pom文件中的resources需要修改

打包插件要加上版本<version>1.4.2.RELEASE</version>

			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<version>1.4.2.RELEASE</version>
			</plugin>

启动jar包：
在jar包所在文件夹启动cmd
直接浏览器访问，不需要jar包包名

注：war包以本地端口号为准，jar包端口号和上下文根以springboot核心配置文件为准。
因为war包部署到外面的tomcat中，jar包靠内嵌的tomcat启动

集成logback

resources目录下，新建文件，文件名为logback-spring.xml
(Spring官方推荐使用带-spring的文件名作为日志配置文件。

Thymeleaf

Thymeleaf依托于html。新建module时，在选择dependes这一步，除了选择web-spring web之外，还需要选择template engines的Thymeleaf。

需要加：

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

Thymeleaf 默认静态资源放在static，后面写相对路径，静态资源的就可以从这下面的目录开始写。

后台刷新

不用关闭服务器，更新内容时，再次访问显示新内容。
1、springboot核心配置文件添加spring.thymeleaf.cache=false关闭thymeleaf缓存
2、edit configuration ，update action和on frame deactivation 都改为update resourecs

Thymeleaf表达式

标准变量表达式
语法：${.......}
作用：访问容器（tomcat）上下文环境中的变量，使用${变量名}获取COntroller中model其中的数据
例：<h3 th:text="${user.username}"></h3>

注：thymeleaf 这里的html可以访问对象的私有变量

选择变量表达式
语法：*{......}
作用：在div中使用 * 来代替绑定的对象。
例：

<div th:object="*{user}">
    用户编号：<span th:text="*{id}"></span>
</div>

url路径表达式
语法：@{......}
作用：和传统写法，在绝对路径方面无区别，但是在相对路径中，有区别
例1：<a th:href="@{http://localhost:8080/xxx}">跳转至XXXX</a>
例2：<a th:href="@{/xxx}">跳转至XXXX</a>

带参(后台获取)路径
例：<a th:href="@{'/xxx?id='+${id}}">跳转至XXXX</a>
最终版：
例：<a th:href="@{/xxx(id=${id},name=${name},age=${age})}">跳转至XXXX带参</a>
小括号相当于？，在RESTful风格中不要（）

Thymeleaf常见属性

th:action
表单提交

通常需要从后台取值，就用th:
如果不需要就用普通html的

th:if
条件判断
例如：<div th:if="${xxx eq x} >yyy</div>"
满足条件就显示yyy

th:unless
条件取反
和th:if正好相反

th:switch/th:case

<div th:switch="${xxx}">
	<span th:case="0">0000</span>
	<span th:case="1">1111</span>
	<span th:case="*">无</span>
</div>

内敛表达式

th:inline=“text”
text这个地方有三个取值：text、javascript、none
例：在标签内生效。

<div th:inline="text">
	数据：[[${data}]]
</div>

这时候取不到后台的值

<script type="text/javascript">
	function showData(){
		alert(${data})
	}
</script>
<button th:onclick="showData()">展示数据</button>

需要内敛脚本

<script type="text/javascript" th:inline="javascript">
	function showData(){
		alert([[${data}]])
	}
</script>
<button th:onclick="showData()">展示数据</button>

Thymeleaf字面量

字符串拼接
| ${xxx} ${yyy} ${zzz}|

表达式 基本对象

由#开始引用
比如后端有request.getSession().setAttribute("data",data);

<span th:text="${#session.getAttribute('data')}"></sapn>
<span th:text="${#httpSession.getAttribute('data')}"></sapn>
<span th:text="${#session.data}"></sapn>

获取访问的路径

<script type="text/javascript" th:inline="javascript">
	//http:localhost:8080/springboot/user/detail
	//获取协议名
	var scheme =[[${#request.getScheme()}]];
	//获取服务器名称
	var serverName=[[${#request.getServerName()}]];
	//获取服务器端口号
	var serverPort=[[${#request.getServerPort()}]];
	//获取上下文根
	var contextPath=[[${#request.getCOntextPath()}]];
	//拼接
	var allPath=scheme+"://"+schemeName+":"+serverPort++"/"contextPath

</script>

方式二

<script type="text/javascript" th:inline="javascript">
	//路径
	var requestURL=[[${#httpServletRequest.requestURL}]];
	//参数
	var queryString = [[${#httpServletRequest.queryString}]];

	var requestAdddress = requestURL + "?" + queryString ;
</script>

功能对象

内置功能对象前都需要加#号，内置对象一般以 s 结尾
加入后端发送了 Date类型实例变量 time

<div th:text="${dates.format(time,'yyyy-MM-dd HH:mm:ss')}"></div>