17章中間試験

トップ->Java Applet入門

Java入門内検索

このページの先頭に戻る

トップページに戻る

このページの先頭に戻る
 トップページに戻る

トップ-> Java入門：17章中間試験-> 解答例

前ページへ　:　トップへ　:　次章へ

4. 解答例


WebServer.java

import java.io.*;
import java.util.*;

public class WebServer{
    private static String    m_strFolder;                  // ファイルが格納されているフォルダ
    private static Log       m_log = new Log();            // ログ
    private static Listener  m_Listener = new Listener();  // メインスレッド
    private static int       m_nPort;                      // ポート番号

    public static void main(String args[]){
        // タイトル表示
        showTitle();

        // 引数が１つでなかったら使用法を表示する
        if( args.length != 1 ){
            showUsage();
            return;
        }

        // 初期化
        if( initialize(args[0]) == false )
            return;

        // 待ち受けスレッド開始
        m_Listener.start();

        // キーボードからの入力ストリーム
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);

        // キーボードから入力
        String str;
        while(true){
            try{
                str = br.readLine();
                str = str.toLowerCase();
                if( str.equals("exit") || str.equals("quit") ){
                    System.out.println("終了処理を開始します。しばらくお待ちください");
                    m_Listener.terminate();
                    m_log.terminate();
                    break;
                }
            }catch(Exception e){}
        }
    }

    // ログに追加
    static void writeLog(String str){
        m_log.writeLog(str);
        System.out.println(str);
    }

    // フォルダを取得する
    static String getFolder(){
        return m_strFolder;
    }

    // 設定ファイルを開いて、初期化する
    private static boolean initialize(String strFileName){
        try{
            // 初期化ファイルを開く
            FileReader fr = new FileReader(strFileName);
            BufferedReader br = new BufferedReader(fr);
            String strLine;

            // １行読み込み
            while( (strLine = br.readLine()) != null ){
                // 読み込んだ１行を元にStreamTokenizerをつくる
                StringReader    sr = new StringReader(strLine);
                StreamTokenizer st = new StreamTokenizer(sr);

                // NullPointerExceptionが起こらないように、ダミー文字を入れておく
                String strFirstToken  = "";
                String strSecondToken = "";
                int nNumber = -1;

                // 最初のトークンの処理
                if(st.nextToken() != st.TT_EOF && st.ttype == st.TT_WORD){
                    // 単語の場合
                    strFirstToken =  st.sval;
                }
                else{
                    showInitFormatError();
                    fr.close();
                    return false;
                }

                // ２つめのトークンの処理（[=]が入るはず
                if( st.nextToken() != st.TT_EOF && st.ttype == (int)'=' ){
                }
                else{
                    showInitFormatError();
                    fr.close();
                    return false;
                }

                // ３つめのトークンの処理
                if(st.nextToken() != st.TT_EOF){
                    if( st.ttype == st.TT_WORD || st.ttype == '\"' )
                        // 単語の場合
                        strSecondToken =  st.sval;
                    else if( st.ttype == st.TT_NUMBER )
                        // 数字の場合
                        nNumber = (int)st.nval;
                }
                else{
                    showInitFormatError();
                    fr.close();
                    return false;
                }

                /* トークンの前処理
                    最初のトークンは小文字に変換する
                    最後のトークンはダブルクォーテーションで始まっていたり終わっていたらそれを除去する */
                strFirstToken = strFirstToken.toLowerCase();
                if( strSecondToken.length() > 1 && strSecondToken.startsWith("\"") )
                    strSecondToken = strSecondToken.substring(1);
                if( strSecondToken.length() > 1 && strSecondToken.endsWith("\"") )
                    strSecondToken = strSecondToken.substring(0, strSecondToken.length()-1);

                // folder設定の場合
                if( strFirstToken.equals("folder") ){
                    File file = new File(strSecondToken);
                    if( file.isDirectory() == true )
                        m_strFolder = strSecondToken;
                    else{
                        showInitFolderError();
                        fr.close();
                        return false;
                    }
                }

                // logファイル設定の場合
                if( strFirstToken.equals("log") ){
                    if( m_log.createLog(strSecondToken) == false ){
                        showInitLogError();
                        fr.close();
                        return false;
                    }
                }

                // ポート番号の場合
                if( strFirstToken.equals("port") ){
                    try{
                        // ポート番号をリスナーにセットする
                        if( m_Listener.setPort(nNumber) == false ){
                            showInitPortError();
                            fr.close();
                            return false;
                        }
                    }catch(NumberFormatException e){
                        showInitFormatError();
                        fr.close();
                        return false;
                    }
                }
            }// ↑while
            if( m_strFolder == null ){
                showInitFormatError();
                fr.close();
                return false;
            }

            fr.close();
            return true;
        }
        catch(FileNotFoundException e){
            showInitLoadError();
            return false;
        }
        catch(IOException e){
            showInitLoad2Error();
            return false;
        }
    }

    // 設定エラー（ポートが開けない）
    private static void showInitPortError(){
        System.err.println("ポートが開けませんでした。");
    }

    // 設定エラー（ファイルが見つからない）
    private static void showInitLoadError(){
        System.err.println("設定ファイルが見つかりません。");
    }

    // 設定エラー（ファイルが見つからない）
    private static void showInitLoad2Error(){
        System.err.println("設定ファイルが読み込めません");
    }

    // 設定エラー（フォルダが見つからない）
    private static void showInitFolderError(){
        System.err.println("設定ファイルで指定されているフォルダが見つかりません");
    }

    // 設定エラー（フォルダが見つからない）
    private static void showInitLogError(){
        System.err.println("設定ファイルで指定されているログファイルに書き込みができません。");
    }

    // 設定エラー表示
    private static void showInitFormatError(){
        System.err.println("設定ファイルのフォーマットが違うため、初期できません。");
        System.err.println();
        System.err.println("Usage:");
        System.err.println("Port=80                    /ポート番号");
        System.err.println("Folder=\"C:\\Web\"            /htmlファイルなどの入っているフォルダ");
        System.err.println("Log=\"C:\\Web\\Web.log\"       /ログをとる場合、ログファイル名");
    }

    // このソフトのタイトルを表示する
    private static void showTitle(){
        System.err.println("JavaWebServer Version 1.0");
        System.err.println("               Copyright 2005 by 目指せプログラマー！");
        System.err.println("               http://hp.vector.co.jp/authors/VA000124/");
        System.err.println();
    }

    // このソフトの使用法を表示する
    private static void showUsage(){
        System.err.println("usage:  java WebServer [ini file]");
    }
}

