知識創造技術者の日々

Flash IDE 上でのMVCについて考えてみた（その２）

2011-01-07T08:19:00.005+09:00

GUIコンポーネントは入れ子の構造となり、また各コンポーネントは MVC のすべての役割をもつため、MVC という枠組みだけでは対応できないと考え、前回の内容を変更しました。

今回作成したサンプル

TextArea に最初 0 が表示され、マウスでクリックもしくは Enter キーを押すごとに値が 1 増えるアプリです。

シンボル

LIBRARY 内のフォルダ名

com.objectfanatics.samplecomponent

シンボル名

Component

リンク先のクラス

com.objectfanatics.samplecomponent.Component

クラス構成

com.objectfanatics.samplecomponent パッケージ

com.objectfanatics.samplecomponent.Component

Flash IDE 上で作成したシンボルからリンクされるクラス。
コンポーネント全体を表すクラス。

com.objectfanatics.samplecomponent.model パッケージ

com.objectfanatics.samplecomponent.model.Model

コンポーネントのモデルのインタフェース。
モデルは可能な限り実装を意識しないで設計したいため、あえてインタフェースを作成。

com.objectfanatics.samplecomponent.model.ModelImpl

コンポーネントのモデルの実装。

com.objectfanatics.samplecomponent.model.ModelListener

Model の変更内容を監視するためのリスナーインタフェース

com.objectfanatics.samplecomponent.view パッケージ

com.objectfanatics.samplecomponent.view.ModelListenerImpl

Model の変更を監視し、Model の変更内容に応じて View を更新するクラス。
ModelListenerインタフェースの実装クラス。

com.objectfanatics.samplecomponent.view.ViewInitializer

View を初期化するためのクラス。

com.objectfanatics.samplecomponent.controller パッケージ

com.objectfanatics.samplecomponent.controller.Controller

Controller の Model 寄りの処理を行なう。

com.objectfanatics.samplecomponent.controller.ViewAdapter

Controller の Component 寄りの処理を行なう。
Component の内部要素に対してリスナーを登録し、イベントを監視する。
Component からのイベントを処理し、必要に応じて Model を更新する。

ソース

package com.objectfanatics.samplecomponent.component {

import com.objectfanatics.samplecomponent.controller.Controller;
import com.objectfanatics.samplecomponent.controller.ViewAdapter;
import com.objectfanatics.samplecomponent.model.Model;
import com.objectfanatics.samplecomponent.model.ModelImpl;
import com.objectfanatics.samplecomponent.view.ModelListenerImpl;
import com.objectfanatics.samplecomponent.view.ViewInitializer;

import flash.display.Sprite;
import flash.text.TextField;

/**
 * FlashIDE 上の LIBRARY にて、フォルダ名が com.objectfanatics.samplecomponent、名前が Component のシンボルに対応するクラスです。
 *
 * このサンプルでは、GUIコンポーネントという単位を扱い、このクラスが１つの GUI コンポーネントを表しています。
 *
 * このコンポーネントの内部には TextField などの GUI コンポーネントが内包（FlashIDE上で定義されたシンボルのインスタンスやActionScriptで動的に作成されたものなど）
 * されており、それはこのコンポーネントそのものの Model, View, Controller のいずれでもないと考えます。
 *
 * そのため、このコンポーネントは Model, View, Controller だけでなく、自身を表す Component とその内部の Sub Components で表されると考えます。
 *
 * View については、Model の内容を常に反映しながら情報を外部に提供するという MVC で言うところの View は、オブジェクトとしては存在しないと考えます。
 * なぜなら、この役割は自身を表す Component もしくはその内部の Sub Components によって達成されるからです。
 *
 * 自身を表す Component とその内部の Sub Components が View に該当するかというと、View としての性質を持っていますが、同時に Model でもあり Controller でも
 * あるため、View と表現するのは妥当ではないと考えます。そのため、自身を表す Component とその内部の Sub Components という表現をしています。
 *
 */
public class Component extends Sprite {

    /**
     * numberText sub component.
     */
    public var numberText:TextField;

    public function Component ():void
    {
        // Model を初期化します
        var model:Model = new ModelImpl ();

        // Model の変更内容を監視し Component に反映させるための ModelListener を初期化します
        model.modelListener = new ModelListenerImpl (this);

        // Controller を初期化します
        var controller:Controller = new Controller (this, model);

        // Component もしくは Sub Components からの入力を監視し Controller に伝える処理を行うクラスを初期化します
        new ViewAdapter (this, controller);

        // View を初期化します
        new ViewInitializer (this, model);
    }
}
}

package com.objectfanatics.samplecomponent.controller {

import com.objectfanatics.samplecomponent.component.Component;
import com.objectfanatics.samplecomponent.model.Model;

/**
 * Controller クラスです.
 *
 * Component の監視処理の記述は ViewAdapter クラスが行っています。
 *
 * Controller 自身が Component や Sub Component の監視を行う場合、複数のコンポーネント上で
 * ボタンの監視やキーが押されることが、Model の値をインクリメントさせるトリガに成り得ます。
 * このような処理を Controller の Component 寄りの処理と言うことにします。
 *
 * しかし、どのボタンが押されてもキーが押されても Controller としては Model の値をインクリメント
 * して欲しいというイベントであると考えられます。このような考えに基づく処理を Controller の
 * Model 寄りの処理と言うことにします。
 *
 * そう考えると、Controller の Model 寄りの処理を Controller が、Component 寄りの処理を
 * ViewAdapter が行っていると言うことができます。
 */
public class Controller {

    private var model:Model;
    private var component:Component;

    public function Controller (component:Component, model:Model):void
    {
        this.component = component;
        this.model = model;
    }

    /**
     * Model の値をインクリメントします.
     */
    public function increment ():void
    {
        model.increment ();
    }
}
}

package com.objectfanatics.samplecomponent.controller {

import com.objectfanatics.samplecomponent.component.Component;

import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.ui.Keyboard;

/**
 * Controller の Component 寄りの処理を受け持つクラスです.
 *
 * Component もしくは Sub Components からの入力を監視し Controller に伝える処理を行います.
 */
public class ViewAdapter {

    private var controller:Controller;

    public function ViewAdapter (component:Component, controller:Controller):void
    {
        // Controller の格納
        this.controller = controller;

        // Component のクリックの検出設定
        component.addEventListener (MouseEvent.CLICK, onClicked);

        // Enter キーの検出設定
        component.addEventListener (KeyboardEvent.KEY_UP, onKeyUp);
    }

    private function onClicked (e:MouseEvent):void
    {
        controller.increment ();
    }

    private function onKeyUp(e:KeyboardEvent):void {
        if (e.keyCode == Keyboard.ENTER) {
            controller.increment ();
        }
    }
}
}

package com.objectfanatics.samplecomponent.model {

/**
 * Model インタフェースです.
 */
public interface Model {

    /**
     * ModelListener をセットします。
     * @param modelListener ModelListener
     */
    function set modelListener (modelListener:ModelListener):void;

    /**
     * 値を返します。
     * @return 値
     */
    function get number ():uint;

    /**
     * 値を1増やします。
     */
    function increment ():void;
}
}

package com.objectfanatics.samplecomponent.model {

/**
 * Model の実装クラスです.
 */
public class ModelImpl implements Model {

    private var _modelListener:ModelListener;

    /**
     * 保持される値
     */
    private var _number:uint = 0;

    /**
     * Model#get number():uint の実装
     */
    public function get number ():uint
    {
        return _number;
    }

    /**
     * Model#set modelListener(modelListener:ModelListener):void の実装
     */
    public function set modelListener (modelListener:ModelListener):void
    {
        this._modelListener = modelListener;
    }

    /**
     * Model#increment():void の実装
     */
    public function increment ():void
    {
        this._modelListener.numberChanged (++_number);
    }
}
}

package com.objectfanatics.samplecomponent.model {

/**
 * Model の変更内容を監視するためのリスナー
 */
public interface ModelListener {

    /**
     * 値が変更された場合に呼び出されます。
     *
     * @param number 変更後の値
     */
    function numberChanged (number:uint);
}
}

package com.objectfanatics.samplecomponent.view {

import com.objectfanatics.samplecomponent.component.Component;
import com.objectfanatics.samplecomponent.model.ModelListener;

/**
 * Model の変更内容を監視し Component に反映させるための ModelListener の実装クラス。
 */
public class ModelListenerImpl implements ModelListener {

    /**
     * 変更対象の Component
     */
    private var component:Component;

    /**
     * コンストラクタ
     * @param view 変更対象の View
     */
    public function ModelListenerImpl (component:Component):void
    {
        this.component = component;
    }

    /**
     * Model の値が変更された時に呼び出され、View 上の表示を変更します。
     * @param currentNumber 現在のの Model の値
     */
    public function numberChanged (currentNumber:uint)
    {
        component.numberText.text = "" + currentNumber;
    }
}
}

package com.objectfanatics.samplecomponent.view {

import com.objectfanatics.samplecomponent.component.Component;
import com.objectfanatics.samplecomponent.model.Model;

/**
 * View を初期化するためのクラスです.
 *
 * ここではこのコンポーネント全体の見た目を初期化するため、View ということばをあえて使用しています。
 */
public class ViewInitializer {

    /**
     * View を初期化します.
     *
     * @param component Component
     * @param model Model
     */
    public function ViewInitializer (component:Component, model:Model):void
    {
        component.numberText.text = "" + model.number;
    }
}
}

今回の所感

今回 Component として扱った箇所を前回は View として扱っていてなんとなく気持ち悪かったのですが、なんとなくすっきりした気がします。

コンポーネントを構成するクラスの数がかなり多くなっていますが、１つのコンポーネントのサブコンポーネントが数十とか数百あり全体のソースが数千行以上に及ぶようなコンポーネントをを作成するのであればこの程度の分割はメリットはあってもデメリットはないと思います。

それほど大きなコンポーネントを作成しない場合であれば、いくつかもしくはすべてを省略してもかまわないと思います。要はケースバイケースということですね。

Twinner で画面上のコンポーネントを動かしたりするような場合、処理はどこに書くのかな？　その処理のトリガがGUIからの入力であればトリガの処理は ViewAdapter に記述して、実際の処理は Controller かな。Twinnerなどによる処理や ActionScript を用いてのコンポーネントの処理などが多くデザイン系の比重が大きい場合は、Controller の描画寄りの処理用として別クラスにしたほうがいいかもしれません。しかし、クラス名や責務はなんだろう。Controllerなのか？Viewなのか？

徹夜後の夕方なのでちょっとヘロヘロです(´・ω・`)

アーカイブ

asdocのエラー

2011-01-01T09:14:00.000+09:00

asdoc を作成する際に遭遇したエラーのメモ

エラー内容

[Fatal Error] :3:6: エレメント型 "Hoge" は対応する終了タグ "</Hoge>" で終了する必要があります。
適格な形式でないテキストが検出されました。詳細については、C:\hoge\fuga\piyo\validation_errors.log を参照してください。

ログ内容

org.xml.sax.SAXParseException: エレメント型 "Hoge" は対応する終了タグ "</Hoge>" で終了する必要があります。

原因と対応方法
メソッドの /** */ で囲まれているドキュメント内に Vector.<Hoge> のような箇所があったことが原因。括弧をエスケープして対応。

asdocでjavadocの-linkオプションのようなことをしようと思ったが、、、

2010-12-01T19:50:00.001+09:00

自作ライブラリの asdoc から as3 の core に含まれている Number とか Boolean とか Vector などの asdoc へのリンクを貼りたくて、調べてみました。

すると、同様の要求が下記のように登録されていました。

ASDoc: Hyperlinks to Actionscript Language Reference documentation

For example, if a method in my custom class returns a Boolean, I would like to be able to click on the word "Boolean", which would take me to the Boolean documentation in the AS3.0 Language Reference:
http://help.adobe.com/en_US/AS3LCR/Flash_10.0/Boolean.html

まさにこの機能！ (｀・ω・´)

しかし、type が Minor Enhancement として登録されています。

マイナーらしいです。 (´・ω・`)

しかも、

Nice request but out of scope for this release. Deferring.

として、クローズされてます。

as3commonsのasdocでも対応してないところをみると、今のところ有効な手段はないかもしれませんね。

flex-mojos と asdoc

2010-11-27T18:27:00.024+09:00

公式ページ
http://flexmojos.sonatype.org/

flexmojos-maven-plugin のある場所
http://repository.sonatype.org/content/groups/flexgroup/org/sonatype/flexmojos/flexmojos-maven-plugin/

com.adobe.flex.framework系のある場所
以下あたりを参考にして、バージョンを決めればよさそう。
https://repository.sonatype.org/content/groups/flexgroup/com/adobe/flex/framework/framework/

mvn test と mvn verify ができる最低限の 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/maven-v4_0_0.xsd">
    
    <!-- pom.xml参考 : http://dev.yoolab.org/maven/content/repositories/releases/org/as3commons/as3commons-project/1.0.1/as3commons-project-1.0.1.pom -->
    
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.objectfanatics</groupId>
    <artifactId>sandbox</artifactId>
    <packaging>swc</packaging>
    <name>ObjectFanatics Sandbox Project</name>
    <version>0.0.1-SNAPSHOT</version>
    <inceptionYear>2010</inceptionYear>
    <url>http://www.objectfanatics.com/</url>
    <description>ObjectFanatics Sandbox Project</description>
    
    <properties>
        <!-- flex-mojos version -->
        <flex-mojos.version>3.5.0</flex-mojos.version>

        <!-- flex version -->
        <flex.version>3.5.0.12683</flex.version>

        <!-- flashplayer version -->
        <flashplayer.version>${flashplayer.version.major}.${flashplayer.version.minor}.${flashplayer.version.revision}</flashplayer.version>
        <flashplayer.version.major>10</flashplayer.version.major>
        <flashplayer.version.minor>0</flashplayer.version.minor>
        <flashplayer.version.revision>0</flashplayer.version.revision>
    </properties>
    
    <!-- 開発者情報 -->
    <developers>
        <developer>
            <id>makoto.sato</id>
            <name>Makoto Sato</name>
            <email>makoto.sato [at] objectfanatics.com</email>
            <url>http://www.objectfanatics.com</url>
            <organization>ObjectFanatics Ltd.</organization>
            <organizationUrl>http://www.objectfanatics.com</organizationUrl>
            <timezone>+9</timezone>
        </developer>
    </developers>

    <dependencies>
        
        <!-- Player/Air Global dependency. -->
        <dependency>
            <groupId>com.adobe.flex.framework</groupId>
            <artifactId>playerglobal</artifactId>
            <version>${flex.version}</version>
            <scope>external</scope>
            <type>swc</type>
            <classifier>${flashplayer.version.major}</classifier>
            <!--<classifier>${flashplayer.version.major}.${flashplayer.version.minor}</classifier>-->
        </dependency>
        
        <!-- for unit testing. http://asunit.org/ -->
        <dependency>
            <groupId>com.asunit</groupId>
            <artifactId>asunit</artifactId>
            <version>20071011</version>
            <type>swc</type>
            <scope>test</scope>
        </dependency>
        
        <!-- Dependencies for Flex. This includes flex classes. ex: ListCollectionView. -->
        <dependency>
            <groupId>com.adobe.flex.framework</groupId>
            <artifactId>framework</artifactId>
            <version>${flex.version}</version>
            <scope>external</scope>
            <type>swc</type>
        </dependency>
        
        <!-- Dependencies for Flex. This includes resource bundle. Not having this dependency causes some errors. ex: [ERROR] Unable to resolve resource bundle "collections" for locale "en_US". -->
        <dependency>
            <groupId>com.adobe.flex.framework</groupId>
            <artifactId>framework</artifactId>
            <version>${flex.version}</version>
            <type>rb.swc</type>
            <scope>external</scope>
        </dependency>

        <dependency>
            <groupId>com.adobe.flex.framework</groupId>
            <artifactId>utilities</artifactId>
            <version>${flex.version}</version>
            <type>swc</type>
            <scope>external</scope>
        </dependency>

        <dependency>
            <groupId>com.adobe.flex.framework</groupId>
            <artifactId>flex</artifactId>
            <version>${flex.version}</version>
            <type>swc</type>
            <scope>external</scope>
        </dependency>

        
        <dependency>
            <groupId>com.adobe.flex.framework</groupId>
            <artifactId>framework</artifactId>
            <version>${flex.version}</version>
            <scope>external</scope>
            <type>zip</type>
            <classifier>configs</classifier>
        </dependency>
        
        <dependency>
            <groupId>com.adobe.flex.framework</groupId>
            <artifactId>rpc</artifactId>
            <version>${flex.version}</version>
            <scope>external</scope>
            <type>swc</type>
        </dependency>
        
        <dependency>
            <groupId>com.adobe.flex.framework</groupId>
            <artifactId>rpc</artifactId>
            <version>${flex.version}</version>
            <type>rb.swc</type>
            <scope>external</scope>
        </dependency>

    </dependencies>
    
    <build>
        <sourceDirectory>src/main/actionscript</sourceDirectory>
        <testSourceDirectory>src/test/actionscript</testSourceDirectory>
        <defaultGoal>test</defaultGoal>

        <plugins>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.sonatype.flexmojos</groupId>
                <artifactId>flexmojos-maven-plugin</artifactId>
                <version>${flex-mojos.version}</version>
                <extensions>true</extensions>
                <dependencies>
                    <dependency>
                        <groupId>com.adobe.flex</groupId>
                        <artifactId>compiler</artifactId>
                        <version>${flex.version}</version>
                        <type>pom</type>
                    </dependency>
                </dependencies>
                <configuration>
                    <configurationReport>true</configurationReport>
                    <targetPlayer>${flashplayer.version}</targetPlayer>
                    <locales>
                        <param>en_US</param>
                    </locales>
                    <updateSecuritySandbox>true</updateSecuritySandbox>
                    <includeAsClasses>
                        <source>
                            <directory>src/main/actionscript</directory>
                        </source>
                    </includeAsClasses>
                </configuration>
                </plugin>
                <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-site-plugin</artifactId>
            </plugin>
        </plugins>

    </build>
    
    <repositories>
        <repository>
            <id>flex-mojos-repository</id>
            <url>http://repository.sonatype.org/content/groups/flexgroup</url>
        </repository>
    </repositories>
    
</project>

asDocの生成
flex-mojosでやろうとしたが、3系だとVectorとかのクラスを認識せず、4系だとspark.cssが見つからないとか言われる。本家のバグレポートでは、3系でバグレポートがでてるのに4.0でFixedということでバグがクローズされてる。このような開発状況を見るかぎりは flex-mojo を利用するのはリスクが高いですね、、、。今回はとりあえずasDocの生成をflex-sdkを直接使って行うだけに留めるけど、将来的には構成管理全般からflex-mojosを外すことにしよう。

"C:\Program Files\flex_sdk_4.1.0.16076\bin\asdoc.exe" -source-path . -doc-sources .

ちなみに、as3のソースコードの内容によって以下のようなエラーが出ることがある。

エラー: toplevel.xml を作成できませんでした : String index out of range: -41

原因は未確認。

非同期呼び出しについてのメモ

2010-11-10T07:35:00.004+09:00

非同期呼び出しが絡んだ設計方法についてのメモです。

※以下、実装がマルチスレッドなのかシングルスレッドなのかは無視して考えましょう。

いい感じの本

Enterprise Integration Patterns とかいい感じっす。ECMA Script 系で必要とされるような非同期処理を扱う雰囲気の本ではなくて JMS や MQ 系のメッセージイングサーバを意識した本なのですが、最初の方の章が非同期処理に関する説明がいい感じで載っています。

おいらも読みなおしたいんだけど、日本に置いてきたので今は読めません(´・ω・`)

同期呼び出しのみの場合

スレッド１：処理A -> 処理B -> 処理C のように実行される。

ある処理が非同期処理に依存する場合

すべての処理が非同期だが、すべての処理が依存関係を持つ場合。

スレッド１：処理Aに処理Bをコールバック登録してフォーク 
スレッド２：     処理A実行 -> 処理Bに処理Cをコールバック登録してフォーク
スレッド３：            処理B実行 -> 処理Cにフォーク
スレッド４：                   処理C実行

この手の処理が、かなり面倒。そもそも概念的に非同期処理でないものを実装上強引に非同期処理にしているだけであり、同時並行処理のメリットが全く無い（シングルスレッド環境などの制約条件下でしかたなく対応するケースがほとんどだと思われ）。しかし、依存する処理をコールバックに変換するだけなので、同期呼び出しの場合からの機械的な変換は可能。この手の設計になる場合、同期処理で擬似コードを書いてから、その後機械的に非同期処理に変換したほうがいいかも。

非同期呼び出しにより処理がフォークする場合

各処理に依存関係がない場合は以下のように4つのスレッドが別々に動作する。

スレッド１：処理Aフォーク -> 処理Bフォーク -> 処理Cフォーク 
スレッド２：              -> 処理A
スレッド３：                               -> 処理B
スレッド４：                                               → 処理C

スレッド1の動作は一瞬にして行われるので、処理A,B,Cはほぼ同時に開始する。このような非同期処理は、人間から見てもそこそこ直感的。多くの場合シーケンシャルに動作させた場合よりも高い性能が得られる。

非同期呼び出し処理がジョインする場合

処理A,B,Cのすべてが完了したあとに次の処理が行われる場合の例

スレッド１：処理Aフォーク -> 処理Bフォーク -> 処理Cフォーク 
スレッド２：              -> 処理A -> 合流条件確認 -> (失敗)
スレッド３：                               -> 処理B                         -> 合流条件確認 -> (成功) -> 合流後の処理
スレッド４：                                                -> 処理C -> 合流条件確認 -> (失敗)

非同期処理のパフォーマンスを享受しつつ、処理の同期もおこなってしまうというおいしいところ取りですね。ジョインする条件の確認や、その条件を構成する情報の登録などをする必要があるのでコーディングレベルでは少しめんどくさいのですが、事前に設計をきちんとやっておけば問題ないでしょう。

設計方針考察

まずは、fork と join の発生する処理は避けて実装する。非同期処理を利用するとしても陸上のリレーのようにコールバックを用いて処理を継続させる方法であれば、join 条件のチェックが必要無いので設計がシンプルになる。この方法で、一通り実装して、実装した機能が仕様を満たしていることを確認する。

以下書きかけ。

設計対象の１つの処理を決定する。
処理内にて順次処理とフォークする処理とジョイン後の処理を、最外殻のレベルで分類し、各々の処理の塊をグループとする。
上記グループのうち、最外殻のジョイン処理とそれにジョインされる処理を１つのグループとして扱う。
複数のグループが残った場合、上記の各グループをメソッド化し、それそれを順次実行する。（各々が依存関係を持たないため並行動作が可能）
単一の順次処理の場合はそのまま記述すればよい。非同期処理は必要ない。
単一のジョインされるグループが残った場合、ジョイン実行条件のための情報（ジョイン実行条件判断クロージャから見えるスコープのフラグなど）を用意し、ジョイン実行条件を判断するクロージャを用意し、ジョイン実行条件のための情報の変更を通知するためのクロージャを用意し、ジョイン後の処理のクロージャを用意し、残りのグループを各メソッドとして作成して引数にジョイン実行条件判断用のクロージャと情報通知用クロージャとジョイン後の処理のクロージャを渡すようにする。

以降、上記の1からをネストして行う。
この説明じゃおいら自身以外にはわからんよねｗ　まぁ、個人的なメモなので、、、。

まとめ

同一スレッドでの順次処理、フォーク、ジョインの３種類を適切に考えて設計すればよいということですね。

このような概念を用いた設計はプログラミング言語で記述することは直感的ではないと思うので（少なくともおいらには）、コーディングに入る前にアクティビティ図のような形で設計してみたほうがよいと思います。

Flash IDE 上でのアルファを変えるだけの簡単なボタンの作成

2010-11-04T04:15:00.008+09:00

今回は、Flashの勘所を友人に教わりつつ、簡単なボタンのコンポーネントを作成してみました。

概要
任意のSpriteを継承したオブジェクトに対して、マウスのロールオーバー時に alpha の値を変更する振る舞いを付加するコンポーネントおよびライブラリです。

仕様
AlphaTransitiveButtonクラス

概要

ロールオーバー時に alpha が変化する Sprite です。
ボタンモードはオンになります。

メリット

Flash IDE 上のシンボルからリンクするだけで、シンボルに対してロールオーバー時に alpha が 0.5 に変化する振る舞いを与えることができます。
自前の ActionScript を作成する必要がありません。

備考
以下の場合、AlphaTransitiveButton クラスを使用せずに ButtonUtils の addXxxBehavior() 系のメソッドを利用の検討を推奨します。

既に継承を使用しているために継承が使えない場合。
Alpha を独自に設定したい場合。
継承を使いたくない場合。（例：10種類の振る舞いを追加するために10回継承するということを避けたい場合）

ButtonUtilsクラス

概要

指定された Sprite クラス(もしくは Sprite を継承したクラス)にロールオーバー時に alpha が変化する振る舞いを付加します。
ボタンモードはオンになります。

備考

Flash IDE 上のシンボルに対して本メソッドのデフォルトの振る舞いを追加する場合は AlphaTransitiveButton クラスの利用も検討してみてください。

サンプル

上のボタンは AlphaTransitiveButton クラスにリンクしています。
下のボタンは、ボタンのシンボルの1フレーム目で ButtonUtils#addAlphaTransitiveButtonBehavior(target, rollOverAlpha) を呼び出し、rollOverAlpha を0.8に設定しています。

ソース

AlphaTransitiveButtonクラス

package {
    
    import flash.display.Sprite;
    import flash.events.MouseEvent;
    
    /**
     * ロールオーバー時に alpha が変化する Sprite です。
     * ボタンモードはオンになります。
     * 
     * メリット
     * 　・　Flash IDE 上のシンボルからリンクするだけで、シンボルに対してロールオーバー時に alpha が 0.5 に変化する振る舞いを与えることができます。
     * 　・　自前の ActionScript を作成する必要がありません。
     * 
     * 備考
     * 　・　以下の場合、AlphaTransitiveButton クラスを使用せずに ButtonUtils の addXxxBehavior() 系のメソッドを利用の検討を推奨します。
     * 　　　・　既に継承を使用しているために継承が使えない場合。
     * 　　　・　Alpha を独自に設定したい場合。
     * 　　　・　継承を使いたくない場合。（例：10種類の振る舞いを追加するために10回継承するということを避けたい場合）
     * 
     * @see ButtonUtils#addAlphaTransitiveButtonBehavior(Sprite, Number)
     */
    public class AlphaTransitiveButton extends Sprite {
        
        public function AlphaTransitiveButton() {
            ButtonUtils.addAlphaTransitiveButtonBehavior(this);
        }
    }
}

ButtonUtilsクラス

package {
    
    import flash.display.Sprite;
    import flash.events.MouseEvent;
    
    /**
     * ボタン関連のユーティリティクラスです。
     */
    public class ButtonUtils extends Sprite {
        
        /**
         * 指定された Sprite クラス(もしくは Sprite を継承したクラス)にロールオーバー時に alpha が変化する振る舞いを付加します。
         * ボタンモードはオンになります。
         * Flash IDE 上のシンボルに対して本メソッドのデフォルトの振る舞いを追加する場合は AlphaTransitiveButton クラスの利用も検討してみてください。
         * 
         * 注： target が Dynamic Text の TextArea の場合など、特定の条件下でマウスオーバー時にマウスカーソルの形状が変化しない場合があります。(flash側の問題)
         * 
         * @param target 対象となる Sprite
         * @param rollOverAlpha ロールオーバー時の alpha の値
         * @see AlphaTransitiveButton
         */
        public static function addAlphaTransitiveButtonBehavior(target:Sprite, rollOverAlpha:Number = 0.5) {
            target.buttonMode = true;
            target.addEventListener(MouseEvent.ROLL_OVER, function(e:MouseEvent):void {
                e.currentTarget.alpha = rollOverAlpha;
            });
            target.addEventListener(MouseEvent.ROLL_OUT, function(e:MouseEvent):void {
                e.currentTarget.alpha = 1;
            });
        }
    }
}

アーカイブ

Flash IDE 上でのMVCについて考えてみた

2010-11-01T03:04:00.011+09:00

Flash IDE 上でのMVCについて考えてみた（その２）が最新です。

近々、Flash IDE で開発を行うことになりました。

開発に入る前の実験として、ステージ上に色々とコンポーネントを配置して、Documentクラスに ActionScript のコードを記述して、なんとなく動くものを作っていたというのがこれまでの話。しかし、これでは保守性に難があるなぁと思う今日この頃。

保守性を向上させようと考えた場合に、すぐに思い浮かぶのはコンポーネント化。コンポーネント内部はシンプルなMVCがよさそう。

ということで、実験してみました。

方式

Flash IDE 上で作成したシンボルから as ファイルにリンクを張る方式。
名前空間は Flash IDE 上の LIBRARY 内にフォルダを作成して対応する。

今回作成するサンプル

TextArea に最初 0 が表示され、マウスでクリックするたびに値が 1 増えるアプリ。

シンボル

LIBRARY 内のフォルダ名

com.objectfanatics.samplecomponent

シンボル名

View

リンク先のクラス

com.objectfanatics.samplecomponent.view.View

クラス構成

com.objectfanatics.samplecomponent.model パッケージ

com.objectfanatics.samplecomponent.model.Model

コンポーネントのモデルのインタフェース。
モデルは可能な限り実装を意識しないで設計したいため、あえてインタフェースを作成。

com.objectfanatics.samplecomponent.model.ModelImpl

コンポーネントのモデルの実装。

com.objectfanatics.samplecomponent.model.ModelListener

Model の変更内容を監視するためのリスナーインタフェース

com.objectfanatics.samplecomponent.view パッケージ

com.objectfanatics.samplecomponent.view.View

Flash IDE 上で作成したシンボルからリンクされるクラス。
View として存在すると同時に、コンポーネント全体を構築する役割も持つ。

com.objectfanatics.samplecomponent.view.ModelListenerImpl

Model の変更を監視し、Model の変更内容に応じて View を更新するクラス。
ModelListenerインタフェースの実装クラス。

com.objectfanatics.samplecomponent.controller パッケージ

com.objectfanatics.samplecomponent.controller.Controller

View の内部要素に対してリスナーを登録し、イベントを監視する。
View からのイベントを処理し、必要に応じて Model を更新する。

クラスのソース

package com.objectfanatics.samplecomponent.model {
 
 public interface Model {
  
  /**
   * ModelListener をセットします。
   * @param modelListener ModelListener
   */
  function setModelListener(modelListener:ModelListener):void;
  
  /**
   * 値を返します。
   * @return 値
   */
  function getNumber():uint;
  
  /**
   * 値を1増やします。
   */
  function increment():void;
 }
}

package com.objectfanatics.samplecomponent.model {
 
 public class ModelImpl implements Model {
  
  private var modelListener:ModelListener;
  
  /**
   * 保持される値
   */
  private var number:uint = 0;
  
  /**
   * Model#getNumber():uint の実装
   */
  public function getNumber():uint {
   return number;
  }
  
  /**
   * Model#setModelListener(modelListener:ModelListener):void の実装
   */
  public function setModelListener(modelListener:ModelListener):void {
   this.modelListener = modelListener;
  }
  
  /**
   * Model#increment():void の実装
   */
  public function increment():void {
   this.modelListener.numberChanged(++number);
  }
 }
}

package com.objectfanatics.samplecomponent.model {
 
 /**
  * Model の変更内容を監視するためのリスナー
  */
 public interface ModelListener {
  
  /**
   * 値が変更された場合に呼び出されます。
   * @param number 現在の値
   */
  function numberChanged(number:uint);
 }
}

package com.objectfanatics.samplecomponent.view {
 
 import flash.display.Sprite;
 
 import com.objectfanatics.samplecomponent.model.Model;
 import com.objectfanatics.samplecomponent.model.ModelImpl;
 import com.objectfanatics.samplecomponent.model.ModelListener;
 import com.objectfanatics.samplecomponent.controller.Controller;
 
 /**
  * FlashIDE 上の LIBRARY にて、フォルダ名が com.objectfanatics.samplecomponent、名前が View のシンボルに対応するクラス。
  * View という名前ですが、FlashIDE上で作成したシンボルからのリンクとなっているため、コンポーネント全体の初期化も行っています。
  * 純粋な View としての処理は、 Model には依存しますが Controller には依存しません。
  */
 public class View extends Sprite {
  
  private const model:Model = new ModelImpl();
  
  public function View():void {
   initView();
   model.setModelListener(new ModelListenerImpl(this));
   new Controller(this, model);
  }
  
  private function initView():void {
   this.numberText.text = "" + model.getNumber();
  }
 }
}

package com.objectfanatics.samplecomponent.view {

 import com.objectfanatics.samplecomponent.model.ModelListener;
  
 /**
  * Model の変更内容を監視し View に反映させるための ModelListener の実装クラス。
  */
 public class ModelListenerImpl implements ModelListener {
  
  /**
   * 変更対象の View
   */
  private var view:View;
  
  /**
   * コンストラクタ
   * @param view 変更対象の View
   */
  public function ModelListenerImpl(view:View):void {
   this.view = view;
  }
  
  /**
   * Model の値が変更された時に呼び出され、View 上の表示を変更します。
   * @param currentNumber 現在のの Model の値
   */
  public function numberChanged(currentNumber:uint) {
   view.numberText.text = "" + currentNumber;
  }
 }
}

package com.objectfanatics.samplecomponent.controller {
 
 import flash.events.MouseEvent;
 
 import com.objectfanatics.samplecomponent.view.View;
 import com.objectfanatics.samplecomponent.model.Model;
 
 public class Controller { 
  
  private var model:Model;
  
  private var view:View;
  
  public function Controller(view:View, model:Model):void {
   
   // Model と View の格納
   this.model = model;
   this.view = view;
   
   // View のクリックの検出設定
   view.addEventListener(MouseEvent.CLICK, function():void{model.increment()});
  }
 }
}

今回の所感

単純な仕様のコンポーネントであれば、この方法でも十分な保守性が得られるのではないかと思いました。しかし、複雑になるとどうなるか全く見当も付きません。実際に複雑なケースに適用してみて実際に問題が生じたときに、その問題をシンプルに表現できる例題を作成して考察してみようと思います。

全体的な仕組みとして再利用が効きそうなポイントが多々あるのですが、ことごとくうまくいきませんでした。たとえば、Viewクラスの内部は Template Method を適用すればコード量抑えられるしロジックを完全に隠蔽できるので保守性が上がりそうなものです。しかし、abstract class が使えないために Template Method のメリットがかなり小さくなってしまいます。通常のクラスで Template Method を試してもみたのですが、Generics が使えないために手動での強引な型変換が必要となり、ソースがかなり長く見辛くなってしまいました。

まだ as3 を触り始めてまもないので、当面は粛々と実験していきたいと思います。

アーカイブ

カナダネタ：ホテル予約編

2010-07-30T09:03:00.005+09:00

突然ですが、業務として8月から半年ほどバンクーバー（カナダ）に行くことになりました。

ということで以下、ホテルの予約メモ。
なにげに結構大変でしたｗ

まず、安い宿がほとんどありません。数年前シリコンバレーにいた時は、ダウンタウンの交通の便がよいところでさえシングルルーム（風呂、トイレ、朝食、電話、高速インターネット回線付き）で$1,050/month、ダブルでも$1,200/month程度で借りられました。飛び込みでも普通のシングルルームで45$あれば借りることができました。月極のフラットを１室借りる場合は、$1,000/month前後でした（電話回線の契約とか自分でする必要がありますが）。しかし、バンクーバーではそうはいかないようです。

ホテルを物色してみた

Shaughnessy Village Vancouver

かなり安い宿です。8月は最高値なのですが、それでも$1045/momth。安いです。よさそうなので、メールでいくつか質問してみました。すると、3ヶ月で$915/month, 6ヶ月で$885/monthとのこと。さらに安い！しかし、途中でのキャンセルについては支払った金額が全く払い戻されないということでした。個人的に、過去にこのような厳しい払い戻しルールの長期滞在用ホテルは経験したことも聞いたこともなく、メールが英文メールとしてもあまりにもぶっきらぼうであり、また、いくつかの質問をさらっと無視されてしまったので、念のため、評判をググッてみました。う～む。賛否両論ですが、事前に長期予約をするにはリスクが大きそうな感じですね。

YWCA of Vancouver

口コミの評価がかなり高いです。Single (1 single bed) with semi- private bath*, TV の weekly rate が $74/night ということで、かなりリーズナブル。semi- private bath* は、2部屋で共有とのこと。"We also offer residence rate if you stay for a minimum of 30 days"とのことで、もっと長く止まるなら、もう少し安くなりそうです。

The Kingston Hotel

シャワールームが共有で、シングルルームが $75 - $125 plus tax とのこと。8月はハイシーズンなので、125$/nightになりそうですね。monthlyのrateも乗っていないので、今回は見送り。

結局・・・

結局、とりあえずYWCAを1ヶ月だけおさえることにして、その間に家具付きのフラットを借りる方向で進めてみることにしました。その際、もし途中キャンセルが可能なら６ヶ月間の予約を入れるという選択肢も残しておきます。

ということで、availability と monthly rate の確認と、6ヶ月の予約を入れるが途中キャンセルする可能性があるという状況でよい案がないかなという質問をメールで確認したところ、非常に丁寧な回答メールを頂きました。以下要約。

30日以上連続して宿泊する場合は、月単位のResidence形式を選択することが可能。その際、ホテルスタッフからの承認が必要になる（Residenceの情報）。しかし、８月はハイシーズンなので daily のレートのみ。
長期滞在で部屋を出る日付が未定の場合は、ひとまず長期の予約をしておいて、部屋を出る１ヶ月前に話せばよい。
全館禁煙。
無線LANはロビーと各部屋で利用可能。価格は $6.00/day, $22.00/week, or $33.00/month。

weekly rate も residence rate も適用できないのは残念ですが、とりあえず8末まではここを押さえようとしたところ、シングルが空いてませんでした(´・ω・`)

