【SpringBoot2学习】动力节点-王鹤

Levent a study

于 2023-11-09 22:06:18 发布

阅读量132

点赞数

分类专栏：笔记文章标签：学习

本文链接：https://blog.csdn.net/Levent_a/article/details/134291132

版权

笔记专栏收录该内容

1 篇文章 0 订阅

订阅专栏

SpringBoot2动力节点王鹤第五章至第十章

第五章接口架构风格
第六章 Springboot集成Redis
- 6.1 配置Windows版本的redis
- 6.2 对比 StringRedisTemplate 和 RedisTemplate
第七章 SpringBoot集成Dubbo
- 7.1 SpringBoot继承Dubbo的文档
第八章
第九章 thymeleaf模板

前四章点击此处
首先要创建空的project，然后加入module
在这里插入图片描述

如果遇到maven插件导入不进来的，记得在settings里面看看maven地址是否正确
在这里插入图片描述

第五章接口架构风格

5.1REST

前言

接口概念： API（Application Programming Interface，应用程序接口）是一些预先定义的接口（如函数、HTTP接口），或指软件系统不同组成部分衔接的约定。用来提供应用程序与开发人员基于某软件或硬件得以访问的一组例程，而又无需访问源码，或理解内部工作机制的细节。

这里的接口是指：可以指访问servlet、controller的url，或调用其他程序的函数。

架构风格就是API的组织方式，传统的方式为： http://localhost:9002/mytrans/addStudent?name=lisi&age=26，在地址上提供了访问的资源名称addStudent, 在其后使用了get方式传递参数。

5.1.1 认识REST

REST(即：表现层状态转移，英文: Representational State Transfer，简称 REST)是一种互联网软件架构设计的风格，但它并不是标准，它只是提出了一组客户端和服务器交互时的架构理念和设计原则，基于这种理念和原则设计的接口可以更简洁，更有层次，REST这个词，是 Roy Thomas Fieding 在他 2000 年的博士论文中提出的。

任何的技术都可以实现这种理念，如果一个架构符合 REST 原则，就称它为 RESTFul 架构

比如我们要访问一个http 接口: http://localhost:8080/boot/order?id=1021&status=l
采用RESTFul 风格则http 地址为: http://localhost:8080/boot/order/1021/1

一句话说明REST：使用url表示资源，使用http动作操作资源

5.1.2 注解

@PathVariable：从url中获取数据
@GetMapping：支持的get请求方式，等同于@RequestMapping(method=RequestMethod.GET)
@PostMapping：支持post请求方式，等同于@RequestMapping(method=RequestMethod.POST)
@PutMapping：支持put请求方式，等同于 @RequestMapping(method=RequestMethod.PUT)
@DeleteMapping：支持delete请求方式，等同于@RequestMapping( method=RequestMethod.DELETE)
@RestController：符合注解，是@Controller 和@ResponseBody组合。
在类的上面使用@RestController ，表示当前类者的所有方法都加入了 @ResponseBody

注解使用

@RestController
public class MyRestController {
    // 学习注解的使用

    //查询id=1001的学生

    /**
     * @PathVariable（路径变量） : 获取url中的数据
     * 属性： value ： 路径变量名
     * 位置： 放在控制器方法的形参前面
     * <p>
     * http://localhost:8080/myboot/student/1002
     * <p>
     * {stuId}:定义路径变量， stuId自定义名称
     */
    @GetMapping("/student/{stuId}")
    public String queryStudent(@PathVariable("stuId") Integer studentId) {
        return "查询学生studentId=" + studentId;
    }
     /**
     * 更新资源
     * <p>
     * 当路径变量名称和 形参名一样， @PathVariable中的value可以省略
     */
    @PostMapping("/student/{id}/{age}")
    public String modifyStudent(@PathVariable Integer id,
                                @PathVariable Integer age) {
        return "更新资源， 执行post请求方式： id=" + id + "#age=" + age;

    }
    
