spring整合mybatisplus2.x詳解

一丶Mp的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"
    xsi:schemaLocation="http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring-1.2.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
    
    
    <!-- 數據源 -->
    <context:property-placeholder location="classpath:db.properties"/>
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <!-- 事務管理器 -->
    <bean id="dataSourceTransactionManager" 
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 基於注解的事務管理 -->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>
    
    
    <!--  配置SqlSessionFactoryBean 
        Mybatis提供的: org.mybatis.spring.SqlSessionFactoryBean
        MP提供的:com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean
     -->
    <bean id="sqlSessionFactoryBean" class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean">
        <!-- 數據源 -->
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
        <!-- 別名處理 -->
        <property name="typeAliasesPackage" value="com.atguigu.mp.beans"></property>    
        
        <!-- 注入全局MP策略配置 -->
        <property name="globalConfig" ref="globalConfiguration"></property>
    </bean>
    
    <!-- 定義MybatisPlus的全局策略配置-->
    <bean id ="globalConfiguration" class="com.baomidou.mybatisplus.entity.GlobalConfiguration">
        <!-- 在2.3版本以后，dbColumnUnderline 默認值就是true -->
        <property name="dbColumnUnderline" value="true"></property>
        
        <!-- 全局的主鍵策略 -->
        <property name="idType" value="0"></property>
        
        <!-- 全局的表前綴策略配置 -->
        <property name="tablePrefix" value="tbl_"></property>
    </bean>
​
    <!-- 
        配置mybatis 掃描mapper接口的路徑
     -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.atguigu.mp.mapper"></property>
    </bean>
    
    
</beans>

 

​

二丶CRUD的常用方法

2.1 Insert 方法

/*
 * MybatisPlus會默認使用實體類的類名到數據中找對應的表.
 * 
 */
//<property name="tablePrefix" value="tbl_"></property>
@TableName(value = "tbl_employee")
public class Employee {
    /*
     * @TableId: value: 指定表中的主鍵列的列名， 如果實體屬性名與列名一致，可以省略不指定. type: 指定主鍵策略.
     */
    //<property name="idType" value="0"></property>
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id; // int
    
    //<property name="dbColumnUnderline" value="true"></property>
    @TableField(value = "last_name")
    private String lastName;
    private String email;
    private Integer gender;
    private Integer age;
   
    @TableField(exist = false)
    //當數據庫里面的表沒有這個字段的時候，就不要寫
    private Double salary;
​
}

 

2.1.1 Insert (對象)

@Test
    public void testCommonInsert1() {
​
        // 初始化Employee對象
        Employee employee = new Employee();
        employee.setLastName("MP");
        employee.setEmail("[e-mail]");
        employee.setGender(1);
        employee.setAge(22);
        employee.setSalary(20000.0);
        // 插入到數據庫
        // insert方法在插入時， 會根據實體類的每個屬性進行非空判斷，只有非空的屬性對應的字段才會出現到SQL語句中
        Integer result = employeeMapper.insert(employee);
​
        System.out.println("result: " + result);
    }

 

2.1.2 insertAllColumn(對象)

 @Test
    public void testCommonInsert() {
​
        // 初始化Employee對象
        Employee employee = new Employee();
        employee.setLastName("MP");
        employee.setEmail("[e-mail]");
        // employee.setGender(1);
        // employee.setAge(22);
        employee.setSalary(20000.0);
        // insertAllColumn方法在插入時， 不管屬性是否非空， 屬性所對應的字段都會出現到SQL語句中.
        Integer result = employeeMapper.insertAllColumn(employee);
        System.out.println("result: " + result);
    }

 

2.1.3 獲得主鍵

      // 獲取當前數據在數據庫中的主鍵值
        Integer key = employee.getId();
        System.out.println("key:" + key);

 

2.2 Update 方法

2.2.1 updateById(對象)

 /**
     * 通用 更新操作
     */
    @Test
    public void testCommonUpdate() {
        // 初始化修改對象
        Employee employee = new Employee();
        employee.setId(7);
        employee.setLastName("小澤老師");
        employee.setEmail("[e-mail]");
        employee.setGender(0);
        Integer result = employeeMapper.updateById(employee);
        System.out.println("result: " + result);
    }

 