Log.java
import java.io.*;
import java.util.*;

// ログファイルを司るクラス
class Log extends Thread{
    // ログファイル
    private PrintWriter m_pwLogFile;

    // 書き込むメッセージの一時保管場所
    private Vector      m_vctMessage = new Vector();

    // スレッドの継続フラグ(同期させるのでプリミティブ型ではなくクラスオブジェクト）
    private Boolean     m_bContinue = Boolean.FALSE;

    // ログファイルを開き、ストリームを作る
    boolean createLog(String strFileName){
        // まだストリームがなければ作成する
        if( m_pwLogFile == null ){
            try{
                // ファイルを開いて、PrintWriterにつなぐ
                FileWriter  fw = new FileWriter(strFileName, true);
                m_pwLogFile = new PrintWriter(fw);

                m_bContinue = Boolean.TRUE;
                start();
                return true;
            }catch(Exception e){
                // エクセプションなら失敗
                m_pwLogFile = null;
                return false;
            }
        }
        else{
            // すでにストリームがあれば失敗
            return false;
        }
    }

    // スレッド本体
    public void run(){
        if( m_pwLogFile != null ){
            while(m_bContinue.booleanValue()){
                try{
                    // 起こされるまで待つ
                    synchronized(this){
                        wait();
                    }
                }catch(InterruptedException e){}
                synchronized(m_bContinue){
                    for( int i = 0 ; i < m_vctMessage.size() ; i++ ){
                        // ベクターから取り出して、ファイルに書き込む
                        m_pwLogFile.println( (String)m_vctMessage.elementAt(i) );
                    }
                    // すべてベクターから消す
                    m_vctMessage.removeAllElements();

                    // フラッシュ
                    m_pwLogFile.flush();
                }
            }
        }
    }