    @PutMapping("/student/test")
    public String test() {
        return "测试请求方式";
    }

前端代码

<h3>添加学生</h3>
<form action="student/zhangsan/20" method="post">
    <input type="submit" value="注册学生">
</form>

5.2 在页面中或者ajax中，支持put，delete请求

这里有个问题，那就是前端直接把method="post"改为method="put"是行不通的，在SpringMVC中有一个过滤器，支持post请求转为put ,delete，完整名称为：org.springframework.web.filter.HiddenHttpMethodFilter

要使用这个过滤器，需要在application.properties(yml)中开启

#启用支持post转put，delet的过滤器
spring.mvc.hiddenmethod.filter.enabled=true

然后在前端页面设置input，让其包含_method参数，值是 put， delete ，而发起这个请求使用的仍然是post方式

<form action="student/test" method="post">
    <input type="hidden" name="_method" value="put">     <--delet方法相似!!!-->
    <input type="submit" value="测试请求方式">
</form>

注意：需要确保请求方式和请求路径格式的组合是唯一的。

第六章 Springboot集成Redis

Redis ：一个基于内存的NoSQL数据库，常用作缓存使用cache，Redis是一个中间，是一个独立的服务器。
Redis的数据类型： string , hash ,set ,zset , list

在Spring,SpringBoot中有RedisTemplate和StringRedisTemplate，处理和redis交互。

6.1 配置Windows版本的redis

为了使用方便下载windows版本的Redis（下面两个都不可以放在中文路径上否则可能会报错）
下拉可以找的目标版本

然后下载Redis客户端jar包

Redis客户端

将windows版本的Redis解压缩

在这里插入图片描述

redis服务“redis-server.exe”启动后如图所示

在这里插入图片描述

使用客户端测试均ok

在这里插入图片描述

redisclient-win32.x86_64.2.0.jar使用方式是，在当前目录的地址框输入cmd，进入cmd输入java -jar
redisclient-win32.x86_64.2.0.jar进入redis图形界面，添加server

在这里插入图片描述

之后在图形界面客户端就能看到刚才添加的数据了

在这里插入图片描述
springboot要使用redis，在新建module的时候，选择NoSQL的Spring Data Redis (Access+Driver)即可。pom中就会有起步依赖。

<!--redis起步依赖： 直接在项目中使用RedisTemplate(StringRedisTemplate)-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<!--在程序中使用RedisTemplate类的方法 操作redis数据， 
		实际就是调用的lettuce 客户端的中的方法-->

springboot中的RedisTemplate使用到的是lettuce客户端
在这里插入图片描述
application.properties设置

#指定redis
spring.redis.host=localhost
spring.redis.port=6379
#spring.redis.password=123

编写controller代码

@RestController
public class RedisController {
    /**
     * 注入RedisTemplate
     *
     * RedisTemplate 泛型
     * RedisTemplate<String,String>
     * RedisTemplate<Object,Object>
     * RedisTemplate
     *
     * 注意： RedisTemplate对象的名称默认为 redisTemplate
     * 方便@Resource按名字注入
     */
    @Resource
    private RedisTemplate redisTemplate;
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    // 添加数据到redis
    @PostMapping("/redis/addstring")
    public String addToRedis(String name, String value)
        // 操作Redis中string类型的数据， 先获取ValueOperations对象
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //添加数据到redis
        valueOperations.set("myname","lisi");
        return "向redis添加string类型的数据";
    }
    // 从redis获取数据
    @GetMapping("/redis/getk")
    public String getData(String k){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        Object v = valueOperations.get(k);
        return "key是"+k+",他的值是："+v;
    }
    @PostMapping("/redis/{k}/{v}")
    public String addStringKV(@PathVariable  String k,
                              @PathVariable  String v){
        // 使用StringRedisTemplate对象
        stringRedisTemplate.opsForValue().set(k,v);
        return "使用StringRedisTemplate对象";
    }
    @GetMapping("/redis/getstr/{k}")
    public String getStringValue(@PathVariable  String k){
        String v  = stringRedisTemplate.opsForValue().get(k);
        return "k的value:"+v;
    }
    
}

可以看出，（stringRedisTemplate）redisTemplate先获取ValueOperations对象，再对redis进行操作
另外，可以用Postman工具模拟浏览器访问，可以避免编写前端代码来测试后端功能。

