mybatis各階段的詳解

2022 年 5 月 10 日
筆記
資料庫

1 本階段的需要注意的幾個點

1,首先是在核心配置文件裡面的內容：

配置的順序，不配則不用管，配則必須按順序來！！！！
properties?,
settings?,
typeAliases?,
typeHandlers?,
objectFactory?,
objectWrapperFactory?,
reflectorFactory?,
plugins?,environments?,
databaseIdProvider?,
mappers?.–>

比如我們在引入了jdbc的配置文件使用了properties標籤，引入jdbc有什麼好處？，可以在配置文件中統一管理
內容而不是在很多個文件改來改去，而且在核心配置文件中把資料庫連接相關的寫死，顯然是硬編碼的所以我們用配置文件代替 nice！！！

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis_db
jdbc.username=root
jdbc.password=kobedu
#為了解決重名的問題和風險 使用前綴jdbc. 見名示意

你可能注意到了上面的寫法用前綴jdbc. 可以很好地將他們與其他的變數區分開，（可以從名字很容易看出是jdbc相關的數據，不至於和同名變數搞混因為username這種可能
不止會出現在資料庫的連接）

1，在核心配置文件中引入jdbc的配置文件

    <properties resource="jdbc.properties"/>
         <typeAliases>
              <package name="com.kobedu.com.kobedu.mybatis.pojo"/>
         </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/> 
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url"
                          value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

上面的程式碼中引入配置文件的部分為可以從上面看到寫法：

2,在核心的配置文件中設置類的別名

下面這段就是用來設置類的別名：


<typeAliases>
    <package name="com.kobedu.com.kobedu.mybatis.pojo"/>
</typeAliases>

那麼問題來了，為什麼要有類的別名這種操作？？

因為在映射文件中每次都要寫全類名顯然有點麻煩比如下面這樣：


<mapper namespace="com.kobedu.com.kobedu.com.kobedu.mybatis.mapper.UserMapper">
    <insert id="insertUser">
        insert into t_user values (null,"旺財","20")
    </insert>
</mapper>

一個項目是會有很多個映射文件的為了方便，所以類別名就出現了。可以在核心配置文件寫介面類和對應的別名


<typeAliases>
    <typeAlias type="com.kobedu.com.kobedu.com.kobedu.mybatis.pojo.User" alias="User"/>
</typeAliases>

這樣就可以在映射文件的命名空間里可以直接寫User（對大小沒有要求也可以是user; 其實可以比這更加簡單，也是我們在實際開發中常用的寫法
就是將整個包寫成別名的形式，如果不寫alias屬性默認為類名（不區分大小寫），這樣就容易多了，我們只需一行程式碼，便可以在所有的映射文件命名空間
中直接寫對應的類名


<typeAliases>
    <typeAlias pack="com.kobedu.com.kobedu.mybatis.pojo"/>
</typeAliases>

3、在核心配置中引入映射文件

引入核心的配置文件

<mappers>
    <mapper resource="mappers/UserMapper.xml"></mapper>
</mappers>

首先需要思考的這裡是映射文件的引入，我們正常的一個項目的資料庫是有很多個表組成的那麼每一張表對應一個mapper介面，每個介面對應一個映射文件，那麼就需要導入大量的映射文件，還容易漏掉–>


<mappers>
    <package name="com.kobedu.com.kobedu.mybatis.mapper"/>
</mappers>

上面這種以包的形式的導入非常方便，不用每次新建一個介面就要導入它的映射文件，但是上面這種寫法需要注意一些問題：

在當前的resource目錄下建包（新建文件然後是文件名 com/kobedu/com.kobedu.mybatis/mapper –>enter）
用上面方式建的包必須要和mapper介面所在的包同名
在包里的映射文件必須和介面類同名

4、查詢時需要返回類型

如果你在映射文件中編寫查詢語句的sql,但是粗心的你忘記了設置返回類型會在控制台拋異常且會看到這樣的說明：
It’s likely that neither a Result Type nor a Result Map was specified.

下面只是指定返回類型的一種方式：resultType,還有 resultMap
它們的區別：

resultType ：設置默認的映射關係(欄位名和屬性一致的情況)
resultMap : 設置自定義的映射關係(欄位名和屬性名不一致或一對多或多對一)

