MyBatis を使用して OceanBase Cloud データベースに接続するサンプルプログラム

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:oceanbase://t5******.********.oceanbase.cloud:3306/test?useServerPrepStmts=true&rewriteBatchedStatements=true
jdbc.username=mysql001
jdbc.password=******

jdbc:mysql://host:port/database?connectTimeout=30000&socketTimeout=60000

jdbc:mysql://host:port/database?characterEncoding=utf8&useUnicode=true

jdbc:mysql://host:port/database?useSSL=true&requireSSL=true

String encodedPassword = URLEncoder.encode(password, "UTF-8");

│--pom.xml
│
├─.idea
│
├─src
│  ├─main
│  │  ├─java
│  │  │  └─com
│  │  │      └─oceanbase
│  │  │          ├─mapper
│  │  │          │------IAppMapper.java
│  │  │          │------IUserMapper.java
│  │  │          │
│  │  │          └─pojo
│  │  │              │---App.java
│  │  │              └─--User.java
│  │  │
│  │  └─resources
│  │      │--jdbc.properties
│  │      │--mybatis-config.xml
│  │      │
│  │      └─com
│  │          └─oceanbase
│  │              └─mapper
│  │                  └─---IUserMapper.xml
│  │
│  └─test
│      └─java
│          └─---TestMybatis.java
│
└─target

```java
<?xml version="1.0" encoding="UTF-8"?>
```

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
</project>

<groupId>com.oceanbase.example</groupId>
<artifactId>java-oceanbase-mybatis</artifactId>
<version>1.0-SNAPSHOT</version>

 <build>
         <plugins>
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-compiler-plugin</artifactId>
             <configuration>
                 <source>8</source>
                 <target>8</target>
             </configuration>
         </plugin>
     </plugins>
 </build>

    ```java
        <dependencies>
        <dependency>
            <groupId>com.oceanbase</groupId>
            <artifactId>oceanbase-client</artifactId>
            <version>2.4.2</version>
        </dependency>
        </dependencies>
    ```

    ```java
        <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
        </dependencies>
    ```

    ```java
        <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>
        </dependencies>
    ```

    ```java
        <dependencies>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.3.0</version>
        </dependency>
        </dependencies>
    ```

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://host:port/TEST?useServerPrepStmts=true&rewriteBatchedStatements=true
jdbc.username=user_name
jdbc.password=******

