O SpringBoot integra o aprendizado básico do modelo JDBC e Thymeleaf (ensino o aprendizado básico em dez minutos!!!)

1.JdbcTemplate

Introdução ao SpringData

As operações do Spring Framework no banco de dados são profundamente encapsuladas em Jdbc. Através da função de injeção de dependência, o DataSource pode ser registrado no JdbcTemplate, para que possamos concluir facilmente o mapeamento objeto-relacional e ajudar a evitar erros comuns, nós pode usá-lo facilmente no SpringBoot.
Características:

1. A velocidade é rápida.Comparado com outros frameworks ORM, o método JDBC é o mais rápido.
2. Configuração simples, produzida pelo próprio Spring, quase nenhuma configuração adicional
3. Baixo custo de aprendizado, afinal JDBC é o conhecimento mais básico, JdbcTemplate é mais como um DBUtils

Integre o JdbcTemplate

Adicione uma dependência em JdbcTemplate em pom.xml

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-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>com.mysql</groupId>
<artifactId>mysql-connector-j</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>
</dependency>
</dependencies>

Adicione a configuração a seguir em application.properties. Vale ressaltar que o SpringBoot configurará automaticamente o DataSource por padrão.
Ele dará prioridade ao pool de conexão HikariCP. Se não houver tal dependência, selecione tomcat-jdbc. Se os dois primeiros não estiverem disponíveis, selecione
Commons DBCP2. Outros tipos de pools de conexão podem ser especificados por meio da propriedade spring.datasource.type

# 数据源
spring:
datasource:
url: jdbc:mysql:///boot?useUnicode=true&characterEncoding=UTF-8
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password:

Inicie o projeto, através do log, você pode ver que o HikariDataSource é injetado por padrão

2022-11-16 09:14:46.329 INFO 16472 --- [ main]
com.xja.Day03Application : Starting Day03Application using Java
1.8.0_201 on DESKTOP-TTS40QH with PID 16472 (E:\课程记录\T6\03-SpringBoot整合
\day03\target\classes started by lenovo in E:\课程记录\T6\03-SpringBoot整合\day03)
2022-11-16 09:14:46.336 INFO 16472 --- [ main]
com.xja.Day03Application : No active profile set, falling back
to 1 default profile: "default"
2022-11-16 09:14:47.614 INFO 16472 --- [ main]
.s.d.r.c.RepositoryConfigurationDelegate : Bootstrapping Spring Data JDBC
repositories in DEFAULT mode.
2022-11-16 09:14:47.624 INFO 16472 --- [ main]
.s.d.r.c.RepositoryConfigurationDelegate : Finished Spring Data repository
scanning in 5 ms. Found 0 JDBC repository interfaces.
2022-11-16 09:14:48.329 INFO 16472 --- [ main]
o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat initialized with port(s): 8080
(http)
2022-11-16 09:14:48.342 INFO 16472 --- [ main]
o.apache.catalina.core.StandardService : Starting service [Tomcat]
2022-11-16 09:14:48.342 INFO 16472 --- [ main]
org.apache.catalina.core.StandardEngine : Starting Servlet engine: [Apache
Tomcat/9.0.68]
2022-11-16 09:14:48.559 INFO 16472 --- [ main] o.a.c.c.C.[Tomcat].
[localhost].[/] : Initializing Spring embedded WebApplicationContext
2022-11-16 09:14:48.560 INFO 16472 --- [ main]
w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext:
initialization completed in 2156 ms
2022-11-16 09:14:48.977 WARN 16472 --- [ main]
ion$DefaultTemplateResolverConfiguration : Cannot find template location:
classpath:/templates/ (please add some templates, check your Thymeleaf
configuration, or set spring.thymeleaf.check-template-location=false)
2022-11-16 09:14:49.090 INFO 16472 --- [ main]
com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Starting...
2022-11-16 09:14:49.283 INFO 16472 --- [ main]
com.zaxxer.hikari.HikariDataSource : HikariPool-1 - Start completed.
2022-11-16 09:14:49.586 INFO 16472 --- [ main]
o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8080
(http) with context path ''
2022-11-16 09:14:49.596 INFO 16472 --- [ main]
com.xja.Day03Application : Started Day03Application in 4.047
seconds (JVM running for 7.288)

teste de caso