查詢的標籤必須指定resultType或resultMap


<select id="getUserList" resultType="com.kobedu.com.kobedu.com.kobedu.mybatis.pojo.User">
    select * from t_user
</select>

2、mybtis獲取參數的兩種方式（重點）

com.kobedu.mybatis 獲取參數的兩種方式：${} 和 #{}

${}:本質字元串的拼接（JDBC原生中的字元串拼接）
和 #{}：本質佔位符

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//com.kobedu.mybatis.org//DTD Mapper 3.0//EN"
        "//com.kobedu.mybatis.org/dtd/com.kobedu.mybatis-3-mapper.dtd">
<mapper namespace="com.kobedu.com.kobedu.mybatis.mapper.ParameterMapper">

    <select id="getUserById" resultType="User">
        select * from t_user where userName=#{username}
    </select>

</mapper>

上面是使用了 #{}寫法相當於原生jdbc的佔位符，這個前面已經提到過了所以不多贅述，需要注意的是#{}裡面的變數名可以是任意的username規範顯然很好，但是aaaa也沒錯因為只是用來佔位的；
還有就是在使用${}時注意”單引號問題，因為${}是字元拼接的方式，所以需要注意！！

傳輸參數時有多個參數時

    <select id="getUserByUsernameAndPassword" resultType="User">
       select * from t_user where userName=#{username} and password=#{password}
   </select>

在測試程式碼里通過傳入兩個參數分別為 username和password 但是在上面程式碼的（映射文件里的部分程式碼）執行失敗，（sql語句未能解析）
報錯：
Cause: org.apache.ibatis.binding.BindingException: Parameter ‘username’ not found. Available parameters are [arg1, arg0, param1, param2]

可以從錯誤提示的資訊不難發現我們的參數在映射文件里未能真正地接受到，可以用[arg1, arg0, param1, param2] 的方式獲取，mybatis將參數放到map容器可以通過建arg0,agr1..的方式
獲取參數（也可以是param1,param2..）
將上面的程式碼改動：

     <select id="getUserByUsernameAndPassword" resultType="User">
        select * from t_user where userName=#{arg0} and password=#{arg1}
    </select>

需要注意的是：使用${}時需要手動添加”才能正常訪問，因為他的處理方式是字元串的拼接

class test{
    @Test
    public void selectUser(){
        ParameterMapper parameterMapper = SqlSessionUtils.getSqlSession().getMapper(ParameterMapper.class);
        User userById = parameterMapper.getUserByUsernameAndPassword("旺財","cwlz");
        System.out.println(userById);
    }
}

做了改動之後結果很感人！！
User{id=6, userName=’旺財’, age=20, password=’cwlz’}

若mapper介面的參數有多個時可以手動添加到map集合

可以直接通過鍵訪問相對應的值（通過自己的方式訪問到數據，上面的形式是mybatis默認提供的map和mybatis默認的提取指的方式 arg0，arg2…）
當需要傳多個參數時將他們放到一個map容器，然後將map傳給對應的方法（模擬mybatis的做法，就可以在sql語句中直接通過鍵訪問到值）程式碼如下：

class Test{ 
@Test
    public void longinTest(){
        ParameterMapper parameterMapper = SqlSessionUtils.getSqlSession().getMapper(ParameterMapper.class);
        Map<String,Object> userInfo = new HashMap<>();
        userInfo.put("username","旺財");
        userInfo.put("password","cwlz");
        User userById = parameterMapper.login(userInfo);
        System.out.println(userById);
        if (userById!=null) {
            System.out.println("登錄成功！");
        }else{
            System.out.println("用戶名或密碼錯誤");
        }
    }
}

映射文件中的部分程式碼：

    <select id="login" resultType="User">
        select * from t_user where userName=#{username} and password=#{password}
    </select>

通過鍵直接獲取值，注意：使用${}時不要忘了單引號！！！！

當參數以實體對象的形式傳參時如何解決？
只需要通過#{}以屬性名的方式訪問！