* `version`：XML ファイルのバージョンを指定します。
* `encoding`：XML ファイルのエンコーディング方式を指定します。
* `DOCTYPE`：タイプがドキュメントタイプ宣言であることを宣言します。
* `configuration`：ドキュメントタイプが MyBatis 設定ファイルであることを指定します。
* `PUBLIC`：ドキュメントタイプがパブリックドキュメントタイプであることを指定します。
* `mybatis.org`：MyBatis 公式サイトを示します。
* `DTD Config 3.0`：MyBatis 設定ファイルのバージョン番号を示します。
* `EN`：ドキュメントタイプの言語が英語であることを示します。

    <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    ```

2. ロードするプロパティファイルのパスとファイル名を指定します。

    ```xml
    <properties resource="jdbc.properties"></properties>
    ```

3. MyBatis のグローバル設定を行います。

MyBatis のグローバル設定の内容には、以下のセクションが含まれます：
    * `setting`：キャッシュやログなど、個別の構成パラメータを設定するために使用されます。
    * `cacheEnabled`：キャッシュ機能を有効または無効にするために使用され、`true` に設定します。
    * `lazyLoadingEnabled`：遅延ロード機能を有効または無効にするために使用され、`true` に設定します。
    * `aggressiveLazyLoading`：積極的な遅延ロード機能を有効または無効にするために使用され、`true` に設定します。
    * `multipleResultSetsEnabled`：複数結果セットのサポートを有効にするかどうかを設定するために使用され、`true` に設定します。
    * `useColumnLabel`：結果セットの列名として列ラベルを使用するかどうかを設定するために使用され、`true` に設定します。
    * `useGeneratedKeys`：自動生成された主キーを使用するかどうかを設定するために使用され、`true` に設定します。
    * `autoMappingBehavior`：自動マッピングの処理動作を設定するために使用され、`PARTIAL` に設定します。
    * `defaultExecutorType`：デフォルトのエグゼキュータタイプを設定するために使用され、`SIMPLE` に設定します。
    * `mapUnderscoreToCamelCase`：データベースの列名にあるアンダースコアを Java オブジェクトのプロパティ名のキャメルケースに変換するかどうかを設定するために使用され、`true` に設定します。
    * `localCacheScope`：ローカルキャッシュのスコープを設定するために使用され、`SESSION` に設定します。
    * `jdbcTypeForNull`：NULL 値を処理する際に使用する JDBC タイプを設定するために使用され、`NULL` に設定します。

<main id="notice" type='explain'>
  <h4>説明</h4>
  <p>settings 要素内の子要素はオプションであり、実際の状況に応じて追加または削除できます。</p>
</main>

**コードは以下の通りです：**

    ```xml
    <settings>
        <!-- Enable or disable caching for global mappers. -->
        <setting name="cacheEnabled" value="true"/>
        <!-- Enable or disable lazy loading globally. When disabled, all associated objects are loaded immediately. -->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!-- When enabled, objects with delayed loading properties will fully load any properties when called. Otherwise, each attribute will be loaded as needed. -->
        <setting name="aggressiveLazyLoading" value="true"/>
        <!-- Allow a single SQL statement to return multiple datasets (depending on driver compatibility) default: true -->
        <setting name="multipleResultSetsEnabled" value="true"/>
        <!-- Can column aliases be used (depending on driver compatibility) default: true -->
        <setting name="useColumnLabel" value="true"/>
        <!-- Allow JDBC to generate primary keys. Drive support is required. If set to true, this setting will force the use of the generated primary key, and some drives may not be compatible but can still be executed. default:false -->
        <setting name="useGeneratedKeys" value="true"/>
        <!-- Specify how MyBatis automatically maps the columns of the data base table NONE: Not Implicit PART: Partial FULL: All -->
        <setting name="autoMappingBehavior" value="PARTIAL"/>
        <!-- This is the default execution type (SIMPLE: simple; REUSE: executor may repeatedly use prepared statements; BATCH: executor can repeatedly execute statements and batch updates) -->
        <setting name="defaultExecutorType" value="SIMPLE"/>
        <!-- Convert fields using camel naming. -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- Set the local cache range session: there will be data sharing statement: statement range (so there will be no data sharing) defalut: session -->
        <setting name="localCacheScope" value="SESSION"/>
        <!-- When the JDBC type is set to null, some drivers need to specify a value, default: Other, and there is no need to specify a type when inserting null values -->
        <setting name="jdbcTypeForNull" value="NULL"/>
    </settings>
    ```

4. MyBatis のプラグインを設定します。

MyBatis のプラグインの内容には、以下のセクションが含まれます：
    * `plugin`：単一のプラグインを設定するために使用されます。
    * `property`：プラグインのプロパティを指定するために使用されます。
    * `interceptor`：プラグインの実装クラスを指定するために使用されます。
    * `helperDialect`：選択したデータベースを指定するために使用されます。
    * `offsetAsPageNum`：offset パラメータを pageNum パラメータとして使用するかどうかを示します。
    * `rowBoundsWithCount`：count クエリを実行するかどうかを示します。
    * `pageSizeZero`：pageSize が 0 のクエリをサポートするかどうかを示します。
    * `reasonable`：合理化クエリを有効にするかどうかを示します。
    * `params`：ページネーションパラメータを渡すためのパラメータ名とパラメータ値のマッピング関係を示します。
    * `supportMethodsArguments`：メソッドパラメータを使用してページネーションパラメータを渡すことをサポートするかどうかを示します。
    * `returnPageInfo`：戻り値のタイプを示します。

**コードは以下の通りです：**

    ```xml
    <plugin interceptor="com.github.pagehelper.PageInterceptor">
       <!-- this parameter indicates which database to connect to -->
       <!--MySQLMode dialect<property name="helperDialect" value="mysql"/>-->
       <!--OracleMode dialect -->
       <property name="helperDialect" value="mysql"/>
       <!-- This parameter defaults to false. When set to true, the first parameter offset of RowBounds will be used as the pageNum page number, similar to the pageNum effect in startPage -->
       <property name="offsetAsPageNum" value="true"/>
       <!-- This parameter defaults to false, and when set to true, using RowBounds pagination will result in a count query -->
       <property name="rowBoundsWithCount" value="true"/>
       <!-- When set to true, if pageSize=0 or RowBounds. limit=0, all results will be queried (equivalent to not executing a pagination query, but the returned results are still of type Page) -->
       <property name="pageSizeZero" value="true"/>
       <!-- Version 3.3.0 is available - pagination parameter rationalization is disabled by default as false. When rationalization is enabled, if pageNum<1, the first page will be queried, and if pageNum>pages, the last page will be queried. Rationalization of paging parameters. When rationalization is disabled, if pageNum<1 or pageNum>pages returns empty data -->
       <property name="reasonable" value="false"/>
       <!-- Version 3.5.0 is available - In order to support the startPage (Object params) method, a 'params' parameter has been added to configure parameter mapping, which can be used to retrieve values from Map or ServletRequest. PageNum, pageSize, count, pageSizeZero, reasonable, orderBy can be configured. If mapping is not configured, the default value will be used. If you do not understand the meaning, do not copy this configuration casually -->
       <property name="params" value="pageNum=start;pageSize=limit;"/>
       <!-- Support passing paging parameters through Mapper interface parameters -->
       <property name="supportMethodsArguments" value="true"/>
       <!-- Always always returns PageInfo type, check to check if the return type is PageInfo, and none returns Page -->
       <property name="returnPageInfo" value="check"/>
    </plugin>
    ```

5. MyBatis の環境を設定します。
MyBatis の環境の内容には、以下のセクションが含まれます：
    * `environment`：単一の環境を設定するために使用されます。
    * `transactionManager`：トランザクションマネージャーの実装クラスを指定するために使用されます。
    * `dataSource`：データソースの実装クラスを指定するために使用されます。
    * `property`：データベースドライバのクラス名を指定します。

<main id="notice" type='explain'>
  <h4>説明</h4>
  <p>MyBatis の他の設定要素では、<code>${}</code> プレースホルダーを使用して、環境で設定されたデータソース、トランザクションマネージャー、エグゼキュータなどを参照できます。</p>
</main>

**コードは以下の通りです：**

    ```xml
        <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>
    ```

6. MyBatis のマッパーを設定します。

MyBatis のマッパーでよく使用される要素は以下の通りです：
    * resource：マッパーの XML 設定ファイルのパスとファイル名を指定するために使用されます。
    * class：マッパーの Java クラス名を指定するために使用されます。

<main id="notice" type='explain'>
  <h4>説明</h4>
  <p>XML 設定ファイルを使用する場合は、mapper 要素で XML ファイルのパスとファイル名を指定する必要があります。Java インターフェースを使用する場合は、mapper 要素で Java クラスの完全修飾名を指定する必要があります。</p>
</main>

**コードは以下の通りです：**

    ```xml
    <mappers>
      <!-- IUserMapper.xml mapping file -->
      <mapper resource="com/alipay/oceanbase/mapper/IUserMapper.xml"></mapper>
      <!-- IAppMapper mapping class -->
      <mapper class="com.oceanbase.mapper.IAppMapper"></mapper>
    </mappers>
    ```

### IUserMapper.xml コードの紹介

`IUserMapper.xml` ファイルは、ユーザーオブジェクトに関連する SQL ステートメントを定義するためのマッピングファイルです。このファイルには `IUserMapper` という名前空間が定義されており、ユーザーオブジェクトに関連する SQL ステートメントを格納するために使用されます。

<main id="notice" type='explain'>
  <h4>説明</h4>
  <p>サンプルを検証するだけであれば、デフォルトのコードを使用し、変更する必要はありません。変更が必要な場合は、実際の状況に応じて変更してください。</p>
</main>

`IUserMapper.xml` ファイルのコードは、主に以下のセクションで構成されています：

1. ファイル宣言文。
XML ファイルの宣言セクションは、XML ファイルのバージョンとエンコーディング方式を指定するために使用されます。DTD ファイルの宣言セクションは、MyBatis の DTD ファイルをインポートするために使用されます。
**コードは以下の通りです：**

```xml
    <?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>
    ```

2. `IUserMapper.java` とのマッピング関係を設定します。

1. `Mapper` インターフェースの名前空間を定義し、Java コード内の `Mapper` インターフェースと対応させます。
    2. `insertUser` という名前の SQL ステートメントを作成し、`test_user` テーブルにレコードを挿入します。これには `id` と `name` の 2 つのフィールドが含まれ、値はそれぞれ `#{id}` と `#{name}` です。`parameterType` プロパティは、渡されるパラメータのタイプが `com.oceanbase.pojo.User` であることを指定します。
    3. `deleteUser` という名前の SQL ステートメントを作成し、`test_user` テーブルからレコードを削除します。`id` フィールドの値に基づいて対応するレコードを照合し、値は `#{id}` です。
    4. `updateUser` という名前の SQL ステートメントを作成し、`test_user` テーブルのレコードを更新します。`name` フィールドの値を `#{name}` に更新し、`id` フィールドの値に基づいて対応するレコードを照合します。値は `#{id}` です。
    5. `selectUsers` という名前の SQL ステートメントを作成し、`test_user` テーブル内のすべてのユーザーレコードをクエリします。
