对SpringBoot的详细学习（整合持久层，整合视图层。。。）

2023-11-11 17:40:34

Spring Boot

Spring Boot 是Java领域的第一框架。

通过Spring Boot可以快速构建一个基于Spring框架的Java Application, 简化配置，自动装配。

JavaConfiguration 用 Java类替代XML的配置方式。

Spring Boot对常用的第三方库提供了配置方案，可以很好地和Spring进行整合，一键式搭建功能完备的Java企业级应用。

开箱即用是 Spring Boot 的特点

1.Spring Boot 的优势：

不需要任何XML配置文件
内嵌Tomcat，可以直接部署
默认支持JSON数据，不需要进行转换
支持RESTful
配置文件非常简单，支持YAML格式

Spring Boot是一种只需要极少配置就可以快速搭建Spring应用，并且集成了常用的第三方类库，让开发者可以快速进行企业级应用开发。
Spring Boot 2.x要求必须基于Spring 5.x，Spring 5.x要求Java版本必须是8以上。

2.Spring Boot的使用

1.创建 Handler

@RestController
@RequestMapping("/hello")
public class HelloHandler {

    @GetMapping("/index")
    public String index(){
        return "Hello Spring Boot";
    }
}

2.创建启动类

package com.southwind.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootApplication {

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

}

启动类必须覆盖所有与业务相关的类: 启动类所在的包必须是业务类所在包的同包或者父包，如果没有覆盖，业务类就不会自动装配到IOC容器中

Spring Boot 配置文件

自定义banner

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nNjFP3Cg-1621597689627)(D:\图片\boot.png)]

Properties

#端口
server.port=8888
#项目访问路径
server.servlet.context-path=/springboot
#cookie失效时间
server.servlet.session.cookie.max-age=100
#session失效时间
server.servlet.session.timeout=100
#编码格式
server.tomcat.uri-encoding=UTF-8

YAML

YAML是不同于Properties的另外一种文件格式，同样可以用来写配置文件, Spring Boot默认支持YAML格式，YAML的优点在于编写简单，结构清晰，利用缩紧的形式来表示层级关系。

相比于Properties, YAML可以进一步简化配置文件的编写，更加方便。

server:
  port: 8888
  servlet:
    context-path: /springboot
    session:
      cookie:
        max-age: 100
      timeout: 100
  tomcat:
    uri-encoding: UTF-8

需要注意的是YAML格式书写规范非常严格，属性名和属性值之间必须至少一个空格。

Spring Boot 会自动集成各种框架

只要你在pom.xml中配置了相关框架的依赖。那么Spring Boot就会自动装载

如果Properties和YAML两种类型的文件同时存在，Properties 的优先级更高。

优先级顺序如下所示:

1、根路径下的config中的配置文件

2、根路径下的配置文件

3、resources 路径下的config中的配置文件

4、resources路径下的配置文件

可以直接在Handler中读取YAML文件中的数据，比如在业务方法中向客户端返回当前服务的端口信息。

package com.southwind.springboot.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/hello")
public class HelloHandler {

    @Value("${server.port}")
    private String port;

    @GetMapping("/index")
    public String index(){
        return "当前服务的端口号："+this.port;
    }
}

@Value注解同样适用于Properties文件.

3.Spring Boot 整合 JSP

Servlet接口，类- -旦实现这个接口，该类就具备了给客户端做响应的功能。

Servlet的体系

最顶层是Servlet接口

第二层: GenericServlet，屏蔽其他不需要的方法

第三层: HttpServlet，根据请求类型再进行分发

第四层:开发者自定义的Servlet

Spring Boot 与视图层的整合

JSP
- JSP 的弊端：效率低
- JSP底层是Servlet
- JSP转换为Servlet,再通过Servlet的方式将视图信息响应给客户端。
Thymeleaf

Java Server Page,是Java提供的一种动态网页技术，底层是Servlet，可以直接在HTML中插入Java代码。

JSP 底层原理：

JSP 是一种中间层组件，开发者可以在这个组件将Java代码与HTML代码经行整合，由JSP引擎将组件转为Servlet,再把开发者定义在组件中的混合代码翻译成Servlet的响应语句，输出给客户端。

1.创建基于maven的项目，添加依赖

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

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

    <dependency>
     <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-jasper</artifactId>
      <version>9.0.45</version>
    </dependency>
  </dependencies>