2.2.2 updateAllColumnById（對象）

 /**
     * 通用 更新操作
     */
    @Test
    public void testCommonUpdate() {
        // 初始化修改對象
        Employee employee = new Employee();
        employee.setId(7);
        employee.setLastName("小澤老師");
        employee.setEmail("[e-mail]");
        employee.setGender(0);
​
        Integer result = employeeMapper.updateAllColumnById(employee);
        System.out.println("result: " + result);
    }

 

2.3 Select 方法

2.3.1 selectById

   // 1. 通過id查詢
        // Employee employee = employeeMapper.selectById(7);
        // System.out.println(employee);

 

2.3.2 selectOne 

   // 2. 通過多個列進行查詢 id + lastName
        // Employee employee = new Employee();
        // //employee.setId(7);
        // employee.setLastName("小澤老師");
        // employee.setGender(0);
        //
        // Employee result = employeeMapper.selectOne(employee);
        // System.out.println("result: " +result );
        // 這個只能查一條數據，多的時候回報錯

 

2.3.3 selectBatchIds

   // 3. 通過多個id進行查詢 <foreach>
        // List<Integer> idList = new ArrayList<>();
        // idList.add(4);
        // idList.add(5);
        // idList.add(6);
        // idList.add(7);
        // List<Employee> emps = employeeMapper.selectBatchIds(idList);
        // System.out.println(emps);

2.3.4 selectByMap 

  // 4. 通過Map封裝條件查詢
        // Map<String,Object> columnMap = new HashMap<>();
        // columnMap.put("last_name", "Tom");
        // columnMap.put("gender", 1);
        //
        // List<Employee> emps = employeeMapper.selectByMap(columnMap);
        // System.out.println(emps);

2.4 Delete 方法

2.4.1 deleteById   

  // 1 .根據id進行刪除
        Integer result = employeeMapper.deleteById(13);
        System.out.println("result: " + result);

 

2.4.2 deleteByMap      

 // 2. 根據 條件進行刪除
        // Map<String,Object> columnMap = new HashMap<>();
        // columnMap.put("last_name", "MP");
        // columnMap.put("email", "[e-mail]");
        // Integer result = employeeMapper.deleteByMap(columnMap);
        // System.out.println("result: " + result );

2.4.3 deleteBatchIds

 // 3. 批量刪除
        // List<Integer> idList = new ArrayList<>();
        // idList.add(3);
        // idList.add(4);
        // idList.add(5);
        // Integer result = employeeMapper.deleteBatchIds(idList);
        // System.out.println("result: " + result );

 

三丶CRUD原理

• employeeMapper 的本質 org.apache.ibatis.binding.MapperProxy

• MapperProxy 中 sqlSession –>SqlSessionFactory

SqlSessionFacotry 中 → Configuration→ MappedStatements

每一個 mappedStatement 都表示 Mapper 接口中的一個方法與 Mapper 映射文件

中的一個 SQL。

MP 在啟動就會挨個分析 xxxMapper 中的方法，並且將對應的 SQL 語句處理好，保

存到 configuration 對象中的 mappedStatements 中.

• SqlSessionFacotry 中 → Configuration→ MappedStatements

每一個 mappedStatement 都表示 Mapper 接口中的一個方法與 Mapper 映射文件

中的一個 SQL。

MP 在啟動就會挨個分析 xxxMapper 中的方法，並且將對應的 SQL 語句處理好，保

存到 configuration 對象中的 mappedStatements 中.

D． 本質:

Configuration： MyBatis 或者 MP 全局配置對象

MappedStatement：一個 MappedStatement 對象對應 Mapper 配置文件中的一個

select/update/insert/delete 節點，主要描述的是一條 SQL 語句

SqlMethod : 枚舉對象 ， MP 支持的 SQL 方法

TableInfo： 數據庫表反射信息 ，可以獲取到數據庫表相關的信息

SqlSource: SQL 語句處理對象

MapperBuilderAssistant： 用於緩存、 SQL 參數、查詢方劑結果集處理等.

通過 MapperBuilderAssistant 將每一個 mappedStatement