となると、ダブルになるので１日 $98.00 です。う～む、高いな。シャワー共有でこの値段は割に合わないなぁ、、、。しかし、今後ここに residence rate で宿泊する可能性も考えると、事前調査という意味ではアリか、、、、。このシーズンはどこも満室だし、中級ホテルでも$200/day弱するし、、、。

ということで、到着日の8日から、某お祭りが終わって落ち着く頃ということで18日まで10夜分だけ予約を取ることにしました。（そして、PDF付きの確認メールがスパムフィルタにかかるのはお約束ｗ）

就業規則の届出をしていない場合の旅費規程について

2010-07-28T15:34:00.003+09:00

弊社は現在常時10人以上の労働者を使用していないため、労働基準監督署に就業規則を届けていません。そのため、旅費規程などについても届出をしていません。その場合、旅費規程により経費として扱われることが妥当な場合でも、所得税が課税される可能性がありうるのではという疑問があります。

ということで、労働基準監督署に聞いてみました。

労働基準監督署曰く

旅費規定等を単独で届け出ることはできず、就業規則を含めて提出する必要がある。
税金については関知しない。
今回の件では特に届けでの必要はない。

とのこと。今度は税務署に聞いてみました。

税務署曰く

労働基準監督署に届けるかどうかは関係ない。
調査が必要な場合などに、該当する書類を見せられるようにしておけばよい。
書類の内容の妥当性は、地域性その他を含めた全体的な視点で判断される。

とのことでした。

妥当な規則を事前に用意していれば、特に問題なさそうです。

Utils.as

2010-06-07T12:59:00.002+09:00

package {
    import flash.filesystem.File;
    import flash.filesystem.FileMode;
    import flash.filesystem.FileStream;
    
    /**
     * とりあえず、静的な便利メソッドを入れ込んでおくクラス。
     * 
     * TODO: Air 以外の開発をする際に、Air 専用とそれ以外を分離しましょう。
     * 
     * 方針
     *         ・ActionScriptはオーバーロードができないので、メソッド名に引数情報もいれる。
     *         ・見かけの簡潔さを求めず、分かりやすさを求める。初めて見る人でもシグニチャだけで機能を確実に理解できることを目指す。
     *         ・管理しきれなくなって『具体的に困る』ことになったら別ライブラリへの分割を考える。
     */
    public class Utils {
        
        /**
         * 指定された XML ファイルを読み込み XML オブジェクトを返します。
         */
        public static function readXmlFromFile(xmlFile:File):XML {
            return new XML(readUTFBytesFromFile(xmlFile));
        }
        
        /**
         * 指定されたファイルを読み込み UTFBytes を返します。
         */
        public static function readUTFBytesFromFile(utfFile:File):String {
            var fileStream:FileStream = new FileStream();
            fileStream.open(utfFile, FileMode.READ);
            var utfBytes:String = fileStream.readUTFBytes(utfFile.size);
            fileStream.close();
            return utfBytes;
        }
        
        /**
         * 指定されたファイルに対して指定された XML を書き込みます。
         */
        public static function writeXmlToFile(xml:XML, file:File):void {
            writeUTFBytesToFile(xml.toXMLString(), file);
        }
        
        /**
         * 指定されたファイルに対して UTFBytes を書き込みます。
         */
        public static function writeUTFBytesToFile(utfBytes:String, file:File):void {
            var fileStream:FileStream = new FileStream();
            fileStream.open(file, FileMode.WRITE);
            fileStream.writeUTFBytes(utfBytes);
            fileStream.close();
        }
        
        /**
         * 指定されたファイルをファイルシステム中に作成します。既に指定されたファイルが存在する場合には何もしません。
         */
        public static function createFile(file:File):void {
            if (!file.exists) {
                var fileStream:FileStream = new FileStream();
                fileStream.open(file, FileMode.WRITE);
                fileStream.close();
            }
        }
    }
}

FlashのUI系コンポーネント調査

2010-06-02T20:33:00.000+09:00

FlashのUI系のコンポーネントについて全く知識がないので、少し調査してみました。

クラス階層

Object
・言うまでもなく、あらゆるクラスのベースとなるクラス。特にUIであるかどうかとは無関係。
・パッケージはトップレベル。

flash.events.EventDispatcher
・flash.events.IEventDispatcher の実装クラス。
・イベントを扱うための汎用的な機能を持つクラス。リスナーの追加削除とかイベントの送信とか。
・特にUIであるかどうかとは無関係。

flash.display.DisplayObject
・display list に配置されるすべてのオブジェクトのベースクラス。
・x,y,zとかalphaとかwidthとかvisibleとかマウス位置とか、表示されるものとしての基本機能を持っている。

flash.display.InteractiveObject
・表示されるオブジェクトでマウスやキーボードやその他の入力デバイスを扱うものすべての抽象クラス。
・このクラスはnewできないし、上記までのクラスもUIを作成するうえでプログラマが明示的に new することはなさそうです。

flash.display.DisplayObjectContainer
・display object の入れ物クラス。
・z 軸上に複数の display object を child として配置できる。
・このサブクラスには Loader, Sprite, Stage, TextLine があります。

flash.display.Loader
・java の ClassLoader のようなものを想像していると DisplayObjectContainer のサブクラスということに違和感を感じるが、実際は swf ファイルおよび画像ファイルをロードして表示するものなので、表示オブジェクトのローダーと言える。
・flex 用のサブクラスとして mx.core.FlexLoader があり、toString() メソッドが DisplayObjects の階層を表すようになっている。

flash.text.engine.TextLine
・display text 上に文字列を表示するためのオブジェクト。
・final クラスなので継承できないし、ユーザが直接 new することもできない。
・flash.text.engine 系のパッケージと関わらない限りは必要なさそう。

flash.display.Stage
・ブラウザ内なら flash の表示領域が Stage で、Airなら各 NativeWindow が Stage を持つ。

flash.display.Sprite
・UI 系の一般的なベースクラスで、MovieClip からtimelineを抜いたようなもの。

開発環境メモ

2010-05-23T09:23:00.002+09:00

WindowsXP環境開発環境メモ

GAE, git, svn, maven を前提とした環境。
今のところ、GAE系やGITの環境の試行錯誤中。

TODO: とりあえずメモなので、あとでちゃんと書きましょう。

7zip

http://www.7-zip.org/ からダウンロードしてすべてデフォルトでインストール。
以降、アーカイブの展開は7zipを使います。(Windows付属のはどうもバギーなので)

ブラウザのインストール
各種ブラウザの動作確認を行うため、複数のブラウザをインストールする。

Firefoxのインストール

http://mozilla.jp/firefox/ から最新版をダウンロードしてすべてデフォルト設定でインストールする。

Google Chrome のインストール

http://www.google.co.jp/chrome/ から最新版をダウンロードしてすべてデフォルト設定でインストールする。

Java

http://java.sun.com/ から Java SE の最新版をダウンロードして、すべてデフォルト設定でインストールする。
環境変数 JAVA_HOME を適切に設定する。（C:\Program Files\Java\jdk1.6.0_20 等）
環境変数 PATH に %JAVA_HOME%\bin を設定する。

maven

http://maven.apache.org/ から安定版の最新のバイナリをダウンロード。(ex. apache-maven-2.2.1-bin.zip)
C:\Program Files 直下にコピー。(ex. C:\Program Files\apache-maven-2.2.1)
環境変数 MAVEN_HOME を設定。
環境変数 Path に %MAVEN_HOME%\bin を追加。

Eclipse

http://www.eclipse.org/downloads/ から Eclipse IDE for Java EE Developers の galileo の最新版をダウンロード。
C:\Program Files\eclipse として展開する。
文字コードの設定

Window -> Preferences -> General -> Workspace -> Text file encoding を utf-8 に設定。

xmlのwidthを999、インデントをスペース2つに変更する。
eclipseにjdkのソースをアタッチ

Window -> Preferences... -> Java -> Installed JREs に移動。
jre を選択して、Edit... ボタンを押下。
C:\tmp\devenv\jdk\jre\lib\rt.jar を選択。
Source Attachement... ボタンを押下。
C:/Program Files/Java/jdk1.6.0_20/src.zip をアタッチ。

eclipseにJavaDocをアタッチ

Sunのサイトからドキュメントをダウンロードして、src.zipと同じフォルダに置く。
Window -> Preferences... -> Java -> Installed JREs に移動。
jre を選択して、Edit... ボタンを押
C:\tmp\devenv\eclipse\jre\lib\rt.jar を選択。
JavaDoc Location... ボタンを押下。
Javadoc in archive と Workspace file を選択。
Archive path を設定先ほどダウンロードしたドキュメントのzipに設定。
Path within archive を設定。（ex. docs/api）
ソース上の対象を選択してShift+F2キーを押せば、システム設定のブラウザ経由でJavaDocが起動します。

m2eclipseの設定

アップデートサイト http://m2eclipse.sonatype.org/sites/m2e からインストールする。
[Window] -> [Preferences...] -> [Maven] にて、以下のオプションをチェック。

Download Artifact Sources
Download Artifact JavaDoc

デフォルトのmavenが3.0系のSNAPSHOT版の場合は、[Window] -> [Preferences...] -> [Maven] -> [Installations] -> [Add] から Program Files 以下にインストールした maven を指定する。

Google 関連プラグインの設定

http://dl.google.com/eclipse/plugin/3.5
Google plugin と Google App Engine を選択してインストール。

subclipse プラグインの設定

アップデートサイト http://subclipse.tigris.org/update_1.6.x からインストールする。その際、オプショナルコンポーネントはすべて無視する。
SVN インタフェースを SVNKit (Pure Java) に設定する。

[Window] -> [Preferences...] -> [Team] -> [SVN] -> [SVNインタフェース] -> [SVNKit (Pure Java)]

EGit プラグインの設定。

アップデートサイト http://download.eclipse.org/egit/updates からインストールする。

Flex のコンポーネント遅延ロードとデータバインディングとモデリングに関する考察

2010-05-11T02:07:00.006+09:00

Flexではコンポーネントの遅延ローディングがデフォルトで行われるようになっています。そのため、mxml ファイル内で定義されたコンポーネントに対して同一の mxml ファイル内の ActionScript からアクセスしても、null が返る可能性があります。

そのような場合、内部コンポーネントを定義するXML要素の属性として、ActionScript 内の変数をバインディングするというワークアラウンドで乗り切ることができます。しかし、データバインディングをする場合、モデルが既にあったとしても、バインディング用の変数をわざわざ用意する必要があります。モデルの中で配列で100要素バインディングするとしたら、100種類の変数を用意する必要があります。

これも、ArrayCollection 型を使用することで解決できますが、既に Vector でデータを持っているモデルがあるとしたら、毎回移し変えなければなりません。

このように、ワークアラウンドで乗り切ることもできますが、あまり建設的ではないように思えます。まだまだ落とし穴があるように思えますし、、、。

ということで、今後の作業効率や成果物の品質にも大きく影響すると考えられるので、この機会に確認しておこうと思います。

例１：ある state で生成された情報を、これから初めて遷移される state に表示する場合。

ソース

Ex1.mxml

思惑

State 1 が初期状態。
State 1 上の入力フォームから結果表示用ラベルに A と B の値を入力し、add ボタンを押下する。
State 2 に遷移し、A + B の結果が表示される。

結果

State 2 で表示される結果表示用ラベルの値が null となり、エラーが発生。

考察

creationPolicy を all にすることにより遅延ロードを抑制できないか？
ドキュメントによると、単一ビューコンテナでは、auto でも all でも同じ動作となり、『デフォルトでは、アプリケーションが最初に起動されたときに単一ビューコンテナのすべての子が生成されます。』となるらしい。生成されてるのに null なのはなぜ？ (´・ω・`)
State が絡む場合はダメらしい。結局、State の遷移を先に行うしかないらしい。

解決法

ある State に含まれるコンポーネントへのアクセスは、その State に遷移してから行う。

解決後のソース

ソース：Ex1_1.mxml

例２：複雑なモデル内部のデータを参照する場合。

バインディング版

ソース：Ex2.mxml
特に問題なく動作する。

例３：配列へバインディングしようとして失敗する版

ソース：Ex2_1.mxml
最初の１回目はうまく行くが、２回目以降も最初の結果が出続ける。

例４：ArrayCollection を用いて対応する版

ソース：Ex2_2.mxml
問題なく動作するが、バインディングのために設計を崩すことになった。バインディングするよりも、特定のタイミングでデータをリロードしてくれるような設計の方がありがたいのだが。例えば状態遷移のタイミングとか。

例５：ボタンクリックのタイミングでデータを格納する版

ソース：Ex2_3.mxml
サブコンポーネントに対する text の指定を、親コンポーネント側で決定することが自然な設計であれば、無理にバインディングする必要はない。そのため、クリックのハンドラでラベルの表示を行っている。

例６：Stateに入るタイミングでデータを格納する版

ソース：Ex2_4.mxml
サブコンポーネントに対する text の指定を、親コンポーネント側で決定することが自然な設計であれば、無理にバインディングする必要はない。状態遷移をする箇所が一箇所であればその場所にラベルにデータを書き込む処理を埋め込めば良いのだが、ソースの様々な箇所から状態遷移が発生する場合には同様の処理を複数回記述することになる。その際、状態遷移をトリガーにした方がシンプルになる場合は、State に入るイベントを用いた方がよい。

付録：ソース

Ex1.mxml

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
      xmlns:s="library://ns.adobe.com/flex/spark" 
      xmlns:mx="library://ns.adobe.com/flex/mx" width="100%" height="100%">
 <s:layout>
  <s:VerticalLayout horizontalAlign="center" verticalAlign="middle"/>
 </s:layout>

 <fx:Script>
  <![CDATA[
   import mx.controls.Alert;
   <!--- A + B の計算をして resultLabel に値を設定し、State2 に遷移するメソッド -->
   private function addButton_clickHandler(event:MouseEvent):void {
    var a:String = aNs.value.toString();
    var b:String = bNs.value.toString();
    var result:String = (aNs.value + bNs.value).toString();
    Alert.show("resultLabel = " + resultLabel); // ここで、resultLabel が null になる。
    resultLabel.text = a + " + " + b + " = " + result;
    currentState = "State2";
   }
  ]]>
 </fx:Script>

 <!-- state を用いて画面遷移を模倣 -->
 <s:states>
  <!-- A と B の値を入力する画面 -->
  <s:State name="State1"/>
  <!-- A + B の結果を表示する画面 -->
  <s:State name="State2"/>
 </s:states>
 
 <!-- State1用コンポーネント群 -->
 <mx:Form includeIn="State1">
  <mx:FormItem label="A">
   <!--- A の値入力用 NumericStepper -->
   <s:NumericStepper id="aNs"/>
  </mx:FormItem>
  <mx:FormItem label="B">
   <!--- B の値入力用 NumericStepper -->
   <s:NumericStepper id="bNs"/>
  </mx:FormItem>
 </mx:Form>
 <s:Button includeIn="State1" label="add" id="addButton" click="addButton_clickHandler(event)"/>
 
 <!-- State2用コンポーネント群 -->
 <!--- A + B = (A+Bの結果) という文字列を表示するためのラベル -->
 <s:Label id="resultLabel" includeIn="State2"/>
 
</s:Application>

Ex1_1.mxml

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
      xmlns:s="library://ns.adobe.com/flex/spark" 
      xmlns:mx="library://ns.adobe.com/flex/mx" width="100%" height="100%">
 <s:layout>
  <s:VerticalLayout horizontalAlign="center" verticalAlign="middle"/>
 </s:layout>

 <fx:Script>
  <![CDATA[
   import mx.controls.Alert;
   <!--- A + B の計算をして resultLabel に値を設定し、State2 に遷移するメソッド -->
   private function addButton_clickHandler(event:MouseEvent):void {
    var a:String = aNs.value.toString();
    var b:String = bNs.value.toString();
    var result:String = (aNs.value + bNs.value).toString();
    currentState = "State2";
    Alert.show("resultLabel = " + resultLabel); // ここで、resultLabel が null ではなく、きちんと表示される。
    resultLabel.text = a + " + " + b + " = " + result;
   }
  ]]>
 </fx:Script>

 <!-- state を用いて画面遷移を模倣 -->
 <s:states>
  <!-- A と B の値を入力する画面 -->
  <s:State name="State1"/>
  <!-- A + B の結果を表示する画面 -->
  <s:State name="State2"/>
 </s:states>
 
 <!-- State1用コンポーネント群 -->
 <mx:Form includeIn="State1">
  <mx:FormItem label="A">
   <!--- A の値入力用 NumericStepper -->
   <s:NumericStepper id="aNs"/>
  </mx:FormItem>
  <mx:FormItem label="B">
   <!--- B の値入力用 NumericStepper -->
   <s:NumericStepper id="bNs"/>
  </mx:FormItem>
 </mx:Form>
 <s:Button includeIn="State1" label="add" id="addButton" click="addButton_clickHandler(event)"/>
 
 <!-- State2用コンポーネント群 -->
 <!--- A + B = (A+Bの結果) という文字列を表示するためのラベル -->
 <s:Label id="resultLabel" includeIn="State2"/>
 
</s:Application>

Ex2.mxml

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
      xmlns:s="library://ns.adobe.com/flex/spark" 
      xmlns:mx="library://ns.adobe.com/flex/mx" width="100%" height="100%">
 <s:layout>
  <s:VerticalLayout horizontalAlign="center" verticalAlign="middle"/>
 </s:layout>

 <fx:Script>
  <![CDATA[
   import mx.controls.Alert;
   <!--- A + B の計算をして resultLabel に値を設定し、State2 に遷移するメソッド -->
   private function addButton_clickHandler(event:MouseEvent):void {
    currentState = "State2";
   }

   <!--- State2 から State1 に戻るボタン -->
   private function backButton_clickHandler(event:MouseEvent):void {
    currentState = "State1";
   }

  ]]>
 </fx:Script>

 <!-- state を用いて画面遷移を模倣 -->
 <s:states>
  <!-- A と B の値を入力する画面 -->
  <s:State name="State1"/>
  <!-- A + B の結果を表示する画面 -->
  <s:State name="State2"/>
 </s:states>
 
 <!-- State1用コンポーネント群 -->
 <mx:Form includeIn="State1">
  <mx:FormItem label="Value 1">
   <!--- 値1 の値入力用 NumericStepper -->
   <s:NumericStepper id="v1Ns"/>
  </mx:FormItem>
  <mx:FormItem label="Value 2">
   <!--- 値2 の値入力用 NumericStepper -->
   <s:NumericStepper id="v2Ns"/>
  </mx:FormItem>
  <mx:FormItem label="Value 3">
   <!--- 値3 の値入力用 NumericStepper -->
   <s:NumericStepper id="v3Ns"/>
  </mx:FormItem>
 </mx:Form>
 <s:Button includeIn="State1" label="add" id="addButton" click="addButton_clickHandler(event)"/>
 
 <!-- State2用コンポーネント群 -->
 <!--- v1 + v2 + v3 = (v1+v2+v3の結果) という文字列を表示するためのラベル -->
 <s:Label id="resultLabel" includeIn="State2" text="{v1Ns.value} + {v2Ns.value} + {v3Ns.value} = {v1Ns.value + v2Ns.value + v3Ns.value}"/>
 <s:Button includeIn="State2" label="back" id="backButton" click="backButton_clickHandler(event)"/>
 
</s:Application>

Ex2_1.mxml

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
      xmlns:s="library://ns.adobe.com/flex/spark" 
      xmlns:mx="library://ns.adobe.com/flex/mx" width="100%" height="100%">
 <s:layout>
  <s:VerticalLayout horizontalAlign="center" verticalAlign="middle"/>
 </s:layout>

 <fx:Script>
  <![CDATA[
   import mx.controls.Alert;
   
   <!--- 値を保持する Vector -->
   private var values:Vector.<Number> = new Vector.<Number>();
   
   <!--- A + B の計算をして resultLabel に値を設定し、State2 に遷移するメソッド -->
   private function addButton_clickHandler(event:MouseEvent):void {
    // コンポーネントの値を values に格納。
    values.push(v1Ns.value);
    values.push(v2Ns.value);
    values.push(v3Ns.value);
    
    currentState = "State2";
   }

   <!--- State2 から State1 に戻るボタン -->
   private function backButton_clickHandler(event:MouseEvent):void {
    currentState = "State1";
   }

  ]]>
 </fx:Script>

 <!-- state を用いて画面遷移を模倣 -->
 <s:states>
  <!-- A と B の値を入力する画面 -->
  <s:State name="State1"/>
  <!-- A + B の結果を表示する画面 -->
  <s:State name="State2"/>
 </s:states>
 
 <!-- State1用コンポーネント群 -->
 <mx:Form includeIn="State1">
  <mx:FormItem label="Value 1">
   <!--- 値1 の値入力用 NumericStepper -->
   <s:NumericStepper id="v1Ns"/>
  </mx:FormItem>
  <mx:FormItem label="Value 2">
   <!--- 値2 の値入力用 NumericStepper -->
   <s:NumericStepper id="v2Ns"/>
  </mx:FormItem>
  <mx:FormItem label="Value 3">
   <!--- 値3 の値入力用 NumericStepper -->
   <s:NumericStepper id="v3Ns"/>
  </mx:FormItem>
 </mx:Form>
 <s:Button includeIn="State1" label="add" id="addButton" click="addButton_clickHandler(event)"/>
 
 <!-- State2用コンポーネント群 -->
 <!--- v1 + v2 + v3 = (v1+v2+v3の結果) という文字列を表示するためのラベル -->
 <s:Label id="resultLabel" includeIn="State2" text="{values[0]} + {values[1]} + {values[2]} = {values[0] + values[1] + values[2]}"/>
 <s:Button includeIn="State2" label="back" id="backButton" click="backButton_clickHandler(event)"/>
 
</s:Application>

Ex2_2.mxml

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
      xmlns:s="library://ns.adobe.com/flex/spark" 
      xmlns:mx="library://ns.adobe.com/flex/mx" width="100%" height="100%">
 <s:layout>
  <s:VerticalLayout horizontalAlign="center" verticalAlign="middle"/>
 </s:layout>

 <fx:Script>
  <![CDATA[
   import mx.collections.ArrayCollection;
   import mx.controls.Alert;
   
   [Bindable]
   /**
    * 値を保持する ArrayCollection
    */
   private var values:ArrayCollection = new ArrayCollection(new Array(3));
   
   /**
    * A + B の計算をして resultLabel に値を設定し、State2 に遷移するメソッド
    */
   private function addButton_clickHandler(event:MouseEvent):void {
    // コンポーネントの値を values に格納。
    values.setItemAt(v1Ns.value, 0);
    values.setItemAt(v2Ns.value, 1);
    values.setItemAt(v3Ns.value, 2);
    
    currentState = "State2";
   }

   <!--- State2 から State1 に戻るボタン -->
   private function backButton_clickHandler(event:MouseEvent):void {
    currentState = "State1";
   }

  ]]>
 </fx:Script>

 <!-- state を用いて画面遷移を模倣 -->
 <s:states>
  <!-- A と B の値を入力する画面 -->
  <s:State name="State1"/>
  <!-- A + B の結果を表示する画面 -->
  <s:State name="State2"/>
 </s:states>
 
 <!-- State1用コンポーネント群 -->
 <mx:Form includeIn="State1">
  <mx:FormItem label="Value 1">
   <!--- 値1 の値入力用 NumericStepper -->
   <s:NumericStepper id="v1Ns"/>
  </mx:FormItem>
  <mx:FormItem label="Value 2">
   <!--- 値2 の値入力用 NumericStepper -->
   <s:NumericStepper id="v2Ns"/>
  </mx:FormItem>
  <mx:FormItem label="Value 3">
   <!--- 値3 の値入力用 NumericStepper -->
   <s:NumericStepper id="v3Ns"/>
  </mx:FormItem>
 </mx:Form>
 <s:Button includeIn="State1" label="add" id="addButton" click="addButton_clickHandler(event)"/>
 
 <!-- State2用コンポーネント群 -->
 <!--- v1 + v2 + v3 = (v1+v2+v3の結果) という文字列を表示するためのラベル -->
 <s:Label id="resultLabel" includeIn="State2" text="{values.getItemAt(0)} + {values.getItemAt(1)} + {values.getItemAt(2)} = {values.getItemAt(0) + values.getItemAt(1) + values.getItemAt(2)}"/>
 <s:Button includeIn="State2" label="back" id="backButton" click="backButton_clickHandler(event)"/>
 
</s:Application>

Ex2_3.mxml

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
      xmlns:s="library://ns.adobe.com/flex/spark" 
      xmlns:mx="library://ns.adobe.com/flex/mx" width="100%" height="100%">
 <s:layout>
  <s:VerticalLayout horizontalAlign="center" verticalAlign="middle"/>
 </s:layout>

 <fx:Script>
  <![CDATA[
   import mx.controls.Alert;
   
   <!--- 値を保持する Vector -->
   private var values:Vector.<Number> = new Vector.<Number>();
   
   <!--- A + B の計算をして resultLabel に値を設定し、State2 に遷移するメソッド -->
   private function addButton_clickHandler(event:MouseEvent):void {
    // コンポーネントの値を values に格納。
    if (values.length == 0) {
     values.push(v1Ns.value);
     values.push(v2Ns.value);
     values.push(v3Ns.value);
    } else {
     values[0] = v1Ns.value;
     values[1] = v2Ns.value;
     values[2] = v3Ns.value;
    }
        
    currentState = "State2";
    
    // ラベルの値を直接指定する。
    resultLabel.text = values[0].toString() + ' + ' + values[1].toString() + ' + ' + values[2].toString() + ' = ' + (values[0] + values[1] + values[2]);

   }

   <!--- State2 から State1 に戻るボタン -->
   private function backButton_clickHandler(event:MouseEvent):void {
    currentState = "State1";
   }
  ]]>
 </fx:Script>

 <!-- state を用いて画面遷移を模倣 -->
 <s:states>
  <!-- A と B の値を入力する画面 -->
  <s:State name="State1"/>
  <!-- A + B の結果を表示する画面 -->
  <s:State name="State2"/>
 </s:states>
 
 <!-- State1用コンポーネント群 -->
 <mx:Form includeIn="State1">
  <mx:FormItem label="Value 1">
   <!--- 値1 の値入力用 NumericStepper -->
   <s:NumericStepper id="v1Ns"/>
  </mx:FormItem>
  <mx:FormItem label="Value 2">
   <!--- 値2 の値入力用 NumericStepper -->
   <s:NumericStepper id="v2Ns"/>
  </mx:FormItem>
  <mx:FormItem label="Value 3">
   <!--- 値3 の値入力用 NumericStepper -->
   <s:NumericStepper id="v3Ns"/>
  </mx:FormItem>
 </mx:Form>
 <s:Button includeIn="State1" label="add" id="addButton" click="addButton_clickHandler(event)"/>
 
 <!-- State2用コンポーネント群 -->
 <!--- v1 + v2 + v3 = (v1+v2+v3の結果) という文字列を表示するためのラベル -->
 <s:Label id="resultLabel" includeIn="State2"/>
 <s:Button includeIn="State2" label="back" id="backButton" click="backButton_clickHandler(event)"/>
 
</s:Application>

Ex2_4.mxml

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
      xmlns:s="library://ns.adobe.com/flex/spark" 
      xmlns:mx="library://ns.adobe.com/flex/mx" width="100%" height="100%">
 <s:layout>
  <s:VerticalLayout horizontalAlign="center" verticalAlign="middle"/>
 </s:layout>

 <fx:Script>
  <![CDATA[
   import mx.controls.Alert;
   
   <!--- 値を保持する Vector -->
   private var values:Vector.<Number> = new Vector.<Number>();
   
   <!--- A + B の計算をして resultLabel に値を設定し、State2 に遷移するメソッド -->
   private function addButton_clickHandler(event:MouseEvent):void {
    // コンポーネントの値を values に格納。
    if (values.length == 0) {
     values.push(v1Ns.value);
     values.push(v2Ns.value);
     values.push(v3Ns.value);
    } else {
     values[0] = v1Ns.value;
     values[1] = v2Ns.value;
     values[2] = v3Ns.value;
    }
        
    currentState = "State2";
   }

   <!--- State2 から State1 に戻るボタン -->
   private function backButton_clickHandler(event:MouseEvent):void {
    currentState = "State1";
   }
  ]]>
 </fx:Script>

 <!-- state を用いて画面遷移を模倣 -->
 <s:states>
  <!-- A と B の値を入力する画面 -->
  <s:State name="State1"/>
  <!-- A + B の結果を表示する画面 -->
  <s:State name="State2" enterState="resultLabel.text = values[0].toString() + ' + ' + values[1].toString() + ' + ' + values[2].toString() + ' = ' + (values[0] + values[1] + values[2])"/>
 </s:states>
 
 <!-- State1用コンポーネント群 -->
 <mx:Form includeIn="State1">
  <mx:FormItem label="Value 1">
   <!--- 値1 の値入力用 NumericStepper -->
   <s:NumericStepper id="v1Ns"/>
  </mx:FormItem>
  <mx:FormItem label="Value 2">
   <!--- 値2 の値入力用 NumericStepper -->
   <s:NumericStepper id="v2Ns"/>
  </mx:FormItem>
  <mx:FormItem label="Value 3">
   <!--- 値3 の値入力用 NumericStepper -->
   <s:NumericStepper id="v3Ns"/>
  </mx:FormItem>
 </mx:Form>
 <s:Button includeIn="State1" label="add" id="addButton" click="addButton_clickHandler(event)"/>
 
 <!-- State2用コンポーネント群 -->
 <!--- v1 + v2 + v3 = (v1+v2+v3の結果) という文字列を表示するためのラベル -->
 <s:Label id="resultLabel" includeIn="State2"/>
 <s:Button includeIn="State2" label="back" id="backButton" click="backButton_clickHandler(event)"/>
 
</s:Application>

flex で creationComplete 時に stage == null になる問題。

2010-05-06T19:23:00.004+09:00

ドキュメントによると、少なくとも activate されている間は stage が生きているらしいです。

そのため、Event.ACTIVATE と Event.RESIZE イベント内なら確実に stage を扱えそうです。

GIMPを使い始めてみようと思ったり思わなかったり。

2010-05-02T19:37:00.001+09:00

以下、GIMPを使おうと思い立ってから以降のメモ書き。

今は何でも屋としてサイト開発をしているので、グラフィック系のチームに画像やレイアウトの注文を任せるようなことができない今日この頃。

グラフィックもやらにゃいかんだろうと思い、どうしたものかと思案中。

PhotoShop をいきなり購入しても、3日で飽きたとかしゃれにならんし。

ということで、GIMPに挑戦してみる。

公式ページ

http://www.gimp.org/

Windows版ダウンロードページ

http://www.gimp.org/windows/

ダウンロード＆インストール

アプリとマニュアルの両方をダウンロードして実行。本体は国際化されているので、何語版というのはありません。

作業メモ：BlazeDS + Flex 環境の Enum ルール

2010-04-22T11:52:00.003+09:00

今回は、BlazeDS + Flex 環境で Enum をどのように扱うかについて考察してみます。

基本事項

基本的な設定やその他基本事項については、以下に準じます。

ActionScript 側の enum 名格納変数について

ActionScript 側の enum 名格納変数を name とします。AMFで通信される情報も java の Enum#name() に準じたものにします。そのため、以下のような独自のEnumProxyを定義します。

package com.objectfanatics.flex.messaging.io;

import java.util.Collections;
import java.util.List;

import flex.messaging.io.AbstractProxy;
import flex.messaging.io.BeanProxy;

public class EnumProxy extends BeanProxy {

    private static final String ACTION_SCRIPT_ENUM_NAME_PROPERTY_NAME = "name";
    private static final List<String> propertyNames = Collections.singletonList(ACTION_SCRIPT_ENUM_NAME_PROPERTY_NAME);

    @SuppressWarnings("unchecked")
    public Object createInstance(String className) {
        return new EnumStub((Class<Enum>) AbstractProxy.getClassFromClassName(className));
    }

    public Object getValue(Object instance, String propertyName) {
        if (propertyName.equals(ACTION_SCRIPT_ENUM_NAME_PROPERTY_NAME)) {
            return Enum.class.cast(instance).name();
        } else {
            throw new IllegalArgumentException("No property named: " + propertyName + " on enum type");
        }
    }

    public void setValue(Object instance, String propertyName, Object value) {
        if (propertyName.equals(ACTION_SCRIPT_ENUM_NAME_PROPERTY_NAME)) {
            EnumStub.class.cast(instance).value = String.class.cast(value);
        } else {
            throw new IllegalArgumentException("no EnumStub property: " + propertyName);
        }
    }

    @SuppressWarnings("unchecked")
    public Object instanceComplete(Object instance) {
        EnumStub es = EnumStub.class.cast(instance);
        return Enum.valueOf((Class) es.cl, es.value);
    }

    @SuppressWarnings("unchecked")
    public List getPropertyNames(Object instance) {
        if (!(instance instanceof Enum)) {
            throw new IllegalArgumentException("getPropertyNames called with non Enum object");
        } else {
            return propertyNames;
        }
    }

    private class EnumStub {
        private Class<?> cl;
        private String value;
        private EnumStub(Class<?> c) {
            cl = c;
        }
    }
}

同時に HttpFlexSession の static ブロックで以下のように定義し、あらゆる Enum 型に対して EnumProxy が適用されるようにします。

// patch for enum serialization
  static {
      PropertyProxyRegistry.getRegistry().register(Enum.class, new EnumProxy());
  }

ActionScript 側の enum ルール

ActionScript 側の enum は、以下のような形式で作成します。

// Sample enum class.
package com.objectfanatics.englishfanatics.dataobject {
    import com.objectfanatics.flex.EnumBase;
    
    // fqcn of java counterpart enum class
    [RemoteClass(alias="com.objectfanatics.sample.SampleEnum")]
    
    // class name should be the same as the name of the java counterpart enum class.
    public class SampleEnum extends EnumBase {
        
        // enums
        //  - const name and the value of the first parameter of the constructor should be the same.
        public static const KUMA_SAN:SampleEnum = new SampleEnum("KUMA_SAN", "くまさん");
        public static const TANUKI_SAN:SampleEnum = new SampleEnum("TANUKI_SAN", "たぬきさん");
        
        // constructor
        //  - default parameter values are required for deserialized enums.
        //  - this must be invoked only for enum constant creation in this class and deserialized enum creation.
        public function SampleEnum(name:String = null, string:String = null) {
            super(name, string);
        }
        
        // returns all enum constants in this class.
        //  - this method is workaround for ActionScript3.0's limitation. 
        //    static methods are not inherited and cannot be overridden in ActionScript 3.0.
        public static function values():Array {
            return superValues();
        }
    }
}

すべての enum は下記のベースクラスを継承します。

package com.objectfanatics.flex {
    import flash.utils.getDefinitionByName;
    import flash.utils.getQualifiedClassName;
    
    /**
     * Base class of enum object.
     */
    public class EnumBase {
        // key = enum class name, value = enum array.
        private static const valuesMap:Object = new Object();
        
        // enum class name
        private var enumClassName:String;
        
        // enum name
        public var name:String;
        
        // string for presentation
        protected var string:String;
        
        public function EnumBase(name:String = null, string:String = null) {
            this.name = name;
            this.string = string;
            enumClassName = getQualifiedClassName(this);
            if (string != null) {
                // for normal enum
                var values:Array = valuesMap[enumClassName];
                if (values == null) values = new Array();
                valuesMap[enumClassName] = values;
                values.push(this);
            } else {
                // for deserialized enum
                return;
            }
        }
        
        // This method name is weird because of ActionScript 3.0's limitation.
        //   - Static methods are not inherited and cannot be overridden in ActionScript 3.0.
        public static function superValues():Array {
            // TODO: check.
            var blocks:Array = new Error().getStackTrace().split("at ");
            var block:String = blocks[2];
            var startIndex:int = block.indexOf("at ");// start of first line
            var endIndex:int = block.indexOf("$");    // end of class name
            var enumClassName:String = block.substring(startIndex + 1, endIndex);
            return valuesMap[enumClassName];
        }
        
        public function toString():String {
            if (string == null) {
                var enumClass:Class = getDefinitionByName(enumClassName) as Class;
                this.string = enumClass[name].string;
            }
            return string;
        }
        
        //use equality instead of identity.
        public function equals(other:EnumBase):Boolean {
            return this.name == other.name;
        }
    }
}

java 側の enum ルール

Java 側の enum は、ActionScript 側の name プロパティと Java 側の Enum#name() の値が対応していれば、どのような形でもかまいません。

以下例。

package com.objectfanatics.sample;

public enum SampleEnum {
    KUMA_SAN, TANUKI_SAN;
}

(´・ω・`) まだまともにに使ってないから、落とし穴がいっぱいありそうな気がする今日この頃。

