前回は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の実戦的な機能をご紹介します。

前段・WebSocketはなぜ生まれたか

伝統的なWebアプリケーションは、HTTPというプロトコルで成立していました。HTTPとは単純なリクエスト・レスポンスモデルであり「クライアントであるWebブラウザがWebサーバに対してリクエストを投げ、返って来たレスポンスを処理する」というモデルで成り立っていました。あくまでクライアントが処理の起点となっているのです。

一方、Webアプリケーションであっても「サーバ側で起きた何らかの出来事を、Webブラウザに通知したい」というニーズは常にありました。これを「サーバプッシュ」と言います。これまで、HTTPを使って擬似的なサーバプッシュを実現するために技術者は様々な工夫を凝らしてきました。しかしやはり、リクエスト・レスポンスモデルの下では無理があったのです。

このような経緯があり、Webブラウザでの真のサーバプッシュを実現するべく策定されたのがWebSocketというプロトコルです。

もちろんJavaEEでもWebSocketはサポートされています。

本エントリではJavaEE7で導入されたWebSocketサーバを簡単に実現する機能をご紹介します。

最小のサンプル

これまで紹介してきたように、JavaEEでは、ある機能を使うのにアノテーションを付与したクラスを単に作成するだけで良い、というスタイルが広く採用されています。WebSocketも例外ではありません。

下記は最小のサンプルです。

package sandbox.websocket.minimum;

import javax.websocket.OnMessage;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint("/ws/min")
public class MinimumEndpoint {

    @OnMessage
    public String onMessage(final String pText) {
        System.out.println(pText);
        return "Re: " + pText;
    }
}

@ServerEndpointアノテーションを付けたクラスはWebSocketサーバとなります。このようなクラスをEndpointクラスと呼びます。

さらに@OnMessageアノテーションでクライアントから送信されたメッセージを処理するメソッドを指定しています。メッセージの処理内容は、送信されたメッセージの頭に「Re: 」を付けて送り返しています。

このクラスのテストのために、次のようなHTMLを作ってみましょう。

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>WebSocket最小のサンプル</title>
  </head>
  <body>
    <input type="text">
    <button type="button" class="btn btn-primary form-control">送信</button>
    <script src="https://code.jquery.com/jquery-2.2.0.min.js"></script>
    <script>
       var ws = null;
       var onOpen = function() {
           $('button').click(function() {
               ws.send($('input').val());
           });
       };
       var onMessage = function(e) {
           alert(e.data);
       };
       var connect = function() {
           ws = new WebSocket('ws://localhost:' + location.port + '/ws/min');
           ws.onopen = onOpen;
           ws.onmessage = onMessage;
       };
       connect();
    </script>
  </body>
</html>

テキストフィールドに文字を入力して「送信」ボタンを押すと、先頭に「Re: 」を付けた文字列がアラートで表示されるサンプルです。

いかがでしょうか。いとも簡単にWebSocketを使ったアプリケーションが作れてしまうことが分かっていただけたかと思います。

ただ、このサンプルはWebブラウザからのリクエストが起点であるため、Ajaxでも実現可能でありWebSocketの旨味がないサンプルです。そこで以降では、WebSocketを使うための実践的な機能を紹介していきます。

@OnMessage以外のアノテーション

@OnMessageアノテーションの他にも@OnOpen/@OnError/@OnCloseというアノテーションがあり、これらのアノテーションが付与されたメソッドは、適切なタイミングでJavaEEコンテナから呼び出されるコールバックメソッドとなります。

下記に典型的なEndpointクラスの宣言方法を示します。

package sandbox.websocket.sample;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint("/ws/sample")
public class SampleEndpoint {

    @OnOpen
    public void onOpen(Session pSession) {
    }

    @OnMessage
    public void onMessage(String pMessage) {
    }

    @OnError
    public void onError(Throwable pError) {
    }

    @OnClose
    public void onClose(Session pSession) {
    }
}

各メソッドはpublicである必要があります。

また@OnErrorコールバックメソッドは、Throwableを引数に取る必要があります。

それ以外のメソッドの引数は必要に応じて増減させることが可能です。例えば、@OnMessageのコールバックでSessionが必要なら、引数に追加してください。

URIテンプレート

接続先を分類するために、URLにパラメータを含めることが出来ます。

@ServerEndpoint("/ws/rooms/{room-descriptor}")
public class DescriptorEndpoint {
    ...

これを使うと、チャットルームの入室管理のようなことが比較的簡単に実装できます。簡単なチャットサーバのコードをご紹介します。

package sandbox.websocket.descritpor;

import java.io.IOException;

import javax.inject.Inject;
import javax.websocket.OnClose;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint("/ws/rooms/{room-descriptor}")
public class DescriptorEndpoint {

    @Inject
    WebSocketSessionManager sessionManager;

    @OnOpen
    public void onOpen(@PathParam("room-descriptor") final String pRoomDescriptor, final Session pSession) {
        this.sessionManager.addSession(pRoomDescriptor, pSession);
    }

    @OnClose
    public void onClose(@PathParam("room-descriptor") final String pRoomDescriptor, final Session pSession) {
        this.sessionManager.removeSession(pRoomDescriptor, pSession);
    }

    @OnMessage
    public void onMessage(@PathParam("room-descriptor") final String pRoomDescriptor, final String pText) {
        for (final Session session : this.sessionManager.getSessions(pRoomDescriptor)) {
            try {
                session.getBasicRemote().sendText("Re: " + pText);
            } catch (final IOException e) {
                e.printStackTrace();
            }
        }
    }
}

注目していただきたいのは次の２点です。

• @ServerEndpointの引数にroom-descriptorというパラメータを含めている
• メソッドの引数に@PathParam("room-descriptor")を指定することでパラメータの値を得ている

なおEndpointクラスはCDIによるスコープ管理が効きません。たとえシングルトンな作りにしたくても、それが叶わないのです。

しかしインジェクション対象にすることはできます。ここでは、チャットルーム毎のWebSocket接続を管理するクラス（WebSocketSessionManager）をシングルトンとして作成し、@Injectアノテーションでインジェクションしています。

WebSocketSessionManagerクラスのコードも掲載しておきます。

package sandbox.websocket.descritpor;

import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CopyOnWriteArrayList;

import javax.enterprise.context.ApplicationScoped;
import javax.websocket.Session;

@ApplicationScoped
public class WebSocketSessionManager {

    private final ConcurrentMap<String, Lock>          locks    = new ConcurrentHashMap<>();
    private final ConcurrentMap<String, List<Session>> sessions = new ConcurrentHashMap<String, List<Session>>() {
        public List<Session> get(final Object key) {
            List<Session> ret = super.get(key);
            if (ret == null) {
                ret = new CopyOnWriteArrayList<>();
                this.put((String) key, ret);
            }
            return ret;
        }
    };

    public void addSession(final String pRoomDescriptor, final Session pSession) {
        synchronized (this.getLock(pRoomDescriptor)) {
            this.sessions.get(pRoomDescriptor).add(pSession);
        }
    }

    public List<Session> getSessions(final String pRoomDescriptor) {
        return this.sessions.get(pRoomDescriptor);
    }

    public void removeSession(final String pRoomDescriptor, final Session pSession) {
        synchronized (this.getLock(pRoomDescriptor)) {
            this.sessions.get(pRoomDescriptor).remove(pSession);
        }
    }

    private Lock getLock(final String pRoomDescriptor) {
        final Lock newLock = new Lock();
        final Lock alreadyLock = this.locks.putIfAbsent(pRoomDescriptor, newLock);
        return alreadyLock == null ? newLock : alreadyLock;
    }

    private static class Lock {
        // nodef
    }

}

スレッドセーフにするために少し複雑なコードになっていますが、結局やっていることは部屋毎にWebSocket接続を束ねているだけなので、臆さず読み解いてみてください。

最後に、これをテストするためのHTMLを掲載します。

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>WebSocket識別子のサンプル</title>
  </head>
  <body>
    <input type="text" name="desc" placeholder="部屋の識別子">
    <button type="button" class="connector">接続</button>
    <hr/>
    <input type="text" name="text" placeholder="送信テキスト">
    <button type="button" class="sender" disabled="disabled">送信</button>
    <hr/>
    <h3>レスポンス</h3>
    <p class="response"></p>
    <script src="https://code.jquery.com/jquery-2.2.0.min.js"></script>
    <script>
       var ws = null;
       $('button.connector').click(function() {
           if (ws) ws.close();
           var url = 'ws://localhost:' + location.port + '/ws/rooms/' + $('input[name="desc"]').val();
           ws = new WebSocket(url);
           ws.onmessage = function(e) {
               $('.response').text(e.data);
           };
           ws.onopen = function() {
               $('button.sender').removeAttr('disabled');
           };
           ws.onclose = function() {
               $('button.sender').attr('disabled', 'disabled');
           };
       });
       $('button.sender').click(function() {
            if (!ws || ws.readyState !== WebSocket.OPEN) {
               alert('先に接続して下さい。');
               return;
           }
           ws.send($('input[name="text"]').val());
       });
    </script>
  </body>
</html>

動作を見てみるときは、ぜひ複数のWebブラウザを開いてください。誰かの投稿が同じ部屋の全員に配信されることが分かると思います。とてもシンプルですが、チャットアプリケーションができました。

DecoderとEncoder

WebSocketはテキストデータとバイナリデータをやり取りできます。一般的には扱いやすいJSON形式のテキストを使うことが多いでしょう。しかしEndpointクラスを普通に作ると、@OnMessageコールバックの引数や戻り値の型は、単なるString型です。せっかくJavaを使っているのですから、ここはデータクラスに変換して型安全にメッセージを扱いたいものです。

この要求に応えるのが、Decoder/Encoderです。

Decoderクラス

Decoderクラスにはクライアント（一般的にはWebブラウザ）から送られてきたメッセージ内容を任意のJavaオブジェクトに変換する処理を実装します。このクラスを作成すると、Endpointクラスの@OnMessageコールバックメソッドに引数にString以外の型が使えるようになります。

ここでは ClientMessageというクラスを導入して、Decoderクラスを作ってみます。なおJSONとJavaオブジェクトの変換にはJSONICというライブラリを使っています。

まずはClientMessageクラスです。getterとsetterのみの単なるデータクラスとして作りましょう。

package sandbox.websocket.json;

import java.util.Date;

public class ClientMessage {
    private Date   date;
    private String body;
    // getter/setterは省略
}

次にDecoderです。JsonDecoderという名前で作ります。なお使い方は後で説明します。

package sandbox.websocket.json;

import javax.websocket.DecodeException;
import javax.websocket.Decoder;
import javax.websocket.EndpointConfig;

import net.arnx.jsonic.JSON;

public class JsonDecoder implements Decoder.Text<ClientMessage> {

    @Override
    public void init(@SuppressWarnings("unused") final EndpointConfig pConfig) {
        // nop
    }

    @Override
    public boolean willDecode(@SuppressWarnings("unused") final String pRequest) {
        return true; // デコード対象としない場合はfalseを返すが、通常はtrueでOK.
    }

    @Override
    public ClientMessage decode(final String pRequestJsonString) throws DecodeException {
        return JSON.decode(pRequestJsonString, ClientMessage.class);
    }

