1. 程式人生 > >Mybatis程式碼生成器Mybatis-Generator使用詳解

Mybatis程式碼生成器Mybatis-Generator使用詳解

前提

最近在做創業專案的時候因為有比較多的新需求,需要頻繁基於DDL生成Mybatis適合的實體、Mapper介面和對映檔案。其中,程式碼生成器是MyBatis Generator(MBG),用到了Mybatis-Generator-Core相關依賴,這裡通過一篇文章詳細地分析這個程式碼生成器的使用方式。本文編寫的時候使用的Mybatis-Generator版本為1.4.0,其他版本沒有進行過調研。

引入外掛

Mybatis-Generator的執行方式有很多種:

  • 基於mybatis-generator-core-x.x.x.jar和其XML配置檔案,通過命令列執行。
  • 通過AntTask結合其XML
    配置檔案執行。
  • 通過Maven外掛執行。
  • 通過Java程式碼和其XML配置檔案執行。
  • 通過Java程式碼和程式設計式配置執行。
  • 通過Eclipse Feature執行。

這裡只介紹通過Maven外掛執行和通過Java程式碼和其XML配置檔案執行這兩種方式,兩種方式有個特點:都要提前編寫好XML配置檔案。個人感覺XML配置檔案相對直觀,後文會花大量篇幅去說明XML配置檔案中的配置項及其作用。這裡先注意一點:預設的配置檔案為ClassPath:generatorConfig.xml

通過編碼和配置檔案執行

通過編碼方式去執行外掛先需要引入mybatis-generator-core依賴,編寫本文的時候最新的版本為:

<dependency>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-core</artifactId>
    <version>1.4.0</version>
</dependency>

假設編寫好的XML配置檔案是ClassPath下的generator-configuration.xml,那麼使用程式碼生成器的編碼方式大致如下:

List<String> warnings = new ArrayList<>();
// 如果已經存在生成過的檔案是否進行覆蓋
boolean overwrite = true;
File configFile = new File("ClassPath路徑/generator-configuration.xml");
ConfigurationParser cp = new ConfigurationParser(warnings);
Configuration config = cp.parseConfiguration(configFile);
DefaultShellCallback callback = new DefaultShellCallback(overwrite);
MyBatisGenerator generator = new MyBatisGenerator(config, callback, warnings);
generator.generate(null);

通過Maven外掛執行

如果使用Maven外掛,那麼不需要引入mybatis-generator-core依賴,只需要引入一個Maven的外掛mybatis-generator-maven-plugin

<plugins>
    <plugin>
        <groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-maven-plugin</artifactId>
        <version>1.4.0</version>
        <executions>
            <execution>
                <id>Generate MyBatis Artifacts</id>
                <goals>
                    <goal>generate</goal>
                </goals>
            </execution>
        </executions>
        <configuration>
            <!-- 輸出詳細資訊 -->
            <verbose>true</verbose>
            <!-- 覆蓋生成檔案 -->
            <overwrite>true</overwrite>
            <!-- 定義配置檔案 -->
            <configurationFile>${basedir}/src/main/resources/generator-configuration.xml</configurationFile>
        </configuration>
    </plugin>
</plugins>

mybatis-generator-maven-plugin的更詳細配置和可選引數可以參考:Running With Maven。外掛配置完畢之後,使用下面的命令即可執行:

mvn mybatis-generator:generate

XML配置檔案詳解

XML配置檔案才是Mybatis-Generator的核心,它用於控制程式碼生成的所有行為。所有非標籤獨有的公共配置的Key可以在mybatis-generator-corePropertyRegistry類中找到。下面是一個相對完整的配置檔案的模板:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>

  <properties resource="db.properties"/>

  <classPathEntry location="/Program Files/IBM/SQLLIB/java/db2java.zip" />

  <context id="DB2Tables" targetRuntime="MyBatis3">

    <jdbcConnection driverClass="COM.ibm.db2.jdbc.app.DB2Driver"
        connectionURL="jdbc:db2:TEST"
        userId="db2admin"
        password="db2admin">
    </jdbcConnection>

    <plugin type="org.mybatis.generator.plugins.SerializablePlugin"/>

    <commentGenerator>
        <property name="suppressDate" value="true"/>
        <property name="suppressAllComments" value="true"/>
    </commentGenerator>

    <javaTypeResolver>
      <property name="forceBigDecimals" value="false" />
    </javaTypeResolver>

    <javaModelGenerator targetPackage="test.model" targetProject="\MBGTestProject\src">
      <property name="enableSubPackages" value="true" />
      <property name="trimStrings" value="true" />
    </javaModelGenerator>

    <sqlMapGenerator targetPackage="test.xml"  targetProject="\MBGTestProject\src">
      <property name="enableSubPackages" value="true" />
    </sqlMapGenerator>

    <javaClientGenerator type="XMLMAPPER" targetPackage="test.dao"  targetProject="\MBGTestProject\src">
      <property name="enableSubPackages" value="true" />
    </javaClientGenerator>

    <table schema="DB2ADMIN" tableName="ALLTYPES" domainObjectName="Customer" >
      <property name="useActualColumnNames" value="true"/>
      <generatedKey column="ID" sqlStatement="DB2" identity="true" />
      <columnOverride column="DATE_FIELD" property="startDate" />
      <ignoreColumn column="FRED" />
      <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" />
    </table>

  </context>
