Mybatis_plus-基础

已于 2024-03-03 17:32:11 修改
阅读量873 收藏 16
点赞数 18
分类专栏： Mybatis Java 文章标签： mybatis java
于 2024-03-03 17:12:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/byron__/article/details/136434159
版权

一、简介

1.概述

2.特性

  • 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
  • 损耗小：启动即会自动注入基本 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.架构

在这里插入图片描述

二、快速入门

1.创建数据库以及表

  • 创建 mybatis-plus 数据库

  • 创建user表

    DROP TABLE IF EXISTS user;

CREATE TABLE user
(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT(11) NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
);

  • 添加用户信息

    DELETE FROM user;

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

2.初始化工程

  • 创建空项目

  • 创建springboot 模块

    在这里插入图片描述

3.添加依赖

  • 添加 springboot依赖

    <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.5</version>
</parent>

  • 引入 spring-boot-starter、spring-boot-starter-test、mybatis-plus-boot-starter、mysql 依赖

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

4.配置

4.1添加springboot启动类

  • 启动类

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

4.2application.yml

  • 数据库信息

    spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mybatis-plus
    password: 123456
    username: root
    driver-class-name: com.mysql.cj.jdbc.Driver

4.3启动类添加@MapperScan

  • 作用：用于扫描 Mapper 文件夹

    @SpringBootApplication
@MapperScan("cn.sycoder.mapper")
public class MybatisPlusApplication {
    public static void main(String[] args) {
        SpringApplication.run(MybatisPlusApplication.class,args);
    }
}

5.编码实现

5.1创建实体类

  • 实体类user

    @Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

5.2编写mapper

  • mapper文件

    public interface UserMapper extends BaseMapper<User> {
}

6.测试

  • 新建测试类

    @SpringBootTest
public class MybatisPlusTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelect() {
        System.out.println(("----- selectAll method test ------"));
        List<User> userList = userMapper.selectList(null);
        userList.forEach(System.out::println);
    }
}

  • 结果

    在这里插入图片描述

三、Mapper CRUD接口

  • 根据userMapper 可以知道，我们使用的方法是BaseMapper 中定义好的，才提高了开发效率。

    在这里插入图片描述

1.添加

1.1方法

  • insert 方法

    int insert(T entity);

1.2测试

  • 测试

    @Test
    public void testInsert(){
        User entity = User.builder().name("sy").age(18).email("sycoder@it.cn").build();
        int count = userMapper.insert(entity);//受影响结果集
        Long id = entity.getId();
        System.out.println("受影响结果数--->"+count);
        System.out.println("id--->"+id);
    }

  • 问题

    • 自增主键值太大了，不符合我们mysql自增的逻辑

      在这里插入图片描述

1.3使用MybatisPlus 支持id策略

  • IdType

    public enum IdType {
    AUTO(0),//数据库自增id
    NONE(1),//没有主键
    INPUT(2),//用户输入id
    ASSIGN_ID(3),//
    ASSIGN_UUID(4);//时间戳，或者叫随机字符串

    private final int key;

    private IdType(int key) {
        this.key = key;
    }

    public int getKey() {
        return this.key;
    }
}

1.4@TableId

  • @TableId修改User 类实体

    @Data
@Builder
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

1.5@TableField

  • @TableField 修改字段名称

    @Data
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    @TableField(select = false)
    private Integer age;
    @TableField(value = "uemail")
    private String email;
}

    在这里插入图片描述

  • 注意：提供无参构造器

2.删除

2.1根据主键删除

  • deleteById方法:根据主键id删除

    int deleteById(Serializable id);
int deleteById(T entity);//传一个对象进来

  • 测试

    @Test
public void testDeleteById(){
    int count = userMapper.deleteById(2L);
    System.out.println("受影响结果数--->"+count);
}

  • 结果

    ==>  Preparing: DELETE FROM user WHERE id=?
==> Parameters: 3(Long)
<==    Updates: 1

