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("插入失敗");
        }

    }

View Code

 

 

 

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); }

 

 

 

 

 

 

 

。