</generatorConfiguration>

配置檔案中,最外層的標籤為<generatorConfiguration>,它的子標籤包括:

  • 0或者1個<properties>標籤,用於指定全域性配置檔案,下面可以通過佔位符的形式讀取<properties>指定檔案中的值。
  • 0或者N個<classPathEntry>標籤,<classPathEntry>只有一個location屬性,用於指定資料來源驅動包(jar或者zip)的絕對路徑,具體選擇什麼驅動包取決於連線什麼型別的資料來源。
  • 1或者N個<context>標籤,用於執行時的解析模式和具體的程式碼生成行為,所以這個標籤裡面的配置是最重要的。

下面分別列舉和分析一下<context>標籤和它的主要子標籤的一些屬性配置和功能。

context標籤

<context>標籤在mybatis-generator-core中對應的實現類為org.mybatis.generator.config.Context,它除了大量的子標籤配置之外,比較主要的屬性是:

  • idContext示例的唯一ID,用於輸出錯誤資訊時候作為唯一標記。
  • targetRuntime:用於執行程式碼生成模式。
  • defaultModelType:控制Domain類的生成行為。執行引擎為MyBatis3DynamicSql或者MyBatis3Kotlin時忽略此配置,可選值:
    • conditional:預設值,類似hierarchical,但是隻有一個主鍵的時候會合並所有屬性生成在同一個類。
    • flat:所有內容全部生成在一個物件中。
    • hierarchical:鍵生成一個XXKey物件,Blob等單獨生成一個物件,其他簡單屬性在一個物件中。

targetRuntime屬性的可選值比較多,這裡做個簡單的小結:

屬性 功能描述
MyBatis3DynamicSql 預設值,相容JDK8+MyBatis 3.4.2+,不會生成XML對映檔案,忽略<sqlMapGenerator>的配置項,也就是Mapper全部註解化,依賴於MyBatis Dynamic SQL類庫
MyBatis3Kotlin 行為類似於MyBatis3DynamicSql,不過相容Kotlin的程式碼生成
MyBatis3 提供基本的基於動態SQLCRUD方法和XXXByExample方法,會生成XML對映檔案
MyBatis3Simple 提供基本的基於動態SQLCRUD方法,會生成XML對映檔案
MyBatis3DynamicSqlV1 已經過時,不推薦使用

筆者偏向於把SQL檔案和程式碼分離,所以一般選用MyBatis3或者MyBatis3Simple。例如:

<context id="default" targetRuntime="MyBatis3">

<context>標籤支援0或N個<property>標籤,<property>的可選屬性有:

property屬性 功能描述 預設值 備註
autoDelimitKeywords 是否使用分隔符號括住資料庫關鍵字 false 例如MySQL中會使用反引號括住關鍵字
beginningDelimiter 分隔符號的開始符號 "
endingDelimiter 分隔符號的結束號 "
javaFileEncoding 檔案的編碼 系統預設值 來源於java.nio.charset.Charset
javaFormatter 類名和檔案格式化器 DefaultJavaFormatter JavaFormatterDefaultJavaFormatter
targetJava8 是否JDK8和啟動其特性 true
kotlinFileEncoding Kotlin檔案編碼 系統預設值 來源於java.nio.charset.Charset
kotlinFormatter Kotlin類名和檔案格式化器 DefaultKotlinFormatter KotlinFormatterDefaultKotlinFormatter
xmlFormatter XML檔案格式化器 DefaultXmlFormatter XmlFormatterDefaultXmlFormatter