2.2根据列删除通过Map方式

  • deleteByMap：根据列删除

  • 方法

    int deleteByMap(@Param("cm") Map<String, Object> columnMap);

  • 测试

    @Test
    public void testDeleteByMap(){
        Map<String,Object> map = new HashMap<>();
        map.put("name","sy");
        int count = userMapper.deleteByMap(map);
        System.out.println("受影响结果数--->"+count);
    }

  • 注意：如果map 中没有列信息，是删除整表

  • 结果

    ==>  Preparing: DELETE FROM user WHERE name = ?
==> Parameters: sy(String)
<==    Updates: 1

2.2根据列删除通过包装方式

  • delete:根据 entity 对象的条件进行删除

  • 方法

    int delete(@Param("ew") Wrapper<T> queryWrapper);

  • 测试

    @Test
public void testDelete(){
    User user = new User();
    user.setName("sy");
    Wrapper wrapper = new QueryWrapper(user);
    int count = userMapper.delete(wrapper);
    System.out.println("受影响结果数--->"+count);
}

  • 结果

    ==>  Preparing: DELETE FROM user WHERE name=?
==> Parameters: sy(String)
<==    Updates: 1

2.3批量删除

  • deleteBatchIds：通过ids 集合实现批量删除

  • 方法

    int deleteBatchIds(@Param("coll") Collection<?> idList);

  • 测试

    @Test
    public void testDeleteBatchIds(){
        List list = new ArrayList<>();
        list.add(1L);
        list.add(3L);
        int count = userMapper.deleteBatchIds(list);
        System.out.println("受影响结果数--->"+count);
    }

  • 结果

    ==>  Preparing: DELETE FROM user WHERE id IN ( ? , ? )
==> Parameters: 1(Long), 3(Long)
<==    Updates: 2

3.修改

3.1根据id更新

  • updateById：根据id更新

  • 方法

    int updateById(@Param("et") T entity);

  • 测试

    @Test
public void testUpdateById(){
    User user = new User();
    user.setId(3L);
    user.setName("zs");
    user.setEmail("sy@qq.com");
    int count = userMapper.updateById(user);
    System.out.println("受影响结果数--->"+count);
}

  • 结果

    ==>  Preparing: UPDATE user SET name=?, uemail=? WHERE id=?
==> Parameters: zs(String), sy@qq.com(String), 3(Long)
<==    Updates: 1

3.2根据条件更新

  • 方法

    int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);

  • 测试

    @Test
public void testUpdate(){
    User user = new User();
    user.setAge(100);//设置需要更新的字段

    //设置需要更新的条件
    UpdateWrapper<User> wrapper = new UpdateWrapper<>();
    wrapper.eq("name","zs");

     int count = userMapper.update(user,wrapper);
    System.out.println("受影响结果数--->"+count);
}

    @Test
public void testUpdate2() {
    //设置需要更新的条件
    UpdateWrapper<User> wrapper = new UpdateWrapper<>();
    wrapper.eq("name", "zs");
    wrapper.set("age",5);

    int count = userMapper.update(null, wrapper);
    System.out.println("受影响结果数--->" + count);
}

  • 结果

    ==>  Preparing: UPDATE user SET age=? WHERE (name = ?)
==> Parameters: 100(Integer), zs(String)
<==    Updates: 1

4.查询

4.1selectById

  • selectById:通过主键id 查询

  • 方法

    T selectById(Serializable id);

  • 测试

    @Test
public void testSelectById(){
    User user = userMapper.selectById(1L);
    System.out.println(user);
}

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user WHERE id=?
==> Parameters: 1(Long)
<==      Total: 1

4.2selectBatchIds

  • selectBatchIds：通过批量的id 查询

  • 方法

    List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);

  • 测试

    @Test
public void testSelectBatchIds(){
    List<Long> ids = new ArrayList<>();
    ids.add(1L);
    ids.add(3L);

    List<User> users = userMapper.selectBatchIds(ids);
    System.out.println(users);
}

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user WHERE id IN ( ? , ? )
==> Parameters: 1(Long), 3(Long)
<==      Total: 2

4.3selectOne

  • selectOne:查询单条信息

  • 方法

    default T selectOne(@Param("ew") Wrapper<T> queryWrapper) {
    List<T> ts = this.selectList(queryWrapper);
    if (CollectionUtils.isNotEmpty(ts)) {
        if (ts.size() != 1) {
            throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records", new Object[0]);
        } else {
            return ts.get(0);
        }
    } else {
        return null;
    }
}

  • 测试

    @Test