6.2 对比 StringRedisTemplate 和 RedisTemplate

StringRedisTemplate：把k，v 都是作为String处理，使用的是String的序列化，可读性好。
RedisTemplate：把k，v 经过了序列化存到redis。 k，v 是序列化的内容，不能直接识别。默认使用的是JDK序列化
补充：
序列化：把对象转化为可传输的字节序列过程称为序列化。
反序列化：把字节序列还原为对象的过程称为反序列化。

为什么需要序列化？

序列化最终的目的是为了对象可以跨平台存储，和进行网络传输。而我们进行跨平台存储和网络传输的方式就是IO，而我们的IO支持的数据格式就是字节数组。我们必须在把对象转成字节数组的时候就制定一种规则（序列化），那么我们从IO流里面读出数据的时候再以这种规则把对象还原回来（反序列化）。

什么情况下需要序列化？

通过上面我想你已经知道了凡是需要进行“跨平台存储”和”网络传输”的数据，都需要进行序列化。本质上存储和网络传输都需要经过
把一个对象状态保存成一种跨平台识别的字节格式，然后其他的平台才可以通过字节信息解析还原对象信息。

序列化的方式：

序列化只是一种拆装组装对象的规则，那么这种规则肯定也可能有多种多样，比如现在常见的序列化方式有：JDK（不支持跨语言）、JSON、XML、Hessian、Kryo（不支持跨语言）、Thrift、Protofbuff

举例：

json序列化：json序列化功能将对象转换为 JSON 格式或从 JSON
格式转换对象。例如把一个Student对象转换为JSON字符串{“name”:“李四”, “age”:29}
)，反序列化(将JSON字符串 {“name”:“李四”, “age”:29} 转换为Student对象)

redisTemplate的序列化方式是可以设置的，但是要在存取值之前。
设置序列化方式如下：

/** 设置 RedisTemplate 序列化
     *  可以设置 key 的序列化， 可以设置value的序列化
     *  可以同时设置 key 和 value的序列化
     */
    @PostMapping("/redis/addstr")
    public String  addString(String k,String v){
        // 使用RedisTemplate
        // 设置 key 使用String的序列化！！！！！！！！！！！！！！！！！
        redisTemplate.setKeySerializer( new StringRedisSerializer());
        // 设置 value 的序列化
        redisTemplate.setValueSerializer( new StringRedisSerializer());
        redisTemplate.opsForValue().set(k,v);
        return "定义RedisTemplate对象的key，value的序列化";
    }
    /**
     * 使用json 序列化， 把java对象转为json存储
     */
    @PostMapping("/redis/addjson")
    public String  addJson(){
        Student student  = new Student();
        student.setId(1001);
        student.setName("zhangsan");
        student.setAge(20);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 把值作为json序列化！！！！！！！！！！！！！！！！！！！！！！！！！
        redisTemplate.setValueSerializer( new Jackson2JsonRedisSerializer(Student.class) );
        redisTemplate.opsForValue().set("mystudent", student);
        return "json序列化";
    }
    @PostMapping("/redis/getjson")
    public String  getJson(){
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 把值作为json序列化
        redisTemplate.setValueSerializer( new Jackson2JsonRedisSerializer(Student.class) );
        Object obj  = redisTemplate.opsForValue().get("mystudent");
        return "json反序列化="+ obj;
    }

第七章 SpringBoot集成Dubbo

7.1 SpringBoot继承Dubbo的文档

Dubbo是一款高性能的Java RPC框架。其前身是阿里巴巴公司开源的一个高性能、轻量级的开源Java RPC框架，可以和Spring框架无缝集成。
点击查看官方的Springboot集成Dubbo的文档

需要创建三个module，分别是接口【包括服务接口和数据类Student】，服务提供者【springboot项目】和服务消费者。

7.2.1 创建接口module001

创建为普通的Maven工程就行。
com.hry.model.Student.class

import java.io.Serializable;

public class Student implements Serializable {
    private static final long serialVersionUID = 1901229007746699151L;

    private Integer id;
    private String name;
    private Integer age;
    
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    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;
    }
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

com.hry.service.StudentService.interface

public interface StudentService {