jdbcConnection標籤

<jdbcConnection>標籤用於指定資料來源的連線資訊,它在mybatis-generator-core中對應的實現類為org.mybatis.generator.config.JDBCConnectionConfiguration,主要屬性包括:

屬性 功能描述 是否必須
driverClass 資料來源驅動的全類名 Y
connectionURL JDBC的連線URL Y
userId 連線到資料來源的使用者名稱 N
password 連線到資料來源的密碼 N

commentGenerator標籤

<commentGenerator>標籤是可選的,用於控制生成的實體的註釋內容。它在mybatis-generator-core中對應的實現類為org.mybatis.generator.internal.DefaultCommentGenerator,可以通過可選的type屬性指定一個自定義的CommentGenerator實現。<commentGenerator>標籤支援0或N個<property>標籤,<property>的可選屬性有:

property屬性 功能描述 預設值
suppressAllComments 是否生成註釋 false
suppressDate 是否在註釋中新增生成的時間戳 false
dateFormat 配合suppressDate使用,指定輸出時間戳的格式 java.util.Date#toString()
addRemarkComments 是否輸出表和列的Comment資訊 false

筆者建議保持預設值,也就是什麼註釋都不輸出,生成程式碼乾淨的實體。

javaTypeResolver標籤

<javaTypeResolver>標籤是<context>的子標籤,用於解析和計算資料庫列型別和Java型別的對映關係,該標籤只包含一個type屬性,用於指定org.mybatis.generator.api.JavaTypeResolver介面的實現類。<javaTypeResolver>標籤支援0或N個<property>標籤,<property>的可選屬性有:

property屬性 功能描述 預設值
forceBigDecimals 是否強制把所有的數字型別強制使用java.math.BigDecimal型別表示 false
useJSR310Types 是否支援JSR310,主要是JSR310的新日期型別 false

如果useJSR310Types屬性設定為true,那麼生成程式碼的時候型別對映關係如下(主要針對日期時間型別):

資料庫(JDBC)型別 Java型別
DATE java.time.LocalDate
TIME java.time.LocalTime
TIMESTAMP java.time.LocalDateTime
TIME_WITH_TIMEZONE java.time.OffsetTime
TIMESTAMP_WITH_TIMEZONE java.time.OffsetDateTime

引入mybatis-generator-core後,可以檢視JavaTypeResolver的預設實現為JavaTypeResolverDefaultImpl,從它的原始碼可以得知一些對映關係:

BIGINT --> Long
BIT --> Boolean
INTEGER --> Integer
SMALLINT --> Short
TINYINT --> Byte
......

有些時候,我們希望INTEGERSMALLINTTINYINT都對映為Integer,那麼我們需要覆蓋JavaTypeResolverDefaultImpl的構造方法:

public class DefaultJavaTypeResolver extends JavaTypeResolverDefaultImpl {

    public DefaultJavaTypeResolver() {
        super();
        typeMap.put(Types.SMALLINT, new JdbcTypeInformation("SMALLINT",
                new FullyQualifiedJavaType(Integer.class.getName())));
        typeMap.put(Types.TINYINT, new JdbcTypeInformation("TINYINT",
                new FullyQualifiedJavaType(Integer.class.getName())));
    }
}

注意一點的是這種自定義實現JavaTypeResolver介面的方式使用程式設計式執行MBG會相對方便,如果需要使用Maven外掛執行,那麼需要把上面的DefaultJavaTypeResolver類打包到外掛中。

javaModelGenerator標籤

<javaModelGenerator標籤>標籤是<context>的子標籤,主要用於控制實體(Model)類的程式碼生成行為。它支援的屬性如下:

屬性 功能描述 是否必須 備註
targetPackage 生成的實體類的包名 Y 例如club.throwable.model
targetProject 生成的實體類檔案相對於專案(根目錄)的位置 Y 例如src/main/java

<javaModelGenerator標籤>標籤支援0或N個<property>標籤,<property>的可選屬性有:

property屬性 功能描述 預設值 備註
constructorBased 是否生成一個帶有所有欄位屬性的建構函式 false MyBatis3Kotlin模式下忽略此屬性配置
enableSubPackages 是否允許通過Schema生成子包 false 如果為true,例如包名為club.throwable,如果Schemaxyz,那麼實體類檔案最終會生成在club.throwable.xyz目錄
exampleTargetPackage 生成的伴隨實體類的Example類的包名 - -
exampleTargetProject 生成的伴隨實體類的Example類檔案相對於專案(根目錄)的位置 - -
immutable 是否不可變 false 如果為true,則不會生成Setter方法,所有欄位都使用final修飾,提供一個帶有所有欄位屬性的建構函式
rootClass 為生成的實體類新增父類 - 通過value指定父類的全類名即可
trimStrings Setter方法是否對字串型別進行一次trim操作 false -

javaClientGenerator標籤

<javaClientGenerator>標籤是<context>的子標籤,主要用於控制Mapper介面的程式碼生成行為。它支援的屬性如下:

屬性 功能描述 是否必須 備註
type Mapper介面生成策略 Y <context>標籤的targetRuntime屬性為MyBatis3DynamicSql或者MyBatis3Kotlin時此屬性配置忽略
targetPackage 生成的Mapper介面的包名 Y 例如club.throwable.mapper
targetProject 生成的Mapper介面檔案相對於專案(根目錄)的位置 Y 例如src/main/java

type屬性的可選值如下:

  • ANNOTATEDMAPPERMapper介面生成的時候依賴於註解和SqlProviders(也就是純註解實現),不會生成XML對映檔案。
  • XMLMAPPERMapper介面生成介面方法,對應的實現程式碼生成在XML對映檔案中(也就是純對映檔案實現)。
  • MIXEDMAPPERMapper介面生成的時候複雜的方法實現生成在XML對映檔案中,而簡單的實現通過註解和SqlProviders實現(也就是註解和對映檔案混合實現)。

注意兩點:

  • <context>標籤的targetRuntime屬性指定為MyBatis3Simple的時候,type只能選用ANNOTATEDMAPPER或者XMLMAPPER
  • <context>標籤的targetRuntime屬性指定為MyBatis3的時候,type可以選用ANNOTATEDMAPPERXMLMAPPER或者MIXEDMAPPER

<javaClientGenerator>標籤支援0或N個<property>標籤,<property>的可選屬性有:

property屬性 功能描述 預設值 備註
enableSubPackages 是否允許通過Schema生成子包 false 如果為true,例如包名為club.throwable,如果Schemaxyz,那麼Mapper介面檔案最終會生成在club.throwable.xyz目錄
useLegacyBuilder 是否通過SQL Builder生成動態SQL false
rootInterface 為生成的Mapper介面新增父介面 - 通過value指定父介面的全類名即可

sqlMapGenerator標籤

<sqlMapGenerator>標籤是<context>的子標籤,主要用於控制XML對映檔案的程式碼生成行為。它支援的屬性如下:

屬性 功能描述 是否必須 備註
targetPackage 生成的XML對映檔案的包名 Y 例如mappings
targetProject 生成的XML對映檔案相對於專案(根目錄)的位置 Y 例如src/main/resources

<sqlMapGenerator>標籤支援0或N個<property>標籤,<property>的可選屬性有:

property屬性 功能描述 預設值 備註
enableSubPackages 是否允許通過Schema生成子包 false -

plugin標籤

<plugin>標籤是<context>的子標籤,用於引入一些外掛對程式碼生成的一些特性進行擴充套件,該標籤只包含一個type屬性,用於指定org.mybatis.generator.api.Plugin介面的實現類。內建的外掛實現見Supplied Plugins。例如:引入org.mybatis.generator.plugins.SerializablePlugin外掛會讓生成的實體類自動實現java.io.Serializable介面並且新增serialVersionUID屬性。

table標籤

<table>標籤是<context>的子標籤,主要用於配置要生成程式碼的資料庫表格,定製一些程式碼生成行為等等。它支援的屬性眾多,列舉如下:

屬性 功能描述 是否必須 備註
tableName 資料庫表名稱 Y 例如t_order
schema 資料庫Schema N -
catalog 資料庫Catalog N -
alias 表名稱標籤 N 如果指定了此值,則查詢列的時候結果格式為alias_column
domainObjectName 表對應的實體類名稱,可以通過.指定包路徑 N 如果指定了bar.User,則包名為bar,實體類名稱為User
mapperName 表對應的Mapper介面類名稱,可以通過.指定包路徑 N 如果指定了bar.UserMapper,則包名為barMapper介面類名稱為UserMapper
sqlProviderName 動態SQL提供類SqlProvider的類名稱 N -
enableInsert 是否允許生成insert方法 N 預設值為true,執行引擎為MyBatis3DynamicSql或者MyBatis3Kotlin時忽略此配置
enableSelectByPrimaryKey 是否允許生成selectByPrimaryKey方法 N 預設值為true,執行引擎為MyBatis3DynamicSql或者MyBatis3Kotlin時忽略此配置
enableSelectByExample 是否允許生成selectByExample方法 N 預設值為true,執行引擎為MyBatis3DynamicSql或者MyBatis3Kotlin時忽略此配置
enableUpdateByPrimaryKey 是否允許生成updateByPrimaryKey方法 N 預設值為true,執行引擎為MyBatis3DynamicSql或者MyBatis3Kotlin時忽略此配置
enableDeleteByPrimaryKey 是否允許生成deleteByPrimaryKey方法 N 預設值為true,執行引擎為MyBatis3DynamicSql或者MyBatis3Kotlin時忽略此配置
enableDeleteByExample 是否允許生成deleteByExample方法 N 預設值為true,執行引擎為MyBatis3DynamicSql或者MyBatis3Kotlin時忽略此配置
enableCountByExample 是否允許生成countByExample方法 N 預設值為true,執行引擎為MyBatis3DynamicSql或者MyBatis3Kotlin時忽略此配置
enableUpdateByExample 是否允許生成updateByExample方法 N 預設值為true,執行引擎為MyBatis3DynamicSql或者MyBatis3Kotlin時忽略此配置
selectByPrimaryKeyQueryId value指定對應的主鍵列提供列表查詢功能 N 執行引擎為MyBatis3DynamicSql或者MyBatis3Kotlin時忽略此配置
selectByExampleQueryId value指定對應的查詢ID提供列表查詢功能 N 執行引擎為MyBatis3DynamicSql或者MyBatis3Kotlin時忽略此配置
modelType 覆蓋<context>defaultModelType屬性 N <context>defaultModelType屬性
escapeWildcards 是否對萬用字元進行轉義 N -
delimitIdentifiers 標記匹配表名稱的時候是否需要使用分隔符去標記生成的SQL N -
delimitAllColumns 是否所有的列都新增分隔符 N 預設值為false,如果設定為true,所有列名會新增起始和結束分隔符

<table>標籤支援0或N個<property>標籤,<property>的可選屬性有:

property屬性 功能描述 預設值 備註
constructorBased 是否為實體類生成一個帶有所有欄位的建構函式 false 執行引擎為MyBatis3Kotlin的時候此屬性忽略
ignoreQualifiersAtRuntime 是否在執行時忽略別名 false 如果為true,則不會在生成表的時候把schemacatalog作為表的字首
immutable 實體類是否不可變 false 執行引擎為MyBatis3Kotlin的時候此屬性忽略
modelOnly 是否僅僅生成實體類 false -
rootClass 如果配置此屬性,則實體類會繼承此指定的超類 - 如果有主鍵屬性會把主鍵屬性在超類生成
rootInterface 如果配置此屬性,則實體類會實現此指定的介面 - 執行引擎為MyBatis3Kotlin或者MyBatis3DynamicSql的時候此屬性忽略
runtimeCatalog 指定執行時的Catalog - 當生成表和執行時的表的Catalog不一樣的時候可以使用該屬性進行配置
runtimeSchema 指定執行時的Schema - 當生成表和執行時的表的Schema不一樣的時候可以使用該屬性進行配置
runtimeTableName 指定執行時的表名稱 - 當生成表和執行時的表的表名稱不一樣的時候可以使用該屬性進行配置
selectAllOrderByClause 指定字句內容新增到selectAll()方法的order by子句之中 - 執行引擎為MyBatis3Simple的時候此屬性才適用
trimStrings 實體類的字串型別屬性會做trim處理 - 執行引擎為MyBatis3Kotlin的時候此屬性忽略
useActualColumnNames 是否使用列名作為實體類的屬性名 false -
useColumnIndexes XML對映檔案中生成的ResultMap使用列索引定義而不是列名稱 false 執行引擎為MyBatis3Kotlin或者MyBatis3DynamicSql的時候此屬性忽略
useCompoundPropertyNames 是否把列名和列備註拼接起來生成實體類屬性名 false -

<table>標籤還支援眾多的非property的子標籤:

  • 0或1個<generatedKey>用於指定主鍵生成的規則,指定此標籤後會生成一個<selectKey>標籤:
<!-- column:指定主鍵列 -->
<!-- sqlStatement:查詢主鍵的SQL語句,例如填寫了MySql,則使用SELECT LAST_INSERT_ID() -->
<!-- type:可選值為pre或者post,pre指定selectKey標籤的order為BEFORE,post指定selectKey標籤的order為AFTER -->
<!-- identity:true的時候,指定selectKey標籤的order為AFTER -->
<generatedKey column="id" sqlStatement="MySql" type="post" identity="true" />
  • 0或1個<domainObjectRenamingRule>用於指定實體類重新命名規則:
<!-- searchString中正則命中的實體類名部分會替換為replaceString -->
<domainObjectRenamingRule searchString="^Sys" replaceString=""/>
<!-- 例如 SysUser會變成User -->
<!-- 例如 SysUserMapper會變成UserMapper -->
  • 0或1個<columnRenamingRule>用於指定列重新命名規則:
<!-- searchString中正則命中的列名部分會替換為replaceString -->
<columnRenamingRule searchString="^CUST_" replaceString=""/>
<!-- 例如 CUST_BUSINESS_NAME會變成BUSINESS_NAME(useActualColumnNames=true) -->
<!-- 例如 CUST_BUSINESS_NAME會變成businessName(useActualColumnNames=false) -->
  • 0或N個<columnOverride>用於指定具體列的覆蓋對映規則:
<!-- column:指定要覆蓋配置的列 -->
<!-- property:指定要覆蓋配置的屬性 -->
<!-- delimitedColumnName:是否為列名新增定界符,例如`{column}` -->
<!-- isGeneratedAlways:是否一定生成此列 -->
<columnOverride column="customer_name" property="customerName" javaType="" jdbcType="" typeHandler="" delimitedColumnName="" isGeneratedAlways="">
   <!-- 覆蓋table或者javaModelGenerator級別的trimStrings屬性配置 -->
   <property name="trimStrings" value="true"/>
<columnOverride/>
  • 0或N個<ignoreColumn>用於指定忽略生成的列:
<ignoreColumn column="version" delimitedColumnName="false"/>

實戰

如果需要深度定製一些程式碼生成行為,建議引入mybatis-generator-core並且通過程式設計式執行程式碼生成方法,否則可以選用Maven外掛。假設我們在本地資料local有一張t_order表如下:

CREATE TABLE `t_order`
(
    id           BIGINT UNSIGNED PRIMARY KEY COMMENT '主鍵',
    order_id     VARCHAR(64)    NOT NULL COMMENT '訂單ID',
    create_time  DATETIME       NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '建立時間',
    amount       DECIMAL(10, 2) NOT NULL DEFAULT 0 COMMENT '金額',
    order_status TINYINT        NOT NULL DEFAULT 0 COMMENT '訂單狀態',
    UNIQUE uniq_order_id (`order_id`)
) COMMENT '訂單表';

假設專案的結構如下:

mbg-sample
  - main
   - java
    - club
     - throwable
   - resources

下面會基於此前提舉三個例子。編寫基礎的XML配置檔案:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!-- 驅動包絕對路徑 -->
    <classPathEntry
            location="I:\Develop\Maven-Repository\mysql\mysql-connector-java\5.1.48\mysql-connector-java-5.1.48.jar"/>

    <context id="default" targetRuntime="這裡選擇合適的引擎">

        <property name="javaFileEncoding" value="UTF-8"/>

        <!-- 不輸出註釋 -->
        <commentGenerator>
            <property name="suppressDate" value="true"/>
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>

        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/local"
                        userId="root"
                        password="root">
        </jdbcConnection>


        <!-- 不強制把所有的數字型別轉化為BigDecimal -->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>

        <javaModelGenerator targetPackage="club.throwable.entity" targetProject="src/main/java">
            <property name="enableSubPackages" value="true"/>
        </javaModelGenerator>

        <sqlMapGenerator targetPackage="mappings" targetProject="src/main/resources">
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>

        <javaClientGenerator type="這裡選擇合適的Mapper型別" targetPackage="club.throwable.dao" targetProject="src/main/java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>

        <table tableName="t_order"
               enableCountByExample="false"
               enableDeleteByExample="false"
               enableSelectByExample="false"
               enableUpdateByExample="false"
               domainObjectName="Order"
               mapperName="OrderMapper">
            <generatedKey column="id" sqlStatement="MySql"/>
        </table>
    </context>