6. `selectUserByPage` という名前の SQL ステートメントを作成し、`test_user` テーブルから指定されたページ数のユーザーオブジェクトをクエリします。サブクエリと `rownum` フィールドを使用してページネーションクエリを実行します。ここで、`#{pageNum}` と `#{pageSize}` は現在のページ番号と 1 ページあたりのレコード数を示します。

**コードは以下の通りです：**

```xml
    <?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="com.oceanbase.mapper.IUserMapper">
<insert id="insertUser" parameterType="com.oceanbase.pojo.User">
INSERT INTO test_user (id,name) VALUES (#{id},#{name})
</insert>
<delete id="deleteUser" parameterType="long">
DELETE FROM test_user WHERE id = #{id}
</delete>
<update id="updateUser" parameterType="com.oceanbase.pojo.User">
UPDATE test_user SET name = #{name} WHERE id = #{id}
</update>
        <select id="selectUsers" resultType="com.oceanbase.pojo.User">
SELECT id,name FROM test_user
        </select>
<!--    There are two ways to paginate queries: 1. Use the pagehelper plugin; 2. Use SQL statements to paginate  -->
<!-- SQL statement pagination: Oracle mode does not support the limit keyword, and instead uses the unique field 'rownum'-->
<select id="selectUserByPage" resultType="com.oceanbase.pojo.User">
select id,name from ( select row_.*, rownum rownum_ from ( select * from test_user ) row_ where rownum
<![CDATA[ <= ]]>  #{pageNum} * #{pageSize} ) where rownum_ <![CDATA[ >]]>  ( #{pageNum}- 1) * #{pageSize}
</select>
</mapper>
    ```