2.创建Handler

package com.southwind.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class HelloHandler {

    @RequestMapping("/index")
    public ModelAndView index(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("index");
        modelAndView.addObject("mess","hello Spring Boot");
        return modelAndView;
    }
}

3.创建JSP

<%@ page contentType="text/html;charset=UTF-8" language="java"  isELIgnored="false" %>
<html>
<head>
    <title>Title</title>
    <!-- Bootstrap -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/html5shiv@3.7.3/dist/html5shiv.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/respond.js@1.4.2/dest/respond.min.js"></script>
    <!-- jQuery (Bootstrap 的所有 JavaScript 插件都依赖 jQuery，所以必须放在前边) -->
    <script src="https://cdn.jsdelivr.net/npm/jquery@1.12.4/dist/jquery.min.js"></script>
    <!-- 加载 Bootstrap 的所有 JavaScript 插件。你也可以根据需要只加载单个插件。 -->
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/js/bootstrap.min.js"></script>
</head>
<body>
<h1>Index</h1>
${mess}
</body>
</html>

4.application.yml

server:
  port: 8888
spring:
  mvc:
    view:
     prefix: /
     suffix: .jsp

5.Application

package com.wdzl;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

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

实际应用

JSTL

1.pom.xml

    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>

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

Lombok的功能是简化实体类的编写工作，常用的方法getter、setter、toString 等方法都可以由Lombok自动生成，开发者不需要手动编写，Lombok的使用需要安装插件。

2.创建实体类

package com.southwind.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;

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

3.Dao层及其实现类

public interface UserDao {

    Collection<User> finAll();
    User findById(Integer id);
    void addUser(User user);
    void deleteById(Integer id);
    void update(User user);
}

@Repository
public class UserDaoImpl implements UserDao {
    private static Map<Integer,User> map;

    static {
        map = new HashMap<>();
        map.put(1,new User(1,"张三"));
        map.put(2,new User(2,"李四"));
        map.put(3,new User(3,"王五"));
    }


    @Override
    public Collection<User> finAll() {
        return map.values();
    }

    @Override
    public User findById(Integer id) {
        return map.get(id);
    }

    @Override
    public void addUser(User user) {
        map.put(user.getId(),user);
    }


    @Override
    public void deleteById(Integer id) {
        map.remove(id);
    }

    @Override
    public void update(User user) {
        map.put(user.getId(),user);
    }
}

4.Service层的接口及其实现类

public interface UserService {

    Collection<User> finAll();
    User findById(Integer id);
    void addUser(User user);
    void deleteById(Integer id);
    void update(User user);
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDaoImpl userDao;

    @Override
    public Collection<User> finAll() {
        return userDao.finAll();
    }

    @Override
    public User findById(Integer id) {
        return userDao.findById(id);
    }

    @Override
    public void addUser(User user) {
        userDao.addUser(user);

    }

    @Override
    public void deleteById(Integer id) {
        userDao.deleteById(id);
    }

    @Override
    public void update(User user){
        userDao.update(user);
    }
}

5…Controller

package com.southwind.controller;

import com.southwind.pojo.User;
import com.southwind.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;


@Controller
public class UserHandler {
    @Autowired
    private UserService userService;

    @RequestMapping("/findAll")
    public ModelAndView findAll(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("index");
        modelAndView.addObject("list",userService.finAll());
        return modelAndView;
    }

    @RequestMapping("/findById/{id}")
    public ModelAndView findById(@PathVariable("id") Integer id){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("update");
        modelAndView.addObject("user",userService.findById(id));
        return modelAndView;
    }

    @PostMapping("/add")
    public String addUser(User user){
        userService.addUser(user);
        return "redirect:/findAll";
    }

    @RequestMapping("/delete/{id}")
    public String delete(@PathVariable("id") Integer id){
        userService.deleteById(id);
        return "redirect:/findAll";
    }

    @PostMapping("/update")
    public String updateUser(User user){
        userService.update(user);
        return "redirect:/findAll";
    }

}

6.Jsp页面

findAll.jsp

