mybatis plus CRUD

首先我们的项目建立之后我们要建立一个实体类来对应我们的数据裤中的信息

employee

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.dailuobo.devops.common.domain.entity.BaseEntity;
import lombok.Data;


/**
 * TableName
 * 是让我们的类和数据库的表建立关系
 *      value 是表明 默认不写value
 */
@Data
@TableName("tbl_employee")
public class Employee  {


    /**
     * TableId
     *  value 指定表中额主键列名 如果实体属性和列名一致 可以省略不写
     *  type指定主键策略  mybatisplus文档上有
     */
    //主键注解 因为我们的表设置的是自增的但是要让mybatisplus同步否则报错
    @TableId(value = "id",type = IdType.AUTO)  //设置自增  因为
    private Integer id;

    @TableField(value = "last_name") //标注当前数据库的列名
    private String lastName;
    private String email;
    private Integer gender;
    private Integer age;



    //如果这个类中有其他的非数据的字段这个时候可以使用
    @TableField(exist = false)
    private Double salary;  //再插入的时候就会忽略这个字段不去数据库中校验
}

然后为这个类再建立能操作数据的方法类Mapper

EmployeeMapper

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.dailuobo.devops.mp.common.domain.entity.Employee;


/**
 * Mapper接口
 * 基于mybatis：在Mapper接口中编写CRUD方法 提供Mapper接口对应的SQL映射文件以及方法对应的SQL语句
 *
 *
 * 基于Mybatis Plus  让XXXMapper继承BaseMapper接口即可
 *     BaseMapper<T> : 泛型指定的就是当前Mapper解耦所操作的实体类对象
 */

public interface EmployeeMapper extends BaseMapper<Employee> {
}

然后我们可以通过这个EmployeeMapper类进行数据的增删改的操作也可以  通过services类继承之后再进行间接操作

我现在测试方法中进行操作：

    @Test
    public void testCommonInsert(){


        //初始化employee对象
        Employee employee = new Employee();

        employee.setLastName("test");
        employee.setEmail("mp@caicai.com");
        employee.setGender(1);
//        employee.setAge(20);

        
        //插入数据库  insert会对实体类的属性进行非空判断 只有非空才会出现在sql语句中
        Integer result = employeeMapper.insert(employee);  //通过点进去的源码可以看到是有一个返回值的  这个返回值是int就是我们队数据库的影响的条数

//        employeeMapper.insertAllColumn   插入的时候如果值没有信息设置为null字符插入 而insert现在集合了这个默认的功能
        System.out.println("result"+result);



        //我们可以通过对象.getId()来获取对象表中数据的主键值
        employee.getId();
    }

插入：insert

这个就相当于我们的python的orm操作信息，都是通过特定的语句可以直接进行数据的操作

mapper对象.insert(对象);

insert插入的是一个对象 然后返回的是一个插入条数 数字

        //初始化employee对象
        Employee employee = new Employee();

        employee.setLastName("test");
        employee.setEmail("mp@caicai.com");
        employee.setGender(1);
        employee.setAge(20);


        //插入数据库  insert会对实体类的属性进行非空判断 只有非空才会出现在sql语句中
        Integer result = employeeMapper.insert(employee);  //通过点进去的源码可以看到是有一个返回值的  这个返回值是int就是我们队数据库的影响的条数

//        employeeMapper.insertAllColumn   插入的时候如果值没有信息设置为null字符插入 而insert现在集合了这个默认的功能
        System.out.println("result"+result);  // result  1

插入的时候只能放在最后插入 哪怕指定已经存在的id插入也不会修改，会自动在后面插入

    @Test
    public void testUpdate(){

        Employee employee = new Employee();
        employee.setLastName("insert_one");
        employee.setId(7); // 只可以当做插入不可以当做修改  如果指定已经有的id插入 也会放在后面依次插入

        Integer result = employeeMapper.insert(employee);
        if (result >= 1){
            System.out.println("插入成功"+result);
        }else{
            System.out.println("插入失败");
        }

    }

getId() :获取对象表中的主键值

        //我们可以通过对象.getId()来获取对象表中数据的主键值
        employee.getId();获取employee 对象的主键值

updateById(); 修改信息  指定主键id去修改 不然就会修改失败 报错，哪怕把一整个对象更新进去也要指定这个对象的主键id

Mapper对象.updateById(更新对象);

更新的时候就要知道和python一样我们先设置值 然后再更新到数据库中

   @Test
    public void testUpdate(){
        Employee employee = new Employee();

        employee.setId(5); // 指定修改的主键id信息
        employee.setLastName("222");
//        employee.setEmail("eqeq");


        //updatebyid如果全部更新 就直接把对象放进去 如果针对选择更新 那就获取这个更新的主键id然后进行更新

        Integer result = employeeMapper.updateById(employee);
        System.out.println("result:"+result); //必须要

    }

根据条件修改:update()  

update(对象,条件构造器)

                    QueryWrapper<Server> queryWrapper = new QueryWrapper<>();
                    queryWrapper.eq("id",name);  //条件
                    serverMapper.update(server,queryWrapper);

修改:

        Employee employee = new Employee();
        employee.setId(7);
        employee.setEmail("111111");