### IAppMapper.java コードの紹介

`IAppMapper.java` ファイルは、SQL マッピング関係を定義するために使用されます。

`IAppMapper.java` ファイルのコードは、主に以下のセクションで構成されています：

1. `Mapper` パッケージを定義します。

現在のファイルが属するパッケージ名が `com.oceanbase.mapper` であることを宣言します。`Mapper` パッケージには以下のインターフェースとクラスが含まれます：

    * `App` インターフェース：データベーステーブルとのマッピングを示し、データの読み書き操作を実装します。
    * `org.apache.ibatis.annotations.*`：MyBatis のアノテーションクラスをインポートするために使用されます。
    * `java.util.List`：`java.util` パッケージの `List` クラスをインポートするために使用されます。
**コードは以下の通りです：**

    ```java
    package com.oceanbase.mapper;
    import com.oceanbase.pojo.App;
    import org.apache.ibatis.annotations.*;
    import java.util.List;
    ```

2. `IAppMapper` インターフェースを定義します。
`IAppMapper` インターフェースは、MyBatis の `Mapper` インターフェースを定義するために使用されます。`Mapper` インターフェースは、SQL マッピング関係を定義し、データベースに対する CRUD 操作を実装するために使用されます。具体的には、`IAppMapper` インターフェースは `test_app` テーブルに対する CRUD 操作のメソッドを定義しており、以下が含まれます：

   * `@Insert` メソッド：データベースにデータを挿入するために使用されます。
   * `@Update` メソッド：データベース内のデータを更新するために使用されます。
   * `@Delete` メソッド：データベース内のデータを削除するために使用されます。
   * `@Select` メソッド：データベース内のデータをクエリするために使用されます。
   * `@Results` メソッド：クエリ結果のマッピング関係を示し、クエリ結果のフィールドを Java オブジェクトのプロパティにマッピングするために使用されます。
