高考报名时间2022年11月1日还剩 天 距离2023年6月7日高考还有 天
栏目分类:
子分类:
返回
文库吧用户登录
文库吧
快速导航关闭
当前搜索
当前分类
前沿技术 软件开发 系统运维 产品运营 生活办公 面试经验 考试题库
子分类
人工智能 大数据 云计算 区块链 物联网 深度学习 机器学习 NLP 计算机视觉 语音识别 其他 大数据系统 数据可视化 数据挖掘与分析 其他 Docker/k8s 虚拟化 云平台 其他 基本原理 数字货币 智能合约 EOS应用 其他 通讯技术 嵌入式开发 单片机 物联网应用 HarmonyOS 其他 后端开发 Web开发 移动开发 游戏开发 Python Java 架构设计 C/C++/C# PHP .Net Go语言 R语言
实用工具
学习工具 小学数学练习 字帖生成 在线画板 函数绘制 拼音字母表 在线词典 黄历查询 亲戚关系计算 安全期计算 中国历史 Excel函数 模拟请求 json格式化 浏览器指纹
热门搜索
西点培训学校 汽修学校 情书 化妆学校 塔沟武校 异形模板 西南大学排名 最精辟人生短句 6步教你追回被骗的钱 南昌大学排名 清朝十二帝 北京印刷学院排名 北方工业大学排名 北京航空航天大学排名 首都经济贸易大学排名 中国传媒大学排名 首都师范大学排名 中国地质大学(北京)排名 北京信息科技大学排名 中央民族大学排名 北京电影学院排名 中国戏曲学院排名 河北政法职业学院排名 河北经贸大学排名 天津中德应用技术大学排名 天津医学高等专科学校排名 天津美术学院排名 天津音乐学院排名 天津工业大学排名 北京工业大学耿丹学院排名
文库吧 > IT > 软件开发 > 后端开发 > Java

MyBatisPlus-基础CRUD操作

Java 更新时间： 发布时间： IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

MyBatisPlus-基础CRUD操作

MyBatisPlus-基础CRUD操作

官网参考链接：https://baomidou.com/pages/49cc81/#service-crud-%E6%8E%A5%E5%8F%A3

工程项目续用上一篇:MyBatisPlus入门学习：利用MP代码生成器快速开发

结构图：

在application.yml文件加上日志输出可以打印sql语句

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
Mapper CRUD 接口

说明:

  • 通用 CRUD 封装BaseMapper接口，为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器
  • 泛型 T 为任意实体对象
  • 参数 Serializable 为任意类型主键 Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
  • 对象 Wrapper 为 条件构造器
使用：

在MpDemoApplicationTests添加方法

insert 
// 插入一条记录
int insert(T entity);

@Test
void mapperInsert(){
    Singer singer=new Singer();
    singer.setName("陶喆");
    singer.setAge(22);
    singer.setOther("空无一人 这片沙滩~");
    int i = singerMapper.insert(singer);
    System.out.println("i = " + i);
}

注意返回值是int类型，返回的也不是id，返回1代表插入成功

select 
// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper queryWrapper);