添加到 configuration 中的 mappedstatements中

四丶條件構造器

查詢方式	說明
setSqlSelect	設置 SELECT 查詢字段
where	WHERE 語句，拼接 + WHERE 條件
and	AND 語句，拼接 + AND 字段=值
andNew	AND 語句，拼接 + AND (字段=值)
or	OR 語句，拼接 + OR 字段=值
orNew	OR 語句，拼接 + OR (字段=值)
eq	等於=
allEq	基於 map 內容等於=
ne	不等於<>
gt	大於>
ge	大於等於>=
lt	小於<
le	小於等於<=
like	模糊查詢 LIKE
notLike	模糊查詢 NOT LIKE
in	IN 查詢
notIn	NOT IN 查詢
isNull	NULL 值查詢
isNotNull	IS NOT NULL
groupBy	分組 GROUP BY
having	HAVING 關鍵詞
orderBy	排序 ORDER BY
orderAsc	ASC 排序 ORDER BY
orderDesc	DESC 排序 ORDER BY
exists	EXISTS 條件語句
notExists	NOT EXISTS 條件語句
between	BETWEEN 條件語句
notBetween	NOT BETWEEN 條件語句
addFilter	自由拼接 SQL
last	拼接在最后，例如：last("LIMIT 1")

• 官方示例

  @Test
  public void testTSQL11() {
      /*
       * 實體帶查詢使用方法  輸出看結果
       */
      EntityWrapper<User> ew = new EntityWrapper<User>();
      ew.setEntity(new User(1));
      ew.where("user_name={0}", "'zhangsan'").and("id=1")
              .orNew("user_status={0}", "0").or("status=1")
              .notLike("user_nickname", "notvalue")
              .andNew("new=xx").like("hhh", "ddd")
              .andNew("pwd=11").isNotNull("n1,n2").isNull("n3")
              .groupBy("x1").groupBy("x2,x3")
              .having("x1=11").having("x3=433")
              .orderBy("dd").orderBy("d1,d2");
      System.out.println(ew.getSqlSegment());
  }
  int buyCount = selectCount(Condition.create()
                  .setSqlSelect("sum(quantity)")
                  .isNull("order_id")
                  .eq("user_id", 1)
                  .eq("type", 1)
                  .in("status", new Integer[]{0, 1})
                  .eq("product_id", 1)
                  .between("created_time", startDate, currentDate)
                  .eq("weal", 1));

   

• 自定義的SQL怎么使用

  List<User> selectMyPage(RowBounds rowBounds, @Param("ew") Wrapper<T> wrapper);
  <select id="selectMyPage" resultType="User">
    SELECT * FROM user 
    <where>
    ${ew.sqlSegment}
    </where>
  </select>
  /**
  ​
  - 用戶登錄次數
  */
  @Select("<script>SELECT * FROM z080_user_login <where> ${ew.sqlSegment} </where></script>")
  List<UserLogin> findUserLogin(@Param("ew") Wrapper<?> wrapper);
  ​
  /**
  ​
  - 用戶在線時長
  */
  @Select("<script>SELECT * FROM z080_user_online <where> ${ew.sqlSegment} </where></script>")
  List<UserOnline> findUserOnline(@Param("ew") Wrapper<?> wrapper);

常用的用法：

delete、selectCount、selectList、selectMaps、selectObjs、update。。。。

五丶ActiveRecord(活動記錄)

5.1 java類繼承

public class Employee extends Model<Employee> {
    private Integer id; // int
    private String lastName;
    private String email;
    private Integer gender;
    private Integer age;
}

 

5.2繼承BaseMapper

public interface EmployeeMapper extends BaseMapper<Employee> {
    //   Integer  insertEmployee(Employee employee );
    //   <insert useGeneratedKeys="true" keyProperty="id" > SQL...</insert>
}

 

5.3 測試類

/**
     * AR 修改操作
     */
    @Test
    public void testARUpdate() {
        Employee employee = new Employee();
        employee.setId(20);
        employee.setLastName("宋老濕");
        employee.setEmail("[e-mail]");
        employee.setGender(1);
        employee.setAge(36);
​
        boolean result = employee.updateById();
        System.out.println("result:" + result);
​
    }
