源码地址：https://github.com/GuiZhouAndroid/mybatisDemo

（Mybatis笔记）Mybatis-Plus——封装接口IService使用（二）
CSDN链接：https://blog.csdn.net/qq_39038178/article/details/120668991

***MySQL用户表***

drop table if exists t_user_login;

/*==============================================================*/
/* Table: t_user_login                                          */
/*==============================================================*/
create table t_user_login
(
   ul_id                int not null auto_increment comment '登录自增ID',
   ul_username          varchar(255) not null comment '登录名',
   ul_password          varchar(255) not null comment '登录密码',
   primary key (ul_id),
   unique key AK_Key_2 (ul_userName)
);
alter table t_user_login comment '用户登录表';

insert into t_user_login (ul_userName,ul_password) values ('admin','admin');
insert into t_user_login (ul_userName,ul_password) values ('root','root');

1.前言

上一章，介绍了mybatis-plus 3.4.3.4 + mybatis-plus-generator 3.5.1的配置和以及基本功能测试，自带的CRUD接口、映射xml文件也可以调用mysql数据。

本章介绍，Mybatis-Plus封装的CRUD接口——IService，如何对mysql数据库表进行增伤改查的操作，以及一些相关实现。高效率开发！！！

2.插入数据（save+saveOrUpdate）

在用户实体类UserLoginBean.java中，添加构造函数，方便测试CRUD接口功能。

    /**
     * 有参构造初始化用户对象数据
     * @param ulUsername 用户名
     * @param ulPassword 密码
     */
    public UserLoginBean(String ulUsername, String ulPassword) {
        this.ulUsername = ulUsername;
        this.ulPassword = ulPassword;
    }

（1）添加一条用户数据，新增接口如下：

    /** 添加一条用户数据 */
    //浏览器访问 http://localhost:8085/user-login-bean/addOnceUserInfo
    @RequestMapping("/addOnceUserInfo")
    public boolean addOnceUserInfo(){
        //返回布尔类型
        return userLoginService.save(new UserLoginBean("添加的用户名","添加的密码"));
    }

浏览器访问接口后：

（2）批量添加用户数据，新增接口如下：

    /** 批量添加用户数据 */
    //浏览器访问 http://localhost:8085/user-login-bean/addBatchUserInfo
    @RequestMapping("/addBatchUserInfo")
    public boolean addBatchUserInfo(){
        //多态机制创建一个List集合，创建两个用户对象数据，调用add()把用户对象数据，依次添加到List集合中
        List<UserLoginBean> userList = new ArrayList<>();
        userList.add(new UserLoginBean("list用户名3","list密码3"));
        userList.add(new UserLoginBean("list用户名4","list密码4"));
        //saveBatch()是mybatis-plus封装好的，批量添加数据使用，接收集合对象
        //返回boolean类型，true为批量添加成功，反之false批量添加失败
        return userLoginService.saveBatch(userList);
    }

浏览器访问接口后：

（3）更新+添加用户信息，新增接口如下：

    /** 注解TableId()——更新+添加用户信息 */
    //浏览器访问 http://localhost:8085/user-login-bean/addSaveOrUpdateUserInfo/qe用户名/qe密码
    @RequestMapping("/addSaveOrUpdateUserInfo/{username}/{password}")
    //username 和 password 的值，从URL中获取
    public boolean addSaveOrUpdateUserInfo(@PathVariable("username") String username,@PathVariable("password") String password){
        //创建更新条件构造器对象
        UpdateWrapper<UserLoginBean> updateWrapper = new UpdateWrapper<>();
        //eq 等于："ul_userName"（用户名）为"admin"的用户信息存在就更新记录为"qe用户名"，不存在就添加一条用户名记录"admin"
        //eq 等于："ul_password"（密码）为"admin"的用户信息存在就更新记录"qe密码"，不存在就添加一条密码记录"admin"
        updateWrapper.eq("ul_username","admin");
        updateWrapper.eq("ul_password","admin");
        //saveOrUpdate()是mybatis-plus封装好的，需要实体类自增ID使用 注解@TableId()，
        //第一个参数是：实体对象数据，第二个参数是：更新条件构造器对象，返回布尔类型
        return userLoginService.saveOrUpdate(new UserLoginBean("操作后"+username,"操作后"+password),updateWrapper);
    }

说明：saveOrUpdate() 先执行更新，不满足更新条件，再执行添加。
详细：当前用户表中存在了用户名"admin"和密码"admin"，如果访问此接口，那么首先会判断指定的qe(k,v)的用户名和密码是否已存在。
——已存在时：获取URL的新用户名值和新密码值，执行UPDATE更新操作。
——不存在时：获取URL的新用户名值和新密码值，执行INSERT添加操作。

调用接口前MySQL用户表数据：

浏览器访问接口后：

调用接口后MySQL用户表数据：因为用户名admin+密码admin存在，就更新