    // 外からスタートを呼ばれないようにprivateでオーバーライドする
    private void start(){
        if( m_pwLogFile != null ){
            super.start();
        }
    }

    // スレッドを終了させる
    void terminate(){
        // 同期をとる
        synchronized(m_bContinue){
            m_bContinue = Boolean.FALSE;
        }

        // 寝ているスレッドを起こす
        synchronized(this){
            notify();
        }

        // スレッドが終わるまで待つ
        try{
            join();
        }catch(Exception e){}
    }

    // ログに書き込む内容を通達する
    void writeLog(String str){
        // ストリームが開いており、スレッドが起動していれば
        if( m_pwLogFile != null && m_bContinue.booleanValue() ){
            // 同期をとる
            synchronized(m_bContinue){
                m_vctMessage.addElement(str);
            }

            // 寝ているスレッドを起こす
            synchronized(this){
                notify();
            }
        }
    }
}

Listener.java
import java.net.*;
import java.util.*;

class Listener extends Thread{
    // HTTPスレッドを格納するベクター
    private Vector m_vctHTTPThread;

    // ポート番号
    private int m_nPort;

    // サーバーソケット
    ServerSocket m_Server;

    // 継続フラグ
    boolean m_bContinue;

    // コンストラクタ
    Listener(){
        m_vctHTTPThread = new Vector();
        m_nPort = -1;
        m_bContinue = false;
    }

    // ポートのセット
    boolean setPort(int nPort){
        if( 0 < nPort && nPort < 65535 && isAlive() == false ){
            try{
                // サーバーソケット作成
                m_Server = new ServerSocket(nPort);
                m_nPort = nPort;
                return true;
            }catch(Exception e){}
        }

        // 失敗の場合
        m_Server = null;
        m_bContinue = false;
        return false;
    }

    public void start(){
        // サーバーソケットができていなければ（setPortが呼ばれていなければ）開始しない
        if( m_Server == null )
            return;

        // 継続フラグ
        m_bContinue = true;

        // スレッド開始
        super.start();
    }

    // スレッドの停止
    void terminate(){
        // setPortが呼ばれていない場合は終了
        if( m_Server == null )
            return;

        // 継続フラグをfalseにする
        m_bContinue = false;

        // ソケットを閉じる
        try{
            m_Server.close();
        }catch(Exception e){}

        // 同期させる
        // この中に入るのはrunが終わっているはず
        synchronized(m_vctHTTPThread){
            // ベクターの中身のスレッドをすべて終了させる
            for( int i = 0 ; i < m_vctHTTPThread.size() ; i++ ){
                HTTPThread http = (HTTPThread)m_vctHTTPThread.elementAt(i);
                http.terminate();
            }
        }
        try{
            join();
        }catch(Exception e){}
    }

    // メインスレッド
    public void run(){
        // setPortが呼ばれていない場合は終了
        if( m_Server == null )
            return;

        // スレッド本体
        while( m_bContinue ){
            Socket sock;
            try{
                // 同期させる
                synchronized(m_vctHTTPThread){
                    // 接続を待つ
                    sock = m_Server.accept();

                    // 接続されたらHTTPThreadを作成する
                    HTTPThread http = new HTTPThread(this, sock);

                    // 新たなオブジェクトをベクターに詰める
                    m_vctHTTPThread.addElement(http);

                    // スレッド開始
                    http.start();
                }
            }catch(Exception e){}
        }
    }

    // HTTPThreadのスレッドが終わったことを通知する
    void threadEnd(HTTPThread t){
        m_vctHTTPThread.removeElement(t);
    }
}

HTTPThread.java
import java.net.*;
import java.io.*;
import java.util.*;

// 実際に通信するスレッド
class HTTPThread extends Thread{
    Socket   m_sock;
    Listener m_listener;

    HTTPThread(Listener listener, Socket sock){
        // nullだった場合
        if( sock == null )
            throw new NullPointerException();
        m_sock = sock;

        // nullだった場合
        if( listener == null )
            throw new NullPointerException();
        m_listener = listener;
    }

