前回はCriteria APIの基本と利点をご紹介しました。今回はCriteria APIの実戦的な機能をいろいろとご紹介します。

準備・エンティティクラスとメタモデルクラスのサンプル

次のようなエンティティクラスとメタモデルクラスが存在することを前提に進めていきます。

まずはUserエンティティクラスです。

package sandbox.entity;

import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    Long      id;

    @Column(length = 150, unique = true, nullable = false)
    String    name;

    // getter/setterは省略
}

次にUserエンティティのプロパティの型を表すメタモデルクラスです。

package sandbox.entity;

import javax.annotation.Generated;
import javax.persistence.metamodel.SingularAttribute;
import javax.persistence.metamodel.StaticMetamodel;

@Generated(value="Dali", date="2016-02-12T22:59:19.623+0900")
@StaticMetamodel(User.class)
public class User_ {
	public static volatile SingularAttribute<User, String> name;
	public static volatile SingularAttribute<User, Long> id;
}

それではCriteria APIを見ていきましょう。

Where条件にメタモデルクラスを使う

メタモデルクラスは、Criteria APIによるクエリの型安全性を高めるという重要な役割を持っています。

冒頭で示したUserというエンティティクラスをnameプロパティの値で絞り込むクエリを作ってみましょう。

private static void selectUsersByName(final EntityManager em, final String pUserName) {
    final CriteriaBuilder builder = em.getCriteriaBuilder();
    final CriteriaQuery<User> query = builder.createQuery(User.class);
    final Root<User> root = query.from(User.class);
    query.where( //
            // メタモデルクラスを使ってカラムを指定する
            builder.equal(root.get(User_.name), pUserName) //
    );
    final List<User> result = em.createQuery(query).getResultList();
    for (final User user : result) {
        System.out.println(user);
    }
}

eclipseの入力補完の様子を見ると、fromに指定したエンティティクラスに応じたメタモデルクラスが候補として表示されることが分かると思います。

Where句に複雑な条件を設定する

検索画面のようにWhere句が動的かつ複雑になる時に、Criteria APIは威力を発揮します。例えば入力のある条件はWhere句に加えるが、入力のない条件はWhere句に加えない、という処理をJPQLで書くのは割と大変です。

private static void selectUsersByName(final EntityManager em, final String name) {
    final StringBuilder s = new StringBuilder("select e from User e where 1 = 1");
    if (name != null) {
        s.append(" and e.name = :name");
    }

    final TypedQuery<User> query = em.createQuery(new String(s), User.class);

    if (name != null) { // 存在しないパラメータを設定すると例外が生じるため、再度チェックせざるを得ない！
        query.setParameter("name", name);
    }

    final List<User> result = query.getResultList();
    for (final User user : result) {
        System.out.println(user);
    }
}

これをCriteria APIで書き直すと、とても素直なプログラムになります。

private static void selectUsersByName(final EntityManager em, final String name) {
    final CriteriaBuilder builder = em.getCriteriaBuilder();
    final CriteriaQuery<User> query = builder.createQuery(User.class);
    final Root<User> root = query.from(User.class);

    final List<Predicate> where = new ArrayList<>();
    if (name != null) {
        where.add(builder.equal(root.get(User_.name), name));
    }

    query.where(where.toArray(new Predicate[where.size()]));

    final List<User> result = em.createQuery(query).getResultList();
    for (final User user : result) {
        System.out.println(user);
    }
}

 関連クラスを同時に取得する

JPAの強みの１つにエンティティクラスの関連をコードで表現出来ることがあります。下記はUserを親に持つTagというエンティティを作っています。

package sandbox.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Tag {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    Long   id;

    @Column(length = 50, unique = false, nullable = false)
    String name;

    @ManyToOne(fetch = FetchType.LAZY)
    User   user;

    @Column(nullable = false)
    long   starCount;

    // getter/setterは省略
}

Tagを取得する際、親のUserも同時に取ってくるようなクエリを作ってみましょう。

