FrontPage

Java/ソケットサンプル

Javaでクライアントとして動作するサンプルを解説する。

C++/ソケットサンプル1(Linuxサーバ)
C++/ソケットサンプル2(Windowsサーバ・クライアント)

制約

サンプルとして、ホスト名"clove.la"でアクセスできること。
サンプルとして、ポート"57891"でアクセスできること。
コンパイルのコマンドラインは"javac cl_javaCl.java"

ファイル名: cl_javaCl.java

import java.io.*;                                               //  標準入出力                                    //
import java.net.*;                                              //  ネットワークライブラリ                        //
                                                                //                                                //
public class cl_javaCl                                          //  javaクライアントクラス                        //
{                                                               //                                                //
    private final int ARG_NUM       =   2;                      //  引数の数                                      //
    private final int MAX_SESSIONS  =   2;                      //  最大セッション数                              //
    private final int RET_OK        =   0;                      //  正常終了                                      //
    private final int RET_NG        =   (-1);                   //  異常終了                                      //
    private final int IND_TRUE      =   10;                     //  真                                            //
    private final int IND_FALSE     =   0;                      //  偽                                            //
//    private final int SV_PORT       =   4519;                   //  使用ポート                                    //
    private final int SV_PORT       =   57891;                  //  使用ポート                                    //
    private final int ZERO          =   0;                      //  そのまま                                      //
    private final int SOCK_TIMER    =   5;                      //  ソケット接続待ち等タイマ                      //
    private final int DEF_BUFF_LEN  =   1200;                   //  通常バッファ長                                //
    private final int RETRY_COUNT   =   4;                      //  リトライ回数                                  //
    private InputStream INSO = null;                            //  入力ストリーム                                //
    private OutputStream OUSO = null;                           //  出力ストリーム                                //
    private Socket sock = null;                                 //  自ソケット                                    //
    private int vc_kill_threads = IND_FALSE;                    //  スレッド停止指示                              //
                                                                //                                                //
    public static void main( String[] args )                    //  メイン処理                                    //
    {                                                           //                                                //
        cl_javaCl obj_javaCl = new cl_javaCl();                 //  javaクライアントクラスの実体化                //
        obj_javaCl.start();                                     //  処理開始依頼                                  //
        return;                                                 //  正常終了                                      //
    }                                                           //                                                //
                                                                //                                                //
    public int start()                                          //  処理開始                                      //
    {                                                           //                                                //
        int rtnCod = RET_OK;                                    //  リターンコード                                //
        InputStreamReader INSR = new InputStreamReader( System.in ); //  InputStreamReaderを生成                  //
        BufferedReader BR = new BufferedReader( INSR );         //  BufferedReaderを生成                          //
        String strBuf = "";                                     //  文字列編集用                                  //
        byte[] byteBuf = new byte[DEF_BUFF_LEN];                //  ストリーム用バイト列                          //
        int retryInd = ZERO;                                    //  リトライ数                                    //
                                                                //                                                //
        Thread thCl = new Thread()                              //  スレッド生成                                  //
        {                                                       //                                                //
            public void run()                                   //                                                //
            {                                                   //                                                //
                try                                             //  例外対応                                      //
                {                                               //                                                //
                    connect();                                  //  セッション開始処理依頼                        //
                }                                               //                                                //
                catch( Exception e )                            //  例外処理                                      //
                {                                               //                                                //
                System.out.print( "connect error: " + e );      //  画面表示                                      //
                }                                               //                                                //
            }                                                   //                                                //
        };                                                      //                                                //
                                                                //                                                //
        thCl.start();                                           //  スレッド開始                                  //
                                                                //                                                //
        try                                                     //  例外対応                                      //
        {                                                       //                                                //
        for( ; ;  )                                             //  送信無限ループ                                //
        {                                                       //                                                //
            if( (null != sock) && sock.isConnected() )          //  ソケットが有効か                              //
            {                                                   //  ソケットが有効なら                            //
                strBuf = BR.readLine();                         //  一行読込                                      //
                if( strBuf.equals("q!") )                       //  セッション終了の合言葉か                      //
                {                                               //  セッション終了の合言葉なら                    //
                    vc_kill_threads = IND_TRUE;                 //  スレッド終了指示                              //
                    strBuf = "disconnect request from client.\n\n"; //  終了時文字列                              //
                    byteBuf = strBuf.getBytes( "UTF8" );        //  バイト列化                                    //
                    OUSO.write( byteBuf );                      //  送信する                                      //
                    Thread.sleep( 25 );                         //  スレッド終了を安全に                          //
                    disconnect();                               //  セッション終了依頼                            //
                    break;                                      //  送信無限ループを抜ける                        //
                }                                               //                                                //
                                                                //                                                //
                byteBuf = strBuf.getBytes( "UTF8" );            //  バイト列化                                    //
                OUSO.write( byteBuf );                          //  送信する                                      //
                Thread.sleep( 25 );                             //  やり過ぎ防止                                  //
            }                                                   //                                                //
            else                                                //  ソケットが無効の場合                          //
            {                                                   //                                                //
                if( RETRY_COUNT > retryInd++ )                  //  リトライ数上限に達するまで                    //
                {                                               //                                                //
                    System.out.print( "connecting.\n\n" );      //  画面表示                                      //
                    Thread.sleep( 500 );                        //  やり過ぎ防止                                  //
                    continue;                                   //  リトライ                                      //
                }                                               //                                                //
                System.out.print( "connection refused.\n\n" );  //  画面表示                                      //
                break;                                          //  受信無限ループを抜ける                        //
            }                                                   //                                                //
        }                                                       //                                                //
        }                                                       //                                                //
        catch( Exception e )                                    //  例外処理                                      //
        {                                                       //                                                //
        System.out.println( "send error:" + e );                //  画面表示                                      //
        }                                                       //                                                //
                                                                //                                                //
        return( rtnCod );                                       //  リターンを返して処理終了                      //
    }                                                           //                                                //
                                                                //                                                //
    private int connect()                                       //  セッション開始処理                            //
    {                                                           //                                                //
        int rtnCod = RET_OK;                                    //  リターンコード                                //
        int recvBytes;                                          //  受信バイト数                                  //
        String strBuf = "";                                     //  文字列編集用                                  //
        byte[] byteBuf = new byte[DEF_BUFF_LEN];                //  ストリーム用バイト列                          //
                                                                //                                                //
        System.out.print( "This is Client's Thread.\n\n" );     //  画面表示                                      //
                                                                //                                                //
        try                                                     //  例外対応                                      //
        {                                                       //                                                //
//        sock = new Socket( "localHost", SV_PORT );              //  ソケット生成                                  //
        sock = new Socket( "clove.la", SV_PORT );               //  ソケット生成                                  //
        INSO = sock.getInputStream();                           //  入力ストリーム                                //
        OUSO = sock.getOutputStream();                          //  出力ストリーム                                //
                                                                //                                                //
        for( ; ; )                                              //  受信無限ループ                                //
        {                                                       //                                                //
            if( (null != sock) && sock.isConnected() )          //  ソケットが有効か                              //
            {                                                   //  ソケットが有効なら                            //
                recvBytes = INSO.read( byteBuf );               //  一行読込                                      //
                if( IND_TRUE == vc_kill_threads )               //  スレッド終了指示があるか                      //
                {                                               //  スレッド終了指示がある場合                    //
                    break;                                      //  受信無限ループを抜ける                        //
                }                                               //                                                //
                                                                //                                                //
                if( ZERO >= recvBytes )                         //  正常に受信できなかったか                      //
                {                                               //  正常に受信できなかった場合                    //
                    continue;                                   //  ループの先頭へ                                //
                }                                               //                                                //
                strBuf = new String( byteBuf, 0, recvBytes, "UTF-8" ); //  文字列編集                             //
                System.out.printf( "recvBytes = %d.\n\n", recvBytes ); //  画面表示                               //
                System.out.printf( "client rec: %s\n\n", strBuf );     //  画面表示                               //
            }                                                   //                                                //
            else                                                //  ソケットが無効の場合                          //
            {                                                   //                                                //
                break;                                          //  受信無限ループを抜ける                        //
            }                                                   //                                                //
        }                                                       //                                                //
        }                                                       //                                                //
        catch( Exception e )                                    //  例外処理                                      //
        {                                                       //                                                //
        System.out.println( "recv error:" + e );                //  画面表示                                      //
        }                                                       //                                                //
                                                                //                                                //
        return( rtnCod );                                       //  リターンを返して処理終了                      //
    }                                                           //                                                //
                                                                //                                                //
    private int disconnect()                                    //  セッション終了処理                            //
    {                                                           //                                                //
        int rtnCod = RET_OK;                                    //  リターンコード                                //
                                                                //                                                //
        try                                                     //  例外対応                                      //
        {                                                       //                                                //
//            sock.close();                                       //  ソケット解放                                  //
            sock.shutdownOutput();                              //  *いきなりcloseだとrecv error*                 //
            Thread.sleep( 1000 );                               //  受信スレッドが終了されるまで待つ              //
            sock.close();                                       //  ソケット解放                                  //
            sock = null;                                        //  ソケット後処理                                //
        }                                                       //                                                //
        catch( Exception e )                                    //  例外処理                                      //
        {                                                       //                                                //
        System.out.println( "disconnect error:" + e );          //  画面表示                                      //
        }                                                       //                                                //
                                                                //                                                //
        return( rtnCod );                                       //  リターンを返して処理終了                      //
    }                                                           //                                                //
}                                                               //                                                //

動作確認

>javac cl_javaCl.java

>java cl_javaCl
connecting.

This is Client's Thread.

q
recvBytes = 1.

client rec: q

q!

>

修正履歴


課題

shutdownOutput()について理解要。


トップ   編集 凍結 差分 バックアップ 添付 複製 名前変更 リロード   新規 一覧 単語検索 最終更新   ヘルプ   最終更新のRSS
Last-modified: 2012-03-08 (木) 00:24:13 (2878d)