システム開発で思うところ

Javaで主にシステム開発をしながら思うところをツラツラを綴る

【雑記】新紙幣発行で思うところ

新紙幣が発行されることが発表されました。
さて、これにともなって どのような論が出てくるでしょうか?
陰謀論的な発想も含めた頭の体操です。

パワーシフト論(的 陰謀論

福沢諭吉から渋沢栄一へ、ということは 経済界における慶応閥の力が弱まってきているという論。
三菱は岩崎弥太郎で、彼と福沢諭吉との 関連を鑑みるに、国としては みずほ銀行(旧第一勧銀) 推し? 三菱UFJはマイナス金利の際に国債を買わないという宣言をしたり、仮想通貨(暗号通貨?)の発行をメガバンクとして早々に打ち出したりと「反日本」と見られて 紙幣の顔から福沢諭吉が外された的な。

バブル期の総決算

バブル期(1984年)からの「顔」が、今 役目を終えたという見方。
でも新しい顔が東京証券取引所の創設者って、結局(ry。 とはいえ、渋沢栄一は 多数の企業設立に関わっているから、それを言ったら何かしらに関係してしまうので「新しい時代に どんどんビジネスを起こしていこう」と考えた方が前向きですね。

タンス預金対策(ロンダリング対策)

新しい紙幣に「電子透かし」的なものを採用することによって、古い紙幣が使えなくなる という論。
電子透かしの無い紙幣は、ある一定期間を経て 市中で使えなくなるという話。
銀行にもっていって新しい紙幣に交換しないといけない、または預金(貯金)としてしないといけない。
タンス預金(地下経済)を把握しようという流れの一環。

キャッシュレスも同じ理屈ですね(インドとか中国とか)。

日本は タンス預金率が高いと言われていますし、どうにかして把握するためには「古い紙幣は 電子透かしがないと市中では使えなくなります」という論理で あぶりだすんじゃないかなぁ、なんて。
そこまでするか分かりませんが、そこまでしたら 結構なインパクトになることは必至でしょう。

紙幣のブロックチェーン

先の電子透かしの延長。
紙幣につける電子透かしは、透かしと言うよりも ID。
IDをもって、それをブロックチェーンとして把握するという論。
預金(貯金)はマイナンバーで把握、紙幣はブロックチェーンで把握。 お釣りとして、小額紙幣は使われるけど、1万円の高額紙幣は お釣りとして出ていくことは無いので それなりにブロックチェーンの効果はあるんじゃないですかね。

仮想通貨が上がる?

ロンダリング対策の影響を受けて、グローバルな仮想通貨へのシフトがより強まるかも。
そうすると値段が上がるかもしれませんね。
(しらんけど)

新紙幣特需

紙幣読み取り関連の銘柄が上がるんじゃないですかね。
特に電子透かしという特殊性があるし、これまでとは違う気がするんですけど どうかなぁ。 (しらんけど)

無人販売機関連のキャッシュレス化

新紙幣対応として、自動販売機の入れ替えをするコストアップに対応はできないということで、自動販売機から 紙幣投入口が無くなるという話。
結果として、硬貨と電子マネー(QR決裁含めて)しか使えなくなる。 これは、割とありそうな気がします。
特に地方の自動販売機だと、紙幣のところに蓋をして使えなくなる可能性が大きいんじゃないかなぁ。
今更、新しい自動販売機に置き換えるコストをかけ無さそうな気がします。

預金封鎖

キャッシュレスとか、タンス預金の是正の延長で ありがち(?)な話として、預金封鎖もあるかなぁ。
正しくは、預金封鎖がやりやすくなるための土台になっていますよね?という感じ。
戦後 日本国債が紙切れになったようなことを 恣意的にやるためには、できるだけ 現金を預金にしておいた方が効果は大きいのは 言わずもがな、です。

円が無くなる?

(さらに ぶっ飛んだ発想)

円が無くなって ドルとか元とか 何かしらの通貨に 一括置き換えされる未来。
日本が無くなるのか、日本以外も含めて国家が無くなるのか、経緯は ともかくとして、円が無くなってしまう。
貨幣変換は 電子化されたら ボタン ポチッでおしまい。
そんなに単純なものでは無いというのは分かっていますが、まぁ、ぶっとんでいくと そういう世界もありますねという論。

その他

とりあえず、インドみたいに高額通貨(1万円)が無くしてまで キャッシュレス化を進めることはしないみたいですね。
逆に10万円札も無いということでもあるようですね。

さいごに

信じるか信じないか(ry

アクターとユースケース(権限)の実装

vermeer.hatenablog.jp

を元に アクターとユースケース(権限)の実装をしてみました。
まだサービスやコントローラーへの適用はしていません。

想定する要件

アクターが複数あって、それぞれに権限がありそうなものということで「申請フロー」を題材にしました。

状態遷移図

f:id:vermeer-1977:20190302104539p:plain

ユースケース

f:id:vermeer-1977:20190302104506p:plain

「編集」については、状態変更を伴わないということもあり 除外して、それ以外の 状態遷移のトリガーとなる振る舞いを 基本的に そのままユースケースとして採用しました。

ツッコミどころや補足など

申請者と承認者を継承関係にしていますが、正直 自分自身「うーん」と思っています。 要件としての役割だから継承関係にしない方が正しい整理だと思うんですよね。 継承すべきものがあるとしたら「社員」みたいなアクターのような気もするんですけど、今回はアクターの継承を含んだ実装例を試したかったということで目をつぶってください。

状態が終了することは無いの?という状態遷移になっていますが、これは一応、意図的なものです。 イミュータブルデータモデル的なことを想定していて、すべての状態を履歴として管理する、という意図です。

実装(インターフェース)

アクター

public interface ActorType {

    public Set<UsecaseType> usecases();

    public default ActorType parentActor() {
        return null;
    }

    public default Set<UsecaseType> recursiveScan(ActorType actor, Set<UsecaseType> usecases) {
        if (actor == null) {
            return usecases;
        }
        usecases.addAll(actor.usecases());
        return recursiveScan(actor.parentActor(), usecases);
    }

    public default boolean hasUsecase(UsecaseType usecase) {
        return this.usecases().contains(usecase);
    }

    public default boolean anyMatch(Set<UsecaseType> usecases) {
        return this.usecases().stream().anyMatch(usecase -> usecases.contains(usecase));
    }

}

ユースケース

ユースケースは、アクターと違って 永続層などの値から ユースケースEnumへの変換が必要だというところです。 ということで、変換用のユーティリティとしても 本インターフェースを使います*1

public interface UsecaseType {

    public Object code();

    public static <E extends Enum<E> & UsecaseType> Optional<E> codeOf(Class<E> enumType, Object code) {
        return Arrays.stream(enumType.getEnumConstants())
                .filter(e -> e.code().equals(code))
                .findFirst();
    }

}

実装(具象クラス)

実装例ということで、分かりやすさ重視で 上述の ユースケース図や状態遷移図の日本語表現を そのまま使っています。 実際の作成の順番としては、ユースケースEnumをつくって、アクターのEnumを実装します。

アクター

public enum Actor implements ActorType {
    起票者(起票, 申請, 取下),
    承認者(差戻, 承認) {
        @Override
        public Actor parentActor() {
            return 起票者;
        }
    };

    private final Set<UsecaseType> usecaces;

    @Override
    public Set<UsecaseType> usecases() {
        return this.usecaces;
    }

    private Actor(UsecaseType... usecases) {
        Set<UsecaseType> _usecases = (usecases == null || usecases.length == 0)
                                     ? Collections.emptySet()
                                     : new HashSet<>(Arrays.asList(usecases));
        this.usecaces = this.recursiveScan(this.parentActor(), _usecases);
    }

}

承認者は、起票者を拡張したアクターであることを parentActorで表現しています。
あとは各アクターに関連するユースケースを記述するだけです。

再帰的にアクターに紐づくユースケースを取得するためにコンストラクタでthis参照をしているところが、ちょっと気にはなっています。
インスタンスフィールドを参照しているわけではないので、大丈夫かなぁと思っていますが、もし問題があるようなら、アクターに関連付けされているユースーケースを取得するメソッド(hasUsecase)で都度 階層情報をさかのぼって ユースケース情報を参照するようにしないといけないかもしれません。一応、ユニットテストでは 想定通りの挙動をしています。

ユースケース

public enum Usecase implements UsecaseType {
    起票, 申請, 取下, 差戻, 承認;

    @Override
    public Object code() {
        return this.name();
    }

    public static Optional<Usecase> codeOf(Object code) {
        return UsecaseType.codeOf(Usecase.class, code);
    }

}

永続層などで保持しているコード値はUsecaseのEnum列挙子と同値という前提です*2
Enumクラスの valueOfの コード値版として、static な codeOfメソッドを準備します*3

使い方の例(テストコード)

public class ActorTest {

    @Test
    public void hasUsecasesAt起票者() {
        Set<UsecaseType> usecases = Actor.起票者.usecases();
        Set<UsecaseType> expects = new HashSet<>(Arrays.asList(起票, 申請, 取下));
        Assert.assertTrue(usecases.containsAll(expects));
    }

    @Test
    public void hasUsecasesAt承認者() {
        Set<UsecaseType> usecases = Actor.承認者.usecases();
        Set<UsecaseType> expects = new HashSet<>(Arrays.asList(起票, 申請, 取下, 差戻, 承認));
        Assert.assertTrue(usecases.containsAll(expects));
    }

    @Test
    public void hasUsecase() {

        Assert.assertTrue(Actor.起票者.hasUsecase(取下));
        Assert.assertTrue(Actor.承認者.hasUsecase(取下));

        Assert.assertFalse(Actor.起票者.hasUsecase(差戻));
    }

    @Test
    public void anyMatch() {
        Set<UsecaseType> items = new HashSet<>(Arrays.asList(差戻, 承認));
        Assert.assertFalse(Actor.起票者.anyMatch(items));

        Assert.assertTrue(Actor.承認者.anyMatch(Actor.起票者.usecases()));

    }

    @Test
    public void convertUsecaseEnum() {
        Assert.assertEquals(Usecase.codeOf("取下").get(), Usecase.取下);
    }

}

さいごに

Actorとユースケースの実装については、だいたいこんな感じで良いかな と思います。
次は これらのEnumを実際に サービスやコントローラーで使ってみて、使い勝手を検証していきたいと思います。


*1:EnumのInterfaceに共通処理を実装する - システム開発で思うところ に 少しStreamでアレンジを加えて実装しました。

*2:手抜きですが意図は伝わると思います

*3:実際の実装に近づけたいので こちらは手抜きをしません

【考察】アクター/ロールについて考える

vermeer.hatenablog.jp

vermeer.hatenablog.jp

への継続考察みたいな感じです。

ログインユーザーの持つ役割(権限)を どうやって 振る舞い(ユースケース・サービス)で表現したら良いのかな?という考察です。

権限と役割の文脈だと、アクター、ロール、パーミッション など、いくつかの表現で示されているように思います。

今回は、実装を踏まえつつ、自分なりに整理をすることで、実装(設計)において迷いを持たないようにすることを目的とした考察とも言えます。

アクター(辞書的な(UML的な)ところ)

- UML超入門_第2章

機能を利用するユーザや、システムが使用するハードウェア、外部システムがアクターとして表現されます。 アクターはシステムの一部ではありません。

ドメインそのものにならないようにする、というのが大事なところという理解です。
やりがちなところとしては、アクターとしての「利用者」があったとして、それを ドメインとして採用すると 全ての集約のルートが 「利用者」になってしまい、巨大な集約をモデリングしてしまうという感じと言えば良いでしょうか?

アクターの権限により起こり得るユースケースから導出される動詞とかコトをモデリングするようにしたら、多分大丈夫です。

ロールと権限

業務システムにおけるロールベースアクセス制御 - Qiita

色々と参考にする中で、やっぱり いつも この記事に戻ってきます。
ザックリいうと、アクセス制御は 権限で指定しましょう、ということになるという理解です。 じゃぁ、ロールは? というと、これもザックリいうと ラベルとかグループとか分類とか、そういうものなので アクセス制限とは 直接的には関係を持たせない方が良い、ということになります。

アクターとロール/権限

印象としては、アクターとロールは 意図しているものは同じように思います。
ちなみに、私は、同じだと考えていました。
そして整理が出来ず悩んでしまいました。*1

Serviceの実装を ユースケース記述のように、アクターとユースケース(振る舞い)によって実装すると、意図の伝わるドキュメントのような実装になると考えていたからです。
アクターとロールが同じという整理では、ロールによるアクセス制限で起こり得る課題を避けられないことになります。

ということで、もう少し 考えてみる必要がありそうです。

先のブログにも 書かれていたことを参考に あれこれ考えてみます。

別途ロールを設計し、組織とマッピングするようにしましょう

ロールという業務的権限の集合

アクターはユースケースの主語なので、業務的権限ではありません。
この文脈では ロールという表現がしっくりします。

権限制御したいオペレーションをグルーピングして、権限として設計するようにしましょう

ここでグルーピングしたものは ユースケースに近しいように考えます。
この文脈では アクターという表現がしっくりします。

ふむ。。。

  • ロールはラベル(システムにおけるアクセス権限に使わない)
  • 権限はユースケース(もしくはグルーピングしたオペレーション)
  • アクターは主語(ロールは システムにおける主語にはならない)

というので、どうでしょうか?

もう少し考えてみます。

ロールはラベル

ラベルはシステムに柔軟さを与えてくれます。

ラベルによる柔軟さ とは、例えば ユーザー登録をする際に 付与する区分として使って、また権限を割り充てた新たに追加も出来るということです。

ロールはラベルとして任意に編集できます(柔軟さの提供)。

権限はユースケース

ユースケースのサイズはアクターから見て、1つのユースケースを終了すれば目的が達成されており、かつ1つのユースケースの中では中断が行われないことを目安にします

とあります。

権限制御したいオペレーションをグルーピングとして、ユースケースは良さそうです。
また、今回の整理とは直接関係は無いのですが、サービスとユースケースを明確に分けて整理できるところも良さそうです。

ユースケースはシステムが提供する価値なので、ラベルのように編集するものではなく、システムの価値として定義(設計)します。

アクターは主語

アクターはシステムの利用者(外部)として ユースケースの主語として表現します。

アクターもユースケースと同様に 編集するものではなく、定義(設計)するものです。 こちらも、機能に対する要件の厳密さを表現します。

さらなる考察

自分なりに 納得ができる整理が出来てきつつあります。
では、もう少し 具体的に実装を踏まえた考察を進めていこうと思います。

コードによる表現対象

ロールはラベルなので、コードによる静的な表現対象から外します。
ユースケース(という名前の権限のグルーピング)と、アクター(という名前のユースケースの関連)が実装(つまり定義)の対象になります。

レイヤー(パッケージ)

結論:アプリケーション層

当初、アクターはシステムの外を定義したものなので、全てのレイヤーから参照できうる層として、ドメイン層が良いかな?と考えました。 ですが、アクターは、

  • ドメイン知識そのものではないのではない
  • 振る舞い(ユースケース)と関連付けされる(依存させる)ものである

ということで、アプリケーション層配下に配置するのが妥当だろうと考えました。
またアプリケーション層であれば、プレゼンテーション層から参照できる、ドメイン層から参照できない という制約も 目的に合っていると思います。

アクター

アクターの種別は、Enumで実装したいです。

ただ、Enumそのものは 継承が使えません。
UMLの表現としてアクターは 汎化や 包含を 用います。
インターフェースを使ったら、表現できうる実装になりそうな気もしますが、そうすると アノテーションで指定しづらくなるような気もするし。。

とはいえ、権限が主たる関心事であると割り切れば、あとは差分の表現さえできれば十分な気もします。 実際、UMLによる汎化と包含について「これが正しい」という厳密な基準について言及されている記事を見つけることも出来ませんでした。 また、そこの厳密さの基準を設けても、自分自身 その基準が妥当なのか 数日経てば変わるような感覚もあり、とりあえず 何かしらの方法で差分表現ができるような実装が出来ればよいだろう、という結論に至りました。

ユースケース(権限)

こちらも Enumで実装したいです。

権限のグルーピングとしてユースケースという表現を考えていますが、ユースケースもアクターと同じく 差分の表現(汎化や包含)があります。
ですが、今回の主たる関心事は ユースケースを実現するフローの差分ではなく、アクターとユースケースの関連のなので、アクターであったような課題は 考える必要は無さそうに思います。

実装

アクター、ユースケース(権限) どちらとも Enumで実装します。
クラス名を、Actor、Usecase として 詳細を列挙子として実装し、アプリケーション層のルートパッケージ直下に配置します。

アクターとユースケース(権限)

関連を示すクラスを別途設けるのではなく、アクターの要素として定義します。

サービス

クラスアノテーションとして、サービスの主語として アクターを宣言します。
アクターは複数指定することも可能です。
こうすることで、ユースケース記述に近しいものを サービスの実装で表現します。

ログインユーザーの権限と アクターに関連付けられた ユースケース(権限)を 用いて、当該サービスの実行可否を判定します。

アクセス制限の指定として、サービスはユースケースを構築する振る舞い(つまり部品)ということで ユースケースを使うことも想定できます。 もちろん「あるサービスは、あるユースケースの部分である」という実装表現もあるとは思いますが、アクターを主語として サービスを述語とする 実装と比べてみて、 実装から理解できる文脈において 優位性を感じることが出来ませんでした。

したがって サービスにおけるアクセス制限は、アクターだけにします。

コントローラーでのアクセス制限

アクセス制限は、システムの中と外の境界となる コントローラーにも設けることも想定されます。 実際、これまで私もアクセス制限を設けるとしたら、コントローラーに実装していました。

ですが、サービスをユースケース記述のように実装する、という考えから、アクセス制限に相当するものは サービスにおけるアクターで表現した方が分かりやすいという考えに変わりました。
とすると、コントローラーで行うアクセス制限は どうするのが良いでしょうか?
結論としては、コントローラーのアクセス制限は ユースケース(権限)で行うです。

理由は、操作は ユースケースの部分である、という文脈で実装をしたいからです。
呼び出すサービスを振り分ける場合も権限(ユースケース)を用いて 分岐をします。*2
また、アクターの使用を避ける理由として、アクターは条件分岐に使えない、ということもあります。

アクターは分岐条件に使えない

少し、この点についての考察を追記しておきたいと思います。
ログインしたユーザー情報から、把握できるのは ロールおよび、それに紐づく権限(ユースケース)だけです。

アクターの代替としてロールは使えません。 ロールは、アクターと異なり、業務的権限の集合のような 全く違う基準で決めるもので あくまでラベル(分類)です。

では、権限(ユースケース)からアクターを導出するというのはどうでしょうか。
例えば、ロールに関連付けられた 権限(ユースケース)が、アクターのユースケース(権限)と完全一致していたら、目的のアクターであると見做せるでしょうか?
それは無理があります。
述語の集合が一致しているからといって、主語は特定できません。犬は走りますが、走れたら犬である とはなりません。

ということで、導出できないアクターを、コントローラーで 呼び出すサービスを分岐させるような処理をしたい場合の条件として使うことは出来ない、ということになります。

アクセス制限が無かったら?

使用用途としては、アクセス制限のための定義なので、特に そのような制限が無ければ、アクターとユースケース(権限)の実装は不要かもしれません。
ただ、私としては 要件として定義した時点で、コードに落としておいて 制限が必要になったら使用するというのでも良いかな?と思っています。

まとめ

参考資料

Bounded Context パターンの実践方法は? | システム設計日記

https://qiita.com/suke_masa/items/1473450a8b59eea5f3cd

アクターとは - たまゆら雑記

さいごに

うーん、、もったいぶった割に当たり前のことを書いただけになった気がしなくもないですが、私としては スッキリしました。

アクターって、システム境界を決めるために大切である、ということは 周知の事実だと思うけど、それをコードとしてどうやって表現するのか?っていうのは あんまり見ないなぁ、と思ったり思わなかったり。
そもそもシステムの外部なのだから コードで実装するものではない、ということなのかなぁ?
でも、何を外部とするのか、外部をどう定義して どう捌くのか、っていうのは システムの内側で それなりに判別しないといけないと思うんですけど、どうなんですかね?

さて、次は この整理を踏まえて実装例を まとめようかな。

*1:知り合いに、このことを話したら「言葉通り、全く違う印象しかないんだけど・・」と言われてしまいました。。

*2:具体的には「ブログ:業務システムにおけるロールベースアクセス制御」で例示されている通りです。

ログインユーザーの管理

ログインしたユーザー情報を管理するにあたって必要そうなことの整理。

順不同で、あれこれ。

各種部品を作ったりするための整理。

EEとかSpringの認証ライブラリは?

とりあえず、各種ライブラリを 使わないで 自前のForm認証から試してみようかと考えています。
今回のテーマは、認証認可をするための仕組み というよりも、ログイン後の権限に対する仕組み を考えてみようと思っているからです。

イントラネット(プライベート)だったら 自前のものや、Firewallの後ろだからBasic認証でも良いかなと思うし、インターネット(パブリック)だったら、自前でログインによる認証・認可を管理するよりも Googleとかのサービスを使うことになると思っています。
つまり、仕組みとして注力するのは ライフサイクルや アクセス権限のことを考える方を優先した方が良いかな?と。

名前付け

ログインユーザーとか、セッションユーザーとか、そんな感じ。
操作者の情報という意味を鑑みて「ClientAgent」にしようと思っています。

ライフサイクル

Scopedアノテーションを付与したクラスと 振る舞いを行うクラスは別にして、ライフサイクルだけを管理するものにしておく。

今回はセッションスコープ

リクエストスコープにして、都度 永続化情報やキャッシュへ問い合わせるというやり方もあると思います。
(可用性の高い仕組みを設けたい場合は、こっちかな?)
アクセスキーは、ログインIDか、そこから生成したハッシュ値を使うイメージ。

ログアウト

もしくは、セッション破棄。
これはクライアントが関係するので、JavaScript による close をトリガーとして サーバーサイドの操作をします。

セッションハイジャック対策

ログインしたところで、セッションIDを書き換えます。
自前のForm認証じゃない場合でも、使えるような仕組みにしたいところですが、そのためには Basic認証とか コンテナによる認証機構を使うとか、そのあたりも調べないといけないので 後回しにするかも。

パスワードのハッシュ化

生パスワードでチェックをするのではなく、ハッシュ化したもので判定をする。
SALTとか使って云々をするところとか、そのあたりもかな。
一応、自前のForm認証用のUtilityとして作るところを最低限と言う感じかなぁ。
この機能は ユーザー登録みたいなところでも使えるような可搬性も踏まえた作りにしておきたいところ。

認証と認可を分ける

若干YAGNIな気もするけど、OAuth2を使った仕組みへの連携とか、そのあたりを ある程度 考慮した仕組みも考えておきたいところ

権限判定

アクションに対するロールとか、そのあたりの仕組み。
悩んでいるところとしては、アクションに対するロールという整理が良いのか、アクターとユースケースとする整理が良いのか、というところ。

これについては、デブサミで 偶然 良い視座をいただきました。

リダイレクト

ログイン画面へのリダイレクトさせるケース

未ログイン

操作に対して、そもそもログインしているか、していないか、というレベルの話。
権限が付与されていない状態での操作、というものも これに含まれるかな。
OAuth2の発想が参考になりそうな気がします。

タイムアウト

セッションタイムアウトしていたら、再ログインを促します。
未ログインとの違いは、長時間の操作をしていなかったことを ユーザーに通知してからログイン画面に遷移させるか、いきなりログイン画面に遷移させるか、というところ。
自分の観測範囲では、遷移パターンはサービスによって異なるように思います。

  • ログイン画面へタイムアウトメッセージを添えて遷移する
  • タイムアウトした旨を伝える画面に遷移して、そこからログイン画面へ遷移する

と思ったけど、機能としては タイムアウトを検知時に 遷移する先の遷移先を指定するだけだから、実質一緒かな?

権限の異なる操作

異なる権限のユーザーで、URLを直接実行するケース。
悪意が無ければ普通は無さそうなケースだけど、だからこそ外せないところ。
通常なら URL Filterで制御するようなところです。
なので、Serviceで権限制御をしようとすると、この点については 対処できないケースがあるような気がしています。 ただ、適切に権限指定すれば 大丈夫な気もしています。

ログイン前後の情報喪失を防ぐ

具体的には、ログイン前にカートに入れた商品を いざ購入しようとしたら ログインを促されて ログインしたらカートの中身が空になるみたいなケース。
なんだけど、これは そもそも可用性の話であって権限とは話が違うので除外。

考えようとしたことのメモとしては

  • カートに商品を入れる という操作は 商品購入というユースケースとして 購入者権限が必要(=ログインしないといけない)として、ログイン画面を介在させる
  • 購入する という操作前後で カートの情報が喪失しないように引き継ぐ

セッションハイジャックのことを考えると*1、そもそも後者って どうやってやっているんだろう?という感じです。
セッションではなく、別のトークンみたいなものをもたせて、セッションとは異なる キャッシュで管理している?
クライアントに保持しておいて 毎回 全部引き回す?

参考情報

以前の自分の認証認可のメモのリンクは、一通り 改めて 読み直しておきたいところ

vermeer.hatenablog.jp

*1:セッションIDを書き換えるだけだから使えるのかな?

RDBのメモ

設計

データベースオブジェクトの命名規約 - Qiita

DB スキーマ設計のガイドライン - Qiita

H2

毛嫌いされる今だからこそ、Java! --- JPA編 ---- - Qiita

h2 databaseをリカバリする - Qiita

H2をインメモリで動かすときの注意 - Yamkazu's Blog

GitHub - vasouv/jpa-h2-payara: Demonstration of the embedded H2 database in Payara 5

JavaEE7の環境構築 - Qiita

デバッグ用のログを出力させる

vermeer.hatenablog.jp

で、基本編的なところを整理しました。

今回は、アイディアネタ的な実装である デバッグ用のログ出力機能について メモを残します。

やりたいこと

  • 実行時例外が発生したときにだけ、アクションの開始時点の情報を出力したい
  • 出力ログファイルも別にしたい

実行時例外になったときに、アクションの開始時点*1の詳細情報を確認できる仕組みがあれば良いかもしれない、かといって、つねにアクションに関する情報をログへ出力したいわけではないというのがアイディアです。

開始時点の情報ですが、ActionクラスのtoStringメソッドの戻り値を出力します。 独自のインターフェースを設けることも考えましたが、 とりあえず toStringはオブジェクトの文字列情報を返却する という責務があるのだから、 あまり深く考えずに toStringをそのまま使うことを前提にしました。
当然ですが、何もしないと クラス名とHashCodeを出力するだけなので、有効な情報はありません。 lombokを使うとか 自分で実装するとか、まぁ そういう手間は必要になります。 とりあえず、仕組みを作るところまでを目標としました。

データを保持する

RequestScoped で、開始時点の情報を保持して(setUp)、実行時例外により処理が終了する際(tearDown)に出力させます。

@RequestScoped
public class LoggerStore {

    private Logger logger;
    private LoggerStoreItems items;
    private Class<?> triggerActionClass;
    private String startTitle;
    private String tearDownTitle;

    @PostConstruct
    public void init() {
        this.items = new LoggerStoreItems();
        this.startTitle = ">> Trace Logging Start >>";
        this.tearDownTitle = "<< Trace Logging  End  <<";
    }

    public void setUp(InvocationContext ic) {
        this.triggerActionClass = ic.getTarget().getClass().getSuperclass();
        this.logger = LoggerFactory.getLogger(LoggerName.LOGGER_STORE_SUB_NAME + "." + triggerActionClass.getName());
        this.append(ic, startTitle);
        this.append(ic, ic.getTarget().toString());
    }

    public void tearDown(Throwable throwable) {
        if (throwable != null) {
            Class<?> throwableClass = throwable.getClass();
            this.items.add(throwableClass, null, throwable, "");
        }
        this.items.add(triggerActionClass, null, null, tearDownTitle);
        this.items.logBy(logger);
    }

    public void append(InvocationContext ic, String message) {
        Class<?> actionClass = ic.getTarget().getClass().getSuperclass();
        Method actionMethod = ic.getMethod();
        this.items.add(actionClass, actionMethod, null, message);
    }

}

Interceptor

@Action
@Interceptor
@Priority(Interceptor.Priority.APPLICATION + 5)
public class ActionInterceptor {

    @Inject
    private LoggerStore loggerStore;

    @AroundInvoke
    public Object invoke(InvocationContext ic) throws Exception {
        Action action = ic.getMethod().getAnnotation(Action.class);

        loggerStore.setUp(ic);

        if (action != null && action.value().equals(Action.Ignore.ON)) {
            return null;
        }

        InvocationContextLogger logger = InvocationContextLogger.getLogger(ic);
        try {
            logger.fine(() -> "start");
            return ic.proceed();
        } finally {
            logger.fine(() -> "end");
        }

    }
}

ExceptionHandler

public class CustomExceptionHandler extends ExceptionHandlerWrapper {

    private final ExceptionHandler exceptionHandler;
    private final ThrowableHandlerFactory throwableHandlerFactory;
    private final ErrorPageNavigator errorPageNavigator;
    private final LoggerStore loggerStore;

    CustomExceptionHandler(ExceptionHandler exceptionHandler, ThrowableHandlerFactory throwableHandlerFactory,
                           ErrorPageNavigator errorPageNavigator, LoggerStore loggerStore) {
        this.exceptionHandler = exceptionHandler;
        this.throwableHandlerFactory = throwableHandlerFactory;
        this.errorPageNavigator = errorPageNavigator;
        this.loggerStore = loggerStore;
    }

    @Override
    public ExceptionHandler getWrapped() {
        return this.exceptionHandler;
    }

    @Override
    public void handle() {

        final Iterator<ExceptionQueuedEvent> it = getUnhandledExceptionQueuedEvents().iterator();

        while (it.hasNext()) {

            ExceptionQueuedEventContext eventContext = (ExceptionQueuedEventContext) it.next().getSource();

            Throwable causeThrowable = getRootCause(eventContext.getException()).getCause();
            Throwable throwable = causeThrowable != null
                                  ? causeThrowable
                                  : eventContext.getException().getCause();

            ThrowableHandler throwableHandler = this.throwableHandlerFactory.createThrowableHandler(throwable, eventContext);
            try {
                throwableHandler.execute();

            } catch (Exception ex) {
                this.errorPageNavigator.navigate(ex);

            } finally {
                this.loggerStore.tearDown(throwable);

                // 未ハンドリングキューから削除する
                it.remove();
            }

            getWrapped().handle();
        }

    }
}

Loggerの初期化

通常のログと違って、出力先の異なる 別のLogger(storeLogger)に出力します。
FileHandlerを 新たに設けることで実装しました。

[Java]Java SE標準ロギングのプロパティ設定で複数のファイルにログを分けて出力する - torutkのブログ
を参考にしました。

@ApplicationScoped
public class LoggerLifecycleHandler {

    private static final Logger rootLogger = Logger.getLogger(LoggerName.ROOT_NAME);
    private static final Logger storeLogger = Logger.getLogger(LoggerName.ROOT_NAME + "." + LoggerName.LOGGER_STORE_SUB_NAME);

    public void startUp(@Observes @Initialized(ApplicationScoped.class) Object event) {
        System.out.println(">> Startup:Initialize RootLogger >>");
        LoggerInitializer.builder()
                .rootLogger(rootLogger)
                .propertiesFilePath("/logging.properties")
                .consoleHandlerClass(LogConsoleHandler.class, LogConsoleFormatter.class)
                .fileHandlerClass(LogFileHandler.class, LogFileFormatter.class)
                .execute();

        LoggerInitializer.builder()
                .rootLogger(storeLogger)
                .propertiesFilePath("/logging.properties")
                .consoleHandlerClass(LogConsoleHandler.class, LogConsoleFormatter.class)
                .fileHandlerClass(LogStoreFileHandler.class, LogFileFormatter.class)
                .execute();

    }

    public void shutdown(@Observes @Destroyed(ApplicationScoped.class) Object event) {
        System.out.println("<< Cleanup:Closing logging file <<");
        LogFileCloser logFileCloser = new LogFileCloser();

        Collections.list(LogManager.getLogManager().getLoggerNames()).stream()
                .filter(name -> name.startsWith(LoggerName.ROOT_NAME))
                .forEach(logFileCloser::close);

    }

}

Code

vermeer_etc / jsf-ddd / source / — Bitbucket

さいごに

開始時点の実装はしましたが、処理中の情報ををストックする実装は一旦 保留としています。 必須な気もしましたが、アイディア実装みたいなところもあるので とりあえずベースとなる仕組みまでで止めておいて、有効活用するケースが具体的にあった時に拡張していけばよいかな と考えたためです。 また、できればクラス名などをLoggerクラスのように リクレクションで取得出来たら便利かな?と思って、実際の実装を見てみたのですが Java8以前と Java9以降では 使っているライブラリが大きく違っていたというのも、一旦保留とした理由の1つです。*2


*1:今回は実装するのを保留にしましたが、必要であれば途中の状態も

*2:まだ EEに関する技術参考になりうるのは Java8に留めておいた方が良いだろうという考えもあっての判断でもあります。