private static void selectTagWithUser(final EntityManager em) {
    final CriteriaBuilder builder = em.getCriteriaBuilder();
    final CriteriaQuery<Tag> query = builder.createQuery(Tag.class);
    final Root<Tag> root = query.from(Tag.class);

    root.fetch(Tag_.user, JoinType.LEFT); // 関連エンティティを同時に取ってくるように指定

    final List<Tag> result = em.createQuery(query).getResultList();
    for (final Tag tag : result) {
        System.out.println(tag.getUser());
    }
}

9行目がポイントです。実はこの行がなくても関連エンティティは取得できるのですが、SQLの実行回数が格段に変わってきます。俗に言う「N+1問題」を回避する手法です。

関連先のエンティティの条件を指定する

JPAの強力な機能の１つに、関連先エンティティの条件指定がとても簡単な点があります。

private static void selectTagByUserName(final EntityManager em, final String pUserName) {
    final CriteriaBuilder builder = em.getCriteriaBuilder();
    final CriteriaQuery<Tag> query = builder.createQuery(Tag.class);
    final Root<Tag> root = query.from(Tag.class);

    query.where(builder.equal(root.get(Tag_.user).get(User_.name), pUserName));

    final List<Tag> result = em.createQuery(query).getResultList();
    for (final Tag tag : result) {
        System.out.println(tag);
    }
}

6行目がポイントです。「Tagクラス#userプロパティ」→「Userクラス#nameプロパティ」とたどって条件指定しています。SQLで同じことをしようとするとJOINを書く必要があり手間がかかるところですが、JPAではかなりシンプルに書けることが分かります。

Where句に IN条件を指定する

IN条件は少し特殊な書き方をするのでハマることがあります。

private static void selectUsersByNames(final EntityManager em, final String... names) {
    final CriteriaBuilder builder = em.getCriteriaBuilder();
    final CriteriaQuery<User> query = builder.createQuery(User.class);
    final Root<User> root = query.from(User.class);

    if (names != null && names.length > 0) {
        query.where(root.get(User_.name).in(names));
    }

    final List<User> result = em.createQuery(query).getResultList();
    for (final User user : result) {
        System.out.println(user);
    }
}

7行目でIN条件を指定しています。CriteriaBuilderを使わない点に注意してください。

また要素数が0の時の挙動は、残念ながらDB製品依存となるようなので、プログラムで明示的にチェックするのが無難でしょう。

Tupleを使って柔軟な結果を得る

Tupleという汎用クラスを使えばエンティティにとらわれない形でデータを取得できます。例えば、JOINを使って複数のテーブルからデータを取得しつつ集計するような用途に有用です。

ただし、型安全性が失われる点には注意が必要です。

private static void selectTupleWithJoin(final EntityManager em) {
    final CriteriaBuilder builder = em.getCriteriaBuilder();

    // Tupleで結果を受け取る
    final CriteriaQuery<Tuple> query = builder.createTupleQuery();

    // Tagを主テーブルにする
    final Root<Tag> root = query.from(Tag.class);

    // JOINする
    final Join<Tag, User> join = root.join(Tag_.user);

    final Path<String> userName = join.get(User_.name);

    // ユーザ名で集計する
    query.groupBy(userName);

    // Userから特定のカラムのみ取得しつつTagのstarCountを合計する
    // 後で取り出しやすいように、カラムには別名を付けておく
    query.multiselect( //
            userName.alias("user_name") //
            , builder.sum(root.get(Tag_.starCount)).alias("tag_count") //
    );

    final List<Tuple> result = em.createQuery(query).getResultList();
    for (final Tuple e : result) {
        System.out.println(e.get("user_name") + " " + e.get("tag_count"));
    }
}

任意のデータクラスをクエリの結果の型にする

Tupleの弱点は、Tupleが汎用的すぎて「どんなデータがいくつ入っているか分かりにくい」ことです。これを補うために、任意の型をクエリの結果とすることができます。

Tupleの例を書き直してみます。まずは結果を受け取るためのクラスを作ります。コンストラクタで全ての値を受け取るようにする必要があります。

public class StarSummary {

    private final String userName;
    private final long   tagCount;

    public StarSummary(final String pUserName, final long pTagCount) {
        this.userName = pUserName;
        this.tagCount = pTagCount;
    }

    // getterは省略
}