Crie uma tabela t_user

CREATE TABLE `student` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) DEFAULT NULL,
`age` int(1) DEFAULT NULL,
`description` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

Classe de entidade

package com.xja.entity;
import lombok.Data;
@Data
public class Student {
    
    
private Integer id;
private String name;
private int age;
private String description;
}

camada de controle

package com.xja.controller;
import java.util.List;
@Controller
@RequestMapping("/student")
public class StudentController {
    
    
@Autowired
private StudentService studentService;
/**
* 查询
*/
@RequestMapping("queryStudentList")
public String queryStudentList(Model model){
    
    
List<Student> list = studentService.queryStudentList();
model.addAttribute("list",list);
return "student_list";
}
/**
* 增加跳转
*/
@RequestMapping("/toAdd")
public String toAdd(){
    
    
return "student_add";
}
/**
* 增加
*/
@RequestMapping("/saveStudent")
public String saveStudent(Student student){
    
    
studentService.saveStudent(student);
return "redirect:/student/queryStudentList";
}
@RequestMapping("/deleteStudent")
public String deleteStudent(Integer id){
    
    
studentService.deleteStudent(id);
return "redirect:/student/queryStudentList";
	}
}

Camada de negócios omitida -> camada de persistência

package com.xja.dao;
import java.util.List;
@Repository //老实持久层的标记 同 @Controller @Service 一起的
public class StudentDao {
    
    
@Autowired
private JdbcTemplate jdbcTemplate;
public List<Student> queryStudentList() {
    
    
String sql = "select * from student";
List<Student> list = jdbcTemplate.query(sql, new
BeanPropertyRowMapper<>(Student.class));
return list;
}
//单个对象 queryForObject
public void saveStudent(Student student) {
    
    
String sql = "insert into student (name,age,description) value
(?,?,?)";
jdbcTemplate.update(sql,student.getName(),student.getAge(),student.getDescript
ion());
}
public void deleteStudent(Integer id) {
    
    
String sql = "delete from student where id = ?";
jdbcTemplate.update(sql,id);
	}
}

página de consulta

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
<link rel="stylesheet" th:href="@{/css/bootstrap.min.css}">
<script type="text/javascript" th:src="@{/js/jquery-3.6.0.js}"></script>
<script type="text/javascript" th:src="@{/js/bootstrap.min.js}"></script>
<script>
$(function () {
      
      
$("#save").click(function () {
      
      
window.location = "toAdd";
})
})
function deletes(id){
      
      
alert(id);
}
</script>
</head>
<body>
<button class="btn btn-success" id="save">增加</button>
<table class="table table-bordered" style="width: 800px">
<tr>
<th>序号</th>
<th>姓名</th>
<th>年龄</th>
<th>描述</th>
<th>操作</th>
</tr>
<tr th:each="stu,i:${list}">
<td th:text="${i.count}"></td>
<td th:text="${stu.name}"></td>
<td th:text="${stu.age}"></td>
<td th:text="${stu.description}"></td>
<td>
<button class="btn btn-sm btn-danger"
th:onclick="|deletes(${stu.id})|">删除</button>
<a th:href="|deleteStudent?id=${stu.id}|">删除</a>
</td>
</tr>
</table>
</body>
</html>

Resultado: ligeiramente

2. Modelo de folha de tomilho

Introdução:
Thymeleaf é um mecanismo de modelo Java moderno do lado do servidor para desenvolver projetos de ambiente da Web e autônomos.
O principal objetivo do Thymeleaf é trazer a elegância do modelo natural - HTML para o seu fluxo de trabalho de desenvolvimento. Pode ser exibido corretamente no navegador direto
e pode ser usado como um protótipo estático, permitindo uma colaboração mais forte entre as equipes de desenvolvimento.
Com os módulos do Spring Framework, livres para escolher como quiser e componentes funcionais conectáveis, o Thymeleaf é
ideal para o desenvolvimento da Web HTML5 JVM moderno - embora possa fazer muito mais.
O modelo de renderização de serviços suportados oficialmente pelo Spring não contém jsp. É Thymeleaf e Freemarker, etc., e
a integração do Thymeleaf com a tecnologia de view do SpringMVC e a configuração automática do SpringBoot é perfeita, e quase não tem custo, basta ficar atento a
sintaxe do Thymeleaf.