​
    /**
     * AR 插入操作
     */
    @Test
    public void testARInsert() {
        Employee employee = new Employee();
        employee.setLastName("宋老師");
        employee.setEmail("[e-mail]");
        employee.setGender(1);
        employee.setAge(35);
​
        boolean result = employee.insert();
        System.out.println("result:" + result);
    }
/**
     * AR 分頁復雜操作
     */
    @Test
    public void testARPage() {
​
        Employee employee = new Employee();
​
        Page<Employee> page = employee.selectPage(new Page<>(1, 1),
                new EntityWrapper<Employee>().like("last_name", "老"));
        List<Employee> emps = page.getRecords();
        System.out.println(emps);
    }

七丶插件原理

<!-- 插件注冊 -->
        <property name="plugins">
            <list>
                <!-- 注冊分頁插件 -->
            <bean class="com.baomidou.mybatisplus.plugins.PaginationInterceptor"></bean>
                <!-- 注冊執行分析插件 -->
                <bean class="com.baomidou.mybatisplus.plugins.SqlExplainInterceptor">
                    <property name="stopProceed" value="true"></property>
                </bean>
                
                <!-- 注冊性能分析插件 -->
                <bean class="com.baomidou.mybatisplus.plugins.PerformanceInterceptor">
                    <property name="format" value="true"></property>
                    <!-- <property name="maxTime" value="5"></property> -->
                </bean>
                
                <!-- 注冊樂觀鎖插件 -->
        <bean class="com.baomidou.mybatisplus.plugins.OptimisticLockerInterceptor">
                </bean>
            
            </list>
            
        </property>

7.1分頁插件

  /**
     * 測試分頁插件
     */
    @Test
    public void testPage() {
​
        Page<Employee> page = new Page<>(1, 1);
​
        List<Employee> emps = employeeMapper.selectPage(page, null);
        System.out.println(emps);
​
        System.out.println("===============獲取分頁相關的一些信息======================");
​
        System.out.println("總條數:" + page.getTotal());
        System.out.println("當前頁碼: " + page.getCurrent());
        System.out.println("總頁碼:" + page.getPages());
        System.out.println("每頁顯示的條數:" + page.getSize());
        System.out.println("是否有上一頁: " + page.hasPrevious());
        System.out.println("是否有下一頁: " + page.hasNext());
​
        // 將查詢的結果封裝到page對象中
        page.setRecords(emps);
        List<Employee> records = page.getRecords();
        System.out.println(records);
​
    }

 

7.2分析插件

/**
     * 測試SQL執行分析插件，執行全表刪除的會報錯
     */
    @Test
    public void testSQLExplain() {
​
        employeeMapper.delete(null); // 全表刪除
    }

 

7.3性能分析插件

/**
     * 測試 性能分析插件
     */
    @Test
    public void testPerformance() {
        Employee employee = new Employee();
        employee.setLastName("瑪利亞老師");
        employee.setEmail("[e-mail]");
        employee.setGender("0");
        employee.setAge(22);
​
        employeeMapper.insert(employee);
​
    }

 

7.4 樂觀鎖插件

@Test
    public void testOptimisticLocker() {
        // 更新操作
        Employee employee = new Employee();
        employee.setId(15);
        employee.setLastName("TomAA");
        employee.setEmail("[e-mail]");
        employee.setGender("1");
        employee.setAge(22);
        employee.setVersion(3);
​
        employeeMapper.updateById(employee);
​
    }
​
 @Version
 private Integer version ;

 

7.5概述