作ったクラスをクエリの結果とするには、CriteriaBuilder#construct(Class, Selection<?>...)を使ってクエリを組み立てます。

    private static void selectStartSummary(final EntityManager em) {
        final CriteriaBuilder builder = em.getCriteriaBuilder();
        final CriteriaQuery<StarSummary> query = builder.createQuery(StarSummary.class);
        final Root<Tag> root = query.from(Tag.class);

        final Join<Tag, User> join = root.join(Tag_.user);

        query.select( //
                builder.construct(StarSummary.class //
                , join.get(User_.name) //
                , builder.sum(root.get(Tag_.starCount)) //
        ));
        query.groupBy(join.get(User_.name));

        final List<StarSummary> result = em.createQuery(query).getResultList();
        for (final StarSummary e : result) {
            System.out.println(e);
        }
    }

9〜11行目でデータクラスを扱っています。

Tupleに比べ扱いやすい型で結果を得られますが、一方でコンストラクタ引数の順番に依存するプログラムとなってしまうのが弱点です。ですがTupleの「どんなデータがいくつ入っているか分かりにくい」という欠点はとても重大ですので、できれば、こちらのデータクラスを使う方が望ましいです。

型安全になりきれていない箇所

ここまで見てきたように、Criteria APIは型安全にクエリを組み立てられる非常に便利な機能なのですが、残念ながら型安全になりきれていない箇所があります。代表的なのはCriteriaBuilder#equal(Expression<?> exp, Object value)メソッドです。

例えば次のコードを見てください。

    query.where( //
        builder.equal(root.get(User_.name), pUserName) //
    );

これを次のように書き間違えたとしても、コンパイルエラーにはならないのです。

    query.where( //
        builder.equal(root.get(User_.id), pUserName) //
    );

このケースでは実行時例外がスローされますが、場合によっては例外がスローされず普通に実行されてしまうため、分かりにくいバグの原因となる可能性があります。

このメソッドのシグニチャが

<C> Predicate equal(Expression<C> exp, C value)

となっていればよかったのに・・・と思えてなりません。頻繁に使うメソッドだけに残念です。

JPAのその他の機能

最後に、ちょっとした便利機能をいくつか紹介しておきます。

ページングに使える２つのメソッド

Webアプリケーションでは検索結果が大量になる場合、ページング表示するのが普通です。JPAには簡単にページングを実装するためのメソッドがあります。

setFirstResult()/setMaxResults()です。

private static List<User> selectUsersWithPaging(final EntityManager em, final int pPageIndex, final int pCountPerPage) {
    final CriteriaBuilder builder = em.getCriteriaBuilder();
    final CriteriaQuery<User> query = builder.createQuery(User.class);
    query.from(User.class);
    return em.createQuery(query) //
            .setFirstResult(pPageIndex * pCountPerPage) //
            .setMaxResults(pCountPerPage) //
            .getResultList();
}

7行目と8行目でページングを指定しています。

結果が必ず1件と分かっている場合に使えるメソッド

結果が必ず1件と分かっている時にはgetSingleResult()メソッドが使えます。

private static void countAllUsers(final EntityManager em) {
    final CriteriaBuilder builder = em.getCriteriaBuilder();
    final CriteriaQuery<Long> query = builder.createQuery(Long.class);
    final Root<User> root = query.from(User.class);

    query.select(builder.count(root));

    final long count = em.createQuery(query).getSingleResult().longValue();
    System.out.println(count);
}

ただし、結果が1件でなかった時は例外がスローされますので、絶対に1件と確信が持てる場合にのみ使ってください。

 まとめ

Criteria APIを中心に、２回に渡ってJPAの様々な機能を解説してきましたがいかがでしたでしょうか。

JPAには他にも便利で重要な機能がたくさんあります。特にエンティティクラスの設計は工夫のしがいがあり、別の機会でご紹介したいところです。

非常にパワフルなJPA。JavaEEを使う場合はぜひJPAを使って効率的かつ安全にDBアクセスを実装していただきたいと思います。

JPAとは

JPAは一言で言えば「高機能なDBアクセスフレームワーク」です。DBアクセスフレームワークは実に様々なものがありますが、JPAの特徴は

• エンティティクラスへの操作を通してDB操作を実現する（DBの都合はプログラマから極力隠される）
• 型安全を追求するための様々な機能を備える

