SpringBoot2.0(mybatis-plus常见的增删改查和分页)

目录

  • 一,mybatis-plus常见注解
  • 二,创建一个工具类和启动类
  • 三,创建实体类
  • 四,创建mapper接口
  • 五,创建service接口和impl类
  • 六,创建配置类
  • 七,创建controller
  • 八,使用测试工具测试增删改查和分页
    • 8.1,测试全部查询
    • 8.2,测试根据id查
    • 8.3,测试模糊查询
    • 8.4,测试新增
    • 8.5,测试修改
    • 8.6,测试删除
    • 8.7,测试分页
  • 九,QueryWrapper介绍

一,mybatis-plus常见注解

@TableName 用于定义表名
@TableId 用于定义表的主键

属性
value 用于定义主键字段名
type 用于定义主键类型(主键策略 IdType),具体策略如下:

IdType.AUTO          主键自增,系统分配,不需要手动输入
IdType.NONE          未设置主键
IdType.INPUT         需要自己输入 主键值
IdType.ASSIGN_ID     系统分配 ID,用于数值型数据(Long,对应 mysql 中 BIGINT 类型)
IdType.ASSIGN_UUID   系统分配 UUID,用于字符串型数据(String,对应 mysql 中 varchar(32) 类型)

统一配置主键策略
配置全局默认主键类型,实体类就不用加 @TableId(value = "id", type = IdType.AUTO)

mybatis-plus.global-config.db-config.id-type=auto

@TableField 用于定义表的非主键字段

属性
value 用于定义非主键字段名,用于别名匹配,假如java对象属性和数据库属性不一样
exist 用于指明是否为数据表的字段, true 表示是,false 为不是,假如某个java属性在数据库没对应的字段则要标记为faslse
fill 用于指定字段填充策略(FieldFill,用的不多)

 字段填充策略:一般用于填充 创建时间、修改时间等字段
     FieldFill.DEFAULT         默认不填充
     FieldFill.INSERT          插入时填充
     FieldFill.UPDATE          更新时填充
     FieldFill.INSERT_UPDATE   插入、更新时填充。

二,创建一个工具类和启动类

util包 JsonData类
DemoApplication启动类

SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第1张图片
启动类

package com.demo;

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


@SpringBootApplication
@MapperScan("com.demo.mapper")  //

public class DemoApplication {


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

}

工具类

package com.demo.util;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor //会生成一个包含所有变量
@NoArgsConstructor //生成一个无参数的构造方法
public class JsonData {

    /**
     * 状态码 0 表示成功,1表示处理中,-1表示失败
     */
    private Integer code;
    /**
     * 数据
     */
    private Object data;
    /**
     * 描述
     */
    private String msg;

    // 成功,传入数据
    public static JsonData buildSuccess() {
        return new JsonData(0, null, null);
    }

    // 成功,传入数据
    public static JsonData buildSuccess(Object data) {
        return new JsonData(0, data, null);
    }

    // 失败,传入描述信息
    public static JsonData buildError(String msg) {
        return new JsonData(-1, null, msg);
    }

    // 失败,传入描述信息,状态码
    public static JsonData buildError(String msg, Integer code) {
        return new JsonData(code, null, msg);
    }
}

三,创建实体类

Bean包 Lapop类

package com.demo.bean;

import lombok.Data;

@Data
public class Lapop {

    /** 键盘id */
    private Integer id ;
    /** 键盘名称 */
    private String name ;
    /** 键盘尺寸 */
    private String size ;
    /** 键盘重量 */
    private String weight ;
    /** 电压 */
    private String voltage ;
    /** 电流 */
    private String current ;
    /** 键盘接口 */
    private String interfacepass ;
    /** 按键个数 */
    private String number ;
}

四,创建mapper接口

mapper包 LapopMapper接口

package com.demo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.demo.bean.Lapop;

public interface LapopMapper extends BaseMapper<Lapop> {
}

五,创建service接口和impl类

service包 LapopService接口
impl包 LapopServiceImpl类

LapopService接口

package com.demo.service;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.demo.bean.Lapop;

import java.util.List;
import java.util.Map;

public interface LapopService {

    // 查询全部
    List<Lapop> getLapop();

    // 根据id查
    Lapop getByIdLapop(int id);

    //模糊查
    List<Lapop> getLapopBylist(Lapop lapop);

    // 新增
    int addLapop(Lapop lapop);

    // 修改
    int updateLapop(Lapop lapop);

    // 删除
    int deleteLapop(int id);

    // 分页
    IPage<Lapop> selectPageVO(Integer LapopIPage, Integer queryWrapper);
}

LapopServiceImpl类

package com.demo.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.demo.bean.Lapop;
import com.demo.mapper.LapopMapper;
import com.demo.service.LapopService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

@Service
public class LapopServiceImpl implements LapopService {

    @Autowired
    private LapopMapper lapopMapper;