Características:

1. Combinação de dinâmico e estático: o Thymeleaf pode ser executado em ambientes de rede e não de rede, ou seja, permite que os artistas visualizem o
   efeito estático da página no navegador e permite que os programadores visualizem o efeito da página dinâmica com dados no servidor . Isso ocorre porque ele oferece suporte a protótipos html e, em seguida,
   adiciona atributos adicionais em tags html para obter modelo + exibição de dados. Quando o navegador interpreta html, ele ignora atributos de tag indefinidos,
   então o modelo de thymeleaf pode ser executado estaticamente; quando alguns dados são retornados para a página, a tag Thymeleaf substituirá dinamicamente o
   conteúdo estático, para que a página possa ser exibida dinamicamente.
   2. Pronto para uso: fornece dialetos padrão e padrão de primavera e pode aplicar modelos diretamente para obter efeitos de expressão JSTL e OGNL, evitando os
   problemas de modelos, jstl e alterações de rótulos todos os dias. Ao mesmo tempo, os desenvolvedores também podem estender e criar dialetos personalizados.
   3. Suporte a vários dialetos: Thymeleaf fornece dialetos padrão de primavera e um módulo opcional perfeitamente integrado ao SpringMVC, que pode realizar rapidamente
   funções como vinculação de formulários, editor de atributos e internacionalização.
   4. Integração perfeita com o SpringBoot, o SpringBoot fornece a configuração padrão do Thymeleaf e configura um analisador de exibição para o Thymeleaf
   , podemos operar o Thymeleaf como costumávamos operar o jsp. Quase não há diferença no código, exceto na sintaxe do modelo
   .

configurações básicas

Criar ambiente Verifique a configuração padrão de
web e Thymeleaf Não há necessidade de fazer nenhuma configuração, o iniciador nos ajudou a configurar o analisador de exibição do Thymeleaf: Além disso, também configura a localização do arquivo de modelo (HTML), um prefixo semelhante a jsp + nome da exibição +Estilo do sufixo Prefixo padrão: classpath:/templates/ Sufixo padrão: .html

Portanto, se retornarmos à exibição: users , ele apontará para classpath:/templates/users.html
O Thymeleaf habilitará o cache de página por padrão para melhorar a simultaneidade da página. Mas isso fará com que nossa página modificada não seja exibida imediatamente, então fechamos
o cache:

#关闭Thymeleaf的缓存
spring.thymeleaf.cache=false

Além disso, após modificar a página, você precisa usar a tecla de atalho: Ctrl + Shift + F9 para atualizar o projeto.
Início rápido
Vamos preparar um controller para controlar o view jump

@Controller
public class HelloController {
    
    
@GetMapping("show1")
public String show1(Model model){
    
    
model.addAttribute("msg", "Hello, Thymeleaf!");
return "hello";
	}
}

Criar um novo modelo HTML

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>hello</title>
</head>
<body>
<h1 th:text="${msg}">大家好</h1>
</body>
</html>

Observe, altere o namespace de html para: xmlns:th="http://www.thymeleaf.org" Haverá prompts de sintaxe
Inicie o projeto e visite a página:

gramática

A principal função do Thymeleaf é renderizar os dados do modelo em HTML, portanto, sua sintaxe é principalmente como analisar os dados do modelo, aprenda com os seguintes aspectos:

• variável

• método

• julgamento condicional

• ciclo

• Operação

   逻辑预算
   布尔运算
   比较运算
   条件运算
  

• outro

variável

Vamos criar uma nova classe de entidade primeiro: User

public class User {
    
    
String name;
int age;
User friend;// 对象类型属性
}

Em seguida, adicione dados ao modelo

@GetMapping("show2")
public String show2(Model model){
    
    
User user = new User();
user.setAge(21);
user.setName("Jack Chen");
user.setFriend(new User("李小龙", 30));
model.addAttribute("user", user);
return "show2";
}

Descrição gramatical:
Thymeleaf usa ${} para obter variáveis ​​no modelo. Observe que esta não é uma expressão el, mas uma expressão ognl, mas a sintaxe é muito semelhante.
Exemplo:
Obtemos dados do usuário na página:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>用户页面</title>
</head>
<body>
<div th:text="${user.name}"></div>
</body>
</html>