1) 插件機制:
Mybatis 通過插件(Interceptor) 可以做到攔截四大對象相關方法的執行,根據需求， 完
成相關數據的動態改變。
Executor
StatementHandler
ParameterHandler
ResultSetHandler
2) 插件原理
四大對象的每個對象在創建時，都會執行 interceptorChain.pluginAll()，會經過每個插
件對象的 plugin()方法，目的是為當前的四大對象創建代理。代理對象就可以攔截到四
大對象相關方法的執行，因為要執行四大對象的方法需要經過代理.
7.2 分頁插件
1) com.baomidou.mybatisplus.plugins.PaginationInterceptor
7.3 執行分析插件
1) com.baomidou.mybatisplus.plugins.SqlExplainInterceptor
2) SQL 執行分析攔截器，只支持 MySQL5.6.3 以上版本
3) 該插件的作用是分析 DELETE UPDATE 語句,防止小白
或者惡意進行 DELETE UPDATE 全表操作
4) 只建議在開發環境中使用，不建議在生產環境使用
5) 在插件的底層 通過 SQL 語句分析命令:Explain 分析當前的 SQL 語句，
根據結果集中的 Extra 列來斷定當前是否全表操作。
7.4 性能分析插件
1) com.baomidou.mybatisplus.plugins.PerformanceInterceptor
2) 性能分析攔截器，用於輸出每條 SQL 語句及其執行時間java 課程系列
3) SQL 性能執行分析,開發環境使用， 超過指定時間，停止運行。有助於發現問題
7.5 樂觀鎖插件
1) com.baomidou.mybatisplus.plugins.OptimisticLockerInterceptor
2) 如果想實現如下需求: 當要更新一條記錄的時候，希望這條記錄沒有被別人更新
3) 樂觀鎖的實現原理:
取出記錄時，獲取當前 version 2
更新時，帶上這個 version 2
執行更新時， set version = yourVersion+1 where version = yourVersion
如果 version 不對，就更新失敗
4) @Version 用於注解實體字段，必須要有。
 

 

 

 

 

 

 

 

 

 

 

 

 

八丶其他配置

<!-- 定義自定義注入器 -->
    <bean id="mySqlInjector" class="com.atguigu.mp.injector.MySqlInjector"></bean>
    
    <!-- 邏輯刪除 -->
    <bean id="logicSqlInjector" class="com.baomidou.mybatisplus.mapper.LogicSqlInjector"></bean>
    
    <!-- 公共字段填充 處理器 -->
    <bean id="myMetaObjectHandler" class="com.atguigu.mp.metaObjectHandler.MyMetaObjectHandler"> </bean>
    
    <!-- 配置Oracle主鍵Sequence -->
    <bean id="oracleKeyGenerator" class="com.baomidou.mybatisplus.incrementer.OracleKeyGenerator"></bean>
​
<!------------------------------------------------------------------------>
​
        <!--注入自定義全局操作 
        <property name="sqlInjector" ref="mySqlInjector"></property>
        -->
        <!-- 注入邏輯刪除 -->
        <property name="sqlInjector" ref="logicSqlInjector"></property>
        
        <!-- 注入邏輯刪除全局值 -->
        <property name="logicDeleteValue" value = "-1"></property>
        <property name="logicNotDeleteValue" value="1"></property>
        
        <!-- 注入公共字段填充處理器 -->
        <property name="metaObjectHandler" ref="myMetaObjectHandler"></property>
        
        <!-- 注入Oracle主鍵Sequence -->
        <property name="keyGenerator" ref="oracleKeyGenerator"></property>

 

8.1 自定義全局操作

8.1.1 在 Mapper 接口中定義相關的 CRUD 方法

/**
 * <p>
 *  Mapper 接口
 * </p>
 *
 * @author weiyunhui
 * @since 2018-06-21
 */
public interface EmployeeMapper extends BaseMapper<Employee> {
    
    int  deleteAll();
}

 

8.1.2擴展 AutoSqlInjector inject 方法，實現 Mapper 接口中方法要注入的 SQL

public class MySqlInjector  extends AutoSqlInjector{
    
    /**
     * 擴展inject 方法，完成自定義全局操作
     */
    @Override
    public void inject(Configuration configuration, MapperBuilderAssistant builderAssistant, Class<?>  ,
            Class<?> modelClass, TableInfo table) {
        //將EmployeeMapper中定義的deleteAll， 處理成對應的MappedStatement對象，加入到configuration對象中。
        
        //注入的SQL語句
        String sql = "delete from " +table.getTableName();
        //注入的方法名   一定要與EmployeeMapper接口中的方法名一致
        String method = "deleteAll" ;
        
        //構造SqlSource對象
        SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
        
        //構造一個刪除的MappedStatement
        this.addDeleteMappedStatement(mapperClass, method, sqlSource);
        
    }
}

 