    @Override
    public void destroy() {
        // nop
    }
}

なおJSON文字列とJavaオブジェクトの変換にはJSONICというライブラリを使っています。

Encoderクラス

次にEncoderクラスを作ってみます。

Encoderクラスには、Javaオブジェクトをクライアントに送信するメッセージに変換する処理を実装します。このクラスを作成すると、Endpointクラスの@OnMessageコールバックメソッドの戻り値にString以外の型が使えるようになります。

ここではServerMessageというクラスを導入して、Encoderクラスを作ってみます。

ServerMessageクラスも、getterとsetterのみの単なるデータクラスとして作ります。

package sandbox.websocket.json;

import java.util.Date;

public class ServerMessage {
    private Date   date;
    private String body;
    private String senderSessionId;
    // getterとsetterは省略
}

次に、JsonEncoderを作りましょう。これも使い方は後で説明します。

package sandbox.websocket.json;

import javax.websocket.EncodeException;
import javax.websocket.Encoder;
import javax.websocket.EndpointConfig;

import net.arnx.jsonic.JSON;

public class JsonEncoder implements Encoder.Text<ServerMessage> {

    @Override
    public void init(@SuppressWarnings("unused") final EndpointConfig pConfig) {
        // nop
    }

    @Override
    public String encode(final ServerMessage pResponse) throws EncodeException {
        return JSON.encode(pResponse);
    }

    @Override
    public void destroy() {
        // nop
    }
}

DecoderとEncoderを使う

作成したDecoderとEncoderはEndpointクラスの中で使います。ポイントは次の２点です。

• Endpointクラスの@ServerEndpointアノテーションのdecodersとencodersに作ったクラスを指定
• @OnMessageコールバックメソッドの引数と戻り値にデータクラスを指定

それではサンプルコードを見てみましょう。

package sandbox.websocket.json;

import java.util.Calendar;

import javax.websocket.OnMessage;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint(value = "/ws/dec-enc" //
, decoders = JsonDecoder.class //
, encoders = JsonEncoder.class)
public class DecEncEndpoint {

    @OnMessage
    public ServerMessage onMessage(final Session pSession, final ClientMessage pRequest) {
        final ServerMessage ret = new ServerMessage();
        ret.setBody("Re: " + pRequest.getBody());
        ret.setDate(Calendar.getInstance().getTime());
        ret.setSenderSessionId(pSession.getId());
        return ret;
    }
}

String型がなくなり、データクラスを通して型安全にデータ操作ができるようになりました。

テスト用のHTMLも掲載します。

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Decoder/Encoderのサンプル</title>
  </head>
  <body>
    <input type="text" name="text" placeholder="送信テキスト">
    <button type="button" class="btn btn-primary form-control">送信</button>
    <script src="https://code.jquery.com/jquery-2.2.0.min.js"></script>
    <script>
       var ws = null;
       var onOpen = function() {
           $('button').click(function() {
               ws.send(JSON.stringify({ body: $('input[name="text"]').val() }));
           });
       };
       var onMessage = function(e) {
           alert(e.data);
       };
       var connect = function() {
           ws = new WebSocket('ws://localhost:' + location.port + '/ws/dec-enc');
           ws.onopen = onOpen;
           ws.onmessage = onMessage;
       };
       connect();
    </script>
  </body>
</html>

動作させてみると、JSON形式のデータをやり取り出来ていることが分かると思います。

データ変換の流れのまとめ

登場人物が多くなり少し複雑になったため、データ変換の流れを整理してみました。

変換処理の流れと、Decoder/Encoderがどのような役割を担っているかを理解いただけたでしょうか。

最後に

以上、JavaEEのWebSocketに関する機能をご紹介しました。

実戦ではもっとたくさんのことに気を配る必要があります。例えばエラー処理やスケーリング、認証、リクエスト内容の解析などの処理が必要です。

しかしWebSocketの根幹となる機能は、本エントリでご紹介した機能で充分カバーされていると思います。JavaEEで作るWebアプリケーションにもどんどんWebSocketを取り入れて、新しいユーザ体験を提供していきましょう。

APIはWebアプリケーションの用途を大きく広げる重要な要素であり、また、これをシンプルなインターフェイスであるREST形式で提供することは、より APIを利用しやすくするための重要な手法となっています。

本エントリではJavaEEでRESTインターフェイスを提供するための仕様であるJAX-RSをご紹介します。

JAX-RSとは

前述のように、RESTによるAPI提供の重要性は増すばかりです。JavaEEにおいても、JavaEE6からRESTインターフェイスを開発するための仕様であるJAX-RSが提供されるようになりました。

JAX-RSの特徴として、アノテーションを使ったシンプルな開発スタイルが挙げられます。まずは基本的な使い方を見てみましょう。

最小のサンプル

それではJAX-RSの最小のサンプルを作ってみましょう。JavaEEコンテナ環境下であれば、たった２つのファイルを作るだけで済みます。

JAX-RSの設定クラス

まずはJAX-RSの設定を持つクラスを作りましょう。

package sandbox.web.api;

import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;

@ApplicationPath("/api")
public class RestApplication extends Application {
    // nodef
}

ポイントは２つ。

1. @ApplicationPath("/api")というアノテーションにより/api以下がJAX-RSで扱うURLになります
2. javax.ws.rs.core.Applicationクラスを継承します。

クラス名はどんな名前でも構いません。また実装は何も必要ありません。

リソースクラス

JAX-RSによる開発の主たる作業は、リソースクラスを作ることです。

リソースというのは情報の断片のことで、URLで識別されるものです。リソースクラスは、リソースに対する操作をリクエストに従って処理するクラスとなります。

ここでは次のような仕様のリソースを、リソースクラスで実装してみましょう。

• Hello, Worldというテキストをリソースとする
• /api/hello/textというパスに対するGETメソッドでテキストが得られる
• テキストのContent-Typeはtext/plain

クラス名は何でもいいのですが、ここでは分かりやすくHelloResourceとしましょう。

package sandbox.web.api;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/hello")
public class HelloResource {

    @Path("/text")
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String asText() {
        return "Hello, World";
    }
}

仕様がそのままアノテーションで表現されていますね。

ではブラウザで次のURLにアクセスしてみましょう。

次のような画面が表示されるはずです。

リソースクラスのポイント

JAX-RSの根幹、リソースクラスを詳しく見てみましょう。とはいえ非常に直感的なコードになっていますので、読み解きやすいと思います。

@PathアノテーションとURLの関係

クラスとメソッドに@Pathアノテーションを付与することで、このリソースクラスにアクセスするためのパス（≒URLの一部）を表現しています。

クラス宣言の@Pathアノテーションは、このリソースが/helloというパスで表されることを示しています。

@Path("/hello")
public class HelloResource

メソッド宣言の@Pathアノテーションは、このリソースに実際にアクセスするためのパスを示しています。

@Path("/text")
@GET
@Produces(MediaType.TEXT_PLAIN)
public String asText()

実際にアクセスするためのパスは、JAX-RSの設定クラスに付与した@ApplicationPathアノテーションにも影響されることに注意してください。

/api/hello/textというパスの階層毎に対応するアノテーションをまとめてみましたので、イメージしてみてください。

メソッドに付与された@GET/@Producesアノテーション

リソースクラスのメソッドには、@Pathの他にも２つのアノテーションが付いています。いずれも重要なアノテーションです。

@GETアノテーションは、メソッドが動作するHTTPメソッドがGETであることを示しています。HTTPメソッドに該当するアノテーションとして、他にも@PUT/@POST/@DELETEなどがあります。

@Producesアノテーションは、このメソッドが返す値をどのようなデータ形式で返すかを示していて、HTTP応答ヘッダ内のContent-Typeを指定していることに相当します。

このようにJAX-RSによるREST開発は、HTTPインターフェイスをアノテーションを駆使して表現するというスタイルになります。

それではJAX-RSが提供する様々な機能を見ていきましょう。多数の機能があるのですが、重要なものに絞ってご紹介します。

POSTメソッドに対応する

POSTメソッドでアクセスされた時に動くメソッドには@POSTアノテーションを付与します。

@Path("text")
@POST
public void postText(@FormParam("text") final String pText) {
    System.out.println(pText);
}

パラメータを@FormParamアノテーションで受け取っています。これは後ほど、もっと詳しく解説します。

同じ考え方で、PUTメソッドやDELETEメソッドにも対応できます。単に@PUTや@DELETEアノテーションを付与すればいいのです。直感的ですね。

@QueryParamアノテーションでクエリパラメータを受け取る

クエリパラメータとは、URLの?以降の部分を言います。例えば以下のURLのクエリパラメータはformat=jsonです。

http://example.com/api/hello/text?format=json

これをリソースクラスで受け取るには、メソッド引数に@QueryParamアノテーションを付与します。

@Path("/text-with-format")
@GET
@Produces(MediaType.TEXT_PLAIN)
public String getTextWithFormat(@QueryParam("format") final String pFormat) {
    return "Hello, World" + "(format=" + pFormat + ")";
}

ブラウザで次のURLにアクセスしてみてください。

確かにクエリパラメータが受け取れていますね。

@FormParamアノテーションでformのパラメータを受け取る

HTMLのformタグで送信するデータはapplication/x-www-form-urlencodedという形式であり、次のような書式のデータです。

param1=value1&param2=value2

JAX-RSではこの形式のデータは特別扱いであり、メソッドの引数に@FormParamアノテーションを付与することで値を受け取ることができます。

@Path("text")
@POST
@Produces(MediaType.TEXT_PLAIN)
public void postText(@FormParam("text") final String pText) {
    System.out.println(pText);
}

少し横道・JAX-RSのクライアントAPIによるテスト

RESTインターフェイスのテストを実施する際、GETであればブラウザで手軽にテストできますが、POSTやPUT、DELETEはそうはいきません。ところがJAX-RSにはクライアント用のAPIが備わっており、手軽にリソースクラスをテストすることができます。

JAX-RSのクライアント APIを使ってPOSTを送るサンプルを掲載しておきます。

public static void main(final String[] pArgs) {
    final Response response = ClientBuilder.newClient() //
            .target("http://localhost:8081/api") // 実行するWeb APIのエントリポイント
            .path("/hello/text") // リクエストを投げるURLのパス部分
            .request(MediaType.TEXT_PLAIN_TYPE) // 受け入れ可能なレスポンス形式(HTTPヘッダでいうAcceptに相当)
            // application/x-www-form-urlencoded形式でデータを作成(HTTPヘッダでいうContent-Typeに相当)し、リクエストを送信.
            .post(Entity.<String> entity("text=hoge", MediaType.APPLICATION_FORM_URLENCODED_TYPE));
    System.out.println(response.getStatusInfo());
}

パスパラメータを受け取る

URLの一部がパラメータになっているケースがよくあります。例えばよくあるブログエントリのURLがこれに相当します。

http://example.com/blog/2015/12/17

2015年12月17日のエントリという意味ですね。JAX-RSでこのようなパラメータを受け取るには、２つのアノテーションを併用します。

1. メソッドの@PathアノテーションでURLパラメータを表現
2. メソッド引数に@PathParamアノテーションを付与し値を受け取る

以下、サンプルです。

@Path("/date/{year}/{month}/{date}")
@GET
@Produces("text/plain; charset=UTF-8")
public String getDateText( //
        @PathParam("year") final int pYear //
        , @PathParam("month") final int pMonth //
        , @PathParam("date") final int pDate //
) {
    return String.format("%d年%d月%d日", pYear, pMonth, pDate);
}

@Pathアノテーションに{パラメータ名}というスタイルでパラメータを表現しているのが分かると思います。

ブラウザで次のURLにアクセスしてみてください。

HTTPリクエストのヘッダ情報を受け取る

時にはクライアントから送信されてきたHTTPヘッダの情報が必要な時があります。この場合、HttpHeaders型のメソッド引数を作り@Contextアノテーションを付与します。するとHttpHeadersを通してヘッダ情報が得られます。

@Path("/headers/{headerName}")
@GET
@Produces(MediaType.TEXT_PLAIN)
public String getRequestHeaderValue( //
        @PathParam("headerName") final String pHeaderName //
        , @Context final HttpHeaders pHeaders) {
    return String.valueOf(pHeaders.getRequestHeader(pHeaderName));
}

ブラウザで次のURLにアクセスしてみてください。

Servlet APIにアクセスする

リソースクラスの中でServlet APIにアクセスしたい場合、メソッド引数にServlet APIのオブジェクトを指定し、そこに@Contextアノテーションを付与します。

@Path("/text")
@GET
@Produces(MediaType.TEXT_PLAIN)
public String asText( //
        @Context final HttpServletRequest pRequest //
        , @Context final ServletContext pContext) {
    System.out.println(pRequest);
    System.out.println(pContext);
    return "Hello, World";
}

上記のように、HttpServletRequestとServletContextは取得可能ですが、HttpSessionはこの方法では取得できません。本来、RESTとHttpSessionは相容れないものですのでこの仕様は妥当と言えますが、どうしてもHttpSessionが必要な場合は、次のようにして取得してください。

@Path("/session-info")
@GET
@Produces(MediaType.TEXT_PLAIN)
public String sessionInfo(@Context final HttpServletRequest pRequest) {
    return String.valueOf(pRequest.getSession());
}

CDIの適用

リソースクラスはJavaEEコンテナ管理であるためCDI連携が可能です。ただ、CDI対象であることをコンテナに示すために、クラス宣言に@Dependentアノテーションを付与する必要があることに注意してください。

このことを踏まえると、リソースクラスは下記のようなコードになります。

@Path("/hello")
@Dependent
public class HelloResource {