が挙げられます。Javaの良さを引き出す工夫に満ちたフレームワークと言えるでしょう。

様々な機能を備えたJPAですが、本エントリでは、検索、中でもCriteria APIを使った型安全な検索を中心にご紹介します。コードをしっかり載せていきますので、Criteria APIのコンセプトを感じ取っていただけると思います。

なお、JPAを動作させる環境を構築する方法は「JavaEEだけでここまでできる！GlassFish+Eclipseで高速Webアプリ開発【環境構築編】」をご覧下さい。

準備１・メタモデルクラスを自動生成する設定

メタモデルクラスとは、エンティティクラスのプロパティに関する情報を表すクラスであり、型安全にJPAを使うためには欠かせないクラスです。

例えば次のようなエンティティクラスがあったとしましょう。

package sandbox.entity;

import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    Long      id;

    @Column(length = 150, unique = true, nullable = false)
    String    name;

    // getter/setterは省略
}

このエンティティクラスに対するメタモデルクラスは次のようになります。

package sandbox.entity;

import javax.annotation.Generated;
import javax.persistence.metamodel.SingularAttribute;
import javax.persistence.metamodel.StaticMetamodel;

@Generated(value="Dali", date="2016-02-12T22:59:19.623+0900")
@StaticMetamodel(User.class)
public class User_ {
	public static volatile SingularAttribute<User, String> name;
	public static volatile SingularAttribute<User, Long> id;
}

メタモデルクラスはeclipseのような開発環境に自動で作ってもらうことができますので、有効にしておきましょう。

ecliseの場合の手順を紹介しておきます。プロジェクトのプロパティを開き、「プロジェクト・ファセット」から「Convert to faceted form…」をクリックします。

プロジェクト・ファセットが有効になったので、JPAサポートを有効にします。

ここで「 OK」を押していったんプロパティ画面を閉じます。

再びプロパティ画面を開くと「JPA」という設定項目が増えていますので、メタモデルクラスの自動生成を有効にします。

これで、エンティティクラスに変更が入る度にメタモデルクラスが自動生成されます。メタモデルクラスの名前はエンティティクラスの名前の後ろに _ を付けたものになります。

準備２・SQLをコンソールに出力する設定

JPAを使いこなすコツはJavaコードを中心に考えることですが、さすがにSQLが見えないと辛すぎます。せめてコンソールにSQLを出力するようにしておきましょう。JPAの設定ファイルであるpersistence.xmlにプロパティを追記します。

EclipseLinkの場合

<property name="eclipselink.logging.level.sql" value="FINE" />
<property name="eclipselink.logging.parameters" value="true" />
<property name="eclipselink.logging.logger" value="org.eclipse.persistence.logging.DefaultSessionLog"/>

OpenJPAの場合

<property name="openjpa.Log" value="DefaultLevel=WARN, Runtime=INFO, Tool=INFO, SQL=TRACE"/>
<property name="openjpa.ConnectionFactoryProperties" value="PrintParameters=true" />

APサーバにGlassFishを使っているのであれば、EclipseLinkの方を設定してください。

スキーマ定義をエンティティクラスで行う

JPAの良さを引き出すコツは、Javaコードを中心に考えることです。まずはスキーマ定義をエンティティクラスで行うようにしてみましょう。

ただ、実はJPAの仕様にはエンティティクラスからDDLを作る機能は含まれていません。JPAの実装であるEclipseLinkやOpenJPAの機能を使います。通常、persistence.xmlにプロパティを追記します。

EclipseLinkの場合

<property name="eclipselink.ddl-generation" value="create-tables" />

OpenJPAの場合

<property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)" />

APサーバにGlassFishを使っているのであれば、EclipseLinkの方を設定してください。

Criteria APIによる検索

JPAの検索には、JPQLとCriteria APIの２つのやり方があります。JPQLは文字列でクエリを記述するため、コンパイル時に型チェックが全く働きません。

例えば以下のコードは実行時にClassCastExceptionがスローされてしまいます。

private static void selectByJPQL(final EntityManager em) {
    final String q = "select e from Tag e";
    for (final User user : em.createQuery(q, User.class).getResultList()) {
        System.out.println(user);
    }
}