8.1.3 在 MP 全局策略中，配置 自定義注入器

 <property name="sqlInjector" ref="mySqlInjector"></property>

啟動的時候會把deleteAll添加進去了

8.2 邏輯刪除

1) com.baomidou.mybatisplus.mapper.LogicSqlInjector
2) logicDeleteValue 邏輯刪除全局值
3) logicNotDeleteValue 邏輯未刪除全局值
4) 在 POJO 的邏輯刪除字段 添加 @TableLogic 注解
5) 會在 mp 自帶查詢和更新方法的 sql 后面，追加『邏輯刪除字段』=『LogicNotDeleteValue
默認值』 刪除方法: deleteById()和其他 delete 方法, 底層 SQL 調用的是 update tbl_xxx
set 『邏輯刪除字段』 =『logicDeleteValue 默認值』

 

8.2.1 xml配置

<!-- 邏輯刪除 -->
    <bean id="logicSqlInjector" class="com.baomidou.mybatisplus.mapper.LogicSqlInjector"></bean>
<!-- 注入邏輯刪除 -->
        <property name="sqlInjector" ref="logicSqlInjector"></property>
<!-- 注入邏輯刪除全局值 -->
        <property name="logicDeleteValue" value = "-1"></property>
        <property name="logicNotDeleteValue" value="1"></property>

 

8.2.2添加注解

@TableLogic   // 邏輯刪除屬性
    private Integer logicFlag ;

 

8.2.3 方法

   /**
     * 測試邏輯刪除
     */
    @Test
    public void testLogicDelete() {
        
//      Integer result = userMapper.deleteById(1);
//      System.out.println("result:" +result );
        User user = userMapper.selectById(1);
        System.out.println(user);
    }

 

 

 

 

 

 

 

 

8.3公共字段填充

8.3.1繼承類重寫方法

/**
 * 自定義公共字段填充處理器
 */
public class MyMetaObjectHandler extends MetaObjectHandler {
​
    /**
     * 插入操作 自動填充
     */
    @Override
    public void insertFill(MetaObject metaObject) {
        // 獲取到需要被填充的字段的值
        Object fieldValue = getFieldValByName("name", metaObject);
        if (fieldValue == null) {
            System.out.println("*******插入操作 滿足填充條件*********");
            setFieldValByName("name", "weiyunhui", metaObject);
        }
​
    }
​
    /**
     * 修改操作 自動填充
     */
    @Override
    public void updateFill(MetaObject metaObject) {
        Object fieldValue = getFieldValByName("name", metaObject);
        if (fieldValue == null) {
            System.out.println("*******修改操作 滿足填充條件*********");
            setFieldValByName("name", "weiyh", metaObject);
        }
    }
​
}

 

8.3.2注解填充字段 @TableFile(fill = FieldFill.INSERT) 查看 FieldFill

@TableField(fill=FieldFill.INSERT_UPDATE)
    private String name ;

 

8.3.3 MP 全局注入 自定義公共字段填充處理器

<!-- 注入公共字段填充處理器 -->
        <property name="metaObjectHandler" ref="myMetaObjectHandler"></property>
測試方法

    /**
     * 測試公共字段填充
     */
    @Test
    public void testMetaObjectHandler() {
        User user = new User();
        //user.setName("Tom");
        
        user.setId(5);
        user.setLogicFlag(1);
        
        userMapper.updateById(user);
    }

 

8.4Oracle序列

8.4.1實體類配置主鍵 Sequence @KeySequence

//@KeySequence(value="seq_user",clazz=Integer.class)
public class User extends Parent {
    //@TableId(type=IdType.INPUT)
    private Integer id  ;

 

8.4.2 全局 MP 主鍵生成策略為 IdType.INPUT

   <!-- Oracle全局主鍵策略 -->
    <property name="idType" value="1"></property>

 

8.4.3全局 MP 中配置 Oracle 主鍵 Sequence

<!-- 注入Oracle主鍵Sequence -->
<property name="keyGenerator" ref="oracleKeyGenerator"></property>

 

8.4.4 寫一個父類

@KeySequence(value="seq_user",clazz=Integer.class)
public abstract class Parent {
​
}