    @Inject
    HogeService hogeService;

なおCDIの詳しいことについては本ブログの「JavaEE屈指の便利機能、CDIを触ってみよう」というエントリをご参照ください。

JSONでデータをやり取りする

最後に、実践的な内容としてJSONでデータをやり取りする方法をご紹介します。

昨今のWebAPIの多くはJSON形式でデータをやり取りしますが、JAX-RSはデフォルトではJSONを扱えません。多少の設定追加が必要ですので、この章で見て行きましょう。

データ変換用のクラスを作成する

JAX-RSには、Content-Typeに応じてJavaオブジェクトを変換する処理を選択／実行する機能が備わっています。

ここではContent-Typeがapplication/jsonの時に動作する変換用クラスを作成します。MessageBodyReaderとMessageBodyWriterインターフェイスを実装し、@Providerアノテーションを付与するのがポイントです。

実装すべきメソッドは５つあります。各メソッドの意味はコメントに書いておきました。どれも引数が多く見にくいかもしれませんが、実際のメソッドの中身はどれも１行ですので、臆さず読んでみてください。

package sandbox.jax_rs;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;

import javax.ws.rs.Consumes;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.MessageBodyReader;
import javax.ws.rs.ext.MessageBodyWriter;
import javax.ws.rs.ext.Provider;

import net.arnx.jsonic.JSON;

@Provider
@Consumes(MediaType.APPLICATION_JSON) // リクエストのContent-Typeがapplication/jsonの時に当クラスが実行される
@Produces(MediaType.APPLICATION_JSON) // レスポンスのContent-Typeがapplication/jsonの時に当クラスが実行される
public class JsonConverter implements MessageBodyReader<Object>, MessageBodyWriter<Object> {

    /**
     * クライアントに返すデータの長さを返しますが、不明な場合は-1を返します.
     */
    @Override
    public long getSize(final Object pT, final Class<?> pType, final Type pGenericType, final Annotation[] pAnnotations, final MediaType pMediaType) {
        return -1;
    }

    /**
     * クライアントから送られてきたデータのContent-Typeが、このクラスで処理可能かどうかを返します. <br>
     * このクラスの場合、application/jsonを処理するようにします.
     */
    @Override
    public boolean isReadable(final Class<?> pType, final Type pGenericType, final Annotation[] pAnnotations, final MediaType pMediaType) {
        return pMediaType.isCompatible(MediaType.APPLICATION_JSON_TYPE);
    }

    /**
     * クライアントに送り返すデータのContent-Typeが、このクラスで処理可能かどうかを返します. <br>
     * このクラスの場合、application/jsonを処理するようにします.
     */
    @Override
    public boolean isWriteable(final Class<?> pType, final Type pGenericType, final Annotation[] pAnnotations, final MediaType pMediaType) {
        return pMediaType.isCompatible(MediaType.APPLICATION_JSON_TYPE);
    }

    /**
     * クライアントからのデータをJavaオブジェクトに変換して返します. <br>
     * ここではクライアントからのデータをJSONと決め打ちして処理します. <br>
     */
    @Override
    public Object readFrom(final Class<Object> pType, final Type pGenericType, final Annotation[] pAnnotations, final MediaType pMediaType,
            final MultivaluedMap<String, String> pHttpHeaders, final InputStream pEntityStream) throws IOException, WebApplicationException {
        return JSON.decode(pEntityStream, pType);
    }

    /**
     * Javaオブジェクトを変換してクライアントに返します. <br>
     * ここではJSONに変換します. <br>
     */
    @Override
    public void writeTo(final Object pT, final Class<?> pType, final Type pGenericType, final Annotation[] pAnnotations, final MediaType pMediaType,
            final MultivaluedMap<String, Object> pHttpHeaders, final OutputStream pEntityStream) throws IOException, WebApplicationException {
        JSON.encode(pT, pEntityStream);
    }
}

なおこJSONとJavaオブジェクトの変換にはJSONICというライブラリを使っています。

リソースクラスでJSONレスポンスを返す

それではリソースクラスにJSON形式でデータを返すメソッドを追加しましょう。

@Path("/json")
@GET
@Produces(MediaType.APPLICATION_JSON)
public Map<String, Object> asJson() {
    final Map<String, Object> ret = new HashMap<>();
    ret.put("response", "Hello, World");
    return ret;
}

@Produces(MediaType.APPLICATION_JSON)というアノテーションにより、レスポンスをJSON形式にすることを示しています。

それではブラウザで次のURLにアクセスして下さい。

レスポンスがJSON形式のデータであることや、レスポンスヘッダのContent-Typeがapplication/jsonになっていることが確認できます。

リソースクラスでJSONを受け取る

次にJSON形式のデータをPOSTで受け取るメソッドを作ってみましょう。

@Path("/json")
@POST
@Consumes(MediaType.APPLICATION_JSON)
public void postJson(final Map<String, Object> pJson) {
    System.out.println(pJson.get("request"));
}

@Consumes(MediaType.APPLICATION_JSON)というアノテーションで、リクエストのContent-Typeがapplication/jsonである場合にこのメソッドが動作することを示しています。

クライアントAPIで動作確認をしてみましょう。

public static void main(final String[] pArgs) {
    final Response response = ClientBuilder.newClient() //
            .target("http://localhost:8081/api") //
            .path("/hello/json") //
            .request() //
            .post(Entity.<String> entity("{ \"request\": \"This is json request.\" }", MediaType.APPLICATION_JSON));
    System.out.println(response.getStatusInfo());
}

このメソッドを実行すると、リソースクラスのpostJson()メソッドが動作することが確認できるはずです。

まとめ

駆け足でJAX-RSを見てきました。実にシンプルな上、RESTの考え方にマッチした分かりやすい仕様になっているため、学びやすいと思います。

本エントリでは紹介しきれなかった機能の中には、サブリソースやキャッシュ制御、レスポンスの詳細な制御など重要なものがあります。幸い、オライリーから良いJAX-RSの指南書が出ています。分量が少なく読みやすいため、ぜひご一読をおすすめします。

冒頭に書いたように、Web APIの重要性は増すばかりです。JAX-RSを使ってRESTフルなAPIをどんどん開発し、Webサービスの価値を高めましょう。

Wicketとは

Wicketはユーザインターフェイス（UI）を担当するフレームワークです。世の中にはJavaEEやPlay Framework、Ninjaのようにフルスタックなフレームワークも存在しますが、Wicketは、StrutsのようにUI層に特化しています。

事例としてはピザハットのサイトがあります。

Java製Webアプリケーションフレームワークは数多くありますが、Wicketの特徴はどこにあるのでしょうか。

Wicketの大事な２つの特徴

1.「Javaらしい」コードでWebアプリケーションを作れる

Wicket最大の特徴はオブジェクト指向を活用したJavaらしいコードでWebアプリケーションを作れることです。
オブジェクト指向の機能と言えば継承やカプセル化による部品化などでしょうか。Wicketはこれらの機能をうまく活用し、継承による画面レイアウトの共通化や、共通部品のクラス化などを可能にしています。
これによりJavaによるプログラミングを楽しみながらWebアプリケーションを作ることが出来るのです。
またほとんど全ての機能をJavaのコードとして記述することから、型安全性やリファクタリングしやすい、などの恩恵もあります。

2. Ajaxが統合されている

WicketはAjaxを上手に取り込んでいます。開発者は少しの作法を覚えるだけで、Ajaxを使った応答性の良いWebアプリケーションを作ることが出来るのです。

その他の特徴

• デフォルトでセキュア
• データと画面を柔軟に結合するModelの提供
• マルチタブやマルチウィンドウへの配慮
• 宣言的なマークアップ
• ユニットテスト用クラスの提供

この記事では大事な２つの特徴に絞ってご紹介しますが、更に詳しい情報を得たい方はWicketの本家Webサイトをご覧下さい。

第一章　最初のサンプル

1. Mavenによる雛形アプリの作成

まずはWebアプリ開発プロジェクトの雛形を作ります。
2015年7月にWicketは7系へのメジャーバージョンアップを果たしました。ここでは7系を使ってサンプルを作って行きましょう。
WicketはMavenのarchetypeを提供していますので、これを利用します。Mavenの導入は事前に済ませておいて下さい。

ターミナル、あるいはコマンドプロンプトで次のコマンドを実行して下さい。

mvn archetype:generate -DgroupId=sandbox -DartifactId=WicketSandbox -DarchetypeGroupId=org.apache.wicket -DarchetypeArtifactId=wicket-archetype-quickstart -DarchetypeVersion=7.0.0 -DarchetypeRepository=https://repository.apache.org/ -DinteractiveMode=false

groupIdとartifactIdは適切に変更して下さい。なおこのコマンドはWicketのQuickstartページで編集出来ます。

2. 雛形アプリの起動

mvnコマンドの実行が完了したら、動作する雛形アプリが出来上がっています。早速起動してみましょう。

cd WicketSandbox
mvn jetty:run

WicketSandboxの部分はご自分のartifactIdに合わせて適切に変更して下さい。

コンソールにテキストがずらずらと表示され、下記のように「Started Jetty Server」と表示されれば起動が完了しています。

********************************************************************
*** WARNING: Wicket is running in DEVELOPMENT mode.              ***
***                               ^^^^^^^^^^^                    ***
*** Do NOT deploy to your live server(s) without changing this.  ***
*** See Application#getConfigurationType() for more information. ***
********************************************************************
2015-10-07 06:56:47.966:INFO:oejsh.ContextHandler:main: Started o.e.j.m.p.JettyWebAppContext@12d54304{/,file:/Users/jabaraster/Documents/Develop/Java/workspace/projects/WicketSandbox/src/main/webapp/,AVAILABLE}{file:/Users/jabaraster/Documents/Develop/Java/workspace/projects/WicketSandbox/src/main/webapp/}
2015-10-07 06:56:47.967:WARN:oejsh.RequestLogHandler:main: !RequestLog
2015-10-07 06:56:48.001:INFO:oejs.ServerConnector:main: Started ServerConnector@319f9f37{HTTP/1.1}{0.0.0.0:8080}
2015-10-07 06:56:48.303:INFO:oejs.ServerConnector:main: Started ServerConnector@4602f47{SSL-http/1.1}{0.0.0.0:8443}
2015-10-07 06:56:48.304:INFO:oejs.Server:main: Started @8721ms
[INFO] Started Jetty Server

次のURLにアクセスして画面を確認してみましょう。

http://localhost:8080

次の画面がブラウザに表示されれば起動に成功しています！

第二章　Wicketによる開発の概念を知る

雛形アプリの中身を見ていく前に、Wicketによる開発の考え方を押さえておきましょう。

1. HTMLとぺージクラスで画面を作る

WicketはHTMLで画面を作り、画面に対しページクラスを作ることでWebアプリケーションを構築します。

2. ページクラスの中にコンポーネントを配置

ページクラスの中には様々な種類のコンポーネントを配置します。コンポーネントはHTMLの一部に相当します。例えば<button></button>タグに相当するButtonクラスなどがあります。Buttonクラスのような基本的なコンポーネントはもちろん、多くのコンポーネントがWicketから提供されています。また必要であれば自作することも出来ます。コンポーネントを知ることはWicketを使う上で重要なポイントになります。

3. コンポーネントは入れ子に出来る

コンポーネントによっては、中に１個以上の子コンポーネントを持つことが出来ます。コンポーネントは入れ子に出来るわけです。
実はページクラスもコンポーネントです。Wicketのページクラスは、ページクラスを根本としたコンポーネントのツリー構造となります。

第三章　HTMLとぺージクラスのポイントを押さえる

Wicketで最も重要なのはHTMLとぺージクラスの作り方です。ここでは雛形アプリを使ってポイントを押さえておきます。
雛形アプリのファイル構成を見ると、「HomePage」から始まるファイルが２つあります。ぺージクラスと、それに対応するHTMLファイルです。

まずはぺージクラスのコードを見てみましょう。

package sandbox;

import org.apache.wicket.request.mapper.parameter.PageParameters;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.WebPage;

public class HomePage extends WebPage {
    private static final long serialVersionUID = 1L;