作業メモ：FlexのRemotingでjavaからにActionScript型をマッピングする方法

2010-04-21T16:23:00.006+09:00

前回は、Flex の Remoting で ActionScript から java に型をマッピングする方法について、実際に動作を確認しながら考えてみました。

今回は、その逆の方向ということで、java から ActionScript に型をマッピングする方法について、実際に動作を確認しながら考えてみます。

基本的な事項は作業メモ：FlexのRemotingでActionScriptからjavaに型をマッピングする方法参照のこと。

Private Fields in Java to Public Fields in ActionScript

基本的に動くようです。

以下、JavaBeans規約を勘違いしてやらかした例。(´・ω・`)

前回 services-config.xml ファイルのチャネルの serialization の設定として include-read-only オプションを追加したのですが、うまく動作しないようです。

シリアライズ対象の Java のクラスは以下のフィールドを持っていて、すべてのフィールドは getter を持っています。

private long id;
private String eText;
private PartOfSpeech partOfSpeech;
private String jText;

仕様どおりなら、public な getter があるので正しく動作するはずです。実装的にも Bean の introspection を利用し判断しているのであれば、問題なく動作するはずなのですが、、、。

しかも、気持ち悪いことに、id だけは正しく伝わっていました。

試しに Java 側の private フィールドを public に変更してみたところ、ActionScript 側にデータが正しく伝わりました。

ということで、原因を調査してみることにしました。

結論。JavaBeans規約的に、おいらが間違ってました。
(´・ω・`) 先頭の２文字が大文字の場合、プロパティ名の先頭は小文字に変換されないのです。

JavaBeans API specification(1.01) の 8.8 Capitalization of inferred names にかかれています。
すっかり忘れてました。Sun出身なのにｗ

Enums in Java to Enum Like Objects in ActionScript

(´・ω・`) TypeError: Error #1034: 強制型変換に失敗しました。

おいらはいままでのところ、作業ログ：BlazeDSのRemotingServiceでJavaのenumを扱う方法で書いたような方法で Enum を扱っていました。そのため、Java 側から String として渡ってくる情報を ActionScript 上で Enum 的オブジェクトに変換しなければなりません。しかし、FlashPlayer 側に手を入れるわけにも行きません。

少し調べてみると、BLZ-17 に java の Enum と AS3 のクラスのマッピングができるようになっているという話を発見。

そちらに書かれている方法どおりにやってみたところ、問題なく動作しました。

初期化用の static ブロックは、web.xml の先頭で listener として読み込まれているという理由で、flex.messaging.HttpFlexSession クラスの先頭に追加しました。以下、追加されたソースです。

// patch for enum serialization
    static {
            PropertyProxyRegistry.getRegistry().register(Enum.class, new EnumProxy());
    }

作業メモ：FlexのRemotingでActionScriptからjavaに型をマッピングする方法

2010-04-20T02:37:00.242+09:00

今回は、Flex の Remoting で ActionScript から java に型をマッピングする方法について、実際に動作を確認しながら考えてみます。

基本情報

基本的な情報は以下に書かれています。

ActionScriptからJavaへのデータマッピング規則
Converting data from ActionScript to Java
JavaとActionScriptのデータマッピングを明示的に指定する方法
Explicitly mapping ActionScript and Java objects
JavaからActionScriptへのデータマッピング規則
Converting data from Java to ActionScript

以下、各型についてマッピングの実験をしてみます。

ActonScript to Java : Boolean, String of "true" or "false" to java.lang.Boolean

Java side test code.

public boolean asToJavaBooleanTest(boolean asBooleanTrue, boolean asBooleanFalse, boolean stringTrue, boolean stringFalse) {
    return 
        (asBooleanTrue  == true ) && 
        (asBooleanFalse == false) &&
        (stringTrue     == true ) &&
        (stringFalse    == false);
}

Flex side test code.

public static function asToJavaBooleanTest():void {
    remoteObjectWrapper.invoke(true, false, "true", "false");
}

ActonScript to Java : flash.utils.ByteArray to byte []

Java side test code.

public boolean asToJavaByteArrayTest(byte[] bytes) {
    return 
        (bytes[0] == 0 ) && 
        (bytes[1] == 1 ) && 
        (bytes[2] == 2 );
}

Flex side test code.

public static function asToJavaByteArrayTest():void {
    var byteArray:ByteArray = new ByteArray();
    byteArray.writeByte(0);
    byteArray.writeByte(1);
    byteArray.writeByte(2);
    remoteObjectWrapper.invoke(byteArray);
}

ActonScript to Java : Date to java.util.Date

Java side test code.

public boolean asToJavaDateTest(Date date) {
    return date.getTime() == 1271699264375L;
}

Flex side test code.

public static function asToJavaDateTest():void {
    var date:Date = new Date();
    date.time = 1271699264375;
    remoteObjectWrapper.invoke(date);
}

ActonScript to Java : int/uint to java.lang.Integer

Java side test code.

public boolean asToJavaIntTest(int intValue, int uintValue1, int uintValue2) {
    return
        (intValue   == -1        ) &&
        (uintValue1 == 2147483647) && // rounded from 2147483648
        (uintValue2 == 2147483647);   // rounded from 2147483649
}

Flex side test code.

public static function asToJavaIntTest():void {
    var intValue:int = -1;
    // java: Integer.MAX_VALUE = 2147483647.
    var uintValue1:uint = 2147483648; // this will be rounded to 2147483647!
    var uintValue2:uint = 2147483649; // this will be rounded to 2147483647!
    remoteObjectWrapper.invoke(intValue, uintValue1, uintValue2);
}

このテストの結果から、以下のことが分かります。

ActionScript 側の uint は Integer.MAX_VALUE = 2147483647 よりも大きい値を扱うことができる。
Java 側は、Integer.MAX_VALUE より大きい値が渡されると Integer.MAX_VALUE に丸めてしまう。
このことから、Java との連携が決まっている場合、uint は使わないほうが無難のようです。

ActonScript to Java : Number to java.lang.Double

Java side test code.

public boolean asToJavaNumberTest(double numberValue) {
    return
        (numberValue == -1.5);
}

Flex side test code.

public static function asToJavaNumberTest():void {
    remoteObjectWrapper.invoke(new Number(-1.5));
}

ActonScript to Java : String to java.lang.String

Java side test code.

public boolean asToJavaStringTest(String stringValue1, String stringValue2, String stringValue3) {
    return
        (stringValue1.equals("")) &&
        (stringValue2.equals("foo")) &&
        (stringValue3 == null); 
}

Flex side test code.

public static function asToJavaStringTest():void {
    var stringValue1:String = "";
    var stringValue2:String = "foo";
    var undefinedValue:String;   // Note: undefined is converted to null.
    var nullValue:String = null; // Note: null is converted to null.
    remoteObjectWrapper.invoke(stringValue1, stringValue2, undefinedValue, nullValue);
}

ActionScript の undefined と null は、Java の null に変換されるようです。

ActonScript to Java : Object (generic) to java.util.Map

Java side test code.

public boolean asToJavaGenericObjectTest(Map<String,Object> nullValue, Map<String,Object> simpleObject, Map<String,Object> hasNullProperty, Map<String,Object> hasStringProperty, Map<String,Object> hasDateProperty, Map<String,Object> hasNestedProperty) {
    return
        (nullValue == null) &&
        (simpleObject != null) &&
        (hasNullProperty.get("property") == null) &&
        (hasStringProperty.get("property").equals("foo")) &&
        (Date.class.isInstance(hasDateProperty.get("property"))) &&
        (Date.class.isInstance(Map.class.cast(hasNestedProperty.get("property")).get("nestedProperty")));
}

Flex side test code.

public static function asToJavaGenericObjectTest():void {
    // null
    var nullValue:Object = null;
    
    // simple object
    var simpleObject:Object = new Object();
    
    // has null property
    var hasNullProperty:Object = new Object();
    hasNullProperty.property = null;
    
    // has String object
    var hasStringProperty:Object = new Object();
    hasStringProperty.property = "foo"
        
    // has Data object
    var hasDateProperty:Object = new Object();
    hasDateProperty.property = new Date();
    
    // has nested property
    var hasNestedProperty:Object = new Object();
    hasNestedProperty.property = new Object();
    hasNestedProperty.property.nestedProperty = new Date();
    
    remoteObjectWrapper.invoke(nullValue, simpleObject, hasNullProperty, hasStringProperty, hasDateProperty, hasNestedProperty);
}

ネストされても、特に問題なく動作するようです。

ActonScript to Java : typed Object to typed Object

private コンストラクタのみのJavaクラスを対象にしてみたところ、以下のように怒られてしまいました。

Unable to create a new instance of type 'experiment.SimpleObject'. 
Types must have a public, no arguments constructor.

ObjectFanatics 的方針としては、public のデフォルトコンストラクタの強制など容認できるはずもありません。
ということで、ソースにパッチを当てて対応しました。

引数無しの private コンストラクタが必要になってしまうのと、そのために final の変数の利用がほぼ絶望的になるという点がかなり厳しいのですが、とりあえずは妥協することにしましょう。将来的には、引数のある private コンストラクタに対応しようと思います。（TODO: 引数なしのプライベートコンストラクタを new してから値を格納する方法ではなく、private コンストラクタの引数にシリアライズされたオブジェクトを復元していく方法を実装する。）

お次は、java 側で private field に値を入れることを期待していたのですが、以下のように怒られてしまいました。

Cannot create class of type 'experiment.WithPrivateFileds'

ObjectFanatics 的方針としては、private field が使えない制約など容認できるはずもありません。

ちょっと調べてみると、こんな issue がありました。
BLZ-427 - Add configuration option for BeanProxy#includeReadOnly property.これか！？
とおもいきや、これは Java から ActionScript 側への変換に関してだけみたいですね。
しかし、BeanProxyのフィールドに対する判断基準になる設定なので、必要です。

ということで、services-config.xml ファイルのチャネル定義に serialization の設定として以下のように include-read-only オプションを追加します。

<channels>
  <channel-definition id="amf" class="mx.messaging.channels.AMFChannel">
    <endpoint url="http://{server.name}:{server.port}/{context.root}/messagebroker/amf" class="flex.messaging.endpoints.AMFEndpoint" />
    <properties>
      <serialization>
        <include-read-only>true</include-read-only>
      </serialization>
    </properties>
  </channel-definition>
</channels>

また、ActionScript 側から渡された値を Java 側の private フィールドに格納する処理も必要です。

ということで、ソースにパッチを当てて対応しました。

Java side test code.

public boolean asToJavaTypedObjectTest(SimpleObject nullValue, SimpleObject simpleObject, SimpleObjectWithPrivateConstructor simpleObjectWithPrivateConstructor, SimpleObjectWithProperties simpleObjectWithProperties, NestableObject nestableObject, WithPrivateFiled withPrivateFiled) {
    return
        (nullValue                               == null) &&
        (simpleObject                            != null) &&
        (simpleObjectWithPrivateConstructor      != null) &&
        (simpleObjectWithProperties.intValue     == 10 ) &&
        (simpleObjectWithProperties.stringValue.equals("foo")) &&
        (simpleObjectWithProperties.simpleObject != null) &&
        (nestableObject.nestableObject.nestableObject.nestableObject == null) &&
        (withPrivateFiled.getStringValue().equals("foo"));
}

Flex side test code.

public static function asToJavaTypedObjectTest():void {
    // null
    var nullValue:Object = null;
    
    // simple object
    var simpleObject:Object = new SimpleObject();
    
    // simple object with private constructor
    var simpleObjectWithPrivateConstructor:SimpleObjectWithPrivateConstructor = new SimpleObjectWithPrivateConstructor();
    
    // simple object with properties
    var simpleObjectWithProperties:SimpleObjectWithProperties = new SimpleObjectWithProperties(10, "foo", new SimpleObject());
    
    // nested properties
    var nestableObject:NestableObject = new NestableObject(new NestableObject(new NestableObject(null)));
    
    // java object has private fields
    var withPrivateFiled:WithPrivateFiled = new WithPrivateFiled("foo");
    
    // enum
    var enumObject:EnumObject = EnumObject.KUMA_SAN;

    remoteObjectWrapper.invoke(nullValue, simpleObject, simpleObjectWithPrivateConstructor, simpleObjectWithProperties, nestableObject, withPrivateFiled);
}

ActonScript to Java : Object to enum

基本方針は、Enums in Java to Enum Like Objects in ActionScriptと同じです。

ActionScript側ではpublicなプロパティを１つだけ持ったオブジェクトをEnumとして扱い、明示的に java 側のEnumにマッピングしないようにします。プロパティの値は java 側の Enum の name と同じにしておきます。

Java side test code.

public boolean asToJavaEnumTest(EnumObject enumValue) {
    return
        (enumValue.equals(EnumObject.KUMA_SAN));
}

Flex side test code.

public static function asToJavaEnumTest():void {
    var enumValue:EnumObject = EnumObject.KUMA_SAN;
    remoteObjectWrapper.invoke(enumValue);
}

以下、未検証

Array (dense) to java.util.List
Array (sparse) to java.util.Map
XML to org.w3c.dom.Document
XMLDocument(legacy XML type) to org.w3c.dom.Document

Patch for Private Constructor

変更前

110: Object instance = cls.newInstance();

変更後

try {
    instance = cls.newInstance();
} catch (IllegalAccessException e){
    for (Constructor<? extends Object> constructor : cls.getDeclaredConstructors()) {
        if (constructor.getParameterTypes().length != 0) continue;
        constructor.setAccessible(true);
        instance = constructor.newInstance();
        break;
    }
    if (instance == null) throw e;
}

Patch for Private Field Serialization

flex.messaging.io.BeanProxy#setValue(Object instance, String propertyName, Object value)

public void setValue(Object instance, String propertyName, Object value)
    {
        BeanProperty bp = getBeanProperty(instance, propertyName);

        if (bp != null)
        {
// patch for private field.
//            if (bp.isWrite())
//            {
                try
                {
                    Class desiredPropClass = bp.getType();
                    TypeMarshaller marshaller = TypeMarshallingContext.getTypeMarshaller();
                    value = marshaller.convert(value, desiredPropClass);
                    ClassUtil.validateAssignment(instance, propertyName, value);
                    bp.set(instance, value);
                }
                catch (Exception e)
                {
                    SerializationContext context = getSerializationContext();

                    // Log ignore failed property set errors
                    if (Log.isWarn() && logPropertyErrors(context))
                    {
                        Logger log = Log.getLogger(LOG_CATEGORY);
                        log.warn("Failed to set property {0} on type {1}.",
                                new Object[] {propertyName, getAlias(instance)}, e);
                    }

                    if (!ignorePropertyErrors(context))
                    {
                        // Failed to get property '{propertyName}' on type '{className}'.
                        MessageException ex = new MessageException();
                        ex.setMessage(FAILED_PROPERTY_WRITE_ERROR, new Object[] {propertyName, getAlias(instance)});
                        ex.setRootCause(e);
                        throw ex;
                    }
                }
// patch for private field.
//            }
//            else
//            {
//                SerializationContext context = getSerializationContext();
//
//                if (Log.isWarn() && logPropertyErrors(context))
//                {
//                    Logger log = Log.getLogger(LOG_CATEGORY);
//                    log.warn("Property {0} not writable on class {1}",
//                            new Object[] {propertyName, getAlias(instance)});
//                }
//
//                if (!ignorePropertyErrors(context))
//                {
//                    //Property '{propertyName}' not writable on class '{alias}'.
//                    MessageException ex = new MessageException();
//                    ex.setMessage(NON_WRITABLE_PROPERTY_ERROR, new Object[] {propertyName, getAlias(instance)});
//                    throw ex;
//                }
//            }
        }
        else
        {
            SerializationContext context = getSerializationContext();

            if (Log.isWarn() && logPropertyErrors(context))
            {
                Logger log = Log.getLogger(LOG_CATEGORY);
                log.warn("Ignoring set property {0} for type {1} as a setter could not be found.",
                            new Object[] {propertyName, getAlias(instance)});
            }

            if (!ignorePropertyErrors(context))
            {
                // Property '{propertyName}' not found on class '{alias}'.
                MessageException ex = new MessageException();
                ex.setMessage(UNKNOWN_PROPERTY_ERROR, new Object[] {propertyName, getAlias(instance)});
                throw ex;
            }
        }
    }

Test source code(Java)

experiment/EnumObject.java

package experiment;

public enum EnumObject {
    KUMA_SAN("くまさん"),
    TANUKI_SAN("たぬきさん");
    private final String string;
    private EnumObject(String string) {
        this.string = string;
    }
}

experiment/NestableObject.java

package experiment;

public class NestableObject {
    public NestableObject nestableObject;
    private NestableObject(){}
    public NestableObject(NestableObject nestableObject) {
        this.nestableObject = nestableObject;
    }
}

experiment/SerializationTestService.java

package test {    
    import flash.utils.ByteArray;
    
    import mx.controls.Alert;

    public final class SerializationTestService {
        private static var remoteObjectWrapper:RemoteObjectWrapper = new RemoteObjectWrapper("SerializationTestService");
        
        public static function asToJavaBooleanTest():void {
            remoteObjectWrapper.invoke(true, false, "true", "false");
        }
        
        public static function asToJavaByteArrayTest():void {
            var byteArray:ByteArray = new ByteArray();
            byteArray.writeByte(0);
            byteArray.writeByte(1);
            byteArray.writeByte(2);
            remoteObjectWrapper.invoke(byteArray);
        }
        
        public static function asToJavaDateTest():void {
            var date:Date = new Date();
            date.time = 1271699264375;
            remoteObjectWrapper.invoke(date);
        }
        
        public static function asToJavaIntTest():void {
            var intValue:int = -1;
            // java: Integer.MAX_VALUE = 2147483647.
            var uintValue1:uint = 2147483648; // this will be rounded to 2147483647!
            var uintValue2:uint = 2147483649; // this will be rounded to 2147483647!
            remoteObjectWrapper.invoke(intValue, uintValue1, uintValue2);
        }
        
        public static function asToJavaNumberTest():void {
            remoteObjectWrapper.invoke(new Number(-1.5));
        }
        
        public static function asToJavaStringTest():void {
            var stringValue1:String = "";
            var stringValue2:String = "foo";
            var undefinedValue:String;   // Note: undefined is converted to null.
            var nullValue:String = null; // Note: null is converted to null.
            remoteObjectWrapper.invoke(stringValue1, stringValue2, undefinedValue, nullValue);
        }
        
        public static function asToJavaGenericObjectTest():void {
            // null
            var nullValue:Object = null;
            
            // simple object
            var simpleObject:Object = new Object();
            
            // has null property
            var hasNullProperty:Object = new Object();
            hasNullProperty.property = null;
            
            // has String object
            var hasStringProperty:Object = new Object();
            hasStringProperty.property = "foo"
                
            // has Data object
            var hasDateProperty:Object = new Object();
            hasDateProperty.property = new Date();
            
            // has nested property
            var hasNestedProperty:Object = new Object();
            hasNestedProperty.property = new Object();
            hasNestedProperty.property.nestedProperty = new Date();
            
            remoteObjectWrapper.invoke(nullValue, simpleObject, hasNullProperty, hasStringProperty, hasDateProperty, hasNestedProperty);
        }
        
        public static function asToJavaTypedObjectTest():void {
            // null
            var nullValue:Object = null;
            
            // simple object
            var simpleObject:Object = new SimpleObject();
            
            // simple object with private constructor
            var simpleObjectWithPrivateConstructor:SimpleObjectWithPrivateConstructor = new SimpleObjectWithPrivateConstructor();
            
            // simple object with properties
            var simpleObjectWithProperties:SimpleObjectWithProperties = new SimpleObjectWithProperties(10, "foo", new SimpleObject());
            
            // nested properties
            var nestableObject:NestableObject = new NestableObject(new NestableObject(new NestableObject(null)));
            
            // java object has private fields
            var withPrivateFiled:WithPrivateFiled = new WithPrivateFiled("foo");
            
            // enum
            var enumObject:EnumObject = EnumObject.KUMA_SAN;

            remoteObjectWrapper.invoke(nullValue, simpleObject, simpleObjectWithPrivateConstructor, simpleObjectWithProperties, nestableObject, withPrivateFiled);
        }
        
        public static function asToJavaEnumTest():void {
            var enumValue:EnumObject = EnumObject.KUMA_SAN;
            remoteObjectWrapper.invoke(enumValue);
        }
        
        private static function createResultHandler(methodName:String):Function {
            return function(result:Boolean):void{Alert.show("methodName : " + (result ? "passed" : "failed"))}
        }
    }
}

experiment/SimpleObject.java

package experiment;

public class SimpleObject {
}

experiment/SimpleObjectWithPrivateConstructor.java

package experiment;

public class SimpleObjectWithPrivateConstructor {
    private SimpleObjectWithPrivateConstructor(){};
}

experiment/SimpleObjectWithProperties.java

package experiment;

public class SimpleObjectWithProperties {
    public int intValue;
    public String stringValue;
    public SimpleObject simpleObject;
    private SimpleObjectWithProperties(){}
    public SimpleObjectWithProperties(int intValue, String stringValue, SimpleObject simpleObject) {
        this.intValue = intValue;
        this.stringValue = stringValue;
        this.simpleObject = simpleObject;
    }    
}

experiment/WithPrivateFiled.java

package experiment;

public class WithPrivateFiled {
    private String stringValue;
    private WithPrivateFiled(){}
    public WithPrivateFiled(String stringValue) { this.stringValue = stringValue; }
    public String getStringValue() { return stringValue; }
}

Test source code(Flex)

test/EnumObject.as

package test {
    
    [RemoteClass(alias="experiment.EnumObject")]
    public class EnumObject {
        
        // Enum constants
        public static const KUMA_SAN:EnumObject = new EnumObject("KUMA_SAN", "くまさん");
        public static const TANUKI_SAN:EnumObject = new EnumObject("TANUKI_SAN", "たぬきさん");
        
        // Enum name. This must be public and not static valiable.
        public var val:String;
        
        [Transient]
        public var string:String;
        
        // Constructor
        public function EnumObject(name:String, string:String) {
            this.val = name;
            this.string = string;
        }
        
        // for displaying.
        public function toString():String {
            return string;
        }
        
        // use equality instead of identity because of the limitation of ActionScript.
        public function equals(object:Object):Boolean {
            return this.toString() == object.toString();
        }
    }
}

test/NestableObject.as

package test {
    
    [RemoteClass(alias="experiment.NestableObject")]
    public class NestableObject {
        
        // nested value
        public var nestableObject:NestableObject;
        
        // constructor
        public function NestableObject(nestableObject:NestableObject) {
            this.nestableObject = nestableObject;
        }
    }
}

test/RemoteObjectWrapper.as

package test {
    import mx.controls.Alert;
    import mx.rpc.events.FaultEvent;
    import mx.rpc.events.ResultEvent;
    import mx.rpc.remoting.Operation;
    import mx.rpc.remoting.RemoteObject;

    public class RemoteObjectWrapper {
        private var remoteObject:RemoteObject;
        public function RemoteObjectWrapper(destination:String):void {
            this.remoteObject = new RemoteObject(destination);
        }
        public function invoke(...args):void {
            var mathodName:String = getCallerSimpleName();
            remoteObject[mathodName].addEventListener("result", function (event:ResultEvent):void{Alert.show(mathodName + " : " + (event.result ? "passed" : "failed"))});
            remoteObject.addEventListener(FaultEvent.FAULT, function(faultEvent:FaultEvent):void{Alert.show("Fault : " + faultEvent)});
            var operation:Operation = remoteObject[mathodName];
            operation.arguments = args;
            operation.send();
        }
        private function getCallerSimpleName():String {
            var block:String = new Error().getStackTrace().split("at ")[3];
            var startIndex:int = block.indexOf("at ");// start of first line
            var endIndex:int = block.indexOf("()");   // end of function name
            var fullName:String = block.substring(startIndex + 3, endIndex);
            var callerSimpleName:String = fullName.substring(fullName.indexOf("/") + 1, endIndex);
            return callerSimpleName; // this is caller's caller.
        }
    }
}

test/SerializationTestService.as

package test {    
    import flash.utils.ByteArray;
    
    import mx.controls.Alert;

    public final class SerializationTestService {
        private static var remoteObjectWrapper:RemoteObjectWrapper = new RemoteObjectWrapper("SerializationTestService");
        
        public static function asToJavaBooleanTest():void {
            remoteObjectWrapper.invoke(true, false, "true", "false");
        }
        
        public static function asToJavaByteArrayTest():void {
            var byteArray:ByteArray = new ByteArray();
            byteArray.writeByte(0);
            byteArray.writeByte(1);
            byteArray.writeByte(2);
            remoteObjectWrapper.invoke(byteArray);
        }
        
        public static function asToJavaDateTest():void {
            var date:Date = new Date();
            date.time = 1271699264375;
            remoteObjectWrapper.invoke(date);
        }
        
        public static function asToJavaIntTest():void {
            var intValue:int = -1;
            // java: Integer.MAX_VALUE = 2147483647.
            var uintValue1:uint = 2147483648; // this will be rounded to 2147483647!
            var uintValue2:uint = 2147483649; // this will be rounded to 2147483647!
            remoteObjectWrapper.invoke(intValue, uintValue1, uintValue2);
        }
        
        public static function asToJavaNumberTest():void {
            remoteObjectWrapper.invoke(new Number(-1.5));
        }
        
        public static function asToJavaStringTest():void {
            var stringValue1:String = "";
            var stringValue2:String = "foo";
            var undefinedValue:String;   // Note: undefined is converted to null.
            var nullValue:String = null; // Note: null is converted to null.
            remoteObjectWrapper.invoke(stringValue1, stringValue2, undefinedValue, nullValue);
        }
        
        public static function asToJavaGenericObjectTest():void {
            // null
            var nullValue:Object = null;
            
            // simple object
            var simpleObject:Object = new Object();
            
            // has null property
            var hasNullProperty:Object = new Object();
            hasNullProperty.property = null;
            
            // has String object
            var hasStringProperty:Object = new Object();
            hasStringProperty.property = "foo"
                
            // has Data object
            var hasDateProperty:Object = new Object();
            hasDateProperty.property = new Date();
            
            // has nested property
            var hasNestedProperty:Object = new Object();
            hasNestedProperty.property = new Object();
            hasNestedProperty.property.nestedProperty = new Date();
            
            remoteObjectWrapper.invoke(nullValue, simpleObject, hasNullProperty, hasStringProperty, hasDateProperty, hasNestedProperty);
        }
        
        public static function asToJavaTypedObjectTest():void {
            // null
            var nullValue:Object = null;
            
            // simple object
            var simpleObject:Object = new SimpleObject();
            
            // simple object with private constructor
            var simpleObjectWithPrivateConstructor:SimpleObjectWithPrivateConstructor = new SimpleObjectWithPrivateConstructor();
            
            // simple object with properties
            var simpleObjectWithProperties:SimpleObjectWithProperties = new SimpleObjectWithProperties(10, "foo", new SimpleObject());
            
            // nested properties
            var nestableObject:NestableObject = new NestableObject(new NestableObject(new NestableObject(null)));
            
            // java object has private fields
            var withPrivateFiled:WithPrivateFiled = new WithPrivateFiled("foo");
            
            // enum
            var enumObject:EnumObject = new EnumObject("");

            remoteObjectWrapper.invoke(nullValue, simpleObject, simpleObjectWithPrivateConstructor, simpleObjectWithProperties, nestableObject, withPrivateFiled);
        }
        
        public static function asToJavaEnumTest():void {
            var enumValue:EnumObject = EnumObject.KUMA_SAN;
            remoteObjectWrapper.invoke(enumValue);
        }
        
        private static function createResultHandler(methodName:String):Function {
            return function(result:Boolean):void{Alert.show("methodName : " + (result ? "passed" : "failed"))}
        }
    }
}

test/SerializationTestServiceApp.mxml

<?xml version="1.0" encoding="utf-8"?>
<!-- Application to invoke serialization tests. -->

<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
               xmlns:s="library://ns.adobe.com/flex/spark" 
               xmlns:mx="library://ns.adobe.com/flex/mx" width="100%" height="100%">
    <s:layout>
        <s:VerticalLayout horizontalAlign="center" verticalAlign="middle"/>
    </s:layout>
    <fx:Script>
        <![CDATA[
            import test.SerializationTestService;
            protected function test():void {
                SerializationTestService.asToJavaBooleanTest();
                SerializationTestService.asToJavaByteArrayTest();
                SerializationTestService.asToJavaDateTest();
                SerializationTestService.asToJavaIntTest();
                SerializationTestService.asToJavaNumberTest();
                SerializationTestService.asToJavaStringTest();
                SerializationTestService.asToJavaGenericObjectTest();
                SerializationTestService.asToJavaTypedObjectTest();
                SerializationTestService.asToJavaEnumTest();
            }
        ]]>
    </fx:Script>
    <s:Button id="testButton" label="Test" click="test()"/>
</s:Application>

test/SimpleObject.as

package test {
    [RemoteClass(alias="experiment.SimpleObject")]
    public class SimpleObject {
        public function SimpleObject() {}
    }
}

test/SimpleObjectWithPrivateConstructor.as

package test {
    [RemoteClass(alias="experiment.SimpleObjectWithPrivateConstructor")]
    public class SimpleObjectWithPrivateConstructor {
        public function SimpleObjectWithPrivateConstructor() {
        }
    }
}

test/SimpleObjectWithProperties.as

package test {
 [RemoteClass(alias="experiment.SimpleObjectWithProperties")]
 public class SimpleObjectWithProperties {
  
  // properties
  public var intValue:int;
  public var stringValue:String;
  public var simpleObject:SimpleObject;
  
  // constructor
  public function SimpleObjectWithProperties(intValue:int, stringValue:String, simpleObject:SimpleObject):void {
   this.intValue = intValue;
   this.stringValue = stringValue;
   this.simpleObject = simpleObject;
  }
 }
}

test/WithPrivateFiled.as

package test {
    [RemoteClass(alias="experiment.WithPrivateFiled")]
    public class WithPrivateFiled {
        
        // The field of ActionSide is public. Java side of that is private.
        public var stringValue:String;
        
        // constructor
        public function WithPrivateFiled(stringValue:String) {
            this.stringValue = stringValue;
        }
    }
}

作業ログ：BlazeDSのRemotingServiceでJavaのenumを扱う方法

2010-04-19T14:32:00.017+09:00

ActionScrip側からAMFで送られた文字列をBlazeDS4側でenumに変換しようとしたところ、

No enum const class

と怒られてしまい、うまくいきませんでした。

flex 側で IExternalizable を実装して String を投げるようにしてみたのですが、そうすると今度は BlazeDS 側で配列に変更しようとしてエラーで落ちました。

方法が間違っていたのかもしれませんが、どうも解決法が見つけられなかったので、とりあえずはワークアラウンドで対応することにしました。

(´・ω・`) 正規の方法を教えてください、、、

