乐趣区

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

作者：

jiezi

在

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).配置主动加载


评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章