public void testSelectOne(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("name","sy");
    User user = userMapper.selectOne(wrapper);
    System.out.println(user);
}

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user WHERE (name = ?)
==> Parameters: sy(String)
<==      Total: 1

4.4selectCount

  • selectCount：表示总记录数

  • 方法

    Long selectCount(@Param("ew") Wrapper<T> queryWrapper);

  • 测试

    @Test
public void testSelectCount(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("name","sy");
    Long count = userMapper.selectCount(wrapper);
    System.out.println(count);
}

  • 结果

    ==>  Preparing: SELECT COUNT( * ) FROM user WHERE (name = ?)
==> Parameters: sy(String)
<==      Total: 1

4.5selectList

  • selectList:查询全部记录

  • 方法

    List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);

  • 测试

    @Test
public void testSelectList(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("name","sy");
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);
}

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user WHERE (name = ?)
==> Parameters: sy(String)
<==      Total: 1

4.6selectPage

  • selectPage:查询出分页结果

  • 方法

    <P extends IPage<T>> P selectPage(P page, @Param("ew") Wrapper<T> queryWrapper);

  • 配置分页插件

    @Configuration
@MapperScan("cn.sycoder.mapper")
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

}

  • 测试

    @Test
public void testSelectPage(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("name","sy");
    Page<User> page = new Page<>(1,1);
    IPage<User> userPage = userMapper.selectPage(page, wrapper);
    System.out.println("总条数为："+userPage.getTotal());
    System.out.println("总页数为："+userPage.getPages());
    List<User> records = userPage.getRecords();
    System.out.println(records);
}

  • 结果

     ==>  Preparing: SELECT COUNT(*) AS total FROM user WHERE (name = ?)
 ==> Parameters: sy(String)
 <==      Total: 1
 ==>  Preparing: SELECT id,name,uemail AS email FROM user WHERE (name = ?) LIMIT ?
 ==> Parameters: sy(String), 1(Long)
 <==      Total: 1

四、Service CRUD接口

说明：

通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，

泛型 T 为任意实体对象

建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类

对象 Wrapper 为 条件构造器

1.提供Service 接口

  • service 接口

    public interface IUserService extends IService<User> {
}

  • service 实现类

    @Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
}

2.api使用

2.1保存

  • save 方法

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

  • 测试

    @Autowired
IUserService service;

@Test
public void testServiceSave(){
    User user = new User();
    user.setName("service 创建");
    user.setAge(18);
    user.setEmail("xxx");
    boolean save = service.save(user);
    System.out.println("保存结果："+save);
}

  • 结果

    ==>  Preparing: INSERT INTO user ( name, age, uemail ) VALUES ( ?, ?, ? )
==> Parameters: service 创建(String), 18(Integer), xxx(String)
<==    Updates: 1

2.2保存或者更新

  • 方法

    // 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);

  • 测试

    @Test
public void testServiceSaveOrUpdate(){
    User user = new User();
    user.setId(6L);
    user.setName("ser1231233vice 创建");
    user.setAge(18);
    user.setEmail("xxx");
    boolean save = service.saveOrUpdate(user);
    System.out.println("保存更新结果："+save);
}

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user WHERE id=?
==> Parameters: 6(Long)
<==      Total: 1
==>  Preparing: UPDATE user SET name=?, age=?, uemail=? WHERE id=?
==> Parameters: ser1231233vice 创建(String), 18(Integer), xxx(String), 6(Long)
<==    Updates: 1

2.3删除

  • 删除方法

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

  • 测试

    @Test
public void testServiceDelete(){
    boolean ret = service.removeById(6L);
    System.out.println("删除的结果："+ret);
}

  • 结果

    ==>  Preparing: DELETE FROM user WHERE id=?
==> Parameters: 6(Long)
<==    Updates: 1

2.4更新

  • 更新方法

    // 根据 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);

  • 测试

    @Test
