MyBatis-Plus built-in interface method usage

Table of contents

Preface

Service CRUD interface

Preface

Before explaining the case, let me first introduce you to the Faker library:

Faker is a Python library for generating fake but real-looking data. It can generate various types of data, including names, addresses, phone numbers, email addresses, company names, job titles, dates and times.

The purpose of Faker is to help developers quickly generate large amounts of fake data for testing, prototyping, and data analysis. It can also be used to create more realistic simulated data for use in games, social networks, and e-commerce websites.

Faker is a very popular library, it has been downloaded millions of times. It is used by many well-known companies, including Google, Amazon, Microsoft, and Netflix.

Faker’s main advantages include:

Easy to use. Faker has a simple API that allows developers to easily generate fake data.

customizable. Faker allows developers to customize the generated data to meet their specific needs.

Supports multiple languages. Faker supports multiple languages, including English, Spanish, French, German and Chinese.

Integrate with other libraries. Faker can be integrated with other Python libraries such as SQLAlchemy and Django.

Faker is a very useful library that helps developers quickly generate large amounts of fake but real-looking data. It's ideal for testing, prototyping, data analysis, and creating more realistic simulated data.

use:

1. Add Faker dependency to the project:

<dependency>
    <groupId>com.github.javafaker</groupId>
    <artifactId>javafaker</artifactId>
    <version>1.0.2</version>
</dependency>

2. In the code, you can create a Faker instance in the following ways:

Faker faker = new Faker();

3. Then you can use Faker to generate various types of data. For example, you can use the following code to generate a fake name:

String name = faker.name().fullName();

4. You can use Faker to generate a fake address:

Address address = faker.address();
String streetAddress = address.streetAddress();
String city = address.city();
String state = address.state();
String zipCode = address.zipCode();

Faker also supports generating other types of data, including phone numbers, email addresses, company names, job titles, dates, and times. You can find more information on how to use Faker in Faker's official documentation.

Service CRUD interface

Service CRUD interface description:

General Service CRUD encapsulates the IService interface, and further encapsulates CRUD using get 查询单行 remove 删除 list 查询集合 page 分页prefix naming to distinguish Mapperlayers to avoid confusion.

Generic Tfor any entity object

1.1 Save

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);

Parameter Description

type	parameter name	describe
T	entity	entity object
Collection<T>	entityList	Entity object collection
int	batchSize	Insert batch quantity

1.2 SaveOrUpdate

// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

Parameter Description

type	parameter name	describe
T	entity	entity object
Wrapper<T>	updateWrapper	Entity object encapsulation operation class UpdateWrapper
Collection<T>	entityList	Entity object collection
int	batchSize	Insert batch quantity

1.3 Remove

// 根据 queryWrapper 设置的条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

Parameter Description

type	parameter name	describe
Wrapper<T>	queryWrapper	Entity wrapper class QueryWrapper
Serializable	id	Primary key ID
Map<String, Object>	columnMap	table field map object
Collection<? extends Serializable>	idList	Primary key ID list

1.4 Update

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);

Parameter Description

type	parameter name	describe
Wrapper<T>	updateWrapper	Entity object encapsulation operation class UpdateWrapper
T	entity	entity object
Collection<T>	entityList	Entity object collection
int	batchSize	Update batch quantity

1.5 Get

// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

Parameter Description

type	parameter name	describe
Serializable	id	Primary key ID
Wrapper<T>	queryWrapper	Entity object encapsulation operation class QueryWrapper
boolean	throwEx	Will an exception be thrown if there are multiple results?
T	entity	entity object
Function<? super Object, V>	mapper	conversion function

1.6 List

// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

Parameter Description

type	parameter name	describe
Wrapper<T>	queryWrapper	Entity object encapsulation operation class QueryWrapper
Collection<? extends Serializable>	idList	Primary key ID list
Map<String, Object>	columnMap	table field map object
Function<? super Object, V>	mapper	conversion function

There is a Mapper CRUD interface that has not been written. In fact, the usage is almost the same. In addition to different method names, the service interface has exception throwing and transaction annotations. The service interface is generally used to operate the database.

For more Service interface operations, please see the official website .

Comprehensive case

package com.ycxw.mybatis_test;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.github.javafaker.Faker;
import com.ycxw.mybatis_test.entity.Book;
import com.ycxw.mybatis_test.mapper.BookMapper;
import com.ycxw.mybatis_test.service.IBookService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Slf4j
@SpringBootTest
class MybatisTextApplicationTests {
    @Autowired
    private IBookService bookService;
    @Autowired
    private BookMapper bookMapper;