    // スレッドメイン
    public void run(){
        String strToken = "";
        String strLog = "";

        InputStream  is = null;
        OutputStream os = null;
        try{
            // ストリーム作成
            os = m_sock.getOutputStream();
            is = m_sock.getInputStream();
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);

            // １行読み込み
            String strLine = br.readLine();

            // トークナイザー
            StringTokenizer st = new StringTokenizer(strLine);
            while(st.hasMoreTokens()){
                strToken = st.nextToken();
                // ファイル取得なら
                if( strToken.equals("GET") ){
                    // 次のトークン取得
                    if( st.hasMoreTokens() ){
                        strToken = st.nextToken();

                        // ターゲットを送る
                        if( sendTarget(strToken) ){
                            strLog = strLog + new Date() + '\t';
                            strLog = strLog + m_sock.getInetAddress().getHostName() + '\t';
                            strLog = strLog + "OK\t";
                            strLog = strLog + strToken;

                            // ログ付け
                            WebServer.writeLog(strLog);

                        }
                        else{
                            strLog = strLog + new Date() + '\t';
                            strLog = strLog + m_sock.getInetAddress().getHostName() + '\t';
                            strLog = strLog + "Failed\t";
                            strLog = strLog + strToken;

                            // ログ付け
                            WebServer.writeLog(strLog);
                        }
                        // ストリームをクローズ
                        is.close();
                        os.close();
                        m_sock.close();

                        // リスナーにスレッドが終わったことを通知する
                        m_listener.threadEnd(this);
                        return;
                    }
                }
            }
        }catch(Exception e){}
        strLog = strLog + new Date() + '\t';
        strLog = strLog + m_sock.getInetAddress().getHostName() + '\t';
        strLog = strLog + "Failed\t";

        // ログ付け
        WebServer.writeLog(strLog);

        // ストリームをクローズ
        try{
            if( is != null )    is.close();
            if( os != null )    os.close();
            m_sock.close();
        }catch(Exception e){}

        // リスナーにスレッドが終わったことを通知する
        m_listener.threadEnd(this);
    }

    // スレッド停止
    void terminate(){
        try{
            m_sock.close();
            join();
        }catch(Exception e){}
    }

    // ターゲット送信
    private boolean sendTarget(String strTarget){
        try{
            // 入出力ストリーム
            FileInputStream fis = new FileInputStream(WebServer.getFolder() + strTarget); 
            OutputStream os = m_sock.getOutputStream();
            BufferedOutputStream bos = new BufferedOutputStream(os);
            OutputStreamWriter osw = new OutputStreamWriter(bos);

            osw.write("HTTP/1.1 200 OK\r\n");
            osw.write("Server:JavaWebServer Version.1\r\n");
            osw.write("Connection: close\r\n\r\n");
            osw.flush();

            byte[] buf = new byte[1024];
            int nRet;
            // ファイルを読み込む
            while( (nRet = fis.read(buf)) > 0 ){
                // 送信する
                bos.write(buf, 0, nRet);
            }
            // ストリームをクローズ
            fis.close();

            return true;

        // ファイルが見つからない
        }catch(FileNotFoundException e){
            sendFileNotFound();
        }catch(Exception e){}
        return false;
    }

    // ファイルが見つからない
    private void sendFileNotFound(){
        try{
            // ストリーム
            OutputStream os = m_sock.getOutputStream();
            BufferedOutputStream bos = new BufferedOutputStream(os);
            OutputStreamWriter osw = new OutputStreamWriter(bos);

            // エラー送信
            osw.write("HTTP/1.1 404 Not Found\r\n");
            osw.flush();
        }catch(Exception e){}
    }
}

WebServer.ini
Port=80
Folder="C:\\Java\\WebServer\\java"
Log="C:\\Java\\WebServer\\WebServer.log"


C:\Java\WebServer\>java WebServer WebServer.ini
JavaWebServer Version 1.0
               Copyright 2005 by 目指せプログラマー！
               http://hp.vector.co.jp/authors/VA000124/

<<ここでブラウザのアドレス欄に「http://127.0.0.1/index.html」と入力>>
Sun Jan 16 06:16:52 JST 2005    localhost       OK      /index.html
exit
終了処理を開始します。しばらくお待ちください

C:\Java\WebServer\>

前ページへ　:　トップへ　:　次章へ