    Student queryStudent(Integer id);
}

7.2.2 创建服务提供者module002

只需要创建springboot项目即可，不需要依赖项。

加入刚刚创建的接口（公共依赖项）

pom.xml中加入

      <!--加入刚刚创建的公共项目的gav-->
		<dependency>
			<groupId>com.hry</groupId>
			<artifactId>module001</artifactId>
			<version>1.0.0</version>
		</dependency>

		<!--dubbo依赖-->
		<dependency>
			<groupId>org.apache.dubbo</groupId>
			<artifactId>dubbo-spring-boot-starter</artifactId>
			<version>2.7.8</version>
		</dependency>

		<!--zookeeper依赖-->
		<dependency>
			<groupId>org.apache.dubbo</groupId>
			<artifactId>dubbo-dependencies-zookeeper</artifactId>
			<version>2.7.8</version>
			<type>pom</type>
			<exclusions>
				<exclusion>
					<artifactId>slf4j-log4j12</artifactId>
					<groupId>org.slf4j</groupId>
				</exclusion>
			</exclusions>
		</dependency>

创建服务

com.bjpowernode.service.impl.StudentServiceImpl.class

import com.hry.model.Student;
import com.hry.service.StudentService;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.stereotype.Component;

/**
 * 使用dubbo中的注解暴露服务
 */
//@Component 可以不用加
@DubboService(interfaceClass = StudentService.class,version = "1.0",timeout = 5000)
public class StudentServiceImpl implements StudentService {
    @Override
    public Student queryStudent(Integer id) {
        Student student  = new Student();
        if( 1001 == id){
            student.setId(1001);
            student.setName("------1001-张三");
            student.setAge(20);
        } else if(1002  == id){
            student.setId(1002);
            student.setName("#######1002-李四");
            student.setAge(22);
        }
        return student;
    }
}

修改配置文件：

application.properties

#配置服务的名称：dubbo:application name="名称“
spring.application.name=studentservice-provider
#配置扫描的包， 扫描的@DubboService
dubbo.scan.base-packages=com.hry.service
##配置dubbo协议
#dubbo.protocol.name=dubbo
#dubbo.protocol.port=20881
#注册中心
dubbo.registry.address=zookeeper://localhost:2181

修改启动类

com.hry.module002.Module002Application.class

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.apache.dubbo.config.spring.context.annotation.EnableDubboConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
 * @EnableDubbo 启用Dubbo
 * @EnableDubboConfig
 * @DubboComponentScan
 */
@SpringBootApplication
//@EnableDubboConfig 不需要了，因为下面的@EnableDubbo已经包含了
@EnableDubbo
public class ProviderApplication {
	public static void main(String[] args) {
		SpringApplication.run(ProviderApplication.class, args);
	}

}

调试Bug:日志框架加载多次，冲突了
pom.xml中排除依赖：在zookeeper中进行添加排除

<dependency>
	<groupId>org.apache. dubbo</groupId>
	<artifactId>dubbo-dependencies-zookeeper</artifactId>
	<version>2.7.8</version>
	<type>pom</type>
	<exclusions>
		<exclusion>
			<artifactId>slf4j-log4j12</artifactId>
			<groupId>org.slf4j</groupId>
		</exclusion>
	</exclusions>
</dependency>

7.2.3 创建服务消费者module003

mudule构建方式同002的创建结构相似，不同之处在于加入了spring web依赖

修改pom.xml文件(同module002加入的一致)
添加一个controller

com.hry.module003.controller.DubboController.class

import com.hry.model.Student;
import com.hry.service.StudentService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DubboController {

    /**
     * 引用远程服务， 把创建好的代理对象，注入给studentService
     */
    //@DubboReference(interfaceClass = StudentService.class,version = "1.0")

    /**
     * 没有使用interfaceClass，默认的就是 引用类型的 数据类型
     */
    @DubboReference(version = "1.0")
    private StudentService studentService;

    @GetMapping("/query")
    public String queryStudent(Integer id){
        Student student   = studentService.queryStudent(id);
        return "调用远程接口，获取对象："+student;
    }
}

修改启动类

