Mybatis-Plus使用和进阶

Mybatis-Plus使用和进阶

1.Mybatis-Plus的使用

Mybatis-Plus基于Mybatis做了很多丰富提高，更加方便我们开发。有些接口和注解用起来还是很顺手的。

pom依赖

<?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 http://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.1.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>mybatisplus</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mybatisplus</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-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.0</version>
        </dependency>
    </dependencies>

    <build>
        <!-- 如果mapper.xml是放在src/main/java目录下，需配置以下-->
        <!--<resources>
            <resource>
                <directory>src/main/java</directory>
                <filtering>false</filtering>
                <includes>
                    <include>**/mapper/*.xml</include>
                </includes>
            </resource>
        </resources>-->
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

yml配置文件

server:
  port: 8899
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&useSSL=false&serverTimezone=UTC&characterEncoding=UTF-8
    username: root
    password: 123456


mybatis-plus:
  # 如果是放在src/main/java目录下 classpath:/com/example/mybatisplus/*/mapper/*Mapper.xml
  # 如果是放在resource目录 classpath:/mapper/*Mapper.xml
  mapper-locations: classpath:/mapper/*Mapper.xml
  #实体扫描，多个package用逗号或者分号分隔com.example.mybatisplus
  typeAliasesPackage: com.example.mybatisplus.entity
  global-config:
    #主键类型  0:"数据库ID自增", 1:"用户输入ID",2:"全局唯一ID (数字类型唯一ID)", 3:"全局唯一ID UUID";
    id-type: 3

    #字段策略 0:"忽略判断",1:"非 NULL 判断"),2:"非空判断"
    field-strategy: 2

    #驼峰下划线转换
    db-column-underline: true

    #mp2.3+ 全局表前缀 mp_
    #table-prefix: mp_

    #刷新mapper 调试神器
    #refresh-mapper: true

    #数据库大写下划线转换
    #capital-mode: true

    # Sequence序接列口实现类配置
    key-generator: com.baomidou.mybatisplus.incrementer.OracleKeyGenerator

    #逻辑删除配置（下面3个配置）
    logic-delete-value: 1
    logic-not-delete-value: 0
    #3.0开始废除此属性，请使用@Bean的方式注入至Spring容器
    #sql-injector: com.baomidou.mybatisplus.mapper.LogicSqlInjector

    #自定义填充策略接口实现
    #3.0开始废除此属性，请使用@Bean的方式注入至Spring容器
    #meta-object-handler: com.baomidou.springboot.MyMetaObjectHandler

  configuration:
    #配置返回数据库(column下划线命名&&返回java实体是驼峰命名)，自动匹配无需as（没开启这个，SQL需要写as： select user_id as userId）
    map-underscore-to-camel-case: true
    #是否开启缓存
    cache-enabled: false

    #配置JdbcTypeForNull, oracle数据库必须配置
    jdbc-type-for-null: 'null'

1.数据库有user表，在程序中有对应的实体类

package com.example.mybatisplus.entity;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

/**
 * @Author: carter
 * @Date: 2019/4/19 10:26
 * @Version 1.0
 */
@TableName("user")
public class user {

    
    @TableId(value = "id")
    private Integer id;
    @TableField(value = "name")
    private String name;
    @TableField(value = "age")
    private Integer age;
    @TableField(value = "address")
    private String address;

	/*getter  and  setter*/
    ......
}

2.在创建UserMapper.java接口时只需继承BaseMapper就可以使用父类BaseMapper一些常用的CRUD操作

package com.example.mybatisplus.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.mybatisplus.entity.user;

/**
 * @Author: carter
 * @Date: 2019/4/19 10:32
 * @Version 1.0
 */
public interface UserMapper extends BaseMapper<user> {
}

3.编写 server 和 serviceImpl

package com.example.mybatisplus.service;

import com.example.mybatisplus.entity.user;

import java.util.List;

/**
 * @Author: carter
 * @Date: 2019/4/19 10:40
 * @Version 1.0
 */
public interface UserService {
     user get(Integer id);
     List<user> getList();
     Integer insertUser(user u);
     Integer updateUser(user u);
     Integer deleteUser(Integer id);
}

package com.example.mybatisplus.service;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.example.mybatisplus.entity.user;
import com.example.mybatisplus.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Author: carter
 * @Date: 2019/4/19 10:35
 * @Version 1.0
 */
@Service
public class UserServiceImpl implements UserService{

    @Autowired
    private UserMapper userMapper;

