サーブレット-クイックガイド
サーブレットとは何ですか？
Javaサーブレットは、Webまたはアプリケーションサーバー上で実行され、Webブラウザまたは他のHTTPクライアントからの要求とHTTPサーバー上のデータベースまたはアプリケーションの間の中間層として機能するプログラムです。
サーブレットを使用すると、Webページフォームを介してユーザーからの入力を収集し、データベースまたは別のソースからレコードを提示し、Webページを動的に作成できます。
Javaサーブレットは、多くの場合、Common Gateway Interface（CGI）を使用して実装されたプログラムと同じ目的を果たします。ただし、サーブレットには、CGIと比較していくつかの利点があります。
パフォーマンスが大幅に向上します。
サーブレットは、Webサーバーのアドレス空間内で実行されます。各クライアント要求を処理するために個別のプロセスを作成する必要はありません。
サーブレットはJavaで記述されているため、プラットフォームに依存しません。
サーバー上のJavaセキュリティー・マネージャーは、サーバー・マシン上のリソースを保護するために一連の制限を実施します。したがって、サーブレットは信頼されます。
Javaクラスライブラリの全機能をサーブレットで利用できます。すでに見たソケットとRMIメカニズムを介して、アプレット、データベース、またはその他のソフトウェアと通信できます。
サーブレットアーキテクチャ
次の図は、Webアプリケーションでのサーブレットの位置を示しています。
サーブレットタスク
サーブレットは次の主要なタスクを実行します-
クライアント（ブラウザ）から送信された明示的なデータを読み取ります。これには、Webページ上のHTMLフォームが含まれます。または、アプレットまたはカスタムHTTPクライアントプログラムから取得することもできます。
クライアント（ブラウザー）から送信された暗黙のHTTP要求データを読み取ります。これには、Cookie、メディアタイプ、ブラウザが理解できる圧縮スキームなどが含まれます。
データを処理して結果を生成します。このプロセスでは、データベースとの通信、RMIまたはCORBA呼び出しの実行、Webサービスの呼び出し、または応答の直接計算が必要になる場合があります。
明示的なデータ（つまり、ドキュメント）をクライアント（ブラウザー）に送信します。このドキュメントは、テキスト（HTMLまたはXML）、バイナリ（GIF画像）、Excelなどのさまざまな形式で送信できます。
暗黙のHTTP応答をクライアント（ブラウザー）に送信します。これには、ブラウザまたは他のクライアントに返されるドキュメントのタイプ（HTMLなど）の通知、Cookieとキャッシュパラメータの設定、およびその他のそのようなタスクが含まれます。
サーブレットパッケージ
Javaサーブレットは、Javaサーブレット仕様をサポートするインタプリタを備えたWebサーバーによって実行されるJavaクラスです。
サーブレットは、 javax.servlet そして javax.servlet.http パッケージは、Javaのエンタープライズエディションの標準部分であり、大規模な開発プロジェクトをサポートするJavaクラスライブラリの拡張バージョンです。
これらのクラスは、JavaサーブレットとJSPの仕様を実装します。このチュートリアルの執筆時点では、バージョンはJavaサーブレット2.5とJSP2.1です。
Javaサーブレットは、他のJavaクラスと同じように作成およびコンパイルされています。サーブレットパッケージをインストールしてコンピュータのクラスパスに追加した後、JDKのJavaコンパイラまたはその他の現在のコンパイラを使用してサーブレットをコンパイルできます。
次は何ですか？
サーブレットから始めるための環境をセットアップするために、段階的に説明します。だから、サーブレットで素敵なドライブのためにあなたのベルトを締めてください。このチュートリアルをとても楽しんでいただけると思います。
開発環境は、サーブレットを開発し、テストして、最後に実行する場所です。
他のJavaプログラムと同様に、Javaコンパイラを使用してサーブレットをコンパイルする必要があります。 javac サーブレットアプリケーションをコンパイルした後、テストして実行するために構成済みの環境にデプロイされます。
この開発環境のセットアップには、次の手順が含まれます。
Java DevelopmentKitのセットアップ
この手順では、Javaソフトウェア開発キット（SDK）の実装をダウンロードし、PATH環境変数を適切に設定します。
-あなたは、OracleのJavaサイトからSDKをダウンロードすることができたJava SEダウンロード。
Java実装をダウンロードしたら、所定の手順に従ってセットアップをインストールおよび構成します。最後に、PATHおよびJAVA_HOME環境変数を設定して、javaおよびjavacを含むディレクトリ（通常はそれぞれjava_install_dir / binおよびjava_install_dir）を参照します。
Windowsを実行していてSDKをC：\ jdk1.8.0_65にインストールしている場合は、C：\ autoexec.batファイルに次の行を配置します。
set PATH = C:\jdk1.8.0_65\bin;%PATH%
set JAVA_HOME = C:\jdk1.8.0_65または、Windows NT / 2000 / XPでは、[マイコンピュータ]を右クリックし、[プロパティ]、[詳細設定]、[環境変数]の順に選択することもできます。次に、PATH値を更新し、[OK]ボタンを押します。
Unix（Solaris、Linuxなど）では、SDKが/usr/local/jdk1.8.0_65にインストールされていて、Cシェルを使用している場合、.cshrcファイルに次のように記述します。
setenv PATH /usr/local/jdk1.8.0_65/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.8.0_65または、Borland JBuilder、Eclipse、IntelliJ IDEA、Sun ONE Studioなどの統合開発環境（IDE）を使用している場合は、簡単なプログラムをコンパイルして実行し、IDEがJavaのインストール場所を認識していることを確認します。
Webサーバーのセットアップ-Tomcat
サーブレットをサポートする多くのWebサーバーが市場で入手可能です。一部のWebサーバーは無料でダウンロードでき、Tomcatもその1つです。
Apache Tomcatは、JavaサーブレットおよびJava Server Pagesテクノロジーのオープンソースソフトウェア実装であり、サーブレットをテストするためのスタンドアロンサーバーとして機能し、ApacheWebサーバーと統合できます。マシンにTomcatをセットアップする手順は次のとおりです-
Tomcatの最新バージョンをからダウンロードします https://tomcat.apache.org/。
インストールをダウンロードしたら、バイナリディストリビューションを便利な場所に解凍します。たとえば、Windowsの場合はC：\ apache-tomcat-8.0.28、Linux / Unixの場合は/usr/local/apache-tomcat-8.0.289で、これらの場所を指すCATALINA_HOME環境変数を作成します。
Tomcatは、Windowsマシンで次のコマンドを実行することで起動できます-
%CATALINA_HOME%\bin\startup.bat
or
C:\apache-tomcat-8.0.28\bin\startup.batTomcatは、Unix（Solaris、Linuxなど）マシンで次のコマンドを実行することで起動できます。
$CATALINA_HOME/bin/startup.sh
or
/usr/local/apache-tomcat-8.0.28/bin/startup.sh起動後、Tomcatに含まれているデフォルトのWebアプリケーションは、次のWebサイトにアクセスして利用できます。 http://localhost:8080/。すべてが正常であれば、次の結果が表示されます-
Tomcatの構成と実行の詳細については、ここに含まれているドキュメント、およびTomcatのWebサイト（http://tomcat.apache.org）を参照してください。
Windowsマシンで以下のコマンドを実行することでTomcatを停止できます-
C:\apache-tomcat-8.0.28\bin\shutdownUnix（Solaris、Linuxなど）マシンで次のコマンドを実行すると、Tomcatを停止できます。
/usr/local/apache-tomcat-8.0.28/bin/shutdown.shCLASSPATHの設定
サーブレットはJavaPlatform、Standard Editionの一部ではないため、コンパイラに対してサーブレットクラスを識別する必要があります。
Windowsを実行している場合は、C：\ autoexec.batファイルに次の行を入力する必要があります。
set CATALINA = C:\apache-tomcat-8.0.28
set CLASSPATH = %CATALINA%\common\lib\servlet-api.jar;%CLASSPATH%または、Windows NT / 2000 / XPでは、[マイコンピュータ]-> [プロパティ]-> [詳細設定]-> [環境変数]に移動できます。次に、CLASSPATH値を更新し、[OK]ボタンを押します。
Unix（Solaris、Linuxなど）では、Cシェルを使用している場合は、次の行を.cshrcファイルに挿入します。
setenv CATALINA = /usr/local/apache-tomcat-8.0.28
setenv CLASSPATH $CATALINA/common/lib/servlet-api.jar:$CLASSPATHNOTE −開発ディレクトリがC：\ ServletDevel（Windows）または/ usr / ServletDevel（Unix）であるとすると、上記で追加したのと同様の方法で、これらのディレクトリもCLASSPATHに追加する必要があります。
サーブレットのライフサイクルは、作成から破棄までのプロセス全体として定義できます。以下は、サーブレットがたどるパスです。
サーブレットは、を呼び出すことによって初期化されます init() 方法。
サーブレットは service() クライアントの要求を処理するメソッド。
サーブレットは、を呼び出すことによって終了します。 destroy() 方法。
最後に、サーブレットは、JVMのガベージコレクターによって収集されたガベージです。
それでは、ライフサイクルの方法について詳しく説明しましょう。
init（）メソッド
initメソッドは1回だけ呼び出されます。サーブレットが作成されたときにのみ呼び出され、その後のユーザー要求に対しては呼び出されません。そのため、アプレットのinitメソッドと同様に、1回限りの初期化に使用されます。
サーブレットは通常、ユーザーがサーブレットに対応するURLを最初に呼び出したときに作成されますが、サーバーの最初の起動時にサーブレットをロードするように指定することもできます。
ユーザーがサーブレットを呼び出すと、各サーブレットの単一インスタンスが作成され、各ユーザーリクエストにより、必要に応じてdoGetまたはdoPostに渡される新しいスレッドが生成されます。init（）メソッドは、サーブレットの存続期間を通じて使用されるデータを作成またはロードするだけです。
initメソッドの定義は次のようになります-
public void init() throws ServletException {
// Initialization code...
}service（）メソッド
service（）メソッドは、実際のタスクを実行するためのメインメソッドです。サーブレットコンテナ（つまり、Webサーバー）はservice（）メソッドを呼び出して、クライアント（ブラウザ）からの要求を処理し、フォーマットされた応答をクライアントに書き戻します。
サーバーがサーブレットの要求を受信するたびに、サーバーは新しいスレッドを生成し、サービスを呼び出します。service（）メソッドはHTTPリクエストタイプ（GET、POST、PUT、DELETEなど）をチェックし、必要に応じてdoGet、doPost、doPut、doDeleteなどのメソッドを呼び出します。
これがこのメソッドのシグネチャです-
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException {
}service（）メソッドはコンテナによって呼び出され、serviceメソッドは必要に応じてdoGet、doPost、doPut、doDeleteなどのメソッドを呼び出します。したがって、service（）メソッドとは何の関係もありませんが、クライアントから受け取るリクエストのタイプに応じて、doGet（）またはdoPost（）のいずれかをオーバーライドします。
doGet（）およびdoPost（）は、各サービスリクエストで最も頻繁に使用されるメソッドです。これら2つのメソッドのシグネチャは次のとおりです。
doGet（）メソッド
GETリクエストは、URLに対する通常のリクエスト、またはメソッドが指定されていないHTMLフォームから発生するため、doGet（）メソッドで処理する必要があります。
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Servlet code
}doPost（）メソッド
POSTリクエストは、POSTをメソッドとして具体的にリストするHTMLフォームから生成され、doPost（）メソッドで処理する必要があります。
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Servlet code
}destroy（）メソッド
destroy（）メソッドは、サーブレットのライフサイクルの最後に1回だけ呼び出されます。このメソッドにより、サーブレットはデータベース接続を閉じたり、バックグラウンドスレッドを停止したり、Cookieリストやヒットカウントをディスクに書き込んだり、その他のクリーンアップアクティビティを実行したりできます。
destroy（）メソッドが呼び出された後、サーブレットオブジェクトはガベージコレクション用にマークされます。destroyメソッドの定義は次のようになります-
public void destroy() {
// Finalization code...
}アーキテクチャ図
次の図は、典型的なサーブレットのライフサイクルシナリオを示しています。
最初に、サーバーに着信するHTTP要求がサーブレットコンテナに委任されます。
サーブレットコンテナは、service（）メソッドを呼び出す前にサーブレットをロードします。
次に、サーブレットコンテナは、複数のスレッドを生成することによって複数の要求を処理します。各スレッドは、サーブレットの単一インスタンスのservice（）メソッドを実行します。
サーブレットは、HTTPリクエストを処理し、実装するJavaクラスです。 javax.servlet.Servletインターフェース。Webアプリケーション開発者は通常、javax.servlet.http.HttpServletを拡張するサーブレットを作成します。これは、サーブレットインターフェイスを実装し、HTTPリクエストを処理するように特別に設計された抽象クラスです。
サンプルコード
以下は、HelloWorldを示すサーブレットの例のサンプルソースコード構造です。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class HelloWorld extends HttpServlet {
private String message;
public void init() throws ServletException {
// Do required initialization
message = "Hello World";
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
// Actual logic goes here.
PrintWriter out = response.getWriter();
out.println("<h1>" + message + "</h1>");
}
public void destroy() {
// do nothing.
}
}サーブレットのコンパイル
上記のコードを使用して、HelloWorld.javaという名前のファイルを作成しましょう。このファイルをC：\ ServletDevel（Windowsの場合）または/ usr / ServletDevel（Unixの場合）に配置します。先に進む前に、このパスの場所をCLASSPATHに追加する必要があります。
環境が適切に設定されていると仮定して、 ServletDevel ディレクトリを作成し、HelloWorld.javaを次のようにコンパイルします-
$ javac HelloWorld.javaサーブレットが他のライブラリに依存している場合は、それらのJARファイルもCLASSPATHに含める必要があります。Hello Worldプログラムで他のライブラリを使用していないため、servlet-api.jarJARファイルのみを含めました。
このコマンドラインは、Sun Microsystems Java Software Development Kit（JDK）に付属の組み込みjavacコンパイラを使用します。このコマンドを正しく機能させるには、使用しているJavaSDKの場所をPATH環境変数に含める必要があります。
すべてがうまくいけば、上記のコンパイルは HelloWorld.class同じディレクトリ内のファイル。次のセクションでは、コンパイルされたサーブレットを本番環境にデプロイする方法について説明します。
サーブレットの導入
デフォルトでは、サーブレットアプリケーションはパス<Tomcat-installationdirectory> / webapps / ROOTにあり、クラスファイルは<Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classesにあります。
の完全修飾クラス名がある場合 com.myorg.MyServletの場合、このサーブレットクラスはWEB-INF / classes / com / myorg /MyServlet.classに配置する必要があります。
今のところ、HelloWorld.classを<Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classesにコピーして、に次のエントリを作成しましょう。 web.xml <Tomcat-installation-directory> / webapps / ROOT / WEB-INF /にあるファイル
<servlet>
<servlet-name>HelloWorld</servlet-name>
<servlet-class>HelloWorld</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloWorld</servlet-name>
<url-pattern>/HelloWorld</url-pattern>
</servlet-mapping>上記のエントリは、web.xmlファイルで使用可能な<web-app> ... </ web-app>タグ内に作成されます。このテーブルにはすでに利用可能なさまざまなエントリが存在する可能性がありますが、気にしないでください。
これでほぼ完了です。<Tomcat-installationdirectory> \ bin \ startup.bat（Windowsの場合）または<Tomcat-installationdirectory> /bin/startup.sh（Linux / Solarisなどの場合）を使用してTomcatサーバーを起動し、最後に次のように入力します。 http://localhost:8080/HelloWorldブラウザのアドレスボックスに入力します。すべてがうまくいけば、次の結果が得られます
ブラウザからWebサーバーに、そして最終的にはバックエンドプログラムに情報を渡す必要がある場合、多くの状況に遭遇したに違いありません。ブラウザは2つの方法を使用して、この情報をWebサーバーに渡します。これらのメソッドは、GETメソッドとPOSTメソッドです。
GETメソッド
GETメソッドは、ページリクエストに追加されたエンコードされたユーザー情報を送信します。ページとエンコードされた情報は、? （疑問符）記号は次のとおりです-
http://www.test.com/hello?key1 = value1&key2 = value2GETメソッドは、ブラウザからWebサーバーに情報を渡すためのデフォルトのメソッドであり、ブラウザのLocation：boxに表示される長い文字列を生成します。サーバーに渡すパスワードやその他の機密情報がある場合は、GETメソッドを使用しないでください。GETメソッドにはサイズ制限があります。リクエスト文字列で使用できるのは1024文字のみです。
この情報はQUERY_STRINGヘッダーを使用して渡され、QUERY_STRING環境変数を介してアクセスでき、サーブレットはを使用してこのタイプのリクエストを処理します。 doGet() 方法。
POSTメソッド
バックエンドプログラムに情報を渡す一般的により信頼性の高い方法は、POST方法です。これは、GETメソッドとまったく同じ方法で情報をパッケージ化しますが、？の後にテキスト文字列として送信する代わりに （疑問符）URLで別のメッセージとして送信します。このメッセージは、解析して処理に使用できる標準入力の形式でバックエンドプログラムに送信されます。サーブレットは、このタイプのリクエストを使用して処理しますdoPost() 方法。
サーブレットを使用したフォームデータの読み取り
サーブレットは、状況に応じて次の方法を使用してフォームデータの解析を自動的に処理します-
getParameter() − request.getParameter（）メソッドを呼び出して、フォームパラメータの値を取得します。
getParameterValues() −パラメータが複数回表示され、チェックボックスなどの複数の値を返す場合は、このメソッドを呼び出します。
getParameterNames() −現在のリクエストのすべてのパラメータの完全なリストが必要な場合は、このメソッドを呼び出します。
URLを使用したGETメソッドの例
これは、GETメソッドを使用してHelloFormプログラムに2つの値を渡す単純なURLです。
http://localhost:8080/HelloForm?first_name = ZARA&last_name = ALI以下は HelloForm.javaWebブラウザからの入力を処理するサーブレットプログラム。使用しますgetParameter() 渡された情報に非常に簡単にアクセスできる方法-
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class HelloForm extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Using GET Method to Read Form Data";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<ul>\n" +
" <li><b>First Name</b>: "
+ request.getParameter("first_name") + "\n" +
" <li><b>Last Name</b>: "
+ request.getParameter("last_name") + "\n" +
"</ul>\n" +
"</body>" +
"</html>"
);
}
}環境が適切に設定されていると仮定して、HelloForm.javaを次のようにコンパイルします-
$ javac HelloForm.javaすべてがうまくいけば、上記のコンパイルは HelloForm.classファイル。次に、このクラスファイルを<Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classesにコピーし、次のエントリを作成する必要があります。web.xml <Tomcat-installation-directory> / webapps / ROOT / WEB-INF /にあるファイル
<servlet>
<servlet-name>HelloForm</servlet-name>
<servlet-class>HelloForm</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloForm</servlet-name>
<url-pattern>/HelloForm</url-pattern>
</servlet-mapping>次に、ブラウザのLocation：boxにhttp：// localhost：8080 / HelloForm？first_name = ZARA＆last_name = ALIと入力し、ブラウザで上記のコマンドを実行する前に、Tomcatサーバーがすでに起動していることを確認します。これにより、次の結果が生成されます-
Using GET Method to Read Form Data
- First Name: ZARA
- Last Name: ALI
フォームを使用したGETメソッドの例
これは、HTMLFORMと送信ボタンを使用して2つの値を渡す簡単な例です。同じサーブレットHelloFormを使用してこの入力を処理します。
<html>
<body>
<form action = "HelloForm" method = "GET">
First Name: <input type = "text" name = "first_name">
<br />
Last Name: <input type = "text" name = "last_name" />
<input type = "submit" value = "Submit" />
</form>
</body>
</html>このHTMLをファイルHello.htmに保存し、<Tomcat-installationdirectory> / webapps / ROOTディレクトリに配置します。http：// localhost：8080 / Hello.htmにアクセスする場合、上記のフォームの実際の出力は次のとおりです。
姓と名を入力してから[送信]ボタンをクリックして、Tomcatが実行されているローカルマシンで結果を確認してください。提供された入力に基づいて、上記の例で述べたのと同様の結果が生成されます。
フォームを使用したPOSTメソッドの例
上記のサーブレットに少し変更を加えて、GETメソッドとPOSTメソッドを処理できるようにします。以下でありHelloForm.java GETまたはPOSTメソッドを使用してWebブラウザからの入力を処理するサーブレットプログラム。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class HelloForm extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Using GET Method to Read Form Data";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<ul>\n" +
" <li><b>First Name</b>: "
+ request.getParameter("first_name") + "\n" +
" <li><b>Last Name</b>: "
+ request.getParameter("last_name") + "\n" +
"</ul>\n" +
"</body>"
"</html>"
);
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}次に、上記のサーブレットをコンパイルしてデプロイし、次のようにPOSTメソッドを使用してHello.htmを使用してテストします。
<html>
<body>
<form action = "HelloForm" method = "POST">
First Name: <input type = "text" name = "first_name">
<br />
Last Name: <input type = "text" name = "last_name" />
<input type = "submit" value = "Submit" />
</form>
</body>
</html>上記のフォームの実際の出力は次のとおりです。姓名を入力してから[送信]ボタンをクリックして、Tomcatが実行されているローカルマシンで結果を確認してください。
提供された入力に基づいて、上記の例で述べたのと同様の結果が生成されます。
チェックボックスデータをサーブレットプログラムに渡す
チェックボックスは、複数のオプションを選択する必要がある場合に使用されます。
これは、2つのチェックボックスがあるフォームのHTMLコードCheckBox.htmの例です。
<html>
<body>
<form action = "CheckBox" method = "POST" target = "_blank">
<input type = "checkbox" name = "maths" checked = "checked" /> Maths
<input type = "checkbox" name = "physics" /> Physics
<input type = "checkbox" name = "chemistry" checked = "checked" />
Chemistry
<input type = "submit" value = "Select Subject" />
</form>
</body>
</html>このコードの結果は次の形式になります
以下に示すのは、チェックボックスボタンのWebブラウザからの入力を処理するCheckBox.javaサーブレットプログラムです。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class CheckBox extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Reading Checkbox Data";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<ul>\n" +
" <li><b>Maths Flag : </b>: "
+ request.getParameter("maths") + "\n" +
" <li><b>Physics Flag: </b>: "
+ request.getParameter("physics") + "\n" +
" <li><b>Chemistry Flag: </b>: "
+ request.getParameter("chemistry") + "\n" +
"</ul>\n" +
"</body>"
"</html>"
);
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}上記の例では、次の結果が表示されます-
Reading Checkbox Data
- Maths Flag : : on
- Physics Flag: : null
- Chemistry Flag: : on
すべてのフォームパラメータの読み取り
以下は、を使用する一般的な例です。 getParameterNames()使用可能なすべてのフォームパラメータを読み取るHttpServletRequestのメソッド。このメソッドは、パラメーター名を不特定の順序で含む列挙型を返します
列挙型を取得したら、hasMoreElements（）メソッドを使用して停止するタイミングを決定し、nextElement（）メソッドを使用して各パラメーター名を取得することにより、標準的な方法で列挙型をループダウンできます。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class ReadParams extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Reading All Form Parameters";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<table width = \"100%\" border = \"1\" align = \"center\">\n" +
"<tr bgcolor = \"#949494\">\n" +
"<th>Param Name</th>"
"<th>Param Value(s)</th>\n"+
"</tr>\n"
);
Enumeration paramNames = request.getParameterNames();
while(paramNames.hasMoreElements()) {
String paramName = (String)paramNames.nextElement();
out.print("<tr><td>" + paramName + "</td>\n<td>");
String[] paramValues = request.getParameterValues(paramName);
// Read single valued data
if (paramValues.length == 1) {
String paramValue = paramValues[0];
if (paramValue.length() == 0)
out.println("<i>No Value</i>");
else
out.println(paramValue);
} else {
// Read multiple valued data
out.println("<ul>");
for(int i = 0; i < paramValues.length; i++) {
out.println("<li>" + paramValues[i]);
}
out.println("</ul>");
}
}
out.println("</tr>\n</table>\n</body></html>");
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}ここで、次の形式で上記のサーブレットを試してください-
<html>
<body>
<form action = "ReadParams" method = "POST" target = "_blank">
<input type = "checkbox" name = "maths" checked = "checked" /> Maths
<input type = "checkbox" name = "physics" /> Physics
<input type = "checkbox" name = "chemistry" checked = "checked" /> Chem
<input type = "submit" value = "Select Subject" />
</form>
</body>
</html>上記のフォームを使用してサーブレットを呼び出すと、次の結果が生成されます-
Reading All Form Parameters
Param Name
Param Value(s)
maths
on
chemistry
on
上記のサーブレットを試して、テキストボックス、ラジオボタン、ドロップダウンボックスなどの他のオブジェクトを持つ他のフォームのデータを読み取ることができます。
ブラウザがWebページを要求すると、Webサーバーに多くの情報が送信されますが、この情報はHTTP要求のヘッダーの一部として送信されるため、直接読み取ることはできません。詳細については、HTTPプロトコルを確認してください。
以下はブラウザ側から来る重要なヘッダー情報であり、Webプログラミングで非常に頻繁に使用します-
| シニア番号 | ヘッダーと説明 |
|---|---|
| 1 | Accept このヘッダーは、ブラウザーまたは他のクライアントが処理できるMIMEタイプを指定します。の値image/png または image/jpeg 2つの最も一般的な可能性です。 |
| 2 | Accept-Charset このヘッダーは、ブラウザーが情報を表示するために使用できる文字セットを指定します。たとえば、ISO-8859-1。 |
| 3 | Accept-Encoding このヘッダーは、ブラウザーが処理方法を知っているエンコーディングのタイプを指定します。の値gzip または compress 2つの最も一般的な可能性です。 |
| 4 | Accept-Language このヘッダーは、サーブレットが複数の言語で結果を生成できる場合に備えて、クライアントの優先言語を指定します。たとえば、en、en-us、ruなど |
| 5 | Authorization このヘッダーは、パスワードで保護されたWebページにアクセスするときにクライアントが自分自身を識別するために使用されます。 |
| 6 | Connection このヘッダーは、クライアントが永続的なHTTP接続を処理できるかどうかを示します。持続的接続により、クライアントまたは他のブラウザは1回のリクエストで複数のファイルを取得できます。の値Keep-Alive 持続的接続を使用する必要があることを意味します。 |
| 7 | Content-Length このヘッダーはPOST要求にのみ適用可能であり、POSTデータのサイズをバイト単位で示します。 |
| 8 | Cookie このヘッダーは、以前にブラウザに送信したサーバーにCookieを返します。 |
| 9 | Host このヘッダーは、元のURLで指定されたホストとポートを指定します。 |
| 10 | If-Modified-Since このヘッダーは、指定された日付以降にページが変更された場合にのみ、クライアントがページを必要としていることを示します。サーバーはコード304を送信します。これはNot Modified 新しい結果が利用できない場合はヘッダー。 |
| 11 | If-Unmodified-Since このヘッダーは、If-Modified-Sinceの逆です。これは、ドキュメントが指定された日付より古い場合にのみ操作が成功するように指定します。 |
| 12 | Referer このヘッダーは、参照元のWebページのURLを示します。たとえば、Webページ1にいて、Webページ2へのリンクをクリックすると、ブラウザがWebページ2を要求すると、Webページ1のURLがReferrerヘッダーに含まれます。 |
| 13 | User-Agent このヘッダーは、リクエストを行っているブラウザまたは他のクライアントを識別し、さまざまなコンテンツをさまざまなタイプのブラウザに返すために使用できます。 |
HTTPヘッダーを読み取るメソッド
サーブレットプログラムでHTTPヘッダーを読み取るために使用できる次のメソッドがあります。これらのメソッドは、HttpServletRequestオブジェクトで使用できます
| シニア番号 | 方法と説明 |
|---|---|
| 1 | Cookie[] getCookies() クライアントがこのリクエストで送信したすべてのCookieオブジェクトを含む配列を返します。 |
| 2 | Enumeration getAttributeNames() このリクエストで使用可能な属性の名前を含む列挙型を返します。 |
| 3 | Enumeration getHeaderNames() このリクエストに含まれるすべてのヘッダー名の列挙を返します。 |
| 4 | Enumeration getParameterNames() このリクエストに含まれるパラメータの名前を含むStringオブジェクトの列挙を返します |
| 5 | HttpSession getSession() このリクエストに関連付けられている現在のセッションを返します。リクエストにセッションがない場合は、セッションを作成します。 |
| 6 | HttpSession getSession(boolean create) このリクエストに関連付けられている現在のHttpSessionを返します。現在のセッションがなく、createの値がtrueの場合は、新しいセッションを返します。 |
| 7 | Locale getLocale() Accept-Languageヘッダーに基づいて、クライアントがコンテンツを受け入れる優先ロケールを返します。 |
| 8 | Object getAttribute(String name) 名前付き属性の値をオブジェクトとして返します。指定された名前の属性が存在しない場合はnullを返します。 |
| 9 | ServletInputStream getInputStream() ServletInputStreamを使用して、リクエストの本文をバイナリデータとして取得します。 |
| 10 | String getAuthType() サーブレットを保護するために使用される認証スキームの名前（「BASIC」や「SSL」など）を返します。JSPが保護されていない場合はnullを返します。 |
| 11 | String getCharacterEncoding() このリクエストの本文で使用されている文字エンコードの名前を返します。 |
| 12 | String getContentType() リクエストの本文のMIMEタイプを返します。タイプが不明な場合は、nullを返します。 |
| 13 | String getContextPath() リクエストのコンテキストを示すリクエストURIの部分を返します。 |
| 14 | String getHeader(String name) 指定されたリクエストヘッダーの値を文字列として返します。 |
| 15 | String getMethod() このリクエストが行われたHTTPメソッドの名前（GET、POST、PUTなど）を返します。 |
| 16 | String getParameter(String name) リクエストパラメータの値を文字列として返します。パラメータが存在しない場合はnullを返します。 |
| 17 | String getPathInfo() このリクエストを行ったときにクライアントが送信したURLに関連付けられた追加のパス情報を返します |
| 18 | String getProtocol() リクエストのプロトコルの名前とバージョンを返します。 |
| 19 | String getQueryString() パスの後のリクエストURLに含まれているクエリ文字列を返します。 |
| 20 | String getRemoteAddr() 要求を送信したクライアントのインターネットプロトコル（IP）アドレスを返します。 |
| 21 | String getRemoteHost() リクエストを送信したクライアントの完全修飾名を返します。 |
| 22 | String getRemoteUser() ユーザーが認証されている場合は、この要求を行っているユーザーのログインを返します。ユーザーが認証されていない場合は、nullを返します。 |
| 23 | String getRequestURI() このリクエストのURLのプロトコル名から、HTTPリクエストの最初の行のクエリ文字列までの部分を返します。 |
| 24 | String getRequestedSessionId() クライアントによって指定されたセッションIDを返します。 |
| 25 | String getServletPath() このリクエストのURLのJSPを呼び出す部分を返します。 |
| 26 | String[] getParameterValues(String name) 指定されたリクエストパラメータが持つすべての値を含むStringオブジェクトの配列を返します。パラメータが存在しない場合はnullを返します。 |
| 27 | boolean isSecure() この要求がHTTPSなどの安全なチャネルを使用して行われたかどうかを示すブール値を返します。 |
| 28 | int getContentLength() リクエスト本文の長さをバイト単位で返し、入力ストリームで使用できるようにします。長さが不明な場合は-1を返します。 |
| 29 | int getIntHeader(String name) 指定されたリクエストヘッダーの値をintとして返します。 |
| 30 | int getServerPort() このリクエストを受信したポート番号を返します。 |
HTTPヘッダーリクエストの例
以下はを使用する例です getHeaderNames()HTTPヘッダー情報を読み取るためのHttpServletRequestのメソッド。このメソッドは、現在のHTTPリクエストに関連付けられたヘッダー情報を含む列挙型を返します。
列挙型を取得したら、hasMoreElements（）メソッドを使用して停止するタイミングを決定し、nextElement（）メソッドを使用して各パラメーター名を取得することにより、標準的な方法で列挙型をループダウンできます。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class DisplayHeader extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "HTTP Header Request Example";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n"+
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<table width = \"100%\" border = \"1\" align = \"center\">\n" +
"<tr bgcolor = \"#949494\">\n" +
"<th>Header Name</th><th>Header Value(s)</th>\n"+
"</tr>\n"
);
Enumeration headerNames = request.getHeaderNames();
while(headerNames.hasMoreElements()) {
String paramName = (String)headerNames.nextElement();
out.print("<tr><td>" + paramName + "</td>\n");
String paramValue = request.getHeader(paramName);
out.println("<td> " + paramValue + "</td></tr>\n");
}
out.println("</table>\n</body></html>");
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}上記のサーブレットを呼び出すと、次の結果が生成されます-
HTTP Header Request Example
Header Name
Header Value(s)
accept
*/*
accept-language
en-us
user-agent
Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; InfoPath.2; MS-RTC LM 8)
accept-encoding
gzip, deflate
host
localhost:8080
connection
Keep-Alive
cache-control
no-cache
前の章で説明したように、WebサーバーがHTTP要求に応答する場合、応答は通常、ステータス行、いくつかの応答ヘッダー、空白行、およびドキュメントで構成されます。典型的な応答は次のようになります-
HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
(Blank Line)
<!doctype ...>
<html>
<head>...</head>
<body>
...
</body>
</html>ステータス行は、HTTPバージョン（例ではHTTP / 1.1）、ステータスコード（例では200）、およびステータスコードに対応する非常に短いメッセージ（例ではOK）で構成されています。
以下は、Webサーバー側からブラウザーに戻る最も有用なHTTP 1.1応答ヘッダーの要約であり、Webプログラミングで非常に頻繁に使用します。
| シニア番号 | ヘッダーと説明 |
|---|---|
| 1 | Allow このヘッダーは、サーバーがサポートする要求メソッド（GET、POSTなど）を指定します。 |
| 2 | Cache-Control このヘッダーは、応答ドキュメントを安全にキャッシュできる状況を指定します。それは値を持つことができますpublic、 private または no-cache パブリックはドキュメントがキャッシュ可能であることを意味し、プライベートはドキュメントがシングルユーザー用であり、プライベート（非共有）キャッシュにのみ保存できることを意味し、nocacheはドキュメントがキャッシュされないことを意味します。 |
| 3 | Connection このヘッダーは、HTTP接続で永続を使用するかどうかをブラウザーに指示します。の値close 永続的なHTTP接続を使用しないようにブラウザに指示し、 keepalive 持続的接続を使用することを意味します。 |
| 4 | Content-Disposition このヘッダーを使用すると、ブラウザがユーザーに、指定された名前のファイルにディスクへの応答を保存するように要求できます。 |
| 5 | Content-Encoding このヘッダーは、送信中にページがエンコードされた方法を指定します。 |
| 6 | Content-Language このヘッダーは、ドキュメントが書かれている言語を示します。たとえば、en、en-us、ruなど |
| 7 | Content-Length このヘッダーは、応答のバイト数を示します。この情報は、ブラウザーが永続的な（維持）HTTP接続を使用している場合にのみ必要です。 |
| 8 | Content-Type このヘッダーは、応答ドキュメントのMIME（Multipurpose Internet Mail Extension）タイプを示します。 |
| 9 | Expires このヘッダーは、コンテンツが古くなっていると見なされ、キャッシュされなくなる時刻を指定します。 |
| 10 | Last-Modified このヘッダーは、ドキュメントが最後に変更された日時を示します。その後、クライアントはドキュメントをキャッシュし、日付を指定できます。If-Modified-Since 後のリクエストのリクエストヘッダー。 |
| 11 | Location このヘッダーは、300年代のステータスコードを持つすべての応答に含める必要があります。これにより、ブラウザにドキュメントアドレスが通知されます。ブラウザは自動的にこの場所に再接続し、新しいドキュメントを取得します。 |
| 12 | Refresh このヘッダーは、ブラウザーが更新されたページを要求するまでの時間を指定します。ページが更新されるまでの時間を秒数で指定できます。 |
| 13 | Retry-After このヘッダーは、503（Service Unavailable）応答と組み合わせて使用して、クライアントが要求を繰り返すことができる時間をクライアントに通知できます。 |
| 14 | Set-Cookie このヘッダーは、ページに関連付けられたCookieを指定します。 |
HTTP応答ヘッダーを設定するメソッド
サーブレットプログラムでHTTP応答ヘッダーを設定するために使用できる次のメソッドがあります。これらのメソッドは、HttpServletResponseオブジェクトで使用できます。
| シニア番号 | 方法と説明 |
|---|---|
| 1 | String encodeRedirectURL(String url) sendRedirectメソッドで使用するために指定されたURLをエンコードします。エンコードが不要な場合は、URLを変更せずに返します。 |
| 2 | String encodeURL(String url) セッションIDを含めて、指定されたURLをエンコードします。エンコードが不要な場合は、URLを変更せずに返します。 |
| 3 | boolean containsHeader(String name) 名前付き応答ヘッダーがすでに設定されているかどうかを示すブール値を返します。 |
| 4 | boolean isCommitted() 応答がコミットされたかどうかを示すブール値を返します。 |
| 5 | void addCookie(Cookie cookie) 指定されたCookieを応答に追加します。 |
| 6 | void addDateHeader(String name, long date) 指定された名前と日付値を持つ応答ヘッダーを追加します。 |
| 7 | void addHeader(String name, String value) 指定された名前と値で応答ヘッダーを追加します。 |
| 8 | void addIntHeader(String name, int value) 指定された名前と整数値を持つ応答ヘッダーを追加します。 |
| 9 | void flushBuffer() バッファ内のすべてのコンテンツをクライアントに強制的に書き込みます。 |
| 10 | void reset() バッファに存在するすべてのデータ、およびステータスコードとヘッダーをクリアします。 |
| 11 | void resetBuffer() ヘッダーやステータスコードをクリアせずに、応答の基になるバッファーの内容をクリアします。 |
| 12 | void sendError(int sc) 指定されたステータスコードを使用し、バッファをクリアして、クライアントにエラー応答を送信します。 |
| 13 | void sendError(int sc, String msg) 指定されたステータスを使用して、クライアントにエラー応答を送信します。 |
| 14 | void sendRedirect(String location) 指定されたリダイレクト場所のURLを使用して、一時的なリダイレクト応答をクライアントに送信します。 |
| 15 | void setBufferSize(int size) 応答の本文の優先バッファーサイズを設定します。 |
| 16 | void setCharacterEncoding(String charset) クライアントに送信される応答の文字エンコード（MIME文字セット）を、たとえばUTF-8に設定します。 |
| 17 | void setContentLength(int len) 応答のコンテンツ本文の長さを設定しますHTTPサーブレットでは、このメソッドはHTTPContent-Lengthヘッダーを設定します。 |
| 18 | void setContentType(String type) 応答がまだコミットされていない場合、クライアントに送信される応答のコンテンツタイプを設定します。 |
| 19 | void setDateHeader(String name, long date) 指定された名前と日付値で応答ヘッダーを設定します。 |
| 20 | void setHeader(String name, String value) 指定された名前と値で応答ヘッダーを設定します。 |
| 21 | void setIntHeader(String name, int value) 指定された名前と整数値で応答ヘッダーを設定します |
| 22 | void setLocale(Locale loc) 応答がまだコミットされていない場合は、応答のロケールを設定します。 |
| 23 | void setStatus(int sc) この応答のステータスコードを設定します |
HTTPヘッダー応答の例
前の例でsetContentType（）メソッドが機能していることはすでに見てきましたが、次の例でも同じメソッドを使用し、さらに次の例を使用します。 setIntHeader() 設定する方法 Refresh ヘッダ。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class Refresh extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set refresh, autoload time as 5 seconds
response.setIntHeader("Refresh", 5);
// Set response content type
response.setContentType("text/html");
// Get current time
Calendar calendar = new GregorianCalendar();
String am_pm;
int hour = calendar.get(Calendar.HOUR);
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
if(calendar.get(Calendar.AM_PM) == 0)
am_pm = "AM";
else
am_pm = "PM";
String CT = hour+":"+ minute +":"+ second +" "+ am_pm;
PrintWriter out = response.getWriter();
String title = "Auto Refresh Header Setting";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n"+
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p>Current Time is: " + CT + "</p>\n"
);
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}上記のサーブレットを呼び出すと、次のように5秒ごとに現在のシステム時刻が表示されます。サーブレットを実行して、結果が表示されるのを待つだけです-
Auto Refresh Header Setting
Current Time is: 9:44:50 PM
HTTP要求メッセージとHTTP応答メッセージの形式は類似しており、次の構造になります。
初期ステータスライン+ CRLF（キャリッジリターン+ラインフィード、つまり改行）
ゼロ個以上のヘッダー行+ CRLF
空白行、つまりCRLF
ファイル、クエリデータ、クエリ出力などのオプションのメッセージ本文。
たとえば、サーバーの応答ヘッダーは次のようになります。
HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
(Blank Line)
<!doctype ...>
<html>
<head>...</head>
<body>
...
</body>
</html>ステータス行は、HTTPバージョン（例ではHTTP / 1.1）、ステータスコード（例では200）、およびステータスコードに対応する非常に短いメッセージ（例ではOK）で構成されています。
以下は、Webサーバーから返される可能性のあるHTTPステータスコードと関連メッセージのリストです。
| コード | メッセージ | 説明 |
|---|---|---|
| 100 | 継続する | リクエストの一部のみがサーバーによって受信されましたが、それが拒否されない限り、クライアントはリクエストを続行する必要があります |
| 101 | スイッチングプロトコル | サーバーはプロトコルを切り替えます。 |
| 200 | OK | リクエストはOKです |
| 201 | 作成した | リクエストが完了し、新しいリソースが作成されます |
| 202 | 承認済み | リクエストは処理のために受け入れられますが、処理は完了していません。 |
| 203 | 信頼できない情報 | |
| 204 | コンテンツなし | |
| 205 | コンテンツをリセット | |
| 206 | 部分的なコンテンツ | |
| 300 | 複数の選択肢 | リンクリスト。ユーザーはリンクを選択してその場所に移動できます。最大5つのアドレス |
| 301 | 恒久的に移動 | リクエストされたページは新しいURLに移動しました |
| 302 | 見つかりました | リクエストされたページは一時的に新しいURLに移動しました |
| 303 | その他を見る | リクエストされたページは別のURLにあります |
| 304 | 変更なし | |
| 305 | プロキシを使う | |
| 306 | 未使用 | このコードは以前のバージョンで使用されていました。使用されなくなりましたが、コードは予約されています |
| 307 | 一時的なリダイレクト | リクエストされたページは一時的に新しいURLに移動しました。 |
| 400 | 要求の形式が正しくありません | サーバーはリクエストを理解しませんでした |
| 401 | 無許可 | リクエストされたページにはユーザー名とパスワードが必要です |
| 402 | 支払いが必要 | このコードはまだ使用できません |
| 403 | 禁止 | リクエストされたページへのアクセスは禁止されています |
| 404 | 見つかりません | サーバーは要求されたページを見つけることができません。 |
| 405 | 許可されていない方法 | リクエストで指定されたメソッドは許可されていません。 |
| 406 | 受け付けできません | サーバーは、クライアントによって受け入れられない応答のみを生成できます。 |
| 407 | プロキシ認証が必要 | このリクエストを処理する前に、プロキシサーバーで認証する必要があります。 |
| 408 | リクエストタイムアウト | サーバーが待機する準備ができているよりも、要求に時間がかかりました。 |
| 409 | 競合 | 競合のため、リクエストを完了できませんでした。 |
| 410 | なくなった | リクエストされたページは利用できなくなりました。 |
| 411 | 必要な長さ | 「Content-Length」は定義されていません。サーバーはそれなしではリクエストを受け入れません。 |
| 412 | 前提条件が失敗しました | リクエストで指定された前提条件は、サーバーによってfalseと評価されました。 |
| 413 | エンティティが大きすぎるリクエスト | リクエストエンティティが大きすぎるため、サーバーはリクエストを受け入れません。 |
| 414 | Request-urlが長すぎます | URLが長すぎるため、サーバーはリクエストを受け入れません。「post」リクエストを長いクエリ情報を含む「get」リクエストに変換すると発生します。 |
| 415 | サポートされていないメディアタイプ | メディアタイプがサポートされていないため、サーバーは要求を受け入れません。 |
| 417 | 期待に失敗しました | |
| 500 | 内部サーバーエラー | リクエストは完了しませんでした。サーバーが予期しない条件を満たしました。 |
| 501 | 実装されていません | リクエストは完了しませんでした。サーバーは必要な機能をサポートしていませんでした。 |
| 502 | 悪いゲートウェイ | リクエストは完了しませんでした。サーバーがアップストリームサーバーから無効な応答を受信しました。 |
| 503 | サービスは利用できません | リクエストは完了しませんでした。サーバーが一時的に過負荷またはダウンしています。 |
| 504 | ゲートウェイタイムアウト | ゲートウェイがタイムアウトしました。 |
| 505 | HTTPバージョンはサポートされていません | サーバーは「httpプロトコル」バージョンをサポートしていません。 |
HTTPステータスコードを設定する方法
次のメソッドを使用して、サーブレットプログラムでHTTPステータスコードを設定できます。これらのメソッドは、HttpServletResponseオブジェクトで使用できます。
| シニア番号 | 方法と説明 |
|---|---|
| 1 | public void setStatus ( int statusCode ) このメソッドは、任意のステータスコードを設定します。setStatusメソッドは、引数としてint（ステータスコード）を取ります。応答に特別なステータスコードとドキュメントが含まれている場合は、PrintWriterでコンテンツを実際に返す前に、必ずsetStatusを呼び出してください。 |
| 2 | public void sendRedirect(String url) このメソッドは、新しいドキュメントのURLを示すLocationヘッダーとともに302応答を生成します |
| 3 | public void sendError(int code, String message) このメソッドは、ステータスコード（通常は404）を、HTMLドキュメント内で自動的にフォーマットされてクライアントに送信される短いメッセージとともに送信します。 |
HTTPステータスコードの例
以下は、407エラーコードをクライアントブラウザに送信し、ブラウザに「認証が必要です!!!」と表示される例です。メッセージ。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class showError extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set error code and reason.
response.sendError(407, "Need authentication!!!" );
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}上記のサーブレットを呼び出すと、次の結果が表示されます-
HTTP Status 407 - Need authentication!!!
type Status report
messageNeed authentication!!!
descriptionThe client must first authenticate itself with the proxy (Need authentication!!!).
Apache Tomcat/5.5.29
サーブレットフィルタは、次の目的でサーブレットプログラミングで使用できるJavaクラスです。
クライアントがバックエンドでリソースにアクセスする前に、クライアントからの要求をインターセプトするため。
クライアントに返送される前にサーバーからの応答を操作するため。
仕様で提案されているフィルターにはさまざまな種類があります-
- 認証フィルター。
- データ圧縮フィルター。
- 暗号化フィルター。
- リソースアクセスイベントをトリガーするフィルター。
- 画像変換フィルター。
- ロギングおよび監査フィルター。
- MIME-TYPEチェーンフィルター。
- トークン化フィルター。
- XMLコンテンツを変換するXSL / Tフィルター。
フィルタはデプロイメント記述子ファイルにデプロイされます web.xml 次に、アプリケーションのデプロイメント記述子のサーブレット名またはURLパターンのいずれかにマップします。
WebコンテナがWebアプリケーションを起動すると、デプロイメント記述子で宣言した各フィルタのインスタンスが作成されます。フィルタは、デプロイメント記述子で宣言されている順序で実行されます。
サーブレットフィルタメソッド
フィルタは、javax.servlet.Filterインターフェイスを実装する単なるJavaクラスです。javax.servlet.Filterインターフェースは、3つのメソッドを定義します-
| シニア番号 | 方法と説明 |
|---|---|
| 1 | public void doFilter (ServletRequest, ServletResponse, FilterChain) このメソッドは、チェーンの最後にあるリソースに対するクライアントの要求により、要求/応答のペアがチェーンを通過するたびにコンテナーによって呼び出されます。 |
| 2 | public void init(FilterConfig filterConfig) このメソッドは、Webコンテナーによって呼び出され、サービスが開始されていることをフィルターに示します。 |
| 3 | public void destroy() このメソッドは、サービスが停止されていることをフィルターに示すためにWebコンテナーによって呼び出されます。 |
サーブレットフィルタ-例
以下は、クライアントのIPアドレスと現在の日時を出力するサーブレットフィルターの例です。この例では、サーブレットフィルタの基本を理解できますが、同じ概念を使用して、より高度なフィルタアプリケーションを作成できます。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Implements Filter class
public class LogFilter implements Filter {
public void init(FilterConfig config) throws ServletException {
// Get init parameter
String testParam = config.getInitParameter("test-param");
//Print the init parameter
System.out.println("Test Param: " + testParam);
}
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws java.io.IOException, ServletException {
// Get the IP address of client machine.
String ipAddress = request.getRemoteAddr();
// Log the IP address and current timestamp.
System.out.println("IP "+ ipAddress + ", Time " + new Date().toString());
// Pass request back down the filter chain
chain.doFilter(request,response);
}
public void destroy( ) {
/* Called before the Filter instance is removed from service by the web container*/
}
}コンパイル LogFilter.java 通常の方法で、クラスファイルを<Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classesに配置します
Web.xmlでのサーブレットフィルタマッピング
フィルタは、サーブレットが定義されてからURLパターンにマップされるのとほぼ同じ方法で、定義されてからURLまたはサーブレットにマップされます。デプロイメント記述子ファイルにフィルタータグの次のエントリを作成しますweb.xml
<filter>
<filter-name>LogFilter</filter-name>
<filter-class>LogFilter</filter-class>
<init-param>
<param-name>test-param</param-name>
<param-value>Initialization Paramter</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>LogFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>上記のフィルタは、指定したため、すべてのサーブレットに適用されます。 /*私たちの構成で。少数のサーブレットにのみフィルターを適用する場合は、特定のサーブレットパスを指定できます。
次に、通常の方法でサーブレットを呼び出そうとすると、生成されたログがWebサーバーのログに表示されます。Log4Jロガーを使用して、上記のログを別のファイルに記録できます。
複数のフィルターの使用
Webアプリケーションは、特定の目的でいくつかの異なるフィルターを定義する場合があります。AuthenFilterとLogFilterの2つのフィルターを定義するとします。残りのプロセスは、以下で説明するように別のマッピングを作成する必要があることを除いて、上記で説明したとおりのままです。
<filter>
<filter-name>LogFilter</filter-name>
<filter-class>LogFilter</filter-class>
<init-param>
<param-name>test-param</param-name>
<param-value>Initialization Paramter</param-value>
</init-param>
</filter>
<filter>
<filter-name>AuthenFilter</filter-name>
<filter-class>AuthenFilter</filter-class>
<init-param>
<param-name>test-param</param-name>
<param-value>Initialization Paramter</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>LogFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>AuthenFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>アプリケーションの順序をフィルタリングします
web.xmlのフィルターマッピング要素の順序によって、Webコンテナーがサーブレットにフィルターを適用する順序が決まります。フィルタの順序を逆にするには、web.xmlファイルのフィルタマッピング要素を逆にする必要があります。
たとえば、上記の例では最初にLogFilterを適用し、次にAuthenFilterを任意のサーブレットに適用しますが、次の例では順序が逆になります。
<filter-mapping>
<filter-name>AuthenFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>LogFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>サーブレットが例外をスローすると、Webコンテナは web.xml スローされた例外タイプとの一致にexception-type要素を使用します。
あなたは使用する必要があります error-page 特定の応答に応じてサーブレットの呼び出しを指定するweb.xmlの要素 exceptions またはHTTP status codes。
web.xml構成
考えてみましょう、あなたが持っているのErrorHandlerの任意の定義された例外またはエラーがあるたびに呼び出されますサーブレットを。以下は、web.xmlで作成されたエントリです。
<!-- servlet definition -->
<servlet>
<servlet-name>ErrorHandler</servlet-name>
<servlet-class>ErrorHandler</servlet-class>
</servlet>
<!-- servlet mappings -->
<servlet-mapping>
<servlet-name>ErrorHandler</servlet-name>
<url-pattern>/ErrorHandler</url-pattern>
</servlet-mapping>
<!-- error-code related error pages -->
<error-page>
<error-code>404</error-code>
<location>/ErrorHandler</location>
</error-page>
<error-page>
<error-code>403</error-code>
<location>/ErrorHandler</location>
</error-page>
<!-- exception-type related error pages -->
<error-page>
<exception-type>
javax.servlet.ServletException
</exception-type >
<location>/ErrorHandler</location>
</error-page>
<error-page>
<exception-type>java.io.IOException</exception-type >
<location>/ErrorHandler</location>
</error-page>すべての例外に対して汎用のエラーハンドラーが必要な場合は、例外ごとに個別のエラーページ要素を定義するのではなく、次のエラーページを定義する必要があります。
<error-page>
<exception-type>java.lang.Throwable</exception-type >
<location>/ErrorHandler</location>
</error-page>以下は、例外処理に関する上記のweb.xmlについて注意すべき点です-
サーブレットErrorHandlerは、他のサーブレットと同じように通常の方法で定義され、web.xmlで構成されます。
ステータスコード404（見つかりません）または403（禁止）のエラーがある場合、ErrorHandlerサーブレットが呼び出されます。
WebアプリケーションがServletExceptionまたはIOExceptionのいずれかをスローした場合、Webコンテナは/ ErrorHandlerサーブレットを呼び出します。
さまざまなタイプのエラーまたは例外を処理するために、さまざまなエラーハンドラーを定義できます。上記の例は非常に一般的であり、基本的な概念を説明する目的に役立つことを願っています。
リクエスト属性-エラー/例外
以下は、エラー処理サーブレットがエラー/例外の性質を分析するためにアクセスできる要求属性のリストです。
| シニア番号 | 属性と説明 |
|---|---|
| 1 | javax.servlet.error.status_code この属性は、java.lang.Integerデータ型に格納した後に格納および分析できるステータスコードを提供します。 |
| 2 | javax.servlet.error.exception_type この属性は、java.lang.Classデータ型に格納した後に格納および分析できる例外タイプに関する情報を提供します。 |
| 3 | javax.servlet.error.message この属性は、java.lang.Stringデータ型に格納した後に格納および分析できる正確なエラーメッセージを情報に提供します。 |
| 4 | javax.servlet.error.request_uri この属性は、サーブレットを呼び出すURLに関する情報を提供し、java.lang.Stringデータ型に格納した後に格納および分析できます。 |
| 5 | javax.servlet.error.exception この属性は、発生した例外に関する情報を提供し、保存および分析できます。 |
| 6 | javax.servlet.error.servlet_name この属性は、java.lang.Stringデータ型に格納した後に格納および分析できるサーブレット名を提供します。 |
エラーハンドラサーブレットの例
この例では、サーブレットでの例外処理の基本を理解できますが、同じ概念を使用して、より高度なフィルターアプリケーションを作成できます。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class ErrorHandler extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Analyze the servlet exception
Throwable throwable = (Throwable)
request.getAttribute("javax.servlet.error.exception");
Integer statusCode = (Integer)
request.getAttribute("javax.servlet.error.status_code");
String servletName = (String)
request.getAttribute("javax.servlet.error.servlet_name");
if (servletName == null) {
servletName = "Unknown";
}
String requestUri = (String)
request.getAttribute("javax.servlet.error.request_uri");
if (requestUri == null) {
requestUri = "Unknown";
}
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Error/Exception Information";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n");
if (throwable == null && statusCode == null) {
out.println("<h2>Error information is missing</h2>");
out.println("Please return to the <a href=\"" +
response.encodeURL("http://localhost:8080/") +
"\">Home Page</a>.");
} else if (statusCode != null) {
out.println("The status code : " + statusCode);
} else {
out.println("<h2>Error information</h2>");
out.println("Servlet Name : " + servletName + "</br></br>");
out.println("Exception Type : " + throwable.getClass( ).getName( ) + "</br></br>");
out.println("The request URI: " + requestUri + "<br><br>");
out.println("The exception message: " + throwable.getMessage( ));
}
out.println("</body>");
out.println("</html>");
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}コンパイル ErrorHandler.java 通常の方法でクラスファイルを
例外を処理するために、web.xmlに次の構成を追加しましょう-
<servlet>
<servlet-name>ErrorHandler</servlet-name>
<servlet-class>ErrorHandler</servlet-class>
</servlet>
<!-- servlet mappings -->
<servlet-mapping>
<servlet-name>ErrorHandler</servlet-name>
<url-pattern>/ErrorHandler</url-pattern>
</servlet-mapping>
<error-page>
<error-code>404</error-code>
<location>/ErrorHandler</location>
</error-page>
<error-page>
<exception-type>java.lang.Throwable</exception-type >
<location>/ErrorHandler</location>
</error-page>ここで、例外を発生させたり、間違ったURLを入力したりするサーブレットを使用してみてください。これにより、Webコンテナが呼び出されます。 ErrorHandlerサーブレットを作成し、プログラムどおりに適切なメッセージを表示します。たとえば、間違ったURLを入力すると、次の結果が表示されます-
The status code : 404上記のコードは、一部のWebブラウザでは機能しない場合があります。したがって、MozillaとSafariを試してみると、うまくいくはずです。
クッキーはクライアントコンピュータに保存されるテキストファイルであり、さまざまな情報追跡の目的で保持されます。JavaサーブレットはHTTPCookieを透過的にサポートします。
リピーターの特定には3つのステップがあります-
サーバースクリプトは、一連のCookieをブラウザに送信します。たとえば、名前、年齢、識別番号など。
ブラウザは、将来使用するためにこの情報をローカルマシンに保存します。
次回ブラウザがWebサーバーに要求を送信すると、ブラウザはそれらのCookie情報をサーバーに送信し、サーバーはその情報を使用してユーザーを識別します。
この章では、Cookieを設定またはリセットする方法、Cookieにアクセスする方法、およびCookieを削除する方法について説明します。
クッキーの構造
通常、CookieはHTTPヘッダーに設定されます（ただし、JavaScriptはブラウザーに直接Cookieを設定することもできます）。Cookieを設定するサーブレットは、次のようなヘッダーを送信する可能性があります-
HTTP/1.1 200 OK
Date: Fri, 04 Feb 2000 21:03:38 GMT
Server: Apache/1.3.9 (UNIX) PHP/4.0b3
Set-Cookie: name = xyz; expires = Friday, 04-Feb-07 22:03:38 GMT;
path = /; domain = tutorialspoint.com
Connection: close
Content-Type: text/htmlご覧のとおり、Set-Cookieヘッダーには、名前と値のペア、GMT日付、パス、およびドメインが含まれています。名前と値はURLエンコードされます。有効期限フィールドは、指定された日時の後にCookieを「忘れる」ようにブラウザに指示するものです。
ブラウザがCookieを保存するように構成されている場合、ブラウザは有効期限までこの情報を保持します。ユーザーがCookieのパスとドメインに一致するページをブラウザに向けると、Cookieがサーバーに再送信されます。ブラウザのヘッダーは次のようになります-
GET / HTTP/1.0
Connection: Keep-Alive
User-Agent: Mozilla/4.6 (X11; I; Linux 2.2.6-15apmac ppc)
Host: zink.demon.co.uk:1126
Accept: image/gif, */*
Accept-Encoding: gzip
Accept-Language: en
Accept-Charset: iso-8859-1,*,utf-8
Cookie: name = xyzサーブレットは、Cookieオブジェクトの配列を返すrequestメソッドrequest.getCookies（）を介してCookieにアクセスできます。
サーブレットCookieメソッド
以下は、サーブレットでCookieを操作するときに使用できる便利なメソッドのリストです。
| シニア番号 | 方法と説明 |
|---|---|
| 1 | public void setDomain(String pattern) このメソッドは、cookieが適用されるドメインを設定します（例：tutorialspoint.com）。 |
| 2 | public String getDomain() このメソッドは、cookieが適用されるドメイン（tutorialspoint.comなど）を取得します。 |
| 3 | public void setMaxAge(int expiry) このメソッドは、Cookieの有効期限が切れるまでに経過する時間（秒単位）を設定します。これを設定しない場合、Cookieは現在のセッションの間のみ存続します。 |
| 4 | public int getMaxAge() このメソッドは、秒単位で指定されたCookieの最大経過時間を返します。デフォルトでは、-1は、ブラウザがシャットダウンするまでCookieが存続することを示します。 |
| 5 | public String getName() このメソッドは、Cookieの名前を返します。作成後に名前を変更することはできません。 |
| 6 | public void setValue(String newValue) このメソッドは、Cookieに関連付けられた値を設定します |
| 7 | public String getValue() このメソッドは、Cookieに関連付けられた値を取得します。 |
| 8 | public void setPath(String uri) このメソッドは、このCookieが適用されるパスを設定します。パスを指定しない場合、現在のページと同じディレクトリ内のすべてのURLと、すべてのサブディレクトリに対してCookieが返されます。 |
| 9 | public String getPath() このメソッドは、このCookieが適用されるパスを取得します。 |
| 10 | public void setSecure(boolean flag) このメソッドは、Cookieを暗号化された（つまりSSL）接続でのみ送信するかどうかを示すブール値を設定します。 |
| 11 | public void setComment(String purpose) このメソッドは、Cookieの目的を説明するコメントを指定します。このコメントは、ブラウザがCookieをユーザーに提示する場合に役立ちます。 |
| 12 | public String getComment() このメソッドは、このCookieの目的を説明するコメントを返します。Cookieにコメントがない場合はnullを返します。 |
サーブレットを使用したCookieの設定
サーブレットを使用したCookieの設定には3つのステップが含まれます-
(1) Creating a Cookie object −どちらも文字列であるCookie名とCookie値を使用してCookieコンストラクターを呼び出します。
Cookie cookie = new Cookie("key","value");名前にも値にも空白や次の文字を含めることはできません。
[ ] ( ) = , " / ? @ : ;(2) Setting the maximum age− setMaxAgeを使用して、Cookieが有効である期間（秒単位）を指定します。以下は、24時間Cookieを設定します。
cookie.setMaxAge(60 * 60 * 24);(3) Sending the Cookie into the HTTP response headers −次のようにresponse.addCookieを使用してHTTP応答ヘッダーにCookieを追加します−
response.addCookie(cookie);例
フォームの例を変更して、姓名のCookieを設定しましょう。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class HelloForm extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Create cookies for first and last names.
Cookie firstName = new Cookie("first_name", request.getParameter("first_name"));
Cookie lastName = new Cookie("last_name", request.getParameter("last_name"));
// Set expiry date after 24 Hrs for both the cookies.
firstName.setMaxAge(60*60*24);
lastName.setMaxAge(60*60*24);
// Add both the cookies in the response header.
response.addCookie( firstName );
response.addCookie( lastName );
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Setting Cookies Example";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head>
<title>" + title + "</title>
</head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<ul>\n" +
" <li><b>First Name</b>: "
+ request.getParameter("first_name") + "\n" +
" <li><b>Last Name</b>: "
+ request.getParameter("last_name") + "\n" +
"</ul>\n" +
"</body>
</html>"
);
}
}上記のサーブレットをコンパイルします HelloForm そして、web.xmlファイルに適切なエントリを作成し、最後にHTMLページに従ってサーブレットを呼び出してみてください。
<html>
<body>
<form action = "HelloForm" method = "GET">
First Name: <input type = "text" name = "first_name">
<br />
Last Name: <input type = "text" name = "last_name" />
<input type = "submit" value = "Submit" />
</form>
</body>
</html>上記のHTMLコンテンツをファイルHello.htmに保持し、<Tomcat-installationdirectory> / webapps / ROOTディレクトリに配置します。http：// localhost：8080 / Hello.htmにアクセスする場合、上記のフォームの実際の出力は次のとおりです。
名と姓を入力して、送信ボタンをクリックしてみてください。これにより、画面に名と姓が表示されると同時に、2つのCookieのfirstNameとlastNameが設定され、次に[送信]ボタンを押したときにサーバーに返されます。
次のセクションでは、WebアプリケーションでこれらのCookieにアクセスする方法について説明します。
サーブレットを使用したCookieの読み取り
Cookieを読み取るには、を呼び出してjavax.servlet.http.Cookieオブジェクトの配列を作成する必要があります。getCookies()HttpServletRequestのメソッド。次に、配列を循環し、getName（）メソッドとgetValue（）メソッドを使用して、各Cookieと関連する値にアクセスします。
例
前の例で設定したCookieを読みましょう-
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class ReadCookies extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Cookie cookie = null;
Cookie[] cookies = null;
// Get an array of Cookies associated with this domain
cookies = request.getCookies();
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Reading Cookies Example";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" );
if( cookies != null ) {
out.println("<h2> Found Cookies Name and Value</h2>");
for (int i = 0; i < cookies.length; i++) {
cookie = cookies[i];
out.print("Name : " + cookie.getName( ) + ", ");
out.print("Value: " + cookie.getValue( ) + " <br/>");
}
} else {
out.println("<h2>No cookies founds</h2>");
}
out.println("</body>");
out.println("</html>");
}
}上記のサーブレットをコンパイルする ReadCookiesweb.xmlファイルに適切なエントリを作成します。first_name cookieを「John」、last_name cookieを「Player」に設定した場合、http：// localhost：8080 / ReadCookiesを実行すると次の結果が表示されます-
Found Cookies Name and Value
Name : first_name, Value: John
Name : last_name, Value: PlayerサーブレットでCookieを削除する
クッキーを削除するのはとても簡単です。クッキーを削除したい場合は、次の3つの手順に従ってフォローアップする必要があります-
既存のCookieを読み取り、Cookieオブジェクトに保存します。
を使用してCookieの経過時間をゼロに設定します setMaxAge() 既存のCookieを削除する方法
このCookieを応答ヘッダーに追加し直します。
例
次の例では、「first_name」という名前の既存のCookieを削除し、次にReadCookiesサーブレットを実行すると、first_nameにnull値が返されます。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class DeleteCookies extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Cookie cookie = null;
Cookie[] cookies = null;
// Get an array of Cookies associated with this domain
cookies = request.getCookies();
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Delete Cookies Example";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" );
if( cookies != null ) {
out.println("<h2> Cookies Name and Value</h2>");
for (int i = 0; i < cookies.length; i++) {
cookie = cookies[i];
if((cookie.getName( )).compareTo("first_name") == 0 ) {
cookie.setMaxAge(0);
response.addCookie(cookie);
out.print("Deleted cookie : " + cookie.getName( ) + "<br/>");
}
out.print("Name : " + cookie.getName( ) + ", ");
out.print("Value: " + cookie.getValue( )+" <br/>");
}
} else {
out.println("<h2>No cookies founds</h2>");
}
out.println("</body>");
out.println("</html>");
}
}上記のサーブレットをコンパイルする DeleteCookiesweb.xmlファイルに適切なエントリを作成します。今すぐ実行します。http：// localhostを：8080 / DeleteCookies次のような結果が表示されます-
Cookies Name and Value
Deleted cookie : first_name
Name : first_name, Value: John
Name : last_name, Value: Player
ここでhttp：// localhost：8080 / ReadCookiesを実行しようとすると、次のように1つのCookieのみが表示されます-
Found Cookies Name and Value
Name : last_name, Value: PlayerInternetExplorerでCookieを手動で削除できます。[ツール]メニューから開始し、[インターネットオプション]を選択します。すべてのCookieを削除するには、[Cookieの削除]を押します。
HTTPは「ステートレス」プロトコルです。つまり、クライアントがWebページを取得するたびに、クライアントはWebサーバーへの個別の接続を開き、サーバーは以前のクライアント要求の記録を自動的に保持しません。
それでも、WebクライアントとWebサーバー間のセッションを維持するには次の3つの方法があります-
クッキー
Webサーバーは、一意のセッションIDをCookieとして各Webクライアントに割り当てることができ、クライアントからの後続の要求では、受信したCookieを使用してそれらを認識することができます。
多くの場合、ブラウザはCookieをサポートしていないため、これは効果的な方法ではない可能性があります。そのため、この手順を使用してセッションを維持することはお勧めしません。
非表示のフォームフィールド
Webサーバーは、次のように、非表示のHTMLフォームフィールドを一意のセッションIDとともに送信できます。
<input type = "hidden" name = "sessionid" value = "12345">このエントリは、フォームが送信されると、指定された名前と値がGETまたはPOSTデータに自動的に含まれることを意味します。Webブラウザーが要求を送り返すたびに、session_id値を使用してさまざまなWebブラウザーを追跡できます。
これはセッションを追跡する効果的な方法ですが、通常の（<A HREF ...>）ハイパーテキストリンクをクリックしてもフォームは送信されないため、非表示のフォームフィールドも一般的なセッション追跡をサポートできません。
URL書き換え
セッションを識別する各URLの末尾にいくつかの追加データを追加でき、サーバーはそのセッションIDをそのセッションに関して保存されているデータに関連付けることができます。
たとえば、http：//tutorialspoint.com/file.htm; sessionid = 12345の場合、セッション識別子はsessionid = 12345として添付され、Webサーバーでアクセスしてクライアントを識別できます。
URL書き換えはセッションを維持するためのより良い方法であり、ブラウザがCookieをサポートしていない場合でも機能します。URL書き換えの欠点は、単純な静的HTMLページの場合でも、セッションIDを割り当てるためにすべてのURLを動的に生成する必要があることです。
HttpSessionオブジェクト
上記の3つの方法とは別に、サーブレットはHttpSessionインターフェイスを提供します。これは、複数のページ要求またはWebサイトへのアクセスでユーザーを識別し、そのユーザーに関する情報を格納する方法を提供します。
サーブレットコンテナは、このインターフェイスを使用して、HTTPクライアントとHTTPサーバーの間にセッションを作成します。セッションは、ユーザーからの複数の接続またはページ要求にわたって、指定された期間持続します。
publicメソッドを呼び出すことでHttpSessionオブジェクトを取得します getSession() 以下のように、HttpServletRequestの
HttpSession session = request.getSession();ドキュメントコンテンツをクライアントに送信する前に、request.getSession（）を呼び出す必要があります。これは、HttpSessionオブジェクトを介して利用できる重要なメソッドの要約です-
| シニア番号 | 方法と説明 |
|---|---|
| 1 | public Object getAttribute(String name) このメソッドは、このセッションで指定された名前でバインドされたオブジェクトを返します。名前でバインドされたオブジェクトがない場合はnullを返します。 |
| 2 | public Enumeration getAttributeNames() このメソッドは、このセッションにバインドされているすべてのオブジェクトの名前を含むStringオブジェクトの列挙を返します。 |
| 3 | public long getCreationTime() このメソッドは、このセッションが作成された時刻を返します。これは、1970年1月1日GMTの午前0時からミリ秒単位で測定されます。 |
| 4 | public String getId() このメソッドは、このセッションに割り当てられた一意の識別子を含む文字列を返します。 |
| 5 | public long getLastAccessedTime() このメソッドは、セッションの最終アクセス時刻を1970年1月1日午前0時からのミリ秒の形式で返します。GMT |
| 6 | public int getMaxInactiveInterval() このメソッドは、サーブレットコンテナがクライアントアクセス間でセッションを開いたままにする最大時間間隔（秒）を返します。 |
| 7 | public void invalidate() このメソッドは、このセッションを無効にし、それにバインドされているオブジェクトのバインドを解除します。 |
| 8 | public boolean isNew( クライアントがセッションについてまだ知らない場合、またはクライアントがセッションに参加しないことを選択した場合、このメソッドはtrueを返します。 |
| 9 | public void removeAttribute(String name) このメソッドは、指定された名前でバインドされたオブジェクトをこのセッションから削除します。 |
| 10 | public void setAttribute(String name, Object value) このメソッドは、指定された名前を使用して、オブジェクトをこのセッションにバインドします。 |
| 11 | public void setMaxInactiveInterval(int interval) このメソッドは、サーブレットコンテナがこのセッションを無効にするまでのクライアント要求間の時間を秒単位で指定します。 |
セッション追跡の例
この例では、HttpSessionオブジェクトを使用して、セッションの作成時刻と最後にアクセスされた時刻を確認する方法について説明します。新しいセッションがまだ存在しない場合は、リクエストに関連付けます。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class SessionTrack extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Create a session object if it is already not created.
HttpSession session = request.getSession(true);
// Get session creation time.
Date createTime = new Date(session.getCreationTime());
// Get last access time of this web page.
Date lastAccessTime = new Date(session.getLastAccessedTime());
String title = "Welcome Back to my website";
Integer visitCount = new Integer(0);
String visitCountKey = new String("visitCount");
String userIDKey = new String("userID");
String userID = new String("ABCD");
// Check if this is new comer on your web page.
if (session.isNew()) {
title = "Welcome to my website";
session.setAttribute(userIDKey, userID);
} else {
visitCount = (Integer)session.getAttribute(visitCountKey);
visitCount = visitCount + 1;
userID = (String)session.getAttribute(userIDKey);
}
session.setAttribute(visitCountKey, visitCount);
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">Session Infomation</h2>\n" +
"<table border = \"1\" align = \"center\">\n" +
"<tr bgcolor = \"#949494\">\n" +
" <th>Session info</th><th>value</th>
</tr>\n" +
"<tr>\n" +
" <td>id</td>\n" +
" <td>" + session.getId() + "</td>
</tr>\n" +
"<tr>\n" +
" <td>Creation Time</td>\n" +
" <td>" + createTime + " </td>
</tr>\n" +
"<tr>\n" +
" <td>Time of Last Access</td>\n" +
" <td>" + lastAccessTime + " </td>
</tr>\n" +
"<tr>\n" +
" <td>User ID</td>\n" +
" <td>" + userID + " </td>
</tr>\n" +
"<tr>\n" +
" <td>Number of visits</td>\n" +
" <td>" + visitCount + "</td>
</tr>\n" +
"</table>\n" +
"</body>
</html>"
);
}
}上記のサーブレットをコンパイルします SessionTrackweb.xmlファイルに適切なエントリを作成します。今すぐ実行します。http：// localhostを：8080 / SessionTrackは、あなたが最初に実行されます場合は、次の結果が表示されます-
Welcome to my website
Session Infomation
Session info
value
id
0AE3EC93FF44E3C525B4351B77ABB2D5
Creation Time
Tue Jun 08 17:26:40 GMT+04:00 2010
Time of Last Access
Tue Jun 08 17:26:40 GMT+04:00 2010
User ID
ABCD
Number of visits
0
同じサーブレットをもう一度実行しようとすると、次の結果が表示されます。
Welcome Back to my website
Session Infomation
info type
value
id
0AE3EC93FF44E3C525B4351B77ABB2D5
Creation Time
Tue Jun 08 17:26:40 GMT+04:00 2010
Time of Last Access
Tue Jun 08 17:26:40 GMT+04:00 2010
User ID
ABCD
Number of visits
1
セッションデータの削除
ユーザーのセッションデータを使い終わったら、いくつかのオプションがあります-
Remove a particular attribute− public void removeAttribute（String name）メソッドを呼び出して、特定のキーに関連付けられている値を削除できます。
Delete the whole session− public void invalidate（）メソッドを呼び出して、セッション全体を破棄できます。
Setting Session timeout− public void setMaxInactiveInterval（int interval）メソッドを呼び出して、セッションのタイムアウトを個別に設定できます。
Log the user out −サーブレット2.4をサポートするサーバー。 logout クライアントをWebサーバーからログアウトし、すべてのユーザーに属するすべてのセッションを無効にします。
web.xml Configuration − Tomcatを使用している場合、上記の方法とは別に、次のようにweb.xmlファイルでセッションタイムアウトを構成できます。
<session-config>
<session-timeout>15</session-timeout>
</session-config>タイムアウトは分で表され、Tomcatのデフォルトのタイムアウトである30分を上書きします。
サーブレットのgetMaxInactiveInterval（）メソッドは、そのセッションのタイムアウト期間を秒単位で返します。したがって、セッションがweb.xmlで15分間構成されている場合、getMaxInactiveInterval（）は900を返します。
このチュートリアルは、JDBCアプリケーションがどのように機能するかを理解していることを前提としています。サーブレットを介したデータベースアクセスを開始する前に、データベースとともに適切なJDBC環境がセットアップされていることを確認してください。
JDBCを使用してデータベースにアクセスする方法とその環境設定の詳細については、JDBCチュートリアルを参照してください。
基本的な概念から始めるために、次のように単純なテーブルを作成し、そのテーブルにいくつかのレコードを作成しましょう。
テーブルを作成する
を作成するには Employees TESTデータベースのテーブルで、次の手順を使用します-
ステップ1
開く Command Prompt 次のようにインストールディレクトリに移動します-
C:\>
C:\>cd Program Files\MySQL\bin
C:\Program Files\MySQL\bin>ステップ2
次のようにデータベースにログインします
C:\Program Files\MySQL\bin>mysql -u root -p
Enter password: ********
mysql>ステップ3
テーブルを作成します Employee に TEST 次のようなデータベース-
mysql> use TEST;
mysql> create table Employees (
id int not null,
age int not null,
first varchar (255),
last varchar (255)
);
Query OK, 0 rows affected (0.08 sec)
mysql>データレコードを作成する
最後に、次のようにEmployeeテーブルにいくつかのレコードを作成します-
mysql> INSERT INTO Employees VALUES (100, 18, 'Zara', 'Ali');
Query OK, 1 row affected (0.05 sec)
mysql> INSERT INTO Employees VALUES (101, 25, 'Mahnaz', 'Fatma');
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO Employees VALUES (102, 30, 'Zaid', 'Khan');
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO Employees VALUES (103, 28, 'Sumit', 'Mittal');
Query OK, 1 row affected (0.00 sec)
mysql>データベースへのアクセス
これは、サーブレットを使用してTESTデータベースにアクセスする方法を示す例です。
// Loading required libraries
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.sql.*;
public class DatabaseAccess extends HttpServlet{
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL="jdbc:mysql://localhost/TEST";
// Database credentials
static final String USER = "root";
static final String PASS = "password";
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Database Result";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n");
try {
// Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");
// Open a connection
Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
// Execute SQL query
Statement stmt = conn.createStatement();
String sql;
sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql);
// Extract data from result set
while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");
//Display values
out.println("ID: " + id + "<br>");
out.println(", Age: " + age + "<br>");
out.println(", First: " + first + "<br>");
out.println(", Last: " + last + "<br>");
}
out.println("</body></html>");
// Clean-up environment
rs.close();
stmt.close();
conn.close();
} catch(SQLException se) {
//Handle errors for JDBC
se.printStackTrace();
} catch(Exception e) {
//Handle errors for Class.forName
e.printStackTrace();
} finally {
//finally block used to close resources
try {
if(stmt!=null)
stmt.close();
} catch(SQLException se2) {
} // nothing we can do
try {
if(conn!=null)
conn.close();
} catch(SQLException se) {
se.printStackTrace();
} //end finally try
} //end try
}
}上記のサーブレットをコンパイルして、web.xmlに次のエントリを作成しましょう。
....
<servlet>
<servlet-name>DatabaseAccess</servlet-name>
<servlet-class>DatabaseAccess</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>DatabaseAccess</servlet-name>
<url-pattern>/DatabaseAccess</url-pattern>
</servlet-mapping>
....次に、URL http：// localhost：8080 / DatabaseAccessを使用してこのサーブレットを呼び出します。これにより、次の応答が表示されます-
Database Result
ID: 100, Age: 18, First: Zara, Last: Ali
ID: 101, Age: 25, First: Mahnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: MittalサーブレットをHTMLフォームタグとともに使用して、ユーザーがファイルをサーバーにアップロードできるようにすることができます。アップロードされるファイルは、テキストファイル、画像ファイル、または任意のドキュメントです。
ファイルアップロードフォームの作成
以下のHTMコードは、アップローダーフォームを作成します。以下は注意すべき重要なポイントです-
フォーム method 属性はに設定する必要があります POST メソッドとGETメソッドは使用できません
フォーム enctype 属性はに設定する必要があります multipart/form-data。
フォーム action属性は、バックエンドサーバーでのファイルのアップロードを処理するサーブレットファイルに設定する必要があります。次の例は使用していますUploadServlet ファイルをアップロードするサーブレット。
単一のファイルをアップロードするには、属性type = "file"を持つ単一の<input ... />タグを使用する必要があります。複数のファイルをアップロードできるようにするには、name属性の値が異なる複数の入力タグを含めます。ブラウザは、[参照]ボタンをそれぞれに関連付けます。
<html>
<head>
<title>File Uploading Form</title>
</head>
<body>
<h3>File Upload:</h3>
Select a file to upload: <br />
<form action = "UploadServlet" method = "post" enctype = "multipart/form-data">
<input type = "file" name = "file" size = "50" />
<br />
<input type = "submit" value = "Upload File" />
</form>
</body>
</html>これにより、ローカルPCからファイルを選択できる次の結果が表示され、ユーザーが[ファイルのアップロード]をクリックすると、選択したファイルと一緒にフォームが送信されます。
File Upload:
Select a file to upload:
NOTE: This is just dummy form and would not work.バックエンドサーブレットの作成
以下はサーブレットです UploadServletこれにより、アップロードされたファイルを受け入れて、ディレクトリ<Tomcat-installation-directory> / webapps / dataに保存します。このディレクトリ名は、次のような外部構成を使用して追加することもできます。context-param 次のようにweb.xmlの要素-
<web-app>
....
<context-param>
<description>Location to store uploaded file</description>
<param-name>file-upload</param-name>
<param-value>
c:\apache-tomcat-5.5.29\webapps\data\
</param-value>
</context-param>
....
</web-app>以下は、一度に複数のファイルのアップロードを処理できるUploadServletのソースコードです。先に進む前に、次のことを確認してください。
次の例はFileUploadに依存しているため、最新バージョンの commons-fileupload.x.x.jarクラスパス内のファイル。あなたはそれをからダウンロードすることができますhttps://commons.apache.org/fileupload/。
FileUploadはCommonsIOに依存するため、最新バージョンの commons-io-x.x.jarクラスパス内のファイル。あなたはそれをからダウンロードすることができますhttps://commons.apache.org/io/。
次の例をテストしている間、maxFileSizeよりも小さいサイズのファイルをアップロードする必要があります。そうしないと、ファイルはアップロードされません。
事前にディレクトリc：\ tempおよびc：\ apache-tomcat8.0.28 \ webapps \ dataを作成しておく必要があります。
// Import required java libraries
import java.io.*;
import java.util.*;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.io.output.*;
public class UploadServlet extends HttpServlet {
private boolean isMultipart;
private String filePath;
private int maxFileSize = 50 * 1024;
private int maxMemSize = 4 * 1024;
private File file ;
public void init( ){
// Get the file location where it would be stored.
filePath = getServletContext().getInitParameter("file-upload");
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
// Check that we have a file upload request
isMultipart = ServletFileUpload.isMultipartContent(request);
response.setContentType("text/html");
java.io.PrintWriter out = response.getWriter( );
if( !isMultipart ) {
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet upload</title>");
out.println("</head>");
out.println("<body>");
out.println("<p>No file uploaded</p>");
out.println("</body>");
out.println("</html>");
return;
}
DiskFileItemFactory factory = new DiskFileItemFactory();
// maximum size that will be stored in memory
factory.setSizeThreshold(maxMemSize);
// Location to save data that is larger than maxMemSize.
factory.setRepository(new File("c:\\temp"));
// Create a new file upload handler
ServletFileUpload upload = new ServletFileUpload(factory);
// maximum file size to be uploaded.
upload.setSizeMax( maxFileSize );
try {
// Parse the request to get file items.
List fileItems = upload.parseRequest(request);
// Process the uploaded file items
Iterator i = fileItems.iterator();
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet upload</title>");
out.println("</head>");
out.println("<body>");
while ( i.hasNext () ) {
FileItem fi = (FileItem)i.next();
if ( !fi.isFormField () ) {
// Get the uploaded file parameters
String fieldName = fi.getFieldName();
String fileName = fi.getName();
String contentType = fi.getContentType();
boolean isInMemory = fi.isInMemory();
long sizeInBytes = fi.getSize();
// Write the file
if( fileName.lastIndexOf("\\") >= 0 ) {
file = new File( filePath + fileName.substring( fileName.lastIndexOf("\\"))) ;
} else {
file = new File( filePath + fileName.substring(fileName.lastIndexOf("\\")+1)) ;
}
fi.write( file ) ;
out.println("Uploaded Filename: " + fileName + "<br>");
}
}
out.println("</body>");
out.println("</html>");
} catch(Exception ex) {
System.out.println(ex);
}
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
throw new ServletException("GET method used with " +
getClass( ).getName( )+": POST method required.");
}
}
}サーブレットのコンパイルと実行
上記のサーブレットUploadServletをコンパイルし、次のようにweb.xmlファイルに必要なエントリを作成します。
<servlet>
<servlet-name>UploadServlet</servlet-name>
<servlet-class>UploadServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>UploadServlet</servlet-name>
<url-pattern>/UploadServlet</url-pattern>
</servlet-mapping>次に、上記で作成したHTMLフォームを使用してファイルをアップロードしてみます。http：// localhost：8080 / UploadFile.htmを試すと、次の結果が表示され、ローカルマシンからファイルをアップロードするのに役立ちます。
File Upload:
Select a file to upload:
サーブレットスクリプトが正常に機能する場合は、ファイルをc：\ apache-tomcat8.0.28 \ webapps \ data \ディレクトリにアップロードする必要があります。
サーブレットを使用することの最も重要な利点の1つは、コアJavaで使用可能なほとんどのメソッドを使用できることです。このチュートリアルでは、提供されているJavaについて説明します。Date で利用可能なクラス java.util パッケージの場合、このクラスは現在の日付と時刻をカプセル化します。
Dateクラスは、2つのコンストラクターをサポートします。最初のコンストラクターは、オブジェクトを現在の日付と時刻で初期化します。
Date( )次のコンストラクターは、1970年1月1日の深夜から経過したミリ秒数に等しい1つの引数を受け入れます。
Date(long millisec)Dateオブジェクトを使用できるようになったら、次のサポートメソッドのいずれかを呼び出して日付を操作できます-
| シニア番号 | 方法と説明 |
|---|---|
| 1 | boolean after(Date date) 呼び出し元のDateオブジェクトにdateで指定された日付より後の日付が含まれている場合はtrueを返し、そうでない場合はfalseを返します。 |
| 2 | boolean before(Date date) 呼び出し元のDateオブジェクトにdateで指定された日付より前の日付が含まれている場合はtrueを返し、そうでない場合はfalseを返します。 |
| 3 | Object clone( ) 呼び出し元のDateオブジェクトを複製します。 |
| 4 | int compareTo(Date date) 呼び出し元のオブジェクトの値を日付の値と比較します。値が等しい場合は0を返します。呼び出し元のオブジェクトが日付より前の場合は、負の値を返します。呼び出し元のオブジェクトが日付より後の場合は、正の値を返します。 |
| 5 | int compareTo(Object obj) objがDateクラスの場合、compareTo（Date）と同じように動作します。それ以外の場合は、ClassCastExceptionをスローします。 |
| 6 | boolean equals(Object date) 呼び出し元のDateオブジェクトにdateで指定されたものと同じ時刻と日付が含まれている場合はtrueを返し、そうでない場合はfalseを返します。 |
| 7 | long getTime( ) 1970年1月1日から経過したミリ秒数を返します。 |
| 8 | int hashCode( ) 呼び出し元オブジェクトのハッシュコードを返します。 |
| 9 | void setTime(long time) 1970年1月1日午前0時からの経過時間をミリ秒単位で表すtimeで指定された時刻と日付を設定します。 |
| 10 | String toString( ) 呼び出し元のDateオブジェクトを文字列に変換し、結果を返します。 |
現在の日付と時刻を取得する
これは、Javaサーブレットで現在の日付と時刻を取得するのが非常に簡単です。toString（）メソッドで単純なDateオブジェクトを使用して、次のように現在の日付と時刻を出力できます。
// Import required java libraries
import java.io.*;
import java.util.Date;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class CurrentDate extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Display Current Date & Time";
Date date = new Date();
String docType = "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">" + date.toString() + "</h2>\n" +
"</body>
</html>"
);
}
}次に、上記のサーブレットをコンパイルしてweb.xmlに適切なエントリを作成し、URL http：// localhost：8080 / CurrentDateを使用してこのサーブレットを呼び出します。これにより、次の結果が得られます-
Display Current Date & Time
Mon Jun 21 21:46:49 GMT+04:00 2010
URL http：// localhost：8080 / CurrentDateを更新してみてください。更新するたびに、秒単位で違いが見つかります。
日付の比較
上で述べたように、サーブレットで使用可能なすべてのJavaメソッドを使用できます。2つの日付を比較する必要がある場合、以下の方法があります-
getTime（）を使用して、両方のオブジェクトについて1970年1月1日の午前0時から経過したミリ秒数を取得し、これら2つの値を比較できます。
メソッドbefore（）、after（）、equals（）を使用できます。たとえば、月の12日は18日の前に来るため、new Date（99、2、12）.before（new Date（99、2、18））はtrueを返します。
Comparableインターフェースによって定義され、Dateによって実装されるcompareTo（）メソッドを使用できます。
SimpleDateFormatを使用した日付の書式設定
SimpleDateFormatは、ロケールに依存する方法で日付をフォーマットおよび解析するための具象クラスです。SimpleDateFormatを使用すると、日時フォーマット用のユーザー定義パターンを選択することから始めることができます。
上記の例を次のように変更しましょう-
// Import required java libraries
import java.io.*;
import java.text.*;
import java.util.Date;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class CurrentDate extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Display Current Date & Time";
Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
String docType = "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">" + ft.format(dNow) + "</h2>\n" +
"</body>
</html>"
);
}
}上記のサーブレットをもう一度コンパイルしてから、URL http：// localhost：8080 / CurrentDateを使用してこのサーブレットを呼び出します。これにより、次の結果が得られます-
Display Current Date & Time
Mon 2010.06.21 at 10:06:44 PM GMT+04:00
単純なDateFormatフォーマットコード
時間形式を指定するには、時間パターン文字列を使用します。このパターンでは、すべてのASCII文字がパターン文字として予約されており、次のように定義されています。
| キャラクター | 説明 | 例 |
|---|---|---|
| G | 時代指定子 | 広告 |
| y | 4桁の年 | 2001年 |
| M | 年の月 | 7月または07 |
| d | 月の日 | 10 |
| h | 午前/午後の時間（1〜12） | 12 |
| H | 1日の時間（0〜23） | 22 |
| m | 時間単位の分 | 30 |
| s | 分で2番目 | 55 |
| S | ミリ秒 | 234 |
| E | 曜日 | 火曜日 |
| D | 年間の日 | 360 |
| F | 月の曜日 | 2（7月第2水曜日） |
| w | 年間の週 | 40 |
| W | 月の週 | 1 |
| a | AM / PMマーカー | 午後 |
| k | 1日の時間（1〜24） | 24 |
| K | 午前/午後の時間（0〜11） | 10 |
| z | タイムゾーン | 東部標準時 |
| ' | テキストのエスケープ | デリミタ |
| 「」 | 一重引用符 | ` |
日付を操作するために使用可能な定数メソッドの完全なリストについては、標準のJavaドキュメントを参照してください。
ページリダイレクトは、クライアントが要求された以外の新しい場所に送信される手法です。ページリダイレクトは通常、ドキュメントが新しい場所に移動するとき、または負荷分散が原因である可能性がある場合に使用されます。
リクエストを別のページにリダイレクトする最も簡単な方法は、メソッドを使用することです sendRedirect()応答オブジェクトの。以下は、このメソッドのシグネチャです-
public void HttpServletResponse.sendRedirect(String location)
throws IOExceptionこのメソッドは、ステータスコードと新しいページの場所とともに応答をブラウザに送り返します。setStatus（）メソッドとsetHeader（）メソッドを一緒に使用して、同じ-を実現することもできます。
....
String site = "http://www.newpage.com" ;
response.setStatus(response.SC_MOVED_TEMPORARILY);
response.setHeader("Location", site);
....例
この例は、サーブレットが別の場所へのページリダイレクトを実行する方法を示しています-
import java.io.*;
import java.sql.Date;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class PageRedirect extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
// New location to be redirected
String site = new String("http://www.photofuntoos.com");
response.setStatus(response.SC_MOVED_TEMPORARILY);
response.setHeader("Location", site);
}
}上記のサーブレットをコンパイルして、web.xmlに次のエントリを作成しましょう。
....
<servlet>
<servlet-name>PageRedirect</servlet-name>
<servlet-class>PageRedirect</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>PageRedirect</servlet-name>
<url-pattern>/PageRedirect</url-pattern>
</servlet-mapping>
....次に、URL http：// localhost：8080 / PageRedirectを使用してこのサーブレットを呼び出します。これにより、URLhttp：//www.photofuntoos.comにリダイレクトされます。
Webページのヒットカウンター
多くの場合、Webサイトの特定のページでのヒットの総数を知りたいと思うでしょう。サーブレットのライフサイクルはサーブレットが実行されるコンテナによって制御されるため、サーブレットを使用してこれらのヒットをカウントするのは非常に簡単です。
以下は、サーブレットのライフサイクルに基づく単純なページヒットカウンターを実装するために実行する手順です。
init（）メソッドでグローバル変数を初期化します。
doGet（）またはdoPost（）メソッドが呼び出されるたびにグローバル変数を増やします。
必要に応じて、データベーステーブルを使用して、destroy（）メソッドにグローバル変数の値を格納できます。この値は、次回サーブレットが初期化されるときにinit（）メソッド内で読み取ることができます。このステップはオプションです。
セッション内での一意のページヒットのみをカウントする場合は、isNew（）メソッドを使用して、そのセッションで同じページがすでにヒットしているかどうかを確認できます。このステップはオプションです。
グローバルカウンターの値を表示して、Webサイトでのヒットの総数を表示できます。このステップもオプションです。
ここでは、Webコンテナが再起動されないと想定しています。再起動するかサーブレットが破棄されると、ヒットカウンタがリセットされます。
例
この例は、単純なページヒットカウンターを実装する方法を示しています-
import java.io.*;
import java.sql.Date;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class PageHitCounter extends HttpServlet {
private int hitCount;
public void init() {
// Reset hit counter.
hitCount = 0;
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
// This method executes whenever the servlet is hit
// increment hitCount
hitCount++;
PrintWriter out = response.getWriter();
String title = "Total Number of Hits";
String docType = "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">" + hitCount + "</h2>\n" +
"</body>
</html>"
);
}
public void destroy() {
// This is optional step but if you like you
// can write hitCount value in your database.
}
}上記のサーブレットをコンパイルして、web.xmlに次のエントリを作成しましょう。
<servlet>
<servlet-name>PageHitCounter</servlet-name>
<servlet-class>PageHitCounter</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>PageHitCounter</servlet-name>
<url-pattern>/PageHitCounter</url-pattern>
</servlet-mapping>
....次に、URL http：// localhost：8080 / PageHitCounterを使用してこのサーブレットを呼び出します。これにより、このページが更新されるたびにカウンターが1つ増え、次の結果が表示されます-
Total Number of Hits
6
Hit Counter for a Website:
多くの場合、Webサイト全体のヒットの総数を知りたいと思うでしょう。これはサーブレットでも非常に簡単で、フィルターを使用してこれを実現できます。
以下は、フィルターライフサイクルに基づく単純なWebサイトヒットカウンターを実装するために実行する手順です。
フィルタのinit（）メソッドでグローバル変数を初期化します。
doFilterメソッドが呼び出されるたびにグローバル変数を増やします。
必要に応じて、データベーステーブルを使用して、グローバル変数の値をfilterのdestroy（）メソッドに格納できます。この値は、次回フィルターが初期化されるときにinit（）メソッド内で読み取ることができます。このステップはオプションです。
ここでは、Webコンテナが再起動されないと想定しています。再起動するかサーブレットが破棄されると、ヒットカウンタがリセットされます。
例
この例は、単純なWebサイトヒットカウンターを実装する方法を示しています-
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
public class SiteHitCounter implements Filter {
private int hitCount;
public void init(FilterConfig config) throws ServletException {
// Reset hit counter.
hitCount = 0;
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws java.io.IOException, ServletException {
// increase counter by one
hitCount++;
// Print the counter.
System.out.println("Site visits count :"+ hitCount );
// Pass request back down the filter chain
chain.doFilter(request,response);
}
public void destroy() {
// This is optional step but if you like you
// can write hitCount value in your database.
}
}次に、上記のサーブレットをコンパイルして、web.xmlに次のエントリを作成しましょう。
....
<filter>
<filter-name>SiteHitCounter</filter-name>
<filter-class>SiteHitCounter</filter-class>
</filter>
<filter-mapping>
<filter-name>SiteHitCounter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
....次に、URL http：// localhost：8080 /などのURLを呼び出します。これにより、ページがヒットするたびにカウンターが1つ増え、ログに次のメッセージが表示されます-
Site visits count : 1
Site visits count : 2
Site visits count : 3
Site visits count : 4
Site visits count : 5
..................ライブゲームのスコア、株式市場のステータス、または外貨両替の配給を表示しているWebページについて考えてみます。このようなすべてのタイプのページでは、ブラウザの更新ボタンまたは再読み込みボタンを使用して、定期的にWebページを更新する必要があります。
Javaサーブレットは、指定された間隔の後に自動的に更新されるようにWebページを作成できるメカニズムを提供することにより、このジョブを簡単にします。
Webページを更新する最も簡単な方法は、メソッドを使用することです。 setIntHeader()応答オブジェクトの。以下は、このメソッドのシグネチャです-
public void setIntHeader(String header, int headerValue)このメソッドは、時間間隔を秒単位で示す整数値とともに、ヘッダー「Refresh」をブラウザーに送り返します。
自動ページ更新の例
この例は、サーブレットがを使用して自動ページ更新を実行する方法を示しています setIntHeader() 設定する方法 Refresh ヘッダ。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class Refresh extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set refresh, autoload time as 5 seconds
response.setIntHeader("Refresh", 5);
// Set response content type
response.setContentType("text/html");
// Get current time
Calendar calendar = new GregorianCalendar();
String am_pm;
int hour = calendar.get(Calendar.HOUR);
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
if(calendar.get(Calendar.AM_PM) == 0)
am_pm = "AM";
else
am_pm = "PM";
String CT = hour+":"+ minute +":"+ second +" "+ am_pm;
PrintWriter out = response.getWriter();
String title = "Auto Page Refresh using Servlet";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n"+
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p>Current Time is: " + CT + "</p>\n"
);
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}次に、上記のサーブレットをコンパイルして、web.xmlに次のエントリを作成しましょう。
....
<servlet>
<servlet-name>Refresh</servlet-name>
<servlet-class>Refresh</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Refresh</servlet-name>
<url-pattern>/Refresh</url-pattern>
</servlet-mapping>
....次に、URL http：// localhost：8080 / Refreshを使用してこのサーブレットを呼び出します。これにより、次のように5秒ごとに現在のシステム時刻が表示されます。サーブレットを実行して、結果が表示されるのを待つだけです-
Auto Page Refresh using Servlet
Current Time is: 9:44:50 PM
サーブレットを使用してメールを送信するのは簡単ですが、最初に必要なのは JavaMail API そして Java Activation Framework (JAF) マシンにインストールされています。
JavaMailの最新バージョン（バージョン1.2）は、Javaの標準Webサイトからダウンロードできます。
JAFの最新バージョン（バージョン1.1.1）は、Javaの標準Webサイトからダウンロードできます。
これらのファイルをダウンロードして解凍します。新しく作成されたトップレベルのディレクトリに、両方のアプリケーション用の多数のjarファイルがあります。追加する必要がありますmail.jar そして activation.jar CLASSPATH内のファイル。
簡単なメールを送信する
これは、マシンから簡単な電子メールを送信する例です。ここでは、localhostインターネットに接続されており、電子メールを送信するのに十分な能力があります。同時に、Java EmailAPIパッケージとJAFパッケージのすべてのjarファイルがCLASSPATHで使用可能であることを確認してください。
// File Name SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
// Assuming you are sending email from localhost
String host = "localhost";
// Get system properties
Properties properties = System.getProperties();
// Setup mail server
properties.setProperty("mail.smtp.host", host);
// Get the default Session object.
Session session = Session.getDefaultInstance(properties);
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
// Set Subject: header field
message.setSubject("This is the Subject Line!");
// Now set the actual message
message.setText("This is actual message");
// Send message
Transport.send(message);
String title = "Send Email";
String res = "Sent message successfully....";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p align = \"center\">" + res + "</p>\n" +
"</body>
</html>"
);
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}次に、上記のサーブレットをコンパイルして、web.xmlに次のエントリを作成しましょう。
....
<servlet>
<servlet-name>SendEmail</servlet-name>
<servlet-class>SendEmail</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>SendEmail</servlet-name>
<url-pattern>/SendEmail</url-pattern>
</servlet-mapping>
....ここで、URL http：// localhost：8080 / SendEmailを使用してこのサーブレットを呼び出します。これにより、指定された電子メールID [email protected]に電子メールが送信され、次の応答が表示されます-
Send Email
Sent message successfully....
複数の受信者に電子メールを送信する場合は、次の方法を使用して複数の電子メールIDを指定します-
void addRecipients(Message.RecipientType type, Address[] addresses)
throws MessagingExceptionパラメータの説明は次のとおりです-
type−これは、TO、CC、またはBCCに設定されます。ここで、CCはカーボンコピーを表し、BCCはブラックカーボンコピーを表します。メッセージの例.RecipientType.TO
addresses−これはEメールIDの配列です。電子メールIDを指定するときは、InternetAddress（）メソッドを使用する必要があります。
HTMLメールを送信する
これは、マシンからHTMLメールを送信する例です。ここでは、localhostインターネットに接続されており、電子メールを送信するのに十分な能力があります。同時に、Java EmailAPIパッケージとJAFパッケージのすべてのjarファイルがCLASSPATHで使用可能であることを確認してください。
この例は前の例と非常に似ていますが、ここではsetContent（）メソッドを使用して、2番目の引数が「text / html」であるコンテンツを設定し、HTMLコンテンツがメッセージに含まれるように指定しています。
この例を使用すると、好きなだけ大きなHTMLコンテンツを送信できます。
// File Name SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
// Assuming you are sending email from localhost
String host = "localhost";
// Get system properties
Properties properties = System.getProperties();
// Setup mail server
properties.setProperty("mail.smtp.host", host);
// Get the default Session object.
Session session = Session.getDefaultInstance(properties);
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
// Set Subject: header field
message.setSubject("This is the Subject Line!");
// Send the actual HTML message, as big as you like
message.setContent("<h1>This is actual message</h1>", "text/html" );
// Send message
Transport.send(message);
String title = "Send Email";
String res = "Sent message successfully....";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p align = \"center\">" + res + "</p>\n" +
"</body>
</html>"
);
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}上記のサーブレットをコンパイルして実行し、指定された電子メールIDでHTMLメッセージを送信します。
電子メールで添付ファイルを送信する
これは、マシンから添付ファイル付きの電子メールを送信する例です。ここでは、localhost インターネットに接続されており、電子メールを送信するのに十分な能力があります。
// File Name SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
// Assuming you are sending email from localhost
String host = "localhost";
// Get system properties
Properties properties = System.getProperties();
// Setup mail server
properties.setProperty("mail.smtp.host", host);
// Get the default Session object.
Session session = Session.getDefaultInstance(properties);
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
// Set Subject: header field
message.setSubject("This is the Subject Line!");
// Create the message part
BodyPart messageBodyPart = new MimeBodyPart();
// Fill the message
messageBodyPart.setText("This is message body");
// Create a multipar message
Multipart multipart = new MimeMultipart();
// Set text message part
multipart.addBodyPart(messageBodyPart);
// Part two is attachment
messageBodyPart = new MimeBodyPart();
String filename = "file.txt";
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);
// Send the complete message parts
message.setContent(multipart );
// Send message
Transport.send(message);
String title = "Send Email";
String res = "Sent message successfully....";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p align = \"center\">" + res + "</p>\n" +
"</body>
</html>"
);
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}上記のサーブレットをコンパイルして実行し、ファイルを添付ファイルとして、指定された電子メールIDのメッセージとともに送信します。
ユーザー認証部分
認証のためにユーザーIDとパスワードを電子メールサーバーに提供する必要がある場合は、これらのプロパティを次のように設定できます。
props.setProperty("mail.user", "myuser");
props.setProperty("mail.password", "mypwd");電子メール送信メカニズムの残りの部分は、上記で説明したとおりのままです。
WEB-INFサブディレクトリを含むWebアプリケーション構造は、すべてのJava Webアプリケーションに標準であり、サーブレットAPI仕様で指定されています。myappの最上位ディレクトリ名を指定します。このディレクトリ構造は次のようになります-
/myapp
/images
/WEB-INF
/classes
/libWEB-INFサブディレクトリには、web.xmlという名前のアプリケーションのデプロイメント記述子が含まれています。すべてのHTMLファイルは、myappである最上位ディレクトリに保存する必要があります。管理者ユーザーの場合、親ディレクトリとしてROOTディレクトリが見つかります。
パッケージでのサーブレットの作成
WEB-INF / classesディレクトリには、すべてのサーブレットクラスとその他のクラスファイルが、パッケージ名と一致する構造で含まれています。たとえば、完全修飾クラス名がある場合com.myorg.MyServlet、このサーブレットクラスは次のディレクトリに配置する必要があります-
/myapp/WEB-INF/classes/com/myorg/MyServlet.class以下は、パッケージ名com.myorgでMyServletクラスを作成する例です。
// Name your package
package com.myorg;
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServlet extends HttpServlet {
private String message;
public void init() throws ServletException {
// Do required initialization
message = "Hello World";
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
// Actual logic goes here.
PrintWriter out = response.getWriter();
out.println("<h1>" + message + "</h1>");
}
public void destroy() {
// do nothing.
}
}パッケージ内のサーブレットのコンパイル
パッケージで利用可能なクラスをコンパイルすることに大きな違いはありません。最も簡単な方法は、Javaファイルを完全修飾パスに保持することです。前述のように、クラスはcom.myorgに保持されます。また、このディレクトリをCLASSPATHに追加する必要があります。
環境が適切に設定されていると仮定して、 <Tomcat-installationdirectory>/ webapps / ROOT / WEB-INF / classesディレクトリを作成し、MyServlet.javaを次のようにコンパイルします
$ javac MyServlet.javaサーブレットが他のライブラリに依存している場合は、それらのJARファイルもCLASSPATHに含める必要があります。Hello Worldプログラムで他のライブラリを使用していないため、servlet-api.jarJARファイルのみを含めました。
このコマンドラインは、Sun Microsystems Java Software Development Kit（JDK）に付属の組み込みjavacコンパイラを使用します。このコマンドを正しく機能させるには、使用しているJavaSDKの場所をPATH環境変数に含める必要があります。
すべてがうまくいけば、上記のコンパイルは MyServlet.class同じディレクトリ内のファイル。次のセクションでは、コンパイルされたサーブレットを本番環境にデプロイする方法について説明します。
パッケージ化されたサーブレットの展開
デフォルトでは、サーブレットアプリケーションはパス<Tomcat-installationdirectory> / webapps / ROOTにあり、クラスファイルは<Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classesにあります。
の完全修飾クラス名がある場合 com.myorg.MyServletの場合、このサーブレットクラスはWEB-INF / classes / com / myorg / MyServlet.classに配置する必要があり、次のエントリを作成する必要があります。 web.xml <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF /にあるファイル
<servlet>
<servlet-name>MyServlet</servlet-name>
<servlet-class>com.myorg.MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MyServlet</servlet-name>
<url-pattern>/MyServlet</url-pattern>
</servlet-mapping>上記のエントリは、web.xmlファイルで使用可能な<web-app> ... </ web-app>タグ内に作成されます。このテーブルにはすでに利用可能なさまざまなエントリが存在する可能性がありますが、気にしないでください。
これでほぼ完了です。<Tomcat-installationdirectory> \ bin \ startup.bat（Windowsの場合）または<Tomcat-installationdirectory> /bin/startup.sh（Linux / Solarisなどの場合）を使用してTomcatサーバーを起動し、最後に http://localhost:8080/MyServletブラウザのアドレスボックスにあります。すべてがうまくいけば、次の結果が得られます-
Hello World
サーブレットのテスト/デバッグは常に困難です。サーブレットは、クライアントとサーバーの相互作用を大量に伴う傾向があり、エラーが発生する可能性が高くなりますが、再現が困難になります。
ここに、デバッグに役立つ可能性のあるいくつかのヒントと提案があります。
System.out.println（）
System.out.println（）は、特定のコードが実行されているかどうかをテストするためのマーカーとして簡単に使用できます。変数値も出力できます。さらに−
SystemオブジェクトはコアJavaオブジェクトの一部であるため、追加のクラスをインストールすることなく、どこでも使用できます。これには、サーブレット、JSP、RMI、EJB、通常のBeanとクラス、およびスタンドアロンアプリケーションが含まれます。
ブレークポイントで停止する手法は、通常の実行を停止するため、より多くの時間がかかります。System.outへの書き込みは、アプリケーションの通常の実行フローにあまり干渉しないため、タイミングが重要な場合に非常に役立ちます。
System.out.println（）を使用するための構文は次のとおりです。
System.out.println("Debugging message");上記の構文で生成されたすべてのメッセージは、Webサーバーのログファイルに記録されます。
メッセージロギング
標準のログ方法を使用してすべてのデバッグ、警告、およびエラーメッセージをログに記録するには、適切なログ方法を使用することをお勧めします。私は使用log4jのは、すべてのメッセージをログに記録します。
サーブレットAPIは、次のようにlog（）メソッドを使用して情報を出力する簡単な方法も提供します。
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class ContextLog extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
String par = request.getParameter("par1");
//Call the two ServletContext.log methods
ServletContext context = getServletContext( );
if (par == null || par.equals(""))
//log version with Throwable parameter
context.log("No message received:", new IllegalStateException("Missing parameter"));
else
context.log("Here is the visitor's message: " + par);
response.setContentType("text/html");
java.io.PrintWriter out = response.getWriter( );
String title = "Context Log";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">Messages sent</h2>\n" +
"</body>
</html>"
);
} //doGet
}ServletContextは、そのテキストメッセージをサーブレットコンテナのログファイルに記録します。Tomcatの場合、これらのログは<Tomcat-installation-directory> / logsにあります。
ログファイルは、新たに発生したバグや問題の頻度を示しています。そのため、通常は発生しないはずの例外のcatch句でlog（）関数を使用することをお勧めします。
JDBデバッガーの使用
アプレットまたはアプリケーションのデバッグに使用するのと同じjdbコマンドを使用してサーブレットをデバッグできます。
サーブレットをデバッグするには、sun.servlet.http.HttpServerをデバッグし、ブラウザからのHTTPリクエストに応答してHttpServerがサーブレットを実行するのを注意深く監視します。これは、アプレットのデバッグ方法と非常によく似ています。違いは、アプレットの場合、デバッグされる実際のプログラムはsun.applet.AppletViewerであるということです。
ほとんどのデバッガーは、アプレットのデバッグ方法を自動的に認識することにより、この詳細を非表示にします。サーブレットに対して同じことを行うまでは、次のようにしてデバッガを支援する必要があります。
デバッガーのクラスパスを設定して、sun.servlet.http.Http-Serverおよび関連するクラスを検出できるようにします。
デバッガーのクラスパスを設定して、サーブレットとサポートクラス（通常はserver_root / servletsとserver_root / classes）も検出できるようにします。
サーブレットの再読み込みが無効になるため、通常、クラスパスにserver_root / servletsは必要ありません。ただし、この包含はデバッグに役立ちます。これにより、HttpServerのカスタムサーブレットローダーがサーブレットをロードする前に、デバッガーがサーブレットにブレークポイントを設定できます。
適切なクラスパスを設定したら、sun.servlet.http.HttpServerのデバッグを開始します。デバッグに関心のあるサーブレットにブレークポイントを設定してから、Webブラウザーを使用して、特定のサーブレット（http：// localhost：8080 / servlet / ServletToDebug）のHttpServerに要求を行うことができます。ブレークポイントで実行が停止しているのがわかるはずです。
コメントの使用
コード内のコメントは、さまざまな方法でデバッグプロセスに役立ちます。コメントは、デバッグプロセスで他の多くの方法で使用できます。
サーブレットはJavaコメントを使用し、1行（// ...）および複数行（/ * ... * /）コメントを使用して、Javaコードの一部を一時的に削除できます。バグが消えた場合は、コメントしたコードを詳しく調べて、問題を見つけてください。
クライアントとサーバーのヘッダー
サーブレットが期待どおりに動作しない場合は、生のHTTPリクエストとレスポンスを確認すると便利な場合があります。HTTPの構造に精通している場合は、要求と応答を読んで、それらのヘッダーで何が起こっているかを正確に確認できます。
重要なデバッグのヒント
サーブレットのデバッグに関するその他のデバッグのヒントのリストを次に示します-
server_root / classesはリロードせず、server_root / servletsはおそらくリロードすることに注意してください。
表示しているページの生のコンテンツを表示するようにブラウザに依頼します。これは、フォーマットの問題を特定するのに役立ちます。これは通常、[表示]メニューのオプションです。
ページのフルリロードを強制して、ブラウザが前のリクエストの出力をキャッシュしていないことを確認してください。Netscape Navigatorでは、Shift-Reloadを使用します。Internet Explorerでは、Shift-Refreshを使用します。
サーブレットのinit（）メソッドがServletConfigパラメータを受け取り、すぐにsuper.init（config）を呼び出すことを確認します。
先に進む前に、3つの重要な用語を説明しましょう-
Internationalization (i18n) −これは、Webサイトが、訪問者の言語または国籍に翻訳されたさまざまなバージョンのコンテンツを提供できるようにすることを意味します。
Localization (l10n) −これは、特定の地理的または文化的地域に適応するためにWebサイトにリソースを追加することを意味します。
locale−これは特定の文化的または地理的な地域です。これは通常、アンダースコアで区切られた国の記号が後に続く言語記号と呼ばれます。たとえば、「en_US」は米国の英語ロケールを表します。
グローバルなウェブサイトを構築する際に注意しなければならない項目がいくつかあります。このチュートリアルでは、これについて完全な詳細を説明することはできませんが、場所、つまりロケールを区別することにより、インターネットコミュニティにさまざまな言語でWebページを提供する方法の良い例を提供します。
サーブレットは、リクエスターのロケールに基づいてサイトの適切なバージョンを取得し、現地の言語、文化、および要件に従って適切なサイトバージョンを提供できます。以下は、ロケールオブジェクトを返すリクエストオブジェクトのメソッドです。
java.util.Locale request.getLocale()ロケールの検出
以下は、リクエスターの場所、言語、そしてもちろんロケールを検出するために使用できる重要なロケールメソッドです。以下のすべてのメソッドは、リクエスターのブラウザーで設定された国名と言語名を表示します。
| シニア番号 | 方法と説明 |
|---|---|
| 1 | String getCountry() このメソッドは、このロケールの国/地域コードをISO 31662文字形式で大文字で返します。 |
| 2 | String getDisplayCountry() このメソッドは、ユーザーに表示するのに適したロケールの国の名前を返します。 |
| 3 | String getLanguage() このメソッドは、このロケールの言語コードを小文字でISO639形式で返します。 |
| 4 | String getDisplayLanguage() このメソッドは、ユーザーへの表示に適したロケールの言語の名前を返します。 |
| 5 | String getISO3Country() このメソッドは、このロケールの国の3文字の省略形を返します。 |
| 6 | String getISO3Language() このメソッドは、このロケールの言語の3文字の省略形を返します。 |
例
この例は、リクエストの言語と関連する国を表示する方法を示しています-
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
public class GetLocale extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//Get the client's Locale
Locale locale = request.getLocale();
String language = locale.getLanguage();
String country = locale.getCountry();
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Detecting Locale";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + language + "</h1>\n" +
"<h2 align = \"center\">" + country + "</h2>\n" +
"</body>
</html>"
);
}
}言語設定
サーブレットは、英語、スペイン語、ドイツ語、フランス語、イタリア語、オランダ語などの西ヨーロッパ言語で書かれたページを出力できます。ここでは、すべての文字を正しく表示するようにContentLanguageヘッダーを設定することが重要です。
2番目のポイントは、HTMLエンティティを使用してすべての特殊文字を表示することです（例：「＆＃241;」）。「ñ」と「＆＃161;」を表します 次のように「¡」を表します。
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
public class DisplaySpanish extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
// Set spanish language code.
response.setHeader("Content-Language", "es");
String title = "En Español";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1>" + "En Español:" + "</h1>\n" +
"<h1>" + "¡Hola Mundo!" + "</h1>\n" +
"</body>
</html>"
);
}
}ロケール固有の日付
java.text.DateFormatクラスとその静的getDateTimeInstance（）メソッドを使用して、ロケールに固有の日付と時刻をフォーマットできます。以下は、特定のロケールに固有の日付をフォーマットする方法を示す例です-
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.DateFormat;
import java.util.Date;
public class DateLocale extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
//Get the client's Locale
Locale locale = request.getLocale( );
String date = DateFormat.getDateTimeInstance(DateFormat.FULL,
DateFormat.SHORT, locale).format(new Date( ));
String title = "Locale Specific Dates";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + date + "</h1>\n" +
"</body>
</html>"
);
}
}ロケール固有の通貨
java.txt.NumberFormatクラスとその静的getCurrencyInstance（）メソッドを使用して、long型やdouble型などの数値をロケール固有の通貨でフォーマットできます。以下は、特定のロケールに固有の通貨をフォーマットする方法を示す例です-
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.NumberFormat;
import java.util.Date;
public class CurrencyLocale extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
//Get the client's Locale
Locale locale = request.getLocale( );
NumberFormat nft = NumberFormat.getCurrencyInstance(locale);
String formattedCurr = nft.format(1000000);
String title = "Locale Specific Currency";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + formattedCurr + "</h1>\n" +
"</body>
</html>"
);
}
}ロケール固有のパーセンテージ
java.txt.NumberFormatクラスとその静的getPercentInstance（）メソッドを使用して、ロケール固有のパーセンテージを取得できます。以下は、特定のロケールに固有のパーセンテージをフォーマットする方法を示す例です-
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.NumberFormat;
import java.util.Date;
public class PercentageLocale extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
//Get the client's Locale
Locale locale = request.getLocale( );
NumberFormat nft = NumberFormat.getPercentInstance(locale);
String formattedPerc = nft.format(0.51);
String title = "Locale Specific Percentage";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + formattedPerc + "</h1>\n" +
"</body>
</html>"
);
}
}これまで、サーブレットがアプリケーションをWebサーバーにデプロイするためにデプロイメント記述子（web.xmlファイル）を使用する方法を学習しました。サーブレットAPI3.0では、javax.servlet.annotationという新しいパッケージが導入されました。サーブレットクラスに注釈を付けるために使用できる注釈タイプを提供します。アノテーションを使用する場合、デプロイメント記述子（web.xml）は必要ありません。ただし、tomcat7以降のバージョンのtomcatを使用する必要があります。
アノテーションは、サーブレット宣言やサーブレットマッピングなどのWebデプロイメント記述子ファイル（web.xml）内の同等のXML構成を置き換えることができます。サーブレットコンテナは、デプロイ時にアノテーション付きクラスを処理します。
サーブレット3.0で導入された注釈タイプは次のとおりです。
| シニア番号 | 注釈と説明 |
|---|---|
| 1 | @WebServlet サーブレットを宣言します。 |
| 2 | @WebInitParam 初期化パラメータを指定します。 |
| 3 | @WebFilter サーブレットフィルタを宣言します。 |
| 4 | @WebListener WebListenerを宣言するには |
| 5 | @HandlesTypes ServletContainerInitializerが処理できるクラスタイプを宣言します。 |
| 6 | @HttpConstraint このアノテーションは、ServletSecurityアノテーション内で使用され、対応するHttpMethodConstraint要素がServletSecurityアノテーション内で発生しないすべてのHTTPプロトコルメソッドに適用されるセキュリティ制約を表します。 |
| 7 | @HttpMethodConstraint このアノテーションは、特定のHTTPプロトコルメッセージのセキュリティ制約を表すために、ServletSecurityアノテーション内で使用されます。 |
| 8 | @MultipartConfig サーブレットクラスで指定される可能性のあるアノテーション。サーブレットのインスタンスがmultipart / form-dataMIMEタイプに準拠するリクエストを予期していることを示します。 |
| 9 | @ServletSecurity このアノテーションは、サーブレット実装クラスで使用され、HTTPプロトコルメッセージでサーブレットコンテナによって適用されるセキュリティ制約を指定します。 |
ここでは、いくつかの注釈について詳しく説明しました。
@WebServlet
@WebServletは、コンテナを使用したサーブレットの構成を宣言するために使用されます。次の表に、WebServletアノテーションに使用される属性のリストを示します。
| シニア番号 | 属性と説明 |
|---|---|
| 1 | String name サーブレットの名前 |
| 2 | String[] value URLパターンの配列 |
| 3 | String[] urlPatterns このフィルターが適用されるURLパターンの配列 |
| 4 | Int loadOnStartup 整数値は、起動順序のヒントを提供します |
| 5 | WebInitParam[] initParams このサーブレットの初期化パラメータの配列 |
| 6 | Boolean asyncSupported このサーブレットでサポートされている非同期操作 |
| 7 | String smallIcon このサーブレットの小さなアイコン（存在する場合） |
| 8 | String largeIcon このサーブレットの大きなアイコン（存在する場合） |
| 9 | String description このサーブレットの説明（存在する場合） |
| 10 | String displayName このサーブレットの表示名（存在する場合） |
少なくとも1つのURLパターンをいずれかで宣言する必要があります value または urlPattern 注釈の属性ですが、両方ではありません。
ザ・ value 設定されている属性がURLパターンのみの場合は、属性の使用をお勧めします。それ以外の場合は、 urlPattern 属性を使用する必要があります。
例
次の例では、@ WebServletアノテーションの使用方法について説明します。テキストを表示するシンプルなサーブレットですHello Servlet。
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet(value = "/Simple")
public class Simple extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.print("<html><body>");
out.print("<h3>Hello Servlet</h3>");
out.print("</body></html>");
}
}コンパイル Simple.java 通常の方法で、クラスファイルを<Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classesに配置します。
ここで、http：// localhost：8080 / Simpleを実行するだけで、任意のサーブレットを呼び出そうとします。Webページに次の出力が表示されます。
Hello servlet@WebInitParam
@WebInitParamアノテーションは、サーブレットまたはフィルタの初期化パラメータを指定するために使用されます。これは、WebFilterまたはWebSevletアノテーション内で使用されます。次の表に、WebInitParamアノテーションに使用される属性のリストを示します。
| シニア番号 | 属性と説明 |
|---|---|
| 1 | String name 初期化パラメータの名前 |
| 2 | String value 初期化パラメータの値 |
| 3 | String description 初期化パラメータの説明 |
例
次の例では、@ WeInitParamアノテーションを@WebServletアノテーションと一緒に使用する方法について説明します。テキストを表示するシンプルなサーブレットですHello Servlet および文字列値 Hello World! から取られた init パラメーター。
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet(value = "/Simple", initParams = {
@WebInitParam(name = "foo", value = "Hello "),
@WebInitParam(name = "bar", value = " World!")
})
public class Simple extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.print("<html><body>");
out.print("<h3>Hello Servlet</h3>");
out.println(getInitParameter("foo"));
out.println(getInitParameter("bar"));
out.print("</body></html>");
}
}コンパイル Simple.java 通常の方法で、クラスファイルを<Tomcat-installationdirectory>; / webapps / ROOT / WEB-INF / classesに配置します。
ここで、http：// localhost：8080 / Simpleを実行するだけで、任意のサーブレットを呼び出そうとします。Webページに次の出力が表示されます。
Hello Servlet
Hello World!@Webfilter
これは、サーブレットフィルタを宣言するために使用されるアノテーションです。これはデプロイメント時にコンテナによって処理され、対応するフィルタが指定されたURLパターン、サーブレット、およびディスパッチャタイプに適用されます。
ザ・ @WebFilter注釈は、Webアプリケーションのフィルターを定義します。このアノテーションはクラスで指定され、宣言されているフィルターに関するメタデータが含まれています。注釈付きフィルターは、少なくとも1つのURLパターンを指定する必要があります。次の表に、WebFilterアノテーションに使用される属性を示します。
| シニア番号 | 属性と説明 |
|---|---|
| 1 | String filterName フィルタの名前 |
| 2 | String[] urlPatterns フィルタが適用される値またはurlPatternsの配列を提供します |
| 3 | DispatcherType[] dispatcherTypes フィルタが適用されるディスパッチャのタイプ（要求/応答）を指定します |
| 4 | String[] servletNames サーブレット名の配列を提供します |
| 5 | String displayName フィルタの名前 |
| 6 | String description フィルタの説明 |
| 7 | WebInitParam[] initParams このフィルターの初期化パラメーターの配列 |
| 8 | Boolean asyncSupported このフィルターでサポートされている非同期操作 |
| 9 | String smallIcon このフィルターの小さなアイコン（存在する場合） |
| 10 | String largeIcon このフィルターの大きなアイコン（存在する場合） |
例
次の例では、@ WebFilterアノテーションの使用方法について説明します。これは、Init-paramの値を表示する単純なLogFilterです。test-paramコンソールの現在のタイムスタンプ。つまり、フィルターは要求と応答の間のインターフェース層のように機能します。ここでは、urlPatternに「/ *」を使用します。つまり、このフィルタはすべてのサーブレットに適用できます。
import java.io.IOException;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.*;
import java.util.*;
// Implements Filter class
@WebFilter(urlPatterns = {"/*"}, initParams = {
@WebInitParam(name = "test-param", value = "Initialization Paramter")})
public class LogFilter implements Filter {
public void init(FilterConfig config) throws ServletException {
// Get init parameter
String testParam = config.getInitParameter("test-param");
//Print the init parameter
System.out.println("Test Param: " + testParam);
}
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
// Log the current timestamp.
System.out.println("Time " + new Date().toString());
// Pass request back down the filter chain
chain.doFilter(request,response);
}
public void destroy( ) {
/* Called before the Filter instance is removed
from service by the web container*/
}
}コンパイル Simple.java 通常の方法で、クラスファイルを<Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classesに配置します。
ここで、http：// localhost：8080 / Simpleを実行するだけで、任意のサーブレットを呼び出そうとします。Webページに次の出力が表示されます。
Hello Servlet
Hello World!次に、サーブレットコンソールを開きます。そこに、あなたはの価値を見つけるでしょうinit パラメータ testparam そしてその current timestamp サーブレット通知メッセージとともに。