com.hry.module002.Module002ApplicationTests.class

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
@EnableDubbo      //Dubbo
class Module002ApplicationTests {
    @Test
    void contextLoads() {
    }
}

修改配置文件application.properties

#指定服务名称
spring.application.name=consumer-application
#指定注册中心
dubbo.registry.address=zookeeper://localhost:2181
#配置扫描的包
dubbo.scan.base-packages=com.hry.controller

测试

首先启用zookeeper3.5.5

点击获取zookeeper下载地址
在这里插入图片描述

然后启用提供者module002的启动类。
之后再启动消费者module003的启动类
访问浏览器localhost:8080/query

在这里插入图片描述

第八章

存着等用到了再看

8.1 打包为war

8.1.1 pom.xml

8.1.2 指定jsp文件编译目录

8.1.3 打包后的war文件名称

8.1.4 完整的build标签内容

8.1.5 创建webapp目录

8.1.6 创建jsp文件

8.1.7 创建JspWarController

8.1.8 设置视图解析器

8.1.9 启动主类继承Spring BootService

8.1.10 指定项目package是war

8.1.11 maven package 打包

8.1.12 发布打包后的war到tomcat

8.1.13

8.2 打包为jar

8.3 SpringBoot部署和运行方式总结

第九章 thymeleaf模板

Thymeleaf是适用于Web和独立环境的现代服务器端Java模板引擎。该模板引擎采用 Java 语言开发模板引擎是一个技术名词，是跨领域跨平台的概念，在 Java 语言体系下有模板引擎，在C#、PHP 语言体系下也有模板引擎，甚至在 JavaScript 中也会用到模板引擎技术，Java 生态下的模板引擎有 Thymeleaf 、Freemaker、Velocity、Beetl等。

Thymeleaf 对网络环境不存在严格的要求，既能用于 Web 环境下，也能用于非 Web 环境下。在非 Web 环境下，他能直接显示模板上的静态数据:在 Web 环境下，它能像 Jsp 一样从后台接收数据并替换掉模板上的静态数据。它是基于 HTML 的，以 HTML 标签为载体，Thymeleaf 要寄托在HTML标签下实现。

Spring Boot 集成了 Thymeleaf模板技术，并且Spring Boot 官方也推荐使用 Thymeleaf来替代JSP 技术，Thymeleaf 是另外的一种模板技术，它本身并不属于 Spring Boot，Spring Boot只是很好地集成这种模板技术，作为前端页面的数据展示，在过去的 Java Web 开发中，我们往往会选择使用 Jsp 去完成页面的动态染，但是jsp 需要翻译编译运行，效率低。

Thymeleaf的官方网站 & 官方手册

9.1 例子

创建一个springboot的module，选择依赖为spring web 和thymeleaf依赖

创建一个controller

com.hry.controller.HelloThymeleafController.class

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import javax.servlet.http.HttpServletRequest;
@Controller
public class HelloThymeleafController {
    @GetMapping("/hello")
    public String helloThymeleaf(Model model,HttpServletRequest request){
        //添加数据到request作用域， 模板引擎可以从request中获取数据
        request.setAttribute("data","欢迎使用Thymeleaf模板引擎");
        //使用model存放对象
        model.addAttribute("mydata","model中的数据");
        //指定视图（模板引用使用的页面（html））
        //逻辑名称  classpath:/templates/hello.html
        return "hello";
    }
}

在resources的templates下新建一个hello.html页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>hello.html</title>
</head>
<body>
    <h3>使用Thymeleaf的例子</h3>
    <p th:text="${data}">想显示数据</p>
    <p th:text="${mydata}">数据</p>
</body>
</html>

在thymeleaf有一些默认的选项，可以在application.properties中修改

#缓存，默认为true,开发阶段建议为false
spring.thymeleaf.cache=false
#编码方式
spring.thymeleaf.encoding=utf-8
#模板类型（默认HTML）
spring.thymeleaf.mode=HTML
#模板的前缀（默认classpath:/templates/）
spring.thymeleaf.prefix=classpath:/templates/
#后缀（默认.html）
spring.thymeleaf.suffix=.html

9.2 表达式

新建一个module，结构如上面的一样