    public HomePage(final PageParameters parameters) {
        super(parameters);

        // Labelコンポーネントをぺージクラスに追加z
        add(new Label("version", getApplication().getFrameworkSettings().getVersion()));

        // TODO Add your page's components here

    }
}

ポイントを挙げておきます。

• ７行目：ぺージクラスはWebPageクラスを継承
• 14行目：ぺージクラスの子としてLabelコンポーネントを追加

次にHTMLを見てみます・・・と言いたいところですが、雛形アプリのHTMLファイルはかなりコード量が多く大事な部分が見えにくいですから、思い切って重要でない部分を落としてしまいましょう。次のようにHTMLを書き換えて下さい。

<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org">
	<head>
		<meta charset="utf-8" />
		<title>Apache Wicket Quickstart</title>
	</head>
	<body>
		Wicketのバージョン: <span wicket:id="version">ここに使っているWicketのバージョンが入ります</span>
	</body>
</html>

何の変哲もないHTMLですが、１つだけ変な記述がありますね。８行目のwicket:id属性です。

wicket:id属性は、HTMLのタグをページクラスで追加したコンポーネントと関連付けるものです。ぺージクラスのコードのコンポーネント追加部分を再掲します。

add(new Label("version", getApplication().getFrameworkSettings().getVersion()));

Labelクラスのコンストラクタの第一引数に注目して下さい。”version”となっており、HTMLのwicket:id属性の値”version”と一致しています。ここがポイントです。

Wicketでは、コンポーネントの第１引数に必ずIDを取るようになっています。このIDとHTML上のwicket:id属性の値を一致させることで、コンポーネントと関連付けられます。

以上がWicketを使う上で最低限知っておかなければならないことです。

第四章　コンポーネントを使う

実際にWebアプリケーションを作るには、種々のコンポーネントの知識が必要です。Wicketは様々なコンポーネントを提供していますので、うまく使えばあまり深く考えなくてもリッチなUIを実現出来ます。ここからは代表的なコンポーネントの使い方を見てみましょう。

1. 予備知識・匿名クラスについて

コンポーネントを使う上でよく使うJavaの機能に匿名クラスというものがあります。匿名クラスは簡単に言えばnewしたオブジェクトの一部メソッドをオーバーライドする機能です。
次のように記載します。

final Map<String, List<String>> map = new HashMap<String, List<String>>() {
    @Override
    public List<String> get(final Object pKey) {
        List<String> ret = super.get(pKey);
        if (ret == null) {
            ret = new ArrayList<>();
            put((String) pKey, ret);
        }
        return ret;
    }
};

コンストラクタ呼び出しの直後に{}を記載し、中でメソッドをオーバーライドします。上記の例ではHashMapクラスをnewすると同時にgetメソッドをオーバーライドしています。この構文はWicketを使っていると頻出しますので慣れておいて下さい。

2. Ajaxコンポーネントを使う

まずはAjaxコンポーネントの使い方を見てみましょう。いきなりAjax？と思われるかもしれませんがWicketはAjaxをとても簡単に扱うことが出来るのです。ここでは、ボタンを押す度にサーバの時刻をAjaxで取得して表示する機能を追加してみましょう。

まずサーバの時刻を表示するコンポーネントを追加します。

final Label now = new Label("now", new AbstractReadOnlyModel<String>() {
    @Override
    public String getObject() {
        return DateFormat.getDateTimeInstance().format(new Date());
    }
});
now.setOutputMarkupId(true);
add(now);

7行目のnow.setOutputMarkupId(true)を忘れないようにして下さい。これはAjaxで書き換えるコンポーネントに対して必要な記述です。

次にリンクコンポーネントを追加します。

final AjaxLink<?> nowRefresher = new AjaxLink<Object>("nowRefresher") {
    @Override
    public void onClick(final AjaxRequestTarget pTarget) {
        pTarget.add(now);
    }
};
add(nowRefresher);

このコードの意味は、「リンクを押したらnowコンポーネントを再表示しなさい」です。

最後にHTMLを編集します。Javaコードで追加した２つのコンポーネントをHTMLにも追記しましょう。

<h2 wicket:id="now">サーバの時刻がここに表示されます</h2>
<a wicket:id="nowRefresher">サーバ時刻表示を更新</a>

次のURLにアクセスして画面を確認してみましょう。

http://localhost:8080

「サーバ時刻表示を更新」というリンクをクリックする度に時刻表示が更新されるのが分かると思います。

このように、WicketはAjaxを「コンポーネントを再表示する」機能として取り込むことで、プログラマが楽にAjaxを利用出来るようにしているのです。

第五章　コレクションを扱う

次に紹介するコンポーネントはコレクションを扱うものです。一覧表示はWebアプリケーションで欠かせないものですから、コレクションの扱い方を押さえておくのは不可欠です。

コレクションを扱うコンポーネントには様々な種類があるのですが、ここでは最も一般的なListViewを使います。以下、ListViewの生成とページクラスへの追加を行うコードです。

final List<String> nameValues = Arrays.<String> asList("JavaEE6", "Ninja", "Play Framework", "Wicket");
final ListView<String> names = new ListView<String>("names", nameValues) {
    @Override
    protected void populateItem(final ListItem<String> pItem) {
        pItem.add(new Label("name", pItem.getModelObject()));
    }
};
add(names);

ここでも匿名クラスが登場しています。オーバーライドしているpopulateItemメソッドは、コレクションの要素毎に呼び出されます。引数のListItemにコンポーネントを追加することで画面を編集出来ます。ここではLabelのみを追加し、シンプルに文字列を表示しています。

併せてHTMLも編集しましょう。

<h2>Javaフレームワーク</h2>
<ul>
    <li wicket:id="names"><span wicket:id="name">ここにコレクションの要素が表示されます</span></li>
</ul>

次のURLにアクセスして画面を確認してみましょう。

http://localhost:8080

いかがでしょうか。多少クセがありますが、Wicketでコレクションを扱うときの基本形は以上のようになります。

その他のコンポーネント

他にも数多くの便利なコンポーネントがあるのですが、とてもではありませんが紹介するスペースが足りませんので、重要なものの名前を挙げるに留めます。

• Form/TextFieldなど：ユーザからの入力を受け取るフォーム部品が提供されています
• AjaxButton/IndicatingAjaxButton：Ajaxでサブミットするボタンです
• AjaxFallbackDefaultDataTable：Ajaxによるページング機能を持つテーブルです

第六章　コンポーネントを作る

最後に、簡単なコンポーネントを作ってみましょう。Ajaxコンポーネントの紹介で作ったサーバ時刻を表示する機能をコンポーネント化してみます。

HTMLを持つコンポーネントを作るには、Panelクラスを継承します。ここではServerTimePanelというクラスを作ってみましょう。

package sandbox;

import java.text.DateFormat;
import java.util.Date;

import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.ajax.markup.html.AjaxLink;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.AbstractReadOnlyModel;

public class ServerTimePanel extends Panel {

    public ServerTimePanel(final String pId) {
        super(pId);

        final Label now = new Label("now", new AbstractReadOnlyModel<String>() {
            @Override
            public String getObject() {
                return DateFormat.getDateTimeInstance().format(new Date());
            }
        });
        now.setOutputMarkupId(true);
        add(now);

        final AjaxLink<?> nowRefresher = new AjaxLink<Object>("nowRefresher") {
            @Override
            public void onClick(final AjaxRequestTarget pTarget) {
                pTarget.add(now);
            }
        };
        add(nowRefresher);
    }
}

HomePage.javaからコンポーネント生成と追加部分を移植しました。

次にHTMLファイルを作成します。クラスと同名、つまりServerTimePanel.htmlを作りましょう。

<wicket:panel>
    <h2 wicket:id="now">サーバの時刻がここに表示されます</h2>
    <button type="button" wicket:id="nowRefresher">サーバ時刻表示を更新</button>
</wicket:panel>

<wicket:panel>〜</wicket:panel>で囲んだ部分がコンポーネントとして使われるHTMLになります。

これでコンポーネントは完成。使う側のページクラスを修正しましょう。

HomePage.javaは次のようになります。

package sandbox;

import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.request.mapper.parameter.PageParameters;

public class HomePage extends WebPage {