4.21.2010追記：正規の方法がありました。詳細はこちらを参照のこと。

~~workaround~~

ActionScript 側の Enum (のような)実装では、内部に必ず Enum.valueOf() メソッドの第二引数に対応する文字列を持つpublicなインスタンス変数(or getter/setter)を配置する。
~~ActionScript 側の Enum (のような)実装では、必ず public var name:String を定義し、java 側の Enum#getName() と対応させる。~~
~~それ以外の変数(or getter/setter)を配置してもよいが、すべてメタタグ [Transient] をつける。~~
~~BlazeDS4のソースにパッチを当てる。~~

AMFから受け取った情報が、値がString型のエントリを一つだけ持つASObjectになればOKです。
この方法だと、副作用として flex 側で IExternalizable を実装する必要がないのでラクチンです。

パッチ

対象のソースコードは、flex.messaging.io.amf.translator.decoder.EnumDecoder クラスです。

元のコードは以下のようになっています。

55: Enum value = Enum.valueOf(desiredClass, encodedObject.toString());

~~encodedObject の型が flex.messaging.io.amf.ASObject 型なので、encodedObject.toString() の値は以下のようなフォーマットの文字列に変換されます。~~

ASObject(33469162){name=HOGE}

上記のワークアラウンドを適用すると、ASObjectはひとつだけエントリを持つマップとなるはずなので、そのエントリの値を使えば Enum が復元できます。

以下が変更内容です。ASObject以外が来る場合もあるかもしれないので（まだそこまでソースを追ってません）一応、オリジナルのコードも残しておきます。

final Enum value;
if (ASObject.class.isInstance(encodedObject)) {
 // patch for workaround
 value = Enum.valueOf(desiredClass, ASObject.class.cast(encodedObject).values().iterator().next().toString());
} else {
 // original
 value = Enum.valueOf(desiredClass, encodedObject.toString());
}

~~ActionScript 側のEnum（のようなもの）の例~~

public final class Hoge {
 public var name:String;
 public function Hoge(name:String) { this.name = name; }
 public static const HOGETAROU:Hoge = new Hoge("HOGETAROU");
 public static const HOGEJIROU:Hoge = new Hoge("HOGEJIROU");
 public static const HOGENOSUKE:Hoge = new Hoge("HOGENOSUKE");
}

ActionScriptファイル内でXMLファイルのembed設定をするサンプル

2010-04-19T04:23:00.004+09:00

ActionScript ファイル内で XML ファイルの embed 設定をする方法のサンプルです。

構成

sample.xml
サンプルのXMLファイル。
XmlService.as
サンプルのXMLファイルへのアクセスを提供する ActionScript ファイル。
EmbeddedXmlTest.mxml
上記の利用するサンプルアプリケーション。

各ファイルを sample パッケージ直下に配置すれば動きます。

見た目はこんな感じです。

sample.xml

<words>
 <word id="1" value="cat" />
 <word id="2" value="dog" />
 <word id="3" value="cow" />
 <word id="4" value="lion" />
 <word id="5" value="monkey" />
 <word id="6" value="squirrel" />
 <word id="7" value="elephant" />
 <word id="8" value="hippopotamus" />
 <word id="9" value="rabbit" />
</words>

XmlService.as

package sample  {
 
 // 埋め込まれた xml ファイルを取得するサービス
 public class XmlService {
  
  /**
   * 埋め込まれた xml ファイル
   */
  [Embed(source="sample.xml")]
  private static const _xml:Class;
    
  /**
   * xml ファイルの内容を表す XML 型の変数
   */
  public static const xml:XML = _xml.data;
  
  /**
   * 指定されたインデックスの word 要素を返します。
   */
  public static function getWord(index:uint):XML {
   return xml.word.(@id==index)[0];
  }
 }
}

EmbeddedXmlTest.mxml

<?xml version="1.0" encoding="utf-8"?>

<!-- XMLファイルの内容を TextArea と DataGrid に表示するサンプル -->

<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
      xmlns:s="library://ns.adobe.com/flex/spark" 
      xmlns:mx="library://ns.adobe.com/flex/mx" width="100%" height="100%">
 <s:layout>
  <s:VerticalLayout verticalAlign="middle" horizontalAlign="center"/>
 </s:layout>
 <mx:HBox width="200" borderVisible="true" verticalAlign="middle" borderColor="black" borderStyle="solid">
  <mx:Label text="id : {idNs.value}"/>
  <mx:NumericStepper id="idNs" width="20" change="wordLabel.text = XmlService.getWord(idNs.value).@value" minimum="1" maximum="{XmlService.xml.word.length()}"/>
  <mx:Label id="wordLabel" width="100%"/>
 </mx:HBox>
 <mx:DataGrid id="grid" x="200" y="200" dataProvider="{XmlService.xml.word}" selectedIndex="{idNs.value-1}">
  <mx:columns>
   <mx:DataGridColumn headerText="id" dataField="@id"/>
   <mx:DataGridColumn headerText="value" dataField="@value"/>
  </mx:columns>
 </mx:DataGrid>
</s:Application>

しかし、この手のネタって検索エンジンで引っ掛けるのが難しいですよね。flex, embed, XML, ActionScript など、どの検索ワードも一般的すぎる、、、。

作業ログ：login機能使用時の SessionDuplicate 問題

2010-04-18T08:22:00.055+09:00

作業ログ：GAE/J + BlazeDS 4 環境について考えてみた。にて、同じ session id を持つ異なる FlexSession のインスタンスを同一とみなすパッチを当てることにより、セッション重複の誤検出をしないように変更しました。

しかし、 login / logout 機能周りでもセッション重複の誤検出が行われるようです。

以下、状況を確認するために仕込んだログ。

// 最初のアクセス(login)
04-17 05:50AM 29.350 MessageBrokerServlet#service() : begin
04-17 05:50AM 29.350 FlexContext#setThreadLocalObjects(): null is set.
04-17 05:50AM 29.350 FlexContext#setThreadLocalSession(): flex.messaging.HttpFlexSession@c1b161 is set. sessionId = BwbsdybycCfB7kDRSLErnw
04-17 05:50AM 29.350 HttpFlexSessionProvider#getOrCreateSession() : HttpFlexSession is retrieved from thread local. id = BwbsdybycCfB7kDRSLErnw
04-17 05:50AM 29.352 flexClient is retrieved from in-memory flexClients repository.
04-17 05:50AM 29.352 AbstractEndpoint#setupFlexClient(C4DB9840-340F-6FC7-5604-28ADF310987A) : flex.messaging.HttpFlexSession@1d952cdf
04-17 05:50AM 29.352 FlexClient#registerFlexSession() : httpClient = flex.messaging.client.FlexClient@d210ab, sessionId = BwbsdybycCfB7kDRSLErnw
04-17 05:50AM 29.359 doAuthentication
04-17 05:50AM 31.199 MessageBrokerServlet#service() : end


// 二回目のアクセス(logout)
04-17 05:50AM 33.584 MessageBrokerServlet#service() : begin
04-17 05:50AM 33.584 FlexContext#setThreadLocalObjects(): null is set.
04-17 05:50AM 33.584 FlexContext#setThreadLocalSession(): flex.messaging.HttpFlexSession@1601a4f is set. sessionId = BwbsdybycCfB7kDRSLErnw
04-17 05:50AM 33.584 HttpFlexSessionProvider#getOrCreateSession() : HttpFlexSession is retrieved from thread local. id = BwbsdybycCfB7kDRSLErnw
04-17 05:50AM 33.585 flexClient is retrieved from in-memory flexClients repository.
04-17 05:50AM 33.585 AbstractEndpoint#setupFlexClient(C4DB9840-340F-6FC7-5604-28ADF310987A) : flex.messaging.HttpFlexSession@1d952cdf
04-17 05:50AM 33.585 FlexClient#registerFlexSession() : httpClient = flex.messaging.client.FlexClient@d210ab, sessionId = BwbsdybycCfB7kDRSLErnw
04-17 05:50AM 33.586 logout
04-17 05:50AM 33.620 sessionDestroyed : id = BwbsdybycCfB7kDRSLErnw
04-17 05:50AM 33.620 attributeRemoved : name = __flexSession, value = flex.messaging.HttpFlexSession@1d952cdf
04-17 05:50AM 33.702 sessionDestroyed : id = BwbsdybycCfB7kDRSLErnw
04-17 05:50AM 33.758 FlexContext#setThreadLocalObjects(): null is set.
04-17 05:50AM 33.760 MessageBrokerServlet#service() : end


// 三回目のアクセス(?)
04-17 05:50AM 34.276 MessageBrokerServlet#service() : begin
04-17 05:50AM 34.276 FlexContext#setThreadLocalObjects(): null is set.
04-17 05:50AM 34.374 sessionCreated : id = KHeEJ_L9FBgQol3Hj15rlw
04-17 05:50AM 34.374 FlexContext#setThreadLocalSession(): flex.messaging.HttpFlexSession@e7b3cf is set. sessionId = KHeEJ_L9FBgQol3Hj15rlw
04-17 05:50AM 34.374 attributeAdded : name = __flexSession, value = flex.messaging.HttpFlexSession@e7b3cf
04-17 05:50AM 34.374 HttpFlexSessionProvider#getOrCreateSession() : HttpFlexSession is created. id = KHeEJ_L9FBgQol3Hj15rlw
04-17 05:50AM 34.375 flexClient is retrieved from in-memory flexClients repository.
04-17 05:50AM 34.375 AbstractEndpoint#setupFlexClient(C4DB9840-340F-6FC7-5604-28ADF310987A) : flex.messaging.HttpFlexSession@b89a50a6
04-17 05:50AM 34.375 FlexClient#registerFlexSession() : httpClient = flex.messaging.client.FlexClient@d210ab, sessionId = KHeEJ_L9FBgQol3Hj15rlw
04-17 05:50AM 34.376 sessions.size() = 2
04-17 05:50AM 34.376 sessionId = BwbsdybycCfB7kDRSLErnw
04-17 05:50AM 34.376 sessionId = KHeEJ_L9FBgQol3Hj15rlw
04-17 05:50AM 34.376 FlexClient#registerFlexSession() : httpClient = flex.messaging.client.FlexClient@d210ab, sessionId = KHeEJ_L9FBgQol3Hj15rlw
04-17 05:50AM 34.406 sessionDestroyed : id = BwbsdybycCfB7kDRSLErnw
04-17 05:50AM 34.420 sessionDestroyed : id = KHeEJ_L9FBgQol3Hj15rlw
04-17 05:50AM 34.420 attributeRemoved : name = __flexSession, value = flex.messaging.HttpFlexSession@b89a50a6
04-17 05:50AM 34.603 sessionCreated : id = tcnt9ZwRj6jAnqib-C9o0A
04-17 05:50AM 34.604 FlexContext#setThreadLocalSession(): flex.messaging.HttpFlexSession@1912a56 is set. sessionId = tcnt9ZwRj6jAnqib-C9o0A
04-17 05:50AM 34.604 attributeAdded : name = __flexSession, value = flex.messaging.HttpFlexSession@1912a56
04-17 05:50AM 34.604 HttpFlexSessionProvider#getOrCreateSession() : HttpFlexSession is created. id = tcnt9ZwRj6jAnqib-C9o0A
04-17 05:50AM 34.604 FlexContext#setThreadLocalObjects(): flex.messaging.HttpFlexSession@b8b7ad0d is set.
04-17 05:50AM 34.627 MessageBrokerServlet#service() : end

一回目のアクセス

問題なく普通にログインできてる感じです。

二回目のアクセス

sessionDestroyed が二回呼ばれてますね。実害はなさそうですが。

三回目のアクセス

FlexClientに古いsessionが残ってますね。それで、新規のsessionが追加されることによって重複が検出されているみたいです。
二回目のアクセスで削除されたはずの BwbsdybycCfB7kDRSLErnw に sessionDestroyed が呼ばれてますね。

何気に、全アクセスのパスが /messagebroker/amf;jsessionid=BwbsdybycCfB7kDRSLErnw になってるなぁ。これが原因？ということで、そうならない形で再実験。cookie 削除して、flashも新規にロードして、ついでに flash 側でもすべてのハンドラにログ仕込んで、さぁ、どうなるか？

logout 後にもう一度アクセスしに行って、そのときにエラーが返されてますね。上記の３回目のアクセスと同様と思われます。それが原因か？

いくつか気持ち悪い問題がありますね。

二回目のアクセスで削除されたはずの BwbsdybycCfB7kDRSLErnw に対して sessionDestroyed が発行されるという問題。
二回目のアクセスで BwbsdybycCfB7kDRSLErnw のセッションを削除したのに、オンメモリ上の FlexClient からは情報が削除されていない。
開発環境では発生せずGAE環境だけで発生する。

ひとまず、一つ目の問題について、専用のテストプログラムを作成し、開発環境とGAE環境で動作させて見ることにします。

ローカルだと IllegalStateException で落ちますが、sessionDestroyedのハンドラは呼ばれました。

結局

振り返ってみると、調査開始時にはずいぶん勘違いがあったなぁ。
インメモリのリポジトリって何だよｗｗｗ

という感じで、上記からけっこう激しく試行錯誤した挙句、以下に落ち着きました。

flex.messaging.client.FlexClient クラスの registerFlexSession(FlexSession) メソッドについて、以下のように修正します。

public void registerFlexSession(FlexSession session)
{
    if (sessions.addIfAbsent(session))
    {
        session.addSessionDestroyedListener(this);
        session.registerFlexClient(this);
    }
    // for session serialization
    else if (session.getFlexClients().isEmpty())
    {
        session.addSessionDestroyedListener(this);
        session.registerFlexClient(this);
    }
}

(´・ω・`) しかし、稀に重複検出の例外が起きるのです。

ログを見る限り、サーバ上では、logout メッセージでセッションを破棄し、, disconnect メッセージで再度セッションを生成しするのですが、次のログイン前の ping で HTTP レベルのセッションが取得できないことがあるようです。

2,3秒間隔で行うとこの問題は発生しません。

GAEではセッション情報を必ずデータストアから取得するようなので、データストア側で遅延があるのであれば、セッションを取得できないのは納得できます（TODO:要調査）。しかし、それだけでは問題にはなりません。なぜ以前のセッション情報として格納されていた FlexClient の情報が復活しているかということです。FlexClient は実際にはシリアライズされるわけではなく毎回復元されるものなので、以前の情報が残っていることはありえません。となると、この仮定が間違っているのか、ほかに見落としている点があるかのどちらかということになります（TODO:要調査）。

まぁ、今のところはログアウト後に速攻でログインしない限り発生しないので、しばらくは放置しようかと思います。

(´・ω・`) GAE環境は調査に時間がかかりすぎるのねん、、、。

GAE 環境につないだ Flex クライアントを FlexBuilder からデバッグする方法

2010-04-17T02:27:00.000+09:00

Flash のクライアントを持つアプリケーションを Google App Engine 上で開発する場合、FlashBuilder 上でデバッグモードで動作するクライアントと GAE をつなぎたくなります。

そのような場合は、以下の手順で対応可能です。

FlashBuilder のプロジェクト側で、GAE のパスを Root URL に設定する。
デバッグモードでクライアントアプリを起動する。

以上。

作業ログ：GAE/J + BlazeDS 4 環境について考えてみた。

2010-04-17T01:47:00.004+09:00

以下、GAE/J + BlazeDS 4 環境について考えてみた作業ログ。

方針

以前、GAE 上で普通に remoting や messaging をしようと思ったところGAE/J + BlazeDS 環境の DuplicateSessionDetected 問題に突き当たりました。また、security 機能を利用しようとした際には後GAE/J + BlazeDS3 環境の HttpSessionListener 問題に突き当たりました。

これらの経緯を考えると、今後も多くの問題に突き当たることが考えられます。これより先に進むのであれば、それなりの覚悟が必要になります。しかし、オープンソースのソフトウェアである限り、手詰まりに可能性が低く、最終的に詰むというリスクは低く抑えられています。これはやるしかないでしょう。

となると、どこまでやるかという問題がありますが、自分たちが必要な機能についてはすべて自分たちで理解したうえでコントロールするというところが落としどころかとおもいます。具体的には、GAE 上で動作すればよく、まずはロールなしのセッションレベルの認証ができればいいし、通常の AMF で remoting ができればOKです。今後メッセージングも必要になるかもしれないとか、GAE上なのでストリーミングが必要になることは当面ありえないだろうとか。そんな感じです。少なくともその時点で必要な機能かつ問題のあるソースはすべて把握しておく必要があり、そのためには全体の構成と主要なクラスについては、ソースレベルで完全に把握する必要があります。

(｀・ω・´) さて、どこから手をつけようか？

まずは環境整理

これから作業をする上で、クリーンな環境を維持することは重要になります。そのため、環境整備の手順を整理しておく必要があります。

ということで、GAE/J + BlazeDS 4 環境の構築に内容をまとめました。

GAE/J + BlazeDS 環境の DuplicateSessionDetected 問題を再び追いながら情報収集

Servletのバージョン

BlazeDS は Servlet2.3以上（TODO:出典明記）
GAE は Servlet2.4（TODO:出典明記）

Application Lifecycle Event

BlazeDS 4 では web.xml で以下のように flex.messaging.HttpFlexSession を Application Lifecycle Event のリスナーとして設定しています。

<!-- Http Flex Session attribute and binding listener support -->
<listener>
  <listener-class>flex.messaging.HttpFlexSession</listener-class>
</listener>

このクラスは以下のインタフェースを実装しています。

javax.servlet.http.HttpSessionAttributeListener
javax.servlet.http.HttpSessionBindingListener
javax.servlet.http.HttpSessionListener

HttpFlexSession が実装するリスナーのメソッドと、実行内容の概要を以下に示します。

void valueBound(HttpSessionBindingEvent event)

何もしません。

void valueUnbound(HttpSessionBindingEvent event)

HttpSessionの属性が削除された場合に flexSession.superInvalidate() を呼びます。。
isHttpSessionListener が true の場合、つまり通常は何もしません。
~~GAE 環境では、呼ばれたら実行されるはずです。~~（追記：GAE環境でも実行されません）
属性が削除されただけでなぜ flexSession.superInvalidate() を呼ぶ必要があるのか？

void sessionCreated(HttpSessionEvent event)

isHttpSessionListener フラグを true にします。

void sessionDestroyed(HttpSessionEvent event)

HttpSessionが削除されたらFlexSessionも削除されるようにします。
attributeRemovedイベントよりよりこちらが先に行われる場合の対策として、attributeRemovedこちらからもattributeRemovedを呼びに行っています。
void attributeAdded(HttpSessionBindingEvent event)
属性変更イベント名が"__flexSession"の場合のみ、flexSession.notifyAttributeBound(name, value)とnotifyAttributeAdded(name, value)を呼びに行く。
必要な属性だけコピーするということですね。

void attributeRemoved(HttpSessionBindingEvent event)

属性変更イベント名が"__flexSession"の場合のみ、flexSession.notifyAttributeUnbound(name, value) と flexSession.notifyAttributeRemoved(name, value) を呼びに行く。

void attributeReplaced(HttpSessionBindingEvent event)

属性変更イベント名が"__flexSession"の場合のみ、flexSession.notifyAttributeUnbound(name, value) と flexSession.notifyAttributeReplaced(name, value) と flexSession.notifyAttributeBound(name, newValue) を呼びに行く。

ログを仕込んで、ローカル環境で実行してみました。

// 初回
MessageBrokerServlet#service() : begin
HttpFlexSession#sessionCreated() : sessionId = 13x3l8s1hg56a
HttpFlexSession#valueBound() : name = __flexSession : sessionId = 13x3l8s1hg56a
HttpFlexSession#attributeAdded() : name = __flexSession : sessionId = 13x3l8s1hg56a
MessageBrokerServlet#service() : end
MessageBrokerServlet#service() : begin
EchoService#echo() : sessionId = 13x3l8s1hg56a
MessageBrokerServlet#service() : end

// 二回目
MessageBrokerServlet#service() : begin
EchoService#echo() : sessionId = 1l72bdhrrlfvy
MessageBrokerServlet#service() : end

デバッガでも追ったところ、Sevletコンテナ側から正しく呼び出されていました。（正しく動作するということが、GAE的にはバグなんですね。）

初回は２回serviceが呼ばれてますね。TODO：要調査

今度はサーバ側にデプロイして同様のことをしてみます。

// 一回目のアクセス（例のセッション重複で失敗）
04-15 02:56PM 55.052 MessageBrokerServlet#service() : begin
04-15 02:56PM 55.283 MessageBrokerServlet#service() : end

04-15 02:56PM 55.555 MessageBrokerServlet#service() : begin
04-15 02:56PM 55.587 HttpFlexSession#sessionDestroyed() : sessionId = CRls4b-kT7-DCbJSV6yFbw
04-15 02:56PM 55.587 FlexSession#invalidate()
04-15 02:56PM 55.870 HttpFlexSession#sessionDestroyed() : sessionId = CRls4b-kT7-DCbJSV6yFbw
04-15 02:56PM 55.961 MessageBrokerServlet#service() : end

// 二回目のアクセス（成功）
04-15 03:17PM 18.307 MessageBrokerServlet#service() : begin
04-15 03:17PM 18.526 HttpFlexSession#sessionCreated() : sessionId = V1pWQsjzwKuDKYUS5IlpZg
04-15 03:17PM 18.527 HttpFlexSession#valueBound() : name = __flexSession : sessionId = V1pWQsjzwKuDKYUS5IlpZg
04-15 03:17PM 18.527 HttpFlexSession#attributeAdded() : name = __flexSession : sessionId = V1pWQsjzwKuDKYUS5IlpZg
04-15 03:17PM 19.251 MessageBrokerServlet#service() : end

04-15 03:17PM 19.719 MessageBrokerServlet#service() : begin
04-15 03:17PM 19.790 HttpFlexSession#sessionDestroyed() : sessionId = V1pWQsjzwKuDKYUS5IlpZg
04-15 03:17PM 19.790 FlexSession#invalidate()
04-15 03:17PM 19.790 HttpFlexSession#valueUnbound() : NOP : name = __flexSession : sessionId = V1pWQsjzwKuDKYUS5IlpZg
04-15 03:17PM 19.790 HttpFlexSession#attributeRemoved() : name = __flexSession : sessionId = V1pWQsjzwKuDKYUS5IlpZg
04-15 03:17PM 19.889 HttpFlexSession#sessionDestroyed() : sessionId = V1pWQsjzwKuDKYUS5IlpZg
04-15 03:17PM 19.976 MessageBrokerServlet#service() : end

04-15 03:20PM 00.169 MessageBrokerServlet#service() : begin
04-15 03:20PM 00.465 HttpFlexSession#sessionCreated() : sessionId = 0Gqlzdy3J_I2n281ANfQmQ
04-15 03:20PM 00.466 HttpFlexSession#valueBound() : name = __flexSession : sessionId = 0Gqlzdy3J_I2n281ANfQmQ
04-15 03:20PM 00.466 HttpFlexSession#attributeAdded() : name = __flexSession : sessionId = 0Gqlzdy3J_I2n281ANfQmQ
04-15 03:20PM 02.255 EchoService#echo() : sessionId = 0Gqlzdy3J_I2n281ANfQmQ
04-15 03:20PM 02.375 MessageBrokerServlet#service() : end

おや？

HttpFlexSession#sessionCreated() は、Servletコンテナのライフサイクルイベントとして以外には絶対に呼ばれないということはソースから確認できます。なのに呼ばれているということは、GAE上でもライフサイクルイベントが呼ばれるということですね。

ということで、GAE/J 環境の Application Lifecycle Listener の実験をしてみたところ、やはり GAE 上でもライフサイクルイベントは呼ばれるようです。

ということで、今度は上記テストのリスナーをコンテナに配備して、埋め込んだデバッグ情報を一度ほぼクリアにしてから、再度動作検証をしていくことにします。ブラウザのcookieは事前に削除しておきます。念のため、_ah_SESSION 情報も削除しておきます。関係ないと思いつつもWeb サイトのプライバシー設定パネルから flash のローカルクッキーも削除します。

開発サーバでの実行

// 一回目のアクセス
sessionCreated : id = 1snep0z5nb1pd
attributeAdded : name = __flexSession, value = flex.messaging.HttpFlexSession@14a18d
EchoService#echo() : sessionId = 1snep0z5nb1pd

// 二回目のアクセス
EchoService#echo() : sessionId = 1snep0z5nb1pd

// 三回目のアクセス
EchoService#echo() : sessionId = 1snep0z5nb1pd

本番サーバでの実行

// UIから一回目のアクセス /messagebroker/amf
04-16 05:16AM 04.683 sessionCreated : id = EmVdv905Ogr0kGuoKMfVHA
04-16 05:16AM 04.690 attributeAdded : name = __flexSession, value = flex.messaging.HttpFlexSession@165547d
// UIから一回しかアクセスしていないけどなぜか二回目のアクセスが行われている。/messagebroker/amf;jsessionid=EmVdv905Ogr0kGuoKMfVHA
04-16 05:16AM 05.584 sessionDestroyed : id = EmVdv905Ogr0kGuoKMfVHA
04-16 05:16AM 05.584 attributeRemoved : name = __flexSession, value = flex.messaging.HttpFlexSession@165547d
04-16 05:16AM 05.861 sessionDestroyed : id = EmVdv905Ogr0kGuoKMfVHA
【結果】Detected duplicate HTTP-based FlexSessions で失敗