在application.properties中加入以下配置

server.port=9001
server.servlet.context-path=/hry
#缓存，默认为true,开发阶段建议为false
spring.thymeleaf.cache=false
#编码方式
spring.thymeleaf.encoding=utf-8
#模板类型（默认HTML）
spring.thymeleaf.mode=HTML
#模板的前缀
spring.thymeleaf.prefix=classpath:/templates/
#后缀
spring.thymeleaf.suffix=.html

9.2.1 标准变量表达式

th:text=" " 是 Thymeleaf 的一个属性，用于文本的显示
语法: $ {key}
说明:标准变量表达式用于访问容器 (tomcat) 上下文环境中的变量，功能和 EL 中的$ {key}相似。Thymeleaf 中的变量表达式使用$ {key}:的方式获取 Controller中model其中的数据。也就是 request 作用域中的数据。
准备SysUser对象

package com.bjpowernode.model;
public class SysUser {
    private Integer id;
    private String name;
    private String sex;
    private Integer age;
    public SysUser() {
    }
    public SysUser(Integer id, String name, String sex, Integer age) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}

新建controller类

package com.bjpowernode.controller;

import com.bjpowernode.model.SysUser;
import com.bjpowernode.vo.Cat;
import com.bjpowernode.vo.Dog;
import com.bjpowernode.vo.Zoo;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.*;

@Controller
@RequestMapping("/tpl")
public class ThymeleafController {

    //第一个标准变量表达式
    @GetMapping("/expression1")
    public String expression1(Model model){
        //添加数据到Model
        model.addAttribute("site","www.bjpowernode.com");
        model.addAttribute("myuser", new SysUser(1001,"李四","m",20));

        //指定视图
        return "expression1";
    }
}

html页面

<div style="margin-left: 400px">
        <h3>标准变量表达式:  ${key}</h3>
        <p th:text="${site}">key不存在</p>
        <br/>
        <p>获取SysUser对象 属性值</p>
        <p th:text="${myuser.id}">id</p>
        <p th:text="${myuser.name}">姓名</p>
        <p th:text="${myuser.sex}">姓名：m男</p>
        <p th:text="${myuser.age}">年龄</p>
        <p th:text="${myuser.getName()}">获取姓名使用getXXX</p>
    </div>

9.2.2 选择变量表达式

语法:*{key}
说明: 需要配和 th:object 一起使用。选择变量表达式，也叫星号变量表达式，使用 th:object 属性来绑定对象，选择表达式首先使用 th:obiect 来绑定后台传来的对象，然后使用 * 来代表这个对象，后面中的值是此对象中的属性。
选择变量表达式 *{…} 是另一种类似于标准变量表达式 $ {} 表示变量的方法选择变量表达式在执行时是在选择的对象上求解，而$ {}是在上下文的变量 odel 上求解

controller类中添加

    @GetMapping("/expression2")
    public String expression2(Model model){
        //添加数据到Model
        model.addAttribute("site","www.bjpowernode.com");
        model.addAttribute("myuser", new SysUser(1001,"李四","m",20));
        //指定视图
        return "expression2";
    }

Html页面

<div style="margin-left: 400px">
        <h3>选择变量表达式:  *{key}</h3>
        <p>使用 *{} 获取SysUser的属性值</p>
        <div th:object="${myuser}">
            <p th:text="*{id}"></p>
            <p th:text="*{name}"></p>
            <p th:text="*{sex}"></p>
            <p th:text="*{age}"></p>
        </div>
        <p>使用*{}完成的表示 对象的属性值</p>
        <p th:text="*{myuser.name}" ></p>

    </div>

9.2.3 链接变量表达式

语法: @{链接 url}
说明: 主要用于链接、地址的展示，可用于< script src=“…” > < link href=“…” > < a href=“…” >< form action=“…” >、< img src=“” >等，可以在 URL 路径中动态获取数据.