class Test{ 
@Test
    public void longinTest2(){
        ParameterMapper parameterMapper = SqlSessionUtils.getSqlSession().getMapper(ParameterMapper.class);
        User userById = parameterMapper.loginByUser(new User(null,"旺財",21,'cwlz'));
        if (userById!=null) {
            System.out.println("登錄成功！");
            System.out.println(userById);
        }else{
            System.out.println("用戶名或密碼錯誤");
        }
    }
}

小提醒： 在接受以實體類對象的參數時在sql語句中的屬性名一定要和實體類定義時屬性的名一樣！！
    比如在實體類的定義時用戶名是這樣定義的 private String userName ;但是在映射文件中#{username} 就會報錯：
     Error querying database.  Cause: org.apache.ibatis.reflection.ReflectionException: There is no getter for property named 'username' in 'class com.kobedu.com.kobedu.mybatis.pojo.User'

所以程式碼的編寫一定要規範,才能減少這種錯誤！！！

使用註解的方式傳遞參數：(以後開發就用它)

在聲明方法時在參數前用註解 @Param(“參數名”)

public interface ParameterMapper {
    //用於測試使用註解的傳參方式
    User testZhuJie(@Param("z_username") String username, @Param("z_password") String password);
}

映射文件中的部分程式碼：（取參數時參數名和方法聲明時的註解的中的參數名一一對應）

    <select id="testZhuJie" resultType="User">
        select * from t_user where userName=#{z_username} and password=#{z_password}
    </select>

小提示：如果映射文件中的參數的名如果和註解中的參數名不一一對應則會報錯：
    Cause: org.apache.ibatis.binding.BindingException: Parameter 'username' not found. Available parameters are [z_username, param1, z_password, param2]
    可以從提示看出是參數找不到（參數名寫錯）！！！

一定要和註解中的參數名一一對應！！！

各種查詢功能

查詢功能
    1. 若查詢出的數據只有一條，可以通過實體類對象接收或者集合類接收
    2. 若查詢出的數據有多條可以通過List集合接收，一定不能通過實體類對象接收，此時會拋異常TooManyResultsException:(就是預期的結果是一個或者null，但是發現多個就會拋出此類異常)

如果查詢的結果只有一個，也可以通過Map集合接收，欄位名為鍵欄位的值為值：{password=0000, id=3, userName=圖區, age=20}

MyBatis 有默認的類型別名，可以在官方文檔中查看！

java.lang.Ingeger –> int ,Integer

int –> _int,_Integer

Map –> map

String –> string

以Map集合接收多條數據

首先我們測試了 Map<String,Object> getAllUser(); 像這樣接收多個數據會報錯TooManyResultsException
然後可以用List接收多條數據：List<Map<String,Object>> getAllUser();結果如下：

[{password=1234, id=1, userName=鎖哥, age=21}, {password=3211, id=2, userName=仁王, age=21}, {password=0000, id=3, userName=圖區, age=20}, {password=kkkk, id=4, userName=旦羅, age=22}, {password=kobedu, id=5, userName=kobe, age=21}, {password=cwlz, id=6, userName=旺財, age=20}, {password=cwlz, id=9, userName=miss, age=20}, {password=cwlz, id=10, userName=1024, age=20}]

以map的形式接收多條數據（重點）

@MapKey("id") 
Map<String,Object> getAllUser();

注意：

小提示：
  將多條數據用Map接收可以使用@MapKey 將一個欄位（在表中獨一無二（通常為主鍵））設為map的鍵將每一條數據作為值，用Map集合接收！

特殊sql的執行

1#{} 底層為佔位符原理
${} 字元串拼接原理

1,模糊查詢