// 查询（根据ID 批量查询）
List selectBatchIds(@Param(Constants.COLLECTION) Collection idList);
// 根据 entity 条件，查询全部记录
List selectList(@Param(Constants.WRAPPER) Wrapper queryWrapper);
// 查询（根据 columnMap 条件）
List selectByMap(@Param(Constants.COLUMN_MAP) Map columnMap);
// 根据 Wrapper 条件，查询全部记录
List> selectMaps(@Param(Constants.WRAPPER) Wrapper queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List selectObjs(@Param(Constants.WRAPPER) Wrapper queryWrapper);

// 根据 entity 条件，查询全部记录（并翻页）
IPage selectPage(IPage page, @Param(Constants.WRAPPER) Wrapper queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage> selectMapsPage(IPage page, @Param(Constants.WRAPPER) Wrapper queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper queryWrapper);
 

参数说明：
 

 

测试：
 
SelectByIdAndBatchIds() 

@Test
void mapperSelectByIdAndBatchIds() {
    String id1 = "1556577794717298690";
    String id2 = "1556592930551185410";
    String id3 = "1556593922332053506";

    List ids= new ArrayList<>();
    ids.add(id1);
    ids.add(id2);
    ids.add(id3);

    Singer singer = singerMapper.selectById(id1);
    System.out.println("===================根据单个id查询：n"+singer.toString());

    List singers = singerMapper.selectBatchIds(ids);
    System.out.println("===================根据多个id查询：");
    singers.forEach(System.out::println);
}

 

控制台输出：
 

 
selectOne 

@Test
void mapperSelectOne() {
    QueryWrapper wrapper = new QueryWrapper<>();
    wrapper.eq("age",18);
    Singer singer = singerMapper.selectOne(wrapper);
    System.out.println("singer = " + singer.toString());
}

 

控制台输出：
 

 
selcetList 

@Test
void mapperSelectList() {
    List singers = singerMapper.selectList(null);
    singers.forEach(System.out::println);
}

 

控制台输出：
 

 
selectByMap 

@Test
void mapperSelectByMap() {
    Map map=new HashMap<>();
    map.put("age",18);
    List singers = singerMapper.selectByMap(map);
    singers.forEach(System.out::println);
}

 

控制台输出：
 

 
selectMaps 

@Test
void mapperSelectMaps() {
    List> maps = singerMapper.selectMaps(null);
    maps.forEach(System.out::println);
}

 

控制台输出：
 

 
selectObjs 

注意：此方法只返回第一个字段的值
 

@Test
void mapperSelectObjs() {
    List objects = singerMapper.selectObjs(null);
    objects.forEach(System.out::println);
}
 

控制台输出：
 

 
selectPage 

@Test
void mapperSelectPage() {
    IPage singerIPage = singerMapper.selectPage(new Page<>(1,10), null);
    singerIPage.getRecords().forEach(System.out::println);
}

 

控制台输出：
 

 
selectMapsPage 

@Test
void mapperSelectMapsPage() {
    Page> mapPage = singerMapper.selectMapsPage(new Page<>(1, 10), null);
    mapPage.getRecords().forEach(System.out::println);
}

 

控制台输出：
 

 
selectCount 

@Test
void mapperSelectCount() {
    Long count = singerMapper.selectCount(null);
    System.out.println("count = " + count);
}

 

 
update 

// 根据 whereWrapper 条件，更新记录
int update(@Param(Constants.ENTITY) T updateEntity, @Param(Constants.WRAPPER) Wrapper whereWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

 

@Test
void mapperUpdate() {
    QueryWrapper wrapper = new QueryWrapper<>();
    wrapper.eq("age",17);
    Singer singer = singerMapper.selectOne(wrapper);
    System.out.println("singer.toString() = " + singer.toString());
    singer.setOther("改一下");
    singerMapper.update(singer,wrapper);
    System.out.println("=============================update======================================");
    List singers = singerMapper.selectList(null);
    singers.forEach(System.out::println);
}

@Test
    void mapperUpdateById() {
        QueryWrapper wrapper = new QueryWrapper<>();
        wrapper.eq("age",17);
        Singer singer = singerMapper.selectOne(wrapper);
        System.out.println("singer.toString() = " + singer.toString());
        singer.setOther("改回来");
        singerMapper.updateById(singer);
        System.out.println("=============================update======================================");
        List singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

 

 

 
delete 

 

@Test
void mapperDelete(){
    QueryWrapper wrapper = new QueryWrapper<>();
    wrapper.eq("age",22);
    singerMapper.delete(wrapper);
    System.out.println("=============================delete======================================");
    List singers = singerMapper.selectList(null);
    singers.forEach(System.out::println);
}

    @Test
    void mapperDeleteBatchsIds(){
        ArrayList ids = new ArrayList<>();
        ids.add("1556830638657703938");
        singerMapper.deleteBatchIds(ids);
        System.out.println("=============================delete======================================");
        List singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperDeleteByMap(){
        Map map=new HashMap<>();
        map.put("age",22);
        singerMapper.deleteByMap(map);
        System.out.println("=============================delete======================================");
        List singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

 

 
Service CRUD接口 

 
 
说明:
 
 
  • 通用 Service CRUD 封装IService 接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
  • 泛型 T 为任意实体对象
  • 建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
  • 对象 Wrapper 为 条件构造器
 

 
使用 
Save 

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

 

注意：service的插入返回的是布尔类型
 

 

批次插入
 

 
SaveOrUpdate 

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

 

//TableId 注解存在更新记录，否则插入一条记录
singerService.saveOrUpdate(singer);
singer.setAge(16);
//这里wrapper为null会更新所有数据，慎用。。。我
singerService.saveOrUpdate(singer,null);

 

saveOrUpdate()这里要注意：
 

entity如果没有id会直插入
 

如果有id会先查询数据有就更新没有则执行插入
 
 

如果还传了wrapper要注意null值会导致对所有数据更新
 

 
Remove 

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

 
Update 

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

 

这两和mapper没多大区别，略！
 
Get 

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

 

@Test
void serviceGet(){
    QueryWrapper wrapper=new QueryWrapper();
    Singer byId = singerService.getById("1556883204896604161");
    System.out.println("byId = " + byId);
    wrapper.eq("age",18);
    wrapper.last("LIMIT 1");
    singerService.getOne(wrapper,true);
    Singer one = singerService.getOne(wrapper);
    System.out.println("one = " + one);
}

 

getOne：结果集有多条会报异常
 

 

singerService.getOne(wrapper, false);

 

false则不报异常选择一条数据输出
 

 

或者加上wrapper.last(“LIMIT 1”);
 

 

Map getMap(Wrapper queryWrapper);
 

map多条返回一条数据不报错
 

@Test
void serviceGetMap(){
    QueryWrapper wrapper=new QueryWrapper();
    wrapper.eq("age",18);
    Map map = singerService.getMap(wrapper);
    System.out.println("map = " + map);
}

 

 

// 根据 Wrapper，查询一条记录
  V getObj(Wrapper queryWrapper, Function mapper);
 

这个没弄懂传的什么参数，后面再填坑吧。
 
List 

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

@Test
void list(){
    List list = singerService.list();
    QueryWrapper wrapper=new QueryWrapper();
    wrapper.eq("age",18);
    List list2 = singerService.list(wrapper);
    List> maps = singerService.listMaps();
    maps.forEach(System.out::println);

    List> maps2 = singerService.listMaps(wrapper);
    maps2.forEach(System.out::println);
}

 
Page 

// 无条件分页查询
IPage page(IPage page);
// 条件分页查询
IPage page(IPage page, Wrapper queryWrapper);
// 无条件分页查询
IPage> pageMaps(IPage page);
// 条件分页查询
IPage> pageMaps(IPage page, Wrapper queryWrapper);

 

@Test
void page(){
    Page page = singerService.page(new Page<>(1, 5));
    page.getRecords().forEach(System.out::println);
    Page> mapPage = singerService.pageMaps(new Page<>(1, 5));
    mapPage.getRecords().forEach(System.out::println);
}

 
Count 

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

 
Chain 
query 

// 链式查询 普通
QueryChainWrapper query();
// 链式查询 lambda 式。注意：不支持 Kotlin
LambdaQueryChainWrapper lambdaQuery();

// 示例：
query().eq("column", value).one();
lambdaQuery().eq(Entity::getId, value).list();

 

@Test
void query(){
    Long count = singerService.query().eq("age", 18).count();
    List list = singerService.lambdaQuery().eq(Singer::getName, "周杰伦").list();
    list.forEach(System.out::println);
}

 

 
update 

// 链式更改 普通
UpdateChainWrapper update();
// 链式更改 lambda 式。注意：不支持 Kotlin
LambdaUpdateChainWrapper lambdaUpdate();

// 示例：
update().eq("column", value).remove();
lambdaUpdate().eq(Entity::getId, value).update(entity);

 

@Test
void update(){
    Singer singer = new Singer();
    singer.setName("周杰伦2");
    singer.setAge(18);
    singer.setOther("爱你穿越时间，两行来自秋末的眼泪");
    singerService.update().eq("age", 18).remove();
    singerService.lambdaUpdate().eq(Singer::getName,"周杰伦2").update(singer);
}

 

 

完整代码
 

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.example.mp_demo.entity.Singer;
import com.example.mp_demo.mapper.SingerMapper;
import com.example.mp_demo.service.SingerService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SpringBootTest
class MpDemoApplicationTests {

    @Autowired
    private SingerMapper singerMapper;

    @Autowired
    private SingerService singerService;

    @Test
    void mapperInsert() {
        Singer singer = new Singer();
        singer.setName("陶喆");
        singer.setAge(22);
        singer.setOther("空无一人 这片沙滩~");
        int i = singerMapper.insert(singer);
        System.out.println("i = " + i);
    }

    @Test
    void mapperSelectById() {
        String id1 = "1556577794717298690";
        String id2 = "1556592930551185410";
        String id3 = "1556593922332053506";

        List ids = new ArrayList<>();
        ids.add(id1);
        ids.add(id2);
        ids.add(id3);

        Singer singer = singerMapper.selectById(id1);
        System.out.println("===================根据单个id查询：n" + singer.toString());

        List singers = singerMapper.selectBatchIds(ids);
        System.out.println("===================根据多个id查询：");
        singers.forEach(System.out::println);
    }

    @Test
    void mapperSelectOne() {
        QueryWrapper wrapper = new QueryWrapper<>();
        wrapper.eq("age",18);
        Singer singer = singerMapper.selectOne(wrapper);
        System.out.println("singer = " + singer.toString());
    }

    @Test
    void mapperSelectList() {
        List singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperSelectByMap() {
        Map map=new HashMap<>();
        map.put("age",18);
        List singers = singerMapper.selectByMap(map);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperSelectMaps() {
        List> maps = singerMapper.selectMaps(null);
        maps.forEach(System.out::println);
    }

    @Test
    void mapperSelectObjs() {
        List objects = singerMapper.selectObjs(null);
        objects.forEach(System.out::println);
    }

    @Test
    void mapperSelectPage() {
        IPage singerIPage = singerMapper.selectPage(new Page<>(1,10), null);
        singerIPage.getRecords().forEach(System.out::println);
    }

    @Test
    void mapperSelectMapsPage() {
        Page> mapPage = singerMapper.selectMapsPage(new Page<>(1, 10), null);
        mapPage.getRecords().forEach(System.out::println);
    }

    @Test
    void mapperSelectCount() {
        Long count = singerMapper.selectCount(null);
        System.out.println("count = " + count);
    }

    @Test
    void mapperUpdate() {
        QueryWrapper wrapper = new QueryWrapper<>();
        wrapper.eq("age",17);
        Singer singer = singerMapper.selectOne(wrapper);
        System.out.println("singer.toString() = " + singer.toString());
        singer.setOther("改一下");
        singerMapper.update(singer,wrapper);
        System.out.println("=============================update======================================");
        List singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperUpdateById() {
        QueryWrapper wrapper = new QueryWrapper<>();
        wrapper.eq("age",17);
        Singer singer = singerMapper.selectOne(wrapper);
        System.out.println("singer.toString() = " + singer.toString());
        singer.setOther("改回来");
        singerMapper.updateById(singer);
        System.out.println("=============================update======================================");
        List singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperDelete(){
        QueryWrapper wrapper = new QueryWrapper<>();
        wrapper.eq("age",22);
        singerMapper.delete(wrapper);
        System.out.println("=============================delete======================================");
        List singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperDeleteBatchsIds(){
        ArrayList ids = new ArrayList<>();
        ids.add("1556830638657703938");
        singerMapper.deleteBatchIds(ids);
        System.out.println("=============================delete======================================");
        List singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperDeleteByMap(){
        Map map=new HashMap<>();
        map.put("age",22);
        singerMapper.deleteByMap(map);
        System.out.println("=============================delete======================================");
        List singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void serviceSave() {
        Singer singer = new Singer();
        singer.setName("周杰伦2");
        singer.setAge(18);
        singer.setOther("爱你穿越时间，两行来自秋末的眼泪");
        boolean save = singerService.save(singer);
        System.out.println("save = " + save);
    }

    @Test
    void serviceSaveBatch() {
        Singer singer1 = new Singer();
        singer1.setName("周杰伦7");
        singer1.setAge(18);
        singer1.setOther("不懂你的黑色幽默");

        Singer singer2 = new Singer();
        singer2.setName("周杰伦8");
        singer2.setAge(18);
        singer2.setOther("周杰伦周杰伦周杰伦周杰伦周杰伦，你的完美主义太彻底");

        List singers=new ArrayList<>();
        singers.add(singer1);
        singers.add(singer2);
        boolean save = singerService.saveBatch(singers,1);
        System.out.println("save = " + save);
        List list = singerService.list();
        list.forEach(System.out::println);
    }

    @Test
    void serviceSaveOrUpdate(){
        Singer singer = new Singer();
        singer.setId("214124123");
        singer.setName("周杰伦001");
        singer.setAge(15);
        singer.setOther("爱像一阵风");
        singerService.saveOrUpdate(singer);
        singer.setAge(16);
       // singerService.saveOrUpdate(singer,null);
    }

    @Test
    void serviceSaveOrUpdateBatch(){

        Singer singer = new Singer();
        singer.setName("周杰伦2");
        singer.setAge(18);
        singer.setOther("爱你穿越时间，两行来自秋末的眼泪");

        Singer singer3 = new Singer();
        singer3.setName("周杰伦7");
        singer3.setAge(18);
        singer3.setOther("不懂你的黑色幽默");

        Singer singer2 = new Singer();
        singer2.setName("周杰伦8");
        singer2.setAge(18);
        singer2.setOther("周杰伦周杰伦周杰伦周杰伦周杰伦，你的完美主义太彻底");

        Singer singer4 = new Singer();
        singer4.setName("周杰伦9");
        singer4.setAge(16);
        singer4.setOther("我的城堡说欢迎光临");

        List list=new ArrayList();
        list.add(singer);
        list.add(singer2);
        list.add(singer3);
        list.add(singer4);
        singerService.saveOrUpdateBatch(list);
    }

    @Test
    void serviceGet(){
        QueryWrapper wrapper=new QueryWrapper();
        Singer byId = singerService.getById("1556883204896604161");
        System.out.println("byId = " + byId);
        wrapper.eq("age",18);
        wrapper.last("LIMIT 1");
        singerService.getOne(wrapper,true);
        Singer one = singerService.getOne(wrapper);
        System.out.println("one = " + one);
    }

    @Test
    void serviceGetMap(){
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("age",18);
        Map map = singerService.getMap(wrapper);
        System.out.println("map = " + map);
    }

    @Test
    void list(){
        List list = singerService.list();
        QueryWrapper wrapper=new QueryWrapper();
        wrapper.eq("age",18);
        List list2 = singerService.list(wrapper);
        List> maps = singerService.listMaps();
        maps.forEach(System.out::println);

        List> maps2 = singerService.listMaps(wrapper);
        maps2.forEach(System.out::println);
    }

    @Test
    void page(){
        Page page = singerService.page(new Page<>(1, 5));
        page.getRecords().forEach(System.out::println);
        Page> mapPage = singerService.pageMaps(new Page<>(1, 5));
        mapPage.getRecords().forEach(System.out::println);
    }

    @Test
    void query(){
        Long count = singerService.query().eq("age", 18).count();
        List list = singerService.lambdaQuery().eq(Singer::getName, "周杰伦").list();
        list.forEach(System.out::println);
    }

    @Test
    void update(){
        Singer singer = new Singer();
        singer.setName("周杰伦2");
        singer.setAge(18);
        singer.setOther("爱你穿越时间，两行来自秋末的眼泪");
        singerService.update().eq("age", 18).remove();
        singerService.lambdaUpdate().eq(Singer::getName,"周杰伦2").update(singer);
    }
}







转载请注明：文章转载自 www.wk8.com.cn















Java相关栏目本月热门文章

















学习工具


代数计算器


三角函数


解析几何


立体几何






知识解答


教育知识


百科知识


生活知识


常识知识






写作必备


作文大全


作文素材


句子大全



实用范文






关于我们


关于我们


联系我们


网站地图






 交流群

文库吧交流群




文库吧客服

文库吧客服












文库吧 版权所有 (c)2021-2022      ICP备案号：晋ICP备2021003244-6号
 








我们一直用心在做

关于我们
文章归档
网站地图
联系我们

版权所有 (c)2021-2022 wk8.com.cn


ICP备案号：晋ICP备2021003244-6号