**データベースに対する CRUD 操作は以下の通りです：**
1. データの挿入
App オブジェクトを `test_app` テーブルのレコードにマッピングし、App オブジェクトのプロパティ値は `#{プロパティ名}` の形式でプレースホルダーとして表されます。`Integer` タイプの戻り値は、SQL ステートメントがデータを挿入した後に返される自動生成された ID、つまり `test_app` テーブルの ID フィールドに対応する値を示します。

        ```java
        @Insert("insert into test_app(id,name) values(#{id},#{name})")
        Integer insertApp(App app);
        ```

2. データの削除
`test_app` テーブルから id が `#{id}` に等しいデータを削除します。

        ```java
        @Delete("delete from test_app  where id =#{id}")
        Integer deleteApp(Long id);
        ```

3. データの更新
`test_app` テーブルのレコードを変更するには、Update 操作を実行する必要があります。

        ```java
        @Update("update test_app set name= #{name} where id = #{id}")
        Integer updateApp(App user);
        ```

4. データのクエリとマッピング
`test_app` テーブル内のすべてのデータをクエリします。同時に、`@Results` アノテーションと `@Result` アノテーションを使用して、クエリ結果を App オブジェクトの `id` および `name` プロパティにマッピングします。最終的に App オブジェクトのリストを返します。

        ```java
        @Update("update test_app set name= #{name} where id = #{id}")
        Integer updateApp(App user);
@Results({
@Result(id = true, column = "id", property = "id"),
@Result(column = "name", property = "name")
})
List<App> selectApps();
        ```

**コードは以下の通りです：**

    ```java
    package com.oceanbase.mapper;
    import com.oceanbase.pojo.App;
    import org.apache.ibatis.annotations.*;
    import java.util.List;
public interface IAppMapper {
@Insert("insert into test_app(id,name) values(#{id},#{name})")
Integer insertApp(App app);

@Delete("delete from test_app  where id =#{id}")
Integer deleteApp(Long id);

@Update("update test_app set name= #{name} where id = #{id}")
Integer updateApp(App user);

@Select("select * from test_app")
@Results({
@Result(id = true, column = "id", property = "id"),
@Result(column = "name", property = "name")
})
List<App> selectApps();
}
    ```

### IUserMapper.java コードの紹介

`IUserMapper.java` ファイルは、データベース操作のメソッドを定義するために使用されます。

