mybatisPlus框架

配置

# 指定mapper文件位置
mybatis-plus.mapper-locations = classpath*:/mapper/**/*.xml

分页插件

创建config开启分页

package com.cqh.config;

/**
 * @author cqh
 * @date 2023/12/10
 * @Description
 */

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
//开启扫描，注意包名不要写错(有了MyBatisPlus的配置类，我们就可以把所有的相关配置都写在这里)
@MapperScan("com.qf.mybatisplusdemo.mapper")
public class MyBatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor mybatisPlusInterceptor = new
                MybatisPlusInterceptor();
//分页插件
        mybatisPlusInterceptor.addInnerInterceptor(new
                PaginationInnerInterceptor(DbType.MYSQL));
        return mybatisPlusInterceptor;
    }
}

分页测试

//修改年龄大于10，并且name为xiao的用户role为 1

package com.cqh;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.cqh.entity.User;
import com.cqh.mapper.UserMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

//查询全部
    @Test
    public void test01(){

        List<User> users = userMapper.selectList(null);
        for (User user : users) {
            System.out.println("user = " + user);
        }
    }
//插入数据
    @Test
    public void test02(){
        User user1 = new User();
        user1.setUsername("chen1");
        user1.setPassword("123456");
        user1.setAge(18);
        user1.setRole("1");
        user1.setSex(1);

        int insert = userMapper.insert(user1);
        System.out.println("insert = " + insert);
        System.out.println("id = " + user1.getId());

    }


    //根据map删除
    @Test
    public void deleteTest(){
        Map<String,Object> map = new HashMap<>();
        map.put("username","xiaoMin");
        map.put("age",11);
        int num = userMapper.deleteByMap(map);
        System.out.println(num);
    }


