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

4次阅读

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

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

`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 是否映射?  不能映射

    -->`

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

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

}`

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

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

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

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

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

无侵入：只做加强不做扭转，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会主动注入根本 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 操作智能剖析阻断，也可自定义拦挡规定，预防误操作

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

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

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

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

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

要求: 以对象的形式操作数据库. 须要办法动静转化为 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 操作. 之后再次封装.

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

`<?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>`

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

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

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

}`

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

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

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

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

页面成果展示

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

1). 增加依赖包

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

2). 配置主动加载

正文完

前端

发表至：前端

2020-09-25

0

关于前端:使用Rollupjs来压缩打包NodejsTS项目

关于前端:eltable表格中嵌入输入框并计算输入占比

关于前端:js中null和undefined的区别

常见图片格式详解

关于javascript:为什么会精度丢失教你看懂-IEEE754

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

2.3 对于 YML 文件配置信息

2.3.1 对于数据库 url 阐明

2.3.2 对于 Mybatis 配置阐明

2.3.3 对于 Mapper 注解优化阐明

3 Mybatis-plus 介绍

3.1 ORM

3.2 MP 介绍

3.3 MP 个性

3.4 MP 入门案例

3.4.1 引入 jar 包

3.4.2 编辑 POJO 对象

3.4.3 编辑 Mapper 接口

3.4.4 批改 YML 映射文件

3.4.5 入门案例测试

3.5 MP 实现原理

3.5.1 对象与表如何映射

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

3.5.3 须要将对象动静转化为 SQL

3.6 MP API 介绍

4 SpringBoot 整合 web 资源

4.1 创立 web 我的项目

4.2 编辑我的项目目录构造

4.3 引入 jar 包文件

4.4 编辑 YML 配置文件

4.5 查问 user 列表数据

4.5.1 编辑 UserController

4.5.2 编辑 UserService

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

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

4.7.1 跳转到 ajax 页面

4.7.2 下载 jQuery 函数类库

4.7.3 导入函数类库

4.7.4 热部署配置

站内搜索