<body>
<h1>你好</h1>
<table>
    <tr>
        <th>编号</th>
        <th>姓名</th>
        <th>操作按钮</th>
    </tr>
    <c:forEach items="${list}" var="user">
        <tr>
            <td>${user.id}</td>
            <td>${user.name}</td>
            <td>
                <a href="/delete/${user.id}">删除</a>
                <a href="/findById/${user.id}">修改</a>
            </td>
        </tr>
    </c:forEach>
</table>
</body>

add.jsp

<body>
<form action="/add" method="post">
    <input type="text" name="id"/><br>
    <input type="text" name="name"/><br>
    <input type="submit" name="提交"/>

</form>

</body>

update.jsp

<body>
<form action="/update" method="post">
    <input type="text" name="id" value="${user.id}" readonly>
    <input type="text" name="name" value="${user.name}">
    <input type="submit">
</form>

</body>

4.Spring Boot 视图层技术

Spring Boot 不推荐使用JSP

1、Thymeleaf模板，类似于JSP，具体的标签名称

2、前后端分离Vue

1、创建Spring Boot应用，选中Thymeleaf模板依赖。

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

2.application.yml视图解析器

spring:
  thymeleaf:
    prefix: classpath/templates/
    suffix: .html

3.实现Controller

package com.wdzl.controller;

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.servlet.ModelAndView;

@Controller
public class MyHandler {

    @RequestMapping("/index")
    public ModelAndView index(Model m){
        ModelAndView modelAndView = new ModelAndView();
        m.addAttribute("hh","dadwada");
        modelAndView.setViewName("index");
        modelAndView.addObject("name","去比");
        return modelAndView;
    }
}

4.HTML页面

<!DOCTYPE html>
<html lang="en">
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
	<h1 th:text="${name}">第一次</h1>
	<p th:text="${hh}"></p>
</body>
</html>

Spring Boot 整合 Thymeleaf

Thymeleaf是目前较为流行的视图层技术，Spring Boot官方推荐使用Thymeleaf。

什么是 Thymeleaf

Thymeleaf是一个支持原生THML文件的Java模版，可以实现前后端分离的交互方式，即视图与业务数据分开响应，它可以直接将服务端返回的数据生成HTML文件,同时也可以处理XML、JavaScript、CSS等格式。

Thymeleaf 最大的特点是既可以直接在浏览器打开(静态方式)，也可以结合服务端将业务数据填充到HTML之后动态生成的页面，Spring Boot 支持Thymelef，使用起来非常方便。

1.创建 Maven 工程，不需要创建Web 工程， pom.xml

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</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-starter-thymeleaf</artifactId>
        </dependency>
    </dependencies>

2.application.yml

spring:
  thymeleaf:
    prefix: classpath:/templates/  #模板路劲
    suffix: .html       #模板后缀
    servlet:
      content-type: text/html   #设置 Contenr-type
    encoding: UTF-8             #编码方式
    mode: HTML5                 #校验H5 格式
    cache: false                #关闭缓存，在开发过程中立即看到结果

3.创建Handler

package com.southwind.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
@RequestMapping("/hello")
public class HelloHandler {

    @GetMapping("/index")
    public ModelAndView index(){
        ModelAndView modelAndView= new ModelAndView();
        modelAndView.setViewName("index");
        modelAndView.addObject("name","赵童");
        return modelAndView;
    }
}

4.启动类

package com.southwind;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

5.HTML

<!DOCTYPE html>
<html lang="en">
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>Hello</h1>
    <p th:text="${name}">hello world</p>
    
</body>
</html>

如果需要加载后台返回的业务数据，则需要在HTML页面中使用Thymeleaf模版标签来完成。
1、需要引入模版标签。

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

2、通过特定的标签完成操作

<p th:text="${name}">hello world</p>

Thymeleaf模版标签不同于JSTL, Thymeleaf 模版标签是直接嵌入到HTML原生标签内部。

Thymeleaf 常用标签

th:text

th:text 用于文本的显示，将业务数据的值填充到HTML标签中。

th:if

th:if用于条件判断，对业务数据的值进行判断，如果条件成立，则显示内容，否则不显示，具体的使用如下所示。

 @GetMapping("/if")
    public ModelAndView ifTest(){
        ModelAndView modelAndView= new ModelAndView();
        modelAndView.setViewName("test");
        modelAndView.addObject("score",90);
        return modelAndView;
    }

<!-- if使用-->     
<p th:if="${score >= 90}">优秀</p>
<p th:if="${score < 90}">良好</p>