    public HomePage(final PageParameters parameters) {
        super(parameters);
        add(new Label("version", getApplication().getFrameworkSettings().getVersion()));
        add(new ServerTimePanel("serverTime"));
    }
}

12行目でServerTimePanelを使っています。ご覧の通り、自作のコンポーネントだからといって特別なことは何もなく、Labelなどのコンポーネントと同じように扱えます。

HomePage.htmlは次のようになります。

<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org">
    <head>
        <meta charset="utf-8" />
        <title>Apache Wicket Quickstart</title>
    </head>
    <body>
        Wicketのバージョン: <span wicket:id="version">ここに使っているWicketのバージョンが入ります</span>
        <hr/>
        <div wicket:id="serverTime"></div>
    </body>
</html>

10行目でServerTimePanelコンポーネントを使っています。こちらも特別なことは何もないですね。実際にブラウザ上でどう表示されるかは、皆さんの目で確かめて下さい。

まとめ

かなり駆け足でWicketの概要と基本を見てきました。Ajaxの利用や部品化が簡単に行えることが理解していただけたかと思います。

Javaの利点を最大限に発揮することを目指して作られているWicketは、機能や設定項目にうまくJavaの型を当てることで、誤解やミスが生じにくいAPIを提供しています。

簡単かつ安全にWebアプリケーションを作れるWicketにぜひ触れてみて、一味違うフレームワークを味わってみて下さい。

Reactとは

Reactはブラウザで動作するWebアプリケーションのUI（ユーザインターフェイス）を担当するJavaScriptライブラリです。DOM操作を通して画面の見た目を変えることに特化しています。

Reactの重要な特徴は３つあります。

JSXによるDOM操作の隠蔽

本来DOM操作は面倒で誤りやすいプログラムを書く必要があのですが、Reactは、JSXというJavaScriptを拡張した言語を提供することで、面倒なDOM操作をプログラマから隠してくれます。

その代わりJSXをJavaScriptに変換するという開発上の手間が必要ですが、JSXはこの手間を上回る利便性を提供してくれます。

一方向データバインディング

Reactでは「データ」→「画面（HTML）」という方向でしかデータが流れません。AngularJSなどは画面でユーザの入力を検出したらデータに反映してくれるようですが、Reactはあくまでデータを画面に反映するのみです。

これはプログラムの見通しが良くなる効果がありますし、またReactを使うために覚えることが少なくなるという利点もあります。

コンポーネント指向

Reactは画面の部品化を促進します。HTMLの一部をコンポーネントとして切り出し、プロパティやイベントハンドラをコンポーネントの中にまとめて記述出来ます。

これにより、プログラムの記述方法が統一されるという効果や、いわゆるカプセル化による保守性向上が望めます。

Reactを使ったプログラム

さてこれ以降は、実際にReactを使ったプログラムを見て行きましょう。今回はHTMLファイルの中にスクリプトを書く方法を使います。

最小のサンプル

まずはReactを使ってHello Worldを書いてみます。

<!DOCTYPE html>
<head>
  <meta charset="UTF-8" />
  <title>Hello, React!</title>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/react.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/JSXTransformer.js"></script>
</head>
<body>
  <div id="content"></div>
  <script type="text/jsx">

// コンポーネントを定義
var Hello = React.createClass({
    render: function() {
        return (
            <h1>Hello, React!</h1>
        );
    },
});
// コンポーネントを描画
React.render(<Hello />, document.getElementById('content'));