接下来，演示INSERT增加

浏览器访问接口后：

调用接口后MySQL用户表数据：增加一条用户数据

在实体类中增加构造方法，如下：

    /**
     * @param ulId 自增ID
     * @param ulUsername 用户名
     * @param ulPassword 密码
     */
    public UserLoginBean(Integer ulId, String ulUsername, String ulPassword) {
        this.ulId = ulId;
        this.ulUsername = ulUsername;
        this.ulPassword = ulPassword;
    }

（4）通过实体对象ID值，批量更新或添加用户信息，新增接口如下：

    /** 通过实体对象ID值，批量更新或添加用户信息,为更好演示批量操作，示例：更新2条，添加2条 */
    //浏览器访问 http://localhost:8085/user-login-bean/addSaveOrUpdateBatchUserInfo
    @RequestMapping("/addSaveOrUpdateBatchUserInfo")
    public boolean addSaveOrUpdateBatchUserInfo(){
        //创建List集合，装载批量数据
        List<UserLoginBean> userList = new ArrayList<>();
        /** 已存在更新情况2条 */
        // id = 1 对应用户信息——用户名："操作后qe用户名"  密码："操作后qe密码"（这条ID为1的用户数据是已经存在的，存在即执行更新）
        userList.add(new UserLoginBean(1,"1更新后qe用户名","1更新后qe密码"));
        // id = 1 对应用户信息——用户名："root"  密码："root"（这条ID为2的用户数据是已经存在的，存在即执行更新）
        userList.add(new UserLoginBean(2,"2更新后root","2更新后qe密码"));
        /** 不存在添加情况2条 */
        // id = 50 对应用户信息——用户名：无  密码：无（这条ID为50的用户数据不存在——添加数据）
        userList.add(new UserLoginBean(50,"50添加用户名","50添加密码"));
        // id = 100 对应用户信息——用户名：无  密码：无（这条ID为100的用户数据不存在——添加数据）
        userList.add(new UserLoginBean(100,"100添加用户名","100添加密码"));
        //返回布尔类型的执行结果
        return userLoginService.saveOrUpdateBatch(userList);
    }

浏览器访问接口后：

调用接口后MySQL用户表数据前后对比：

3.删除数据（remove）

（1）通过ID删除用户信息，新增接口如下：

    /** 通过主键ID值，删除用户信息 */
    //浏览器访问 http://localhost:8085/user-login-bean/deleteUserInfoById
    @RequestMapping("/deleteUserInfoById")
    public Boolean deleteUserInfoById(){
        //removeById()是mybatis-plus封装好的，通过主键ID值，删除ID值为100的用户信息，返回布尔类型
        return userLoginService.removeById(100);
    }

    /** 通过实体对象ID值，删除用户信息，此方式演示与上面效果相似，省略演示 */
    //浏览器访问 http://localhost:8085/user-login-bean/deleteUserInfoByEntityId
    @RequestMapping("/deleteUserInfoByEntityId")
    public Boolean deleteUserInfoByEntityId(){
        //removeById()是mybatis-plus封装好的，通过实体对象ID值，删除ID值为5的用户信息，返回布尔类型
        return userLoginService.removeById(new UserLoginBean(5));
    }

浏览器访问接口后：

调用接口后MySQL用户表数据：

（2）通过实体对象条件删除相应用户信息，新增接口如下

    /** 通过实体对象条件，删除相应用户信息 */
    //浏览器访问 http://localhost:8085/user-login-bean/deleteUserInfoByEntity
    @RequestMapping("/deleteUserInfoByEntity")
    public Boolean deleteUserInfoByEntity(){
        //创建一个QueryWrapper对象
        QueryWrapper<UserLoginBean> queryWrapper = new QueryWrapper<>();
        //构造map条件：删除自增ID大于等于6的用户信息（"DELETE FROM t_user_login WHERE ul_id >= 6"）
        queryWrapper.ge("ul_id","6");
        //返回布尔类型
        return userLoginService.remove(queryWrapper);
    }

浏览器访问接口后：

调用接口后MySQL用户表数据：

（3）通过Map集合条件，删除相应用户信息，新增接口如下：

    /** 通过Map集合条件，删除相应用户信息 */
    //浏览器访问 http://localhost:8085/user-login-bean/deleteUserInfoByMap
    @RequestMapping("/deleteUserInfoByMap")
    public Boolean deleteUserInfoByMap() {
        //创建Map集合，装载条件数据
        HashMap<String, Object> hashMap = new HashMap<>();
        //构造map条件，（DELETE FROM t_user_login WHERE ul_id = 2 AND ul_password = "2更新后qe密码" AND ul_username = "2更新后root"）
        //每一个put()等同于一个MySQL的并且"AND"
        hashMap.put("ul_id",2); 
        hashMap.put("ul_username","2更新后root");
        hashMap.put("ul_password","2更新后qe密码");
        //返回布尔类型
        return userLoginService.removeByMap(hashMap);
    }