th:unless

th:unless 也用于条件判断，与th:if 相反，如果条件不成立则显示，否则不显示

  @GetMapping("/unless")
    public ModelAndView unlessTest(){
        ModelAndView modelAndView= new ModelAndView();
        modelAndView.setViewName("test");
        modelAndView.addObject("score",90);
        return modelAndView;
    }

<!--unless使用-->
<p th:unless="${score >= 90}">优秀</p>
<p th:unless="${score < 90}">良好</p>

th:switch th:case

th:switch th:case两个结合起来使用，用作多条件等值判断，逻辑与Java中的switch-case 一致，当switch中的业务数据等于某个case时，就显示该case对应的内容

    @GetMapping("/switch")
    public ModelAndView switchTest(){
        ModelAndView modelAndView= new ModelAndView();
        modelAndView.setViewName("test");
        modelAndView.addObject("studentId",1);
        return modelAndView;
    }

<!--switch case 使用-->
<div th:switch="${studentId}">
    <p th:case="1">你好</p>
    <p th:case="2">李明</p>
    <p th:case="3">张三</p>

th:action

用来指定请求的URL，相当于form表单中的 action

两种使用方式

  @GetMapping("/redirect/{url}")
    public String redirect(@PathVariable("url") String url, Model model){
        model.addAttribute("url","/hello/login");
        return url;
    }




    @PostMapping("/login")
    @ResponseBody
    public String loginTest(){
        return "login";
    }

第一种，前端页面写死

<!--action使用-->
<form th:action="@{/hello/login}" method="post">
    <input type="submit">
</form>

第二种，从后端传入

<!--action使用-->
<form th:action="${url}" method="post">
    <input type="submit">
</form>

如果action的值直接写在HTML中，则需要使用@{}，如果是从后台传来的数据，则使用${}。

th:each

用来遍历集合

pom.xml

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

实体类

package com.southwind.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;

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

controller

 @GetMapping("/list")
    public ModelAndView each(){
        List<User> list = new ArrayList<>();
        User u1 = new User(1,"张三");
        User u2 = new User(2,"王五");
        User u3 = new User(3,"李四");
        list.add(u1);
        list.add(u2);
        list.add(u3);

        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("test");
        modelAndView.addObject("list",list);
        return modelAndView;
    }

html

<!--    each的使用-->
<table>
    <tr>
        <th>编号</th>
        <th>姓名</th>
    </tr>
    <tr th:each="user:${list}">
        <td th:text="${user.id}"></td>
        <td th:text="${user.name}"></td>

    </tr>
</table>

th:value

用来给标签赋值。

 @GetMapping("/value")
    public ModelAndView value(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("test");
       modelAndView.addObject("value","天不生我");
        return modelAndView;
    }

<!--value的使用-->
<input type="text" th:value="${value}">

th:src

用来引入静态资源，相当于HTML原生标签img、script 的 src 属性

图片，css，js，静态加载的html都需要放置在resources/static文件中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w7DoluTS-1621597689638)(D:\图片\15.png)]

@GetMapping("/src")
public ModelAndView src(){
     ModelAndView modelAndView = new ModelAndView();
     modelAndView.setViewName("test");
     modelAndView.addObject("src","/1.png");
     return modelAndView;
}

    <!--src的使用-->
<img th:src="${src}"/>
<!--src的值直接写在HTML中-->
<img th:src="@{/1.png}"/>

th:href

用作设置超链接

 @RequestMapping("/href")
    public ModelAndView href(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("test");
        modelAndView.addObject("href","https://tong-zhao.gitee.io");
        return modelAndView;
    }

     <!--href使用-->
<a th:href="${href}">点一点</a>

th:selected

用作给HTML元素设置选中，条件成立则选中，否则不选中

@RequestMapping("/select")
    public ModelAndView select(){
        List<User> list = new ArrayList<>();
        User u1 = new User(1,"张三");
        User u2 = new User(2,"王五");
        User u3 = new User(3,"李四");
        list.add(u1);
        list.add(u2);
        list.add(u3);

        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("test");
        modelAndView.addObject("list",list);
        modelAndView.addObject("name","李四");
        return modelAndView;
    }

      <!--select的使用-->
<select>    
    <option th:each="user:${list}"                                   th:value="${user.id}"                                     th:text="${user.name}"                                   th:selected="${user.name == name}"></option></select>