//根据多个id进行批量删除
    @Test
    public void deleteTest2(){
        ArrayList<Integer> ids = new ArrayList<>();
        ids.add(15);
        ids.add(17);
        int num = userMapper.deleteBatchIds(ids);
        System.out.println(num);
    }


    //根据多个条件进行删除
    @Test
    public void deleteTest3(){
        QueryWrapper<User> userQueryWrapper = new QueryWrapper<>();
        userQueryWrapper.eq("username","a3");
        userQueryWrapper.eq("sex",1);
        int num = userMapper.delete(userQueryWrapper);
        System.out.println(num);
    }


    //根据id修改
    @Test
    public void updateTest(){
        User user = new User();
        user.setId(6);
        user.setUsername("李四");
        int num = userMapper.updateById(user);
        System.out.println(num);
    }


    //根据Map中传递的条件进行查询
    @Test
    public void selectTest(){
        Map<String,Object> map = new HashMap<>();
        map.put("id",6);
        map.put("username","李四");
        List<User> users = userMapper.selectByMap(map);
        users.forEach(user -> System.out.println(user));
    }

    @Test
    public void selectByNameTest(){
        List<User> users = userMapper.selectByName("李四");
        users.forEach(user -> System.out.println(user));
    }


    @Test
    public void PaginationInnerInterceptorTest(){
//简单分页模型 current：第几页 size：显示几条数据
//底层逻辑就是使用Limit分页的公式 (index-1)*pageSize
        Page<User> page = new Page<>(1,3);
//条件构造器Wrapper目前没有就写null
        userMapper.selectPage(page,null);
    }



    @Test
    public void PaginationInnerInterceptorTest2(){
//简单分页模型 current：第几页 size：显示几条数据
//底层逻辑就是使用Limit分页的公式 (index-1)*pageSize
        Page<User> page = new Page<>(2,3);
//条件构造器Wrapper目前没有就写null
        userMapper.selectPage(page,null);
//获取记录
        List<User> users = page.getRecords();
        users.forEach(user -> System.out.println(user));
        System.out.println(page.getPages()); //获取总页数
        System.out.println(page.getTotal()); //获取总数据量
        System.out.println(page.hasNext());//是否有下一页
        System.out.println(page.hasPrevious());//是否有上一页
    }


    // 查询username不为空的用户，并且年龄大于10岁
    @Test
  public void selectTest1(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.isNotNull("username")
                .ge("age",10);
        userMapper.selectList(wrapper).forEach(System.out::println);//类似于map传入条件
    }




    // 查询名字为chen的用户
    @Test
   public void selectTest2(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("username","chen");
        User user = userMapper.selectOne(wrapper);//类似于map传入条件
        System.out.println(user);
    }


    // 查询年龄18~25岁之间的用户
    @Test
   public void selectTest3(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",18,25);
        userMapper.selectList(wrapper).forEach(System.out::println);//类似于map传入条件
    }


    // 查询年龄大于等于25岁的用户
    @Test
   public void selectTest4(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.ge("age",25);
        userMapper.selectList(wrapper).forEach(System.out::println);//类似于map传入条件
    }

    // 模糊查询：查询名字不包含a的用户，反之like就是包含
    @Test
   public void selectTest5(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.notLike("username","a");
        userMapper.selectList(wrapper).forEach(System.out::println);//类似于map传入条件
    }


    //模糊查询：包含左侧或者右侧具体内容
    @Test
   public void selectTest6(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
    // 模糊查询：查询名字不包含qf的用户，反之like就是包含
    // likeLeft和likeRight
    // 左右就是 %在左或者在右
    // 以下就是 a% 相当于以a开头的名字
        wrapper.likeRight("username","a");

        userMapper.selectList(wrapper).forEach(System.out::println);//类似于map传入条件
    }


    //通过子查询，查询id等于6的用户信息，此方法也可以进行表关联查询
    @Test
   public void selectTest7(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();

        wrapper.inSql("id","select id from tb_user where id=6");
        userMapper.selectObjs(wrapper).forEach(System.out::println);
    }

    // 查询用户名中包含a并且年龄大于29或者crateTime为空的用户
    @Test
   public void selectTest8(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.like("username","a")
                .and(w->w.gt("age",26).or().isNull("createTime"));
        userMapper.selectList(wrapper).forEach(System.out::println);
    }


    // 模糊查询：查询名字包含a的用户,并且按照age升序排序，注意参数不能为空
    @Test
   public void selectTest9(){
    //假设用户传递参数
        String username = "a";
        Integer age = 1;
        //先判断条件是否符合，符合才会组合到SQL语句中
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.like(StringUtils.isNotBlank(username),"username",username)
                .orderByAsc(age != null,"age");
        userMapper.selectList(wrapper).forEach(System.out::println);//类似于map传入条件
    }
    //修改用户id为24的username为jack
    @Test
   public void updateTest1(){
       // QueryWrapper<User> wrapper = new QueryWrapper<>();
       // wrapper.eq("id",24);
        User user = new User();
        user.setUsername("jack");
       // userMapper.update(user,wrapper);
        userMapper.update(user,new QueryWrapper<User>().eq("id",24));
    }


    //删除username为jack的用户
    @Test
   public void deleteTest1(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("username","jack");
        userMapper.delete(wrapper);
    }


    //修改年龄大于10，并且username为xiao的用户role为 0
    @Test
   public void updateTest2(){
        UpdateWrapper<User> wrapper = new UpdateWrapper<>();
        wrapper.gt("age",10)
                .eq("username","xiao")
                .set("role","0");
//无需传递user对象，直接赋值为null
        userMapper.update(null,wrapper);
    }


    @Test
   public void selectTest10(){
//假设用户传递参数
        String username = "a";
        Integer age = null;
//LambdaQueryWrapper就是为了防止我们写错字段，可以直接通过Lambda的方式来直接获取指定字段对应的实体类对应的名称
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(StringUtils.isNotBlank(username),User::getUsername,username)
                .orderByAsc(age != null,User::getAge);
        userMapper.selectList(wrapper).forEach(System.out::println);//类似于map传入条件
    }

    //修改年龄大于10，并且name为xiao的用户role为 1
    @Test
   public void updateTest3(){
        LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();
        wrapper.gt(User::getAge,10)
                .eq(User::getUsername,"xiao")
                .set(User::getRole,"1");
//无需传递user对象，直接赋值为null
        userMapper.update(null,wrapper);
    }

}