よく見ると、クエリ文字列がfrom Tagとなっています。結果のエンティティはUser型で受けていますから、型が異なっていおり、実行時にClassCastExceptionがスローされるのです。

しかしCriteria APIを使うと、このようなミスはコンパイル時に検出できるようになります。上のJPQLをCriteria APIで描き直してみましょう。

private static void selectByCriteria(final EntityManager em) {
    final CriteriaBuilder builder = em.getCriteriaBuilder();
    final CriteriaQuery<Tag> criteria = builder.createQuery(Tag.class);
    criteria.from(User.class);

    final TypedQuery<User> query = em.createQuery(criteria);
    for (final User user : query.getResultList()) {
        System.out.println(user);
    }
}

eclipseでこのコードを書くと、以下のようにコンパイルエラーとしてミスを教えてくれます。

このように、Criteria APIを使うとクエリのミスをコンパイル時にチェックできるようになります。これがCriteria APIの最大の利点です。

また、副次的な効果ですが変なクエリが書かれないようになります。実際の開発現場では、変態的なSQLが横行してチューンングの足枷になったり、特定のDB製品でしか実行できない書き方がされていたりと、SQL周りの問題が起きやすいです。しかしCriteria APIを使えばクエリの記述方法がある程度統一されるため、問題が起きにくく、またレビューしやすくなります。

Criteria APIによるクエリの基本形

Criteria APIはJPQLの構造をJavaクラスで表現したものと考えることができます。JPQLの構成要素の基本は次の３つです。

1. from句：どのエンティティ（≒テーブル）からデータを取得するか
2. where句：抽出条件
3. select句：どのエンティティ、あるいはプロパティなどを取得するか

この３つを踏まえると、Criteria APIを使ったプログラムの基本形は次のようになります。

private static void selectUsersByName(final EntityManager em, final String pUserName) {
    // クエリを組み立てるためのオブジェクトを得る
    final CriteriaBuilder builder = em.getCriteriaBuilder();

    // クエリ全体を表現するオブジェクトを作成.
    // 引数として、クエリ結果の型を指定する.
    final CriteriaQuery<User> query = builder.createQuery(User.class);

    // from句指定
    final Root<User> root = query.from(User.class);

    // where句指定
    query.where( //
            builder.equal(root.get(User_.name), pUserName) //
            , builder.isNotNull(root.get(User_.name)) //
    );

    // select句指定.
    // ここではプロパティではなくエンティティそのものを指定.
    // ただしfromと同じエンティティを指定する場合はこの行は省略可能.
    query.select(root);

    // クエリ実行
    final List<User> result = em.createQuery(query).getResultList();
    for (final User user : result) {
        System.out.println(user);
    }
}

結果の型を指定できるのがとても強力です。例えば全件数を得るクエリは次のように書けます。

private static void countAllUsers(final EntityManager em) {
    final CriteriaBuilder builder = em.getCriteriaBuilder();

    // 件数なので結果は数値で得るようにする
    final CriteriaQuery<Long> query = builder.createQuery(Long.class);
    final Root<User> root = query.from(User.class);

    // count関数を使う
    query.select(builder.count(root));

    final long count = em.createQuery(query).getSingleResult().longValue();
    System.out.println(count);
}

基本編はここまでです。次回の応用編では、Criteria APIの実戦的な機能をご紹介します。

さて、前回　MyBatis Generator の使い方 で以下の4つのファイルが自動生成されました。

・データを格納するエンティティクラス
・抽出条件を設定するサンプルクラス
・データ操作のメインとなるマッパークラス
・上のマッパークラスに紐づいた実際の SQL を書く XML ファイル

※ファイル名は DB のテーブル名が頭につきますので、みなさんは違うファイル名でも気にしないでOKです。

　1. ライブラリとデータソースの設定をする

1.  Maven もしくは Gradle から以下のライブラリを入れてください。

・mybatis
・mysql-connector-java
・commons-dbcp2

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.2.8</version>
            <type>jar</type>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
        </dependency>

2. applicationContext.xml を以下の情報で src/main/resources/ に作成

<?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:mybatis="http://mybatis.org/schema/mybatis-spring"
  xsi:schemaLocation="