结合th:each来使用，首先遍历list 集合动态创建option元素，根据每次遍历出的user.name与业务数据中的name是否相等来决定是否要选择。

th:attr

给HTML标签的任意属性赋值

 @RequestMapping("/attr")
    public ModelAndView attr(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("test");
        modelAndView.addObject("attr","赵童");
        return modelAndView;
    }

<!--     attr的使用-->
<!--两种用法结果相同-->
<input th:attr="value=${attr}"/><br>
<input th:value="${attr}"/>

Thymeleaf对象

Thymeleaf支持直接访问Servlet Web原生资源，HttpServletRequest、 HttpServletResponse、 HttpSession、ServletContext.

#request : 获取 HttpServletRequest 对象

#response ：获取 HttpServletResponse 对象

#session ：获取 HttpSession 对象

#servletContext : 获取ServletContext对象

 @RequestMapping("/servlet")
 public String servlet(HttpServletRequest request){
     request.setAttribute("value","request");
     request.getSession().setAttribute("value","session");
     request.getServletContext().setAttribute("value","servletContext");
     return "test";
 }

         <!--servlet -->
<p th:text="${#request.getAttribute('value')}"></p><br>
<p th:text="${#session.getAttribute('value')}"></p><br>
<p th:text="${#servletContext.getAttribute('value')}"></p><br>
<p th:text="${#response}"></p>

Thymemeaf支持直接访问 session，${#request.getAttribute('value')}也可以简化成${name}

@RequestMapping("/servlet2")
    public ModelAndView servlet2(HttpSession session){
        session.setAttribute("name","李四");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("test");
        modelAndView.addObject("name","张三");
        return modelAndView;
    }

<!--上面是下面的简化-->
<p th:text="${name}"></p>
<p th:text="${#request.getAttribute('name')}"></p>
<p th:text="${session.name}"></p>
<p th:text="${#session.getAttribute('name')}"></p>

Thymeleaf 内置对象

dates ：日期格式化
calendars：日期操作
numbers : 数字格式化
strings : 字符串格式化
bools : boolean
arrays : 数组内置对象
lists : List集合内置对象
sets : Set集合内置对象
maps : Map集合内置对象

@RequestMapping("/utility")
    public ModelAndView utility(){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("test");
        modelAndView.addObject("date",new Date());
        Calendar calendar = Calendar.getInstance();
        calendar.set(2020,2,18);
        modelAndView.addObject("calendar",calendar);
        modelAndView.addObject("number",0.50);
        modelAndView.addObject("string","String Boot");
        modelAndView.addObject("boolean",false);
        modelAndView.addObject("array", Arrays.asList("你好","世界","哈哈"));

        List<User> list = new ArrayList<>();
        User u1 = new User(1,"张三");
        User u2 = new User(2,"王五");
        User u3 = new User(3,"李四");
        list.add(u1);
        list.add(u2);
        list.add(u3);
        modelAndView.addObject("list", list);

        Set<User> set = new HashSet<>();
        set.add(new User(5,"屈波"));
        set.add(new User(6,"唐康"));
        modelAndView.addObject("set", set);

        Map<Integer,User> map = new HashMap<>();
        map.put(1,new User(66,"王必武"));
        map.put(2,new User(88,"幕佳"));
        modelAndView.addObject("map", map);

        return modelAndView;
    }

date格式化: <span th:text="${#dates.format(date,'yyyy-MM-dd')}"></span><br>
当前日期: <span th:text="${#dates.createToday()}"></span><br>
当前时间: <span th:text="${#dates.createNow()}"></span><br>
Calendar格式化: <span th:text="${#calendars.format(calendar,'yyyy-MM-dd')}"></span><br>
number百分比格式化: <span th:text="${#numbers.formatPercent(number,2,2)}"></span><br>
name是否为空: <span th:text="${#strings.isEmpty(string)}"></span><br>
name长度: <span th:text="${#strings.length(string)}"></span><br>
name拼接: <span th:text="${#strings.concat('OK',string)}"></span><br>
boolean是否为true: <span th:text="${#bools.isTrue(boolean)}"></span><br>
arrays的长度: <span th:text="${#arrays.length(array)}"></span><br>
arrays是否包含张三: <span th:text="${#arrays.contains(array,'张三')}"></span><br>
List是否为空: <span th:text="${#lists.isEmpty(list)}"></span><br>
List的长度: <span th:text="${#lists.size(list)}"></span><br>
Set是否为空: <span th:text="${#sets.isEmpty(set)}"></span><br>
Set的长度: <span th:text="${#sets.size(set)}"></span><br>
Map是否为空: <span th:text="${#maps.isEmpty(map)}"></span><br>
Map的长度: <span th:text="${#maps.size(map)}"></span><br>

5.Spring Boot 整合持久层

5.1Spring Boot 整合 JdbcTemplate

JdbcTemplate是Spring自带的JDBC模版组件，底层实现了对JDBC的封装，用法与MyBatis类似，需要开发者自定义SQL语句, JdbcTemplate帮助我们完成数据库的连接，SQL 执行，结果集的封装。
不足之处是灵活性不如MyBatis,因为MyBatis的SQL语句定义在XML中，更有利于维护和扩展,JdbcTemplate以硬编码的方式将SQL直接写在Java代码中，不利于扩展维护。

1.导入依赖

<parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.4.5</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-starter-jdbc</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

2.创建实体类

package com.southwind.pojo;

import lombok.Data;

@Data
public class User {
    private Integer id;
    private String name;
    private String password;
    private int age;
}

3.创建UserDao接口，及其实现类

package com.southwind.dao;

import com.southwind.pojo.User;

import java.util.List;

public interface UserDao {
    List<User> findAll();
    User findById(Integer id);
    int addUser(User user);
    int update(User user);
    int deleteById(Integer id);
}

package com.southwind.dao.impl;

import com.southwind.dao.UserDao;
import com.southwind.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class UserDaoImpl implements UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public List<User> findAll() {
        String sql ="select*from user";
        return jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(User.class));
    }

    @Override
    public User findById(Integer id) {
        String sql ="select*from user where id = ?";
        return jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<>(User.class),id);
    }

    @Override
    public int addUser(User user) {
        String sql ="insert into user (id,name,password,age) values (?,?,?,?)";
        return jdbcTemplate.update(sql,user.getId(),user.getName(),user.getPassword(),user.getAge());
    }

    @Override
    public int update(User user) {
        String sql ="update user set name = ? where id = ?";
        return jdbcTemplate.update(sql,user.getName(),user.getId());
    }

    @Override
    public int deleteById(Integer id) {
        String sql ="delete from user where id = ?";
        return jdbcTemplate.update(sql,id);
    }
}

