MyBatis-Plus基础使用

最新推荐文章于 2023-10-07 14:14:09 发布
最新推荐文章于 2023-10-07 14:14:09 发布
阅读量401 收藏
点赞数
分类专栏： MyBatis-Plus 文章标签： mybatis java mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71212413/article/details/129785272
版权

一、简介

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.初始化工程

3.添加依赖

  • 添加 springboot依赖

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

4.配置

4.1application.yml

  • 数据库信息
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mybatis-plus
    password: 123456
    username: root
    driver-class-name: com.mysql.cj.jdbc.Driver

4.2启动类添加@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 接口

 1.1service 接口

public interface IUserService extends IService<User> {
}

1.2service 实现类

@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.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

  • 常用方法  
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 '值%'
  • like 
@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 = '老李头'")

 

喝咖啡学Java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatisPlusselectById、selectOne、selectBatchIds、selectByMap、selectPage的使用示例代码
04-21
MyBatisPlus通用CRUD中查询方法selectById、selectOne、selectBatchIds、selectByMap、selectPage的使用示例代码
tidb(mysql5.7) springboot mybatis-plus
09-07
java Springboot开发必备环境 ： 推荐1： 统一参数校验，自定义异常提醒，统一日志，统一响应返回，统一异常处理 。...mybatis-plus 采用最新的生成代码工具 推荐3： 将多个基础功能整理后，并用单元测试验证。
深入了解：MyBatisPlus中删除方法deletetById、deleteBatchIds、deleteByMap的使用
牛肉胡辣汤
10-07 5608
在使用MyBatisPlus进行数据库操作时，删除数据是常见且重要的操作。本文介绍了MyBatisPlus中的三种删除方法：​​、​​和​​的使用方法。通过灵活运用这些方法，我们可以方便地实现对数据库中数据的删除操作。希望本文对大家在使用MyBatisPlus进行开发时有所帮助！
Java开发学习(四十七)----MyBatisPlus删除语句之多记录操作
02-09 666
很简单删除掉，但是一个个删除的话还是比较慢和费事的，所以一般会给用户一个批量操作，也就是前面有一个复选框，用户一次可以勾选多个也可以进行全选，然后删一次就可以将购物车清空，这个就需要用到。翻译方法的字面意思为:删除（根据ID 批量删除）,参数是一个集合，可以存放多个id值。除了按照id集合进行批量删除，也可以按照id集合进行批量查询，还是先来看下API。方法名称翻译为:查询（根据ID 批量查询），参数是一个集合，可以存放多个id值。执行成功后，数据库表中的数据就会按照指定的id进行删除。
mybatis传入List参数或者单个String 参数等问题
gaoshan12345678910的博客
07-10 1万+
一：在Userdao里面定义一个方法  public int deleteBatch(List&lt;String&gt;  ids); 在对应的UserDao.xml 错误写法 &lt;delete id="deleteBatch"&gt; DELETE FROM s_user WHERE id in &lt;foreach item="ids" collection="ids" ope...
Java实现多选批量删除,含前后端相关代码
见证自己学习,成长的记录
08-24 1万+
本文介绍如何使用Java实现多选批量删除
【后端结合】新程序猿笔记Day14（京淘项目）
小白猿想成为Simba
12-13 4837
1. MybatisPlus(MP) 1.1 MP介绍 MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 1.2 MP特点 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作强大的 CRUD 操作：内置通用 Mapper、通用 Serv.
Mybatis根据id实现批量删除
qq_44227032的博客
07-27 1212
前端传来的ids为一个数组，使用@RequestParam接收，将数组重命名为ids。@Pram注解的作用是给参数命名，将 ids命名为ids。id 为mapper层定义的批量删除方法，必须一致。
MybatisPlus中删除方法deleteById、deleteBatchIds、deleteByMap的使用
热门推荐
12程序猿的博客
07-14 2万+
MybatisPlus中删除方法deleteById、deleteBatchIds、deleteByMap的使用 场景 项目搭建专栏： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/column/info/37194 基础搭建： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/89407994 实现 deleteById /*** * 通用删除操作 通过ID删除 */ @Test publ
mybatis中多个参数传递的问题
趁年轻不如拼一拼
09-14 337
对于接口中传入参数有以下几种方式: 传递一个参数 接口 //根据用户id查询 Account selectById(Integer aid); 接口xml <!--根据id查询--> <select id="selectById" resultType="Account"> select * from account where aid=#{aid} </select> 测试代码 @Test pub
MyBatisPlus
m0_50315078的博客
07-29 885
mybatisplus
MyBatis-Plus入门+MyBatis-Plus文档手册 中文pdf高清版.rar
11-09
mybatis在持久层框架中还是比较火的，一般项目都是基于ssm。虽然mybatis可以直接在xml中...《MyBatis-Plus入门文档》主要介绍了MyBatis-Plus入门使用，以及关于mybatis-plus的更多介绍及特性，感兴趣的可以下载学习一下
springboot集成mybatis-plus的demo基础搭建
03-03
2，现在是微服务架构为主流的时代，springcloud离不开springboot的基础，掌握在springboot上集成mybatis-plus是一个很重要的技能。 3，本资源中是源码，完整的演示了springboot集成mybatis-plus 的全过程，简单易懂...
MyBatis-Plus入门.pdf
07-08
MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
mybatis-plus基础功能实现
最新发布
12-24
spring boot环境下mybatis-plus基础功能实现，swagger也可以使用。
MyBatis —— parameters元素
tuxq5721
01-07 2081
参数可以指定一个确定的数据类型。什么情况下需要 javaType： 参数对象是一个 HashMap参数值可能为 null 尽管所有这些强大的选项很多时候你只简单指定属性名, MyBatis 会自己计算剩余的。 最多的情况是你为 jdbcType 指定可能为空的列名。   简单示例 简单的参数 select id
Mybatis参数（Parameters）传递
路在何方
06-06 5499
1.单个普通类型（基本类型、包装类型、String）的参数 封装规则：Mybatis不会做特殊的处理 取值 #{随便写，建议与实际的参数名保持一致} 例如： 操作：public Employee getEmployeeById(Integer id ); 取值：#{id} <!-- 关于select 的查询语句 resulType:查询结果对应的类型 id 当前sql语句的唯一标识 #{id}...
MybatisPlus--复杂条件构造类 Wrapper 及在增删查改中的使用
sout
02-25 7086
如果想进行复杂条件查询，那么需要使用条件构造器 Wapper，涉及到如下方法 1、delete 2、selectOne 3、selectCount 4、selectList 5、selectMaps 6、selectObjs 7、update 一、wapper介绍 Wrapper ： 条件构造抽象类，最顶端父类 AbstractWrapper ： 用于查询条件封装...
mybatis-plus实现 相似实体类使用泛型操作同样的逻辑代码更新保存修改的方法
sgambler的博客
07-16 3057
目录场景问题一、Entity准备二、具体泛型写法1. 实现类2.handleUserAssociat - 处理关联关系3.saveOrUpdateBatchUserAsos - 批量保存关联关系（重要）总结 场景 假设有3个类似的实体类，某处需要处理的业务逻辑（增删改）是一样的，业务还比较复杂，如果单独写，则需要写3个大致一样的长代码段，此处想利用泛型解决。 问题 相似的实体类有不同的字段，而泛型不能获取其属性方法，所以有些不好解决，尝试许久，终于可行，示例代码如下。 PS：系统使用了mybatis
mybatis-plus的使用
03-02
Mybatis-Plus 是 Mybatis 的增强工具，在 Mybatis 的基础上简化了开发流程，提高了开发效率。使用 Mybatis-Plus 可以简化 CRUD 操作，还提供了很多实用的功能，比如分页、逻辑删除、自动填充等。 下面是 Mybatis-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值