`IUserMapper.java` ファイルのコードは、主に以下のセクションで構成されています：

1. 他のクラスとインターフェースの参照。

現在のファイルに含まれるインターフェースとクラスを宣言します：
   * `User` クラス：ユーザーオブジェクトを示します。
   * `org.apache.ibatis.annotations.Param` クラス：MyBatis フレームワークのパラメータアノテーションです。
   * `List` インターフェース：リストタイプを示します。
**コードは以下の通りです：**

    ```java
    package com.oceanbase.mapper;
    import com.oceanbase.pojo.User;
    import org.apache.ibatis.annotations.Param;
    import java.util.List;
    ```

2. `IUserMapper` インターフェースを定義します。

`IUserMapper` という名前のインターフェースを定義し、ユーザーデータの挿入、削除、更新、クエリのメソッド、およびユーザーデータのページネーションクエリのメソッドを定義します。同時に、`JavaDoc` コメントと `@Param` アノテーションを使用して、コードの可読性と保守性を向上させます。
**コードは以下の通りです：**

   ```java
    public interface IUserMapper {

        Integer insertUser(User user);

        Integer deleteUser(Long id);

        Integer updateUser(User user);

        List<User> selectUsers();

        public List<User> selectUserByPage(@Param("user") User user, @Param("pageNum") Integer pageNum,
                                        @Param("pageSize") Integer pageSize);
    }

   package com.oceanbase.pojo;

   public class App {
       private Long id;
       private String name;

       public App() {
       }

       public App(Long id, String name) {
            this.id = id;
           this.name = name;
       }

       public Long getId() {
           return id;
       }

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

       public String getName() {
           return name;
       }

       public void setName(String name) {
           this.name = name;
       }

       @Override
       public String toString() {
           return "App{" +
id= + id +
, name=' + name + '\'' +
}';
       }
       }

   package com.oceanbase.pojo;

public class User {
       private Long id;
       private String name;

   public User() {
       }

public User(Long id, String name) {
            this.id = id;
           this.name = name;
       }

       public Long getId() {
           return id;
       }

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

       public String getName() {
           return name;
       }

       public void setName(String name) {
           this.name = name;
       }

       @Override
       public String toString() {
return "User{" +
id= + id +
, name=' + name + '\'' +
}';
       }
       }

* `IAppMapper` インターフェース：App オブジェクトに関連する SQL ステートメントを定義するために使用されます。
* `IUserMapper` インターフェース：User オブジェクトに関連する SQL ステートメントを定義するために使用されます。
* `App` クラス：App オブジェクトで、SQL ステートメントの実行状況をテストするために使用されます。
* `User` クラス：User オブジェクトで、SQL ステートメントの実行状況をテストするために使用されます。
* `PageHelper` プラグイン：ページネーションクエリ機能を実装するために使用されます。
* `PageInfo` プラグイン：ページネーションクエリ結果をカプセル化するために使用されます。
* `Resources` クラス：MyBatis 設定ファイルをロードするために使用されます。
* `SqlSession` クラス：SQL ステートメントを実行し、トランザクションを管理するために使用されます。
* `SqlSessionFactory` クラス：SqlSession オブジェクトを作成するために使用されます。
* `SqlSessionFactoryBuilder` クラス：SqlSessionFactory オブジェクトを作成するために使用されます。
* `org.junit.Test`：JUnit テストフレームワークのアノテーションで、テストメソッドをマークするために使用されます。
* `IOException` クラス：入出力操作中のエラーを示すために使用されます。
* `SQLException` クラス：SQL 操作中のエラーを示すために使用されます。
* `Statement` インターフェース：SQL ステートメントを実行し、結果を返すために使用されます。
* `java.util.List` インターフェース：順序付けられたコレクションを示すために使用され、その中の要素は重複する可能性があります。

```java
import com.oceanbase.mapper.IAppMapper;
import com.oceanbase.mapper.IUserMapper;
import com.oceanbase.pojo.App;
import com.oceanbase.pojo.User;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import java.io.IOException;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
```

```java
    public void testUserMapper() throws SQLException, IOException {
        //mybatis xml usecases
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Statement statement = sqlSession.getConnection().createStatement();
        try {
            statement.execute("drop table test_user");
        } catch (SQLException ex) {
        } finally {
            statement.execute("create table test_user(id number(20) primary key,name varchar2(100))");
        }
        IUserMapper mapper = sqlSession.getMapper(IUserMapper.class);
        //insert 10 users
        for (int i = 1; i <= 10; i++) {
            User user = new User((long) i, "insert");
            Integer insertResult = mapper.insertUser(user);
        }
        //delete id==1
        Integer deleteResult = mapper.deleteUser(1L);
        //update id==2L name=update
        User updateUser = new User(2L, "update");
        Integer updateResult = mapper.updateUser(updateUser);
        //selectUsers query all
        List<User> userList = mapper.selectUsers();
        userList.forEach(System.out::println);
        //selectUsersByPage：use the rownum keyword in SQL statements to manually perform pagination queries,
        // example: data on page 2 (3 items per page)
            User user = new User();
        user.setName("insert");
        List<User> usersByPage = mapper.selectUserByPage(user, 2, 3);
        System.out.println("usersByPage = " + usersByPage);
        statement.close();
        sqlSession.commit();
        sqlSession.close();
        }