controller类中添加

    //链接表达式
    @GetMapping("/link")
    public String link(Model model){
        model.addAttribute("userId",1002);
        return "link";
    }
    //测试链接表达式的地址
    @GetMapping("/queryAccount")
    @ResponseBody
    public String queryAccount(Integer id){
        return "queryAccount,参数id="+id;
    }
    //有两个参数的地址
    @GetMapping("/queryUser")
    @ResponseBody
    public String queryUser(String name, Integer age){
        return "queryUser,有两个参数：name="+name+",age="+age;
    }

Html页面

    <h3>链接绝对路径</h3>
    <a th:href="@{http://www.baidu.com}">链接到百度</a>

    <h3>链接的是相对地址</h3>
    <a th:href="@{/tpl/queryAccount}">相对地址，没有参数</a>
    <h3>链接的相对地址，使用字符串链接传递参数</h3>
    <a th:href="@{'/tpl/queryAccount?id='+ ${userId} }">获取model中数据</a>
    <h3>推荐使用的传参数的方式</h3>
    <a th:href="@{/tpl/queryAccount(id=${userId})}">传参数</a>
    <h3>传递多个参数</h3>
    <a th:href="@{/tpl/queryUser(name='lisi',age=20)}">传多个参数</a>

9.2.4 Thymeleaf属性

大部分属性和 html 的一样，只不过前面加了一个 th 前缀。加了 th 前的属性，是经过模版引擎处理的。
如：th:action，th:methon，th:href，th:src，th:text，th:style，th:each等
特别的：
在这里插入图片描述

controller类中添加

    //使用模板的属性
    @GetMapping("/property")
    public String useProperty(Model model){
        model.addAttribute("methodAttr","post");
        model.addAttribute("id","2342");

        model.addAttribute("paramname","name");
        model.addAttribute("uservalue","lisi");

        model.addAttribute("textcolor","color:blue");

        return "html-property";
    }
    //循环List
    @GetMapping("/eachList")
    public String eachList(Model model){
        List<SysUser> users  = new ArrayList<>();
        users.add( new SysUser(1001,"张三","m",20));
        users.add( new SysUser(1002,"关羽","m",70));
        users.add( new SysUser(1003,"张飞","m",60));
        users.add( new SysUser(1004,"刘备","m",80));
        users.add( new SysUser(1005,"孙尚香","f",50));
        model.addAttribute("myusers",users);
        return "eachList";
    }

Html页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>属性</title>
    <script th:src="@{/js/jquery-3.4.1.js}" type="text/javascript"></script>
</head>
<body>
    <--简单属性-->
    <div style="margin-left: 400px">
        <h3>属性使用， 在html元素的属性上加入th</h3>
        <form th:action="@{/loginServlet}" th:method="${methodAttr}">
            <input th:type="text" th:name="${paramname}" th:value="${uservalue}"> <br/>
            <input type="button" id="btn" th:onclick="btnClick()" value="按钮">
        </form>

        <p th:style="${textcolor}">这是模板的例子</p>
    </div>
    
    <--each属性-->
    <div style="margin-left: 400px">
       <!--<div th:each="user,userIter:${myusers}">
            <p th:text="${user.id}"></p>
            <p th:text="${user.name}"></p>
            <p th:text="${user.sex}"></p>
            <p th:text="${user.age}"></p>
       </div>-->
       <br/>
       <br/>
       <table border="1" cellpadding="0" cellspacing="0">
           <thead>
             <tr>
                 <td> 编号</td>
                 <td> id 序号 </td>
                 <td> name </td>
                 <td> sex </td>
                 <td> age </td>
                 <td>姓名</td>
                 <td>是否是第一行</td>
             </tr>
           </thead>
           <tbody>
             <tr th:each="user:${myusers}">
                 <td th:text="${userStat.count}+'/'+${userStat.size}"></td>
                 <td th:text="${user.id}"></td>
                 <td th:text="${user.name}"></td>
                 <td th:text="${user.sex}"></td>
                 <td th:text="${user.age}"></td>
                 <td th:text="${userStat.current.name}"></td>
                 <td th:text="${userStat.first}"/>
             </tr>
           </tbody>
       </table>
   </div>
</body>
<script type="text/javascript">
    function btnClick(){
        alert("按钮单击了");
    }
    $(function(){
        $("#btn").click(function(){
            alert("click===jquery")
        })
    })
</script>
</html>