Resultado:
parece quase o mesmo que a expressão el. Mas a diferença é que nossa expressão é escrita em um atributo de tag chamado: th:text, que
é chamado de diretiva

Combinação de instruções dinâmicas e estáticas
:
Thymeleaf defende modelos naturais, o que significa que os modelos são códigos html puros, que são separados do mecanismo de modelo e podem ser executados diretamente em um ambiente puramente estático
. Agora, se escrevermos diretamente uma expressão como ${} em html, obviamente ela dará errado em um ambiente estático, o que não está de acordo com a
filosofia de Thymeleaf.
Todas as expressões em Thymeleaf precisam ser escritas em diretivas, que são atributos personalizados em HTML5, e todas as diretivas em Thymeleaf
começam com th:. Como a expressão ${user.name} é escrita em um atributo personalizado, em um ambiente estático, o conteúdo da expressão será
tratado como uma string comum e o navegador ignorará automaticamente essas instruções, para que nenhum erro seja relatado !
Agora, em vez de passar pelo SpringMVC, abrimos a página diretamente com um navegador para ver:

• Em páginas estáticas, o comando th não é reconhecido, mas o navegador não relatará um erro e o tratará como um atributo normal. Desta forma, o valor padrão do span, faça login, será exibido na página
• Se estiver no ambiente Thymeleaf, o comando th será reconhecido e analisado, e o significado de th:text é substituir o conteúdo do texto no rótulo, portanto, o valor de user.name substitui o padrão faça o login no span

O design da instrução é exatamente o brilho do Thymeleaf e também é a razão pela qual é superior a outros mecanismos de modelo. A combinação de design estático e dinâmico o torna perfeito para
desenvolvedores front-end e desenvolvedores back-end.
Compatibilidade com versões anteriores
Mas preste atenção, e se o navegador não suportar Html5?
Se você não oferece suporte a esse th: namespace, pode substituir th:text por data-th-text e Thymeleaf também é compatível.
Além disso, por motivos de segurança
, o comando th:text processará o valor lido pela expressão para evitar a injeção de HTML.
Por exemplo,

Olá

será formatado como $lt;p$ gt;olá $lt;/p$ lt; .
Se você deseja produzir o conteúdo original em vez da saída formatada, use th:utext em vez disso
Açúcar sintático da expressão ognl
Agora, para obter o valor da variável, usamos o objeto clássico Método de nome de propriedade. Mas, em alguns casos, o próprio nome do atributo pode ser uma variável,
o que devemos fazer?
ognl fornece uma sintaxe semelhante a js:

例如： ${
    
    user.name} 可以写作${
    
    user['name']}

Cenário de variável personalizada
Veja o seguinte caso:

<h2>
<p>Name: <span th:text="${user.name}">Jack</span>.</p>
<p>Age: <span th:text="${user.age}">21</span>.</p>
<p>friend: <span th:text="${user.friend.name}">Rose</span>.</p>
</h2>

Obtemos todas as informações do usuário e as exibimos separadamente.
Quando a quantidade de dados é relativamente grande, será muito problemático escrever o usuário com frequência.
Portanto, Thymeleaf fornece variáveis ​​personalizadas para resolver:
Exemplo:

<h2 th:object="${user}">
<p>Name: <span th:text="*{name}">Jack</span>.</p>
<p>Age: <span th:text="*{age}">21</span>.</p>
<p>friend: <span th:text="*{friend.name}">Rose</span>.</p>
</h2>

Primeiro use th:object="${user}" em h2 para obter o valor de user e salve-o. Em seguida, em qualquer elemento dentro de h2, você pode obter o atributo em user por *{attribute name}, assim economiza muitos métodos
prefixados do usuário

<h2 th:object="${user}">
<p>FirstName: <span th:text="*{name.split(' ')[0]}">Jack</span>.</p>
<p>LastName: <span th:text="*{name.split(' ')[1]}">Li</span>.</p>
</h2>

Objetos globais fornecidos pelo Thymeleaf:

Por exemplo,
adicionamos um objeto do tipo data à variável de ambiente

@GetMapping("show3")
public String show3(Model model){
    
    
model.addAttribute("today", new Date());
return "show3";
}

processamento de página

<p>
今天是: <span th:text="${#dates.format(today,'yyyy-MM-dd')}">2018-04-25</span>
</p>