4.Controller

package com.southwind.controller;

import com.southwind.dao.impl.UserDaoImpl;
import com.southwind.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/user")
public class UserHandler {
    @Autowired
    private UserDaoImpl userDao;


    @GetMapping("/findAll")
    public List<User> findAll(){
        return userDao.findAll();
    }

    @GetMapping("/findById/{id}")
    public User findById(@PathVariable("id") Integer id){
        return userDao.findById(id);
    }

    @PostMapping("/add")
    public int add(@RequestBody User user){
        return userDao.addUser(user);
    }

    @PutMapping("/update")
    public int update(@RequestBody User user){
        return userDao.update(user);
    }

    @RequestMapping("/delete/{id}")
    public int delete(@PathVariable("id") Integer id){
        return userDao.deleteById(id);
    }
}

5.配置文件

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 13992794421

6.启动类

package com.southwind;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

5.2Spring Boot 整合 MyBatis

ORM框架 (Object Relationship Mapping) 对象关系映射

对象是指Java这种面向对象的编程语言

关系是指关系型数据库

一对多关系

User -> Order

User表

Order表

MySQL中的数据关联我们使用字段值经行映射

product_ info 中的category_ type的值和product_ category中的category. _type相等

Spring Boot会自动创建MyBatis框架所需要的各种bean,开发者只需要在pom.xml中把MyBatis的相关依赖添加进来即可，

1.导入相关依赖pom.xml

 <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </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>
        </dependency>