// UIから二回目のアクセス /messagebroker/amf;jsessionid=EmVdv905Ogr0kGuoKMfVHA
04-16 05:18AM 19.795 sessionCreated : id = uqSuxURP-RXL1hsdcp2c0A
04-16 05:18AM 19.795 attributeAdded : name = __flexSession, value = flex.messaging.HttpFlexSession@34a1c8
04-16 05:18AM 19.830 sessionDestroyed : id = EmVdv905Ogr0kGuoKMfVHA
04-16 05:18AM 19.850 sessionDestroyed : id = uqSuxURP-RXL1hsdcp2c0A
04-16 05:18AM 19.850 attributeRemoved : name = __flexSession, value = flex.messaging.HttpFlexSession@34a1c8
04-16 05:18AM 20.008 sessionCreated : id = SaKtj72k_5tVABGvK7vOAg
04-16 05:18AM 20.008 attributeAdded : name = __flexSession, value = flex.messaging.HttpFlexSession@1e514a9
【結果】Detected duplicate HTTP-based FlexSessions で失敗）

// 三回目のアクセス /messagebroker/amf;jsessionid=SaKtj72k_5tVABGvK7vOAg
04-16 05:20AM 34.078 EchoService#echo() : sessionId = SaKtj72k_5tVABGvK7vOAg 
【結果】成功

現状のデータからの考察

開発環境上の動作は、意図したとおりのものです。しかし、本番環境上の動作は、意図とはかなり異なる動きをしています。

まず flash クライアントからの初回のアクセスが2回に分けて行われています。これ自体理由が分からないので調査したいところですが、何回アクセスがきたところで、セッション管理に影響するというのは問題です。まずは最初のアクセスからソースを追いつつ、仮定を立ててみます。

・仮定１：初回アクセスの２回目のHTTP呼び出しにて、BaseHTTPEndpoint#setupFlexClient() の432行で DuplicateSessionException が throw されている。
・仮定２：上記は同クラス400行にてflexClient.getFlexSessions()のサイズを2として受け取っている。
・仮定３：仮定２の直接の原因は、FlexClient の 1119 行目で複数の FlexSession が登録されてしまうこと。

とりあえず、ここまでを確認してみたところ、仮定１，２は正解。仮定３は可能性ありです。二回目のアクセスで、一回目で生成された FlexClient を使用しているのであれば、仮定３はほぼクロです。

ということで、ログを仕込んで再実行。

開発環境

// 初回（成功）
04-16 08:52AM 37.279 [beyondseeker-mixi-01/1.341297705342737136].: MessagingConfiguration#createFlexClientManager() : FlexClientManager is created with problem!
04-16 08:52AM 38.068 [beyondseeker-mixi-01/1.341297705342737136].: MessageBrokerServlet#service() : begin
04-16 08:52AM 38.322 [beyondseeker-mixi-01/1.341297705342737136].: sessionCreated : id = zpE2j7OXspDhdA1-960ZCg
04-16 08:52AM 38.325 [beyondseeker-mixi-01/1.341297705342737136].: attributeAdded : name = __flexSession, value = flex.messaging.HttpFlexSession@187e184
04-16 08:52AM 38.644 [beyondseeker-mixi-01/1.341297705342737136].: FlexClient#registerFlexSession() : httpClient = flex.messaging.client.FlexClient@92de02
04-16 08:52AM 38.644 [beyondseeker-mixi-01/1.341297705342737136].: FlexClient#registerFlexSession() : httpClient = flex.messaging.client.FlexClient@92de02
04-16 08:52AM 38.659 [beyondseeker-mixi-01/1.341297705342737136].: EchoService#echo() : sessionId = zpE2j7OXspDhdA1-960ZCg
04-16 08:52AM 38.705 [beyondseeker-mixi-01/1.341297705342737136].: MessageBrokerServlet#service() : end

本番環境

// 初回（成功）
04-16 08:52AM 37.279 MessagingConfiguration#createFlexClientManager() : FlexClientManager is created with problem!
04-16 08:52AM 38.068 MessageBrokerServlet#service() : begin
04-16 08:52AM 38.322 sessionCreated : id = zpE2j7OXspDhdA1-960ZCg
04-16 08:52AM 38.325 attributeAdded : name = __flexSession, value = flex.messaging.HttpFlexSession@187e184
04-16 08:52AM 38.644 FlexClient#registerFlexSession() : httpClient = flex.messaging.client.FlexClient@92de02
04-16 08:52AM 38.644 FlexClient#registerFlexSession() : httpClient = flex.messaging.client.FlexClient@92de02
04-16 08:52AM 38.659 EchoService#echo() : sessionId = zpE2j7OXspDhdA1-960ZCg
04-16 08:52AM 38.705 MessageBrokerServlet#service() : end

// 二回目（失敗）
04-16 08:53AM 39.110 MessageBrokerServlet#service() : begin
04-16 08:53AM 39.112 flexClient is retrieved from in-memory flexClients repository.
04-16 08:53AM 39.112 FlexClient#registerFlexSession() : httpClient = flex.messaging.client.FlexClient@92de02
04-16 08:53AM 39.112 sessions.size() = 2
04-16 08:53AM 39.112 sessionId = zpE2j7OXspDhdA1-960ZCg
04-16 08:53AM 39.112 sessionId = zpE2j7OXspDhdA1-960ZCg
04-16 08:53AM 39.112 FlexClient#registerFlexSession() : httpClient = flex.messaging.client.FlexClient@92de02
04-16 08:53AM 39.128 sessionDestroyed : id = zpE2j7OXspDhdA1-960ZCg
04-16 08:53AM 39.129 attributeRemoved : name = __flexSession, value = flex.messaging.HttpFlexSession@187e184
04-16 08:53AM 39.250 sessionDestroyed : id = zpE2j7OXspDhdA1-960ZCg
04-16 08:53AM 39.343 MessageBrokerServlet#service() : end

開発環境、本番環境に関わらず、二回目のアクセスはオンメモリの情報を取得しています。

FlexClientManager では、取得できればオンメモリのものを使用し、できなければサーバ上のものを使用するので、GAE 環境でも問題なさそうです。

そして、問題なのは、同じ sessionId を二箇所登録している部分です。これは以前
GAE/J + BlazeDS 環境の DuplicateSessionDetected 問題で調べたとおりなので、同様に対処します。

本番環境

// 初回（成功）
04-16 09:38AM 51.550 MessagingConfiguration#createFlexClientManager() : FlexClientManager is created with problem!
04-16 09:38AM 52.813 MessageBrokerServlet#service() : begin
04-16 09:38AM 53.228 FlexClient#registerFlexSession() : httpClient = flex.messaging.client.FlexClient@1bb60ad
04-16 09:38AM 53.228 FlexClient#registerFlexSession() : httpClient = flex.messaging.client.FlexClient@1bb60ad
04-16 09:38AM 53.250 EchoService#echo() : sessionId = IHEyAtViGH3J9Et5RT48mg
04-16 09:38AM 53.300 MessageBrokerServlet#service() : end

// 二回目（成功）
04-16 09:39AM 49.765 MessageBrokerServlet#service() : begin
04-16 09:39AM 49.767 flexClient is retrieved from in-memory flexClients repository.
04-16 09:39AM 49.767 FlexClient#registerFlexSession() : httpClient = flex.messaging.client.FlexClient@1bb60ad
04-16 09:39AM 49.767 EchoService#echo() : sessionId = IHEyAtViGH3J9Et5RT48mg
04-16 09:39AM 49.769 MessageBrokerServlet#service() : end

という感じで、GAE/J 上でも最低限使える環境になったかなと思います。

GAE/J 環境の Application Lifecycle Listener の実験

2010-04-16T08:55:00.003+09:00

最近、GAE/J が Application Lifecycle Listener に対応していないという話を聞きました。現在 GAE 上で BlazeDS を動かそうとしている身としては、これはぜひともはっきりさせておきたいネタです。

ということで、ひとまず BlazeDS が使用している下記の３つのイベントリスナインタフェースを対象に実験してみました。

import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingListener;
import javax.servlet.http.HttpSessionListener;

開発環境上での実行結果

sessionCreated : id = 16es70wx6934m
attributeAdded : name = foo, value = bar
attributeReplaced : name = foo, value = bar
attributeRemoved : name = foo, value = hoge
valueBound : name = fumyo, value = null
attributeAdded : name = fumyo, value = listenertest.ApplicationLifecycleListener@1977b9b
valueUnbound : name = fumyo, value = null
attributeRemoved : name = fumyo, value = listenertest.ApplicationLifecycleListener@1977b9b
sessionDestroyed : id = 16es70wx6934m

本番環境での実行結果

sessionCreated : id = 8xj_3ZWLJhJRl4nrVAzsCw
attributeAdded : name = foo, value = bar
attributeReplaced : name = foo, value = bar
attributeRemoved : name = foo, value = hoge
valueBound : name = fumyo, value = null
attributeAdded : name = fumyo, value = listenertest.ApplicationLifecycleListener@13b625b
valueUnbound : name = fumyo, value = null
attributeRemoved : name = fumyo, value = listenertest.ApplicationLifecycleListener@13b625b
sessionDestroyed : id = 8xj_3ZWLJhJRl4nrVAzsCw

なんと、GAE/J 上で、上記のリスナーは完全に動作しているようです。(｀・ω・´)

テスト用サーブレットのソース

package listenertest;

import java.io.IOException;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@SuppressWarnings("serial")
public class ListenertestServlet extends HttpServlet {
 public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
  HttpSession session = req.getSession(true);
  session.setAttribute("foo", "bar");
  session.setAttribute("foo", "hoge");
  session.removeAttribute("foo");
  session.setAttribute("fumyo", new ApplicationLifecycleListener());
  session.removeAttribute("fumyo");
  session.invalidate();
  resp.setContentType("text/plain");
  resp.getWriter().println("Test complete!");
 }
}

テスト用リスナーのソース

package listenertest;

import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class ApplicationLifecycleListener implements HttpSessionListener, HttpSessionAttributeListener, HttpSessionBindingListener {

 @Override
 public void sessionCreated(HttpSessionEvent event) {
  System.err.println("sessionCreated : id = " + event.getSession().getId());
 }

 @Override
 public void sessionDestroyed(HttpSessionEvent event) {
  System.err.println("sessionDestroyed : id = " + event.getSession().getId());
 }

 @Override
 public void attributeAdded(HttpSessionBindingEvent event) {
  System.err.println("attributeAdded : name = " + event.getName() + ", value = " + event.getValue());
 }

 @Override
 public void attributeRemoved(HttpSessionBindingEvent event) {
  System.err.println("attributeRemoved : name = " + event.getName() + ", value = " + event.getValue());
 }

 @Override
 public void attributeReplaced(HttpSessionBindingEvent event) {
  System.err.println("attributeReplaced : name = " + event.getName() + ", value = " + event.getValue());
 }

 @Override
 public void valueBound(HttpSessionBindingEvent event) {
  System.err.println("valueBound : name = " + event.getName() + ", value = " + event.getValue());
 }

 @Override
 public void valueUnbound(HttpSessionBindingEvent event) {
  System.err.println("valueUnbound : name = " + event.getName() + ", value = " + event.getValue());
 }
}

GAE/J + BlazeDS 4 環境の構築

2010-04-16T03:51:00.006+09:00

今回は GAE/J(Google App Engine Java) と BlazeDS 4 環境の構築方法についてまとめたいと思います。

BlazeDS 3 と同様の環境を構築

基本的な環境は BlazeDS 3 の時とほぼ同じです。そのため、GAE/J + BlazeDS + Flash Builder 環境の構築と同様の手順で作業を行います。

BlazeDS の jar ファイルを持ってくる箇所は行わなくてもかまいません。

BlazeDS 4 のビルド

ソースのチェックアウト

BlazeDS4系は trunk 以下に配置されています。（4.16.2010現在）
ソースは http://opensource.adobe.com/svn/opensource/blazeds/trunk からチェックアウトします。

必要なツール

JDK と ant をそろえましょう。
ant には Ant-Contrib が必要になるため、http://ant-contrib.sourceforge.net/ から取得します（現在の最新は ant-contrib-1.0b2-bin.zip 等）。それを展開後、ant-contrib.jar を ant の lib フォルダ以下にコピーします。

ビルド

trunk 直下で ant main を実行するとビルドが開始されます。

BlazeDS 4 の jar ファイルの取得

BlazeDS 4 のビルドが完了したら、冒頭で準備した Web アプリケーションの WEB-INF/lib 以下に、以下のファイルをコピーします。

trunk/lib/flex-messaging-core.jar
trunk/lib/flex-messaging-common.jar
trunk/lib/flex-messaging-remoting.jar
trunk/lib/flex-rds-server.jar
trunk/lib/xalan.jar
trunk/lib/xercesImpl.jar

※必要に応じて必要なファイルをコピーしましょう。

RDS環境の設定

web.xml に以下の設定を追加します。

<servlet>
  <display-name>RDSDispatchServlet</display-name>
  <servlet-name>RDSDispatchServlet</servlet-name>
  <servlet-class>flex.rds.server.servlet.FrontEndServlet</servlet-class>
  <init-param>
    <param-name>useAppserverSecurity</param-name>
    <param-value>false</param-value>
  </init-param>
  <load-on-startup>10</load-on-startup>
</servlet>

<servlet-mapping id="RDS_DISPATCH_MAPPING">
  <servlet-name>RDSDispatchServlet</servlet-name>
  <url-pattern>/CFIDE/main/ide.cfm</url-pattern>
</servlet-mapping>

これで、GAE開発環境では正しく動作し、GAE本番環境では 1/3 の確率で動作するアプリが完成（のはず）。この問題は、GAE/J + BlazeDS + Flash Builder 環境の構築に書かれているような感じで FlexSession に equals()メソッドと hashCode() メソッドをつけると回避できます。

以上。

作業ログ：BlazeDS4調査

2010-04-16T00:04:00.049+09:00

以下、BlazeDS4調査の作業ログです。

これまで

BlazeDS系について、今まで以下のような作業を行ってきました。

ここまでわかってきたことは、以下のようなことです。

BlazeDS3 を GAE 上で運用するにはいろいろと痛い問題がある。
独自に解決したとしても BLZ-444 により、BlazeDS 3系にバックポートできる可能性はほぼ無い。
逆に、BLZ-444 により、次世代以降の BlazeDS にて GAE をサポートする意思はあると考えられる。

上記からの考察。

BlazeDS3系と今後付き合うメリットは低い。
BlazeDS4系は未知数だが、BlazeDS3だって現状でソースをほとんど読んでるんだから、大差ない。
BlazeDS4系は、開発中なだけに、こちらでの要望が通る可能性が高い。
BlazeDS4系は、データ中心開発系でにぎわい始めてきているので、タイミング的にも悪くない。

結論

将来的な選択肢は、BlazeDS4で行くか、BlazeDSを捨てるか。
BlazeDS4系は、BLZ-444 があることと、現在開発中なのでこちらの意見が通りやすいという点から、これに賭けてみることにする。

BlazeDS4系調査

BlazeDS4系のドキュメントはここからたどれる。
BlazeDS 4.0 Release Notes

data-centric development features of Flash Builder 4 というのが、LCDSを用いた開発を指しているんですね。確かにこんな感じで便利だ。
New Spring / BlazeDS Test Drive Available: Flex 4, BlazeDS 4, and Spring / BlazeDS Integration 1.0.3 も役に立ちそう。後でチェックしよう。

BlazeDS 4.0 Installation Guide

ぱっと見たところ、BlazeDS3とあまり変わらなそう。ということで試してみることにした。
source tree は http://opensource.adobe.com/svn/opensource/blazeds/ から見れる。
基本的に、既存の3.2のプロジェクトに対して、Upgrading BlazeDS 3.2 to version 4.0 の方法を適用すればよさそうだ。
コミット情報のフォーラムがあるんですね。便利だ。

BlazeDS4のコンパイル

ソースは、http://opensource.adobe.com/svn/opensource/blazeds/trunk からチェックアウト。300MB以上あるので結構時間がかかります。
ビルド用のツールは ant っぽいですが、どのバージョンか不明。ということで、とりあえず 1.8.0 で試してみる。
build.xml をかるく見たところ、main というターゲットが全体的なビルドらしいので、実行してみた。見事に失敗。
```
[taskdef] Could not load definitions from resource net/sf/antcontrib/antcontrib.properties. It could not be found.
```
ということで、antcontrib 入れなきゃだめっぽい。
http://ant-contrib.sourceforge.net/ に行って ant-contrib-1.0b2-bin.zip をダウンロードして、ant-contrib.jar を ant の lib フォルダ以下にコピーして、再チャレンジ。今度は成功。

BlazeDS 3.2 のアプリを BlazeDS 4 に対応させる

BlazeDS3.2のころの自分のプロジェクトファイルのバックアップを取り、変更を開始。
まず、BlazeDS3.2用に追加した jar ファイルをすべて削除。
BlazeDS3.2のソースにパッチを当てたものもすべて削除。
具体的にどの jar を追加すればよいかわからないので、とりあえず設定ファイルから先に手をつける。既存の WEB-INF/flex 以下の設定ファイルの名前に.oldをつけ、新規にBlazeDS4のサンプルの定義ファイルをコピー。両者を見比べながら変更しようとおもったが、特に変更する必要はなさそうなので、もとに戻す。
カスタム login command のコンパイルのため（AppServerLoginCommand クラス等が必要なため） flex-messaging-core.jar をコピーし、パスを通す。
flex.messaging.LocalizedException が無いため flex-messaging-common.jar をコピーする。
flex.messaging.services.RemotingService が無いため flex-messaging-remoting.jar をコピーする。
これで、ローカルではあっさり動きました。
今度はGAE上にデプロイして試してみる。
見かけ上、BlazeDS 3.2 上で起きた session の duplication 問題と、logoutをする際の Session 破棄時に HttpSessionListener が働かない問題とほぼ同様の動きをします。
ひとまず、基本的なインストールの作業はこれで終了とします。

RDSを試してみる。

Using Adobe LiveCycle Data Services を読んでみた。
LiveCycle Data Services JAR files と関連 JAR ファイルを WEB-INF/lib ディレクトリに入れる必要があるらしい。取り合えず flex-rds-server.jar が怪しいのでコピーしておく。
WEB-INF/flex 以下の設定ファイルの設定を書くらしい。
MessageBrokerServlet の設定と session listener の設定を WEB-INF/web.xml に書くらしい。って、GAE だと session listener 使えないんだけど、、、。既にダメポな予感 (´・ω・`)
ここまで読んで、これは LiveCycle Data Services 全般の説明だということに気づく。BlazeDS3.2用のドキュメントを一通り読んでいるので、読まなくてもよさそう。ということで、data-centric development にのみフォーカスして情報を収集することにする。
Flex 4 Sample Application using a Java Back-End, BlazeDS 4 and Flash Builder 4 Data Wizards の flex-java-testdrive.zip をダウンロードし、設定をパクることにする。

services-config.xmlの services 要素には

<service class="flex.samples.util.DatabaseService" id="db" />

を追加。

web.xml には次のような設定を追加。

<servlet>
  <display-name>RDSDispatchServlet</display-name>
  <servlet-name>RDSDispatchServlet</servlet-name>
  <servlet-class>flex.rds.server.servlet.FrontEndServlet</servlet-class>
  <init-param>
    <param-name>useAppserverSecurity</param-name>
    <param-value>false</param-value>
  </init-param>
  <load-on-startup>10</load-on-startup>
</servlet>

<servlet-mapping id="RDS_DISPATCH_MAPPING">
  <servlet-name>RDSDispatchServlet</servlet-name>
  <url-pattern>/CFIDE/main/ide.cfm</url-pattern>
</servlet-mapping>

これでコンテナを実行。Flex Builder 4 の Connect to Data/Service のところから接続しに行ってみる。あっさりつなぎこめました。
これでいろいろ実験しようとおもった矢先、Flush Builder 4 が突然不調に。デザインモードを開こうとおもうといきなり VM が落ちる状況に(´・ω・`)
この件は、FlashBuilder4の再インストールで解決。

これでやっと、BlazeDS4のGAE対応作業の前準備ができました。

GAE/J + BlazeDS3 環境の HttpSessionListener 問題

2010-04-15T10:01:00.005+09:00

最近、GAE/J 環境では HttpSessionListener は効かないらしいという話を聞きました。

http://groups.google.com/group/google-appengine-java/browse_thread/thread/672879dd9a3ba137の下記の発言から、ローカルの環境で動くのがバグであることがわかります。

Hi Erum. App Engine doesn't support this callback, so when sessionDestroyed
is triggered by the development server, it's not within an active request
and hence the exception that you're seeing. In the production environment,
you would see a similar result if the callback is even triggered at all.

The fact that the development server does trigger sessionDestroyed is a bug
in the SDK. Please file a new report in our public tracker, and I'm sorry
for the bad news.

これがもし本当なら、GAE 上で BlazeDS を使うのは結構厳しそうな気がします。

一例ですが、BlazeDS 3.2 のHttpFlexSession では、以下のようにライフサイクルイベントを前提としたコードがそれなりにあります。どうしたものか (´・ω・`)

/**
 * Implements HttpSessionListener.
 * When an HttpSession is destroyed, the associated HttpFlexSession is also destroyed.
 * NOTE: This method is not invoked against an HttpFlexSession associated with a request
 * handling thread.
 */
public void sessionDestroyed(HttpSessionEvent event)
{
    HttpSession session = event.getSession();
    Map httpSessionToFlexSessionMap = getHttpSessionToFlexSessionMap(session);
    HttpFlexSession flexSession = (HttpFlexSession)httpSessionToFlexSessionMap.remove(session.getId());
    if (flexSession != null)
    {
        // invalidate the flex session
        flexSession.superInvalidate();

        // Send notifications to attribute listeners if needed
        // This may send extra notifications if attributeRemoved is called first by the server,
        // but Java servlet 2.4 says session destroy is first, then attributes.
        for (Enumeration e = session.getAttributeNames(); e.hasMoreElements(); )
        {
            String name = (String) e.nextElement();
            if (name.equals(SESSION_ATTRIBUTE))
                continue;
            Object value = session.getAttribute(name);
            if (value != null)
            {
                flexSession.notifyAttributeUnbound(name, value);
                flexSession.notifyAttributeRemoved(name, value);
            }
        }
    }

}

しかし、本当にそうなのか？

ということで、GAE/J 環境の Application Lifecycle Listener の実験をしてみました。

JDO の Query を Generics に対応させてみた。

2010-04-15T03:17:00.001+09:00

javax.jdo.Query interface の execute() メソッドは戻り値が java.lang.Object 型なので、以下のようにキャストする必要があります。

Collection<User> users = (Collection<User>)query.execute();

でも、めんどくさいです。(´・ω・`)

しかも、キャストのところでコンパイラが警告を出します。

@SuppressWarning("unchecked") とか書けば警告は消えますが。