        //基础的CRUD
    /**
     * 查询单条
     * @param id
     * @return user
     */
    public user get(Integer id) {
        return userMapper.selectById(id);
    }

    /**
     * 批量查询操作
     * @return
     */
    public List<user> getList(){
        //参数暂时为null  queryWrapper是查询条件类
        //userMapper.selectBatchIds(idlist);//通过传入List的id集合查询
       return userMapper.selectList(null);
    }

    /**
     * insert操作
     */

    public Integer insertUser(user u){
        return userMapper.insert(u);
    }

    /**
     * update操作
     */
    public Integer updateUser(user u){
        //第二参数暂时为null  queryWrapper是查询条件类
        //userMapper.update(u,null);//更新全部
        //userMapper.updateById(u);//根据id进行更新，没有传值的属性就不会更新
        //userMapper.updateAllColumnById(u);//根据id进行更新，没传值的属性就更新为null
        return userMapper.updateById(u);

    }

    /***
     * delete操作
     */
    public Integer deleteUser(Integer id){
        //参数暂时为null  queryWrapper是查询条件类
        //userMapper.delete(null);//删除全部
        return userMapper.deleteById(id);//根据id删除
    }
}

4.编写controller

package com.example.mybatisplus.Controller;

import com.example.mybatisplus.entity.user;
import com.example.mybatisplus.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @Author: carter
 * @Date: 2019/4/19 10:38
 * @Version 1.0
 */
@RestController
public class UserController {

    @Autowired
    private UserService userService;


     /**
     * 查询单条
     * @param id
     * @return user
     */
    @GetMapping("/user/{id}")
    public user getUserById(@PathVariable("id") Integer id) {
        return userService.get(id);
    }

     /**
     * 批量查询操作
     * @return
     */
    @GetMapping("/userList")
    public List<user> getList() {
        return userService.getList();
    }
    
     /**
     * insert操作
     */
    @PostMapping("/insertUser")
    public Integer insertUser(@RequestBody user u) {
        return userService.insertUser(u);
    }

    /**
     * update操作
     */
    @PostMapping("/updateUser")
    public Integer updateUser(@RequestBody user u){
        //第二参数暂时为null  queryWrapper是查询条件类
        return userService.updateUser(u);
    }

    /***
     * delete操作
     */
    @GetMapping("/deleteUser/{id}")
    public Integer deleteUser(@PathVariable("id") Integer id){
        //参数暂时为null  queryWrapper是查询条件类
        return userService.deleteUser(id);
    }

}

条件构造器使用

1.查询年龄在20-30 address为湖北的

//查询年龄在20-30  address为湖北的
    public  IPage<user>  selectUserPage() {

        Page page = new Page<user>(1,20);
        QueryWrapper<user> queryWrapper = new QueryWrapper<user>().between("age", 20, 30).eq("address", "湖北");
        IPage<user> userIPage = userMapper.selectPage(page, queryWrapper);
        return userIPage;
    }

执行结果：

QueryWrapper类的between方法有三个参数，第一个参数是需要比较的字段名（数据库的，不是实体类的），第二和第三个参数是比较的条件,eq是equals的简写。

Page在构造对象是可传参也可不传参第一个参数表示页码 和每页记录条数，若不传参数默认页码为1，每页记录条数为10。

total,size,current,searchCount,pages返回参数是Page类的属性

2.查询age为22且address中带有湖北、或者name中带有“张”的用户

//查询age为22且address中带有湖北、或者name中带有“张”的用户：
public  IPage<user>  selectList() {
    Page page = new Page<user>(1,20);
    QueryWrapper<user> queryWrapper = new QueryWrapper<user>()
        .eq("age",22)
        .like("address","湖北")
        .or()
        .like("name","张");
    IPage<user> userIPage = userMapper.selectPage(page, queryWrapper);
    return userIPage;
}

执行结果：

like()相当于sql的模糊查询。or()相当于sql的or关键字

3、查询address为广东，根据age排序，简单分页

 //查询address为广东，根据age排序，简单分页：
    public  List<user>  selectLists() {
        QueryWrapper<user> queryWrapper = new QueryWrapper<user>()
                .eq("address","广东")
                .orderBy(true,true,"age")
                .last("limit 1,3");
        List<user> list = userMapper.selectList(queryWrapper);
        return list;
    }

执行结果：

4.根据条件更新