    @Test
    void contextLoads() {
    }

    /**
     * 保存单个
     */
    @Test
    public void test01() {
        /*创建faker实例
        参数：指定使用语言和国家*/
        Faker faker = new Faker(new Locale("zh", "CN"));
        /*
          faker.number().randomDouble(x,x,x)
        * 生成一个介于 100 和 999 之间的随机浮点数，并且保留两位小数。
        * */
        Book book = new Book()
                .setBookname(faker.book().title())
                .setPrice((float) faker.number().randomDouble(2, 100, 999));
        bookService.save(book);
    }

    /**
     * 保存多个
     */
    @Test
    public void test02() {
        /*
         * Stream.generate方法：创建一个无限流，其中每个元素都是使用提供的lambda表达式生成的。
         * 使用lambda表达式创建一个新的Book对象，并用Faker库生成的随机书名和价格对其进行初始化。
         * limit方法：将流限制为只包含前1000个元素。
         * collect方法：将流收集到一个列表中。
         * */
        Faker faker = new Faker(new Locale("zh", "CN"));
        List<Book> list = Stream.generate(
                () -> new Book()
                        .setBookname(faker.book().title())
                        .setPrice((float) faker.number().randomDouble(2, 100, 999))
        ).limit(10).collect(Collectors.toList());
        bookService.saveBatch(list);
    }

    @Test
    public void test03() {
        Faker faker = new Faker(Locale.CHINA);
        List<Book> list = Stream.generate(
                () -> new Book()
                        .setBookname(faker.book().title())
                        .setPrice((float) faker.number().randomDouble(2, 100, 999))
        ).limit(1000).collect(Collectors.toList());
        bookService.saveBatch(list, 500);
    }

    @Test
    public void test04() {
        QueryWrapper<Book> wrapper = new QueryWrapper<>();
        /*条件删除
         * lt小于
         * */
        wrapper.lt("price", 500);
//        wrapper.like("name", "你");
        bookService.remove(wrapper);
    }

    @Test
    public void test05() {
        Map<String, Object> ms = new HashMap<>();
        ms.put("price", 100);
//        ms.put("name", "你");
        bookService.removeByMap(ms);
    }

    @Test
    public void test06() {
        List<Long> ids = bookService
                .list()
                .stream()
                .limit(5)
                .map(Book::getId)
                .collect(Collectors.toList());
        bookService.removeBatchByIds(ids);
    }

    @Test
    public void test07() {
        UpdateWrapper<Book> wrapper = new UpdateWrapper<>();
        wrapper.eq("id", 493587255361727L);
        wrapper.set("name", "jack");
        wrapper.setSql("price=price+1");
        bookService.update(wrapper);
    }

    @Test
    public void test08() {
        Faker faker = new Faker(Locale.CHINA);
        Book Book = new Book()
                .setBookname(faker.book().title())
                .setPrice((float) faker.number().randomDouble(2, 100, 999));
        UpdateWrapper<Book> wrapper = new UpdateWrapper<>();
        wrapper.eq("id", 493587255361723L);
        bookService.update(Book, wrapper);
    }

    @Test
    public void test09() {
        QueryWrapper<Book> wrapper = new QueryWrapper<>();
        wrapper.like("name", "吕");
        wrapper.gt("price", 200);
        bookService.getOne(wrapper);
    }

    @Test
    public void test10() {
        QueryWrapper<Book> wrapper = new QueryWrapper<>();
        /*sql条件加拼接*/
        wrapper.gt("price", 200);
        /*拼接sql到最后*/
        wrapper.last("limit 1");
        bookService.getOne(wrapper);
    }

    @Test
    public void test11() {
        QueryWrapper<Book> wrapper = new QueryWrapper<>();
        wrapper.gt("price", 200);
        bookService.getOne(wrapper, false);
    }

    @Test
    public void test12() {
        QueryWrapper<Book> wrapper = new QueryWrapper<>();
        wrapper.gt("price", 200);
        wrapper.last("limit 1");
        bookService.getMap(wrapper).forEach((k, v) -> {
            log.warn("{},{}", k, v);
        });
    }

    @Test
    public void test13() {
        QueryWrapper<Book> wrapper = new QueryWrapper<>();
        wrapper.gt("price", 200);
        wrapper.last("limit 1");
        bookService.getObj(wrapper, e -> {
            log.warn("{}", e);
            return new Object();
        });
    }

}