public void testServiceUpdate(){
    User user = new User();
    user.setId(6L);
    user.setName("ser1231233vice 创建");
    user.setAge(18);
    user.setEmail("xxx");
    boolean ret = service.updateById(user);
    System.out.println("更新结果："+ret);
}

  • 结果

    ==>  Preparing: UPDATE user SET name=?, age=?, uemail=? WHERE id=?
==> Parameters: ser1231233vice 创建(String), 18(Integer), xxx(String), 6(Long)
<==    Updates: 0

2.5查询

  • 查询方法

    // 根据 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);

  • 测试

    @Test
public void testServiceGet(){
    User user = service.getById(7L);
    System.out.println(user);
}

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user WHERE id=?
==> Parameters: 7(Long)
<==      Total: 1

2.6查询多结果集

  • 查询多条数据

    // 查询所有
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);

  • 测试

    @Test
public void testServiceList(){
    List<User> list = service.list();
    System.out.println(list);
}

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user
==> Parameters: 
<==      Total: 5

2.7分页查询

  • 分页方法

    // 无条件分页查询
IPage<T> page(IPage<T> page);
// 条件分页查询
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
// 无条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page);
// 条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);

2.8查询数量

  • 查询数量方法

    // 查询总记录数
int count();
// 根据 Wrapper 条件，查询总记录数
int count(Wrapper<T> queryWrapper);

五、条件构造器

1.allEq

  • AbstractWrapper

    在这里插入图片描述

  • 常用方法

    allEq(Map<R, V> params)
allEq(Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, Map<R, V> params, boolean null2IsNull)

  • 测试

    @Test
    public void testAllEq(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        Map<String,Object> parms = new HashMap();
        parms.put("name","sy");
        parms.put("age",18);
        wrapper.allEq(parms);
        List<User> users = userMapper.selectList(wrapper);
        System.out.println(users);
    }

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user WHERE (name = ? AND age = ?)
==> Parameters: sy(String), 18(Integer)
<==      Total: 1

  • 带过滤的常用方法

    allEq(BiPredicate<R, V> filter, Map<R, V> params)
allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)

  • 测试

     @Test
    public void testAllEq(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        Map<String,Object> parms = new HashMap();
        parms.put("name","sy");
        parms.put("age",18);
        parms.put("uemail",null);
        //SELECT id,name,uemail AS email FROM user WHERE (name = ?)
        wrapper.allEq((k,v)->("name".equals(k)),parms);
        List<User> users = userMapper.selectList(wrapper);
        System.out.println(users);
    }

2.比较操作

  • 比较符

    比较符说明符号
    eq等于=
    ne不等于!= <>
    gt大于>
    ge大于等于>=
    lt小于<
    le小于等于<=
    between包含BETWEEN 值1 AND 值2
    notBetween不包含NOT BETWEEN 值1 AND 值2
    in包含字段 IN (value.get(0), value.get(1), …)
    notIn不包含字段 NOT IN (value.get(0), value.get(1), …)

  • 测试

    @Test
    public void testBasicSwap(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name","sy").ge("age",18)
                .in("uemail","xxx");
        List<User> users = userMapper.selectList(wrapper);
        System.out.println(users);
    }

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user WHERE (name = ? AND age >= ? AND uemail IN (?))
==> Parameters: sy(String), 18(Integer), xxx(String)
<==      Total: 1

3.模糊查询

  • 模糊查询

    方法说明
    likeLIKE ‘%值%’
    notLikeNOT LIKE ‘%值%’
    likeLeftLIKE ‘%值’
    likeRightLIKE ‘值%’

  • 测试

    @Test
    public void testLike(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.like("name","s");
        List<User> users = userMapper.selectList(wrapper);
        System.out.println(users);
    }

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user WHERE (name LIKE ?)
==> Parameters: %s%(String)
<==      Total: 5

  • likeLeft

    @Test
public void testLike(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.likeLeft("name","y");//%y
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);
}

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user WHERE (name LIKE ?)
==> Parameters: %y(String)
<==      Total: 4

4.排序操作

  • 排序分组操作

    方法说明
    groupBy分组：GROUP BY 字段, …
    orderByAsc排序：ORDER BY 字段, … ASC
    orderByDesc排序：ORDER BY 字段, … DESC
    orderBy排序：ORDER BY 字段, …

  • 测试分组

    @Test