// 根据条件更新
public  Integer  update() {
    user user = new user();
    user.setName("苍老师");
    user.setAge(18);
    QueryWrapper<user> queryWrapper = new QueryWrapper<user>()
        .eq("name","小李飞刀")
        .eq("age",36);
    Integer count=userMapper.update(user,queryWrapper);
    return count;
}

5.根据条件删除

//根据条件删除
public Integer delete(){
    QueryWrapper<user> queryWrapper = new QueryWrapper<user>()
        .eq("name","李侃")
        .eq("age",27);
    Integer count = userMapper.delete(queryWrapper);
    return count;
}

2.MyBatis-plus进阶

一、ActiveRecord:

Active Record(活动记录)，是一种领域模型模式，特点是一个模型类对应关系型数据库中的一个表，而模型类的一个实例对应表中的一行记录。ActiveRecord 一直广受动态语言（ PHP 、 Ruby 等）的喜爱，而 Java 作为准静态语言，对于 ActiveRecord 往往只能感叹其优雅，所以 MP 也在 AR 道路上进行了一定的探索，仅仅需要让实体类继承 Model 类且实现主键指定方法，即可开启 AR 之旅。

接下来看具体代码：

1.entity:

public class User extends Model<User> {
    private Integer id;
    private String name;
    private Integer age;
    private Integer gender;
    //重写这个方法，return当前类的主键
    @Override
    protected Serializable pkVal() {
        return id;
    }
    //getter and setter
}

注：实体类继承Model类，重写pkVal方法。

2.UserMapper

package com.example.mybatisplus.mapper.ActiveRecord;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.mybatisplus.entity.ActiveRecord.User;

/**
 * @Author: carter
 * @Date: 2019/4/20 14:54
 * @Version 1.0
 */
public interface NewUserMapper extends BaseMapper<User> {
}

注：虽然AR模式用不到该接口，但是一定要定义，否则使用AR时会报空指针异常。

3.UserService

package com.example.mybatisplus.service.ActiveRecord;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.mybatisplus.entity.ActiveRecord.User;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Author: carter
 * @Date: 2019/4/20 14:52
 * @Version 1.0
 */
@Service
public class NewUserServiceImpl implements NewUserService {
    @Override
    //插入数据
    public Boolean insert(User user) {
        return user.insert();
    }

    @Override
    //根据id修改
    public Boolean update(User user) {
        return user.updateById();
    }

    @Override
    //根据id删除
    public Boolean delete(User user) {
        return user.deleteById();
    }

    @Override
    //查询所有
    public List<User> seleteList() {
        User user=new User();
        //1、查询所有
        //List<User> users = user.selectAll();
        //2、根据条件查询
        List<User> users = user.selectList(new QueryWrapper<User>().like("name","刘"));
        //3、查询符合条件的总数
        //int result = user.selectCount(new QueryWrapper<User>().eq("age",22));
        return users;
    }

    @Override
    //根据id查询
    public User seleteOne(Integer id) {
        User user=new User();
        //根据id查询
        //user = user.selectById(1);
        //或者这样用
        //user.setId(1);
        //user = user.selectById();
        return user.selectById(1);
    }
}

4.UserController

package com.example.mybatisplus.Controller.ActiveRecord;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.mybatisplus.entity.ActiveRecord.User;
import com.example.mybatisplus.service.ActiveRecord.NewUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @Author: carter
 * @Date: 2019/4/20 15:51
 * @Version 1.0
 */
@RestController
public class NewUserController {

    @Autowired
    NewUserService userServicel;

    //插入数据
    @PostMapping("/insertAc")
    public Boolean insert() {
        User user=new User();
        user.setName("小晓");
        user.setAge(18);
        user.setAddress("湖北");
        user.setId(17);
        return userServicel.insert(user);
    }

    //根据id修改
    @PostMapping("/updateAc")
    public Boolean update() {
        User user=new User();
        user.setId(7);
        user.setName("王丽雅");
        user.setAge(20);
        user.setAddress("四川");
        return userServicel.update(user);
    }

    //根据id删除
    @PostMapping("/deleteAc")
    public Boolean delete() {
        User user=new User();
        user.setId(15);
        return userServicel.delete(user);
    }

    //查询
    @PostMapping("/selectAc")
    public List<User> seleteList() {
        User user=new User();
        List<User> users = userServicel.seleteList();
        return users;
    }

    //根据id查询
    @PostMapping("/seleteOneAc")
    public User seleteOne(Integer id) {
        return userServicel.seleteOne(17);
    }


}

参考官方文档