  </script>
</body>

scriptタグのtype属性値が”text/jsx”となっていることに注意して下さい。

このサンプルでは、Reactプログラミングで欠かすことの出来ない２つの操作を行っています。

• コンポーネントを作る：React.createClass関数（”createClass”なのに”コンポーネントを作る”と表現しているのは大目に見て下さい）
• 画面に描画する：React.render関数

また、Helloコンポーネントのrender関数に注目して下さい。HTMLタグを直接returnしていますね。この書き方を実現しているのが、JSXというJavaScript拡張言語です。

重要な３つの機能

驚くべきことに、ReactでWebアプリケーションを作る上で必須なのはたった３つの機能です。

１．子コンポーネントに属性を指定する

コンポーネントは入れ子に出来ます。１つのコンポーネントで事が済むことはほとんど無く、いくつかのコンポーネントを組み合わせて画面を作って行くのが通常です。

なおここからのサンプルコードは、HTMLの部分が最小のサンプルと変わりません。ですのでscriptタグの中だけを記載することにします。

// 子コンポーネント
var Child = React.createClass({
    render: function() {
        return (
            <h2>{this.props.text}</h2>
        );
    }
});
// 親コンポーネント
var Parent = React.createClass({
    render: function() {
        return (
            <div>
                <h1>ここは親です</h1>
                <Child text="ここは子1です" />
                <Child text="ここは子2です" />
            </div>
        );
    },
});
// 親コンポーネントを描画
React.render(<Parent />, document.getElementById('content'));

ChildとParentという２つのコンポーネントを定義しています。そして親コンポーネントParentのrender関数の中でChildコンポーネントを使っています。render関数の中にはHTMLタグだけでなくコンポーネントを書くことも出来るのです。

重要な機能として、親から子に属性を通して値を渡すことが出来ます。以下の部分です。

<Child text="ここは子1です" />

Childコンポーネントにtext属性を付けています。一方、Childコンポーネントの中では次のようにしてtext属性値を使っています。

return (
    <h2>{this.props.text}</h2>
);

this.propsというオブジェクトを使うことで属性値にアクセス出来ます。

２．イベントハンドリング

コンポーネントの属性には関数を渡すことが出来ます。これを利用し、子コンポーネントのイベントを親コンポーネントでハンドリングすることが出来ます。

// 子コンポーネント
var Child = React.createClass({
    onClick: function() {
        this.props.onNowButtonClick(new Date());
    },
    render: function() {
        return (
            <div>
                <h2>{this.props.text}</h2>
                <button onClick={this.onClick}>現在時刻を通知</button>
            </div>
        );
    }
});
// 親コンポーネント
var Parent = React.createClass({
    handleNowButtonClick: function(pNow) {
        alert(pNow);
    },
    render: function() {
        return (
            <div>
                <h1>ここは親です</h1>
                <Child onNowButtonClick={this.handleNowButtonClick} text="ここは子です" />
            </div>
        );
    },
});
// 親コンポーネントを描画
React.render(<Parent />, document.getElementById('content'));

親コンポーネントにはイベントをハンドリングする関数handleNowButtonClickが増えました。またChildコンポーネントの属性にイベントハンドリング関数を渡しています。

子コンポーネントは少し複雑です。まずrender関数にbuttonタグを増やしonClick属性に自身のイベントハンドラ関数onClickを渡しています。

<button onClick={this.onClick}>現在時刻を通知</button>

そして自身のイベントハンドラ関数の中で、属性に指定された関数onNowButtonClickを実行しています。

onClick: function() {
    this.props.onNowButtonClick(new Date());
}

３．状態を扱う

最後の機能は状態を扱うためのものです。次のサンプルではボタンを押す度に画面の時刻表示が変わります。

// 子コンポーネント
var Child = React.createClass({
    onClick: function() {
        this.props.onNowButtonClick(new Date());
    },
    render: function() {
        return (
            <div>
                <h2>{this.props.time.toString()}</h2>
                <button onClick={this.onClick}>現在時刻を通知</button>
            </div>
        );
    }
});
// 親コンポーネント
var Parent = React.createClass({
    getInitialState: function() {
        return {
            now: new Date()
        };
    },
    handleNowButtonClick: function(pNow) {
        this.setState({ now: pNow }); // ←ここが重要！状態を更新します
        alert(pNow);
    },
    render: function() {
        return (
            <div>
                <h1>ここは親です</h1>
                <Child onNowButtonClick={this.handleNowButtonClick} time={this.state.now} />
            </div>
        );
    },
});
// 親コンポーネントを描画
React.render(<Parent />, document.getElementById('content'));

親コンポーネントにgetInitialState関数が増えています。この関数はコンポーネントの初期状態を返します。

getInitialState: function() {
    return {
        now: new Date()
    };
}

更にsetState関数を呼び出すことで状態を変更しています。

handleNowButtonClick: function(pNow) {
    this.setState({ now: pNow }); // ←ここが重要！
    alert(pNow);
}

もう１つ重要な箇所があります。子コンポーネントの属性に親コンポーネントの状態を渡しています。

<Child onNowButtonClick={this.handleNowButtonClick} time={this.state.now} />

ReactのすごいところはsetState関数を呼び出すと関連する箇所が自動で書き換わることです。プログラマはコンポーネントを定義し、render関数を書き、setState関数を呼ぶだけ。たったこれだけでWebアプリケーションがきれいに動きます。

データの更新を伴うサンプル

最後のサンプルとして、データの更新を伴う画面のコードを載せておきます。画面イメージは次のようになります。

このサンプルはHTMLも変わっていますので全文を載せます。手軽に見栄えを良くするためにBootstrapを使っています。

<!DOCTYPE html>
<head>
  <meta charset="UTF-8" />
  <title>ReactによるCRUDアプリ</title>
  <link href="http://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css" rel="stylesheet">
  <script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/react.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/react/0.13.3/JSXTransformer.js"></script>
  <style>
    body {
        padding-top: 20px;
    }
  </style>
</head>
<body>
  <div id="content"></div>
  <script type="text/jsx">
// テーブルの各行となるコンポーネント
var Rows = React.createClass({
    onDataRemove: function(pIndex) {
        this.props.onDataRemove({ index: pIndex });
    },
    render: function() {
        // 各行のタグを連結
        var rows = this.props.data.map(function(e, idx) {
            return (
                <tr key={e.id}>
                    <td>{e.title}</td>
                    <td>{e.content}</td>
                    <td>
                        <button onClick={this.onDataRemove.bind(this, idx)} className="btn btn-danger">
                            <i className="glyphicon glyphicon-trash" />
                        </button>
                    </td>
                </tr>
            );
        }.bind(this));
        // tableタグを作成
        return (
            <table className="table table-striped">
                <thead>
                    <th>タイトル</th>
                    <th>内容</th>
                    <th> </th>
                </thead>
                <tbody>
                    {rows}
                </tbody>
            </table>
        );
    }
});
// 入力フォームコンポーネント
var Form = React.createClass({
    onAddButtonClick: function(e) {
        // React.findDOMNode関数で入力項目を得ることが出来る
        var title = React.findDOMNode(this.refs.title).value;
        var content = React.findDOMNode(this.refs.content).value;

        // データ追加をイベント通知
        this.props.onDataAdd({ id: (new Date()).getTime(), title: title, content: content });

        e.preventDefault(); // デフォルトの動作をキャンセル
    },
    render: function() {
        return (
            <form>
                <div className="form-group">
                    <label htmlFor="title">タイトル</label>
                    <input ref="title" type="text" className="form-control" id="title" />
                </div>
                <div className="form-group">
                    <label htmlFor="content">内容</label>
                    <textarea ref="content" className="form-control" id="content" />
                </div>
                <button onClick={this.onAddButtonClick} className="btn btn-primary">追加</button>
            </form>
        );
    }
});
// ルートコンポーネント
var Root = React.createClass({
    getInitialState: function() {
        return {
            data: []
        };
    },
    handleDataAdd: function(e) {
        var data = this.state.data;
        data.push(e);
        this.setState({ data: data });
    },
    handleDataRemove: function(e) {
        var data = this.state.data;
        data.splice(e.index, 1);
        this.setState({ data: data });
    },
    render: function() {
        return (
            <div className="container">
                <Form onDataAdd={this.handleDataAdd} />
                <hr/>
                <Rows data={this.state.data} onDataRemove={this.handleDataRemove} />
            </div>
        );
    }
});
// ルートコンポーネントを画面に描画
React.render(<Root />, document.getElementById('content'));
  </script>
</body>

少し長くなりましたが、各コンポーネントの役割分担がはっきりしている上にHTMLとJavaScriptが１つのコンポーネントの中にまとまっているため、コードの見通しが良く読みやすいと思います。

またJSXのおかげでDOM操作のコードが一切現れていない点に注目して下さい。render関数にテンプレートを書いておけば、DOMを意識する必要がなくなります。

画面は常にデータに対して描画されます。ずれることはありません。またユーザの入力はsetState関数でデータに反映させることで、Reactが文字通りreact（反応）して必要な部分だけが再描画されます。

つまりReactを手にしたプログラマはデータ操作だけに集中してプログラムすれば良い、ということになります。Reactの真髄はここにあります。

実戦投入するときには

本エントリのコードはあくまでサンプルですので、実際にReactを実戦投入するときに、考慮すべきことがあります。

JSXの事前コンパイル

本エントリのコードはポータビリティを重視したため、JSXをブラウザでコンパイルしています。しかし実戦では事前にJSXをコンパイルし出力されたJavaScriptをHTMLから参照するようにするべきです。

事前コンパイルにはいくつかの方法がありますが、この解説はまたの機会に譲ることにします。

サーバサイドレンダリング

素直にReactを使っていると、HTMLの多くがJavaScriptが実行されるまで描画されないため、体感的にページの描画が遅くなります。そこでReactでは初期画面をサーバサイドでもレンダリング出来る仕組みが備わっています。

サーバサイドレンダリングの詳しい解説もまたの機会に譲ることにします。

Reactの注意点

Reactを通さずDOMを操作するのは厳禁！

これは、例えばjQueryを使ってDOMを追加／削除／変更することは厳禁！ということです。また、jQueryを通してイベントハンドラを設定することも厳禁です。これはReactが採用している「バーチャルDOM」という仕組みへの配慮です。

DOM操作というのは低速な処理です。そこでReactは、DOMを更新しなければならないときに、バーチャルDOMを使って差分を算出し、実際のDOMは最低限必要な箇所のみ更新する、ということをやっているのです。

ですので、Reactを通さずにDOMを更新してしまうと、バーチャルDOMと実際のDOMに齟齬が出来てしまい、Reactが正しくDOMを更新出来なくなってしまいます。

jQueryに慣れていればいるほど、この制限は辛いものになるでしょう。しかし一度Reactに慣れてしまうと、jQueryの手続き的なDOM操作がとても面倒かつ危険なものに思えてきます。ぜひReactを使ってみてパラダイムシフトを体感していただきたいと思います。

まとめ

覚えることが少なくとっつきやすいReact。実績も充分（何せFacebookで使われている！）です。JavaScriptにHTMLを埋め込むのが気持ち悪いと感じる方もいると思いますが、そこを乗り越えればものすごく便利に使えるライブラリです。

SPA（Single Page Application）タイプのWebアプリケーションを作るときは、ぜひ採用を検討してみて下さい。

スタイルにはいろんな考え方がありますが、本エントリでは「読むときのことを考える」という原則に従ったスタイルを考えて行きます。

「プログラムは書いている時間よりも読まれている時間の方がずっと長い」とFacebookの中の人が言ったとか言わないとか。また「昨日の自分は他人」とも言いますね。たとえ自分が書いたプログラムでも、後から読み返してみると「何でこんなコーディングしてるんだろ・・・」と思うことは良くあります。自分も含めた将来の読み手に対し、適切な情報を与えることで読みやすいプログラムを書くように心がける必要があるでしょう。

考え方の基本は「読み手に課す前提を減らす」

「読み手に課す前提」とは何でしょうか。それは、ある箇所のコードを読んでいるときに考慮しなければならない事柄を減らす、ということです。

次のコードを見て下さい。

public Object someMethod(String s) {
    String os = cnv(s);
    ...
}

public String cnv(String s) {
    ...
}

someMethodを読み解くには、いろんな可能性を考える必要があります。

• publicだからどこから呼び出されているか分からないな・・・
• 返り値がObject型なんだけど、実際にはどの型のオブジェクトが返ってるんだろう・・・？
• インスタンス変数に手を加えてる可能性ってあるのかな・・・？
• cnvメソッドは何をやってるんだろう？副作用はないの？インスタンス変数に手を加えるようなことしてないよね？
• cnvメソッドまでpublicなんだけど名前から言ってユーティリティっぽいんだけど、このクラスの外から呼び出している箇所ってあるの？

安易なpublic宣言のおかげで、読み解くのがとてもたいへんなことになっています。しかし、このコードが次のようになっているとどうでしょうか。

void someMethod(final String s) {
    final String os = cnv(s);
    ...
}

private static String cnv(final String s) {
    ...
}

• someMethodはパッケージ外から呼び出されていることはない！→呼び出し元を洗い出す範囲が減った！
• 戻り値はない！→インスタンス変数に何らかの変更を加えているはず！
• cnvメソッドはprivateかつstaticだから、インスタンス変数に手を加えることは無いしこのクラスの外から呼び出されることはない！

先のコードに比べ、考慮しなければならない事柄が相当に減ります。

読み手に課す前提を減らすためのスタイル

読み手に課す前提を減らすには、以下のようなスタイルを採用すると良いでしょう。

アクセス修飾子はprivateが基本！

特にpublicはどこからでも参照可能になり影響範囲が広大です。本当にpublicでないといけないのか、自問しましょう。

変数のスコープは最小限に

コードを読む際に考慮すべき変数が少ない方が読みやすいです。グローバル変数よりもインスタンス変数を、インスタンス変数よりもローカル変数を選択しましょう。

staticメソッドを好む

staticメソッドの中ではthisが参照出来ません。staticメソッドの中ではインスタンス変数に変更が入らないことが保証されるわけで、考えなければならないことがかなり減ります。

これは後にもう少し詳しく解説します。

ちなみに・・・あくまでstaticメソッドが有用なのであって、static変数はむやみに使わないように気を付けて下さい。特にfinalでないstatic変数が必要な局面はほぼありません。finalでないstatic変数を宣言したくなったら「何かがおかしいのでは？」と自問して下さい。

変数やメソッドの名前の単語を極力省略しない

書くのは面倒ですが読みやすいです。

変数の数を少なくする

ただでさえ変数の中の値は目に見えないため、人間にとって把握が難しい存在です。その上数が増えると飛躍的に複雑さが増し、手に負えなくなります。クラスにまとめるなどして、シンプルに管理出来ないか？などの手法を考えましょう。

インデントを減らす

インデントは何らかの条件分岐の結果で生じている場合がほとんどです。よって、インデントが深いということは複数の条件が組み合わされている、ということであり、人間の頭では把握が難しい状況です。

また、インデントを抜ける際には「今までどんな条件の下で処理が実行されてたんだっけ」と考えなおす必要があります。

これは後にもう少し詳しく解説します。

変数は宣言と同時に初期化し、finalを付ける

先にも書いたように、変数の値は目にみえないため、人間にとって把握が難しい存在です。ましてや値がどんどん変わって行ってしまうような変数は、相当理解が難しいと言えます。

final変数は、２度と値が変わらないことが保証されています。これは読み手に大きな安心感を与えます。

これは後にもう少し詳しく解説します。

３つの具体例

前項で紹介したスタイルのうち、あまり普及していないような気がするけれどもコードの読みやすさへの貢献度の高いスタイルを３つピックアップし、少しだけ掘り下げてみましょう。

staticメソッドを好む

スタイル具体例１つ目はstaticメソッドについてです。

メソッドにstaticを付けると、読み手に対し「このメソッドの中ではthisを使っていませんよ！」と知らせていることになります。thisを使っていないということは、少なくとも自クラス内のインスタンス変数やインスタンスメソッドを使っていないということになります。これは読み手にとって、考えなければならないことをかなり減らす効果があります。

以下のコードを見て下さい。

private String cnv(String s) {
    if (s == null) {
        return "★";
    }
    return "★" + s;
}

このメソッドはthisにアクセスしていないのですが、全てのコードを読むまでそのことが分かりません。しかし次のように書き換えるとどうでしょうか。

private static String cnv(String s) {
    if (s == null) {
        return "★";
    }
    return "★" + s;
}

コードを読むまでもなく、thisにアクセスしていないことが明示されます。

eclipseのコンパイラ設定

実はeclipseのコンパイラ設定にはthisにアクセスしていないメソッドを「staticを付けることが出来るよ！」と教えてくれる設定があります。ぜひオンにして積極的にstaticを付けるようにしましょう。

変数にfinalを付ける

スタイル具体例の２つ目は変数にfinalを付けることです。これは手軽で効果が高いスタイルである上にプログラムの腕を向上させる効果もあるため、強くおすすめします。

プログラムを書く側は、変数にfinalを付けなくても、実際に値が変わることはないことを確信出来ます。しかし読み手はその確信を得るのに、変数のスコープにある全てのコードを読む必要があるのです。

しかしfinalの付いた変数は、その変数の宣言を見ただけで、値が変わらないという確信を得ることが出来ます。これは読み手にとってとてもありがたいことなのです。

更に、変数の宣言と共に初期化するように心がけると値に何が入っているか分かりやすくなります。

以下のコードを見て下さい。

private Map<String, String> cache;

/**
 * コンストラクタ
 */
public SomeClass() {
    this.cache = new HashMap<>();
    ...
}

cacheという変数の値はどこからか書き換えられる可能性があり、読み手はこのことを意識してコードを読む必要があります。また実際にcacheにどんな値が入っているのか、コンストラクタを見るまで分かりません。

しかし次のように書くとどうでしょうか。

private final Map<String, String> cache = new HashMap<>();

/**
 * コンストラクタ
 */
public SomeClass() {
    ...
}

finalが付いているおかげで、この変数の値が決して書き換えられないことが分かります。また宣言と同時に初期化しているため、値に何が入っているか一目瞭然です。

finalを忘れがちな変数

メソッド/コンストラクタ引数

void someMethod(final String s) {
    ...
}

catch

try {
    ...
} catch (final RuntimeException e) {
    ....
}