public void testGroupBy(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.groupBy("name");
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);
}

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user GROUP BY name
==> Parameters: 
<==      Total: 2

  • 测试排序

    @Test
public void testOrder(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.orderBy(true,false,"id");
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);
}

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user ORDER BY id DESC
==> Parameters: 
<==      Total: 5

5.逻辑查询

  • 逻辑查询

    方法说明
    or例: eq("id",1).or().eq("name","老王")—>id = 1 or name = '老王'
    and例: and(i -> i.eq("name", "李白").ne("status", "活着"))—>and (name = '李白' and status <> '活着')

  • or 方法

    注意事项:

    主动调用or表示紧接着下一个方法不是用and连接!(不调用or则默认为使用and连接)

  • 测试方法

    @Test
public void testOr(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("name","sy").or().eq("age",18);
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);
}

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user WHERE (name = ? OR age = ?)
==> Parameters: sy(String), 18(Integer)
<==      Total: 4

  • and 方法测试

    @Test
public void testAnd(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("name","sy").and(i -> i.ne("age", 18)
            .or().ne("age",1));
    //select * from user where name = sy and (age != 18  or age != 1)
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);

}

  • 结果

    ==>  Preparing: SELECT id,name,uemail AS email FROM user WHERE (name = ? AND (age <> ? OR age <> ?))
==> Parameters: sy(String), 18(Integer), 1(Integer)
<==      Total: 4

6.select

  • select 方法

    例子 select(“id”, “name”, “age”)：具体需要查询的列

  • 方法测试

    @Test
public void testSelect(){
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.select("id");
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);

}

  • 结果

    ==>  Preparing: SELECT id FROM user
==> Parameters: 
<==      Total: 5

7.UpdateWrapper

  • 更新 wrapper

    说明:

    继承自 AbstractWrapper ,自身的内部属性 entity 也用于生成 where 条件
    及 LambdaUpdateWrapper, 可以通过 new UpdateWrapper().lambda() 方法获取!

  • set

    SQL SET 字段
例: set("name", "老李头")
例: set("name", "")--->数据库字段值变为空字符串
例: set("name", null)--->数据库字段值变为null

  • setSql

    设置 SET 部分 SQL