//        employee.setLastName("update_two");
//        Integer result = employeeMapper.updateById(employee);

        UpdateWrapper updateWrapper = new UpdateWrapper();
        updateWrapper.eq("id", 7);
//        Integer result = employeeMapper.update (employee,new UpdateWrapper().set("name", "buiob"));

        employeeMapper.update(employee, updateWrapper);

查询操作：

    selectById();   通过主键查询
  
　　selectBatchIds()  通过主键list查询  返回的也是list集合


　　selectList();根据判断条件查询 


　　selectOne() 构造查询条件  返回的是一个对象

selectById();

Mapper对象.selectById(要查询的主键id);

  @Test
    public void testcommonSelect(){ //获取主键是3的数据对象
        Employee employee = employeeMapper.selectById(3); //根据主键来查找到这个主键对应的数据  获取的是一个对象
        System.out.println("employee对象："+employee);
    }

selectOne();  和selectMap差不多都是按照条件然后查询 但是返回值不同

构构造查询条件 () 内传递的是对象

    @Test
    public void selectOne(){

//        Employee employee = new Employee();
//        employee.setEmail("tree.com");
        Employee employee1 = employeeMapper.selectOne(new QueryWrapper<Employee>().eq("email","three.com"));
        System.out.println("selevtOne:"+ employee1);
        
        //selevtOne:Employee(id=2, lastName=three, email=three.com, gender=1, age=30, salary=null)

    }

查询多个信息   selectBatchIds()  返回的是list集合

 /**                                                                    
  * 通过多个id获取                                                            
  */                                                                    
 @Test                                                                  
 public void getlist(){      //返回的是查询的对象信息                              
     List<Integer> idlist = new ArrayList<>();                          
     idlist.add(1);                                                     
     idlist.add(3);                                                     
                                                                        
     List<Employee> employees = employeeMapper.selectBatchIds(idlist);  
     System.out.println("employees:"+employees);   //返回的就是查询到的3条信息                     
 }                                                                      

构造条件查询：selectByMap()返回的list集合 里面必须是map对象

/** selectByMap    条件查询                                                  
   *    通过Map封装条件查询                                                        
   */                                                                      
  @Test                                                                    
  public void getMap(){                                                    
      //通过Map封装信息                                                          
      Map<String,Object> columnMap = new HashMap<>();                      
      columnMap.put("last_name","Tom");     //这里面写列名而不是对应的属性名              
      columnMap.put("gender",1);     //查询last_name是Tom  gender是1的数据库信息                                      
      List<Employee> employees = employeeMapper.selectByMap(columnMap);    
      System.out.println(employees); //就获取的查询的对象信息    
 // 结果封装成Map:Map:[Employee(id=2, lastName=three, email=three.com, gender=1, age=30, salary=null)]

  } 

    @Test
    public void selectMap(){
        Map<String,Object> stringMap = new HashMap<>();
        //设置条件查询
        stringMap.put("email","three.com");//设置查询条件
        List<Employee> employeeList = employeeMapper.selectByMap(stringMap);  //查询email ==  tree.com
        System.out.println("Map:"+employeeList);

    }

selectList(); 按照字段查询

    @Test
    public  void selecList(){
        // select 要查询的字段   只返回你设置的字段其他的都是null
        List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().select("email"));
        System.out.println(employeeList); 返回的是每条记录的设置查询的字段 其余的不显示
    }

相当于执行SELECT email FROM tbl_employee  这条sql语句

    @Test
    public void selectList(){
        Employee employee = new Employee();

// where 条件查询和and添加和orderby使用

// SELECT age FROM tbl_employee WHERE email = ? AND age = ? ORDER BY id ASC

List<Employee> employeeList = employeeMapper.selectList(new QueryWrapper<Employee>().select("age").eq("email",employee.getEmail()) .eq("age",employee.getAge()).orderBy(true,true,"id")); System.out.println("employeeList:"+employeeList); }

相当于SQL语句SELECT age FROM tbl_employee WHERE email = ? AND age = ? ORDER BY id ASC

删除操作：delete

deleteById()  根据主键删除

deleteBatchIds() 根据主键列表删除
deleteMap() 根据条件删除 根据的是map中的条件

deleteById()： 根据主键删除

    @Test
    public void  deleteBy(){
        Integer result = employeeMapper.deleteById(4);  //返回的是删除的条数

        System.out.println("delete:"+ result);
    }

deleteBatchIds() :根据主键列表删除

    @Test
    public void deleteByIds(){
        List<Integer> idlist = new ArrayList<>();
        idlist.add(3);
        idlist.add(7);
        idlist.add(12);
        idlist.add(11);
        Integer integer = employeeMapper.deleteBatchIds(idlist);  //根据list集合进行删除
        System.out.println("deletelist:"+integer); 
    }

deleteByMap() : 根据条件删除

    @Test
    public  void deleteMap(){
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("id",5);  //根据id删除
        Integer integer = employeeMapper.deleteByMap(columnMap);
        System.out.println("deletemap"+integer);
    }

    @Test
    public  void deleteMap(){
       Map<String,Object> columnMap = new HashMap<>();
       columnMap.put("email",null);  //删除email 和last_name都是null的信息
       columnMap.put("last_name",null);
       Integer integer = employeeMapper.deleteByMap(columnMap);
       System.out.print("map:"+integer);
    }

。