SC项目-03SpringBoot整合Mybatis-plus，整合web资源

1 Mybatis-plus介绍

1.1 ORM

对象关系映射（英语：Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序设计技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。如今已有很多免费和付费的ORM产品，而有些程序员更倾向于创建自己的ORM工具。
实质: 对象与数据库中表完成映射.
分析:

对象与表一一映射.
对象中的属性与表中的字段一一映射.

实质: 以对象的方式操作数据库.

说明 : Mybatis满足ORM对象映射的要求,但是Mybatis是一种半自动化的ORM映射框架
案例1: Mybatis进行数据库查询时,是否可以直接转化为对象,供用户使用呢 true 表与对象完成映射.
案例2: Mybatis在进行数据库更新操作时,能否利用对象直接操作呢??? false 不可以.需要自己手写sql.

1.2 MP介绍

MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

1.3 MP特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

1.4 MP入门案例

3.4.1 引入jar包

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.2.0</version>
        </dependency>

1.4.2 编辑POJO对象

@Data
@Accessors(chain = true)
@TableName  //("user")      //1.将对象与表 进行一对一关联
public class User implements Serializable {
    @TableId(type = IdType.AUTO)    //主键的信息  设定自增
    private Integer Id;
    //@TableField(value = "name")     //如果字段名称与属性的名称一致(包含驼峰规则),可以省略不写
    private String name;
    private Integer age;
    private String sex;

1.4.3 编辑Mapper接口

//@Mapper //将接口交给Spring管理
public interface UserDao extends BaseMapper<User> {
    //查询user表的所有的记录
 @Select("select * from user")
    List<User> findAll();
}

1.4.4修改YML映射文件

mybatis-plus:
  #定义别名包
 type-aliases-package: com.jt.pojo
  #加载user标签的mapper文件
 mapper-locations: classpath:/mybatis/mappers/*.xml
  #开启驼峰映射
 configuration:
    map-underscore-to-camel-case: true

1.5 MP实现原理

1.5.1 对象与表如何映射

可以利用自定义的注解的方式实现映射. @TableName 不能省略 @TableField(“name”)如果名称一致可以省略
1.对象的名称与表的名称一一映射.
2.对象中的属性与表中的字段一一映射.

1.5.2 利用接口封装公共的CURD方法

MP主要的目的是实现单表的CRUD操作.所以将公共的方法写到同一个接口中 BaseMapper
以后用户使用时,只需要继承即可.

1.5.3 需要将对象动态转化为SQL

要求:以对象的方式操作数据库. 需要方法动态转化为SQL
userMapper.insert(user对象)
Sql: insert into 表名(字段名称1,字段名称2....) values (属性值1,属性值2......)
personMapper.insert(person对象)
Sql: insert into 表名(字段名称1,字段名称2....) values (属性值1,属性值2......)

底层实现时需要动态的拼接Sql即可.
表名: @TableName注解动态获取
字段名称: @TableField(“name”) 获取
属性值: 动态利用get方法取值即可.

MP将上述的sql结构进行拼接最终形成可执行的Sql.之后利用Mybatis执行sql操作.之后再次封装.

1.6 MP API介绍

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.jt.dao.UserDao;
import com.jt.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.Arrays;
import java.util.List;
@SpringBootTest
class SpringbootDemo2MybatisApplicationTests {
   @Autowired
 private UserDao userDao;
 @Test
 public void testFind(){
      List<User> userList = userDao.findAll();
 System.out.println(userList);
 }
   @Test
 public void testSelect01(){
      List<User> userList = userDao.selectList(null);
 System.out.println(userList);
 }
   /**
 * 业务: 查询id=11的用户信息   主键...
 */ @Test
 public void testSelect02(){
      User user = userDao.selectById(11);
 System.out.println(user);
 }
   /**
 * 业务: 查询name属性为"小乔"的数据
 * sql:  select * from user where name="小乔";
 * 对象的方式 >  sql方式
 */
 @Test
 public void testSelect03(){
      //条件构造器
 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 queryWrapper.eq("name", "小乔");
 List<User> userList = userDao.selectList(queryWrapper);
 System.out.println(userList);
 }
   /**
 * 业务: 查询name属性为"小乔"的数据 并且 age >=18岁
 * sql:  select * from user where name="小乔" and age>=18;
 * * 大于 >  gt| 小于 <  lt   |
 * 大于等于 >= ge  | 小于等于 le
 */ @Test
 public void testSelect04(){
      //条件构造器
 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 queryWrapper.eq("name", "小乔")
                .ge("age", 18);
 List<User> userList = userDao.selectList(queryWrapper);
 System.out.println(userList);
 }
   /**
 * 业务: 查询name中包含 "精"的用户,并且sex为女
 * 业务: 查询name中包含 以精结尾的数据,并且sex为女
 * sql:  select * from user where name like "%精%" and sex="女";
 */ @Test
 public void testSelect05(){
      //条件构造器
 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 queryWrapper.likeLeft("name", "精")
                .eq("sex", "女");
 List<User> userList = userDao.selectList(queryWrapper);
 System.out.println(userList);
 }
   /**
 * 需求: 查询user表中的数据 要求按照年龄降序排列,如果年龄相同按照id降序排列
 */
 @Test
 public void testSelect06(){
      QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 queryWrapper.orderByDesc("age","id");
 List<User> userList = userDao.selectList(queryWrapper);
 System.out.println(userList);
 }
   /**
 * 需求: 查询name属性为null的数据.
 * where name is null */ @Test
 public void testSelect07(){
      QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 queryWrapper.isNull("name");
 List<User> userList = userDao.selectList(queryWrapper);
 System.out.println(userList);
 }
   /**
 * 查询name="小乔" age=17 性别=女的用户
 * 如果传递的是对象.会根据对象中不为null的属性充当where条件.
 */ @Test
 public void testSelect08(){
      User user = new User();
 user.setName("小乔").setAge(17).setSex("女");
 QueryWrapper<User> queryWrapper = new QueryWrapper<>(user);
 List<User> userList = userDao.selectList(queryWrapper);
 System.out.println(userList);
 }
   /**
 * 查询id=1,3,5,10数据.
 * sql: select * from user where id in (1,3,5,10) */ @Test
 public void testSelect09(){
      //转化时,注意使用对象的类型
 Integer[] ids = {1,3,5,10};
 List<Integer> idList = Arrays.asList(ids);
 List<User> userList = userDao.selectBatchIds(idList);
 System.out.println(userList);
 }
   @Test
 public void testInsert(){
      User user = new User();
 user.setName("特朗普").setAge(70).setSex("男");
 userDao.insert(user);
 }
   /**
 * 删除name=null的数据,或者name="特朗普"
 */ @Test
 public void testDelete(){
      QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 queryWrapper.isNull("name")
                .or()
               .eq("name", "特朗普");
 userDao.delete(queryWrapper);
 }
   /**
 * 案例1: 将id=1的数据的年龄改为8000岁.
 * sql1:  update user set age=8000 where id=1; * 案例2: 要求将name="黑熊精" age=5500.
 * sql2:  update user set age=5500 where name="黑熊精";
 */ @Test
 public void testUpdate(){
      User user = new User();
 user.setId(1); //主键充当where条件
 user.setAge(8000);
 userDao.updateById(user);
 //参数说明 1.实体对象  封装set条件的值
 //       2.更新条件构造器
 User temp = new User();
 temp.setAge(5500);
 UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
 updateWrapper.eq("name", "黑熊精");
 userDao.update(temp,updateWrapper);
 }
}