</generatorConfiguration>

純註解

使用純註解需要引入mybatis-dynamic-sql

<dependency>
    <groupId>org.mybatis.dynamic-sql</groupId>
    <artifactId>mybatis-dynamic-sql</artifactId>
    <version>1.1.4</version>
</dependency>

需要修改兩個位置:

<context id="default" targetRuntime="MyBatis3DynamicSql">
...

<javaClientGenerator type="ANNOTATEDMAPPER"
...

執行結果會生成三個類:

// club.throwable.entity
public class Order {
    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    private Long id;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    private String orderId;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    private Date createTime;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    private BigDecimal amount;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    private Byte orderStatus;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public Long getId() {
        return id;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public void setId(Long id) {
        this.id = id;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public String getOrderId() {
        return orderId;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public Date getCreateTime() {
        return createTime;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public BigDecimal getAmount() {
        return amount;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public void setAmount(BigDecimal amount) {
        this.amount = amount;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public Byte getOrderStatus() {
        return orderStatus;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public void setOrderStatus(Byte orderStatus) {
        this.orderStatus = orderStatus;
    }
}

// club.throwable.dao
public final class OrderDynamicSqlSupport {
    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final Order order = new Order();

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final SqlColumn<Long> id = order.id;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final SqlColumn<String> orderId = order.orderId;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final SqlColumn<Date> createTime = order.createTime;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final SqlColumn<BigDecimal> amount = order.amount;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final SqlColumn<Byte> orderStatus = order.orderStatus;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final class Order extends SqlTable {
        public final SqlColumn<Long> id = column("id", JDBCType.BIGINT);

        public final SqlColumn<String> orderId = column("order_id", JDBCType.VARCHAR);

        public final SqlColumn<Date> createTime = column("create_time", JDBCType.TIMESTAMP);

        public final SqlColumn<BigDecimal> amount = column("amount", JDBCType.DECIMAL);

        public final SqlColumn<Byte> orderStatus = column("order_status", JDBCType.TINYINT);

        public Order() {
            super("t_order");
        }
    }
}

@Mapper
public interface OrderMapper {
    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    BasicColumn[] selectList = BasicColumn.columnList(id, orderId, createTime, amount, orderStatus);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @SelectProvider(type=SqlProviderAdapter.class, method="select")
    long count(SelectStatementProvider selectStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @DeleteProvider(type=SqlProviderAdapter.class, method="delete")
    int delete(DeleteStatementProvider deleteStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @InsertProvider(type=SqlProviderAdapter.class, method="insert")
    @SelectKey(statement="SELECT LAST_INSERT_ID()", keyProperty="record.id", before=true, resultType=Long.class)
    int insert(InsertStatementProvider<Order> insertStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @SelectProvider(type=SqlProviderAdapter.class, method="select")
    @Results(id="OrderResult", value = {
        @Result(column="id", property="id", jdbcType=JdbcType.BIGINT, id=true),
        @Result(column="order_id", property="orderId", jdbcType=JdbcType.VARCHAR),
        @Result(column="create_time", property="createTime", jdbcType=JdbcType.TIMESTAMP),
        @Result(column="amount", property="amount", jdbcType=JdbcType.DECIMAL),
        @Result(column="order_status", property="orderStatus", jdbcType=JdbcType.TINYINT)
    })
    Optional<Order> selectOne(SelectStatementProvider selectStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @SelectProvider(type=SqlProviderAdapter.class, method="select")
    @Results(id="OrderResult", value = {
        @Result(column="id", property="id", jdbcType=JdbcType.BIGINT, id=true),
        @Result(column="order_id", property="orderId", jdbcType=JdbcType.VARCHAR),
        @Result(column="create_time", property="createTime", jdbcType=JdbcType.TIMESTAMP),
        @Result(column="amount", property="amount", jdbcType=JdbcType.DECIMAL),
        @Result(column="order_status", property="orderStatus", jdbcType=JdbcType.TINYINT)
    })
    List<Order> selectMany(SelectStatementProvider selectStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @UpdateProvider(type=SqlProviderAdapter.class, method="update")
    int update(UpdateStatementProvider updateStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default long count(CountDSLCompleter completer) {
        return MyBatis3Utils.countFrom(this::count, order, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int delete(DeleteDSLCompleter completer) {
        return MyBatis3Utils.deleteFrom(this::delete, order, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int deleteByPrimaryKey(Long id_) {
        return delete(c -> 
            c.where(id, isEqualTo(id_))
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int insert(Order record) {
        return MyBatis3Utils.insert(this::insert, record, order, c ->
            c.map(id).toProperty("id")
            .map(orderId).toProperty("orderId")
            .map(createTime).toProperty("createTime")
            .map(amount).toProperty("amount")
            .map(orderStatus).toProperty("orderStatus")
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int insertSelective(Order record) {
        return MyBatis3Utils.insert(this::insert, record, order, c ->
            c.map(id).toProperty("id")
            .map(orderId).toPropertyWhenPresent("orderId", record::getOrderId)
            .map(createTime).toPropertyWhenPresent("createTime", record::getCreateTime)
            .map(amount).toPropertyWhenPresent("amount", record::getAmount)
            .map(orderStatus).toPropertyWhenPresent("orderStatus", record::getOrderStatus)
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default Optional<Order> selectOne(SelectDSLCompleter completer) {
        return MyBatis3Utils.selectOne(this::selectOne, selectList, order, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default List<Order> select(SelectDSLCompleter completer) {
        return MyBatis3Utils.selectList(this::selectMany, selectList, order, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default List<Order> selectDistinct(SelectDSLCompleter completer) {
        return MyBatis3Utils.selectDistinct(this::selectMany, selectList, order, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default Optional<Order> selectByPrimaryKey(Long id_) {
        return selectOne(c ->
            c.where(id, isEqualTo(id_))
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int update(UpdateDSLCompleter completer) {
        return MyBatis3Utils.update(this::update, order, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    static UpdateDSL<UpdateModel> updateAllColumns(Order record, UpdateDSL<UpdateModel> dsl) {
        return dsl.set(id).equalTo(record::getId)
                .set(orderId).equalTo(record::getOrderId)
                .set(createTime).equalTo(record::getCreateTime)
                .set(amount).equalTo(record::getAmount)
                .set(orderStatus).equalTo(record::getOrderStatus);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    static UpdateDSL<UpdateModel> updateSelectiveColumns(Order record, UpdateDSL<UpdateModel> dsl) {
        return dsl.set(id).equalToWhenPresent(record::getId)
                .set(orderId).equalToWhenPresent(record::getOrderId)
                .set(createTime).equalToWhenPresent(record::getCreateTime)
                .set(amount).equalToWhenPresent(record::getAmount)
                .set(orderStatus).equalToWhenPresent(record::getOrderStatus);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int updateByPrimaryKey(Order record) {
        return update(c ->
            c.set(orderId).equalTo(record::getOrderId)
            .set(createTime).equalTo(record::getCreateTime)
            .set(amount).equalTo(record::getAmount)
            .set(orderStatus).equalTo(record::getOrderStatus)
            .where(id, isEqualTo(record::getId))
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int updateByPrimaryKeySelective(Order record) {
        return update(c ->
            c.set(orderId).equalToWhenPresent(record::getOrderId)
            .set(createTime).equalToWhenPresent(record::getCreateTime)
            .set(amount).equalToWhenPresent(record::getAmount)
            .set(orderStatus).equalToWhenPresent(record::getOrderStatus)
            .where(id, isEqualTo(record::getId))
        );
    }
}

極簡XML對映檔案

極簡XML對映檔案生成只需要簡單修改配置檔案:

<context id="default" targetRuntime="MyBatis3Simple">
...

<javaClientGenerator type="XMLMAPPER"
...

生成三個檔案:

// club.throwable.entity
public class Order {
    private Long id;

    private String orderId;

    private Date createTime;

    private BigDecimal amount;

    private Byte orderStatus;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public BigDecimal getAmount() {
        return amount;
    }

    public void setAmount(BigDecimal amount) {
        this.amount = amount;
    }

    public Byte getOrderStatus() {
        return orderStatus;
    }

    public void setOrderStatus(Byte orderStatus) {
        this.orderStatus = orderStatus;
    }
}

// club.throwable.dao
public interface OrderMapper {
    int deleteByPrimaryKey(Long id);

    int insert(Order record);

    Order selectByPrimaryKey(Long id);

    List<Order> selectAll();

    int updateByPrimaryKey(Order record);
}

// mappings
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="club.throwable.dao.OrderMapper">
    <resultMap id=&q