‘%${username}’
concat(‘%’,#{username},’%’)
“%”#{username}”%” (這個最常用)

2,批量刪除

#{} 是自動會添加''的

所以在批量刪除的案例：需要注意的是不能使用#{} 因為它是會自動添加” 所以在批量刪除的語句中我們要使用${}

 <delete id="deleteMore">
    delete from t_user where id in (${ids})
</delete>

3,動態設置表名

select * from ${tableName} 
    不能使用#{} 會有錯

4,添加功能獲取自增的主鍵

用的場景：

useGeneratedKeys:設置當前的標籤中的sql使用了自增主鍵
keyProperty:將自增主鍵的值賦值給傳輸到映射文件中參數的某個屬性

自定義映射

1,resultMap處理欄位和屬性的映射關係

若欄位和屬性名不一致，則可以通過resultMap設置自定義映射

為欄位起別名，保持和屬性名一致
設置全局配置將 _ 自動映射為駝峰
使用自定義映射 resultMap

1,為欄位起別名

2,設置全局配置

在mybatis的核心配置文件用下面的程式碼將資料庫中命名的規範 (user_name) 轉換為 java中的命名規範 (userName)

    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

3,通過resultMap設置自定義映射關係

就是手動設置屬性與欄位的映射關係：
如果設置了手動的設置屬性和欄位的映射關係，注意主鍵使用 id 標籤，普通欄位使用 result標籤，就算屬性和欄位名一一對應，只要
用了這種方式就必須要寫全！！！

<!--type 映射關係中的實體類-->
<resultMap id="user_table_map" type="User">
<!--        主鍵欄位-->
        <id property="id" column="id"></id>
<!--        普通欄位 
            property 映射關係中的屬性名，column 欄位名，當前sql查詢出來的欄位名
-->
        <result property="userName" column="user_name"></result>
        <result property="age" column="age"></result>
        <result property="password" column="password"></result>
    </resultMap>
    <select id="getAllUser" resultMap="user_table_map">
        select * from t_user
    </select>

映射

表和表之間是有映射的，那麼表所對應的實體類之間也是要有映射的，處理多對一的映射關係

級聯屬性賦值
association
分步查詢

一對多的查詢:

案例：按照部門的編號查詢部門需要返回該部門的員工列表

<resultMap id="getDeptAndUserByDidMap" type="Dept">
        <id property="id" column="id"></id>
        <result property="deptName" column="dept_name"></result>
        <collection property="users" ofType="User">
            <id property="id" column="id"></id>
            <result property="userName" column="user_name"></result>
            <result property="age" column="age"></result>
            <result property="password" column="password"></result>
        </collection>
    </resultMap>

    <select id="getDeptAndUserByDid" resultMap="getDeptAndUserByDidMap">
        select * from t_dept left join t_user on t_dept.id = t_user.did where t_dept.id = #{did};
    </select>

通過分步查詢實現:

mybatis 中的動態查詢

😎
多條件的查詢

if

if 根據標籤中test的屬性所對應的表達式決定標籤中的內容是否拼接到sql語句中

  <select id="getUserByCondition" resultType="User">
        select * from t_user where 'cwlz'='cwlz'

        <if test="userName != null and userName != '' ">
            and user_name = #{userName}
        </if>
        <if test="age != null and age != '' ">
            and age = #{age}
        </if>


    </select>

上面的where後面的 1=1 是細節，因為當where後面的條件都為空時就成了 select * from t_user where
顯然這種sql語句是有問題的，還有一種情況就是當userName為null時語句就成了 select * from t_user where and age=#{age}
這也是錯的，所以在where後加一個恆成立的條件不僅不會影響查詢結果，而且沒有會在特定情況時sql語句是會報錯的所以很有必要

where

where 當where標籤中有內容時，會自動生成where關鍵字，並且將內容前多餘的and 或者or去掉
當where中沒有內容時，此時where標籤沒有任何效果就是不會生成關鍵字注意：在寫條件時不能在後面加and or 這個在下一條語句無效時mybatis不會幫你去掉！

trim

prifix|suffix : 將trim標籤中在內容前面或後面添加指定內容
suffixOverrides|prefixOverrides: 將trim標籤中內容前面或後面去掉指定內容

    <select id="getUserByCondition" resultType="User">
        select * from t_user
        <trim prefix="where" suffix="" prefixOverrides="" suffixOverrides="and|or" >
            <if test="userName != null and userName != '' ">
                user_name = #{userName} and
            </if>
            <if test="age != null and age != '' ">
                age = #{age} and
            </if>
            <if test="password != null and password !=''">
               password = #{password}
            </if>

        </trim>
    </select>

choose when otherwise

相當於 if else

choose:用於包when otherwise
when: 相當於if
otherwise: else

    <select id="getUserByCondition" resultType="User">
        select * from t_user
       <where>
            <choose>
                <when test="userName != null and userName != '' ">
                    user_name = #{userName}
                </when>
                <when test="age != null and age != '' ">
                    age = #{age}
                </when>
                <when test="password != null and password != '' ">
                    password = #{password}
                </when>

                <otherwise>
                    did = 1
                </otherwise>

            </choose>
        </where>
    </select>

foreach

一個案例 –>就是當我們需要批量刪除一些東西時（參數以數組的形式傳入）

  <delete id="deletesByIds" >
       delete from t_user where id in
        (
            <foreach collection="ids" item="id" separator=",">
                #{id}
            </foreach>
            )
   </delete>

collection 是需要遍歷的集合
item 代表當前的
separator 分隔
open 以什麼開始，在上面案例中的括弧可以 open=”(” 這樣寫
close 以什麼結束，在上面案例中的括弧可以 open=”)” 這樣寫

  <delete id="deletesByIds" >
       delete from t_user where id in
            <foreach collection="ids" item="id" separator="or" open="(" close=")">
                id = #{id}
            </foreach>
   </delete>

sql

sql 片段: 在我們的查詢語句不能在實際開發中也一直寫 *；因為我們要按需查找，不必將不需要的也查詢出來,我們可以將我們平常查詢次數較多的欄位
放在sql片段內，可以在需要查詢時直接進行引用！

 <sql id="sqldept"> id,dept_name</sql>
   <select id="getDeptAndById" resultMap="m2">
       select <include refid="sqldept"></include> from t_dept where id = #{did}
   </select>

快取

快取，這個術語我們聽過很多次，在web階段時訪問網頁時有快取機制！
現在sql的查詢時也有快取機制，有一級快取，一級快取是默認開啟的，一級快取的範圍時sqlSession，將我們查詢到的數據先進行快取，若下次有相同的查詢時不用重新
訪問資料庫，可以直接從快取中取出！！！！

使一級快取失效的情況

不同的sqlSession對應不同的一級快取
同一個SqlSession但是查詢條件不同
同一個SqlSession兩次的查詢期間執行了任何一次增刪改操作
同一個SqlSession兩次查詢期間手動清空了快取

手動清空快取 sqlSession.clearCache();

一級快取是默認使用的，而二級快取需要手動開啟！

二級快取

二級快取的相關配置

在mapper配置文件中添加cache標籤可以設置一些屬性：

eviction屬性：快取回收策略
- LRU 最近最少使用的：移除最長時間不被使用的對象。
- FIFO 先進先出：按對象進入快取的順序來移除他們。
- SOFT 軟引用：移除基於垃圾回收器狀態和弱引用規則的對象。
- WEAK 弱引用：更積極地移除基於垃圾回收器狀態和弱引用規則的對象。
  默認為LRU
flushInterval屬性：刷新間隔，單位毫秒
默認情況是不設置的，也就是說沒有刷新間隔，快取僅僅調用語句時刷新
size屬性: 引用數目，正整數。
代表快取最多可以存儲多少個對象，太大容易導致記憶體溢出
readOnly：只讀 true/false
- true 只讀快取：會給所有的調用者返回快取對象的相同實例。因此這些對象不能被修改。這提供了很重要的性能優勢
- false 讀寫快取: 會返回快取對象的拷貝（通過序列化）。這回慢些，但是安全，因此默認是FALSE

談快取

一級快取的作用域是一個sqlsession內;
二級快取的作用域是針對mapper進行快取

MyBatis快取查詢的順序

先查詢二級快取，因為二級快取中可能會有其他程式已經查出來的數據，可以拿來直接使用。
如果二級快取沒有命中，在查詢一級快取
如果一級快取也沒有命中，則查詢資料庫
SqlSession 關閉之後，一級快取中的數據會寫入二級快取

整合EHCache

<!-- Mybatis EHCache整合包 -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.2.1</version>
</dependency>
<!-- slf4j日誌門面的一個具體實現 -->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

MyBatis的逆向工程

正向工程：先創建java實體類，由框架負責根據實體類生成資料庫表。 Hibernate是支援正向工程的。
逆向工程：先創建資料庫表，有框架負責根據資料庫表，反向生成如下資源：
- java實體類
- Mapper介面
- Mapper映射文件

MyBatis逆向工程

逆向工程就是不難理解,我們之前都是由實體類到資料庫，而逆向類就是通過資料庫表生成實體類，

正向工程：先創建java實體類，有框架負責根據實體類生成資料庫表。
逆向工程：先創建資料庫表，有框架負責根據資料庫表，反向生成java實體類
- java實體類
  - Mapper介面
  - Mapper映射文件

創建逆向工程的步驟

添加依賴和插件

<dependencies>
	<!-- MyBatis核心依賴包 -->
	<dependency>
		<groupId>org.mybatis</groupId>
		<artifactId>mybatis</artifactId>
		<version>3.5.9</version>
	</dependency>
	<!-- junit測試 -->
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.13.2</version>
		<scope>test</scope>
	</dependency>
	<!-- MySQL驅動 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>8.0.27</version>
	</dependency>
	<!-- log4j日誌 -->
	<dependency>
		<groupId>log4j</groupId>
		<artifactId>log4j</artifactId>
		<version>1.2.17</version>
	</dependency>
</dependencies>
<!-- 控制Maven在構建過程中相關配置 -->
<build>
	<!-- 構建過程中用到的插件 -->
	<plugins>
		<!-- 具體插件，逆向工程的操作是以構建過程中插件形式出現的 -->
		<plugin>
			<groupId>org.mybatis.generator</groupId>
			<artifactId>mybatis-generator-maven-plugin</artifactId>
			<version>1.3.0</version>
			<!-- 插件的依賴 -->
			<dependencies>
				<!-- 逆向工程的核心依賴 -->
				<dependency>
					<groupId>org.mybatis.generator</groupId>
					<artifactId>mybatis-generator-core</artifactId>
					<version>1.3.2</version>
				</dependency>
				<!-- 資料庫連接池 -->
				<dependency>
					<groupId>com.mchange</groupId>
					<artifactId>c3p0</artifactId>
					<version>0.9.2</version>
				</dependency>
				<!-- MySQL驅動 -->
				<dependency>
					<groupId>mysql</groupId>
					<artifactId>mysql-connector-java</artifactId>
					<version>8.0.27</version>
				</dependency>
			</dependencies>
		</plugin>
	</plugins>
</build>

創建MyBatis的核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "//mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="jdbc.properties"/>
    <typeAliases>
        <package name=""/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name=""/>
    </mappers>
</configuration>

創建逆向工程的配置文件

文件名必須是：generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "//mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--
    targetRuntime: 執行生成的逆向工程的版本
    MyBatis3Simple: 生成基本的CRUD（清新簡潔版）
    MyBatis3: 生成帶條件的CRUD（奢華尊享版）
    -->
    <context id="DB2Tables" targetRuntime="MyBatis3">
        <!-- 資料庫的連接資訊 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/mybatis_db"
                        userId="root"
                        password="123456">
        </jdbcConnection>
        <!-- javaBean的生成策略-->
        <javaModelGenerator targetPackage="com.atguigu.mybatis.pojo" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- SQL映射文件的生成策略 -->
        <sqlMapGenerator targetPackage="com.atguigu.mybatis.mapper"
                         targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
        <!-- Mapper介面的生成策略 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.atguigu.mybatis.mapper" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>
        <!-- 逆向分析的表 -->
        <!-- tableName設置為*號，可以對應所有表，此時不寫domainObjectName -->
        <!-- domainObjectName屬性指定生成出來的實體類的類名 -->
        <table tableName="t_emp" domainObjectName="Emp"/>
        <table tableName="t_dept" domainObjectName="Dept"/>
    </context>
</generatorConfiguration>

執行插件的generate目標

在maven中找到插件下的generate並執行它你就會發現他自動幫你生成了java的實體類！

QBC

逆向工程有兩個版本簡單版和加強版
實際開發中使用的大都是加強版，可以按條件進行增刪改查！

對逆向工廠的操作的相關回顧！

分頁插件

引入依賴

<!-- //mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>5.2.0</version>
</dependency>

配置分頁插件(在核心配置文件中)

<plugins>
	<!--設置分頁插件-->
	<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

Tags: 資料庫