```

```java
    public void testSqlSession() throws SQLException, IOException {
        //SqlSession usecases
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Statement statement = sqlSession.getConnection().createStatement();
        try {
            statement.execute("drop table test_user");
        } catch (SQLException ex) {
        } finally {
            statement.execute("create table test_user(id number(20) primary key,name varchar2(100))");
        }
        //insert
        for (int i = 1; i <= 10; i++) {
            User user = new User((long) i, "insert");
            //Integer insertResult = mapper.insertUser(user);
            int insertResult = sqlSession.insert("com.oceanbase.mapper.IUserMapper.insertUser", user);
        }
        //delete
        int deleteResult = sqlSession.delete("com.oceanbase.mapper.IUserMapper.deleteUser", 1L);
        //update
        User updateUser = new User(2L, "update");
        int updateResult = sqlSession.update("com.oceanbase.mapper.IUserMapper.updateUser", updateUser);
        //selectUsers
        List<User> userList = sqlSession.selectList("com.oceanbase.mapper.IUserMapper.selectUsers", null);
        userList.forEach(System.out::println);
        //System.out.println("userList = " + userList);
        statement.close();
        sqlSession.commit();
        sqlSession.close();
        }
```

```java
    public void testAppMapper() throws SQLException, IOException {
        //mybatis annotation usecases
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Statement statement = sqlSession.getConnection().createStatement();
        try {
            statement.execute("drop table test_app");
        } catch (SQLException ex) {
        } finally {
            statement.execute("create table test_app(id number(20) primary key,name varchar2(100))");
        }

        IAppMapper mapper = sqlSession.getMapper(IAppMapper.class);

        //insert
        for (int i = 1; i <= 10; i++) {
            App app = new App((long) i, "insert" + i);
            Integer insertResult = mapper.insertApp(app);
        }

        //delete
        Integer deleteResult = mapper.deleteApp(1L);
        //update
        App updateApp = new App(2L, "update");
        Integer updateResult = mapper.updateApp(updateApp);
        //commit
        sqlSession.commit();

        //selectApps
        List<App> appList = mapper.selectApps();
        appList.forEach(System.out::println);

        //selectbyPage
        //set page parameters
        PageHelper.startPage(2, 3);
        //selectApps
        List<App> appList1 = mapper.selectApps();
        //get pageList
        PageInfo pageInfo = new PageInfo(appList1);
        List<App> pageList = pageInfo.getList();
        System.out.println("pageList = " + pageList);

        sqlSession.close();
        }
```