http://www.springframework.org/schema/beans


http://www.springframework.org/schema/beans/spring-beans-4.0.xsd


http://www.springframework.org/schema/context


http://www.springframework.org/schema/context/spring-context-4.0.xsd


http://mybatis.org/schema/mybatis-spring

    http://mybatis.org/schema/mybatis-spring.xsd">

<!-- DataSource -->
<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
  <property name="driverClassName" value="com.mysql.jdbc.Driver" />
  <property name="url" value="jdbc:mysql://localhost/car" />   //接続サーバーとMySQLスキーマ名
  <property name="username" value="root" />   //データベースのユーザー名
  <property name="password" value="" />   //接続パスワード
</bean>

<!-- SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean" >
  <property name="dataSource" ref="dataSource" />
</bean>

<!-- Mapper -->
//↓id名は呼び出すために使う名前なので任意でOKです
<bean id="mp" class="org.mybatis.spring.mapper.MapperFactoryBean">
//↓valueには自動生成された *Mapper.java クラスをパッケージ名込みで指定してください
  <property name="mapperInterface" value="jp.gmo.myfirstspringboot.mybatis.TCarMapper" />
  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

</beans>

 ※applicationContext.xml は、データベースの接続情報とマッパークラスにID名をつけて登録する設定ファイルです。

　2. データにアクセスするメインクラスを作成

今回準備したテーブルはこんな感じです。
(データベース名 car  テーブル名 t_car)

src/main/resources 配下に同パッケージ名でマッパー *.xml ファイルを配置します。
これにより、ビルド後に classファイルと同じディレクトリに入ります。

早速以下のメインクラスを作って  id, name, brand のデータを取り出してみましょう。

public class DataCaller {

    public static void main(String[] args) throws IOException {

        String resource = "src/main/resources/applicationContext.xml";
        ApplicationContext ac = new FileSystemXmlApplicationContext(resource);
        TCarMapper tcarmapper = (TCarMapper) ac.getBean("mp");

        TCar record = new TCar();
        TCarExample example = new TCarExample();
        example.setDistinct(true);
              
        ArrayList<TCar> result = (ArrayList<TCar>)tcarmapper.selectByExample(example);
        for (TCar r : result) {
            System.out.println(r.getId() + " " +r.getName() + " " + r.getBrand());
        }
    }
}

 

 

　3. MySQL テーブルからデータを取り出す

DataCaller.java メインクラスを実行します。

ちゃんとデータが取れました。

 

insert する場合はこんな感じで出来ます↓

		TCar record = new TCar();
		record.setId(6);
		record.setName("JULIETA");
		record.setBrand("ALPHA_ROMEO");
		tcarmapper.insert(record);

 

 

　おまけ： カスタマイズして SQL を作ってみる

TCarExample.java, TCarmapper.xml をカスタマイズすることでオリジナルの SQL を組み立てることができます。ここでは カラムを指定する SQL を足してみましょう。

 (TCarExample.java)

     /**
     * original
     */
    public void setColumn(String column) {
        this.column = column;
    }

 

(TCarmapper.xml )

    <!-- 
    <include refid="Base_Column_List" />
    -->
    
    <!-- original -->
    <if test="column == 'id'">
      id
    </if>
    <if test="column == 'name'">
      name
    </if>
    <if test="column == 'brand'">
      brand
    </if>
    <if test="column == null">
        <include refid="Base_Column_List" />
    </if>
    <!-- original -->

 

 (DataCaller )

public class DataCaller {

    public static void main(String[] args) throws IOException {

        String resource = "src/main/resources/applicationContext.xml";
        ApplicationContext ac = new FileSystemXmlApplicationContext(resource);
        TCarMapper tcarmapper = (TCarMapper) ac.getBean("mp");
 
        TCarExample example = new TCarExample();
        example.setColumn("name");  //originalメソッドの呼び出し
                
        ArrayList<TCar> result = (ArrayList<TCar>)tcarmapper.selectByExample(example);
        for (TCar r : result) {
            System.out.println(r.getId() + " " +r.getName() + " " + r.getBrand());
        }
    }
}

 

実行します。

name カラムだけデータが取れましたね。

