JSR-353」タグアーカイブ

WebSocketにてJSON形式のデータをJavaFXとやり取りしてみる。の4

先ほどに続いて送受信部分

送信処理

  1. 画面の送信ボタンからSingleController#handleSendActionが呼ばれる。
  2. SingleController#handleSendActionから@ClientEndpointのsendメソッド(自分で作った普通のメソッド)を呼び出す。
  3. sendメソッド内でSession.getAsyncRemote().sendObject(dataObj)を呼び出す
  4. encodersに指定してあるClientEncoderクラスのencodeメソッドが呼び出される。
  5. encodeメソッドでエンコードされたデータ(JSON形式の文字列)がServerEndpointに送信される。

エコープログラムなのでServerEndpointで受信されたデータは(若干加工され)ClientEndpointに戻される。そのため、続けて受信処理が走る。

 

受信処理

  1. サーバからのデータがPushされる。
  2. @ClientEndpointのdecodersに指定してあるClientDecoderクラスのwillDecodeメソッドが呼び出され入力値がチェックされる。
  3. willDecodeの結果がtrueならば続けてdecodeメソッドが呼び出されてジェネリクスで指定した型(ClientData)にデコードされる。
  4. デコードされたデータを引数に@ClientEndpointの@OnMessageが呼び出される。ここはJavaFXのスレッド配下ではなく、WebSocketのスレッドに移っている。そのため、JavaFXのコントロールを直接操作することはできない。
  5. @OnMessageの中でPlatform.runLaterを呼び、JavaFXの画面操作(接続時処理ViewObj#write)の呼び出しを登録(?)する。
  6. JavaFXスレッドに戻り、JavaFXの画面操作が実行される。

(コントローラーの関連する部分)

public class SingleController implements Initializable {
    @FXML
    private void handleSendAction(ActionEvent event) {
        System.out.println("SingleController#handleSendAction");
        wsClient.send(msgInput.getText(), sess);
    }
}

(ClientEndpointの関連する部分)

@ClientEndpoint( 
   decoders = { ClientDecoder.class }, 
   encoders = { ClientEncoder.class })
public class WSJsonSingleClient {

    @OnMessage
    public void onMessage(ClientData dataObj) {
        System.out.println("WSJsonSingleClient#onMessage");
        final ClientData channeled = dataObj;
        Platform.runLater(new Runnable() {
            @Override
            public void run() {
                viewObj.write(
                        channeled.getSessionId(), 
                        channeled.getMessageTimeString(), 
                        channeled.getMessage());
            };
        });
    }

    public void send(String text,Session sess) {
        System.out.println("WSJsonSingleClient#send");
        ClientData dataObj = new ClientData(text);
        sess.getAsyncRemote().sendObject(dataObj);
    }
}

(ClientEncoder)

public class ClientEncoder implements Encoder.Text<ClientData> {

    @Override
    public void init(EndpointConfig paramEndpointConfig) {
        System.out.println("ClientEncoder#init");
    }

    @Override
    public void destroy() {
        System.out.println("ClientEncoder#destroy");
    }

    @Override
    public String encode(ClientData paramData) throws EncodeException {
        System.out.println("ClientEncoder#encode");
        JsonObject model = Json.createObjectBuilder()
                   .add("message", paramData.getMessage())
                   .add("messageTime",paramData.getMessageTime())
                   .build();
        return model.toString();
    }
}

(ClientDecoder)

public class ClientDecoder implements Decoder.Text<ClientData> {

    @Override
    public void destroy() {
        System.out.println("ClientDecoder#destroy");
    }

    @Override
    public void init(EndpointConfig arg0) {
        System.out.println("ClientDecoder#init");
    }

    @Override
    public ClientData decode(String inputString) throws DecodeException {
        System.out.println("ClientDecoder#decode");
        try{
            JsonObject jsonObject = Json.createReader(new StringReader(inputString)).readObject();
            return  new ClientData(jsonObject);
        } catch(Exception e){
            e.printStackTrace();
            throw new DecodeException(inputString,"ClientDecoder#decode失敗", (Throwable)e);
        }
    }

    @Override
    public boolean willDecode(String inputString) {
        try {
            System.out.println("ClientDecoder#willDecode");
            Json.createReader(new StringReader(inputString)).readObject();
            return true;
        } catch (JsonException ex) {
            ex.printStackTrace();
            return false;
        }
    }
}

github:https://github.com/epea/test01/tree/WF_JSON_FX_SINGLE

WebSocketにてJSON形式のデータをJavaFXとやり取りしてみる。の3

先ほどの続き

接続処理

  1. 画面の開始ボタンからSingleController#handleStartButtonActionが呼ばれる。
  2. handleStartButtonAction内でClientManager#connectToServerを呼びWebSocketの起動を開始する。
  3. WebSocketの@OnOpenが呼ばれる。ここはJavaFXのスレッド配下ではなく、WebSocketのスレッドに移っている。そのため、JavaFXのコントロールを直接操作することはできない。
  4. @OnOpenの中でPlatform.runLaterを呼び、JavaFXの画面操作(接続時処理ViewObj#open)の呼び出しを登録(?)する。
  5. JavaFXスレッドに戻り、JavaFXの画面操作が実行される。

切断処理1

  1. 画面の終了ボタンからSingleController#handleStoptButtonActionが呼ばれる。
  2. Session#closeを呼び出し、WebSocketの終了処理を開始する。
  3. 切断処理2に続く

 

切断処理2

  1. 「切断処理1」または「ServerEndpointからの切断」等により、WebSocketの@OnCloseが呼ばれる。ここはJavaFXのスレッド配下ではなく、WebSocketのスレッドに移っている。そのため、JavaFXのコントロールを直接操作することはできない。
  2. @OnCloseの中でPlatform.runLaterを呼び、JavaFXの画面操作(接続時処理ViewObj#close)の呼び出しを登録(?)する。
  3. JavaFXスレッドに戻り、JavaFXの画面操作が実行される。

(コントローラーの関連する部分)

public class SingleController implements Initializable {

    private WSJsonSingleClient wsClient = null;
    private Session sess = null;

    // 略

    @FXML
    private void handleStartButtonAction(ActionEvent event) {
        System.out.println("SingleController#handleStartButtonAction");
        try {
            ClientManager m = org.glassfish.tyrus.client.ClientManager
                    .createClient();
            URI clientURI = new URI("ws://localhost:8080/first/hellojson/");
            sess = m.connectToServer(wsClient, clientURI);

        } catch (DeploymentException | URISyntaxException e) {
            Logger.getLogger(SampleController.class.getName()).log(
                    Level.SEVERE, null, e);
        }
    }

    @FXML
    private void handleStoptButtonAction(ActionEvent event) {
        System.out.println("SingleController#handleStoptButtonAction");
        try {
            sess.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

   // 略
}

(ClientEndpointの関連する部分)

@ClientEndpoint( decoders = { ClientDecoder.class }, encoders = { ClientEncoder.class })
public class WSJsonSingleClient {
    // 略
    @OnOpen
    public void onOpen(Session session) {
        System.out.println("WSJsonSingleClient#onOpen");
        Platform.runLater(new Runnable() {
            @Override
            public void run() {
                viewObj.open();
            };
        });
    }

    // 略

    @OnClose
    public void closeConnection(Session session) {
        System.out.println("WSJsonSingleClient#closeConnection");
        Platform.runLater(new Runnable() {
            @Override
            public void run() {
                viewObj.close();
            };
        });
    }
    // 略
}

github:https://github.com/epea/test01/tree/WF_JSON_FX_SINGLE

JSON送受信部分へ

 

WebSocketにてJSON形式のデータをJavaFXとやり取りしてみる。の2

先ほどの続き

前提条件

  • JavaFXのコントロール(ラベルとかボタンとか)はJavaFXのスレッド配下からでないと原則(※1)操作できない(と思う)
  • WebSocketはプログラム本体とは別のスレッドでデータの送受信を行う。
  • WebSocketのスレッド内からPlatform#runLaterを呼ぶことで、JavaFXのスレッド配下で行わせたい処理を登録できる。
  • 今の実装だと、接続状況の排他制御がきちんとされていないので、「サーバからの切断」と「クライアントからの起動」のシーケンスが重なったときとかにうまく動かないケースがでてくる。(はず)

※1 こちらにあるようにコントロールに結びついたObservableListを別スレッドから操作した場合は、その操作が画面に反映される。ラベルとかボタンとかのコントロールで試した範囲ではJavaFXのスレッドかどうかチェックにかかってうまくいかなかったがやりようはあるかもしれない。

ApplicationクラスとFXML

Applicationクラスは起動するだけ。

public class WSJsonSingle extends Application {

    @Override
    public void start(Stage stage) throws Exception {
        Parent root = FXMLLoader.load(getClass().getResource("SingleJson.fxml"));
        Scene scene = new Scene(root);
        stage.setScene(scene);
        stage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

 

FXMLはfx:idふって、onActionを紐付けている程度。

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

<?import java.lang.*?>
<?import java.util.*?>
<?import javafx.scene.*?>
<?import javafx.scene.control.*?>
<?import javafx.scene.layout.*?>

<AnchorPane prefHeight="363.0" prefWidth="502.0" xmlns:fx="http://javafx.com/fxml" fx:controller="jp.co.epea.wsclient.SingleController">
  <children>
    <Label alignment="CENTER" contentDisplay="CENTER" prefHeight="43.0" prefWidth="502.0" text="JSON送受信" />
    <VBox layoutY="43.0" prefHeight="331.0" prefWidth="502.0">
      <children>
        <HBox alignment="CENTER" prefHeight="100.0" prefWidth="200.0">
          <children>
            <Button fx:id="startButton" mnemonicParsing="false" onAction="#handleStartButtonAction" text="開始" />
            <Button fx:id="stopButton" mnemonicParsing="false" onAction="#handleStoptButtonAction" text="終了" />
            <Label fx:id="statusLabel" text="ステータス" />
          </children>
        </HBox>
        <HBox prefHeight="100.0" prefWidth="200.0">
          <children>
            <TextField fx:id="msgInput" editable="false" prefWidth="200.0" />
            <Button fx:id="sendButton" mnemonicParsing="false" onAction="#handleSendAction" text="送信" />
          </children>
        </HBox>
        <VBox prefHeight="200.0" prefWidth="100.0">
          <children>
            <HBox prefHeight="100.0" prefWidth="200.0">
              <children>
                <Label text="発言者:" />
                <Label fx:id="nameLabel" text="発言者初期値(起動時に変更)" />
              </children>
            </HBox>
            <HBox prefHeight="100.0" prefWidth="200.0">
              <children>
                <Label text="発言日時:" />
                <Label fx:id="timeLabel" text="発言日時初期値(起動時に変更)" />
              </children>
            </HBox>
            <HBox prefHeight="100.0" prefWidth="200.0">
              <children>
                <Label text="発言内容:" />
                <Label fx:id="msgLabel" text="発言内容初期値(起動時に変更)" />
              </children>
            </HBox>
          </children>
        </VBox>
      </children>
    </VBox>
  </children>
</AnchorPane>

起動処理

WSJsonSingle#mainから。

画面項目の初期化と、ClientEndpointのインスタンス化(まだ接続しない)。

public class SingleController implements Initializable {

    private WSJsonSingleClient wsClient = null;

    @Override
    public void initialize(URL location, ResourceBundle resources) {
        // コントロールをまとめたクラスを作って
        ViewObj obj = new ViewObj(nameLabel, timeLabel, msgLabel, statusLabel,
                msgInput, startButton, stopButton, sendButton);
        // ClientEndpointに渡してインスタンス化
        wsClient = new WSJsonSingleClient(obj);
    }
}

public class ViewObj {
    private Label nameLabel;
   // 略
    ViewObj(Label nameLabel, Label timeLabel, Label msgLabel,
            Label statusLabel, TextField msgInput, Button startButton,
            Button stopButton, Button sendButton) {
        super();
        // 略
        // コントロール類の初期化(項目設定とか、ボタンのdisable周りとか)
        this.init();
    }

    private void init(){
        nameLabel.setText("");
        // 略
    }
}

@ClientEndpoint( decoders = { ClientDecoder.class }, encoders = { ClientEncoder.class })
public class WSJsonSingleClient {

    private ViewObj viewObj;

    public WSJsonSingleClient(ViewObj viewObj) {
        this.viewObj = viewObj;
    }
    // 略
}

github:https://github.com/epea/test01/tree/WF_JSON_FX_SINGLE

続き

WebSocketにてJSON形式のデータをJavaFXとやり取りしてみる

Glassfish4とJavaFX間でJSON形式のデータをWebsocketにてやり取りしてみたのでメモ。

何ページかに分かれているけど実際にJSONのハンドリングをしている箇所はこちら

サーバサイドはこの前HTMLとやり取りしたものとほぼ同じ。

大まかな動きは以下。なお、表示はリスト形式ではなくてラベルの中身を置換していく形式(表示以外はやっていることはHTMLの時とほぼ一緒)

  1. HTMLからJSONで入力テキストと現在日時を送信。
  2. GlassfishのWebsocketで受信(&Decode)
  3. 受け取ったデータに情報(とりあえずユーザ情報代わりのセッションID)を付与し繋がっているクライアント(JavaFX&この前作ったHTML)全体にJSON形式で返信
  4. JavaFX(またはHTML)で受け取ったデータを表示

データ形式はこの前と同じ。(なので、クライアントはこの前のHTMLとJavaFXで併用できる。)

(JavaFX->glassfishのデータ形式)
{"message":"メッセージ","messageTime":時間(ミリ秒)}

(glassfish->JavaFXのデータ形式)
{"message":"メッセージ","sessionId":"セッションID","messageTime":"HH:mm:ss"}

斜体は変数

Maven

必要な依存関係を追加。(動作確認はeclipse上のM2E)

    <dependencies>
       <!-- JavaFX 2 -->
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>javafx</artifactId>
            <version>2.2</version>
            <scope>system</scope>
            <systemPath>${javafx2.home}</systemPath>
        </dependency>
        <!-- Websocket (JSR-356) -->
        <!-- TYRUS-210の対応で1.2にあげている -->
        <dependency>
            <groupId>org.glassfish.tyrus</groupId>
            <artifactId>tyrus-client</artifactId>
            <version>1.2</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.glassfish.tyrus</groupId>
            <artifactId>tyrus-container-grizzly</artifactId>
            <version>1.2</version>
            <scope>compile</scope>
        </dependency>
        <!-- JSON Processing (JSR-353) -->
        <dependency>
            <groupId>javax.json</groupId>
            <artifactId>javax.json-api</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish</groupId>
            <artifactId>javax.json</artifactId>
            <version>1.0.2 </version>
        </dependency>
    </dependencies>

画面フロー

起動時

開始ボタンしか押せない状態。裏ではWebSocket用のClientEndPointをインスタンス化している。

initial

 

開始ボタンクリック後(の入力欄に文字入力した状態)

入力欄や送信ボタン・終了ボタンが使えるようになる。

bef_send

送信ボタンクリック後

入力メッセージと時間がサーバに送信される。そしてデータを受信したサーバにて加工(といってもセッションID文字列を付加しただけ)されたデータがクライアントに送られ、そのデータがラベルに表示される。

aft_send

 

終了ボタンクリック後

開始ボタンしか押せない状態になる。

closed

 

github:https://github.com/epea/test01/tree/WF_JSON_FX_SINGLE

続き。

WebSocketにてJSON形式のデータをやり取りしてみる(Glassfish 4)

Glassfish4とHTML間でJSON形式のデータをWebsocketにてやり取りしてみたのでメモ。

大まかな動きは以下

  1. HTMLからJSONで入力テキストと現在日時を送信。
  2. GlassfishのWebsocketで受信(&Decode)
  3. 受け取ったデータに情報(とりあえずユーザ情報代わりのセッションID)を付与し繋がっているクライアント(HTML)全体にJSON形式で返信
  4. HTMLで受け取ったデータを表示
(html->glassfishのデータ形式)
{"message":"メッセージ","messageTime":時間(ミリ秒)}

(glassfish->htmlのデータ形式)
{"message":"メッセージ","sessionId":"セッションID","messageTime":"HH:mm:ss"}

斜体は変数

Maven

必要な依存関係を追加。(動作確認はeclipse上のM2E)

    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-web-api</artifactId>
            <version>7.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- 8/10追記 javaee-web-apiの中に入っていたもので足りた -->
        <!-- Websocket (JSR-356) -->
        <dependency>
            <groupId>javax.net.websocket</groupId>
            <artifactId>javax.net.websocket-api</artifactId>
            <version>1.0-b06</version>
            <type>jar</type>
        </dependency>
        <dependency>
            <groupId>org.glassfish.websocket</groupId>
            <artifactId>websocket-api</artifactId>
            <version>0.2</version>
            <scope>provided</scope>
        </dependency>
        <!-- JSON Processing (JSR-353) を使う場合-->
        <dependency>
            <groupId>javax.json</groupId>
            <artifactId>javax.json-api</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish</groupId>
            <artifactId>javax.json</artifactId>
            <version>1.0.2 </version>
        </dependency>
    </dependencies>

画面

  1. new WebSocket(arg)のargで接続先指定をしてWebSocketオブジェクトを取得する
  2. 接続先は@ServerEndpointをつけたサーバサイドのPOJOに指定したもの。
  3. WebSocketのsendで送信、onmessageで受信
  4. Websocketで送られてきたデータはsocket.onmessageで渡される引数(今回はmessage)のdataに入っている。
  5. 取り出してからの扱いは普通のJSON。
 <!DOCTYPE html>
<html>
<head>
<title>JsonのWebSocketテスト</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<script
    src="//ajax.googleapis.com/ajax/libs/jquery/1.10.1/jquery.min.js"></script>
<script type="text/javascript">
    var socket;
    $(document).ready(
            function() {
                var host = "ws://localhost:8080/first/hellojson/";
                socket = new WebSocket(host);

                socket.onmessage = function(message) {
                    try {
                        var wsRes = $.parseJSON(message.data);
                        $('#log').append(
                                wsRes.messageTime +
                                "(送信者=" + wsRes.sessionId + "):" + 
                                wsRes.message + "<br/>");
                    } catch (e) {
                        alert(e);
                        return;
                    }
                }

                $('#send').click(function() {
                    var obj = new Object();
                    obj.message = $('#msg').val();
                    obj.messageTime = new Date().getTime();
                    var jsonString = JSON.stringify(obj);
                    socket.send(jsonString);
                    $('#msg').val('');
                })

            });
</script>
</head>
<body>
    <h1>JsonのWebSocketテスト</h1>
    <div id="log"></div>
    <input id="msg" type="text" />
    <button id="send">送信</button>
</body>
</html>

WebSocket用のPOJO(GlassFish側)

  1. @ServerEndpointをつけたPOJOでWebSocket用クラス(サーバエンドポイント)を作る
  2. パスはvalueで指定。自分の環境ではコンテキストがfirstなのでfirst/hellojson/がサーバエンドポイントのアドレス
  3. @onMessageが繋がっている(クライアントサイドの)エンドポイントから呼ばれたときに動く個所
  4. decodersでクラスを指定すると、やってきたメッセージが指定されたクラスでデコードされて渡される。
  5. encodersでクラスを指定すると、指定したクラスでエンコードしたデータを、繋がっているエンドポイントに渡せる。
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

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

import jp.co.epea.first.json.TestData;
import jp.co.epea.first.json.TestDecoder;
import jp.co.epea.first.json.TestEncoder;

@ServerEndpoint(value = "/hellojson/", 
decoders = { TestDecoder.class }, encoders = { TestEncoder.class })
public class HelloJson {

    static Set<Session> sessions = Collections
            .synchronizedSet(new HashSet<Session>());

    @OnMessage
    public void onMessage(TestData data, Session sess) {
        System.out.println("Call HelloJson:data[" + data + "]");
        data.setSessionId(sess.getId());
        for (Session s : sessions) {
            s.getAsyncRemote().sendObject(data);
        }
    }

    @OnOpen
    public void open(Session sess) {
        System.out.println("開始します:" + sess.getId());
        sessions.add(sess);
    }

    @OnClose
    public void close(Session sess) {
        System.out.println("終了します:" + sess.getId());
        sessions.remove(sess);
    }

    @OnError
    public void error(Session sess, Throwable t) {
        System.out.println("エラーです:" + sess.getId());
        t.printStackTrace();
    }
}

decodersのクラス

  1. javax.websocket.DecoderのText<T>をimplementsする。(Text形式であるJSONの場合)
  2. <T>に入るのはエンドポイントのOnMessageに渡したい型
  3. willDecodeメソッドがデコードできるかどうか判定。
  4. バリデーションとかはwillDecodeでなくOnMessageでやるべきがどうかは未調査。(未実装)
  5. decodeメソッドで返却するオブジェクトを生成しreturnする。
  6. JSON Processingを使っているが何を使ってObject化してもOK
import java.io.StringReader;

import javax.json.Json;
import javax.json.JsonException;
import javax.json.JsonObject;
import javax.websocket.DecodeException;
import javax.websocket.Decoder;
import javax.websocket.EndpointConfig;

public class TestDecoder implements Decoder.Text<TestData> {

@Override
public void destroy() {
System.out.println("TestDecoder#destroy");
}

@Override
public void init(EndpointConfig arg0) {
System.out.println("TestDecoder#init");
}

@Override
public TestData decode(String inputString) throws DecodeException {
JsonObject jsonObject = Json.createReader(new StringReader(inputString)).readObject();
return  new TestData(jsonObject);
}

/*
* Answer whether the given String can be decoded into an object of type
* T.だそう 入力チェックもここでやるのがよい?
*/
@Override
public boolean willDecode(String inputString) {
try {
Json.createReader(new StringReader(inputString)).readObject();
return true;
} catch (JsonException ex) {
ex.printStackTrace();
return false;
}
}
}

encodersのクラス

  1. javax.websocket.EncoderのText<T>をimplementsする。(Text形式であるJSONの場合)
  2. <T>に入るのはエンドポイントのOnMessageで呼ぶsendObjectの引数(返す元ネタ)
  3. encodeメソッドで返却するStringを生成しreturnする。
  4. JSON Processingを使っているが何を使ってString化してもOK
import java.text.SimpleDateFormat;
import java.util.Date;

import javax.json.Json;
import javax.json.JsonObject;
import javax.websocket.EncodeException;
import javax.websocket.Encoder;
import javax.websocket.EndpointConfig;

public class TestEncoder implements Encoder.Text {

	@Override
	public void init(EndpointConfig paramEndpointConfig) {
		System.out.println("TestEncoder#init");
	}

	@Override
	public void destroy() {
		System.out.println("TestEncoder#destroy");
	}

	@Override
	public String encode(TestData paramData) throws EncodeException {
		JsonObject model = Json.createObjectBuilder()
				   .add("message", paramData.getMessage())
				   .add("sessionId",paramData.getSessionId())
				   .add("messageTime", formatDate(paramData.getMessageTime()))
				   .build();
		return model.toString();
	}

	private String formatDate(long millDate){
		return new SimpleDateFormat("HH:mm:ss").format(new Date(millDate));
	}

}

データクラス

import javax.json.JsonObject;

public class TestData {

    // メッセージ
    private String message;
    // 送信日時
    private long messageTime;
    // sessionId(ユーザ名の変わり)
    private String sessionId;

    public TestData(JsonObject jsonObject) {
        if(jsonObject.containsKey("message")){
            this.message = jsonObject.getString("message");
        }
        if(jsonObject.containsKey("messageTime")){
            this.messageTime = jsonObject.getJsonNumber("messageTime").longValue();
        }
    }

    public void setSessionId(String sessionId) {
        this.sessionId = sessionId;
    }

    String getMessage() {
        return message;
    }

    long getMessageTime() {
        return messageTime;
    }

    String getSessionId() {
        return sessionId;
    }
}

github[https://github.com/epea/test01/tree/WS_JSON]

JSON Processing(JSR-353)に寄り道1

Websocketで複数のデータを送ろうとした際に、JavaEE7でJSON Processingが出てたのを思い出したので触ってみた。

ArunさんのブログにあるようにJSONとObject間のデータバインディングまではやってくれない。

(Note, binding JSON to Java objects and vice versa is not part of the scope of this JSR.)

想定用途(?)を探して見つけたブログによるとStaxでDom操作する感覚で使えるよとのこと。

->JCPにしっかり書いてあった。(2.1)

 

利用設定(Maven)

pomに依存関係を追加

        <!-- JSON Processing (JSR-353) -->
        <dependency>
            <groupId>javax.json</groupId>
            <artifactId>javax.json-api</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish</groupId>
            <artifactId>javax.json</artifactId>
            <version>1.0.2 </version>
        </dependency>

試したソース

import javax.json.Json;
import javax.json.JsonObject;
import javax.json.stream.JsonParser;

public class FirstJson01 {
    public static void main(String[] args) {
        System.out.println("生成");
        JsonObject model = Json.createObjectBuilder()
                   .add("firstName", "Duke")
                   .add("lastName", "Java")
                   .add("age", 18)
                   .add("streetAddress", "100 Internet Dr")
                   .add("city", "JavaTown")
                   .add("state", "JA")
                   .add("postalCode", "12345")
                   .add("phoneNumbers", Json.createArrayBuilder()
                      .add(Json.createObjectBuilder()
                         .add("type", "mobile")
                         .add("number", "111-111-1111"))
                      .add(Json.createObjectBuilder()
                         .add("type", "home")
                         .add("number", "222-222-2222")))
                   .build();

        String text = model.toString();
        System.out.println(text);

        System.out.println("解析");
        StringReader sr = new StringReader(text);
        JsonParser parser = Json.createParser(sr);
        while(parser.hasNext()){
            JsonParser.Event event = parser.next();
            System.out.println(event);
        }
    }
}

Eventの種類はSTART_OBJECT/END_OBJECT、START_ARRAY/END_ARRAY、KEY_NAME、VALUE_STRING、VALUE_NUMBER、VALUE_TRUE、VALUE_FALSE、VALUE_NULL。