 ローカル変数

void someMethod(final String s) {
    final String os = cnv(s);
    ...
}

クラスによっては全ての変数にfinalを付けることが出来ます。

finalを付けられないこともある、が・・・

for文のループ変数にはfinalを付けられません。が、forループの多くは拡張for文に置き換え可能であり、拡張for文のループ変数にはfinalを付けられます。

for文を使ってListの全要素にアクセスするコードは以下のようになります。

final List<String> ss = getStringList();
for (int i = 0; i < ss.size(); i++) {
    System.out.println(ss.get(i));
}

ループ変数はインクリメントされていくため、finalを付けることは出来ません。

これを拡張for文に置き換えると次のようになります。

for (final String s : getStringList()) {
    System.out.println(s);
}

拡張for文に置き換えたことで、変数にfinalを付けられる上に変数ssが不要になっています。シンプルになり読みやすくなったと思います。

eclipseの設定に頼ってはいけない

実はeclipseには保管アクションの中に「finalを付けられる変数に自動で付けてくれる設定」があります。しかしこの機能に頼ることはおすすめしません。なぜなら、finalを付けられない変数には付けてくれないためです。

保険として設定する分には構いませんが、基本的にはプログラマが意思を持ってfinalを付ける必要があります。

インデントを減らす

最後のスタイル具体例はインデントについてです。

インデントが深くなる典型的なケースはif、for、while、tryによるものでしょう。これらはいずれも何らかの条件分岐であると考えられます。つまりインデントを付けられたコードを読む際、読み手は「ここのコードが実行されている条件は何だっけ・・・？」と考えながら読むことになります。

例えば、次のようなコードを目にしたことはありませんか？

void someMethod(String s) {
    if (s != null) {
        // とても長いコード
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        s = .....;
    } else { // ん？このelseの条件って何だったっけ？
        s = "";
    }
    ...
}

長いコードブロックが終わるとおもむろに現れるelse。これを読み手が目にすると、「ん？このelseの条件は何だっけ？」と、ifのコードブロックの一番上まで戻らざるを得ません。

このコードは次のように書くとぐっと読みやすくなります。

void someMethod(String s) {
    if (s == null) {
        s = "";
    } else {
        // とても長いコード
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        ...
        s = .....;
    }
    ...
}

が、更に工夫して、次のように書けばもっと読みやすくなります。

void someMethod(String s) {
    s = cnv(s);
    ...
}

private static String cnv(final String s) {
    if (s == null) {
        return "";
    }
    // とても長いコード
    ...
    ...
    ...
    ...
    ...
    ...
    ...
    ...
    ...
    ...
    ...
    return .....;
}

インデントがほぼ無くなってしまいました。someMethodメソッドの中を見る限り、条件分岐が無くなっていて、コードを追いやすくなっていると思います。

条件分岐を別メソッドに切り出すようにすると、インデントの多くを無くすことが出来ます。

まとめ

ここまで「読むときのことを考える」という原則のもとで、様々なスタイルを考えて来ました。

スタイルを理解するにはその裏にある原則を理解することが必要です。例えば過去のエントリ「Java @Override アノテーション活用法」で紹介したスタイルは、読みやすさに加えて「ミスは極力コンパイルエラーとして捕捉する」という原則に沿ったスタイルです。

このエントリでは具体的なスタイルについて解説しましたが、原則を理解することでより良いスタイルを自分で選択出来るようになると思います。ぜひ日々考えながらプログラミングするようにしてみて下さい。

今回はいよいよWebアプリを作っていきます。

このエントリのゴール

• 簡単にJavaEE開発環境を構築する手順を説明します【前回ご紹介】
• JavaEEを使ったRDBにアクセスする簡単なサンプルを作成する手順を説明します【今回はこちらの手順をご紹介】

前提

• 前回のエントリに沿って開発環境が構築されていること

アプリケーションの作成

JavaEEの仕様は重厚長大ですが、Webアプリを作るだけならほんの少しのことを知っているだけでOKです。

ここでは、JPAを使って単一テーブルからのCRUDを実行するシンプルな１画面のみのアプリを作ってみます。画面イメージは以下のようになります。

それでは、EJB→Servlet→JSPの順番で作成していきます。

EJB

EJBといっても大げさに考える必要はなく、DBアクセスを担当するフツーのクラスのことです。

今回は、JavaEE標準のDBアクセス仕様であるJPAを使ってEJBを実装します。まずはJPAの動作に必要な設定ファイルとクラスを作成しましょう。

JPA設定ファイル（persistence.xml）の作成

Eclipse上にソースフォルダsrc/main/resourcesが無い場合は作成し、更にその中にMETA-INFフォルダを作って下さい。

META-INFフォルダの中にpersistence.xmlを次の通りに作成します。

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
    xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
    <persistence-unit name="pu" transaction-type="JTA">
        <jta-data-source>jdbc/App</jta-data-source>
        <exclude-unlisted-classes>false</exclude-unlisted-classes>
        <properties>
            <property name="eclipselink.ddl-generation" value="create-tables" />
            <property name="eclipselink.logging.level.sql" value="FINE" />
            <property name="eclipselink.logging.parameters" value="true" />
            <!-- eclipseのConsoleビューにSQLを出力するための設定. http://stackoverflow.com/questions/4676705/jpa-2-0-logging-and-tracing-through-with-glassfish-3-0-1-and-netbeans-6-9-1 -->
            <property name="eclipselink.logging.logger" value="org.eclipse.persistence.logging.DefaultSessionLog"/>
        </properties>
    </persistence-unit>
</persistence>

<property name=”eclipselink.ddl-generation” value=”create-tables” />という記述のおかげで、サーバ起動時にテーブルが自動で作られます。

また、DBデータはプロジェクト内のdbフォルダの中に作られます。このフォルダを削除すれば、再度テーブルが作られます。

エンティティクラスの作成

DBのテーブルに対応するクラスを作成しましょう。

src/main/java下のパッケージsandbox.entityに以下の通りにEmployeeクラスを作成します。

package sandbox.entity;

import java.io.Serializable;

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

@Entity
public class Employee implements Serializable {

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

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

    public Long getId() {
        return this.id;
    }

    public String getName() {
        return this.name;
    }

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

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

EJBクラスの作成

src/main/java下のパッケージsandbox.serviceにEmployeeServiceクラスを作成します。INSERT、SELECT、DELETE用に３つのメソッドを作成しましょう。

package sandbox.service;

import java.util.List;

import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;

import sandbox.entity.Employee;

@Stateless
public class EmployeeService {

    @PersistenceContext(unitName = "pu")
    EntityManager em;

    public Employee delete(final long pDeleteEmployeeId) {
        final Employee emp = this.em.find(Employee.class, Long.valueOf(pDeleteEmployeeId));
        this.em.remove(emp);
        return emp;
    }

    public List<Employee> getAll() {
        final CriteriaBuilder builder = this.em.getCriteriaBuilder();
        final CriteriaQuery<Employee> query = builder.createQuery(Employee.class);
        query.from(Employee.class);
        return this.em.createQuery(query).getResultList();
    }

    public Employee insert(final String pName) {
        final Employee newEmp = new Employee();
        newEmp.setName(pName);
        this.em.persist(newEmp);
        return newEmp;
    }
}

たったこれだけです。メソッドの前後で自動的にトランザクションが仕込まれます。また以前の記事「依存性注入（DIコンテナ）について」で紹介したDI機能によって、JPA用のEntityManagerオブジェクトが良い感じでインジェクトされます。

またSQLが全く登場しないことにも注目して下さい。JPAのCriteria Queryという機能を使うと、SQLを書かずに済むシーンが増えます。文字列に頼らず型を使ってDBアクセス出来るようになることは、Javaの型安全性ととても相性の良い手法だと思います。JPAを使う場合は、ぜひ有効活用してみて下さい。

これら全ての機能がJavaEEによって提供されている点にも注目です。SpringやHibernateなどのライブラリを組み合わせて使う場合、ライブラリ同士をうまく接続するために多少なりとも設定を書く必要がありますが、JavaEEであればライブラリを、それもたった２つのJARを参照するだけ。

このお手軽さがJavaEEを使って開発する際の魅力です。

Servletの作成

続いてHTTPリクエストを受け取るためのServletを作成します。今回は、ルート（ / ）へのGETで社員一覧、ルートへのPOSTで社員の追加を行うようにしましょう。

src/main/java下のパッケージsandbox.web.handlerにEmployeeHandlerクラスを作成します。

package sandbox.web.handler;

import java.io.IOException;
import java.util.List;

import javax.inject.Inject;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import sandbox.entity.Employee;
import sandbox.service.EmployeeService;

@WebServlet(urlPatterns = "/")
public class EmployeeHandler extends HttpServlet {

    @Inject
    EmployeeService employeeService;

    @Override
    protected void doGet(final HttpServletRequest pReq, final HttpServletResponse pResp) throws ServletException, IOException {
        final List<Employee> emps = this.employeeService.getAll();
        pReq.setAttribute("emps", emps);
        pReq.getRequestDispatcher("WEB-INF/emp.jsp").forward(pReq, pResp);
    }

    @Override
    protected void doPost(final HttpServletRequest pReq, final HttpServletResponse pResp) throws ServletException, IOException {
        final String empName = pReq.getParameter("employee-name");
        this.employeeService.insert(empName);
        pResp.sendRedirect("/");
    }
}

もう１つServletを作ります。/deleteへのPOSTで社員一覧を削除するようにしましょう。

src/main/java下のパッケージsandbox.web.handlerにEmployeeDeleteHandlerクラスを作成します。

package sandbox.web.handler;

import java.io.IOException;

import javax.inject.Inject;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import sandbox.service.EmployeeService;

@WebServlet(urlPatterns = "/delete")
public class EmployeeDeleteHandler extends HttpServlet {

    @Inject
    EmployeeService employeeService;

    @Override
    protected void doPost(final HttpServletRequest pReq, final HttpServletResponse pResp) throws ServletException, IOException {
        final String employeeIdStr = pReq.getParameter("employee-id");
        try {
            final long employeeId = Long.parseLong(employeeIdStr);
            this.employeeService.delete(employeeId);
        } catch (final NumberFormatException e) {
            // nop
        }
        pResp.sendRedirect("/");
    }
}

各メソッドでやっていることは

1. EJBを呼び出してDB操作
2. JSP呼び出し、または/へのリダイレクト

という単純な処理です。

ServletクラスでもDI機能が使えるため、EmployeeServiceオブジェクトが良い感じでインジェクトされます。

JSPの作成

最後に、JSPで画面を作成しましょう。

src/main/webapp/WEB-INFの下にemp.jspを作成して下さい。

<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <link href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css" rel="stylesheet">
    <title>社員情報</title>
  </head>
  <body>
    <div class="container">
      <fieldset>
        <legend>社員一覧</legend>
        <table class="table table-striped">
          <thead>
            <tr>
              <td>#</td>
              <td>名前</td>
              <td> </td>
            </tr>
          </thead>
          <tbody>
            <c:forEach  items="${emps}" var="emp">
              <tr>
                <td>${emp.id}</td>
                <td>${emp.name}</td>
                <td>
                  <form method="post" action="${request.contextPath}/delete">
                    <input type="hidden" value="${emp.id}" name="employee-id" />
                    <button class="btn btn-danger"><span class="glyphicon glyphicon-trash"></span></button>
                  </form>
                </td>
              </tr>
            </c:forEach>
          </tbody>
        </table>
      </fieldset>
      <fieldset>
        <legend>社員登録</legend>
        <form method="post" action="${request.contextPath}">
          <div class="form-group">
            <input type="text" name="employee-name" class="form-control" />
          </div>
          <button class="btn btn-primary">追加</button>
        </form>
      </fieldset>
    </div>
  </body>
</html>

手軽に見栄えを良くするために、Bootstrapを使っています。

文字化け防止クラスの作成

実はこのままでは日本語が文字化けします。次のクラスを作成して文字コードをUTF-8に統一します。

src/main/java下のパッケージsandbox.webにCharacterEncodingFilterクラスを作成します。

package sandbox.web;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

import javax.servlet.DispatcherType;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebFilter(urlPatterns = "/*", dispatcherTypes = DispatcherType.REQUEST)
public class CharacterEncodingFilter implements Filter {

    @Override
    public void destroy() {
        // nop
    }

    @Override
    public void doFilter(final ServletRequest pRequest, final ServletResponse pResponse, final FilterChain pChain) throws IOException,
            ServletException {
        ((HttpServletRequest) pRequest).setCharacterEncoding(StandardCharsets.UTF_8.name());
        ((HttpServletResponse) pResponse).setCharacterEncoding(StandardCharsets.UTF_8.name());
        pChain.doFilter(pRequest, pResponse);
    }