いかがでしたか？今回は MyBatis の使い方をサンプルファイルを交えて解説しました。旧 iBatis として知られる MyBatis は昔からの実績や、現在でも大規模な案件で使われる安定性をもっています。個人的には Java のデファクトスタンダード O/Rマッパーとして認知されたら嬉しいなと思っています。

しかし、最初にマッパーやエンティティクラスなどを自分で書くのは非常にしんどいです。そんなとき、手っ取り早く使えるようにファイルを自動生成してくれるのが MyBatis Genarator です。とりあえずこれを使って、あとからファイルをカスタマイズして覚えていくのが良いと思います。

今回は Maven 経由で MyBatis を入れます。

　MyBatis Generator を手っ取り早くインストール

最近の Eclipse, NetBeans, IntelliJ ならどれでも Maven はすぐ使えるはずですので、pom.xml に以下を追記しましょう。

<project ...>
     ...
     <build>
       ...
       <plugins>
        ...
        <plugin>          //ここから
      	  <groupId>org.mybatis.generator</groupId>
      	  <artifactId>mybatis-generator-maven-plugin</artifactId>
          <version>1.3.0</version>
        </plugin>         //ここまで　※入れるカテゴリはpluginsの中です
        ...
      </plugins>
      ...
    </build>
    ...
  </project>

これでプラグインとしてインストールされます。

　generatorConfig.xml を配置する

この xml ファイルを元にして各ファイルが自動生成されますのでサンプルをもとに作りましょう。
作る場所はプロジェクトの resources 直下です。

プロジェクト名 > src > main > resources > generatorConfig.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="C:\Program Files\MySQL\Connector.J 5.1\mysql-connector-java-5.1.33-bin.jar"/>
  // ↑ MySQLに接続するConnectorJのjarファイルを指定します
  <context id="context1" >
    <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://localhost:3306/car" userId="root" password="password" />
    // ↑　ローカルのMySQLに接続するパスとDB名、それからMySQLのユーザーIDとパスを指定します
    <javaModelGenerator targetPackage="jp.cloudear.test.db" targetProject="C:\Users\masa\Documents\NetBeansProjects\project\src\main\java\" />
    <sqlMapGenerator targetPackage="jp.cloudear.test.db" targetProject="C:\Users\masa\Documents\NetBeansProjects\project\src\main\java\" />
    <javaClientGenerator targetPackage="jp.cloudear.test.db" targetProject="C:\Users\masa\Documents\NetBeansProjects\project\src\main\java\" type="XMLMAPPER" />
    // ↑  3行すべてに、MyBatisのクラスを入れたいパッケージ名と、プロジェクトのファイルパスを入れてください
    <table schema="student" tableName="classA" >
    // ↑　DB名とテーブル名を入れてください
    </table>
  </context>
</generatorConfiguration>

　いよいよファイルを自動生成する

上で作った xml ファイルを Maven から実行します。

※NetBeans の場合

pom.xml を右クリック > Mavenの実行 > ゴール > ゴール欄に
「mybatis-generator:generate」を入力してOK

生成に失敗した場合 MySQL への接続失敗の可能性が高いです。以下の点を確認してみてください。

• ローカルの MySQL に指定の ID と PW でちゃんと接続できるか
• generatorConfig.xml の Connector/Jのパス指定を間違えていないか
• generatorConfig.xml の DB名、テーブル名の指定を間違えていないか

他の IDE をご使用の方は IDE から Maven ゴールを実行する方法を調べてみてください。

　Generator によって生成されたファイルを見てみる

生成に成功するとテーブル名が先頭についた以下のような4ファイルが出来ているはずです。

1. エンティティクラス
2. クエリ条件サンプルクラス
3. マッパークラス
4. マッパー設定XMLファイル

これらを使えば簡単に DBアクセスのプログラムが作れます。generatorConfig.xml を作るのがちょっとめんどくさいかもしれませんが、仮に手動で4つのファイルを作ろうとすると10倍時間がかかりますｗ　それに比べたらだいぶ楽だと思います。

いかがでしたか？今回は MyBatis を簡単に使い始めるためのファイルを Generator を使って生成してみました。これらのファイルを使って DB操作してみると、カスタマイズして使いこなす一助になると思います。