例: setSql("name = '老李头'")
Byron丶
关注
  • 18
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【MyBatis】 MyBatis与MyBatis-Plus的区别
四季轮换叶，一路招摇胜
09-12 5万+
mybatis-plus 是 mybatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
Mybatis-Plus-【通俗易懂全讲解】
热门推荐
qq_55293923的博客
04-26 4万+
Mybatis-Plus 配置日志 我们所有的sql现在是不可见的，我们希望知道它是怎么执行的，所以我们必须要看日志！ # 配置日志 mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl 配置完毕日志之后，后面的学习就需要注意这个自动生成的SQL，你们就会喜欢上Mybatis-Plus！ CRUD扩展 插入操作 insert插入 @Test//测试插入 public void t
Mybatis-Plus开发提速器mybatis-plus-generator-ui
夜郎King的博客
11-28 2万+
​本文简要介绍一款基于Mybatis-Plus的代码自助生成器，地址:mybatis-plus-generator-ui。文章通过实例集成的方式来详细讲解mybatis-plus-generator-ui，从相关概念到实际集成案例，以及具体的扩展开发介绍。
mybatis-plus 使用 mybatis-plus-join 增强多表关联查询能力
小毕超博客
10-31 3164
`mybatis-plus` 原生的能力不支持多表关联，对于这种场景只能通过写`SQL`进行实现，而`mybatis-plus-join` 则是建立在 `mybatis-plus` 基础之上的扩展框架，可以在不影响原有能力之上通过简单的`API`即可实现多表关联能力而无需编写`SQL`。
mybatis-plus-join mybatis-plus必备神器
博博的博客
07-20 3万+
mybatis-plus-join是mybatis plus的一个多表插件，上手简单，十分钟不到就能学会全部使用方式，只要会用mp就会用这个插件，仅仅依赖了lombok，而且是扩展mp的构造器并非更改原本的构造器，不会对原有项目产生一点点影响，相信大多数项目都有这俩插件，四舍五入就是没依赖。 ......
MyBatis-Plus-Join联表查询
weixin —> Ryan-0713
12-18 904
你还在写sql语句吗？赶快用起来，效率翻倍。
springboot+MyBatis-Plus-Join整合增强mybatis
qq_41889337的博客
01-04 841
springboot+MyBatis-Plus-Join整合增强mybatis
Mybatis-plus做连接查询的插件Mybatis-plus-join
m0_67400973的博客
08-22 2988
对Mybatis-plus进行功能升级，提高开发效率；使用方法与Mybatis-plus一样，学习成本低；增加了多表连接查询功能，摆脱xml模式多表连接；…
Mybatis-Plus 开发提速器：mybatis-plus-generator-ui 你确定不了解一下？
Java精选
02-21 989
前言在基于Mybatis的开发模式中，很多开发者还会选择Mybatis-Plus来辅助功能开发，以此提高开发的效率。虽然Mybatis也有代码生成的工具，但Mybatis-Plus由于在Mybatis基础上做了一些调整，因此，常规的生成工具生成的代码还有一些不太符合预期。而且对于多数据库的支持不是很好。因此，我们需要一款支持高度定制化，带图形UI页面，能适配多数数据库的基础程序生成框架。本文就介绍...
MyBatisPlus mybatis-plus-join
hudeyong926的专栏
02-03 1万+
一、MyBatis Plus 介绍 MyBatis Plus是国内人员开发的 MyBatis 增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 MyBatis Plus 的核心功能有：支持通用的 CRUD、代码生成器与条件构造器。 通用 CRUD：定义好 Mapper 接口后，只需要继承BaseMapper<T>接口即可获得通用的增删改查功能，无需编写任何接口方法与配置文件 条件构造器：通过EntityWrapper<T>（实体包装.....
mybatis-plus-generator.rar
12-26
- 本项目基于原生MyBatis-Plus-Generator，在官方代码生成工具的基础上，进行优化，主要特性有： 1. 支持多表及全表生成，无需在控制台输入表名； 2. 集成Lombok，无需生成setXXX和getXXX方法； 3. 集成API文档...
mybatis-plus-3.5.3.jar
04-11
mybatis-Plus.jar 各个版本...Mybatis-Plus是一个Mybatis的增强工具，只是在Mybatis的基础上做了增强却不做改变，MyBatis-Plus支持所有Mybatis原生的特性，所以引入Mybatis-Plus不会对现有的Mybatis构架产生任何影响。
mybatis-plus-3.4.0.jar
04-11
mybatis-Plus.jar 各个版本...Mybatis-Plus是一个Mybatis的增强工具，只是在Mybatis的基础上做了增强却不做改变，MyBatis-Plus支持所有Mybatis原生的特性，所以引入Mybatis-Plus不会对现有的Mybatis构架产生任何影响。
mybatis-plus-3.5.0.jar
04-11
mybatis-Plus.jar 各个版本...Mybatis-Plus是一个Mybatis的增强工具，只是在Mybatis的基础上做了增强却不做改变，MyBatis-Plus支持所有Mybatis原生的特性，所以引入Mybatis-Plus不会对现有的Mybatis构架产生任何影响。
简单的项目部署脚本（转载）
u010230019的博客
06-09 592
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1209
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 397
修改菜品——后端Java
java.lang.reflect.Type是什么
最新发布
yuchangyuan5237的博客
06-12 367
通过 java.lang.reflect.Type 接口及其实现，Java 提供了一个强大的机制，用于在运行时检查和操作类型信息。这在编写通用库、框架和工具时特别有用，因为它允许你处理泛型类型和其他复杂类型结构。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 370
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
mybatis-plus-boot-starter和mybatis-plus-generator
03-01
mybatis-plus-boot-starter是MyBatis-Plus框架的一个启动器，它简化了MyBatis-Plus的配置和集成过程。通过引入mybatis-plus-boot-starter依赖，我们可以快速地集成MyBatis-Plus框架，并且可以使用MyBatis-Plus提供的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值