2 SpringBoot整合web资源

2.1 创建web项目

2.2 编辑项目目录结构

2.3 引入jar包文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.jt</groupId>
    <artifactId>springboot_demo3_web</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>springboot_demo3_web</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!--引入插件lombok 自动的set/get/构造方法插件  -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--引入数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!--springBoot数据库连接  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!--spring整合mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.2.0</version>
        </dependency>

        <!--springBoot整合JSP添加依赖  -->
        <!--servlet依赖 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
        </dependency>

        <!--jstl依赖 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>

        <!--使jsp页面生效 -->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2.4 编辑YML配置文件

server:
  port: 8090    #定义端口
  servlet:
    context-path: /   #定义项目的发布路径
spring:
  datasource:
    #driver-class-name: com.mysql.cj.jdbc.Driver   springboot程序采用默认的配置
    url: jdbc:mysql://127.0.0.1:3306/jtdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    username: root
    password: root

  mvc:         #引入mvn配置
    view:
      prefix: /WEB-INF/     # /默认代表根目录 src/main/webapp
      suffix: .jsp

mybatis-plus:
  #定义别名包
  type-aliases-package: com.jt.pojo
  #加载user标签的mapper文件
  mapper-locations: classpath:/mybatis/mappers/*.xml
  #开启驼峰映射
  configuration:
    map-underscore-to-camel-case: true

#引入日志信息.
logging:
  level:
    com.jt.mapper: debug

2.5 查询user列表数据

要求: 用户通过http://localhost:8090/findAll请求.跳转到userList.jsp页面中.并且展现user表所有数据,以MP的方式查询

2.5.1 编辑UserController

package com.jt.controller;

import com.jt.pojo.User;
import com.jt.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

//@RestController   //json  字符串本身   不经过视图解析器
@Controller
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 需求：用户通过http://localhost:8090/findAll
     * 跳转页面路径:userList.jsp
     * 页面取值信息: el表达式:${userList} 从域中取值.
     *              在页面跳转之前应该将userList数据保存到域中 key就是userList.
     */
    @RequestMapping("/findAll")
    public String findAll(Model model){  //利用model对象将数据保存到request对象中.

        //1.查询数据库 获取list集合信息
        List<User> userList = userService.findAll();
        model.addAttribute("userList",userList);
        System.out.println(userList);
        return "userList";
    }

}