浏览器访问接口后：

调用接口后MySQL用户表数据：

（4）通过主键ID，批量删除用户信息，新增接口如下：

    /** 通过主键ID，批量删除用户信息 */
    //浏览器访问 http://localhost:8085/user-login-bean/deleteBatchUserInfoByIds
    @RequestMapping("/deleteBatchUserInfoByIds")
    public Boolean deleteBatchUserInfoByIds(){
        //创建List集合，装载批量数据
        List<Integer> userLoginBeans = new ArrayList<>();
        //把自增ID值为1、3的用户信息，放到List集合中
        userLoginBeans.add(1);
        userLoginBeans.add(3);
        //根据List保存的自增ID值，执行批量删除操作【DELETE FROM t_user_login WHERE ul_id IN ( 1 , 3 )】
        //返回布尔类型
        return userLoginService.removeByIds(userLoginBeans);
    }

浏览器访问接口后：

调用接口后MySQL用户表数据：（ID为5的用户信息，本人私下测试通过实体ID删除了）

4.更新数据（Update）

表数据都删差不多了，重新执行创表语句

（1）通过实体对象ID值，更新用户信息，新增接口如下：

    /** 通过实体对象ID值，更新用户信息 */
    //浏览器访问 http://localhost:8085/user-login-bean/updateUserInfoById
    @RequestMapping("/updateUserInfoById")
    public Boolean updateUserInfoById(){
        //通过ID值为1，修改对应的用户名和密码，返回布尔类型
        //修改前 用户名"root"，密码"root"
        return userLoginService.updateById(new UserLoginBean(1,"更新用户名root","更新密码root"));
    }

浏览器访问接口后：

（2）通过 UpdateWrapper 条件，更新用户信息需要设置 sqlset，新增接口如下：

    /** 通过 UpdateWrapper 条件，更新用户信息 需要设置 sqlset */
    //浏览器访问 http://localhost:8085/user-login-bean/updateUserInfoBySqlSet
    @RequestMapping("/updateUserInfoBySqlSet")
    public Boolean updateUserInfoBySqlSet(){
        //创建 UpdateWrapper 对象
        UpdateWrapper<UserLoginBean> updateWrapper = new UpdateWrapper<>();
        //构造条件
        updateWrapper
                .eq("ul_username","更新用户名root") // ul_username = '更新用户名root'
                .eq("ul_password","更新密码root") // ul_password = '更新密码root'
                //更新的set参数值
                .setSql("ul_username = 'update用户名',ul_password = 'update密码'");
        /** 以上构造条件，效果等同于以下单独set() */
//        updateWrapper
//                .eq("ul_username","更新用户名root")
//                .eq("ul_password","更新密码root")
//                .set("ul_username","update用户名")
//                .set("ul_password","update密码");
        //返回布尔类型
        return userLoginService.update(updateWrapper);
    }

浏览器访问接口后：

（3）通过实体条件，更新用户信息不需要设置 sqlset，新增接口如下：

    /** 通过实体条件，更新用户信息 不需要设置 sqlset */
    //浏览器访问 http://localhost:8085/user-login-bean/updateUserInfoByEntity
    @RequestMapping("/updateUserInfoByEntity")
    public Boolean updateUserInfoByEntity(){
        //创建 UpdateWrapper 对象
        UpdateWrapper<UserLoginBean> updateWrapper = new UpdateWrapper<>();
        //构造条件
        updateWrapper
                .eq("ul_username","update用户名") // ul_username = 'update用户名'
                .eq("ul_password","update密码"); // ul_password = 'update密码'
        //创建用户对象
        UserLoginBean user = new UserLoginBean("新root","新root");
        //第一个参数：实体对象初始化信息，第二个参数：构造的where条件。返回布尔类型
        return userLoginService.update(user,updateWrapper);
    }

浏览器访问接口后：

（4）通过实体对象ID值，批量更新用户信息，新增接口如下：

    /** 通过实体对象ID值，批量更新用户信息 */
    //浏览器访问 http://localhost:8085/user-login-bean/updateUserInfoByBatchById
    @RequestMapping("/updateUserInfoByBatchById")
    public Boolean updateUserInfoByBatchById(){
        //创建List集合，装载批量数据
        List<UserLoginBean> userLoginBeans = new ArrayList<>();
        //创建两个用户对象数据，分别对应ID值1、2，后面的用户名和密码，即使对应更新数据参数
        userLoginBeans.add(new UserLoginBean(1,"1批量更新用户名root","1批量更新密码root"));
        userLoginBeans.add(new UserLoginBean(2,"2批量更新用户名root","2批量更新密码root"));
        //返回布尔类型
        return userLoginService.updateBatchById(userLoginBeans);
    }

浏览器访问接口后：

***因文章过长，查询数据+分页查询等功能在第二篇演示***