    @Override
    public List<Lapop> getLapop() {
        // 查询全部
        List<Lapop> getLapopList = lapopMapper.selectList(new QueryWrapper<Lapop>());
        return getLapopList;
    }

    @Override
    public Lapop getByIdLapop(int id) {
        // 根据id查
        return lapopMapper.selectById(id);
    }

    @Override
    public List<Lapop> getLapopBylist(Lapop lapop) {
        // 模糊查询
        QueryWrapper queryWrapper = new QueryWrapper<Lapop>();
        queryWrapper.like("name",lapop.getName());
        queryWrapper.gt("Number",lapop.getNumber());
        return lapopMapper.selectList(queryWrapper);
    }


    @Override
    public int addLapop(Lapop lapop) {
        // 新增
        return lapopMapper.insert(lapop);
    }

    @Override
    public int updateLapop(Lapop lapop) {
        // 修改
        return lapopMapper.updateById(lapop);
    }

    @Override
    public int deleteLapop(int id) {
        // 删除
        return lapopMapper.deleteById(id);
    }

    @Override
    public IPage<Lapop> selectPageVO(Integer LapopIPage, Integer queryWrapper) {
        // 分页
        QueryWrapper<Lapop> wrapper = new QueryWrapper<>();
        //第1页,每页2条
        Page<Lapop> page = new Page<>(LapopIPage, queryWrapper);
        IPage<Lapop> LapopbyIPage = lapopMapper.selectPage(page, wrapper);
        System.out.println("总条数"+LapopbyIPage.getTotal());
        System.out.println("总页数"+LapopbyIPage.getPages());
        //获取当前数据
        return LapopbyIPage;
    }
}

六,创建配置类

config包 MybatisPlusPageConfig类
配置分页插件

package com.demo.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MybatisPlusPageConfig {
    /**
     * 新的分页插件
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

}

七,创建controller

controller包 LapopController类

package com.demo.controller;


import com.demo.bean.Lapop;
import com.demo.service.LapopService;
import com.demo.util.JsonData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/lapopController")
public class LapopController {

    @Autowired
    private LapopService lapopService;

    @RequestMapping("/LapopList")
    @ResponseBody
    public JsonData LapopList(){
        // 查询全部
        return JsonData.buildSuccess(lapopService.getLapop());
    }

    @RequestMapping("/LapopByIDDList")
    @ResponseBody
    public JsonData LapopByIDDList(int id){
        // 根据id查
        return JsonData.buildSuccess(lapopService.getByIdLapop(id));
    }

    @RequestMapping("/paLapopByList")
    @ResponseBody
    public JsonData paLapopByList(Lapop lapop){
        // 模糊查
        return JsonData.buildSuccess(lapopService.getLapopBylist(lapop));
    }

    @RequestMapping("/insertLapop")
    public Object insertLapop(@RequestBody Lapop lapop){
        // 新增
        int restue = lapopService.addLapop(lapop);
        return JsonData.buildSuccess(restue);
    }

    @RequestMapping("/updateLapop")
    public Object updateLapop(@RequestBody Lapop lapop){
        // 修改
        int request = lapopService.updateLapop(lapop);
        return JsonData.buildSuccess(request);
    }

    @RequestMapping("/deleteLapop")
    public Object deleteLapop(int id){
        // 删除
        return JsonData.buildSuccess(lapopService.deleteLapop(id));
    }

    @RequestMapping("/PageLapop")
    public Object PageLapop(Integer passerIPage, Integer queryWrapper ){
        // 分页
        return JsonData.buildSuccess(lapopService.selectPageVO(passerIPage,queryWrapper));
    }
}

八,使用测试工具测试增删改查和分页

8.1,测试全部查询

SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第2张图片
SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第3张图片

8.2,测试根据id查

SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第4张图片
SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第5张图片

8.3,测试模糊查询

SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第6张图片
SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第7张图片

8.4,测试新增

SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第8张图片
SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第9张图片

8.5,测试修改

SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第10张图片
SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第11张图片

8.6,测试删除

SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第12张图片
SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第13张图片

8.7,测试分页

SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第14张图片
SpringBoot2.0(mybatis-plus常见的增删改查和分页)_第15张图片

九,QueryWrapper介绍

QueryWrapper介绍
可以封装sql对象,包括where条件,order by排序,select哪些字段等等
查询包装类,可以封装多数查询条件,泛型指定返回的实体类

List<BannerDO> list = bannerMapper.selectList(new QueryWrapper<BannerDO>());

核心API

- eq 等于
- ne 不等于
- gt 大于
- ge 大于等于
- lt 小于
- le 小于等于
- or 拼接or
- between 两个值中间
- notBetween 不在两个值中间
- like 模糊匹配
- notLike 不像
- likeLeft 左匹配
- likeRight 右边匹配
- isNull 字段为空
- in in查询
- groupBy 分组
- orderByAsc 升序
- orderByDesc 降序
- having having查询

你可能感兴趣的:(mybatis,spring,spring,boot,java)