2.配置yml文件

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 13992794421
mybatis:
  mapper-locations: classpath:/mapping/*.xml
  type-aliases-package: com.wdzl.entity

3.创建实体类

package com.wdzl.entity;


import lombok.Data;

@Data
public class User {
    private Integer id;
    private String name;
    private String password;
    private Integer age;
}

4.创建Repository接口，及其映射的xml文件

package com.wdzl.repository;

import com.wdzl.entity.User;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface UserRepository {
    List<User> findAll();
}

<?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.wdzl.repository.UserRepository">
    <select id="findAll" resultType="com.wdzl.entity.User">
        select * from user
    </select>
</mapper>

5.启动类

package com.wdzl;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
@MapperScan("com.wdzl.repository")
public class SpringbootApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootApplication.class, args);

    }

}

6.测试类

package com.wdzl.springboot;

import com.wdzl.entity.User;
import com.wdzl.repository.UserRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class SpringbootApplicationTests {
    @Autowired
    private UserRepository userRepository;

    @Test
    void contextLoads() {
        List<User> list = userRepository.findAll();
        for (User user : list){
            System.out.println(user);
        }
    }

}

MyBatis要使用需要配置哪些对象？

DataSource、sqlSessionFactory对象必须存在，MyBatis框架才能跑

SSM如何做到呢?

spring.xml配置bean标签

Spring Boot如何做到呢?也是需要创建bean,但是现在不需要程序员配置了, Spring Boot会自动装载的。

通过ApplicationContext对象来获取当前Spring创建的对象

开发者只需要在pom.xml中弓|入相关框架的依赖，Spring Boot就会自动创建对应的baen,装载到IoC中。

让框架成为可插拔的形式。

1.导入依赖pom.xml

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

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

2.创建实体类

package com.southwind.pojo;

import lombok.Data;

@Data
public class User {
    private Integer id;
    private String name;
    private String password;
    private int age;
}

3.创建UserDao接口，及其映射的xml

package com.southwind.mybatis;

import com.southwind.pojo.User;

import java.util.List;

public interface UserDao {
    List<User> findAll();
    User findById(Integer id);
    int addUser(User user);
    int update(User user);
    int deleteById(Integer id);
}

<?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.southwind.mybatis.UserDao"><!-- 对应dao层的全限定类名-->
    <select id="findAll" resultType="User">
        select*from user
    </select>

    <select id="findById" parameterType="java.lang.Integer" resultType="User">
        select * from user where id = #{id}
    </select>

    <insert id="addUser" parameterType="User">
        insert into user (name,password,age) values (#{name},#{password},#{age})
    </insert>

    <update id="update" parameterType="User">
        update user name =#{name} where id=#{id}
    </update>

    <delete id="deleteById" parameterType="java.lang.Integer">
        delete from user where id = #{id}
    </delete>
</mapper>

4.Handler

package com.southwind.controller;

import com.southwind.mybatis.UserDao;
import com.southwind.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/User")
public class Handler {

    @Autowired
    private UserDao userDao;

    @GetMapping("/findAll")
    public List<User> findAll(){
        return userDao.findAll();
    }

    @GetMapping("/findById/{id}")
    public User findById(@PathVariable("id") Integer id){
        return userDao.findById(id);
    }

    @PostMapping("/add")
    public int add(@RequestBody User user){
        return userDao.addUser(user);
    }

    @PutMapping("/update")
    public int update(@RequestBody User user){
        return userDao.update(user);
    }

    @RequestMapping("/delete/{id}")
    public int delete(@PathVariable("id") Integer id){
        return userDao.deleteById(id);
    }
}

5.配置文件

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 13992794421
mybatis:
  mapper-locations: classpath:/mapping/*.xml
  type-aliases-package: com.southwind.pojo

6.启动类

package com.southwind;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.southwind.mybatis")
public class MyBatisApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyBatisApplication.class,args);
    }
}

码农公寓

Spring Boot

1.Spring Boot 的优势：

2.Spring Boot的使用

Spring Boot 配置文件

3.Spring Boot 整合 JSP

Servlet的体系

Spring Boot 与视图层的整合

实际应用

4.Spring Boot 视图层技术

Spring Boot 整合 Thymeleaf

什么是 Thymeleaf

Thymeleaf 常用标签

th:text

th:if

th:unless

th:switch th:case

th:action

th:each

th:value

th:src

th:href

th:selected

th:attr

Thymeleaf对象

Thymeleaf 内置对象

5.Spring Boot 整合持久层

5.1Spring Boot 整合 JdbcTemplate

5.2Spring Boot 整合 MyBatis

ORM框架 (Object Relationship Mapping) 对象关系映射

相关文章