でも、めんどくさいです。(´・ω・`)

ということで、execute系メソッドの引数として型変数を渡せるようなクラスを作成してみました。

PersistenceManagerExt.java

package com.objectfanatics.gae.datastore;

import java.util.Collection;
import java.util.Date;
import java.util.EnumSet;
import java.util.Set;

import javax.jdo.Extent;
import javax.jdo.FetchGroup;
import javax.jdo.FetchPlan;
import javax.jdo.JDOException;
import javax.jdo.ObjectState;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;
import javax.jdo.Transaction;
import javax.jdo.datastore.JDOConnection;
import javax.jdo.datastore.Sequence;
import javax.jdo.listener.InstanceLifecycleListener;

/**
 * PersistenceManager for QueryExt.
 */
public class PersistenceManagerExt implements PersistenceManager {
 
 /**
  * PersistenceManager instance to be delegated.
  */
 private final PersistenceManager instance;
 
 /**
  * Constructor.
  * 
  * @param instance instance to be delegated
  */
 public PersistenceManagerExt(PersistenceManager instance) {
  this.instance = instance;
 }
 
 // for generics
 @SuppressWarnings("unchecked")
 @Override
 public QueryExt newNamedQuery(Class cls, String filter) {
  return new QueryExt(instance.newNamedQuery(cls, filter));
 }
 @Override
 public QueryExt newQuery() {
  return new QueryExt(instance.newQuery());
 }
 @SuppressWarnings("unchecked")
 @Override
 public QueryExt newQuery(Class cls, Collection cln, String filter) {
  return new QueryExt(instance.newQuery(cls, cln, filter));
 }
 @SuppressWarnings("unchecked")
 @Override
 public QueryExt newQuery(Class cls, Collection cln) {
  return new QueryExt(instance.newQuery(cls, cln));
 }
 @SuppressWarnings("unchecked")
 @Override
 public QueryExt newQuery(Class cls, String filter) {
  return new QueryExt(instance.newQuery(cls, filter));
 }
 @SuppressWarnings("unchecked")
 @Override
 public QueryExt newQuery(Class cls) {
  return new QueryExt(instance.newQuery(cls));
 }
 @SuppressWarnings("unchecked")
 @Override
 public QueryExt newQuery(Extent cln, String filter) {
  return new QueryExt(instance.newQuery(cln, filter));
 }
 @SuppressWarnings("unchecked")
 @Override
 public QueryExt newQuery(Extent cln) {
  return new QueryExt(instance.newQuery(cln));
 }
 @Override
 public QueryExt newQuery(Object compiled) {
  return new QueryExt(instance.newQuery(compiled));
 }
 @Override
 public QueryExt newQuery(String language, Object query) {
  return new QueryExt(instance.newQuery(language, query));
 }
 @Override
 public QueryExt newQuery(String query) {
  return new QueryExt(instance.newQuery(query));
 }
 
 // delegate methods.
 @SuppressWarnings("unchecked")
 @Override
 public void addInstanceLifecycleListener(InstanceLifecycleListener listener, Class... classes) {
  instance.addInstanceLifecycleListener(listener, classes);
 }
 @Override
 public void checkConsistency() {
  instance.checkConsistency();
 }
 @Override
 public void close() {
  instance.close();
 }
 @Override
 public Transaction currentTransaction() {
  return instance.currentTransaction();
 }
 @Override
 public void deletePersistent(Object pc) {
  instance.deletePersistent(pc);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void deletePersistentAll(Collection pcs) {
  instance.deletePersistentAll(pcs);
 }
 @Override
 public void deletePersistentAll(Object... pcs) {
  instance.deletePersistentAll(pcs);
 }
 @Override
 public <T> T detachCopy(T pc) {
  return instance.detachCopy(pc);
 }
 @Override
 public <T> Collection<T> detachCopyAll(Collection<T> pcs) {
  return instance.detachCopyAll(pcs);
 }
 @Override
 public <T> T[] detachCopyAll(T... pcs) {
  return instance.detachCopyAll(pcs);
 }
 @Override
 public void evict(Object pc) {
  instance.evict(pc);
 }
 @Override
 public void evictAll() {
  instance.evictAll();
 }
 @SuppressWarnings("unchecked")
 @Override
 public void evictAll(boolean subclasses, Class pcClass) {
  instance.evictAll(subclasses, pcClass);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void evictAll(Collection pcs) {
  instance.evictAll(pcs);
 }
 @Override
 public void evictAll(Object... pcs) {
  instance.evictAll(pcs);
 }
 @Override
 public void flush() {
  instance.flush();
 }
 @Override
 public boolean getCopyOnAttach() {
  return instance.getCopyOnAttach();
 }
 @Override
 public JDOConnection getDataStoreConnection() {
  return instance.getDataStoreConnection();
 }
 @Override
 public boolean getDetachAllOnCommit() {
  return instance.getDetachAllOnCommit();
 }
 @Override
 public <T> Extent<T> getExtent(Class<T> persistenceCapableClass, boolean subclasses) {
  return instance.getExtent(persistenceCapableClass, subclasses);
 }
 @Override
 public <T> Extent<T> getExtent(Class<T> persistenceCapableClass) {
  return instance.getExtent(persistenceCapableClass);
 }
 @SuppressWarnings("unchecked")
 @Override
 public FetchGroup getFetchGroup(Class cls, String name) {
  return instance.getFetchGroup(cls, name);
 }
 @Override
 public FetchPlan getFetchPlan() {
  return instance.getFetchPlan();
 }
 @Override
 public boolean getIgnoreCache() {
  return instance.getIgnoreCache();
 }
 @SuppressWarnings("unchecked")
 @Override
 public Set getManagedObjects() {
  return instance.getManagedObjects();
 }
 @SuppressWarnings("unchecked")
 @Override
 public Set getManagedObjects(Class... classes) {
  return instance.getManagedObjects(classes);
 }
 @SuppressWarnings("unchecked")
 @Override
 public Set getManagedObjects(EnumSet<ObjectState> states, Class... classes) {
  return instance.getManagedObjects(states, classes);
 }
 @SuppressWarnings("unchecked")
 @Override
 public Set getManagedObjects(EnumSet<ObjectState> states) {
  return instance.getManagedObjects(states);
 }
 @Override
 public boolean getMultithreaded() {
  return instance.getMultithreaded();
 }
 @Override
 public <T> T getObjectById(Class<T> cls, Object key) {
  return instance.getObjectById(cls, key);
 }
 @Override
 public Object getObjectById(Object oid, boolean validate) {
  return instance.getObjectById(oid, validate);
 }
 @Override
 public Object getObjectById(Object oid) {
  return instance.getObjectById(oid);
 }
 @Override
 public Object getObjectId(Object pc) {
  return instance.getObjectId(pc);
 }
 @SuppressWarnings("unchecked")
 @Override
 public Class getObjectIdClass(Class cls) {
  return instance.getObjectIdClass(cls);
 }
 @Override
 public Object[] getObjectsById(boolean validate, Object... oids) {
  return instance.getObjectsById(validate, oids);
 }
 @SuppressWarnings("unchecked")
 @Override
 public Collection getObjectsById(Collection oids, boolean validate) {
  return instance.getObjectsById(oids, validate);
 }
 @SuppressWarnings("unchecked")
 @Override
 public Collection getObjectsById(Collection oids) {
  return instance.getObjectsById(oids);
 }
 @Override
 public Object[] getObjectsById(Object... oids) {
  return instance.getObjectsById(oids);
 }
 @SuppressWarnings("deprecation")
 @Override
 public Object[] getObjectsById(Object[] oids, boolean validate) {
  return instance.getObjectsById(oids, validate);
 }
 @Override
 public PersistenceManagerFactory getPersistenceManagerFactory() {
  return instance.getPersistenceManagerFactory();
 }
 @Override
 public Integer getQueryTimeoutMillis() {
  return instance.getQueryTimeoutMillis();
 }
 @Override
 public Sequence getSequence(String name) {
  return instance.getSequence(name);
 }
 @Override
 public Date getServerDate() {
  return instance.getServerDate();
 }
 @Override
 public Object getTransactionalObjectId(Object pc) {
  return instance.getTransactionalObjectId(pc);
 }
 @Override
 public Object getUserObject() {
  return instance.getUserObject();
 }
 @Override
 public Object getUserObject(Object key) {
  return instance.getUserObject(key);
 }
 @Override
 public boolean isClosed() {
  return instance.isClosed();
 }
 @Override
 public void makeNontransactional(Object pc) {
  instance.makeNontransactional(pc);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void makeNontransactionalAll(Collection pcs) {
  instance.makeNontransactionalAll(pcs);
 }
 @Override
 public void makeNontransactionalAll(Object... pcs) {
  instance.makeNontransactionalAll(pcs);
 }
 @Override
 public <T> T makePersistent(T pc) {
  return instance.makePersistent(pc);
 }
 @Override
 public <T> Collection<T> makePersistentAll(Collection<T> pcs) {
  return instance.makePersistentAll(pcs);
 }
 @Override
 public <T> T[] makePersistentAll(T... pcs) {
  return instance.makePersistentAll(pcs);
 }
 @Override
 public void makeTransactional(Object pc) {
  instance.makeTransactional(pc);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void makeTransactionalAll(Collection pcs) {
  instance.makeTransactionalAll(pcs);
 }
 @Override
 public void makeTransactionalAll(Object... pcs) {
  instance.makeTransactionalAll(pcs);
 }
 @Override
 public void makeTransient(Object pc, boolean useFetchPlan) {
  instance.makeTransient(pc, useFetchPlan);
 }
 @Override
 public void makeTransient(Object pc) {
  instance.makeTransient(pc);
 }
 @Override
 public void makeTransientAll(boolean useFetchPlan, Object... pcs) {
  instance.makeTransientAll(useFetchPlan, pcs);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void makeTransientAll(Collection pcs, boolean useFetchPlan) {
  instance.makeTransientAll(pcs, useFetchPlan);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void makeTransientAll(Collection pcs) {
  instance.makeTransientAll(pcs);
 }
 @Override
 public void makeTransientAll(Object... pcs) {
  instance.makeTransientAll(pcs);
 }
 @SuppressWarnings("deprecation")
 @Override
 public void makeTransientAll(Object[] pcs, boolean useFetchPlan) {
  instance.makeTransientAll(pcs, useFetchPlan);
 }
 @Override
 public <T> T newInstance(Class<T> pcClass) {
  return instance.newInstance(pcClass);
 }
 @SuppressWarnings("unchecked")
 @Override
 public Object newObjectIdInstance(Class pcClass, Object key) {
  return instance.newObjectIdInstance(pcClass, key);
 }
 @Override
 public Object putUserObject(Object key, Object val) {
  return instance.putUserObject(key, val);
 }
 @Override
 public void refresh(Object pc) {
  instance.refresh(pc);
 }
 @Override
 public void refreshAll() {
  instance.refreshAll();
 }
 @SuppressWarnings("unchecked")
 @Override
 public void refreshAll(Collection pcs) {
  instance.refreshAll(pcs);
 }
 @Override
 public void refreshAll(JDOException jdoe) {
  instance.refreshAll(jdoe);
 }
 @Override
 public void refreshAll(Object... pcs) {
  instance.refreshAll(pcs);
 }
 @Override
 public void removeInstanceLifecycleListener(InstanceLifecycleListener listener) {
  instance.removeInstanceLifecycleListener(listener);
 }
 @Override
 public Object removeUserObject(Object key) {
  return instance.removeUserObject(key);
 }
 @Override
 public void retrieve(Object pc, boolean useFetchPlan) {
  instance.retrieve(pc, useFetchPlan);
 }
 @Override
 public void retrieve(Object pc) {
  instance.retrieve(pc);
 }
 @Override
 public void retrieveAll(boolean useFetchPlan, Object... pcs) {
  instance.retrieveAll(useFetchPlan, pcs);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void retrieveAll(Collection pcs, boolean useFetchPlan) {
  instance.retrieveAll(pcs, useFetchPlan);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void retrieveAll(Collection pcs) {
  instance.retrieveAll(pcs);
 }
 @Override
 public void retrieveAll(Object... pcs) {
  instance.retrieveAll(pcs);
 }
 @SuppressWarnings("deprecation")
 @Override
 public void retrieveAll(Object[] pcs, boolean useFetchPlan) {
  instance.retrieveAll(pcs, useFetchPlan);
 }
 @Override
 public void setCopyOnAttach(boolean flag) {
  instance.setCopyOnAttach(flag);
 }
 @Override
 public void setDetachAllOnCommit(boolean flag) {
  instance.setDetachAllOnCommit(flag);
 }
 @Override
 public void setIgnoreCache(boolean flag) {
  instance.setIgnoreCache(flag);
 }
 @Override
 public void setMultithreaded(boolean flag) {
  instance.setMultithreaded(flag);
 }
 @Override
 public void setQueryTimeoutMillis(Integer interval) {
  instance.setQueryTimeoutMillis(interval);
 }
 @Override
 public void setUserObject(Object o) {
  instance.setUserObject(o);
 }
}

QueryExt.java

package com.objectfanatics.gae.datastore;

import java.util.Collection;
import java.util.Map;

import javax.jdo.Extent;
import javax.jdo.FetchPlan;
import javax.jdo.PersistenceManager;
import javax.jdo.Query;

/**
 * Generics enabled Query extension.
 */
public class QueryExt implements Query {
 
 /**
  * Query instance to be delegated.
  */
 private final Query instanceToBeDelegated;
 
 /**
  * Constructor.
  * @param instanceToBeDelegated Query instance to be delegated
  */
 public QueryExt(Query instanceToBeDelegated) {
  if (instanceToBeDelegated == null) throw new IllegalArgumentException("instanceToBeDelegated must not be null.");
  this.instanceToBeDelegated = instanceToBeDelegated;
 }
 
 // for generics.
 @SuppressWarnings("unchecked")
 public <T> Collection<T> executeExt(Class<T> t) {
  return (Collection<T>)instanceToBeDelegated.execute();
 }
 @SuppressWarnings("unchecked")
 public <T> Collection<T> executeExt(Class<T> t, Object p1, Object p2, Object p3) {
  return (Collection<T>)instanceToBeDelegated.execute(p1, p2, p3);
 }
 @SuppressWarnings("unchecked")
 public <T> Collection<T> executeExt(Class<T> t, Object p1, Object p2) {
  return (Collection<T>)instanceToBeDelegated.execute(p1, p2);
 }
 @SuppressWarnings("unchecked")
 public <T> Collection<T> executeExt(Class<T> t, Object p1) {
  return (Collection<T>)instanceToBeDelegated.execute(p1);
 }
 @SuppressWarnings("unchecked")
 public <T> Collection<T> executeWithArrayExt(Class<T> t, Object... parameters) {
  return (Collection<T>)instanceToBeDelegated.executeWithArray(parameters);
 }
 @SuppressWarnings("unchecked")
 public <T> Collection<T> executeWithMapExt(Class<T> t, Map parameters) {
  return (Collection<T>)instanceToBeDelegated.executeWithMap(parameters);
 }
 
 // delegate methods.
 @Override
 public void addExtension(String key, Object value) {
  instanceToBeDelegated.addExtension(key, value);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void addSubquery(Query sub, String variableDeclaration, String candidateCollectionExpression, Map parameters) {
  instanceToBeDelegated.addSubquery(sub, variableDeclaration, candidateCollectionExpression, parameters);
 }
 @Override
 public void addSubquery(Query sub, String variableDeclaration, String candidateCollectionExpression, String... parameters) {
  instanceToBeDelegated.addSubquery(sub, variableDeclaration, candidateCollectionExpression, parameters);
 }
 @Override
 public void addSubquery(Query sub, String variableDeclaration, String candidateCollectionExpression, String parameter) {
  instanceToBeDelegated.addSubquery(sub, variableDeclaration, candidateCollectionExpression, parameter);
 }
 @Override
 public void addSubquery(Query sub, String variableDeclaration, String candidateCollectionExpression) {
  instanceToBeDelegated.addSubquery(sub, variableDeclaration, candidateCollectionExpression);
 }
 @Override
 public void cancel(Thread thread) {
  instanceToBeDelegated.cancel(thread);
 }
 @Override
 public void cancelAll() {
  instanceToBeDelegated.cancelAll();
 }
 @Override
 public void close(Object queryResult) {
  instanceToBeDelegated.close(queryResult);
 }
 @Override
 public void closeAll() {
  instanceToBeDelegated.closeAll();
 }
 @Override
 public void compile() {
  instanceToBeDelegated.compile();
 }
 @Override
 public void declareImports(String imports) {
  instanceToBeDelegated.declareImports(imports);
 }
 @Override
 public void declareParameters(String parameters) {
  instanceToBeDelegated.declareParameters(parameters);
 }
 @Override
 public void declareVariables(String variables) {
  instanceToBeDelegated.declareVariables(variables);
 }
 @Override
 public long deletePersistentAll() {
  return instanceToBeDelegated.deletePersistentAll();
 }
 @SuppressWarnings("unchecked")
 @Override
 public long deletePersistentAll(Map parameters) {
  return instanceToBeDelegated.deletePersistentAll(parameters);
 }
 @Override
 public long deletePersistentAll(Object... parameters) {
  return instanceToBeDelegated.deletePersistentAll(parameters);
 }
 @Override
 public Object execute() {
  return instanceToBeDelegated.execute();
 }
 @Override
 public Object execute(Object p1, Object p2, Object p3) {
  return instanceToBeDelegated.execute(p1, p2, p3);
 }
 @Override
 public Object execute(Object p1, Object p2) {
  return instanceToBeDelegated.execute(p1, p2);
 }
 @Override
 public Object execute(Object p1) {
  return instanceToBeDelegated.execute(p1);
 }
 @Override
 public Object executeWithArray(Object... parameters) {
  return instanceToBeDelegated.executeWithArray(parameters);
 }
 @SuppressWarnings("unchecked")
 @Override
 public Object executeWithMap(Map parameters) {
  return instanceToBeDelegated.executeWithMap(parameters);
 }
 @Override
 public FetchPlan getFetchPlan() {
  return instanceToBeDelegated.getFetchPlan();
 }
 @Override
 public boolean getIgnoreCache() {
  return instanceToBeDelegated.getIgnoreCache();
 }
 @Override
 public PersistenceManager getPersistenceManager() {
  return instanceToBeDelegated.getPersistenceManager();
 }
 @Override
 public Boolean getSerializeRead() {
  return instanceToBeDelegated.getSerializeRead();
 }
 @Override
 public Integer getTimeoutMillis() {
  return instanceToBeDelegated.getTimeoutMillis();
 }
 @Override
 public boolean isUnmodifiable() {
  return instanceToBeDelegated.isUnmodifiable();
 }
 @SuppressWarnings("unchecked")
 @Override
 public void setCandidates(Collection pcs) {
  instanceToBeDelegated.setCandidates(pcs);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void setCandidates(Extent pcs) {
  instanceToBeDelegated.setCandidates(pcs);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void setClass(Class cls) {
  instanceToBeDelegated.setClass(cls);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void setExtensions(Map extensions) {
  instanceToBeDelegated.setExtensions(extensions);
 }
 @Override
 public void setFilter(String filter) {
  instanceToBeDelegated.setFilter(filter);
 }
 @Override
 public void setGrouping(String group) {
  instanceToBeDelegated.setGrouping(group);
 }
 @Override
 public void setIgnoreCache(boolean ignoreCache) {
  instanceToBeDelegated.setIgnoreCache(ignoreCache);
 }
 @Override
 public void setOrdering(String ordering) {
  instanceToBeDelegated.setOrdering(ordering);
 }
 @Override
 public void setRange(long fromIncl, long toExcl) {
  instanceToBeDelegated.setRange(fromIncl, toExcl);
 }
 @Override
 public void setRange(String fromInclToExcl) {
  instanceToBeDelegated.setRange(fromInclToExcl);
 }
 @Override
 public void setResult(String data) {
  instanceToBeDelegated.setResult(data);
 }
 @SuppressWarnings("unchecked")
 @Override
 public void setResultClass(Class cls) {
  instanceToBeDelegated.setResultClass(cls);
 }
 @Override
 public void setSerializeRead(Boolean serialize) {
  instanceToBeDelegated.setSerializeRead(serialize);
 }
 @Override
 public void setTimeoutMillis(Integer interval) {
  instanceToBeDelegated.setTimeoutMillis(interval);
 }
 @Override
 public void setUnique(boolean unique) {
  instanceToBeDelegated.setUnique(unique);
 }
 @Override
 public void setUnmodifiable() {
  instanceToBeDelegated.setUnmodifiable();
 }
}

PersistenceManager のいくつかの newQuery() 系のメソッドは引数でエンティティの型を受け取っているので、それを利用すれば QueryExt<T> のような形でエンティティの型を渡すこともできそうですね。要検討ということで。

Flex でカスタムコンポーネントを作成してみた

2010-04-13T08:23:00.008+09:00

Flex でカスタムコンポーネントを作ってみました。

お題

今回は、ありがちな感じのログイン用の画面を題材に選んでみました。

オブジェクト指向っぽく考えてみた。

まずば、カスタムコンポーネントをブラックボックスと考えてみたときに、外部にどのような機能を公開すべきか考えてみました。

とりあえず、サンプルとしては以下の機能があればいいかな。

userName:String
ユーザー名入力用コンポーネントとの双方向バインドされた bindable な変数
password:String
パスワード入力用コンポーネントとの双方向バインドされた bindable な変数
loginBtn_clickHandler:Function
ログインボタンをクリックしたときに呼び出される関数を外部からセットするための変数。
clear()
ユーザー名入力用コンポーネントとパスワード入力用コンポーネントのクリア用関数
showErrorMessage(message:String)
エラーメッセージ表示用関数

公開する変数については、変数自体が bindable でありながら、その変数自体もコンポーネントのテキストと双方向にバインドされているというのがミソですね。

関数のハンドラについては、Function 型の変数としました。本当は関数のシグニチャをインタフェースのように定義して厳密な型指定をしたかったのですが、できなさそうなので、、、。できるのかな？

サンプルコンポーネント（LoginBox）

ユーザー名とパスワードの入力フィールドとログインボタンを持つシンプルなログイン画面です。

LoginBox.mxml

<?xml version="1.0" encoding="utf-8"?>
<s:Group xmlns:fx="http://ns.adobe.com/mxml/2009" 
   xmlns:s="library://ns.adobe.com/flex/spark" 
   xmlns:mx="library://ns.adobe.com/flex/mx">
 <s:layout>
  <s:VerticalLayout horizontalAlign="center" verticalAlign="middle"/>
 </s:layout>
 <fx:Script>
  <![CDATA[
   import mx.controls.Alert;
   import mx.effects.Effect;
   import mx.effects.Fade;
   [Bindable]
   /**
    * user name.
    */
   public var userName:String;
   
   [Bindable]
   /**
    * password.
    */
   public var password:String;
   
   /**
    * Login handler.
    * 
    * This handler is invoked when login button is clicked.
    */
   public var loginBtn_clickHandler:Function;
   
   /**
    * Clear user name, password and error message.
    */
   public function clear():void {
    userNameTextInput.text = "";
    passwordTextInput.text = "";
    errorMessageLabel.visible = false;
   }
   
   /**
    * Show error message.// TODO: エラー失敗時のハンドラという名前のほうが正解？要検討。
    */
   public function showErrorMessage(message:String):void {
    errorMessageLabel.visible = true;
    errorMessageLabel.text = message;
   }
  ]]>
 </fx:Script>

 <!-- Bi-directional Bindings -->
 <fx:Binding source="userNameTextInput.text" destination="userName"/>
 <fx:Binding source="userName" destination="userNameTextInput.text"/>
 <fx:Binding source="passwordTextInput.text" destination="password"/>
 <fx:Binding source="password" destination="passwordTextInput.text"/>
 
 <!-- Visual Components -->
 <mx:Form fontFamily="Courier New" defaultButton="{loginBtn}">
  <mx:FormItem label="username">
   <mx:TextInput id="userNameTextInput" focusIn="IME.enabled = false;userNameTextInput.setSelection(0,userNameTextInput.text.length)"/>
  </mx:FormItem>
  <mx:FormItem label="password">
   <mx:TextInput displayAsPassword="true" id="passwordTextInput" focusIn="IME.enabled = false;passwordTextInput.setSelection(0,passwordTextInput.text.length)" keyDown="IME.enabled = false"/>
  </mx:FormItem>
 </mx:Form>
 <s:Label id="errorMessageLabel" text="Login failed" color="red" visible="false" hideEffect="{Fade}"/>
 <s:HGroup>
  <s:Button label="Login" id="loginBtn" click="loginBtn_clickHandler(event)"/>
  <s:Button label="Clear" id="clearBtn" click="clear()"/>
 </s:HGroup>
</s:Group>

サンプル用コンポーネントのテスト用アプリ（LoginBoxTest）

LoginBox コンポーネントを試すためのアプリです。

username = foo, password = bar の時以外はログイン失敗メソッドを呼び出すハンドラを設定しています。

LoginBoxTest.mxml

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
      xmlns:s="library://ns.adobe.com/flex/spark" 
      xmlns:mx="library://ns.adobe.com/flex/mx" xmlns:component="component.*" width="100%" height="100%" creationComplete="init()">
 <s:layout>
  <s:VerticalLayout horizontalAlign="center" verticalAlign="middle"/>
 </s:layout>

 <fx:Script>
  <![CDATA[   
   import mx.controls.Alert;
   
   // test for loginBox.loginBtn_clickHandler
   private function init():void {
    loginBox.loginBtn_clickHandler = function(event:MouseEvent):void {
     Alert.show("Login button clicked.\nusername = "+loginBox.userName+"\npassword = "+loginBox.password+"\nPos = ("+event.localX+", "+event.localY+")", "Assigned Method from Outer Component");
     if (loginBox.userName != "foo" || loginBox.password != "bar") loginBox.showErrorMessage("Login Failed");
    };
   }
   
   // test for loginBox.clear()
   protected function button1_clickHandler(event:MouseEvent):void {
    loginBox.clear();
   }
  ]]>
 </fx:Script>
 
 <!-- bi-directional bind test for userName valiable. -->
 <fx:Binding source="userNameTextInput.text" destination="loginBox.userName"/>
 
 <!-- bi-directional bind test for password valiable. -->
 <fx:Binding source="passwordTextInput.text" destination="loginBox.password"/>
 
 <s:Label text="Test for LoginBox" fontSize="24"/>
 <mx:Form>
  
  <!-- bi-directional bind test for userName valiable. -->
  <mx:FormItem label="bi-directional bind test for userName valiable">
   <mx:TextInput id="userNameTextInput" focusIn="IME.enabled = false" text="{loginBox.userName}"/>
  </mx:FormItem>
  
  <!-- bi-directional bind test for password valiable. -->
  <mx:FormItem label="bi-directional bind test for password valiable">
   <mx:TextInput id="passwordTextInput" focusIn="IME.enabled = false" text="{loginBox.password}"/>
  </mx:FormItem>
  
  <!-- clear method test -->
  <mx:FormItem label="clear method test">
   <s:Button label="Clear" click="button1_clickHandler(event)"/>
  </mx:FormItem>
 </mx:Form>
 
 <component:LoginBox id="loginBox"/>
</s:Application>

作業ログ : BlazeDS のカスタム LoginCommand がなぜかうまく動かなくて調べた時のログ

2010-04-12T00:46:00.001+09:00

BlazeDS のカスタム LoginCommand がなぜかうまく動かなくて調べた時のログ

経緯

GAE/J + BlazeDS 環境の Security 設定を書いているときにハマった時のログ。

とりあえずのゴール

何が分からないのかも分からない状態なので、とりあえずいろいろ調べてみることにしよう。

Integrating Spring Security with BlazeDS and Flex RIAsを読んでみた
Integrating Spring Security with BlazeDS and Flex RIAs

とりあえず、Integrating Spring Security with BlazeDS and Flex RIAsを見て、実際に security 系の機能を利用する側の雰囲気をつかんでみる。

この記事は spring-flex が正式にリリースされる前に書かれた Spring Security + BlazeDS + Flex 環境についてのまとめ記事。
環境は以下を前提としている。

Spring 2.5.5
Spring-Security 2.0.4 (core & tiger)
BlazeDS 3.2
Flex3

この記事は、end-point に対してセキュリティをかける目的は持っておらず、メソッド呼び出しレベルでセキュリティをかけることを目的としている。
BlazeDS は user の credential を request から取得し、それを SpingSecurity に渡して SecureContext が作成され、認証され、 ThreadLocal 中の SecureContext に認証情報が格納される。その後、普通に SpringSecurity が普通にメソッドを保護する。→ 実際に接続の受諾や拒否を行う部分を SpringSecurity にやらせてしまうわけですね。
BlazeDS の持つサーバ側の session 管理機能を一切使わず、自分で実装しようとしてるのかな？
Step1:maven の pom.xml を設定して jar を取得する。
Step2:amf のアクセスを org.springframework.web.filter.DelegatingFilterProxy で受けるように web.xml を設定する。
Step3:Spring Security の設定をする。
Step4:Spring Security に対応した flex.messaging.security.LoginCommand を実装する。
Step5:services-config.xml に設定する。

基本的に、GAE/J + BlazeDS 環境の Security 設定でハマった時と同じ方法ですね。今回の件の問題解決には関係なさそう。

GAE 上でうまくセキュリティが動作しない件の調査

spring-flex を使ってみてもいいけど、っていうか使う予定ではいるけど、現状の問題の原因がわからないままというのもなんなので、もうちょっと調べてみた。

ローカル環境にて、セキュリティ関連の動作を追ってみた。とりあえず、printStackTrace() を埋め込んでみました。

以下、ログイン時のカスタムLoginCommandまでの流れ。

java.lang.Exception: This is only a test.
 at security.CustomLoginCommand.doAuthentication(CustomLoginCommand.java:12)
 at flex.messaging.security.LoginManager.login(LoginManager.java:206)
 at flex.messaging.services.AuthenticationService.decodeAndLoginWithCharset(AuthenticationService.java:131)
 at flex.messaging.services.AuthenticationService.serviceCommand(AuthenticationService.java:81)
 at flex.messaging.MessageBroker.routeCommandToService(MessageBroker.java:1605)
 at flex.messaging.endpoints.AbstractEndpoint.serviceMessage(AbstractEndpoint.java:861)
 at flex.messaging.endpoints.amf.MessageBrokerFilter.invoke(MessageBrokerFilter.java:121)
 at flex.messaging.endpoints.amf.LegacyFilter.invoke(LegacyFilter.java:158)
 at flex.messaging.endpoints.amf.SessionFilter.invoke(SessionFilter.java:44)
 at flex.messaging.endpoints.amf.BatchProcessFilter.invoke(BatchProcessFilter.java:67)
 at flex.messaging.endpoints.amf.SerializationFilter.invoke(SerializationFilter.java:146)
 at flex.messaging.endpoints.BaseHTTPEndpoint.service(BaseHTTPEndpoint.java:278)
 at flex.messaging.MessageBrokerServlet.service(MessageBrokerServlet.java:322)
 at javax.servlet.http.HttpServlet.service(HttpServlet.java:806)
 at org.mortbay.jetty.servlet.ServletHolder.handle(ServletHolder.java:511)
 at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1166)
 at com.google.appengine.api.blobstore.dev.ServeBlobFilter.doFilter(ServeBlobFilter.java:51)
 at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1157)
 at com.google.apphosting.utils.servlet.TransactionCleanupFilter.doFilter(TransactionCleanupFilter.java:43)
 at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1157)
 at com.google.appengine.tools.development.StaticFileFilter.doFilter(StaticFileFilter.java:122)
 at org.mortbay.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1157)
 at org.mortbay.jetty.servlet.ServletHandler.handle(ServletHandler.java:388)
 at org.mortbay.jetty.security.SecurityHandler.handle(SecurityHandler.java:216)
 at org.mortbay.jetty.servlet.SessionHandler.handle(SessionHandler.java:182)
 at org.mortbay.jetty.handler.ContextHandler.handle(ContextHandler.java:765)
 at org.mortbay.jetty.webapp.WebAppContext.handle(WebAppContext.java:418)
 at com.google.apphosting.utils.jetty.DevAppEngineWebAppContext.handle(DevAppEngineWebAppContext.java:70)
 at org.mortbay.jetty.handler.HandlerWrapper.handle(HandlerWrapper.java:152)
 at com.google.appengine.tools.development.JettyContainerService$ApiProxyHandler.handle(JettyContainerService.java:349)
 at org.mortbay.jetty.handler.HandlerWrapper.handle(HandlerWrapper.java:152)
 at org.mortbay.jetty.Server.handle(Server.java:326)
 at org.mortbay.jetty.HttpConnection.handleRequest(HttpConnection.java:542)
 at org.mortbay.jetty.HttpConnection$RequestHandler.content(HttpConnection.java:938)
 at org.mortbay.jetty.HttpParser.parseNext(HttpParser.java:755)
 at org.mortbay.jetty.HttpParser.parseAvailable(HttpParser.java:218)
 at org.mortbay.jetty.HttpConnection.handle(HttpConnection.java:404)
 at org.mortbay.io.nio.SelectChannelEndPoint.run(SelectChannelEndPoint.java:409)
 at org.mortbay.thread.QueuedThreadPool$PoolThread.run(QueuedThreadPool.java:582)

GAE上での動作についてメモ

GAE上では、ログイン後の動作にて、LoginManager.getCurrentPrincipal() が null を返している。ということは、ログイン時の CurrentPrincipal の格納に問題があるのか、取得時に問題があるのかのどちらかと考えられる。
ローカル上では、ログイン時には、ログインの認証が成功した後に FlexSession.setUserPrincipal() が呼び出されている。その後普通にセキュリティ制約のあるアクセスしてみたところ、FlexSession.setUserPrincipal() は呼ばれていない。サーバ上でオンメモリで保存されてもシリアライズを介したとしても、この動作は納得。しかし、HttpSessionレベルではどうなっているのだろうか？FlexSessionとSessionの関係ってどうなってるんだろ？
FlexSessionは、HttpSession に "__flexSession" という属性名で格納される。
GAE の Session をいろいろいじってみたのだが、普通に session に属性を set/get するのは問題なく動作するし、FlexSesson が session に保存されていることも確認したし、HttpFlexSession のインスタンスがシリアライズ/デシリアライズされているらしいことも確認(toString()の@以下の番号が変化することで確認)した。となると、FlexSession か Principal のシリアライズ/デシリアライズが問題？
ローカルで普通に FlexSession をシリアライズ/デシリアライズしたら、getUserPrincipal() がnullになりました。ということは、GAEの問題じゃないですね。
調べてみたら、HttpFlexSession#writeObject() メソッドが、例外を握りつぶしていました。例外の内容は、CustomLoginCommand が Serializable でないという内容。Principal が CustomLoginCommand のインナークラスだったので、CustomLoginCommand が Serializable である必要があったんですねぇ。ということで、CustomPrincipal として独自のクラスに切り出して、再度動作確認。
GAE上で動作しましたー！

GAE/J + BlazeDS 環境の Security 設定

2010-04-11T02:47:00.007+09:00

今回は、GAE/J + BlazeDS 環境で Security の設定をしてみようと思います。

ベースの環境
以下の作業は、GAE/J + BlazeDS + Flash Builder 環境の構築で構築した環境をベースとします。

参考資料
Administering BlazeDS applications - Security - Configuring security

本日のメニュー

本日は、以下のメニューを一通りこなしたいと思います。

custom authentication に対応する。
認証ロジックは、サンプルとして固定のものを使用する。（username = foo, password = bar)
role は使用しない。
Session 単位の認証のみ行い、FlexClient 単位の認証は行わない。
security-constraint は destination 単位ではなく service 単位でかける。

カスタム LoginCommand の作成

login command の実装クラスは、flex.messaging.security.LoginCommand インタフェースを実装している必要があります。

今回は、flex.messaging.security.LoginCommand インタフェースを implements した抽象クラスである flex.messaging.security.AppServerLoginCommand を継承してカスタムの LoginCommand を作成しようと思います。

CustomLoginCommand.java

package security;

import java.security.Principal;

import flex.messaging.security.AppServerLoginCommand;

public class CustomLoginCommand extends AppServerLoginCommand {

 @Override
 public Principal doAuthentication(final String username, Object credentials) {
  String password = extractPassword(credentials);
  boolean isValidUser = "foo".equals(username) && "bar".equals(password);
  return isValidUser ? new CustomPrincipal(username) : null;
 }

 @Override
 public boolean logout(Principal principal) {
  return true;
 }
}

CustomPrincipal.java

package security;

import java.io.Serializable;
import java.security.Principal;

class CustomPrincipal implements Principal, Serializable {
 private String name;
 public CustomPrincipal(String name) { this.name = name; }
 public String getName() { return null; }
 public int hashCode() { return name.hashCode(); }
 public boolean equals(Object obj) { return name.equals(obj); }
}

services-config.xml ファイルの設定

services-config.xml ファイルでは、以下の２つの作業を行います。

login-command の定義
login command の実装として security.CustomLoginCommand クラスを指定します。
<login-command class="security.CustomLoginCommand" server="all"/>
security-constraint の定義
今回は role を使用しないので、security-constraint は id のみの指定となります。
<security-constraint id="security_constraint"/>

services-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<services-config>

  <services>
    <default-channels><channel ref="amf" /></default-channels>
    <service-include file-path="remoting-config.xml" />
    <service-include file-path="messaging-config.xml" />
  </services>

  <channels>
    <channel-definition id="amf" class="mx.messaging.channels.AMFChannel">
      <endpoint url="http://{server.name}:{server.port}/{context.root}/messagebroker/amf" class="flex.messaging.endpoints.AMFEndpoint" />
      <properties>
        <polling-enabled>true</polling-enabled><!-- default is true (though the document doesn't say so) -->
      </properties>
    </channel-definition>
  </channels>

  <security>
    <login-command class="security.CustomLoginCommand" server="all"/>
    <security-constraint id="security_constraint"/>
  </security>

  <system>
    <!-- Workaround for GAE : java.lang.management.ManagementFactory is a restricted class. -->
    <manageable>false</manageable>
  </system>

</services-config>

各 service に対する security-constraint の設定

security-constraint は destination 毎に設定することもできますが、今回は service 単位で設定します。具体的には remoting service と messaging service に設定します。

設定方法は、各 <service> 要素の直下に以下のようにデフォルトの security-constraint を指定します。

<default-security-constraint ref="security_constraint"/>

以下、各 service の定義ファイル：
remoting-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<service id="remoting-service" class="flex.messaging.services.RemotingService">

  <default-security-constraint ref="security_constraint"/>
  
  <adapters>
    <adapter-definition id="java-object" class="flex.messaging.services.remoting.adapters.JavaAdapter" default="true" />
  </adapters>

  <destination id="echoServiceDestination">
    <properties>
      <source>server.EchoService</source>
      <scope>application</scope>
    </properties>
  </destination>

</service>

messaging-config.xml

<service id="message-service" class="flex.messaging.services.MessageService">

  <default-security-constraint ref="security_constraint"/>
  
  <adapters>
    <adapter-definition id="actionscript" class="flex.messaging.services.messaging.adapters.ActionScriptAdapter" default="true" />
  </adapters>

  <destination id="messageServiceDestination">
  </destination>

</service>

疎通確認用アプリケーションの開発（クライアント側）

GAE/J + BlazeDS + Flash Builder 環境の構築の Flex プロジェクトに、SecuredClient.mxml ファイルを作成します。

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
      xmlns:s="library://ns.adobe.com/flex/spark"
      xmlns:mx="library://ns.adobe.com/flex/mx" width="100%" height="100%" creationComplete="init()" currentState="BeforeLogin">
 <s:layout>
  <s:VerticalLayout horizontalAlign="center" paddingLeft="24" paddingBottom="24" paddingRight="24" paddingTop="24" />
 </s:layout>
 <s:states>
  <s:State name="BeforeLogin"/>
  <s:State name="AfterLogin"/>
 </s:states>
 <fx:Declarations>
  <mx:Producer id="producer" destination="messageServiceDestination" fault="messagingFaultHandler(event);"/>
 </fx:Declarations>
 <fx:Script>
  <![CDATA[
   import mx.binding.utils.ChangeWatcher;
   import mx.controls.Alert;
   import mx.messaging.ChannelSet;
   import mx.messaging.config.ServerConfig;
   import mx.messaging.events.MessageAckEvent;
   import mx.messaging.events.MessageEvent;
   import mx.messaging.events.MessageFaultEvent;
   import mx.messaging.messages.AsyncMessage;
   import mx.rpc.AsyncResponder;
   import mx.rpc.AsyncToken;
   import mx.rpc.events.FaultEvent;
   import mx.rpc.events.ResultEvent;
   
   private var cs:ChannelSet;
   
   // Define an AsyncToken object.
   private var token:AsyncToken;
   
   // Initialize component
   private function init():void {
    cs = ServerConfig.getChannelSet("messageServiceDestination");
    if (cs.authenticated == true) {
     currentState = "AfterLogin";
    }
   }
   
   // Login
   private function login(username:String, password:String):void {
    if (cs.authenticated == false) {
     token = cs.login(username, password);
     token.addResponder(new AsyncResponder(LoginResultEvent, LoginFaultEvent));
    }
   }
   
   // Handle successful login.
   private function LoginResultEvent(event:ResultEvent, token:Object=null):void  {
    if (event.result != "success") return;
    currentState="AfterLogin"
   }
   
   // Handle login failure.
   private function LoginFaultEvent(event:FaultEvent, token:Object=null):void {
    if (event.fault.faultCode != "Client.Authentication") return;
    Alert.show("Login Failed!");
   }
   
   // Logout and handle success or failure.
   private function logout():void {
    // Add result and fault handlers.
    token = cs.logout();
    token.addResponder(new AsyncResponder(LogoutResultEvent,LogoutFaultEvent));
   }
   
   // Handle successful login.
   private function LogoutResultEvent(event:ResultEvent, token:Object=null):void  {
    if (event.result != "success") return;
    currentState="BeforeLogin"
   }
   
   // Handle login failure.
   private function LogoutFaultEvent(event:FaultEvent, token:Object=null):void {
    if (event.fault.faultCode != "Client.Authentication") return;
    Alert.show("Logout Failed!");
   }
   
   // Handle a message fault.
   private function messagingFaultHandler(event:MessageFaultEvent):void {
    Alert.show(event.message.faultString);
   }
   
   // Send the message in response to a Button click.
   private function sendMessage():void {
    producer.send(new AsyncMessage("This is only a test."));
   }
   
  ]]>
 </fx:Script>
 <mx:Form includeIn="BeforeLogin">
  <mx:FormItem label="username">
   <mx:TextInput id="userNameTi" focusIn="IME.enabled = false"/>
  </mx:FormItem>
  <mx:FormItem label="password">
   <mx:TextInput displayAsPassword="true" id="passwordTi" focusIn="IME.enabled = false" keyDown="IME.enabled = false"/>
  </mx:FormItem>
 </mx:Form>
 <s:Label includeIn="AfterLogin" text="Hi, {userNameTi.text}. You have logged in."/>
 <s:HGroup includeIn="BeforeLogin,AfterLogin">
  <s:Button label="Login" id="loginBtn" includeIn="BeforeLogin" click="login(userNameTi.text, passwordTi.text)"/>
  <s:Button includeIn="AfterLogin" label="Logout" id="logoutBtn" click="logout()"/>
  <s:Button includeIn="BeforeLogin,AfterLogin" label="Send Message" id="sendMessageButton" click="sendMessage();"/>
 </s:HGroup>
</s:Application>

以上。

注意点

独自の Principal を作成する場合、確実に serialize できるようにしましょう。その際、例外が発生しなかったからといって安心してはいけません。おいらのように、悲しい思いをすることになります。

下記のように、HttpFlexSession は writeObject() メソッドを独自に持って serialize を制御しています。

/**
 * Implements Serializable; only the Principal needs to be serialized as all
 * attribute storage is delegated to the associated HttpSession.
 *
 * @param stream The stream to read instance state from.
 */
private void writeObject(ObjectOutputStream stream)
{
    try
    {
        Principal principal = super.getUserPrincipal();
        if (principal != null && principal instanceof Serializable)
            stream.writeObject(principal);
    }
    catch (IOException e)
    {
        // Principal was Serializable and non-null; if this happens there's nothing we can do.
        // The user will need to reauthenticate if necessary.
    }
    catch (LocalizedException ignore)
    {
        // This catch block added for bug 194144.
        // On BEA WebLogic, writeObject() is sometimes invoked on invalidated session instances
        // and in this case the checkValid() invocation in super.getUserPrincipal() throws.
        // Ignore this exception.
    }
}

そして、writeObject 時に IOException を握りつぶしています。

ご注意ください。

参考：作業ログ : BlazeDS のカスタム LoginCommand がなぜかうまく動かなくて調べた時のログ

付録
login-command 要素に server 属性を追加し忘れた時の例外。

javax.servlet.UnavailableException: Attribute 'server' must be specified for element 'login-command'.
 at flex.messaging.MessageBrokerServlet.init(MessageBrokerServlet.java:170)
 at org.mortbay.jetty.servlet.ServletHolder.initServlet(ServletHolder.java:440)
 at org.mortbay.jetty.servlet.ServletHolder.doStart(ServletHolder.java:263)
 at org.mortbay.component.AbstractLifeCycle.start(AbstractLifeCycle.java:50)
 at org.mortbay.jetty.servlet.ServletHandler.initialize(ServletHandler.java:685)
 at org.mortbay.jetty.servlet.Context.startContext(Context.java:140)
 at org.mortbay.jetty.webapp.WebAppContext.startContext(WebAppContext.java:1250)
 at org.mortbay.jetty.handler.ContextHandler.doStart(ContextHandler.java:517)
 at org.mortbay.jetty.webapp.WebAppContext.doStart(WebAppContext.java:467)
 at org.mortbay.component.AbstractLifeCycle.start(AbstractLifeCycle.java:50)
 at org.mortbay.jetty.handler.HandlerWrapper.doStart(HandlerWrapper.java:130)
 at org.mortbay.component.AbstractLifeCycle.start(AbstractLifeCycle.java:50)
 at org.mortbay.jetty.handler.HandlerWrapper.doStart(HandlerWrapper.java:130)
 at org.mortbay.jetty.Server.doStart(Server.java:224)
 at org.mortbay.component.AbstractLifeCycle.start(AbstractLifeCycle.java:50)
 at com.google.appengine.tools.development.JettyContainerService.startContainer(JettyContainerService.java:185)
 at com.google.appengine.tools.development.AbstractContainerService.startup(AbstractContainerService.java:146)
 at com.google.appengine.tools.development.DevAppServerImpl.start(DevAppServerImpl.java:219)
 at com.google.appengine.tools.development.DevAppServerMain$StartAction.apply(DevAppServerMain.java:162)
 at com.google.appengine.tools.util.Parser$ParseResult.applyArgs(Parser.java:48)
 at com.google.appengine.tools.development.DevAppServerMain.(DevAppServerMain.java:113)
 at com.google.appengine.tools.development.DevAppServerMain.main(DevAppServerMain.java:89)

GAE/J + BlazeDS 環境の DuplicateSessionDetected 問題

2010-04-10T09:27:00.016+09:00

GAE/J + BlazeDS 環境では、以下のようなエラーメッセージが出ることがあります。

Detected duplicate HTTP-based FlexSessions, generally due to the remote host disabling session cookies. Session cookies must be enabled to manage the client connection correctly." faultCode="Server.Processing.DuplicateSessionDetected

この問題について、AppEngine & Adobe BlazeDS (fix) では flex.messaging.endpoints.BaseHTTPEndpoint クラスのソースにパッチを当てる方法でエラーを回避しています。

今回は、この問題を少し掘り下げて考えてみようと思います。

確かにエラーは出なくなるけど、、、。いいのか？

問題箇所をコメントアウトすればエラーは出なくなります。しかし、コメントアウトされた箇所のコードにも意味があるわけで、とりあえずコメントアウトというのはどうも気持ちがわるいです。

ということで、BaseHTTPEndpoint.java を見てみました。もし GAE 側で session の cookie の扱いに不備があるのであれば、確かに下記のコードで duplicateSessionDetected が true になりそうです。

boolean duplicateSessionDetected = (FlexContext.getHttpRequest().getAttribute(REQUEST_ATTR_DUPLICATE_SESSION_FLAG) != null) ? true : false;

ということで、ログを仕込んで確認してみたところ、結果は false でした。

ということは、怪しい箇所は以下ということになりますね。

if (!duplicateSessionDetected)
{
    List sessions = flexClient.getFlexSessions();
    int n = sessions.size(); // <- suspicious!
    if (n > 1)
    {
        int count = 0;
        for (int i = 0; i < n; i++)
        {
            if (sessions.get(i) instanceof HttpFlexSession)
                count++;
            if (count > 1)
            {
                FlexContext.getHttpRequest().setAttribute(REQUEST_ATTR_DUPLICATE_SESSION_FLAG, Boolean.TRUE);
                duplicateSessionDetected = true;
                break;
            }
        }
    }
}

ログを仕込んで確認したところ、flexClient.getFlexSessions().size() の値はローカルだと常に 1 ですが、GAE 環境だと 2 度目のアクセスで 2 になることを確認しました。しかし 3 にはなりませんでした。

これは、2 になった場合に duplicateSessionDetected = true になり、session の invalidate を行う if ブロックが実行されることが影響していると思われます。ということは、その if ブロックをコメントアウトしてしまうと、アクセスされるたびに flexClient.getFlexSessions() が１つずつ増えていくということが考えられます。

実際にログを仕込んで確認したところ、やはりアクセスのたびに flexClient.getFlexSessions() が 1 つずつ増える現象が確認できました。

となると、FlexClient に FlexSession を格納するところが怪しいですよね。ということで、session オブジェクトの格納箇所を見てみました。

public void registerFlexClient(FlexClient flexClient)
{
    if (flexClients.addIfAbsent(flexClient))
    {
        flexClient.addClientDestroyedListener(this);
        flexClient.registerFlexSession(this);
    }
}

flexClients は java.util.concurrent.CopyOnWriteArrayList 型です。

flexClients.addIfAbsent(flexClient) によって、既に flexClient が flexClients に含まれている場合は無視するようなプログラムになっています。

しかし、同一性の判断はどうしているのか気になります。

予想通り、equals メソッドを適切に実装していませんでした。そのため、同一セッションをあらわすオブジェクトでも、デシリアライズされたインスタンス同士が別物として扱われてしまい、GAE のローカル環境ではうまく動くのに本番環境ではうまく動かなかったというわけです。

ということで、HttpFlexSession クラスに以下のメソッドを追加して問題解決です。（たぶん）

@Override
public boolean equals(Object obj) {
 if (!FlexSession.class.isInstance(obj)) return false;
 return FlexSession.class.cast(obj).getId().equals(getId());
}

@Override
public int hashCode() {
 return httpSession != null ? getId().hashCode() : super.hashCode();
}

もしくは、FlexSession クラス以下に以下のメソッドとか。

@Override
public boolean equals(Object obj) {
 if (!FlexSession.class.isInstance(obj)) return false;
 return FlexSession.class.cast(obj).getId().equals(getId());
}

@Override
public int hashCode() {
 if (HttpFlexSession.class.isInstance(this) && HttpFlexSession.class.cast(this).httpSession != null) { // to avoid NPE.
  return getId().hashCode();
 } else {
  return super.hashCode();
 }
}

BlazeDS 入門記（Measuring message processing performance）

2010-04-10T04:04:00.000+09:00

Additional programming topics / Measuring message processing performance

About measuring message processing performance

メッセージ処理に関する箇所の時間やサイズ等のパフォーマンスを測定するという話。

パフォーマンス測定機能はデフォルトでは disabled。
パフォーマンス測定機能を enable にすると、メッセージサイズ、サーバ処理時間、ネットワーク通信時間を測定可能。メッセージをサーバにプッシュしたクライアントや、サーバからプッシュされたメッセージを受信したクライアントや、プッシュしたメッセージの応答を受けたクライアントで測定可能。
部分的な情報はサーバでも確認可能。
BlazeDS のプロキシを使わないで外部サーバとやり取りする場合には、パフォーマンス測定を利用できない。
メッセージ処理のメトリクスは MessagePerformanceUtils で定義される。Producer が ack を受けたときや Consumer がメッセージを受けたときに、このクラスのインスタンスにデータが格納され、そのプロパティを確認することによりパフォーマンスを確認できる。
メッセージを受け取った場合に、メッセージ送信元を特定する情報を得ることはできないらしい。
ポーリングではない本当のリアルタイムメッセージでは、networkRTT、serverPollDelay、totalTime は測定できないので 0 が入る。
以下、一部のメッセージ処理メトリクスの説明

clientReceiveTime : クライアントが応答メッセージを受け取った時間。UNIX時刻のミリ秒。
messageSize :クライアントのオリジナルメッセージのバイト数で、サーバの endpoint でデシリアライズされたサイズ。
networkRTT : totalTime - serverProcessingTime。メッセージの送信から受信までの時間からサーバ処理時間を抜いたものなので、純粋にネットワーク通信の時間となる。ストリーミングの場合は無意味なので0が入る。
originatingMessageSentTime : クライアントがメッセージを投げた時間。ackは対象外。
originatingMessageSize : 元のメッセージサイズ。ackの場合は対象外。
pushedMessageFlag : ポーリングではない真のプッシュの場合には true になる。ackは対象外。
pushOneWayTime : プッシュされたメッセージの送信から受信までの時間。クライアントとサーバの時計が合っていることが前提。ackは対象外。
responseMessageSize : 応答メッセージのサイズ。サーバ側の endpoint でシリアライズしたときのサイズ。
totalPushTime では Producer と Consumer の時計が合っていなければ値の信頼性が損なわれる。

pushOneWayTime ではサーバと Consumer の時計が合っていなければ値の信頼性が損なわれる。
タイミング情報だけを収集するテストと、サイズ情報を収集するテストは別で行い、最後のそれらをあわせたテストをすべき。タイミング収集をするときにサイズ情報を収集すると、誤差が大きくなる。

Measuring message processing performance

機能の enabled / disabled はチャネル定義の record-message-times と record-message-sizes 要素で設定する。
new MessagePerformanceUtils(event.message) みたいな感じでOK。
prettyPrint() メソッドで情報の文字列化をお手軽に行える。

TODO：実際にやってみたけど、totalTime とか networkRTT がマイナスの巨大な値になる。なぜに？要調査。

BlazeDS 入門記（Message delivery with adaptive polling）

2010-04-10T01:41:00.000+09:00

Additional programming topics / Message delivery with adaptive polling

各クライアントベースでメッセージがどのようにキューイングされるかのカスタムロジックを書くという話。

当面利用しなさそうなので、一通り読むだけにとどめておこう。

BlazeDS 入門記（Extending applications with factories）

2010-04-10T01:32:00.000+09:00

Additional programming topics / Extending applications with factories

Remoting Service の destination は java のクラスのインスタンスであり、デフォルトでは BlazeDS がこれをインスタンス化する。applicaiton scope の場合は ServletContext に保存され、session scope の場合は FlexSession に保存される。保存時の attribute の名前は destination 名になるが、destination の attribute-id 属性により指定可能。
BlazeDS は、コンポーネントの生成と管理を独自で行うためのプラグインを提供している。

ここら辺は、当面使わなそうなので割愛。

BlazeDS 入門記（The Ajax client library）

2010-04-10T00:53:00.000+09:00

Additional programming topics / The Ajax client library

JavaScript から BlazeDS サーバと通信するためのライブラリの話。

当面使う予定が無いので、とりあえず割愛。

BlazeDS 入門記（Run-time configuration）

2010-04-10T00:48:00.000+09:00

Additional programming topics / Run-time configuration

設定ファイルで行うようなことを、プログラムとして実行時に行うという話。

動的設定は、起動時に MessageBroker でやる方法と、RemoteObject でやる方法がある。
サーバーのスタートアップ時に動的に設定をする場合、flex.messaging.services.AbstractBootstrapService クラスを継承して initialize() メソッドを実装する。start() と stop() メソッドを実装することもできる。そして、services-config.xml ファイルに <service class="dev.service.MyBootstrapService1" id="bootstrap1"/> のように設定する。

BlazeDS 入門記（Clustering）

2010-04-10T00:32:00.001+09:00

Administering BlazeDS applications / Clustering

ソフトウェアクラスタリングができるよという話。

GAE では使えなさそうなので割愛。

BlazeDS 入門記（Security）

2010-04-10T00:28:00.000+09:00

Administering BlazeDS applications / Security

サーバ側の destination にセキュリティをかけられるという話。

J2EE のセキュリティフレームワークや、カスタムのセキュリティ用ロジックを使えるらしい。

Securing BlazeDS

Authentication はユーザーの認証。
Authorization は行動に対する許可。
Authentication を通過しなければ Authorization はできない。
BlazeDS では destination に対してセキュリティ制約をかけることができる。
Basic認証では、credentialが無かったり間違っていたりする場合に HTTP 401 を返すことにより、ブラウザ側でログインダイアログを出す。カスタム認証ではクライアントに失敗を返す。デフォルトはカスタム認証。
BlazeDS では login Command により認証を行う。これはサーバ実装により異なる。Tomcat, JBoss, Oracle Application Server, BEA WebLogic, IBM WebSphere, Adobe JRun 用のものは事前に用意されている。
login command は role を使わない authentication のみも可能。
login command は flex.messaging.security.LoginCommand インタフェースを実装している。これを実装したカスタムの login command を作成することも可能。
channel と endpoint のレベルで https を用いて通信をセキュアにすることも可能。
ベーシックとカスタム認証でセキュリティ制約を作成するステップはほとんど同様。異なるのはクライアントからサーバにどのようにクレデンシャルを渡すか。セキュリティを設定するステップは以下：

１．services-config.xml ファイル内の security 要素により login command を指定する。
２．services-config.xml ファイル内にセキュリティ制約を定義する。セキュリティ制約はベーシック認証もしくはカスタム認証を設定できる。ひとつか複数のロールの設定もできる。
３．destination 定義からセキュリティ制約を参照させる。
４．カスタム認証を利用する場合、ChannelSet.login() メソッドにてサーバからクレデンシャルを渡す。result event は成功を示し、fault event は失敗を示す。ベーシック認証の場合は、flex アプリケーションでは何もしなくてもOK。ブラウザが勝手に認証ダイアログで対応してくれる。

Configuring security

セキュリティ設定は services-config.xml に書いてもいいけど、data-management-config.xml や messaging-config.xml やその他の設定ファイルに書いてもよい。
セキュリティ制約は destination の定義時に参照される。
複数の destination が同一のセキュリティ制約を参照してもかまわない。
デフォルトではセッション毎に認証され、情報は session に格納される。
per-client-authentication プロパティによりクライアント毎に認証をかけることも可能。この場合、データは FlexClient に格納される。
per-client-authentication を true にした場合、ブラウザの状態により認証がリセットされるので、ブラウザのリフレッシュで認証がリフレッシュすることもある。
BlazeDS がデフォルトで用意する login command は session に依存しているので、per-client-authentication を true にする場合はカスタムの　login command を作成し、session が競合しても問題ないようにする必要がある。
単一の destination のみで利用されるセキュリティ制約は、destination 定義中に記述することが可能。
service レベルでデフォルトのセキュリティ制約をかけることもできる。service/default-security-constraint@ref 属性に security-constraint の id を指定すればOK。→ これ便利。
RemoteService の destination の場合、include-methods と exclude-methods にてメソッドレベルの設定が可能。許可されていないメソッドが呼び出された場合は fault イベントが発生する。

Custom authentication

カスタム認証の場合、クライアントアプリケーション側で明示的に ChannelSet.login() や ChannelSet.logout() を呼び出す。login にはユーザ名とパスワードが必要。
RemoteObject等のインスタンスに setCredentials() を使うと、呼び出し時に自動的にクレデンシャルをつかってくれるらしい。
useProxy プロパティを true にしておかないと、login(), setCredentials(), setRemoteCredentials() メソッドが機能しないらしい。
per-client-authentication property が false の場合、logout()メソッドは session を invalidate する。
per-client-authentication property が true の場合、logout()メソッドは FlexClient オブジェクトの認証情報をクリアするが、FlexClient や session は破棄しない。

Passing credentials to a proxy service

プロキシした先でクレデンシャルが必要な場合のお話。

BlazeDS 入門記（Client-side logging）

2010-04-09T21:07:00.000+09:00

Administering BlazeDS applications / Logging

Client-side logging

クライアント側でのロギングの話。

trace() メソッドを使う方法と、Logging API を使う方法がある。

Server-side logging

サーバ側でのロギングの話。

log4j っぽい感じでできますね。

Monitoring and managing services

MBeans で実行時のマネジメントができるよという話。

GAE 環境では不可能なので、割愛。

BlazeDS 入門記（Connecting to the Java Message Service）

2010-04-09T20:29:00.000+09:00

Messaging Service / Connecting to the Java Message Service (JMS)

JMS をブリッジする場合の話。

特に使う予定が無いので、目だけ通すにとどめておく。

BlazeDS 入門記（Using the Messaging Service）

2010-04-09T17:15:00.002+09:00

Messaging Service / Using the Messaging Service

複数のFlexクライアントとBlazeDSサーバの間で publish-subscribe のメッセージングが可能。
JMSAdapter により JMS の queue や topic にブリッジ可能。
クライアントからのメッセージをサーバ経由で別のクライアントに配送することが可能。
サーバからメッセージをクライアントに配送することも可能。
メッセージは、ユニークID、BlazeDSヘッダ、カスタムヘッダ、ボディ等で構成される。BlazeDSヘッダの先頭はDSという文字列。
クライアントからメッセージを送信するには Producer コンポーネントを使用する。
クライアントでメッセージを受信するには Consumer コンポーネントを使用する。
Consumer は selector expression が使える。
Producer と Consumer は subtopic information を追加可能。
queue-based のメッセージングは、JMSAdapter に JMS Queue をバインディングすることにより可能。
以下、BlazeDS Server Architecture の図
チャネルはReal-timeのものを使う。ポーリングでもOK。
Message Service は message destinations のリストと、各 destination にサブスクライブしているクライアント情報を保持する。→ これって Session に持つのかな？
標準的なアダプタとして ActionScriptAdapter と JMSAdapter があり、その他のカスタムアダプタを自作することも可能。
メッセージング系の設定は services-config.xmlにも書けるけど messaging-config.xml に書くのがオススメ。

Working with Producer components

クライアント側での Producer の書き方についての説明。

自動的にリトライする方法もあるが、複数回送信される可能性があるので、副作用のあるメッセージングは注意すること。
配送できたかよくわからんシチュは２つある。それは、Producer.requestTimeout プロパティの値を超えた場合と、応答が帰ってくる前にチャネルの接続が切れた場合。この場合、ErrorMessage.faultCode が ErrorMessage.MESSAGE_DELIVERY_IN_DOUBT になる。
reconnectAttempts は、-1だと無限に再試行して、0だと再試行しない。
reconnectInterval は再試行のインターバル。0だと再試行しない。

Working with Consumer components

クライアント側での Consumer の書き方についての説明。

Consumer.subscribed プロパティは Flex クライアントが destination に subscribe したときに true になる。
Consumer.connected プロパティは Flex クライアントがサーバに接続したときに true になる。
resubscribeAttempts は、subscribe に失敗した際に fault イベントを返す前に何度リトライするかを設定する。-1は無限リトライ、0はリトライしない。→ これって、GAEのような負荷分散環境では必須ですね。まぁ、このような環境でメッセージングが使えるのが前提なんですが、調査してないのでわかりまてん。
resubscribeInterval はリトライ間隔をミリ秒単位で設定する。0の場合はリトライをしない。
AMFChannelのようなリアルタイムでないチャネルに polling-enabled を使用しないで使うこともできる。この場合、クライアント側で Consumer.receive() を自分から呼びに行けばOK。

Using a pair of Producer and Consumer components in an application

メッセージを送受信するクライアントアプリケーションの場合、同一の destination をもつ Producer と Consumer のペアができるという話。

Message filtering

メッセージのフィルタリングの話。

Producer はメッセージヘッダや subtopic information に情報を付加できる。Consumer ではこの情報を元にクライテリアベースのフィルタリングができる。
Consumer コンポーネントは subscribe するときにフィルタリング用のクライテリアをサーバに送信する。このようにして、実際にフィルタリングをする作業はサーバ側で行う。
注意書きとして、フィルタリング用の情報としてメッセージヘッダと subtopic の両方を同時に使用してはいけないと書かれている。→ なんでだろ？
AsyncMessage.headers プロパティにヘッダ情報が格納される。これは連想配列で、キーがヘッダ名で値が文字列か数字となる。
JMS もしくは DS という文字列で始まるヘッダ名は予約されているので使用禁止。
Consumer の selector プロパティにフィルタリングの条件を記述する。これは SQL92 conditional expression syntax をベースにしている。たとえば selector="prop1 < 4" のような書き方ができる。
mx.messaging.MultiTopicConsumer や mx.messaging.MultiTopicProducer を利用すると、複数の topic を単一のイベントハンドラで扱うことができます。
JMSを使用する場合は subtopic は利用不可。→ 基本的に常にヘッダだけ使えば間違いないですね。
subtopic 名は、destination 名にドット区切りでつける。Consumer 側はワイルドカードが使える。ワイルドカードは1つのトークンに閉じて適用される。"foo.*.baz" は "foo.bar.baz" と"foo.aaa.baz" にマッチするが、"foo.bar.cookie" にはマッチしない。
subtopic を有効にするためには、destination の設定で以下のような指定が必要。

<allow-subtopics>true</allow-subtopics>
<subtopic-separator>.</subtopic-separator>

Configuring the Messaging Service

設定の話いろいろ。

いろいろと設定項目があるので、きちんとおさえておきましょう。

BlazeDS 入門記（Using the Remoting Service）

2010-04-08T15:01:00.022+09:00

RPC services / Using the Remoting Service

以下、特に気になった点

RemoteObject component

Remoting Service destination はデフォルトコンストラクタが必要。
Remoting Service のオブジェクトはステートレスでもステートフルでもOK。
クラウドを意識するならば、アプリケーションスコープの状態は BigTable、セッションレベルの状態なら Session に格納すべきですね。普通にヒープに入れると大変なことに、、、。
RemoteObjectの予約メソッド名に注意しましょう。予約メソッド名にカブった場合、以下のメソッドでワークアラウンド可能。

public function getOperation(name:String):Operation

Configuring a destination

destination のスコープとして、request, application, session の３つの選択肢がある。デフォルトは request スコープ。
ってことは、デフォルト設定だと、毎回インスタンス生成するということか。通常のサービスの場合はきちんとスレッドセーフに作成して application スコープで対応かな。サーバー間レプリケーション不要のキャッシュとか使いたいし。レプリケーションが必要なら memcache 使うべきだけど、その必要のないリードオンリーのキャッシュって結構あるからなぁ。
Remoting Service destination のホワイトリストの作成が可能。その他、メソッドレベルの細かな制約もつけられるらしい。詳細は Configuring a destination to use a security constraint 参照のこと。
この考え方は地味に重要ですね。手動でxmlに指定するのではなく、特定の java インタフェースをホワイトリストとしてくれるような機能があればいいのですが、あるのかな？

Calling a service

RemoteObject の作成や設定は、ActionScript でも MXML でもOK。
concurrency property の設定が可能。

multiple : デフォルト。すべての呼び出しが普通に実行される。
single : 既に実行中の場合は、それ以降の呼び出しは瞬時に fault 扱いとなって、サーバ側への呼び出しは行われない。これは連打防止に使えますね。
last : 呼び出しはすべて行われるが、最後の呼び出し結果だけが利用される。長時間かかる処理なので、UI 的には途中で処理を abort して新規に処理を行いたいようなケースで利用できそうですね。利用箇所はかなり慎重に決定する必要がありそうです。

RemoteObject のインスタンスは、リモートオブジェクトをあらわしているのではなく、リモートオブジェクトと後処理の組み合わせを表したものという理解でいいのかな？　混乱しやすいポイントかもしれませんね。

Handling events

Remote Service の呼び出しが完了すると、result と fault のどちらかのイベントが発生するという話。詳細は Handling service events 参照のこと。

Passing parameters

パラメータの渡し方に、明示的に渡す方法と、事前にバインディングしておくものがあるという話。

何気に showBusyCursor="true" とか設定してますね。

明示的に渡したほうが分かりやすいような気がしますが、事前にバインディングしたほうがよいケースってどんな場合なんでしょう？

Handling results

リモート呼び出しの結果が、Operation.lastResult か ResultEvent.result から取得するという話。

その他の話は HttpService や WebService 以外では関係なさそうなので割愛。

Accessing EJBs and other objects in JNDI

EJB や JNDI 経由でオブジェクトにアクセスする場合の話。

BlazeDS 入門記（Defining and invoking a service component）

2010-04-08T02:23:00.000+09:00

RPC services / Using HTTP and web services / Defining and invoking a service component

以降、当面 RemotingService 以外使う予定が無いので、RPC services / Using HTTP and web services は割愛。

TODO：あとでやろう。

BlazeDS 入門記（Using HTTPService and WebService without a destination）

2010-04-08T02:17:00.000+09:00

RPC services / Using HTTP and web services / Using destinations / Using HTTPService and WebService without a destination

ProxyServiceを使用しないで HTTPService や WebService を利用する方法の説明。

基本的に、Flash 側から直接対象のサービスにアクセスする方法や、異なるドメインの場合には crossdomain.xml ファイルが必要とか、そういう話。

yahoo の場合、http://api.search.yahoo.com/crossdomain.xml とかありますね。

BlazeDS 入門記（Configuring the Proxy Service）

2010-04-08T02:08:00.000+09:00

RPC services / Using HTTP and web services / Using destinations / Configuring the Proxy Service

Proxy Service のお話。

BlazeDS 入門記（Using destinations）

2010-04-08T02:06:00.000+09:00

RPC services / Using HTTP and web services / Using destinations

主な内容

destination をサーバ側で集中管理することにより、クライアント側は何も考えずに destination を指定すればサービスを扱うことができる。
destination に認証をかけることができる。
その他、HTTPService と WebService 関連情報いろいろ。

BlazeDS 入門記（RPC components versus other technologies）

2010-04-08T01:56:00.000+09:00

RPC services / Using HTTP and web services / RPC components versus other technologies

普通に flash の利点のようなことがかかれてます。

BlazeDS 入門記（RPC components）

2010-04-08T01:52:00.001+09:00

RPC services / Using HTTP and web services / RPC components

RPC コンポーネントのお話。

BlazeDS 入門記（Explicitly mapping ActionScript and Java objects）

2010-04-08T01:41:00.000+09:00

BlazeDS architecture / Data serialization / Serializing between ActionScript and web services

ActionScript と web service のシリアライズ規則です。

気が遠くなりそうです。

BlazeDS 入門記（Explicitly mapping ActionScript and Java objects）

2010-04-08T01:37:00.001+09:00

BlazeDS architecture / Data serialization / Serializing between ActionScript and Java / Explicitly mapping ActionScript and Java objects

Javaオブジェクトの場合、暗黙的に変換されないクラスは setter/getter メソッドと public のプロパティはシリアライズ対象となり、その他はシリアライズされない。

ActionScriptのオブジェクトの場合もメソッドとかアクセサ等の呼び名が違うだけで内容は同様。

ActionScript側では [RemoteClass(alias=" ")] メタデータを使うことにより、明示的に Java のクラスにマッピング可能。

[Transient] も使えるようですね。

Converting data from Java to ActionScript

変換規則の話。

Configuring AMF serialization on a channel

services-config.xml ファイルに設定可能な serialization 要素の設定項目の話。

Using custom serialization between ActionScript and Java

java の externalize のようなことができるという話。かなり熱いですね。

java 側では普通に java.io.Externalizable を実装すればよく、ActionScript 側では flash.utils.IExternalizable を実装すれば OK です。

いろいろと面白いことができそうですね。オブジェクト毎に最適なフォーマットを適用したり、キャッシュによりシリアライズ・デシリアライズの処理をスキップするとか、デフォルトの方法でシリアライズしつつそのバイナリデータをクライアントとサーバの共通辞書で圧縮して渡すとか。

BlazeDS 入門記（Session life cycle）

2010-04-08T00:34:00.000+09:00

BlazeDS architecture / Data serialization / Serializing between ActionScript and Java

シリアライズの型変換の話。

BlazeDS 入門記（Session life cycle）

2010-04-07T23:44:00.003+09:00

BlazeDS architecture / Managing session data / Session life cycle

Disconnecting from an HTTP-based channel

HTTP はステートレスなプロトコルのため、SWF ファイルが切断された時、サーバ上での検出はサーバ上の HTTP セッションタイムアウトのタイミングに依存する。そのため、Flex アプリケーションから BlazeDS サーバに切断を通知させたいのであれば、ChannelSet の disconnectAll() メソッドを JavaScript から呼ばせるようにするとのことらしい。

流れとしては、以下のように disconnectAll() メソッドを用意し、

private function disconnectAll():void {
 remoteObject.channelSet.disconnectAll();
}

これを ActionScript メソッドをコンテナから呼び出し可能なものとして登録するための init() メソッドを用意し、

private function init():void {
 if (ExternalInterface.available) {
  ExternalInterface.addCallback("disconnectAll", disconnectAll);
 }
}

application 要素の creationComplete 属性に init() メソッドを登録します。

creationComplete="init()"

そして JavaScrpt側では

<script type="text/javascript">
    function disconnectAll() {
        document.getElementById("RpcClient").disconnectAll();
    }
</script>

のようにメソッドを用意し、body 要素の onunload 属性を以下のように設定して、unload 時に上記 JavaScrpt の disconnectAll() メソッドが呼ばれるようにします。

<body onunload="disconnectAll()">

実際にやってみたところ、クライアント側では期待通りの動きをしていることは確認できました。でも、サーバ側でうまくできているのか確認するほうほうがよくわかりません。ひとまず TODO:要確認として、先に進むことにします。

Invalidating an HTTP session

Another complication with using the HTTP protocol is that multiple SWF files share the same HTTP session. When one SWF file disconnects, BlazeDS cannot invalidate the HTTP session. In this scenario, the default behavior on the server is to leave the current session in place for other applications or pages that are using the HTTP session. However, you can use the optional invalidate-session-on-disconnect configuration property in a channel definition in the services-config.xml file to invalidate the session, as the following example shows:

<channel-definition id="my-amf" class="mx.messaging.channels.AMFChannel">
    <endpoint url="http://servername:port/contextroot/messagebroker/amf"
        class="flex.messaging.endpoints.AMFEndpoint"/>
    <properties>
        <invalidate-session-on-disconnect>true</invalidate-session-on-disconnect>
    </properties>
</channel>

複数のSWFファイルが接続している状態では、１つのSWFファイルが切断されても HTTP セッションの invalidate をしない。このようなケースで HTTP セッションを invalidate したい場合、services-config.xml ファイルに以下のように invalidate-session-on-disconnect の指定をすると、１つのSWFファイルが切断されると HTTP セッションが invalidate されるようになるという話。

実験してみましたが、残念ながらサーバ側で invalidation されるのを確認できませんでした。これもひとまず TODO:要確認として、先に進むことにします。

BlazeDS 入門記（Using the FlexContext class with FlexSession and FlexClient attributes）

2010-04-07T19:35:00.000+09:00

BlazeDS architecture / Managing session data / Using the FlexContext class with FlexSession and FlexClient attributes

The flex.messaging.FlexContext class is a utility class that exposes the current execution context on the BlazeDS server. It provides access to FlexSession and FlexClient instances associated with the current message being processed. It also provides global context by accessing MessageBroker, ServletContext, and ServletConfig instances.

FlexContext からは、FlexSession や FlexClient といった BlazeDS 依存の情報から、 ServletContext や ServletConfig など Servlet 系の情報まで。一通り取得することが可能なようですね。

The following example shows a Java class that calls FlexContext.getHttpRequest() to get an HTTPServletRequest object and calls FlexContext.getFlexSession() to get a FlexSession object. Exposing this class as a remote object makes it accessible to a Flex client application. Place the compiled class in the WEB_INF/classes directory or your BlazeDS web application.

package myROPackage;

import flex.messaging.*;
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class SessionRO {

    public HttpServletRequest request;
    public FlexSession session;

    public SessionRO() {
        request = FlexContext.getHttpRequest();
        session = FlexContext.getFlexSession();
    }
    
    public String getSessionId() throws Exception {
        String s = new String();
        s = (String) session.getId();
        return s;
    }

    public String getHeader(String h) throws Exception {
        String s = new String();
        s = (String) request.getHeader(h);
        return h + "=" + s;
    }
}

上記、HttpServletRequest と FlexSession の利用例。

BlazeDS 入門記（FlexClient, MessageClient, and FlexSession objects）

2010-04-07T19:09:00.002+09:00

BlazeDS architecture / Managing session data / FlexClient, MessageClient, and FlexSession objects

The FlexClient object

Every Flex application, written in MXML or ActionScript, is eventually compiled into a SWF file. When the SWF file connects to the BlazeDS server, a flex.messaging.client.FlexClient object is created to represent that SWF file on the server. SWF files and FlexClient instances have a one-to-one mapping. In this mapping, every FlexClient instance has a unique identifier named id, which the BlazeDS server generates. An ActionScript singleton class, mx.messaging.FlexClient, is also created for the Flex application to access its unique FlexClient id.

FlexClient のインスタンスは SWF ファイルに対応するらしいです。

と言われてもよく分からないので、同一ブラウザで２つのタブを開いてアクセスしてみました。

アクセスされた側で FlexContext.getFlexClient().getId() を表示するようにしたところ、ブラウザ毎ではなく、クライアント毎に異なるIDが振られることが確認できました。

The MessageClient object

If a Flex application contains a Consumer component (flex.messaging.Consumer), the server creates a corresponding flex.messaging.MessageClient instance that represents the subscription state of the Consumer component. Every MessageClient has a unique identifier named clientId. The BlazeDS server can automatically generate the clientId value, but the Flex application can also set the value in the Consumer.clientId property before calling the Consumer.subscribe() method.

Consumer 毎に個別にユニークな ID が自動的に振られるが、自前で振ることも可能という話。

The FlexSession object

A FlexSession object represents the connection between the Flex application and the BlazeDS server. Its life cycle depends on the underlying protocol, which is determined by the channels and endpoints used on the client and server, respectively.

If an HTTP-based channel, such as AMFChannel or HTTPChannel, is used in the Flex application, the FlexSession on the BlazeDS server is scoped to the browser and wraps an HTTP session. If the HTTP-based channel connects to a servlet-based endpoint, the underlying HTTP session is a J2EE HttpSession object.

FlexSession は Flex アプリケーションと BlazeDS 間のコネクションをあらわし、channel と endpoint によって決定されるプロトコルによってライフサイクルが変わるという話。

AMFChannel や HTTPChannel のような HTTP ベースの channel の場合、FlexSession は HTTP Session のラップになるらしい。

HttpSession と本当に同じ振る舞いをするか、一応確認してみることにしよう。

ということで、同一ブラウザで２つのタブや別ウィンドウを開いてアクセスする実験をしてみました。

アクセスされた側で FlexContext.getFlexSession().getId() を表示するようにしたところ、同一ブラウザでは同一の ID が表示されました。

別ブラウザではどうなるかということで、IE と FF で試してみたところ、別ブラウザでは異なる ID となりました。

予想通り、HttpSession と同じ振る舞いになりました。めでたし。

The relationship between FlexClient, MessageClient, and FlexSession classes

A FlexClient object can have one or more FlexSession instances associated with it depending on the channels that the Flex application uses. For example, if the Flex application uses one HTTPChannel, one FlexSession represents the HTTP session created for that HTTPChannel on the BlazeDS server.

A FlexSession can also have one or more FlexClients associated with it. For example, when a SWF file that uses an HTTPChannel is opened in two tabs, two FlexClient instances are created in the BlazeDS server (one for each SWF file), but there is only one FlexSession because two tabs share the same underlying HTTP session.

In terms of hierarchy, FlexClient and FlexSession are peers whereas there is a parent-child relationship between FlexClient/FlexSession and MessageClient. A MessageClient is created for every Consumer component in the Flex application. A Consumer must be contained in a single SWF file and it must subscribe over a single channel. Therefore, each MessageClient is associated with exactly one FlexClient and one FlexSession.

If either the FlexClient or the FlexSession is invalidated on the server, it invalidates the MessageClient. This behavior matches the behavior on the client. If you close the SWF file, the client subscription state is invalidated. If you disconnect the channel or it loses connectivity, the Consumer component is unsubscribed.

FlexSession、FlexClient、MessageClient のインスタンスの関係が、FlexSession 1:* FlexClient 1-* MessageClient という話。

Event listeners for FlexClient, MessageClient, and FlexSession

いろいろとリスナーがあるとよという話。

ひとまず、FlexClientListener と FlexSessionListener について実験してみました。

FlexClient.addClientCreatedListener(new FlexClientListener() {
 public void clientDestroyed(FlexClient flexClient) {
  System.out.println("clientDestroyed : " + flexClient.getId());
 }

 public void clientCreated(FlexClient flexClient) {
  System.out.println("clientDestroyed : " + flexClient.getId());
 }
});
FlexSession.addSessionCreatedListener(new FlexSessionListener() {
 public void sessionDestroyed(FlexSession flexSession) {
  System.out.println("sessionDestroyed : " + flexSession.getId());
 }
 public void sessionCreated(FlexSession flexSession) {
  System.out.println("sessionCreated : " + flexSession.getId());
 }
});

上記のような形でリスナーを登録後、新規にアクセスしてみると、下記のようなメッセージが表示されました。

clientCreated : 4590A4C9-5A1E-5D26-BE7F-21101AD66C98
sessionCreated : ngskddnnb17q

clientDestroyed と sessionDestroyed がどのタイミングで呼び出されるのかは、振る舞いを追う限りはよく分かりませんでした。後でソースを見てみようと思います。

Log categories for FlexClient, MessageClient, and FlexSession classes

FlexClient, MessageClient, FlexSession のログカテゴリは以下という話。

Client.FlexClient
Client.MessageClient
Endpoint.FlexSession

BlazeDS 入門記（Using BlazeDS clients and servers behind a firewall）

2010-04-07T16:00:00.001+09:00

BlazeDS architecture / Channels and endpoints / Using BlazeDS clients and servers behind a firewall

Because servlet-based endpoints use standard HTTP requests, communicating with clients inside firewalls usually works, as long as the client-side firewall has the necessary ports open. Using the standard HTTP port 80 and HTTPS port 443 is recommended because many firewalls block outbound traffic over non-standard ports.

クライアント側がファイアウォール内にある場合は多くの場合 HTTP と HTTPS のポートしか外に出られないので、標準の80番と443番を使いましょうという話。

The protocols that the various client channels use are hard coded. For example, the AMFChannel always uses HTTP, while the SecureAMFChannel always uses HTTPS. One thing to watch for when using a SecureAMFChannel/SecureAMFEndpoint combination is an issue with Internet Explorer related to no-cache response headers and HTTPS. By default, no-cache response headers are enabled on HTTP-based endpoints. This causes problems for Internet Explorer browsers. You can suppress these response headers by adding the following configuration property to your endpoint:

<add-no-cache-headers>false</add-no-cache-headers>

IEだと HTTPS の時に no-cache ヘッダをつけるとうまく動作しないので、HTTPS と IE を併用したいのなら上記の設定をして no-cache ヘッダをつけないようにしましょうという話。

When you have a firewall/reverse HTTP proxy in your deployment that handles SSL for you, you must mix and match your channel and endpoint. You need the client to use a secure channel and the server to use an insecure endpoint, as the following example shows:

<channel-definition id="secure-amf" class="mx.messaging.channels.SecureAMFChannel">
   <endpoint url="https://[firewall ip:port]/{context.root}/messagebroker/amf" 
   class="flex.messaging.endpoints.AMFEndpoint"/>
   <properties>
   <add-no-cache-headers>false</add-no-cache-headers>
   ...

The channel class uses HTTPS to hit the firewall/proxy, and the endpoint URL must point at the firewall/proxy. Because SSL is handled in the middle, you want the endpoint class used by BlazeDS to be the insecure AMFEndpoint and your firewall/proxy must hand back requests to the HTTP port of the BlazeDS server, not the HTTPS port.

firewall で HTTPS を受ける場合、endpoint の url 設定を firewall 向けに書きましょうという話。でもって、もし wirewall 側で HTTPS で受けて裏のサーバでは HTTP で受けるのであれば、endpoint のクラスは Secure 無しのものにしましょうねという話。channel と endpoint のクラスの組み合わせが通常と異なるのがポイントですね。

BlazeDS 入門記（Channel and endpoint recommendations）

2010-04-07T15:23:00.001+09:00

BlazeDS architecture / Channels and endpoints / Channel and endpoint recommendations

以下、特に気になった点。

RPC したいだけなら AMFChannel を使いましょう。
サーバからデータをプッシュしたい場合でも、RPC 用とメッセージング用でチャネルを分ける必要はない。
可能なら、単一の channel set かつ１つの channel しか使わないのがベスト。

「3. AMFChannel/Endpoint with simple polling and piggybacking enabled (no fallback needed) 」が GAE 環境で実現できるのかは調査したいなぁ。

BlazeDS 入門記（Configuring channels with servlet-based endpoints）

2010-04-07T14:53:00.003+09:00

BlazeDS architecture / Channels and endpoints / Configuring channels with servlet-based endpoints

以下、特に気になった点。

AMFEndpoint と HTTPEndpoint はシンプルな servlet ベースの endpointで、RPC の時はポーリング無しで普通にアクセスし、メッセージングの場合はポーリングがロングポーリングをするのが普通。
polling-enabled はオプション。デフォルトでは false。（ってドキュメントに書かれているけどたぶんウソ。実際にやってみると、未指定でもポーリングされる。明示的に false を指定するとポーリングされなくなる。）
polling-interval-millis はオプション。デフォルトは 3000。0 に設定すると、現在ポーリング中のメッセージを受けると即座に次のポーリングを行う。
wait-interval-millis はオプション。デフォルトは 0。サーバー側がポーリングを受け付けた際に、データが存在しない場合にどれだけ待つかの設定。値が0だとサーバーは一切待たない。値が-1だと次のメッセージが用意できるまでサーバはレスポンスを返さないで待ち続ける。BlazeDS 的には1分を推奨しているが、GAE環境では30秒ルールがあるのでせいぜい20秒程度が妥当か？っていうか、GAE環境でポーリング自体が妥当なのか検証する必要があるが、、、。
client-wait-interval-millis はオプション。デフォルトは 0。クライアント側がポーリングのレスポンスを受けた後にどれだけ休むかを指定する。0を指定すると、polling-interval-millis のみによって次のポーリングのタイミングを決定する。このオプションは polling interval を上書きするので、この値を 1 にすると、ポーリングのメッセージを受け付けるとすぐに次のポーリングを始めるので、リアルタイムストリーミングのようになる。サーバー側で待ち時間を発生させていない環境では、このオプションを使わずに polling-interval-millis を使いましょう。
max-waiting-poll-requests はオプション。デフォルトは 0。サーバー側のポーリング返信待ち状態スレッド数の上限。このスレッド数が上限に達すると、それ以降のポーリングリクエストは即座に返却される（wait-interval-millis のような動きになる）。
piggybacking-enabled はオプション。デフォルトは false。これを true にすると、同一チャネルのあらゆるメッセージのレスポンスをポーリングのレスポンス代わりに使うことができる。
login-after-disconnect はオプション。デフォルトは false。これを true にすると、メッセージがセッション切れで認証できなくなってエラーになっった場合に、自動的に最認証してメッセージも再送してくれる。これは便利かも。クライアント側のコードで、この手のエラーハンドリングをしなくてもよくなるわけですねー。
flex-client-outbound-queue-processor はオプション。pub-subモデルの場合、サーバ側にsubscribeしたクライアントの数だけ外向けのキューのプロセッサのインスタンスができるらしい。そのプロセッサ実装へのプロパティをこのプロパティで指定するとのこと。
serialization はオプションで、endpoint に対する serialization のプロパティ。独自の externalize とかできるっぽい。燃えますね。
connect-timeout-seconds はオプション。クライアント側のチャネルの接続試行のタイムアウト時間設定。
invalidate-session-on-disconnect はオプション。デフォルトでは disabled。enabledにすると、サーバがクライアントチャネルからの disconnect メッセージを受け取ると、対応するセッションを無効にする。同一ブラウザで複数の swf ファイルを起動したときなど、ブラウザレベルでセッションが共有されるわけだが、そのような場合でも１つの disconnect メッセージで問答無用にセッションが切られるということですね。
add-no-cache-headers はオプション。デフォルトでは true。pragma no-cache header をつける。

BlazeDS 入門記（About channels and endpoints）

2010-04-06T21:19:00.000+09:00

BlazeDS architecture / Channels and endpoints / About channels and endpoints

以下、特に気になった点。

channel はクライアント側のオブジェクト。
channel は BlazeDS server の endpoint と通信する。
channel の設定は services-config.xml に記述する。
endpoiint のURLの指定方法が気になる。url="http://servername:8400/myapp/messagebroker/amf" のような感じの指定のうち、myapp はコンテキストパスで messagebroker は web.xml MessageBroker の servlet-mapping から自明ですよね。となると、最後の amf の部分がどのようにして決定されるのか知りたい。何でもいいのかな？ということで、実際に試してみた。結論としては何でもOKでした。サーバ側にデプロイされている設定と、flash がコンパイルされた時点の設定が同一であればOKです。もちろん、全 endpoint でユニークである必要はありますが。
Flex コンポーネントは channel set が使える。
flex のコンパイル時に -services オプションによって services-config.xml を指定する。flash builder でプロジェクトを作成すると、プロジェクト作成時に設定した情報を元に勝手に -services オプションが付与される。compiler のオプション設定で手動で変更可能。
アプリケーションで動的に destination を作成する場合、application-level default channel というのが使えるらしい。
channel set で fallback 用の設定が可能。（でも、正直言って、自社案件ではこの機能をつかってうれしい状況が思い浮かばない。）
HTTPS を使う endpoint は、クラス名の先頭に Secure が付く。
Piggybacking provides lightweight pseudo polling。えせポーリングですねｗ。使いたいけど、ユーザー数が多い場合に topic や queue の管理がどうなるんだろ？要確認ですね。
Piggybacking は、polling enabled になっている channel でも利用可能。インターバルを長めに設定しておいて、アクセスがなければそのインターバルでポーリングして、アクセスがあればそのデータに相乗りするという形。これも便利そうだ。GAEとの親和性の高い JMS のようなサービスがあれば完璧ですね。ないのかな？要調査ですね。
polling と　piggybacking を組み合わせる際、piggyback でデータを取得した際に、そこからポーリング時間がリセットされるのかそうじゃないのかは、要確認ですね。
long polling も使える。これはポーリングをかけたときにデータがなければそのまま待機するという仕組みだが、GAE 環境では不可ですね。残念。
streaming も GAE 環境では不可ですね。

BlazeDS 入門記（Configuration elements）

2010-04-06T14:55:00.001+09:00

BlazeDS architecture / BlazeDS architecture / About configuration files/ Configuration elements

services-config.xml の説明。
見たまんまなので割愛。

BlazeDS 入門記（About configuration files）

2010-04-06T14:40:00.000+09:00

BlazeDS architecture / BlazeDS architecture / About configuration files

以下、特に気になった点。

BlazeDS の設定は services-config.xml ファイルに記述する。デフォルトのロケーションは WEB-INF/flex だが、web.xml 内の MessageBrokerServlet の設定により変更することも可能。
service 定義用のファイルを services-config.xml に include することができる（remoting-config.xmlとか）。インラインでも書けるらしい。（でも、やらないほうがいいですよね。）
{server.name}等の token を使うと、環境から動的に情報を決定できる。でも Air アプリでは機能しないので注意。（Webで配布するのが前提でないのだから当然ですよね。）
jvm のオプションでもトークンを渡せるらしい。

BlazeDS 入門記（BlazeDS server architecture）

2010-04-06T14:15:00.000+09:00

BlazeDS architecture / BlazeDS architecture / BlazeDS server architecture

以下、アーキテクチャの図

以下、特に気になるポイント。

EndPoint は MessageBrokerServlet によって実現されている。
HTTP session listener（flex.messaging.HttpFlexSession）によって BlazeDS は HTTP Session をサポートする。
channel と endpoint は同じフォーマットにする必要がある。
channel の設定は WEB-INF/flex/services-config.xml ファイルで行う。
MessageBroker はメッセージのルーティングを行う。
destination 側にセキュリティ制約がかかっている場合は、MessageBroker が認証を行う。（Security参照のこと）
RemotingService は remoting-config.xml に、HTTPProxyService は proxy-config.xml に、MessageService は messaging-config.xml に設定する。
RemotingDestination は JavaAdapter を、HTTPProxyDestination は HTTPProxyAdapter か SOAPAdapter を、MessageDestination は ActionScriptAdapter か JMSAdapter を使用する。
カスタムの Adapter の作成も可能。
設定は xml ファイルではなくスタートアップ時にプログラム的に動的に行うこともできる。（個人的には、設定内容が宣言的な性質を持っている限りは、定義ファイル内で定義すべきだと思う。）

BlazeDS 入門記（BlazeDS client architecture）

2010-04-06T12:28:00.000+09:00

BlazeDS architecture / BlazeDS architecture / BlazeDS client architecture

クライアントとサーバの通信の低レベルの内容はチャネルが抽象化している。
チャネルは、検出とフェイルオーバーを行う集合にグループ化される。
BlazeDS サーバと通信する RemoteObject、HTTPService、WebService、Producer、Consumer コンポーネントは Flex SDK の rpc.swc コンポーネントライブラリに含まれている。
チャネルに接続できない場合、チャネルセット中の次のチャネルを試行する。
AMFChannel と HTTPChannel を必要に応じて使い分けましょう。
クライアントとサーバ間のやり取りはすべてメッセージを介して行われる。
すべてのメッセージはクライアントサイド（ActionScript）とサーバサイド（java）の実装が存在する。
サーバープッシュ API を使用してサーバからクライアントにメッセージを配信することもできる。
request/reply パターンと publish/subscribe パターンがある。

という話。

BlazeDS 入門記（Deploying your application）

2010-04-06T11:37:00.002+09:00

Getting started with BlazeDS / Building and deploying BlazeDS applications / Deploying your application

本番環境によってデプロイ方法が変わるという話。ひとつめの方法は、アプリと関連ファイルをすべて BlazeDS Web アプリにいれてしまい、単一の war ファイルを作成し、それを本番環境にデプロイするやり方。

もうひとつの方法は、複数の BlazeDS アプリを１つの Web アプリに入れる方法。この場合、自分の新規のアプリを走らせるために必要なディレクトリを追加した新たな拡張されたBlazeDSアプリを持つことになるらしい。（WEB-INF/flex フォルダのようなものが複数になったり web.xml 内の MessageBroker Servlet の定義が複数になったりする状況のことかな？）

BlazeDS アプリケーションを本番環境にデプロイするためには、以下を含めたすべての必要なものを入れましょうとのこと。

クライアントアプリケーションの入ったコンパイル済みの SWF ファイル。
Flex Builder によって作成された HTML ラッパー。mxmlc コンパイラを使った場合は自作のもの。
サーバーサイドアプリの入った jar ファイル。
実行時に必要なもの。
BlazeDS Web アプリ。
BlazeDS 設定ファイル群。

BlazeDS 入門記（Debugging your application）

2010-04-05T23:58:00.003+09:00

Getting started with BlazeDS / Building and deploying BlazeDS applications / Debugging your application

以下のようなデバッグができるらしい。

コードにブレークポイントがセットできる。
アプリケーションの実行を、一時停止、一時停止からの復帰、停止の制御ができる。
コードのステートメントに深く潜ったり戻ったりできる。
変数の内容を確認できる。
実行中のアプリ内で expression を evaluate できる。

Flex アプリケーションのデバッグは、trace() を埋め込むようなシンプルなものから、行レベルのデバッグまでできる。Flex Builder のデバッガやコマンドラインのデバッガ使えるらしい。

Using Flash Debug Player

コマンドラインデバッガもしくは Flex Builder デバッガを使用するためには、Flash Debug Player のインストールと設定が必要です。

どうも記事が古いのか私の環境がおかしいのか分かりませんが、ドキュメントに書かれた情報と私の環境が異なるようです。右クリックメニューに Show Redraw Regions（領域の再描画）のような項目が表示されるらしいのですが、、、。

とりあえず、http://www.adobe.com/support/flashplayer/downloads.html から Adobe Flash Player 10 — Debugger Versions をインストールしてみました。

FlexBuilder 上のデバッガからアプリを起動すると、trace()メソッドによるデバッグ情報の出力や、ブレークポイントの利用やステップ実行や変数の内容確認などができました。

Using logging to debug your application

Client-side logging

クライアントサイドでは、直接ログファイルにメッセージを書き出す方法と、Flex から生成されたメッセージをログファイルに書き出すように設定する方法があるらしい。前者は trace() で、後者が Logging API らしい。後者はログレベルとかを log4j のように設定できる感じですね。

設定は mm.cfg ファイルで行うらしい。ということで、以下のように設定しました。

ErrorReportingEnable=1
TraceOutputFileEnable=1

配置場所は、WinXP の場合は C:\Documents and Settings\username フォルダです。

trace() を埋め込んだ Flex アプリケーション Flash Builder から実行したところ、通常モードでもデバッグモードでも C:\Documents and Settings\username\Application Data\Macromedia\Flash Player\Logs\flashlog.txt ファイルが生成され、trace() の内容が表示されました。

mxmlファイル内にを入れたところ、Flex からのログも出力されるようになりました。

ちなみに、ドキュメントではとなっていましたが、Flash Builder 4 では loglevel 要素は存在しませんでした。

Server-side logging

サーバサイドのログ設定は services-config.xml に記述します。デフォルトでは標準出力に吐かれます。

利用可能なログレベルは以下のようになっているらしいです。

All
Debug
Info
Warn
Error
None

以下、ログレベルを利用した設定例です。

<logging>

<!-- You may also use flex.messaging.log.ServletLogTarget. -->
    <target class="flex.messaging.log.ConsoleTarget" level="Debug">
        <properties>
            <prefix>[Flex]</prefix>
            <includeDate>false</includeDate>
            <includeTime>false</includeTime>
            <includeLevel>false</includeLevel>
            <includeCategory>false</includeCategory>
        </properties>
        <filters>
            <pattern>Endpoint</pattern>
            <!--<pattern>Service.*</pattern>-->
            <!--<pattern>Message.*</pattern>-->
        </filters>
    </target>
</logging>

設定は logging 要素を services-config.xml ファイルの services-config 要素直下に配置してあげれば OK です。

Measuring application performance

メッセージ処理部分のタイミングとサイジングに関するデータが取れるらしいです。

デフォルトではこの機能は動作してないが、動作させるとメッセージサイズ、サーバ処理時間、ネットワーク移動時間が取得できるらしい。この情報は、クライアント側がデータ送信、データ受信、メッセージ送信後の応答受信時に取得可能らしい。この情報のサブセットはサーバ上のアクセスでも取得できるらしい（ちょっと意味分からん）。

useProxy プロパティを false にしているとき以外はこのデータが取得できるらしい。

チャネル定義に以下の定義を設定すればデータが取れるらしい。

<record-message-times>
<record-message-sizes>

Measuring message processing performance に詳しい説明があるので、ここでは割愛。

BlazeDS入門記（Running the BlazeDS sample applications）

2010-04-05T17:41:00.001+09:00

Getting started with BlazeDS / Building and deploying BlazeDS applications / Building your server-side application

サーバサイドの BlazeDS アプリケーションを java で作成し、javac コンパイラでコンパイルします。

Creating a simple Java class to return data to the client

A common reason to create a server-side Java class is to represent data returned to the client. For example, the client-side RemoteObject component lets you access the methods of server-side Java objects to return data to the client.

ここでは、サーバサイドの java クラスを作成する一般的な理由のひとつは、クライアントに返却されるデータを表現することであると書かれています。

この文脈での java クラスは純粋なデータクラスであり、ドメインモデルに所属しないクラスであることを意識しておくことが重要ですね。

データクラスだけではなく BlazeDS の destination となるサービスもドメインモデル内のものではなく、 Remote Facade だと割り切るのが重要だと思います。

The Test Drive sample application contains the Accessing Data Using Remoting sample where the client-side code uses the RemoteObject component to access product data on the server. The Product.java class represents that data. After starting the BlazeDS server and the samples database, view this example by opening the following URL in a browser: http://localhost:8400/samples/testdrive-remoteobject/index.html.

Product.java をデータとしてやり取りするサンプルがあるよんという話ですね。

以下略ｗ

Creating a Java class that extends a BlazeDS class

data adapter を自作する場合など、BlazeDS のクラスを拡張したクラスを作成することもあるよという話。

BlazeDS入門記（Running the BlazeDS sample applications）

2010-04-05T15:54:00.000+09:00

Getting started with BlazeDS / Building and deploying BlazeDS applications / Running the BlazeDS sample applications

BlazeDS Turnkey 版のサンプルアプリの起動方法について書かれています。

特に語ることは無いっす。

BlazeDS入門記（Setting up your development environment）

2010-04-05T15:49:00.002+09:00

Getting started with BlazeDS / Building and deploying BlazeDS applications / Setting up your development environment

Installation directory structure

ここでは BlazeDS Turnkey ZIP file のディレクトリ構造を説明しています。

あんま興味ないので割愛ｗ

Accessing a web application

ここではサンプルのアクセス方法が書かれています。

あんま興味ないので割愛ｗｗ

Creating a web application

BlazeDS アプリケーションをWebアプリケーションとごっちゃにしないで分けておきましょうという話。

Defining the directory structure for client-side code

クライアントアプリを開発する際のディレクトリ構造についての説明。

ここら辺については、おいら自身がまた Flex のアプリ開発に慣れてないので、とりあえず読んでおくだけに留めておくことにしよう。

Defining the directory structure for server-side code

サーバサイドの開発をする際のディレクトリ構造についての説明。

IDE 環境とか maven とか絡んできそうですね。おいおい研究していくことにしよう。

BlazeDS入門記（Example BlazeDS applications）

2010-04-05T13:50:00.009+09:00

Getting started with BlazeDS / Introduction to BlazeDS / Example BlazeDS applications

今回は、ほとんどマニュアルをなぞってるだけです。

RPC service example

Remoting Service は BlazeDS に含まれる RPC サービスの１つです。クライアントは Remoting Service によりサーバ上の POJO にアクセスできます。

この例では、クライアントから渡された文字列をエコーバックする EchoService.java という java のクラスをサーバ上にデプロイします。

EchoService.java

package remoting;
public class EchoService
{
    public String echo(String text) {
        return "Server says: I received '" + text + "' from you";
    }
}

echo()メソッドは String の引数を受け、それにテキストを付加したものを返します。EchoService.java をコンパイル後、EchoService.class を WEB-INF/classes/remoting ディレクトリ以下に配置します。java クラスが BlazeDS に一切依存していないところが重要。

destination を定義し、ひとつ以上の channel を参照します。WEB-INF/flex/remoting-config.xml　を編集して、EchoService.class を Remoting Service の destination として設定します。

<destination id="echoServiceDestination" channels="my-amf">
    <properties>
        <source>remoting.EchoService</source>
    </properties>
</destination>

source 要素は java クラスを参照しています。そして channels 属性は my-amf という名前の channel を参照します。

以下のように WEB-INF/flex/services-config.xml に my-amf channel を定義します。

<channel-definition id="my-amf" class="mx.messaging.channels.AMFChannel">
    <endpoint url="http://{server.name}:{server.port}/{context.root}/messagebroker/amf" 
        class="flex.messaging.endpoints.AMFEndpoint"/>
    <properties>
        <polling-enabled>false</polling-enabled>
    </properties>
</channel-definition>

この channel 定義は Flex クライアントがサーバ上の AMFEndpoint に non-polling AMFChannel を使用することを指定しています。

今回作成する Flex client application は EchoService へのアクセスに RemoteObject コンポーネントを使用します。RemoteObject コンポーネントは destination を特定するために destination を使用します。ユーザがボタンをクリックすると、サーバ上の echo() メソッドが呼び出されます。

<?xml version="1.0"?>
<!-- intro\intro_remoting.mxml --> 
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" 
    width="100%" height="100%">

    <mx:Script>
        <![CDATA[
            import mx.rpc.events.FaultEvent;
            import mx.rpc.events.ResultEvent;

            // Send the message in response to a Button click.
            private function echo():void {
                var text:String = ti.text;
                remoteObject.echo(text);
            }

            // Handle the recevied message.
            private function resultHandler(event:ResultEvent):void {
                ta.text += "Server responded: "+ event.result + "\n";
            }

            // Handle a message fault.
            private function faultHandler(event:FaultEvent):void {
                ta.text += "Received fault: " + event.fault + "\n";
            }
        ]]>
    </mx:Script>

    <mx:RemoteObject id="remoteObject"
        destination="echoServiceDestination"
        result="resultHandler(event);"
        fault="faultHandler(event);"/>
        
    <mx:Label text="Enter a text for the server to echo"/>
    <mx:TextInput id="ti" text="Hello World!"/>
    <mx:Button label="Send" click="echo();"/>
    <mx:TextArea id="ta" width="100%" height="100%"/>
</mx:Application>

Flash Builder か mxmlc コンパイラを使用してクライアントアプリケーションを SWF ファイルにコンパイルし、Webアプリケーションにデプロイします。

Messaging Service example

クライアントアプリケーションは、Messaging Service により他のクライアントとのメッセージの送受信ができます。今回の例では、同一の BlazeDS destination へのメッセージの送受信をする Flex アプリケーションを作成します。

次のように WEB-INF/flex/messaging-config.xml に messaging destination を定義します。

<destination id="MessagingDestination" channels="my-amf-poll"/>

次のように WEB-INF/flex/services-config.xml に my-amf-poll channel を定義します。

<channel-definition id="my-amf-poll" class="mx.messaging.channels.AMFChannel">
    <endpoint
        url="http://{server.name}:{server.port}/{context.root}/messagebroker/amfpoll"
        class="flex.messaging.endpoints.AMFEndpoint"/>
    <properties>
        <polling-enabled>true</polling-enabled>
        <polling-interval-seconds>1</polling-interval-seconds>
    </properties>
</channel-definition>

このチャネル定義はインターバルが１秒のポーリングチャネルを定義しています。そのため、このクライアントはサーバに１秒ごとにポーリングメッセージを送ります。ポーリングチャネルはクライアントが変更通知を受けるもっとも簡単な方法です。他の選択肢としては、piggybacking を用いたポーリング、long-polling、streaming があります。

以下の Flex クライアントアプリケーションはメッセージの送信に Producer コンポーネントを、受信に Consumer コンポーネントを使用しています。メッセージを送信するために Producer はまず AsyncMessage クラスのインスタンスを作成してその body 要素にメッセージをセットします。そして Producer.send() メソッドによって送信します。メッセージを受信するためには、Consumer はまず Consumer.subscribe() メソッドにより特定の destination に対して送信されるメッセージに対するサブスクライブをします。

<?xml version="1.0"?>
<!-- intro\intro_messaging.mxml --> 
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" 
    width="100%" height="100%"
    creationComplete="consumer.subscribe();">

    <mx:Script>
        <![CDATA[
            import mx.messaging.events.MessageFaultEvent;
            import mx.messaging.events.MessageEvent;
            import mx.messaging.messages.AsyncMessage;
            import mx.messaging.Producer;
            import mx.messaging.Consumer;

            // Send the message in response to a Button click.
            private function sendMessage():void {
                var msg:AsyncMessage = new AsyncMessage();
                msg.body = "Foo";
                producer.send(msg);
            }
            
            // Handle the received message.
            private function messageHandler(event:MessageEvent):void {
                ta.text += "Consumer received message: "+ event.message.body + "\n";
            }

            // Handle a message fault.
            private function faultHandler(event:MessageFaultEvent):void {
                ta.text += "Received fault: " + event.faultString + "\n";
            }
        ]]>
    </mx:Script>

    <mx:Producer id="producer"
        destination="MessagingDestination"
        fault="faultHandler(event);"/>

    <mx:Consumer id="consumer"
        destination="MessagingDestination"
        fault="faultHandler(event);"
        message="messageHandler(event);"/>

    <mx:Button label="Send" click="sendMessage();"/>
    <mx:TextArea id="ta" width="100%" height="100%"/>
</mx:Application>

Flash Builder か mxmlc コンパイラを使用してクライアントアプリケーションを SWF ファイルにコンパイルし、Webアプリケーションにデプロイします。