关于前端:第四阶段-day924-springboot

40次阅读

共计 11374 个字符，预计需要花费 29 分钟才能阅读完成。

2.3 对于 YML 文件配置信息

2.3.1 对于数据库 url 阐明

1. 时区设定
serverTimezone=GMT%2B8 %2B= + 号
2. 编码格局设定
useUnicode=true&characterEncoding=utf8
3. 是否主动的从新链接
autoReconnect=true
4. 是否容许批量操作
allowMultiQueries=true

2.3.2 对于 Mybatis 配置阐明

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




`<!--
        前提:   Mybatis 进行映射时必须满足属性名称统一
        业务阐明:
            表:      user_id   user_name
            对象:    userId   userName

        解决方案:  开启 mybatis 驼峰规定映射
        原理:
            字段名称 user_id~~~ 去除 "_" 线~~~userid
            ~~~~ 首字母大写 userId~~~~~ 属性 userId
            只有名称统一, 则能够主动映射.
        注意事项:  如果开启驼峰规定, 则必须满足要求.
                 问: 对象的属性 user_id 与字段 user_id 是否映射?  不能映射

    -->`

2.3.3 对于 Mapper 注解优化阐明

因为每个接口都须要增加 Mapper 注解导致代码繁琐. 能够采纳包扫描的形式动静导入 代码如下

`@SpringBootApplication
@MapperScan("com.jt.dao") // 次要通知 mapper 的包门路, 会主动的实现包扫描
public class SpringbootDemo2MybatisApplication {public static void main(String[] args) {SpringApplication.run(SpringbootDemo2MybatisApplication.class, args);
    }

}`

3 Mybatis-plus 介绍

3.1 ORM

对象关系映射（英语：Object Relational Mapping，简称 ORM，或 O /RM，或 O /R mapping），是一种程序设计技术，用于实现面向 对象 编程语言里不同类型零碎的 数据之间的转换 。从成果上说，它其实是创立了一个可在编程语言里应用的“虚构对象数据库”。现在已有很多收费和付费的 ORM 产品，而有些程序员更偏向于创立本人的 ORM 工具。
本质: 对象与数据库中表实现映射
剖析:

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

本质: 以对象的形式操作数据库.

阐明 : Mybatis 满足 ORM 对象映射的要求, 然而 Mybatis 是一种半自动化的 ORM 映射框架
案例 1: Mybatis 进行数据库查问时, 是否能够间接转化为对象, 供用户应用呢 true 表与对象实现映射.
案例 2: Mybatis 在进行数据库更新操作时, 是否利用对象间接操作呢??? false 不能够. 须要本人手写 sql.

3.2 MP 介绍

MyBatis-Plus（简称 MP）是一个 MyBatis 的加强工具，在 MyBatis 的根底上只做加强不做扭转，为简化开发、提高效率而生。

3.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 操作智能剖析阻断，也可自定义拦挡规定，预防误操作

3.4 MP 入门案例

3.4.1 引入 jar 包

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

3.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;
}`

3.4.3 编辑 Mapper 接口

3.4.4 批改 YML 映射文件

3.4.5 入门案例测试

`@Test
    public void testSelect01(){List<User> userList = userDao.selectList(null);
        System.out.println(userList);
    }`

3.5 MP 实现原理

3.5.1 对象与表如何映射

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

3.5.2 利用接口封装公共的 CURD 办法

MP 次要的目标是实现单表的 CRUD 操作. 所以将公共的办法写到同一个接口中 BaseMapper
当前用户应用时, 只须要继承即可.

3.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 操作. 之后再次封装.

3.6 MP API 介绍

`package com.jt;

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);
    }
}`

4 SpringBoot 整合 web 资源

4.1 创立 web 我的项目

4.2 编辑我的项目目录构造

4.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>`

4.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`

4.5 查问 user 列表数据

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

4.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";
    }

}`

4.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);
    }
}`

4.6 对于 IDEA 启动 web 我的项目配置

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

4.7 异步的形式实现列表展示

4.7.1 跳转到 ajax 页面

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

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

页面成果展示

4.7.2 下载 jQuery 函数类库

4.7.3 导入函数类库

阐明: 从课前材料中获取 jQuery 类库即可

4.7.4 热部署配置

1). 增加依赖包

`<!-- 反对热部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>`

2). 配置主动加载


正文完
前端
发表至： 前端
2020-09-25
 0
关于前端:前端高质量交付产品利器之自动化测试
关于前端:关于-SAP-Spartacus-genericlink-component-的模板代码
关于前端:原来项目打包也有这么技巧-浅谈-Tree-Shaking-机制
webpack-express-实现文件精确缓存