    @Override
    public void init(final FilterConfig pFilterConfig) throws ServletException {
        // nop
    }
}

以上でコーディングは終了です！おつかれさまでした。

Eclipseプロジェクトは次のような状態になっているはずです。

動作確認

前回作成したJavaEEContainerStarterクラスを起動した上で、以下のURLにアクセスして動作を確認してみて下さい。

http://localhost:8081

まとめ

Eclipse上でJavaEEを使った開発の手順を説明してきました。

RoRほどではないものの、思ったよりも簡単に開発を始められ、割りと少ないコード量でWebアプリが作成出来ることがご理解いただけたかと思います。

フルJavaEEを使って開発する利点は、機能が豊富で、更にそれらの機能が既に統合されている、という点です。新しい機能を使うときにJAR参照を追加したりする必要はありません。RESTfulなWebアプリを作るためのJAX-RSであっても、WebSocketのハンドラクラスであっても、適切なアノテーションを付与したクラスを作れば、それだけで動作します。またビジネスロジックをEJBとして作成すれば、DI機能によってどこからでも利用出来ます。

しかしこう言った利点を享受したくてJavaEEを使おうとしても、環境構築が面倒で挫折した、という人は少なくないと思います。

今回ご紹介した環境構築手順を使えば、簡単高速に開発が始められますので、ぜひJavaEEを体験してその便利さに触れていただきたいと思います。

そんな中、標準仕様であるJavaEEは人気が今ひとつな気がしますね。仕様が重い、動作が重い、などの悪印象があるのがその原因かもしれません。

しかし実は相当に開発しやすくなっているんです。

このエントリでは、JavaEEを活用してWebアプリを高速開発する手順を２回に分けてご紹介します。

このエントリのゴール

• 簡単にJavaEE開発環境を構築する手順を説明します【今回はこちらの手順をご紹介】
• JavaEEを使ったRDBにアクセスする簡単なサンプルを作成する手順を説明します 【次回ご紹介】

前提

• Eclipseをインストールしておいて下さい
• Maven3系を導入しておいて下さい

開発環境の構築

APサーバとDBサーバをインストールせずにEclipseでの開発環境を構築します。具体的には、組み込みGlassFishと組み込みH2 Database Engineを利用します。

Eclipseプロジェクトの作成

以下のコマンドでプロジェクトのひな形を作成して下さい。

mvn -B archetype:create -DgroupId=sandbox -DartifactId=rapid-javaee -DarchetypeArtifactId=maven-archetype-quickstart -Dversion=1.0

これでrapid-javaeeというディレクトリが作られ、その中にpom.xmlが作られます。このファイルの中身を次のように書き換えます。設定の意味は極力ファイル内にコメントを付けておきましたので参照して下さい。

<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>
    <groupId>sandbox</groupId>
    <artifactId>rapid-javaee</artifactId>
    <version>1.0</version>
    <packaging>war</packaging>
    <name>rapid-javaee</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <!-- JavaEE7のAPI -->
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-web-api</artifactId>
            <version>7.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- 組み込みGlassFish -->
        <dependency>
            <groupId>org.glassfish.main.extras</groupId>
            <artifactId>glassfish-embedded-web</artifactId>
            <version>4.1</version>
            <scope>provided</scope>
        </dependency>
        <!-- H2 Database Engine -->
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.4.181</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <finalName>rapid-javaee</finalName>
        <!-- JavaEEの仕様に従ってclassファイルを配置するための設定 -->
        <outputDirectory>src/main/webapp/WEB-INF/classes</outputDirectory>
        <testOutputDirectory>src/main/webapp/WEB-INF/test-classes</testOutputDirectory>
        <!-- javaファイル以外のファイル格納用ソースフォルダの設定 -->
        <resources>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**</include>
                </includes>
                <excludes>
                    <exclude>**/*.java</exclude>
                </excludes>
            </resource>
        </resources>
        <testResources>
            <testResource>
                <directory>src/test/resources</directory>
            </testResource>
            <testResource>
                <directory>src/test/java</directory>
                <includes>
                    <include>**</include>
                </includes>
                <excludes>
                    <exclude>**/*.java</exclude>
                </excludes>
            </testResource>
        </testResources>
        <plugins>
            <!-- UTF-8のソースを正しくコンパイルしてもらうための設定 -->
            <plugin>
                <inherited>true</inherited>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <optimize>true</optimize>
                    <debug>true</debug>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!-- WAR作成時にweb.xmlがなくてもOKにする -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

さらに、Eclipseで開発できるようにするために、以下のコマンドも実行しておきます。

mvn eclipse:eclipse

これでEclipseプロジェクトが作成されました。

Eclipseプロジェクトのインポート

作成したプロジェクトをEclipseにインポートして下さい。ただ、この時点ではAppTest.javaにコンパイルエラーがあるはずです。

このファイル、今回は使わないので削除して下さい。

JavaEEサーバ（GlassFish）起動クラスの作成

JavaEEサーバをEclipseから起動出来るようにします。src/test/javaソースフォルダ下のsandboxパッケージに、JavaEEContainerStarterというクラスを次の通りに作成して下さい。コードの意味はコメントを参照して下さい。

package sandbox;

import java.io.BufferedReader;
import java.io.File;
import java.io.InputStreamReader;

import javax.sql.DataSource;

import org.glassfish.embeddable.GlassFish;
import org.glassfish.embeddable.GlassFishProperties;
import org.glassfish.embeddable.GlassFishRuntime;
import org.h2.jdbcx.JdbcDataSource;

public class JavaEEContainerStarter {
    /**
     * 当クラスのソースの参考ページURL. <br>
     * http://www.coppermine.jp/docs/programming/2013/12/glassfish-embedded-server.html
     */
    @SuppressWarnings("nls")
    public static void main(final String[] pArgs) throws Exception {
        final long s = System.currentTimeMillis();
        final GlassFishProperties properties = new GlassFishProperties();

        // HTTPは8081番ポート、HTTPSは8082番ポートでリッスン
        properties.setPort("http-listener", 8081);
        properties.setPort("https-listener", 8082);

        // サーバ起動
        final GlassFish glassfish = GlassFishRuntime.bootstrap().newGlassFish(properties);
        glassfish.start();

        // コネクションプール作成. 組み込みH2 Database Engineを利用する.
        final String connectionPoolName = "AppConnectionPool";
        glassfish.getCommandRunner().run("create-jdbc-connection-pool" //
                , "--datasourceclassname=" + JdbcDataSource.class.getName() //
                , "--restype=" + DataSource.class.getName() //
                , "--property", "url=jdbc\\:h2\\:./db/db" //
                , connectionPoolName //
                );

        // JDBCリソースとしてコネクションプールを、jdbc/Appという名前で登録する.
        glassfish.getCommandRunner().run("create-jdbc-resource" //
                , "--connectionpoolid", connectionPoolName //
                , "jdbc/App" //
        );

        // Webアプリを配備.
        glassfish.getDeployer().deploy( //
                new File("src/main/webapp") //
                , "--name=app" //
                , "--contextroot", "/");

        System.out.println("GlassFishサーバを起動しました.");
        System.out.println(System.currentTimeMillis() - s + " ms");

        // Enterを押せばサーバ停止.
        new BufferedReader(new InputStreamReader(System.in)).readLine();
        glassfish.stop();
        System.out.println("GlassFishサーバを停止.");
    }
}

このクラスが本エントリの大きなポイントです。通常、JavaEEサーバは別途インストールして起動、Eclipseで開発するためにアダプタを導入して・・・と面倒な手順を踏む必要がありますが、この方法だと起動は簡単かつスピーディ、環境構築に苦労はなしと良いこと尽くしです。

試しにこのクラスを起動してみて下さい。10秒以内には起動完了するはずです。

以上で開発環境構築は完了！これでJavaEEの全ての機能を使った開発が開始出来ます。びっくりするほど簡単ですね。

次回予告

次回はいよいよJavaEEを使ったWebアプリ開発の手順をご紹介します。JavaEEは機能が豊富な上に手軽に利用出来る点が利点です。この利点を活用してWebアプリを簡単高速に作成していきます。

お楽しみに。

今回はノーマルの Vim で使えるもので、個人的によく使うテクニックをご紹介。

　ここからここまでコピー or 切り取りしたい

なんといっても一番使う行コピーと行切り取りです。いえいえ 5yy とか 10dd とかじゃないですよ！

5行など行数が少なければ目測で 5yy とかできますが、コピーしたい行数が 127行だったりしたら大変ですね。
あまり Vim に慣れていない方は :set nu で行数を表示して、コピーしたい行を引き算してヤンクするというのを見掛けます。
これは効率が悪いですし、計算違いで関係ない行までコピー or 切り取りしてしまう可能性もあります。

そんなときは以下を使いましょう。

ここは1行目ですよ。    //この行でmsと打つ
ここは2行目ですよ。 
ここは3行目ですよ。
ここは4行目ですよ。
（中略）
ここは126行目ですよ。
ここは127行目ですよ。  //この行でy'sもしくはd'sと打つ

上の例ではコピーをしたい始めの行でmsと打ち、コピー終わりの行でy’sと打つと、1~127行がヤンクされます。（d’sだとヤンクではなく切り取りになります）

これだと始点と終点でコマンドを打つだけなので間違いもないし簡単ですね。知らなかった方はレッツトライ！

　大文字と小文字を切り替える or どちらかに統一する

シェルスクリプトの変数や PHP の定数などは大文字で書くのが慣習ですが、そうなっていないものを直したりするときに使えます。

選択した文字を大文字⇔小文字にトグルさせる場合は~（チルダ）で、選択した文字をすべて小文字に統一したい場合はu（小文字）、大文字に統一したい場合はU（大文字）でできます。

//まずは ctrl+v で対象文字を選択します

this is komoji   //左の文字すべてを選択した状態でUと打つと大文字へ変換されます

THIS IS OMOJI    //左の文字すべてを選択した状態でuと打つと大文字へ変換されます

ThIs Is KoNGoU   //左の文字すべてを選択した状態で~を打つとすべての大文字と小文字が反転します

　一文字づつもしくは複数文字をリプレイスする

わざわざ挿入モードに入らずに1文字だけ修正したいとか、この単語だけ修正したいとかあると思いますが、その際はコマンドモードで以下を実施してください。

understanf   //fの上にカーソルを移動してr、そのまま変換したい文字(d)を入力

disk  //dの上にカーソルを移動してR、そのまま変換したい文字を打ち、最後にESC

　マクロを組んで同じ操作をワンキーで繰り返す

なにやら難しい感じですが、めちゃくちゃ簡単です。 Vim では操作を記録して実行するマクロ機能がありますが、それを.（ドット）で繰り返すだけです。

//qaと打ち記録を開始　qの後ろは任意の覚えやすい文字で結構です

This is Macro Test!  //左のように記録したい操作をやりきります　
    1234567          //今回は簡単ですが3行の文字入力をしました
  Test is End

//qと打ち記録を停止します

//@aと打つと1回マクロを実施しますが、.（ドット）だけでも実施できます。

This is Macro Test!
    1234567
  Test is End

//回数指定でマクロを実行したい場合は7@aと押すと7回実行できます

上の例だとコピーしたほうが早いですが、複雑な操作を再実行したい場合はマクロのほうが良いですね。

　大文字小文字に関係なく検索

地味ですが検索時は必須ですね。わざわざ大文字で検索して、次に小文字で検索してとやっている人を見掛けました。検索文字列の後ろに\cとつけるだけでOKですw

banana BaNANA Apple
Grape Banana ORANGE
orange PEAR peAR GRAPE

//（スラッシュ）を押して検索文字列banana\cと打つとすべてのバナナが引っ掛かります

いかがでしたか？今回はノーマルの Vim で使えるテクニックをご紹介しました。みなさんの作業効率を高める一助にしていただければ幸いです。