valor literal

Às vezes, precisamos preencher tipos básicos como string, valor, Boolean, etc. no comando, e não queremos que o Thymeleaf o analise em uma variável ,
que é chamada de valor literal neste momento.
Literais de string
Use um par de ' para citar o conteúdo que é um literal de string:

<p>
你正在观看 <span th:text="'thymeleaf'">template</span> 的字符串常量值.
</p>

Thymeleaf em th:text não é considerado uma variável, mas uma string
Valor literal do número
Os números não precisam de nenhuma sintaxe especial, o que está escrito é o que é e as operações aritméticas podem ser executadas diretamente

<p>今年是 <span th:text="2018">1900</span>.</p>
<p>两年后将会是 <span th:text="2018 + 2">1902</span>.</p>

Literais booleanos
Os literais booleanos são verdadeiros ou falsos:

<div th:if="true">
你填的是true
</div>

Uma instrução th:if é citada aqui, que é semelhante a v-if em vue. Operações
aritméticas Operadores aritméticos suportados: + - * / %

<span th:text="${user.age}"></span>
<span th:text="${user.age}%2 == 0"></span>

• Operações de comparação
  Operações de comparação suportadas: > , < , >= e <= , mas > , < não podem ser usadas diretamente, porque xml será analisado como tags e aliases devem ser usados.
  Observe que == e != não podem apenas comparar valores, semelhante à função de equals.
  Aliases que podem ser usados: gt (>), lt (<), ge (>=), le (<=), not (!).Também eq (==), neq/ne (!=).
• Operação condicional
  1. Operação ternária

 <span th:text="${user.sex} ? '男':'女'"></span>

As três partes do operador ternário: conditon ? então: senão
condição: condição
então: o resultado da condição sendo verdadeiro
else: o resultado de não ser verdadeiro
Cada uma dessas partes pode ser qualquer expressão em Thymeleaf.
2. Valor padrão
Às vezes, tomamos um valor que pode estar vazio. Nesse momento, precisamos fazer um julgamento não vazio. Você pode usar a expressão?: Abreviação de valor padrão
:

 <span th:text="${user.name} ?: '二狗'"></span>

Quando o valor da expressão anterior for nulo, o último valor padrão será usado.
Nota: Não há espaço entre ?: .
ciclo

Loop também é um requisito usado com muita frequência, usamos o comando th:each para concluir:
se houver uma coleção de usuários: os usuários estão no Contexto.

<tr th:each="user : ${users}">
<td th:text="${user.name}">Onions</td>
<td th:text="${user.age}">2.41</td>
</tr>

${users} é a coleção a ser percorrida e pode ser dos seguintes tipos:

1.Iterable, uma classe que implementa a interface Iterable
2.Enumeration, uma enumeração
3.Interator, um iterador
4.Map, o que é percorrido é um Map.Entry
5.Array, um array e todos os outros objetos que estão de acordo com o resultado do array são
iterados ao mesmo tempo, também podemos obter o objeto de estado iterado:

<tr th:each="user,stat : ${users}">
<td th:text="${user.name}">Onions</td>
<td th:text="${user.age}">2.41</td>
</tr>

O objeto stat contém as seguintes propriedades:

• índice, o índice a partir de 0
• contagem, o número de elementos, a partir de 1
• tamanho, o número total de elementos
• atual, o elemento atualmente percorrido
• par/ímpar, retorna se é par ou ímpar, valor booleano
• primeiro/lista, se o valor de retorno é o primeiro ou o último,
  julgamento lógico de valor booleano

Com if e else, podemos alcançar todas ^{as funções_} .
Use th:if ou th:unless em Thymeleaf, o significado dos dois é exatamente o oposto.

<span th:if="${user.age} < 24">小鲜肉</span>

Se a expressão for avaliada como verdadeira, o rótulo será renderizado na página, caso contrário, não será renderizado.
As seguintes condições são consideradas verdadeiras:
o valor da expressão é verdadeiro,
o valor da expressão é um valor diferente de zero,
o valor da expressão é um caractere diferente de zero
, o valor da expressão é uma string, mas não "falso", "não", "off"
A expressão não é um booleano Qualquer um de , string, número, caractere,
outras condições, incluindo nulo, são consideradas falsas