2.5.2 编辑UserService

package com.jt.service;

import com.jt.mapper.UserMapper;
import com.jt.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService{

    @Autowired
    private UserMapper userMapper;


    @Override
    public List<User> findAll() {

        return userMapper.selectList(null);
    }
}

2.6 关于IDEA启动web项目配置

-------------------

说明:配置IDEA启动项.将工作目录配置到本项目即可

2.7 异步的方式实现列表展现

2.7.1 跳转到ajax页面

需求:用户通过http://localhost:8090/ajax请求要求跳转到ajax.jsp页面中

/**
     * 跳转到ajax.jsp页面
     */
    @RequestMapping("/ajax")
    public String ajax(){

        return "ajax";
    }

页面效果展现

2.7.2 下载jQuery函数类库

2.7.3 导入函数类库

4.7.3 热部署配置

1).添加依赖包

<!--支持热部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>

2).配置自动加载

3.Ajax加强

3.1 Ajax特点

使用ajax特点为: 局部刷新,异步响应.
同步缺点: 如果进行了同步的请求,那么用户不可以做任何的操作,只能等待任务的完成. 用户的友好性差.

3.2 关于Ajax调用说明

<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>您好Springboot</title>
<script type="text/javascript" src="/js/jquery-3.4.1.min.js"></script>
<script type="text/javascript">
     /**
          for语法1:
            for(let i=0;i<xxx.length;i++){
                .....
            }

          for语法2:   index  代表下标
           for(let index in data){
                console.log("测试for循环")
                let user = data[index];
                alert(user.name);
           }

           for语法3:   user当前循环遍历的对象
               for(let user of data){
                    console.log("for循环测试:"+user.name);
               }

           **/

    $(function(){

        $.ajax({
            type : "get",
            url  : "/findAjax",
            //dataType : "text/json/html/xml",        //返回值类型
            async : false,    //关闭异步操作,改为同步的请求
            success : function(data){
                let trs = "";
                for(let user of data){
                   let id = user.id;
                   let name = user.name;
                   let age = user.age;
                   let sex = user.sex;
                   trs += "<tr align='center'><td>"+id+"</td><td>"+name+"</td><td>"+age+"</td><td>"+sex+"</td></tr>"
                }
                $("#tab1").append(trs);
            },
            error : function(){
                alert("请求异常!!!!");
            }
        })


        //1. $.get(url,data,回调函数)
        //findAjax查询后端userList集合信息.
       /*  $.get("/findAjax",function(data){

            $(data).foreach(function(index,user){
                console.log(user);
               })

            let trs = "";
            for(let user of data){
               let id = user.id;
               let name = user.name;
               let age = user.age;
               let sex = user.sex;
               trs += "<tr align='center'><td>"+id+"</td><td>"+name+"</td><td>"+age+"</td><td>"+sex+"</td></tr>"
            }
            $("#tab1").append(trs);
        }); */

    });

</script>
</head>
<body>
    <table id="tab1" border="1px" width="65%" align="center">
        <tr>
            <td colspan="6" align="center"><h3>学生信息</h3></td>
        </tr>
        <tr>
            <th>编号</th>
            <th>姓名</th>
            <th>年龄</th>
            <th>性别</th>
        </tr>
    </table>
</body>
</html>