JavaServer Pagesとは何ですか？

JavaServer Pages（JSP）は、動的コンテンツをサポートするWebページを開発するためのテクノロジです。これは、開発者が特別なJSPタグを使用してHTMLページにJavaコードを挿入するのに役立ちます。そのほとんどは、<％で始まり、％>で終わります。

JavaServer Pagesコンポーネントは、JavaWebアプリケーションのユーザーインターフェイスの役割を果たすように設計されたJavaサーブレットの一種です。Web開発者は、JSPを、HTMLまたはXHTMLコード、XML要素、および埋め込まれたJSPアクションとコマンドを組み合わせたテキストファイルとして記述します。

JSPを使用すると、Webページフォームを介してユーザーからの入力を収集し、データベースまたは別のソースからレコードを提示し、Webページを動的に作成できます。

JSPタグは、データベースからの情報の取得やユーザー設定の登録、JavaBeansコンポーネントへのアクセス、ページ間の制御の受け渡し、リクエストやページ間の情報の共有など、さまざまな目的に使用できます。

なぜJSPを使用するのですか？

JavaServer Pagesは、多くの場合、を使用して実装されたプログラムと同じ目的を果たします。 Common Gateway Interface (CGI)。しかし、JSPにはCGIと比較していくつかの利点があります。

• JSPでは、個別のCGIファイルを使用する代わりに、動的要素をHTMLページ自体に埋め込むことができるため、パフォーマンスが大幅に向上します。

• JSPは、ページが要求されるたびにサーバーがインタープリターとターゲットスクリプトをロードする必要があるCGI / Perlとは異なり、サーバーによって処理される前に常にコンパイルされます。

• JavaServerPagesはJavaサーブレットAPIの上に構築されているため、サーブレットと同様に、JSPは以下を含むすべての強力なエンタープライズJavaAPIにもアクセスできます。 JDBC, JNDI, EJB, JAXP, 等

• JSPページは、Javaサーブレットテンプレートエンジンでサポートされているモデルであるビジネスロジックを処理するサーブレットと組み合わせて使用​​できます。

最後に、JSPは、エンタープライズクラスのアプリケーション用の完全なプラットフォームであるJavaEEの不可欠な部分です。これは、JSPが最も単純なアプリケーションから最も複雑で要求の厳しいアプリケーションで役割を果たすことができることを意味します。

JSPの利点

次の表に、他のテクノロジに対するJSPを使用する他の利点を示します。

vs. Active Server Pages（ASP）

JSPの利点は2つあります。まず、動的部分はVisual Basicやその他のMS固有の言語ではなく、Javaで記述されているため、より強力で使いやすくなっています。次に、他のオペレーティングシステムやMicrosoft以外のWebサーバーに移植できます。

対純粋サーブレット

HTMLを生成するprintlnステートメントをたくさん持つよりも、通常のHTMLを書く（そして変更する！）方が便利です。

vs.サーバーサイドインクルード（SSI）

SSIは、実際には単純な包含のみを目的としており、フォームデータを使用したり、データベース接続を行ったりする「実際の」プログラムを対象としていません。

対JavaScript

JavaScriptはクライアント上で動的にHTMLを生成できますが、データベースアクセスや画像処理などの複雑なタスクを実行するためにWebサーバーと対話することはほとんどできません。

対静的HTML

もちろん、通常のHTMLに動的な情報を含めることはできません。

次は何ですか？

JSPで開始するように環境をセットアップするために段階的に説明します。あなたがJSPの学習を進めるためにJavaプログラミングを実際に使っていることを前提としています。

Javaプログラミング言語を知らない場合は、Javaチュートリアルを読んでJavaプログラミングを理解することをお勧めします。

開発環境は、JSPプログラムを開発し、テストして、最終的に実行する場所です。

このチュートリアルでは、次の手順を含むJSP開発環境のセットアップについて説明します。

Java DevelopmentKitのセットアップ

このステップでは、Javaソフトウェア開発キット（SDK）の実装をダウンロードし、PATH環境変数を適切に設定します。

-あなたは、OracleのJavaサイトからSDKをダウンロードすることができたJava SEダウンロード。

Java実装をダウンロードしたら、所定の手順に従ってセットアップをインストールおよび構成します。最後に設定しますPATH and JAVA_HOME を含むディレクトリを参照する環境変数 java そして javac、通常 java_install_dir/bin そして java_install_dir それぞれ。

Windowsを実行していて、SDKをにインストールする場合 C:\jdk1.5.0_20、次の行を追加する必要があります C:\autoexec.bat ファイル。

set PATH = C:\jdk1.5.0_20\bin;%PATH%
set JAVA_HOME = C:\jdk1.5.0_20

または、 Windows NT/2000/XP、右クリックすることもできます My Computer、 選択する Properties、その後 Advanced、 に続く Environment Variables。次に、PATH値を更新し、[OK]ボタンを押します。

Unix（Solaris、Linuxなど）で、SDKがにインストールされている場合 /usr/local/jdk1.5.0_20 Cシェルを使用する場合は、次のものを .cshrc ファイル。

setenv PATH /usr/local/jdk1.5.0_20/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.5.0_20

または、 Integrated Development Environment (IDE) お気に入り Borland JBuilder, Eclipse, IntelliJ IDEA、または Sun ONE Studio、簡単なプログラムをコンパイルして実行し、Javaをインストールした場所をIDEが認識していることを確認します。

Webサーバーのセットアップ：Tomcat

JavaServerPagesおよびサーブレット開発をサポートする多数のWebサーバーが市場で入手可能です。一部のWebサーバーは無料でダウンロードでき、Tomcatもその1つです。

Apache Tomcatは、JavaServer Pagesおよびサーブレットテクノロジのオープンソースソフトウェア実装であり、JSPおよびサーブレットをテストするためのスタンドアロンサーバーとして機能し、ApacheWebサーバーと統合できます。マシンにTomcatをセットアップする手順は次のとおりです-

• Tomcatの最新バージョンをからダウンロードします https://tomcat.apache.org/。

• インストールをダウンロードしたら、バイナリディストリビューションを便利な場所に解凍します。たとえば、C:\apache-tomcat-5.5.29 on windows, or /usr/local/apache-tomcat-5.5.29 Linux / Unixで作成します CATALINA_HOME これらの場所を指す環境変数。

Tomcatは、Windowsマシンで次のコマンドを実行することで起動できます-

%CATALINA_HOME%\bin\startup.bat
 
or
 
C:\apache-tomcat-5.5.29\bin\startup.bat

Tomcatは、Unix（Solaris、Linuxなど）マシンで次のコマンドを実行することで起動できます。

$CATALINA_HOME/bin/startup.sh
 
or
 
/usr/local/apache-tomcat-5.5.29/bin/startup.sh

起動が成功すると、Tomcatに含まれているデフォルトのWebアプリケーションが次のURLにアクセスして利用できるようになります。 http://localhost:8080/。

実行すると、次の出力が表示されます-

Tomcatの構成と実行の詳細については、ここに含まれているドキュメントと、TomcatのWebサイトを参照してください。 https://tomcat.apache.org/。

Windowsマシンで次のコマンドを実行すると、Tomcatを停止できます。

%CATALINA_HOME%\bin\shutdown
or

C:\apache-tomcat-5.5.29\bin\shutdown

Unix（Solaris、Linuxなど）マシンで次のコマンドを実行すると、Tomcatを停止できます。

$CATALINA_HOME/bin/shutdown.sh

or

/usr/local/apache-tomcat-5.5.29/bin/shutdown.sh

CLASSPATHの設定

サーブレットはJavaPlatform、Standard Editionの一部ではないため、コンパイラに対してサーブレットクラスを識別する必要があります。

Windowsを実行している場合は、次の行を入力する必要があります。 C:\autoexec.bat ファイル。

set CATALINA = C:\apache-tomcat-5.5.29
set CLASSPATH = %CATALINA%\common\lib\jsp-api.jar;%CLASSPATH%

または、 Windows NT/2000/XP、右クリックすることもできます My Computer、 選択する Properties、その後 Advanced、その後 Environment Variables。次に、CLASSPATH値を更新し、[OK]ボタンを押します。

Unix（Solaris、Linuxなど）では、Cシェルを使用している場合は、次の行を入力します。 .cshrc ファイル。

setenv CATALINA = /usr/local/apache-tomcat-5.5.29
setenv CLASSPATH $CATALINA/common/lib/jsp-api.jar:$CLASSPATH

NOTE −開発ディレクトリが C:\JSPDev (Windows) または /usr/JSPDev (Unix)、次に、これらのディレクトリもCLASSPATHに追加する必要があります。

Webサーバーには、JSPエンジン、つまり、JSPページを処理するためのコンテナが必要です。JSPコンテナは、JSPページのリクエストをインターセプトする役割を果たします。このチュートリアルでは、JSPページの開発をサポートするためにJSPコンテナが組み込まれているApacheを利用します。

JSPコンテナはWebサーバーと連携して、JSPが必要とするランタイム環境やその他のサービスを提供します。それは、JSPの一部である特別な要素を理解する方法を知っています。

次の図は、WebアプリケーションでのJSPコンテナとJSPファイルの位置を示しています。

JSP処理

次の手順は、WebサーバーがJSPを使用してWebページを作成する方法を説明しています。

• 通常のページと同様に、ブラウザはHTTPリクエストをWebサーバーに送信します。

• Webサーバーは、HTTP要求がJSPページに対するものであることを認識し、それをJSPエンジンに転送します。これは、で終わるURLまたはJSPページを使用して行われます。.jsp の代わりに .html。

• JSPエンジンは、JSPページをディスクからロードし、サーブレットコンテンツに変換します。この変換は非常に単純で、すべてのテンプレートテキストがprintln（）ステートメントに変換され、すべてのJSP要素がJavaコードに変換されます。このコードは、ページの対応する動的な動作を実装します。

• JSPエンジンは、サーブレットを実行可能クラスにコンパイルし、元の要求をサーブレットエンジンに転送します。

• サーブレットエンジンと呼ばれるWebサーバーの一部は、サーブレットクラスをロードして実行します。実行中、サーブレットはHTML形式で出力を生成します。出力はさらに、HTTP応答内のサーブレットエンジンによってWebサーバーに渡されます。

• Webサーバーは、静的HTMLコンテンツの観点からHTTP応答をブラウザーに転送します。

• 最後に、Webブラウザーは、静的ページであるかのように、HTTP応答内で動的に生成されたHTMLページを正確に処理します。

上記のすべての手順は、次の図に示されています。

通常、JSPエンジンは、JSPファイルのサーブレットがすでに存在するかどうか、およびJSPの変更日がサーブレットよりも古いかどうかを確認します。JSPが生成されたサーブレットよりも古い場合、JSPコンテナは、JSPが変更されておらず、生成されたサーブレットがまだJSPのコンテンツと一致していると見なします。これにより、プロセスが他のスクリプト言語（PHPなど）よりも効率的になり、したがって高速になります。

したがって、ある意味で、JSPページは、Javaプログラミングの専門家でなくてもサーブレットを作成するための単なる別の方法です。翻訳フェーズを除いて、JSPページは通常のサーブレットとまったく同じように処理されます。

この章では、JSPのライフサイクルについて説明します。JSPの低レベルの機能を理解するための鍵は、JSPが従う単純なライフサイクルを理解することです。

JSPライフサイクルは、作成から破棄までのプロセスとして定義されます。これはサーブレットのライフサイクルに似ていますが、JSPをサーブレットにコンパイルするために必要な追加の手順があります。

JSPがたどるパス

以下は、JSPがたどるパスです。

• Compilation
• Initialization
• Execution
• Cleanup

JSPライフサイクルの4つの主要なフェーズは、サーブレットライフサイクルと非常によく似ています。4つのフェーズについて以下に説明します-

JSPコンパイル

ブラウザがJSPを要求すると、JSPエンジンは最初にページをコンパイルする必要があるかどうかを確認します。ページがコンパイルされたことがない場合、または最後にコンパイルされてからJSPが変更されている場合、JSPエンジンはページをコンパイルします。

コンパイルプロセスには3つのステップが含まれます-

• JSPの解析。
• JSPをサーブレットに変える。
• サーブレットのコンパイル。

JSP初期化

コンテナがJSPをロードすると、コンテナは jspInit()リクエストを処理する前のメソッド。JSP固有の初期化を実行する必要がある場合は、jspInit() 方法−

public void jspInit(){
   // Initialization code...
}

通常、初期化は1回だけ実行され、サーブレットのinitメソッドと同様に、通常、データベース接続を初期化し、ファイルを開き、jspInitメソッドでルックアップテーブルを作成します。

JSP実行

JSPライフサイクルのこのフェーズは、JSPが破棄されるまでのリクエストとのすべての対話を表します。

ブラウザがJSPを要求し、ページがロードおよび初期化されるたびに、JSPエンジンは _jspService() JSPのメソッド。

_jspService（）メソッドは HttpServletRequest と HttpServletResponse そのパラメータとして次のように-

void _jspService(HttpServletRequest request, HttpServletResponse response) {
   // Service handling code...
}

ザ・ _jspService()JSPのメソッドは、要求に基づいて呼び出されます。これは、その要求に対する応答の生成を担当し、このメソッドは、7つのHTTPメソッドすべてに対する応答の生成も担当します。GET, POST, DELETE、など。

JSPクリーンアップ

JSPライフサイクルの破棄フェーズは、JSPがコンテナによる使用から削除される時期を表します。

ザ・ jspDestroy()メソッドは、サーブレットのdestroyメソッドに相当するJSPです。データベース接続の解放や開いているファイルのクローズなど、クリーンアップを実行する必要がある場合は、jspDestroyをオーバーライドします。

jspDestroy（）メソッドの形式は次のとおりです。

public void jspDestroy() {
   // Your cleanup code goes here.
}

この章では、JSPの構文について説明します。JSP開発に関連する単純な構文（つまり、要素）の基本的な使用法を理解します。

JSPの要素

JSPの要素を以下に説明します-

スクリプトレット

スクリプトレットには、ページスクリプト言語で有効なJAVA言語ステートメント、変数またはメソッドの宣言、または式をいくつでも含めることができます。

スクリプトレットの構文は次のとおりです-

<% code fragment %>

上記の構文に相当するXMLを次のように記述できます-

<jsp:scriptlet>
   code fragment
</jsp:scriptlet>

作成するテキスト、HTMLタグ、またはJSP要素は、スクリプトレットの外部にある必要があります。以下は、JSPの簡単で最初の例です。

<html>
   <head><title>Hello World</title></head>
   
   <body>
      Hello World!<br/>
      <%
         out.println("Your IP address is " + request.getRemoteAddr());
      %>
   </body>
</html>

NOTE − Apache TomcatがC：\ apache-tomcat-7.0.2にインストールされており、環境が環境セットアップチュートリアルに従ってセットアップされていると仮定します。

上記のコードをJSPファイルに保存しましょう hello.jsp このファイルを C:\apache-tomcat7.0.2\webapps\ROOTディレクトリ。URLを使用して同じものを閲覧するhttp://localhost:8080/hello.jsp。上記のコードは次の結果を生成します-

JSP宣言

宣言は、JSPファイルの後半でJavaコードで使用できる1つ以上の変数またはメソッドを宣言します。JSPファイルで使用する前に、変数またはメソッドを宣言する必要があります。

以下はJSP宣言の構文です-

<%! declaration; [ declaration; ]+ ... %>

上記の構文に相当するXMLを次のように記述できます-

<jsp:declaration>
   code fragment
</jsp:declaration>

以下はJSP宣言の例です-

<%! int i = 0; %> 
<%! int a, b, c; %> 
<%! Circle a = new Circle(2.0); %>

JSP式

JSP式要素には、評価され、文字列に変換され、JSPファイルの式が表示される場所に挿入されるスクリプト言語式が含まれています。

式の値は文字列に変換されるため、JSPファイルでは、HTMLでタグ付けされているかどうかに関係なく、テキスト行内で式を使用できます。

式要素には、Java言語仕様に従って有効な任意の式を含めることができますが、セミコロンを使用して式を終了することはできません。

以下はJSP式の構文です-

<%= expression %>

上記の構文に相当するXMLを次のように記述できます-

<jsp:expression>
   expression
</jsp:expression>

次の例は、JSP式を示しています-

<html> 
   <head><title>A Comment Test</title></head> 
   
   <body>
      <p>Today's date: <%= (new java.util.Date()).toLocaleString()%></p>
   </body> 
</html>

上記のコードは次の結果を生成します-

Today's date: 11-Sep-2010 21:24:25

JSPコメント

JSPコメントは、JSPコンテナが無視する必要のあるテキストまたはステートメントをマークします。JSPコメントは、JSPページの一部を非表示または「コメントアウト」する場合に役立ちます。

以下はJSPコメントの構文です-

<%-- This is JSP comment --%>

次の例は、JSPコメントを示しています-

<html> 
   <head><title>A Comment Test</title></head> 
   
   <body> 
      <h2>A Test of Comments</h2> 
      <%-- This comment will not be visible in the page source --%> 
   </body> 
</html>

上記のコードは次の結果を生成します-

A Test of Comments

特別に扱われるコメントや文字を挿入するためにさまざまな場合に使用できる特別な構成がいくつかあります。これが要約です-

S.No.	構文と目的
1	<%-- comment --%> JSPコメント。JSPエンジンでは無視されます。
2	<!-- comment --> HTMLコメント。ブラウザによって無視されます。
3	<\% 静的<％リテラルを表します。
4	%\> 静的％>リテラルを表します。
5	\' 一重引用符を使用する属性内の一重引用符。
6	\" 二重引用符を使用する属性の二重引用符。

JSPディレクティブ

JSPディレクティブは、サーブレットクラスの全体的な構造に影響を与えます。通常、次の形式になります-

<%@ directive attribute="value" %>

ディレクティブタグには3つのタイプがあります-

S.No.	指令と説明
1	<%@ page ... %> スクリプト言語、エラーページ、バッファリング要件など、ページに依存する属性を定義します。
2	<%@ include ... %> 翻訳フェーズ中にファイルを含めます。
3	<%@ taglib ... %> ページで使用されるカスタムアクションを含むタグライブラリを宣言します

私たちは、別の章でJSPディレクティブを説明するだろうディレクティブ- JSP

JSPアクション

JSPアクションは constructsサーブレットエンジンの動作を制御するためのXML構文。ファイルを動的に挿入したり、JavaBeansコンポーネントを再利用したり、ユーザーを別のページに転送したり、JavaプラグインのHTMLを生成したりできます。

Action要素はXML標準に準拠しているため、構文は1つだけです。

<jsp:action_name attribute="value" />

アクション要素は基本的に事前定義された関数です。次の表に、使用可能なJSPアクションを示します-

S.No.	構文と目的
1	jsp:include ページが要求されたときにファイルが含まれます。
2	jsp:useBean JavaBeanを検索またはインスタンス化します。
3	jsp:setProperty JavaBeanのプロパティを設定します。
4	jsp:getProperty JavaBeanのプロパティを出力に挿入します。
5	jsp:forward リクエスターを新しいページに転送します。
6	jsp:plugin JavaプラグインのOBJECTまたはEMBEDタグを作成するブラウザ固有のコードを生成します。
7	jsp:element XML要素を動的に定義します。
8	jsp:attribute 動的に定義されたXML要素の属性を定義します。
9	jsp:body 動的に定義されたXML要素の本体を定義します。
10	jsp:text JSPページおよびドキュメントにテンプレートテキストを書き込むために使用されます。

JSPアクションについては別の章で説明しますJSP-アクション

JSP暗黙オブジェクト

JSPは、暗黙オブジェクトとも呼ばれる9つの自動定義変数をサポートします。これらの変数は−です

S.No.	オブジェクトと説明
1	request これは HttpServletRequest リクエストに関連付けられたオブジェクト。
2	response これは HttpServletResponse クライアントへの応答に関連付けられたオブジェクト。
3	out これは PrintWriter クライアントに出力を送信するために使用されるオブジェクト。
4	session これは HttpSession リクエストに関連付けられたオブジェクト。
5	application これは ServletContext アプリケーションコンテキストに関連付けられたオブジェクト。
6	config これは ServletConfig ページに関連付けられているオブジェクト。
7	pageContext これにより、パフォーマンスの向上などのサーバー固有の機能の使用がカプセル化されます JspWriters。
8	page これは単にの同義語です this、および変換されたサーブレットクラスによって定義されたメソッドを呼び出すために使用されます。
9	Exception ザ・ Exception オブジェクトを使用すると、指定されたJSPから例外データにアクセスできます。

私たちは、別の章ではJSP暗黙オブジェクトを説明するだろう暗黙オブジェクト- JSP。

制御フローステートメント

意思決定ステートメント、ループなどを含む、JSPプログラミングでJavaのすべてのAPIとビルディングブロックを使用できます。

意思決定ステートメント

ザ・ if...else ブロックは通常のスクリプトレットのように始まりますが、スクリプトレットは各行で閉じられ、スクリプトレットタグの間にHTMLテキストが含まれています。

<%! int day = 3; %> 
<html> 
   <head><title>IF...ELSE Example</title></head> 
   
   <body>
      <% if (day == 1 || day == 7) { %>
         <p> Today is weekend</p>
      <% } else { %>
         <p> Today is not weekend</p>
      <% } %>
   </body> 
</html>

上記のコードは次の結果を生成します-

Today is not weekend

今、以下を見てください switch...case を使用して少し異なって書かれたブロック out.println() およびScriptletasの内部-

<%! int day = 3; %> 
<html> 
   <head><title>SWITCH...CASE Example</title></head> 
   
   <body>
      <% 
         switch(day) {
            case 0:
               out.println("It\'s Sunday.");
               break;
            case 1:
               out.println("It\'s Monday.");
               break;
            case 2:
               out.println("It\'s Tuesday.");
               break;
            case 3:
               out.println("It\'s Wednesday.");
               break;
            case 4:
               out.println("It\'s Thursday.");
               break;
            case 5:
               out.println("It\'s Friday.");
               break;
            default:
               out.println("It's Saturday.");
         }
      %>
   </body> 
</html>

上記のコードは次の結果を生成します-

It's Wednesday.

ループステートメント

Javaでは、3つの基本的なタイプのループブロックを使用することもできます。 for, while, and do…while JSPプログラミングのブロック。

以下を見てみましょう for ループの例-

<%! int fontSize; %> 
<html> 
   <head><title>FOR LOOP Example</title></head> 
   
   <body>
      <%for ( fontSize = 1; fontSize <= 3; fontSize++){ %>
         <font color = "green" size = "<%= fontSize %>">
            JSP Tutorial
      </font><br />
      <%}%>
   </body> 
</html>

上記のコードは次の結果を生成します-

JSP Tutorial 


 JSP Tutorial 


 JSP Tutorial 

上記の例は、 while 次のようにループします-

<%! int fontSize; %> 
<html> 
   <head><title>WHILE LOOP Example</title></head> 
   
   <body>
      <%while ( fontSize <= 3){ %>
         <font color = "green" size = "<%= fontSize %>">
            JSP Tutorial
         </font><br />
         <%fontSize++;%>
      <%}%>
   </body> 
</html>

上記のコードは次の結果を生成します-

JSP Tutorial 

 JSP Tutorial 

 JSP Tutorial

JSP演算子

JSPは、Javaでサポートされているすべての論理演算子と算術演算子をサポートしています。次の表に、優先順位が最も高いすべての演算子を表の上部に表示し、優先順位が最も低い演算子を下部に表示します。

式内では、優先順位の高い演算子が最初に評価されます。

カテゴリー	オペレーター	結合性
Postfix	（）[]。（ドット演算子）	左から右へ
単項	++ ----！〜	右から左へ
乗法	* /％	左から右へ
添加剤	+-	左から右へ
シフト	>> >>> <<	左から右へ
関連した	>> = << =	左から右へ
平等	==！=	左から右へ
ビットごとのAND	＆	左から右へ
ビット単位のXOR	^	左から右へ
ビットごとのOR	|	左から右へ
論理積	&&	左から右へ
論理OR	||	左から右へ
条件付き	？：	右から左へ
割り当て	= + =-= * = / =％= >> = << =＆= ^ = | =	右から左へ
コンマ	、	左から右へ

JSPリテラル

JSP式言語は、次のリテラルを定義します-

• Boolean −真と偽

• Integer −Javaのように

• Floating point −Javaのように

• String−一重引用符と二重引用符付き。"は\"としてエスケープされ、 'は\'としてエスケープされ、\は\\としてエスケープされます。

• Null − null

この章では、JSPのディレクティブについて説明します。これらのディレクティブは、JSP処理の特定の側面を処理する方法をコンテナーに指示し、コンテナーに指示と指示を提供します。

JSPディレクティブは、サーブレットクラスの全体的な構造に影響を与えます。通常、次の形式になります-

<%@ directive attribute = "value" %>

ディレクティブには、キーと値のペアとしてリストし、コンマで区切ることができるいくつかの属性を含めることができます。

@記号とディレクティブ名の間、および最後の属性と終了％>の間のブランクはオプションです。

ディレクティブタグには3つのタイプがあります-

S.No.	指令と説明
1	<%@ page ... %> スクリプト言語、エラーページ、バッファリング要件など、ページに依存する属性を定義します。
2	<%@ include ... %> 翻訳フェーズ中にファイルを含めます。
3	<%@ taglib ... %> ページで使用されるカスタムアクションを含むタグライブラリを宣言します

JSP-ページディレクティブ

ザ・ pageディレクティブは、コンテナに指示を与えるために使用されます。これらの手順は、現在のJSPページに関連しています。ページディレクティブは、JSPページのどこにでもコーディングできます。慣例により、ページディレクティブはJSPページの上部にコーディングされます。

以下は、ページディレクティブの基本的な構文です-

<%@ page attribute = "value" %>

上記の構文に相当するXMLを次のように記述できます-

<jsp:directive.page attribute = "value" />

属性

次の表に、ページディレクティブに関連付けられている属性を示します-

S.No.	属性と目的
1	buffer 出力ストリームのバッファリングモデルを指定します。
2	autoFlush サーブレット出力バッファの動作を制御します。
3	contentType 文字エンコード方式を定義します。
4	errorPage Javaのチェックされていないランタイム例外について報告する別のJSPのURLを定義します。
5	isErrorPage このJSPページが別のJSPページのerrorPage属性で指定されたURLであるかどうかを示します。
6	extends 生成されたサーブレットが拡張する必要のあるスーパークラスを指定します。
7	import JavaインポートステートメントがJavaクラスに対して行うように、JSPで使用するパッケージまたはクラスのリストを指定します。
8	info サーブレットでアクセスできる文字列を定義します getServletInfo() 方法。
9	isThreadSafe 生成されたサーブレットのスレッドモデルを定義します。
10	language JSPページで使用されるプログラミング言語を定義します。
11	session JSPページがHTTPセッションに参加するかどうかを指定します
12	isELIgnored JSPページ内のEL式を無視するかどうかを指定します。
13	isScriptingEnabled スクリプト要素の使用を許可するかどうかを決定します。

上記のすべての属性に関連する詳細については、ページディレクティブを確認してください。

インクルードディレクティブ

ザ・ includeディレクティブは、変換フェーズ中にファイルを含めるために使用されます。このディレクティブは、変換フェーズ中に他の外部ファイルのコンテンツを現在のJSPとマージするようにコンテナに指示します。あなたはコーディングすることができますinclude JSPページの任意の場所にあるディレクティブ。

このディレクティブの一般的な使用形態は次のとおりです。

<%@ include file = "relative url" >

includeディレクティブのファイル名は、実際には相対URLです。パスが関連付けられていないファイル名を指定した場合、JSPコンパイラはファイルがJSPと同じディレクトリにあると見なします。

上記の構文に相当するXMLを次のように記述できます-

<jsp:directive.include file = "relative url" />

includeディレクティブの詳細については、Includeディレクティブを確認してください。

taglibディレクティブ

JavaServer Pages APIを使用すると、HTMLまたはXMLタグのように見えるカスタムJSPタグを定義できます。タグライブラリは、カスタム動作を実装するユーザー定義タグのセットです。

ザ・ taglib ディレクティブは、JSPページがカスタムタグのセットを使用することを宣言し、ライブラリの場所を識別し、JSPページ内のカスタムタグを識別する手段を提供します。

taglibディレクティブは、以下の構文に従います。

<%@ taglib uri="uri" prefix = "prefixOfTag" >

ここでは、 uri 属性値は、コンテナが理解できる場所に解決され、 prefix 属性は、マークアップのどのビットがカスタムアクションであるかをコンテナに通知します。

上記の構文に相当するXMLを次のように記述できます-

<jsp:directive.taglib uri = "uri" prefix = "prefixOfTag" />

taglibディレクティブの詳細については、Taglibディレクティブを確認してください。

この章では、JSPでのアクションについて説明します。これらのアクションは、XML構文の構成を使用して、サーブレットエンジンの動作を制御します。ファイルを動的に挿入したり、JavaBeansコンポーネントを再利用したり、ユーザーを別のページに転送したり、JavaプラグインのHTMLを生成したりできます。

Action要素はXML標準に準拠しているため、構文は1つだけです。

<jsp:action_name attribute = "value" />

アクション要素は基本的に事前定義された関数です。次の表に、使用可能なJSPアクションを示します-

S.No.	構文と目的
1	jsp:include ページが要求されたときにファイルが含まれます。
2	jsp:useBean JavaBeanを検索またはインスタンス化します。
3	jsp:setProperty JavaBeanのプロパティを設定します。
4	jsp:getProperty JavaBeanのプロパティを出力に挿入します。
5	jsp:forward リクエスターを新しいページに転送します。
6	jsp:plugin JavaプラグインのOBJECTまたはEMBEDタグを作成するブラウザ固有のコードを生成します。
7	jsp:element XML要素を動的に定義します。
8	jsp:attribute 動的に定義されたXML要素の属性を定義します。
9	jsp:body 動的に定義されたXML要素の本体を定義します。
10	jsp:text JSPページおよびドキュメントにテンプレートテキストを書き込むために使用されます。

共通の属性

すべてのアクション要素に共通する2つの属性があります。 id 属性と scope 属性。

Id属性

id属性はAction要素を一意に識別し、JSPページ内でアクションを参照できるようにします。アクションがオブジェクトのインスタンスを作成する場合、id値を使用して、暗黙的なオブジェクトPageContextを介してそれを参照できます。

スコープ属性

この属性は、Action要素のライフサイクルを識別します。id属性とscope属性は直接関連しています。これは、scope属性がidに関連付けられたオブジェクトの存続期間を決定するためです。scope属性には、次の4つの値があります。(a) page, (b)request, (c)session、および (d) application。

<jsp：include>アクション

このアクションにより、生成されているページにファイルを挿入できます。構文は次のようになります-

<jsp:include page = "relative URL" flush = "true" />

とは異なり include JSPページがサーブレットに変換されるときにファイルを挿入するディレクティブ。このアクションは、ページが要求されたときにファイルを挿入します。

次の表に、インクルードアクションに関連する属性を示します-

S.No.	属性と説明
1	page 含まれるページの相対URL。
2	flush boolean属性は、インクルードされたリソースがインクルードされる前にバッファーがフラッシュされるかどうかを決定します。

例

次の2つのファイルを定義しましょう (a)date.jsp そして (b) main.jsp 次のように-

以下は、の内容です date.jsp ファイル-

<p>Today's date: <%= (new java.util.Date()).toLocaleString()%></p>

以下は、の内容です main.jsp ファイル-

<html>
   <head>
      <title>The include Action Example</title>
   </head>
   
   <body>
      <center>
         <h2>The include action Example</h2>
         <jsp:include page = "date.jsp" flush = "true" />
      </center>
   </body>
</html>

これらすべてのファイルをルートディレクトリに保存して、アクセスしてみましょう。 main.jsp。次の出力が表示されます-

 
       
The include action Example
 Today's date: 12-Sep-2010 14:54:22 
      

<jsp：useBean>アクション

ザ・ useBeanアクションは非常に用途が広いです。まず、id変数とscope変数を使用して既存のオブジェクトを検索します。オブジェクトが見つからない場合は、指定されたオブジェクトの作成を試みます。

Beanをロードする最も簡単な方法は次のとおりです-

<jsp:useBean id = "name" class = "package.class" />

Beanクラスがロードされると、次を使用できます。 jsp:setProperty そして jsp:getProperty Beanプロパティを変更および取得するアクション。

次の表に、useBeanアクションに関連付けられている属性を示します-

S.No.	属性と説明
1	class Beanの完全なパッケージ名を指定します。
2	type オブジェクトを参照する変数のタイプを指定します。
3	beanName java.beans.Beansクラスのinstantiate（）メソッドで指定されたBeanの名前を指定します。

それでは、 jsp:setProperty そしてその jsp:getProperty これらのアクションに関連する有効な例を示す前に、アクション。

<jsp：setProperty>アクション

ザ・ setPropertyアクションはBeanのプロパティを設定します。Beanは、このアクションの前に事前に定義されている必要があります。setPropertyアクションを使用する2つの基本的な方法があります-

使用できます jsp:setProperty 後、しかし外 jsp:useBean 以下に示す要素-

<jsp:useBean id = "myName" ... />
...
<jsp:setProperty name = "myName" property = "someProperty" .../>

この場合、 jsp:setProperty 新しいBeanがインスタンス化されたか、既存のBeanが見つかったかに関係なく、が実行されます。

jsp：setPropertyが表示される2番目のコンテキストは、 jsp:useBean 以下に示す要素-

<jsp:useBean id = "myName" ... >
   ...
   <jsp:setProperty name = "myName" property = "someProperty" .../>
</jsp:useBean>

ここで、jsp：setPropertyは、既存のオブジェクトが見つかった場合ではなく、新しいオブジェクトがインスタンス化された場合にのみ実行されます。

次の表に、に関連付けられている属性を示します。 setProperty アクション-

S.No.	属性と説明
1	name プロパティが設定されるBeanを指定します。Beanは事前に定義されている必要があります。
2	property 設定するプロパティを示します。「*」の値は、名前がBeanプロパティ名と一致するすべてのリクエストパラメータが適切なセッターメソッドに渡されることを意味します。
3	value 指定されたプロパティに割り当てられる値。パラメータの値がnullであるか、パラメータが存在しない場合、setPropertyアクションは無視されます。
4	param param属性は、プロパティが受け取る値を持つ要求パラメーターの名前です。valueとparamの両方を使用することはできませんが、どちらも使用することはできません。

<jsp：getProperty>アクション

ザ・ getProperty actionは、指定されたプロパティの値を取得して文字列に変換し、最後にそれを出力に挿入するために使用されます。

getPropertyアクションには2つの属性しかなく、どちらも必須です。getPropertyアクションの構文は次のとおりです-

<jsp:useBean id = "myName" ... />
...
<jsp:getProperty name = "myName" property = "someProperty" .../>

次の表に、に関連付けられている必要な属性を示します。 getProperty アクション-

S.No.	属性と説明
1	name 取得するプロパティを持つBeanの名前。Beanは事前に定義されている必要があります。
2	property property属性は、取得するBeanプロパティの名前です。

例

この例でさらに使用されるテストBeanを定義しましょう-

/* File: TestBean.java */
package action;
 
public class TestBean {
   private String message = "No message specified";
 
   public String getMessage() {
      return(message);
   }
   public void setMessage(String message) {
      this.message = message;
   }
}

上記のコードを生成されたものにコンパイルします TestBean.class ファイルを作成し、TestBean.classをにコピーしたことを確認してください C:\apache-tomcat-7.0.2\webapps\WEB-INF\classes\action フォルダと CLASSPATH 変数もこのフォルダに設定する必要があります-

次に、次のコードを使用します main.jspファイル。これにより、Beanがロードされ、単純な文字列パラメータが設定/取得されます-

<html>
   
   <head>
      <title>Using JavaBeans in JSP</title>
   </head>
   
   <body>
      <center>
         <h2>Using JavaBeans in JSP</h2>
         <jsp:useBean id = "test" class = "action.TestBean" />
         <jsp:setProperty name = "test"  property = "message" 
            value = "Hello JSP..." />
            
         <p>Got message....</p>
         <jsp:getProperty name = "test" property = "message" />
      </center>
   </body>
</html>

アクセスしてみましょう main.jsp、次の結果が表示されます-

 
       
Using JavaBeans in JSP
 Got message.... Hello JSP... 
      

<jsp：forward>アクション

ザ・ forward actionは、現在のページのアクションを終了し、静的ページ、別のJSPページ、Javaサーブレットなどの別のリソースにリクエストを転送します。

以下は、の構文です。 forward アクション-

<jsp:forward page = "Relative URL" />

次の表に、転送アクションに関連する必要な属性を示します。

S.No.	属性と説明
1	page 静的ページ、別のJSPページ、Javaサーブレットなどの別のリソースの相対URLで構成する必要があります。

例

次の2つのファイルを再利用しましょう (a) date.jsp そして (b) main.jsp 次のように-

以下は、の内容です date.jsp ファイル-

<p>Today's date: <%= (new java.util.Date()).toLocaleString()%></p>

以下は、の内容です main.jsp ファイル-

<html>
   <head>
      <title>The include Action Example</title>
   </head>
   
   <body>
      <center>
         <h2>The include action Example</h2>
         <jsp:forward page = "date.jsp" />
      </center>
   </body>
</html>

これらすべてのファイルをルートディレクトリに保存して、アクセスしてみましょう。 main.jsp。これにより、次のような結果が表示されます。

ここでは、メインページのコンテンツを破棄し、転送されたページのコンテンツのみを表示しました。

        Today's date: 12-Sep-2010 14:54:22 
      

<jsp：plugin>アクション

ザ・ pluginアクションは、JavaコンポーネントをJSPページに挿入するために使用されます。ブラウザの種類を判別し、<object> または <embed> 必要に応じてタグを付けます。

必要なプラグインが存在しない場合は、プラグインをダウンロードしてからJavaコンポーネントを実行します。Javaコンポーネントは、アプレットまたはJavaBeanのいずれかです。

プラグインアクションには、Javaコンポーネントのフォーマットに使用される一般的なHTMLタグに対応するいくつかの属性があります。ザ・<param> 要素を使用して、アプレットまたはBeanにパラメータを送信することもできます。

以下は、プラグインアクションを使用する典型的な構文です-

<jsp:plugin type = "applet" codebase = "dirname" code = "MyApplet.class"
   width = "60" height = "80">
   <jsp:param name = "fontcolor" value = "red" />
   <jsp:param name = "background" value = "black" />
 
   <jsp:fallback>
      Unable to initialize Java Plugin
   </jsp:fallback>
 
</jsp:plugin>

興味がある場合は、アプレットを使用してこのアクションを試すことができます。新しい要素、<fallback> 要素は、コンポーネントに障害が発生した場合にユーザーに送信されるエラー文字列を指定するために使用できます。

The <jsp:element> Action
The <jsp:attribute> Action
The <jsp:body> Action

ザ・ <jsp:element>, <jsp:attribute> そして <jsp:body>アクションは、XML要素を動的に定義するために使用されます。XML要素はコンパイル時に静的に生成されるのではなく、要求時に生成される可能性があるため、動的という言葉は重要です。

以下は、XML要素を動的に定義する簡単な例です。

<%@page language = "java" contentType = "text/html"%>
<html xmlns = "http://www.w3c.org/1999/xhtml"
   xmlns:jsp = "http://java.sun.com/JSP/Page">
   
   <head><title>Generate XML Element</title></head>
   
   <body>
      <jsp:element name = "xmlElement">
         <jsp:attribute name = "xmlElementAttr">
            Value for the attribute
         </jsp:attribute>
         
         <jsp:body>
            Body for XML element
         </jsp:body>
      
      </jsp:element>
   </body>
</html>

これにより、実行時に次のHTMLコードが生成されます-

<html xmlns = "http://www.w3c.org/1999/xhtml" xmlns:jsp = "http://java.sun.com/JSP/Page">
   <head><title>Generate XML Element</title></head>
   
   <body>
      <xmlElement xmlElementAttr = "Value for the attribute">
         Body for XML element
      </xmlElement>
   </body>
</html>

<jsp：text>アクション

ザ・ <jsp:text>アクションを使用して、JSPページおよびドキュメントにテンプレートテキストを書き込むことができます。以下は、このアクションの簡単な構文です-

<jsp:text>Template data</jsp:text>

テンプレートの本体に他の要素を含めることはできません。テキストとEL式のみを含めることができます（注-EL式については次の章で説明します）。XMLファイルでは、次のような式は使用できないことに注意してください。${whatever > 0}、大なり記号は違法であるため。代わりに、gt などのフォーム ${whatever gt 0} または別の方法は、値をに埋め込むことです CDATA セクション。

<jsp:text><![CDATA[<br>]]></jsp:text>

含める必要がある場合 DOCTYPE 宣言、例えば XHTML、も使用する必要があります <jsp:text> 次のような要素-

<jsp:text><![CDATA[<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
   "DTD/xhtml1-strict.dtd">]]></jsp:text>

   <head><title>jsp:text action</title></head>
   
   <body>
      <books><book><jsp:text>  
         Welcome to JSP Programming
      </jsp:text></book></books>
   </body>
</html>

上記の例を試してみてください <jsp:text> アクション。

この章では、JSPの暗黙オブジェクトについて説明します。これらのオブジェクトは、JSPコンテナが各ページで開発者に提供するJavaオブジェクトであり、開発者は明示的に宣言せずに直接呼び出すことができます。JSP暗黙オブジェクトは、pre-defined variables。

次の表に、JSPがサポートする9つの暗黙的なオブジェクトを示します。

S.No.	オブジェクトと説明
1	request これは HttpServletRequest リクエストに関連付けられたオブジェクト。
2	response これは HttpServletResponse クライアントへの応答に関連付けられたオブジェクト。
3	out これは PrintWriter クライアントに出力を送信するために使用されるオブジェクト。
4	session これは HttpSession リクエストに関連付けられたオブジェクト。
5	application これは ServletContext アプリケーションコンテキストに関連付けられたオブジェクト。
6	config これは ServletConfig ページに関連付けられているオブジェクト。
7	pageContext これにより、パフォーマンスの向上などのサーバー固有の機能の使用がカプセル化されます JspWriters。
8	page これは単にの同義語です this、および変換されたサーブレットクラスによって定義されたメソッドを呼び出すために使用されます。
9	Exception ザ・ Exception オブジェクトを使用すると、指定されたJSPから例外データにアクセスできます。

リクエストオブジェクト

リクエストオブジェクトは、 javax.servlet.http.HttpServletRequestオブジェクト。クライアントがページを要求するたびに、JSPエンジンはその要求を表す新しいオブジェクトを作成します。

リクエストオブジェクトは、フォームデータ、Cookie、HTTPメソッドなどを含むHTTPヘッダー情報を取得するためのメソッドを提供します。

リクエストオブジェクトに関連付けられたメソッドの完全なセットについては、次の章-JSP-クライアントリクエストで説明します。

応答オブジェクト

応答オブジェクトは、 javax.servlet.http.HttpServletResponseオブジェクト。サーバーが要求オブジェクトを作成するのと同じように、サーバーはクライアントへの応答を表すオブジェクトも作成します。

応答オブジェクトは、新しいHTTPヘッダーの作成を処理するインターフェースも定義します。このオブジェクトを介して、JSPプログラマーは新しいCookieまたは日付スタンプ、HTTPステータスコードなどを追加できます。

次の章-JSP-サーバー応答で、応答オブジェクトに関連付けられたメソッドの完全なセットについて説明します。

アウトオブジェクト

out暗黙オブジェクトはのインスタンスです javax.servlet.jsp.JspWriter オブジェクトであり、応答でコンテンツを送信するために使用されます。

最初のJspWriterオブジェクトは、ページがバッファリングされているかどうかに応じて異なる方法でインスタンス化されます。バッファリングは、を使用して簡単にオフにすることができますbuffered = 'false' ページディレクティブの属性。

JspWriterオブジェクトには、 java.io.PrintWriterクラス。ただし、JspWriterには、バッファリングを処理するように設計された追加のメソッドがいくつかあります。PrintWriterオブジェクトとは異なり、JspWriterはスローしますIOExceptions。

次の表に、作成に使用する重要なメソッドを示します。 boolean char, int, double, object, String、など。

S.No.	方法と説明
1	out.print(dataType dt) データ型の値を出力します
2	out.println(dataType dt) データ型の値を出力してから、改行文字で行を終了します。
3	out.flush() ストリームをフラッシュします。

セッションオブジェクト

セッションオブジェクトはのインスタンスです javax.servlet.http.HttpSession また、セッションオブジェクトがJavaサーブレットで動作するのとまったく同じように動作します。

セッションオブジェクトは、クライアント要求間のクライアントセッションを追跡するために使用されます。セッションオブジェクトの完全な使用法については、次の章-JSP-セッショントラッキングで説明します。

アプリケーションオブジェクト

アプリケーションオブジェクトは、 ServletContext 生成されたサーブレットのオブジェクトであり、実際には javax.servlet.ServletContext オブジェクト。

このオブジェクトは、ライフサイクル全体にわたるJSPページの表現です。このオブジェクトは、JSPページが初期化されるときに作成され、JSPページがによって削除されると削除されます。jspDestroy() 方法。

アプリケーションに属性を追加することにより、Webアプリケーションを構成するすべてのJSPファイルがその属性にアクセスできるようにすることができます。

JSPでのアプリケーションオブジェクトの使用を確認します-ヒットカウンターの章。

構成オブジェクト

構成オブジェクトはのインスタンス化です javax.servlet.ServletConfig との直接ラッパーです ServletConfig 生成されたサーブレットのオブジェクト。

このオブジェクトにより、JSPプログラマは、パスやファイルの場所などのサーブレットまたはJSPエンジンの初期化パラメータにアクセスできます。

以下 config メソッドはあなたが今までに使用するかもしれない唯一のものであり、その使用法は些細なものです-

config.getServletName();

これにより、サーブレット名が返されます。これは、サーブレットに含まれる文字列です。 <servlet-name> で定義された要素 WEB-INF\web.xml ファイル。

pageContextオブジェクト

pageContextオブジェクトは、 javax.servlet.jsp.PageContextオブジェクト。pageContextオブジェクトは、JSPページ全体を表すために使用されます。

このオブジェクトは、実装の詳細のほとんどを回避しながら、ページに関する情報にアクセスする手段として意図されています。

このオブジェクトは、各リクエストのリクエストオブジェクトとレスポンスオブジェクトへの参照を格納します。ザ・application, config, session、およびoutオブジェクトは、このオブジェクトの属性にアクセスすることによって派生します。

pageContextオブジェクトには、バッファリング情報、errorPageURL、ページスコープなど、JSPページに発行されたディレクティブに関する情報も含まれています。

PageContextクラスは、次のようないくつかのフィールドを定義します。 PAGE_SCOPE, REQUEST_SCOPE, SESSION_SCOPE, そして APPLICATION_SCOPE、4つのスコープを識別します。また、40を超えるメソッドをサポートしており、その約半分はjavax.servlet.jsp.JspContext class。

重要な方法の1つは removeAttribute。このメソッドは、1つまたは2つの引数を受け入れます。例えば、pageContext.removeAttribute ("attrName") 次のコードはページスコープからのみ属性を削除しますが、すべてのスコープから属性を削除します-

pageContext.removeAttribute("attrName", PAGE_SCOPE);

pageContextの使用は、JSP-ファイルアップロードの章で確認できます。

ページオブジェクト

このオブジェクトは、ページのインスタンスへの実際の参照です。これは、JSPページ全体を表すオブジェクトと考えることができます。

ページオブジェクトは、実際にはの直接の同義語です。 this オブジェクト。

例外オブジェクト

例外オブジェクトは、前のページからスローされた例外を含むラッパーです。これは通常、エラー状態に対する適切な応答を生成するために使用されます。

このオブジェクトの完全な使用法については、JSP-例外処理の章で説明します。

この章では、JSPでのクライアントリクエストについて説明します。ブラウザがWebページを要求すると、Webサーバーに多くの情報が送信されます。この情報はHTTPリクエストのヘッダーの一部として送信されるため、この情報を直接読み取ることはできません。詳細については、HTTPプロトコルを確認してください。

次の表に、ブラウザからの重要なヘッダー情報を示します。この情報は、Webプログラミングで頻繁に使用されます-

S.No.	ヘッダーと説明
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がRefererヘッダーに含まれます。
13	User-Agent このヘッダーは、リクエストを行っているブラウザまたは他のクライアントを識別し、さまざまなコンテンツをさまざまなタイプのブラウザに返すために使用できます。

HttpServletRequestオブジェクト

リクエストオブジェクトは、 javax.servlet.http.HttpServletRequestオブジェクト。クライアントがページを要求するたびに、JSPエンジンはその要求を表す新しいオブジェクトを作成します。

リクエストオブジェクトは、HTTPヘッダー情報を取得するためのメソッドを提供します。 form data, cookies, HTTP methods、など。

次の表に、JSPプログラムでHTTPヘッダーを読み取るために使用できる重要なメソッドを示します。これらのメソッドは、Webサーバーへのクライアント要求を表すHttpServletRequestオブジェクトで使用できます。

S.No.	方法と説明
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() の方法 HttpServletRequestHTTPヘッダー情報を読み取ります。このメソッドは、現在のHTTPリクエストに関連付けられたヘッダー情報を含む列挙型を返します。

列挙型を取得したら、標準的な方法で列挙型をループダウンできます。を使用しますhasMoreElements() いつ停止するかを決定する方法と nextElement() 各パラメータ名の名前を取得するメソッド。

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>HTTP Header Request Example</title>
   </head>

   <body>
      <center>
         <h2>HTTP Header Request Example</h2>
         
         <table width = "100%" border = "1" align = "center">
            <tr bgcolor = "#949494">
               <th>Header Name</th>
               <th>Header Value(s)</th>
            </tr>
            <%
               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");
               }
            %>
         </table>
      </center>
   
   </body>
</html>

上記のコードを入れましょう main.jsp それにアクセスしてみてください。

HTTPヘッダーリクエストの例

ヘッダー名	ヘッダー値
受け入れる	* / *
受け入れる言語	en-us
ユーザーエージェント	Mozilla / 4.0（互換性; MSIE 7.0; Windows NT 5.1; Trident / 4.0; InfoPath.2; MS-RTC LM 8）
accept-encoding	gzip、deflate
ホスト	localhost：8080
接続	生き続ける
キャッシュ制御	キャッシュなし

同様の方法ですべてのメソッドに取り組むことができます。

この章では、JSPでのサーバー応答について説明します。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 in the example)、ステータスコード (200 in the example)、およびステータスコードに対応する非常に短いメッセージ (OK in the example)。

以下は、Webサーバーからブラウザーに戻る最も有用なHTTP1.1応答ヘッダーの要約です。これらのヘッダーは、Webプログラミングで頻繁に使用されます-

S.No.	ヘッダーと説明
1	Allow このヘッダーはリクエストメソッドを指定します（GET, POST、など）サーバーがサポートします。
2	Cache-Control このヘッダーは、応答ドキュメントを安全にキャッシュできる状況を指定します。それは値を持つことができますpublic, private または no-cache パブリックはドキュメントがキャッシュ可能であることを意味し、プライベートはドキュメントがシングルユーザー向けであり、プライベート（非共有）キャッシュにのみ保存できることを意味し、キャッシュなしはドキュメントがキャッシュされないことを意味します。
3	Connection このヘッダーは、永続的なHTTP接続を使用するかどうかをブラウザーに指示します。の値close 永続的なHTTP接続を使用しないようにブラウザに指示し、 keep-alive 持続的接続を使用することを意味します。
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を指定します。

HttpServletResponseオブジェクト

応答オブジェクトは、 javax.servlet.http.HttpServletResponse object。サーバーが要求オブジェクトを作成するのと同じように、サーバーはクライアントへの応答を表すオブジェクトも作成します。

応答オブジェクトは、新しいHTTPヘッダーの作成を処理するインターフェースも定義します。このオブジェクトを介して、JSPプログラマーは新しいCookieまたは日付スタンプ、HTTPステータスコードなどを追加できます。

次のメソッドを使用して、サーブレットプログラムにHTTP応答ヘッダーを設定できます。これらのメソッドは、HttpServletResponseオブジェクトで使用できます。このオブジェクトはサーバーの応答を表します。

S.No.	方法と説明
1	String encodeRedirectURL(String url) で使用するために指定されたURLをエンコードします sendRedirect メソッド、またはエンコードが不要な場合は、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ヘッダー応答の例

次の例では、 setIntHeader() 設定する方法 Refresh デジタル時計をシミュレートするヘッダー-

<%@ page import = "java.io.*,java.util.*" %>

<html>
   
   <head>
      <title>Auto Refresh Header Example</title>
   </head>
   
   <body>
      <center>
         <h2>Auto Refresh Header Example</h2>
         <%
            // Set refresh, autoload time as 5 seconds
            response.setIntHeader("Refresh", 5);
            
            // 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;
               out.println("Current Time is: " + CT + "\n");
         %>
      </center>
   
   </body>
</html>

次に、上記のコードを main.jspそれにアクセスしてみてください。これにより、次のように5秒ごとに現在のシステム時刻が表示されます。JSPを実行します。次の出力が表示されます。

 
       
Auto Refresh Header Example
 Current Time is: 9:44:50 PM 
      

同様の方法で他の方法を試すことができます。

この章では、JSPのHttpステータスコードについて説明します。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 version (HTTP/1.1 in the example)、ステータスコード（例では200）、およびステータスコードに対応する非常に短いメッセージ (OK in the example)。

次の表に、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 protocol" バージョン。

HTTPステータスコードを設定する方法

次の方法を使用して、サーブレットプログラムでHTTPステータスコードを設定できます。これらのメソッドは、HttpServletResponseオブジェクトで使用できます。

S.No.	方法と説明
1	public void setStatus ( int statusCode ) このメソッドは、任意のステータスコードを設定します。setStatusメソッドは、引数としてint（ステータスコード）を取ります。返信に特別なステータスコードとドキュメントが含まれている場合は、必ず電話してくださいsetStatusPrintWriterでコンテンツを実際に返す前。
2	public void sendRedirect(String url) このメソッドは、新しいドキュメントのURLを示すLocationヘッダーとともに302応答を生成します。
3	public void sendError(int code, String message) このメソッドは、ステータスコード（通常は404）を、HTMLドキュメント内で自動的にフォーマットされてクライアントに送信される短いメッセージとともに送信します。

HTTPステータスコードの例

次の例は、407エラーコードがクライアントブラウザに送信される方法を示しています。この後、ブラウザはあなたに「Need authentication!!!「メッセージ。

<html>
   <head>
      <title>Setting HTTP Status Code</title>
   </head>
   
   <body>
      <%
         // Set error code and reason.
         response.sendError(407, "Need authentication!!!" );
      %>
   </body>
</html>

次の出力が表示されます-

HTTP Status 407 - Need authentication!!!
type Status report
message Need authentication!!!
description The client must first authenticate itself with the proxy (Need authentication!!!).
Apache Tomcat/5.5.29

HTTPステータスコードをより快適に使用するには、さまざまなステータスコードとその説明を設定してみてください。

この章では、JSPでのフォーム処理について説明します。ブラウザからWebサーバーに、そして最終的にはバックエンドプログラムに情報を渡す必要がある場合、多くの状況に遭遇したに違いありません。ブラウザは2つの方法を使用して、この情報をWebサーバーに渡します。これらのメソッドは、GETメソッドとPOSTメソッドです。

フォーム処理の方法

ここで、フォーム処理の方法について説明します。

GETメソッド

GETメソッドは、ページリクエストに追加されたエンコードされたユーザー情報を送信します。ページとエンコードされた情報は？で区切られます 次のような文字-

http://www.test.com/hello?key1=value1&key2=value2

GETメソッドは、ブラウザからWebサーバーに情報を渡すためのデフォルトのメソッドであり、ブラウザのに表示される長い文字列を生成します。 Location:box。GETメソッドは使用しないことをお勧めします。サーバーに渡すパスワードまたはその他の機密情報がある場合。

GETメソッドにはサイズ制限があります。 only 1024 characters can be in a request string。

この情報はを使用して渡されます QUERY_STRING header を使用して処理できるQUERY_STRING環境変数を介してアクセスできます getQueryString() そして getParameter() リクエストオブジェクトのメソッド。

POSTメソッド

バックエンドプログラムに情報を渡す一般的により信頼性の高い方法は、POST方法です。

このメソッドは、GETメソッドとまったく同じ方法で情報をパッケージ化しますが、？の後にテキスト文字列として送信するのではありません。URLでは、別のメッセージとして送信します。このメッセージは、解析して処理に使用できる標準入力の形式でバックエンドプログラムに送信されます。

JSPは、このタイプのリクエストを使用して処理します getParameter() 単純なパラメータを読み取る方法と getInputStream() クライアントからのバイナリデータストリームを読み取るメソッド。

JSPを使用したフォームデータの読み取り

JSPは、状況に応じて次の方法を使用してフォームデータの解析を自動的に処理します-

• getParameter() −あなたは電話します request.getParameter() フォームパラメータの値を取得するメソッド。

• getParameterValues() −パラメータが複数回表示され、チェックボックスなどの複数の値を返す場合は、このメソッドを呼び出します。

• getParameterNames() −現在のリクエストのすべてのパラメータの完全なリストが必要な場合は、このメソッドを呼び出します。

• getInputStream() −このメソッドを呼び出して、クライアントからのバイナリデータストリームを読み取ります。

URLを使用したGETメソッドの例

次のURLは、GETメソッドを使用してHelloFormプログラムに2つの値を渡します。

http://localhost:8080/main.jsp?first_name=ZARA&last_name=ALI

以下は main.jspWebブラウザからの入力を処理するJSPプログラム。を使用しますgetParameter() 渡された情報に非常に簡単にアクセスできる方法-

<html>
   <head>
      <title>Using GET Method to Read Form Data</title>
   </head>
   
   <body>
      <h1>Using GET Method to Read Form Data</h1>
      <ul>
         <li><p><b>First Name:</b>
            <%= request.getParameter("first_name")%>
         </p></li>
         <li><p><b>Last  Name:</b>
            <%= request.getParameter("last_name")%>
         </p></li>
      </ul>
   
   </body>
</html>

今タイプ http://localhost:8080/main.jsp?first_name=ZARA&last_name=ALI お使いのブラウザで Location:box。これにより、次の結果が生成されます-

GETメソッドを使用したフォームデータの読み取り First Name：ZARA Last Name：ALI

フォームを使用したGETメソッドの例

以下は、HTMLFORMと送信ボタンを使用して2つの値を渡す例です。同じJSPmain.jspを使用してこの入力を処理します。

<html>
   <body>
      
      <form action = "main.jsp" 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-installation-directory>/webapps/ROOT directory。アクセスするときhttp://localhost:8080/Hello.htm、次の出力が表示されます。

フォームを使用したPOSTメソッドの例

上記のJSPを少し変更して、GETメソッドとPOSTメソッドの両方を処理してみましょう。以下はmain.jsp GETまたはPOSTメソッドを使用してWebブラウザから指定された入力を処理するJSPプログラム。

実際、パラメータを渡す唯一の方法が変更され、バイナリデータがJSPプログラムに渡されていないため、上記のJSPに変更はありません。ファイル処理に関連する概念については、バイナリデータストリームを読み取る必要がある別の章で説明します。

<html>
   <head>
      <title>Using GET and POST Method to Read Form Data</title>
   </head>
   
   <body>
      <center>
      <h1>Using POST Method to Read Form Data</h1>
      
      <ul>
         <li><p><b>First Name:</b>
            <%= request.getParameter("first_name")%>
         </p></li>
         <li><p><b>Last  Name:</b>
            <%= request.getParameter("last_name")%>
         </p></li>
      </ul>
   
   </body>
</html>

以下は、の内容です Hello.htm ファイル-

<html>
   <body>
      
      <form action = "main.jsp" 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>

続けましょう main.jsp およびhello.htm <Tomcat-installationdirectory>/webapps/ROOT directory。アクセスするときhttp://localhost:8080/Hello.htm、次の出力が表示されます。

姓名を入力してから[送信]ボタンをクリックして、Tomcatが実行されているローカルマシンで結果を確認してください。

提供された入力に基づいて、上記の例と同様の結果が得られます。

チェックボックスデータをJSPプログラムに渡す

チェックボックスは、複数のオプションを選択する必要がある場合に使用されます。

以下は例です HTML code, CheckBox.htm、2つのチェックボックスがあるフォームの場合。

<html>
   <body>
      
      <form action = "main.jsp" 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ブラウザからの入力を処理するmain.jspJSPプログラムです。

<html>
   <head>
      <title>Reading Checkbox Data</title>
   </head>
   
   <body>
      <h1>Reading Checkbox Data</h1>
      
      <ul>
         <li><p><b>Maths Flag:</b>
            <%= request.getParameter("maths")%>
         </p></li>
         <li><p><b>Physics Flag:</b>
            <%= request.getParameter("physics")%>
         </p></li>
         <li><p><b>Chemistry Flag:</b>
            <%= request.getParameter("chemistry")%>
         </p></li>
      </ul>
   
   </body>
</html>

上記のプログラムは次の結果を生成します-

Reading Checkbox Data

      
 
       
Maths Flag :: on
 
       
Physics Flag:: null
 
       
Chemistry Flag:: on
 
      

すべてのフォームパラメータの読み取り

以下は、を使用する一般的な例です。 getParameterNames()使用可能なすべてのフォームパラメータを読み取るHttpServletRequestのメソッド。このメソッドは、指定されていない順序でパラメーター名を含む列挙型を返します。

列挙型を取得したら、標準的な方法で列挙型をループダウンできます。 hasMoreElements() いつ停止するかを決定する方法と nextElement() 各パラメータ名を取得するメソッド。

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>HTTP Header Request Example</title>
   </head>

   <body>
      <center>
         <h2>HTTP Header Request Example</h2>
         <table width = "100%" border = "1" align = "center">
            <tr bgcolor = "#949494">
               <th>Param Name</th>
               <th>Param Value(s)</th>
            </tr>
            <%
               Enumeration paramNames = request.getParameterNames();
               while(paramNames.hasMoreElements()) {
                  String paramName = (String)paramNames.nextElement();
                  out.print("<tr><td>" + paramName + "</td>\n");
                  String paramValue = request.getHeader(paramName);
                  out.println("<td> " + paramValue + "</td></tr>\n");
               }
            %>
         </table>
      </center>
   
   </body>
</html>

以下は、の内容です Hello.htm −

<html>
   <body>
      
      <form action = "main.jsp" 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>

次に、上記のHello.htmを使用してJSPを呼び出してみてください。これにより、提供された入力に基づいて、次のような結果が生成されます。

すべてのフォームパラメータの読み取り

パラメータ名	パラメータ値
数学	オン
化学	オン

上記のJSPを試して、テキストボックス、ラジオボタン、ドロップダウンなどの他のオブジェクトを含む他のフォームのデータを読み取ることができます。

この章では、JSPのフィルタについて説明します。サーブレットおよびJSPフィルタは、次の目的でサーブレットおよびJSPプログラミングで使用できるJavaクラスです。

• クライアントがバックエンドでリソースにアクセスする前に、クライアントからの要求をインターセプトするため。

• クライアントに返送される前にサーバーからの応答を操作するため。

仕様で提案されているフィルターにはさまざまな種類があります-

• 認証フィルター
• データ圧縮フィルター
• 暗号化フィルター
• リソースアクセスイベントをトリガーするフィルター
• 画像変換フィルター
• ロギングおよび監査フィルター
• MIME-TYPEチェーンフィルター
• トークン化フィルター
• XMLコンテンツを変換するXSL / Tフィルター

フィルタはデプロイメント記述子ファイルにデプロイされます web.xml次に、アプリケーションのデプロイメント記述子のサーブレットまたはJSP名またはURLパターンのいずれかにマップします。デプロイメント記述子ファイルweb.xmlは、<Tomcat-installation-directory> \ confディレクトリにあります。

JSPコンテナがWebアプリケーションを起動すると、デプロイメント記述子で宣言した各フィルタのインスタンスが作成されます。フィルタは、デプロイメント記述子で宣言されている順序で実行されます。

サーブレットフィルタメソッド

フィルタは、を実装する単なるJavaクラスです。 javax.servlet.Filterインターフェース。javax.servlet.Filterインターフェースは、3つのメソッドを定義します-

S.No.	方法と説明
1	public void doFilter (ServletRequest, ServletResponse, FilterChain) このメソッドは、チェーンの最後にあるリソースに対するクライアントの要求により、要求/応答のペアがチェーンを通過するたびにコンテナーによって呼び出されます。
2	public void init(FilterConfig filterConfig) このメソッドは、Webコンテナーによって呼び出され、サービスが開始されていることをフィルターに示します。
3	public void destroy() このメソッドは、サービスが停止されていることをフィルターに示すためにWebコンテナーによって呼び出されます。

JSPフィルターの例

次の例は、クライアントがJSPファイルにアクセスするたびに、クライアントのIPアドレスと現在の日時を出力する方法を示しています。この例では、JSPフィルターの基本を理解できますが、同じ概念を使用して、より高度なフィルターアプリケーションを作成できます。

// 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 通常の方法であなたの LogFilter.class ファイルに <Tomcat-installation-directory>/webapps/ROOT/WEB-INF/classes。

Web.xmlでのJSPフィルターマッピング

フィルタは、サーブレットが定義されてからURLパターンにマップされるのとほぼ同じ方法で、定義されてからURLまたはJSPファイル名にマップされます。 web.xmlファイル。デプロイメント記述子ファイルにフィルタータグの次のエントリを作成します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>

上記のフィルタは、指定したため、すべてのサーブレットとJSPに適用されます。 /*私たちの構成で。少数のサーブレットまたはJSPのみにフィルタを適用する場合は、特定のサーブレットまたはJSPパスを指定できます。

次に、サーブレットまたはJSPを呼び出そうとすると、生成されたログがWebサーバーログに表示されます。使用できますLog4J logger 上記のログを別のファイルに記録します。

複数のフィルターの使用

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コンテナーがサーブレットまたはJSPにフィルターを適用する順序が決まります。フィルタの順序を逆にするには、でフィルタマッピング要素を逆にする必要があります。web.xml ファイル。

たとえば、上記の例では、最初にLogFilterを適用してから、任意のサーブレットまたはJSPに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>

この章では、JSPでのCookieの処理について説明します。クッキーはクライアントコンピュータに保存されるテキストファイルであり、さまざまな情報追跡の目的で保持されます。JSPは、基盤となるサーブレットテクノロジを使用してHTTPCookieを透過的にサポートします。

ユーザーの特定とリピーターには3つのステップがあります-

• サーバースクリプトは、一連のCookieをブラウザに送信します。たとえば、名前、年齢、識別番号などです。

• ブラウザは、将来使用するためにこの情報をローカルマシンに保存します。

• 次回ブラウザがWebサーバーに要求を送信すると、ブラウザはそれらのCookie情報をサーバーに送信し、サーバーはその情報を使用してユーザーを識別します。

この章では、Cookieを設定またはリセットする方法、Cookieにアクセスする方法、およびJSPプログラムを使用してCookieを削除する方法について説明します。

クッキーの構造

通常、CookieはHTTPヘッダーに設定されます（ただし、JavaScriptはブラウザーに直接Cookieを設定することもできます）。Cookieを設定するJSPは、次のようなヘッダーを送信する可能性があります-

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 header 含まれています a name value pair, a GMT date, a path そして a domain。名前と値はURLエンコードされます。ザ・expires フィールドはブラウザへの指示です "forget" 指定された日時の後の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

その後、JSPスクリプトはrequestメソッドを介してCookieにアクセスできるようになります request.getCookies()これはCookieオブジェクトの配列を返します。

サーブレットCookieメソッド

次の表に、JSPでCookieを操作するときに使用できるCookieオブジェクトに関連付けられた便利なメソッドを示します。

S.No.	方法と説明
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を返します。

JSPを使用したCookieの設定

JSPを使用したCookieの設定には、3つのステップが含まれます-

ステップ1：Cookieオブジェクトを作成する

どちらも文字列であるCookie名とCookie値を使用してCookieコンストラクターを呼び出します。

Cookie cookie = new Cookie("key","value");

名前にも値にも空白や次の文字を含めることはできません。

[ ] ( ) = , " / ? @ : ;

ステップ2：最大年齢を設定する

あなたが使う setMaxAgeCookieが有効である期間（秒単位）を指定します。次のコードは、24時間Cookieを設定します。

cookie.setMaxAge(60*60*24);

ステップ3：HTTP応答ヘッダーにCookieを送信する

あなたが使う response.addCookie 次のようにHTTP応答ヘッダーにCookieを追加します

response.addCookie(cookie);

例

フォームの例を変更して、姓名のCookieを設定しましょう。

<%
   // 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 );
%>

<html>
   <head>
      <title>Setting Cookies</title>
   </head>
   
   <body>
      <center>
         <h1>Setting Cookies</h1>
      </center>
      <ul>
         <li><p><b>First Name:</b>
            <%= request.getParameter("first_name")%>
         </p></li>
         <li><p><b>Last  Name:</b>
            <%= request.getParameter("last_name")%>
         </p></li>
      </ul>
   
   </body>
</html>

上記のコードを入れましょう main.jsp ファイルを作成し、次のHTMLページで使用します-

<html>
   <body>
      
      <form action = "main.jsp" 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.jsp そして、置きます hello.jsp そして main.jsp に <Tomcat-installation-directory>/webapps/ROOTディレクトリ。アクセスする時期http://localhost:8080/hello.jsp、これが上記のフォームの実際の出力です。

名と姓を入力して、送信ボタンをクリックしてみてください。これにより、画面に姓と名が表示され、2つのCookieも設定されますfirstName そして lastName。これらのCookieは、次に[送信]ボタンをクリックしたときにサーバーに返されます。

次のセクションでは、WebアプリケーションでこれらのCookieにアクセスする方法について説明します。

JSPでCookieを読み取る

Cookieを読み取るには、を呼び出してjavax.servlet.http.Cookieオブジェクトの配列を作成する必要があります。getCookies( )HttpServletRequestのメソッド。次に、アレイを循環して、getName() そして getValue() 各Cookieと関連する値にアクセスするためのメソッド。

例

前の例で設定されたCookieを読んでみましょう-

<html>
   <head>
      <title>Reading Cookies</title>
   </head>
   
   <body>
      <center>
         <h1>Reading Cookies</h1>
      </center>
      <%
         Cookie cookie = null;
         Cookie[] cookies = null;
         
         // Get an array of Cookies associated with the this domain
         cookies = request.getCookies();
         
         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>");
         }
      %>
   </body>
   
</html>

上記のコードを入れましょう main.jspファイルにアクセスしてみてください。あなたが設定した場合first_name cookie 「ジョン」と last_name cookie 「プレーヤー」として実行します http://localhost:8080/main.jsp 次の結果が表示されます-

 Found Cookies Name and Value
Name : first_name, Value: John
Name : last_name, Value: Player

JSPでCookieを削除する

クッキーを削除するのはとても簡単です。クッキーを削除したい場合は、次の3つの手順に従う必要があります-

• 既存のCookieを読み取り、Cookieオブジェクトに保存します。

• を使用してCookieの経過時間をゼロに設定します setMaxAge() 既存のCookieを削除する方法。

• このCookieを応答ヘッダーに追加し直します。

例

次の例は、という名前の既存のCookieを削除する方法を示しています。 "first_name" 次回main.jspJSPを実行すると、first_nameにnull値が返されます。

<html>
   <head>
      <title>Reading Cookies</title>
   </head>
   
   <body>
      <center>
         <h1>Reading Cookies</h1>
      </center>
      <%
         Cookie cookie = null;
         Cookie[] cookies = null;
         
         // Get an array of Cookies associated with the this domain
         cookies = request.getCookies();
         
         if( cookies != null ) {
            out.println("<h2> Found 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>");
         }
      %>
   </body>
   
</html>

上記のコードを main.jspファイルにアクセスしてみてください。次の結果が表示されます-

Cookies Name and Value
Deleted cookie : first_name
Name : first_name, Value: John
Name : last_name, Value: Player

ここで、http：// localhost：8080 / main.jspをもう一度実行すると、次のように1つのCookieのみが表示されます。

 Found Cookies Name and Value
Name : last_name,  Value: Player

InternetExplorerでCookieを手動で削除できます。[ツール]メニューから開始し、[インターネットオプション]を選択します。すべてのCookieを削除するには、[Cookieの削除]ボタンをクリックします。

この章では、JSPでのセッション追跡について説明します。HTTPは「ステートレス」プロトコルです。つまり、クライアントがWebページを取得するたびに、クライアントはWebサーバーへの個別の接続を開き、サーバーは以前のクライアント要求の記録を自動的に保持しません。

Webクライアントとサーバー間のセッションの維持

ここで、WebクライアントとWebサーバー間のセッションを維持するためのいくつかのオプションについて説明します-

クッキー

Webサーバーは、一意のセッションIDをCookieとして各Webクライアントに割り当てることができ、クライアントからの後続の要求では、受信したCookieを使用してそれらを認識することができます。

ブラウザがCookieをサポートしていない場合があるため、これは効果的な方法ではない可能性があります。この手順を使用してセッションを維持することはお勧めしません。

非表示のフォームフィールド

Webサーバーは、次のように、非表示のHTMLフォームフィールドを一意のセッションIDとともに送信できます。

<input type = "hidden" name = "sessionid" value = "12345">

このエントリは、フォームが送信されると、指定された名前と値が自動的に GET または POSTデータ。Webブラウザーがリクエストを送り返すたびに、session_id valueは、さまざまなWebブラウザーを追跡するために使用できます。

これはセッションを追跡する効果的な方法ですが、通常の（<A HREF ...>）ハイパーテキストリンクをクリックしてもフォームは送信されないため、非表示のフォームフィールドも一般的なセッション追跡をサポートできません。

URL書き換え

各URLの最後にいくつかの追加データを追加できます。このデータはセッションを識別します。サーバーは、そのセッションIDを、そのセッションに関して保存されているデータに関連付けることができます。

たとえば、 http://tutorialspoint.com/file.htm;sessionid=12345、セッション識別子は次のように添付されます sessionid = 12345 これは、クライアントを識別するためにWebサーバーでアクセスできます。

URLの書き換えは、セッションを維持するためのより良い方法であり、Cookieをサポートしていないブラウザでも機能します。ここでの欠点は、ページが単純な静的HTMLページであるにもかかわらず、セッションIDを割り当てるためにすべてのURLを動的に生成する必要があることです。

セッションオブジェクト

上記のオプションとは別に、JSPはサーブレットが提供するHttpSessionインターフェイスを利用します。このインターフェースは、ユーザーを識別する方法を提供します。

• 1ページのリクエストまたは
• ウェブサイトへのアクセスまたは
• そのユーザーに関する情報を保存する

デフォルトでは、JSPでセッション追跡が有効になっており、新しいHttpSessionオブジェクトが新しいクライアントごとに自動的にインスタンス化されます。セッショントラッキングを無効にするには、次のようにページディレクティブセッション属性をfalseに設定して、明示的にオフにする必要があります。

<%@ page session = "false" %>

JSPエンジンは、暗黙的な方法でHttpSessionオブジェクトをJSP作成者に公開します sessionオブジェクト。以来session オブジェクトはすでにJSPプログラマーに提供されており、プログラマーは初期化なしでオブジェクトからデータの保存と取得をすぐに開始できます。 getSession()。

これは、セッションオブジェクトを通じて利用できる重要なメソッドの要約です-

S.No.	方法と説明
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オブジェクトを使用して、セッションの作成時刻と最後にアクセスされた時刻を確認する方法について説明します。新しいセッションがまだ存在しない場合は、リクエストに関連付けます。

<%@ page import = "java.io.*,java.util.*" %>
<%
   // Get session creation time.
   Date createTime = new Date(session.getCreationTime());
   
   // Get last access time of this Webpage.
   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 Webpage.
   if (session.isNew() ){
      title = "Welcome to my website";
      session.setAttribute(userIDKey, userID);
      session.setAttribute(visitCountKey,  visitCount);
   } 
   visitCount = (Integer)session.getAttribute(visitCountKey);
   visitCount = visitCount + 1;
   userID = (String)session.getAttribute(userIDKey);
   session.setAttribute(visitCountKey,  visitCount);
%>

<html>
   <head>
      <title>Session Tracking</title>
   </head>
   
   <body>
      <center>
         <h1>Session Tracking</h1>
      </center>
      
      <table border = "1" align = "center"> 
         <tr bgcolor = "#949494">
            <th>Session info</th>
            <th>Value</th>
         </tr> 
         <tr>
            <td>id</td>
            <td><% out.print( session.getId()); %></td>
         </tr> 
         <tr>
            <td>Creation Time</td>
            <td><% out.print(createTime); %></td>
         </tr> 
         <tr>
            <td>Time of Last Access</td>
            <td><% out.print(lastAccessTime); %></td>
         </tr> 
         <tr>
            <td>User ID</td>
            <td><% out.print(userID); %></td>
         </tr> 
         <tr>
            <td>Number of visits</td>
            <td><% out.print(visitCount); %></td>
         </tr> 
      </table> 
   
   </body>
</html>

次に、上記のコードを main.jsp アクセスしてみてください http://localhost:8080/main.jsp。URLを実行すると、次の結果が表示されます-

私のウェブサイトへようこそ

Session Information

セッション情報	値
id	0AE3EC93FF44E3C525B4351B77ABB2D5
作成時間	2010年6月8日火曜日17：26：40GMT + 04：00
最終アクセス時刻	2010年6月8日火曜日17：26：40GMT + 04：00
ユーザーID	あいうえお
訪問数	0

ここで、同じJSPをもう一度実行しようとすると、次の結果が得られます。

ようこそ私のウェブサイトに戻る

Session Information

情報タイプ	値
id	0AE3EC93FF44E3C525B4351B77ABB2D5
作成時間	2010年6月8日火曜日17：26：40GMT + 04：00
最終アクセス時刻	2010年6月8日火曜日17：26：40GMT + 04：00
ユーザーID	あいうえお
訪問数	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を返します。

この章では、JSPでのファイルのアップロードについて説明します。JSPをHTMLフォームタグとともに使用して、ユーザーがファイルをサーバーにアップロードできるようにすることができます。アップロードされるファイルは、テキストファイル、バイナリ、画像ファイル、または任意のドキュメントです。

ファイルアップロードフォームの作成

ファイルアップロードフォームの作成方法を理解しましょう。次のHTMLコードは、アップローダーフォームを作成します。以下は注意すべき重要なポイントです-

• フォーム method 属性はに設定する必要があります POST メソッドとGETメソッドは使用できません。

• フォーム enctype 属性はに設定する必要があります multipart/form-data。

• フォーム action属性は、バックエンドサーバーでのファイルのアップロードを処理するJSPファイルに設定する必要があります。次の例は使用していますuploadFile.jsp ファイルをアップロードするプログラムファイル。

• 単一のファイルをアップロードするには、単一のファイルを使用する必要があります <input .../> 属性付きのタグ type = "file"。複数のファイルをアップロードできるようにするには、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 −上記のフォームは単なるダミーフォームであり、機能しません。マシンで上記のコードを試して、機能させる必要があります。

バックエンドJSPスクリプトの作成

アップロードしたファイルを保存する場所を定義しましょう。これをプログラムにハードコーディングするか、このディレクトリ名を次のような外部構成を使用して追加することもできます。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>

以下はのソースコードです UploadFile.jsp。これにより、一度に複数のファイルのアップロードを処理できます。ファイルのアップロードに進む前に、次のことを考慮してみましょう。

• 次の例は 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-tomcat5.5.29\webapps\data かなり前もって。

<%@ page import = "java.io.*,java.util.*, javax.servlet.*" %>
<%@ page import = "javax.servlet.http.*" %>
<%@ page import = "org.apache.commons.fileupload.*" %>
<%@ page import = "org.apache.commons.fileupload.disk.*" %>
<%@ page import = "org.apache.commons.fileupload.servlet.*" %>
<%@ page import = "org.apache.commons.io.output.*" %>

<%
   File file ;
   int maxFileSize = 5000 * 1024;
   int maxMemSize = 5000 * 1024;
   ServletContext context = pageContext.getServletContext();
   String filePath = context.getInitParameter("file-upload");

   // Verify the content type
   String contentType = request.getContentType();
   
   if ((contentType.indexOf("multipart/form-data") >= 0)) {
      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>JSP File 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();
               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: " + filePath + 
               fileName + "<br>");
            }
         }
         out.println("</body>");
         out.println("</html>");
      } catch(Exception ex) {
         System.out.println(ex);
      }
   } else {
      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>");
   }
%>

次に、上記で作成したHTMLフォームを使用してファイルをアップロードしてみます。やってみるとhttp://localhost:8080/UploadFile.htm、次の結果が表示されます。これは、ローカルマシンからファイルをアップロードするのに役立ちます。

File Upload − 
Select a file to upload −
 
 

 

JSPスクリプトが正常に機能する場合は、ファイルをにアップロードする必要があります。 c:\apache-tomcat5.5.29\webapps\data\ ディレクトリ。

この章では、JSPでデータを処理する方法について説明します。JSPを使用することの最も重要な利点の1つは、コアJavaで使用可能なすべてのメソッドを使用できることです。私たちはあなたを案内しますDate で利用可能なクラス java.utilパッケージ; このクラスは、現在の日付と時刻をカプセル化します。

Dateクラスは、2つのコンストラクターをサポートします。最初のコンストラクターは、オブジェクトを現在の日付と時刻で初期化します。

Date( )

次のコンストラクターは、1970年1月1日の午前0時から経過したミリ秒数に等しい1つの引数を受け入れます。

Date(long millisec)

Dateオブジェクトを使用できるようになったら、次のサポートメソッドのいずれかを呼び出して日付を操作できます-

S.No.	方法と説明
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時からの経過時間をミリ秒単位で表す時刻で指定された日時を設定します。
10	String toString( ) 呼び出し元のDateオブジェクトを文字列に変換し、結果を返します。

現在の日付と時刻を取得する

JSPプログラムを使用すると、現在の日付と時刻を非常に簡単に取得できます。単純なDateオブジェクトを使用できますtoString() 次のように現在の日付と時刻を印刷する方法-

<%@ page import = "java.io.*,java.util.*, javax.servlet.*" %>

<html>
   <head>
      <title>Display Current Date & Time</title>
   </head>
   
   <body>
      <center>
         <h1>Display Current Date & Time</h1>
      </center>
      <%
         Date date = new Date();
         out.print( "<h2 align = \"center\">" +date.toString()+"</h2>");
      %>
   </body>
</html>

コードを保持しましょう CurrentDate.jsp 次に、URLを使用してこのJSPを呼び出します http://localhost:8080/CurrentDate.jsp。次の結果が表示されます-

Display Current Date & Time
Mon Jun 21 21:46:49 GMT+04:00 2010

でページを更新します URL http://localhost:8080/CurrentDate.jsp。更新するたびに秒単位で違いがわかります。

日付の比較

前のセクションで説明したように、JSPスクリプトで使用可能なすべての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を返します。

• あなたは使用することができます compareTo( )方法; このメソッドは、Comparable interface 日付によって実装されます。

SimpleDateFormatを使用した日付の書式設定

SimpleDateFormatは、ロケールに依存する方法で日付をフォーマットおよび解析するための具象クラスです。SimpleDateFormatを使用すると、日時フォーマット用のユーザー定義パターンを選択することから始めることができます。

上記の例を次のように変更してみましょう-

<%@ page import = "java.io.*,java.util.*" %>
<%@ page import = "javax.servlet.*,java.text.*" %>

<html>
   <head>
      <title>Display Current Date & Time</title>
   </head>
   
   <body>
      <center>
         <h1>Display Current Date & Time</h1>
      </center>
      <%
         Date dNow = new Date( );
         SimpleDateFormat ft = 
         new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
         out.print( "<h2 align=\"center\">" + ft.format(dNow) + "</h2>");
      %>
   </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	月の日	0
h	午前/午後の時間（1〜12）	2
H	1日の時間（0〜23）	22
m	時間単位の分	30
s	分で2番目	55
S	ミリ秒	234
E	曜日	火曜日
D	年間の日	360
F	月の曜日	2（7月第2水曜日）
w	年間の週	40
W	月の週
a	AM / PMマーカー	午後
k	1日の時間（1〜24）	24
K	午前/午後の時間（0〜11）	0
z	タイムゾーン	東部標準時
'	テキストのエスケープ	デリミタ
「」	一重引用符	`

日付を操作するために使用可能な定数メソッドの完全なリストについては、標準のJavaドキュメントを参照してください。

この章では、JSPを使用したページリダイレクトについて説明します。ページリダイレクトは通常、ドキュメントが新しい場所に移動し、クライアントをこの新しい場所に送信する必要がある場合に使用されます。これは、負荷分散または単純なランダム化が原因である可能性があります。

リクエストを別のページにリダイレクトする最も簡単な方法は、 sendRedirect()応答オブジェクトのメソッド。以下は、このメソッドのシグネチャです-

public void response.sendRedirect(String location)
throws IOException

このメソッドは、ステータスコードと新しいページの場所とともに応答をブラウザに送り返します。また、使用することができますsetStatus() そしてその setHeader() 同じリダイレクトの例を達成するために一緒にメソッド-

....
String site = "http://www.newpage.com" ;
response.setStatus(response.SC_MOVED_TEMPORARILY);
response.setHeader("Location", site); 
....

例

この例は、JSPが別の場所へのページリダイレクトを実行する方法を示しています-

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>Page Redirection</title>
   </head>
   
   <body>
      <center>
         <h1>Page Redirection</h1>
      </center>
      <%
         // New location to be redirected
         String site = new String("http://www.photofuntoos.com");
         response.setStatus(response.SC_MOVED_TEMPORARILY);
         response.setHeader("Location", site); 
      %>
   </body>
</html>

上記のコードをPageRedirect.jspに配置し、URLを使用してこのJSPを呼び出します。 http://localhost:8080/PageRedirect.jsp。これにより、指定されたURLに移動しますhttp://www.photofuntoos.com。

この章では、JSPのヒットカウンターについて説明します。ヒットカウンターは、Webサイトの特定のページへのアクセス数を示します。通常、ユーザーが最初にホームページにアクセスすると想定して、index.jspページにヒットカウンターを添付します。

ヒットカウンターを実装するには、ApplicationImplicitオブジェクトと関連するメソッドを利用できます。 getAttribute() そして setAttribute()。

このオブジェクトは、ライフサイクル全体にわたるJSPページの表現です。このオブジェクトは、JSPページが初期化されるときに作成され、JSPページがによって削除されると削除されます。jspDestroy() 方法。

以下は、アプリケーションレベルで変数を設定するための構文です。

application.setAttribute(String Key, Object Value);

上記の方法を使用して、ヒットカウンター変数を設定し、同じ変数をリセットできます。以下は、前の方法で設定された変数を読み取る方法です。

application.getAttribute(String Key);

ユーザーがページにアクセスするたびに、ヒットカウンターの現在の値を読み取り、1ずつ増やして、後で使用できるように設定し直すことができます。

例

この例は、JSPを使用して特定のページのヒットの総数をカウントする方法を示しています。Webサイトのヒットの総数をカウントする場合は、すべてのJSPページに同じコードを含める必要があります。

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>Application object in JSP</title>
   </head>
   
   <body>
      <%
         Integer hitsCount = (Integer)application.getAttribute("hitCounter");
         if( hitsCount ==null || hitsCount == 0 ) {
            /* First visit */
            out.println("Welcome to my website!");
            hitsCount = 1;
         } else {
            /* return visit */
            out.println("Welcome back to my website!");
            hitsCount += 1;
         }
         application.setAttribute("hitCounter", hitsCount);
      %>
      <center>
         <p>Total number of visits: <%= hitsCount%></p>
      </center>
   
   </body>
</html>

上記のコードを入れましょう main.jsp URLを使用してこのJSPを呼び出します http://localhost:8080/main.jsp。これにより、ページを更新すると増加するヒットカウンター値が表示されます。さまざまなブラウザを使用してページにアクセスしてみると、ヒットカウンターがヒットするたびに増加し続け、次のような結果が得られることがわかります。

 
       
Welcome back to my website!
 
       
Total number of visits: 12
 
      

ヒットカウンターリセット

アプリケーション、つまりWebサーバーを再起動すると、アプリケーション変数がリセットされ、カウンターがゼロにリセットされます。この損失を回避するには、次の点を考慮してください。

• 単一のカウントでデータベーステーブルを定義します。ヒットカウントとしましょう。それにゼロ値を割り当てます。

• ヒットするたびに、表を読んでヒットカウントの値を取得します。

• hitcountの値を1つ増やし、テーブルを新しい値で更新します。

• ヒットカウントの新しい値を合計ページヒットカウントとして表示します。

• すべてのページのヒット数をカウントする場合は、すべてのページに上記のロジックを実装します。

この章では、JSPでの自動更新について説明します。ライブゲームのスコア、株式市場のステータス、または外貨両替の配給を表示しているWebページについて考えてみます。このようなすべてのタイプのページでは、ブラウザの更新ボタンまたは再読み込みボタンを使用して、定期的にWebページを更新する必要があります。

JSPは、指定された間隔の後に自動的に更新されるような方法でWebページを作成できるメカニズムを提供することにより、このジョブを簡単にします。

Webページを更新する最も簡単な方法は、 setIntHeader()応答オブジェクトのメソッド。以下は、このメソッドのシグネチャです-

public void setIntHeader(String header, int headerValue)

このメソッドは、時間間隔を秒単位で示す整数値とともに、ヘッダー「Refresh」をブラウザーに送り返します。

自動ページ更新の例

次の例では、 setIntHeader() 設定する方法 Refreshヘッダ。これは、デジタル時計のシミュレーションに役立ちます-

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>Auto Refresh Header Example</title>
   </head>
   
   <body>
      <center>
         <h2>Auto Refresh Header Example</h2>
         <%
            // Set refresh, autoload time as 5 seconds
            response.setIntHeader("Refresh", 5);
            
            // 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;
            out.println("Crrent Time: " + CT + "\n");
         %>
      </center>
   
   </body>
</html>

次に、上記のコードを main.jspそれにアクセスしてみてください。これにより、次のように5秒ごとに現在のシステム時刻が表示されます。JSPを実行し、結果が表示されるのを待つだけです-

Auto Refresh Header Example
Current Time is: 9:44:50 PM

この章では、JSPを使用してメールを送信する方法について説明します。JSPを使用してメールを送信するには、JavaMail API そしてその Java Activation Framework (JAF) マシンにインストールされています。

• JavaMailの最新バージョン（バージョン1.2）は、Javaの標準Webサイトからダウンロードできます。

• JavaBeans Activation Framework JAFの最新バージョン（バージョン1.0.2）は、Javaの標準Webサイトからダウンロードできます。

新しく作成されたトップレベルディレクトリで、これらのファイルをダウンロードして解凍します。両方のアプリケーション用の多数のjarファイルがあります。追加する必要がありますmail.jar そしてその activation.jar CLASSPATH内のファイル。

簡単なメールを送信する

これは、マシンから簡単な電子メールを送信する例です。あなたのlocalhostインターネットに接続されており、電子メールを送信するのに十分な能力があること。Java EmailAPIパッケージおよびJAFパッケージのすべてのjarファイルがCLASSPATHで使用可能であることを確認してください。

<%@ page import = "java.io.*,java.util.*,javax.mail.*"%>
<%@ page import = "javax.mail.internet.*,javax.activation.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>

<%
   String result;
   
   // 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 object
   Properties properties = System.getProperties();

   // Setup mail server
   properties.setProperty("mail.smtp.host", host);

   // Get the default Session object.
   Session mailSession = Session.getDefaultInstance(properties);

   try {
      // Create a default MimeMessage object.
      MimeMessage message = new MimeMessage(mailSession);
      
      // 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);
      result = "Sent message successfully....";
   } catch (MessagingException mex) {
      mex.printStackTrace();
      result = "Error: unable to send message....";
   }
%>

<html>
   <head>
      <title>Send Email using JSP</title>
   </head>
   
   <body>
      <center>
         <h1>Send Email using JSP</h1>
      </center>
      
      <p align = "center">
         <% 
            out.println("Result: " + result + "\n");
         %>
      </p>
   </body>
</html>

上記のコードを入れましょう SendEmail.jsp ファイルを作成し、URLを使用してこのJSPを呼び出します http://localhost:8080/SendEmail.jsp。これは、指定された電子メールIDに電子メールを送信するのに役立ちます[email protected]。次の応答が返されます-

Send Email using JSP
Result: 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インターネットに接続されており、電子メールを送信するのに十分な能力があること。からのすべてのjarファイルを確認してくださいJava Email API package そしてその JAF package CLASSPATHで利用できます。

この例は前の例と非常に似ていますが、ここでは setContent() 2番目の引数がであるコンテンツを設定するメソッド "text/html" HTMLコンテンツがメッセージに含まれることを指定します。

この例を使用すると、必要なだけ大きなHTMLコンテンツを送信できます。

<%@ page import = "java.io.*,java.util.*,javax.mail.*"%>
<%@ page import = "javax.mail.internet.*,javax.activation.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>

<%
   String result;
   
   // 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 object
   Properties properties = System.getProperties();

   // Setup mail server
   properties.setProperty("mail.smtp.host", host);

   // Get the default Session object.
   Session mailSession = Session.getDefaultInstance(properties);

   try {
      // Create a default MimeMessage object.
      MimeMessage message = new MimeMessage(mailSession);
      
      // 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);
      result = "Sent message successfully....";
   } catch (MessagingException mex) {
      mex.printStackTrace();
      result = "Error: unable to send message....";
   }
%>

<html>
   <head>
      <title>Send HTML Email using JSP</title>
   </head>

   <body>
      <center>
         <h1>Send Email using JSP</h1>
      </center>
      
      <p align = "center">
         <% 
            out.println("Result: " + result + "\n");
         %>
      </p>
   </body>
</html>

上記のJSPを使用して、特定の電子メールIDでHTMLメッセージを送信しましょう。

電子メールで添付ファイルを送信する

以下は、マシンから添付ファイル付きの電子メールを送信する例です-

<%@ page import = "java.io.*,java.util.*,javax.mail.*"%>
<%@ page import = "javax.mail.internet.*,javax.activation.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>

<%
   String result;
   
   // 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 object
   Properties properties = System.getProperties();

   // Setup mail server
   properties.setProperty("mail.smtp.host", host);

   // Get the default Session object.
   Session mailSession = Session.getDefaultInstance(properties);

   try {
      // Create a default MimeMessage object.
      MimeMessage message = new MimeMessage(mailSession);

      // 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 multipart 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";
      result = "Sent message successfully....";
   } catch (MessagingException mex) {
      mex.printStackTrace();
      result = "Error: unable to send message....";
   }
%>

<html>
   <head>
      <title>Send Attachment Email using JSP</title>
   </head>
   
   <body>
      <center>
         <h1>Send Attachment Email using JSP</h1>
      </center>
      
      <p align = "center">
         <%out.println("Result: " + result + "\n");%>
      </p>
   </body>
</html>

上記のJSPを実行して、ファイルを添付ファイルとして、指定された電子メールIDのメッセージとともに送信してみましょう。

ユーザー認証部分

認証のためにユーザーIDとパスワードを電子メールサーバーに提供する必要がある場合は、これらのプロパティを次のように設定できます。

props.setProperty("mail.user", "myuser");
props.setProperty("mail.password", "mypwd");

電子メール送信メカニズムの残りの部分は、上記で説明したままになります。

フォームを使用してメールを送信する

HTMLフォームを使用して電子メールパラメータを受け入れることができ、次に request 次のようにすべての情報を取得するオブジェクト-

String to = request.getParameter("to");
String from = request.getParameter("from");
String subject = request.getParameter("subject");
String messageText = request.getParameter("body");

すべての情報を入手したら、上記のプログラムを使用して電子メールを送信できます。

この章では、JSPのさまざまなタグについて理解します。JavaServer Pages標準タグライブラリ（JSTL）は、多くのJSPアプリケーションに共通するコア機能をカプセル化する便利なJSPタグのコレクションです。

JSTLは、反復や条件、XMLドキュメントを操作するためのタグ、国際化タグ、SQLタグなどの一般的な構造タスクをサポートしています。また、既存のカスタムタグをJSTLタグと統合するためのフレームワークも提供します。

JSTLライブラリをインストールする

JSPタグの操作を開始するには、最初にJSTLライブラリをインストールする必要があります。Apache Tomcatコンテナを使用している場合は、次の2つの手順に従います-

Step 1− Apache Standard Taglibからバイナリディストリビューションをダウンロードし、圧縮ファイルを解凍します。

Step 2 −標準のTaglibを Jakarta Taglibs distribution、ディストリビューションの「lib」ディレクトリにあるJARファイルをアプリケーションの「lib」ディレクトリにコピーするだけです。 webapps\ROOT\WEB-INF\lib ディレクトリ。

ライブラリを使用するには、ライブラリを使用する各JSPの先頭に<taglib>ディレクティブを含める必要があります。

JSTLタグの分類

JSTLタグは、その機能に応じて、JSPページの作成時に使用できる次のJSTLタグライブラリグループに分類できます。

• Core Tags

• Formatting tags

• SQL tags

• XML tags

• JSTL Functions

コアタグ

タグのコアグループは、最も一般的に使用されるJSTLタグです。以下は、JSPにJSTLコアライブラリを含めるための構文です。

<%@ taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>

次の表に、コアJSTLタグを示します-

S.No.	タグと説明
1	<％= ...>と同様ですが、式用です。
2	式の評価結果を 'scope'
3	を削除します scoped variable （指定されている場合、特定のスコープから）。
4	任意のキャッチ Throwable それはその体で起こり、オプションでそれを露出させます。
5	指定された条件が真の場合に本体を評価する単純な条件付きタグ。
6	相互に排他的な条件付き操作のコンテキストを確立する単純な条件付きタグ。 <when> そして <otherwise>。
7	のサブタグ <choose> その状態が次のように評価された場合、それはその体を含みます 'true'。
8	のサブタグ <choose> それに続く <when> タグを付けて実行するのは、以前のすべての条件が 'false'。
9	絶対URLまたは相対URLを取得し、そのコンテンツをページ、文字列のいずれかに公開します。 'var'、またはのリーダー 'varReader'。
10	基本的な反復タグ。さまざまなコレクションタイプを受け入れ、サブセット化やその他の機能をサポートします。
11	提供されたデリメータで区切られたトークンを繰り返し処理します。
12	含むにパラメータを追加します 'import' タグのURL。
13	新しいURLにリダイレクトします。
14	オプションのクエリパラメータを使用してURLを作成します

タグのフォーマット

JSTLフォーマットタグは、国際化されたWebサイトのテキスト、日付、時刻、および数値をフォーマットおよび表示するために使用されます。以下は、JSPにフォーマットライブラリを含めるための構文です。

<%@ taglib prefix = "fmt" uri = "http://java.sun.com/jsp/jstl/fmt" %>

次の表に、JSTLタグのフォーマットを示します-

S.No.	タグと説明
1	特定の精度または形式で数値をレンダリングすること。
2	数値、通貨、またはパーセンテージの文字列表現を解析します。
3	提供されたスタイルとパターンを使用して、日付や時刻をフォーマットします。
4	日付や時刻の文字列表現を解析します
5	タグ本体で使用されるリソースバンドルをロードします。
6	指定されたロケールをロケール構成変数に格納します。
7	リソースバンドルをロードし、名前付きスコープ変数またはバンドル構成変数に格納します。
8	本体にネストされたアクションのタイムフォーマットまたは解析のタイムゾーンを指定します。
9	指定されたタイムゾーンをタイムゾーン構成変数に格納します
10	国際化されたメッセージを表示します。
11	リクエスト文字エンコードを設定します

SQLタグ

JSTL SQLタグライブラリは、次のようなリレーショナルデータベース（RDBMS）と対話するためのタグを提供します。 Oracle, mySQL、または Microsoft SQL Server。

以下は、JSPにJSTLSQLライブラリを含めるための構文です。

<%@ taglib prefix = "sql" uri = "http://java.sun.com/jsp/jstl/sql" %>

次の表に、SQLJSTLタグを示します-

S.No.	タグと説明
1	プロトタイピングにのみ適した単純なデータソースを作成します
2	本体またはsql属性で定義されたSQLクエリを実行します。
3	本体またはsql属性で定義されたSQL更新を実行します。
4	SQLステートメントのパラメーターを指定された値に設定します。
5	SQLステートメントのパラメーターを指定されたjava.util.Date値に設定します。
6	ネストされたデータベースアクション要素に共有接続を提供し、すべてのステートメントを1つのトランザクションとして実行するように設定します。

XMLタグ

JSTL XMLタグは、XMLドキュメントを作成および操作するJSP中心の方法を提供します。以下は、JSPにJSTLXMLライブラリを含めるための構文です。

JSTL XMLタグライブラリには、XMLデータを操作するためのカスタムタグがあります。これには、XMLの解析、XMLデータの変換、およびXPath式に基づくフロー制御が含まれます。

<%@ taglib prefix = "x" 
   uri = "http://java.sun.com/jsp/jstl/xml" %>

例を進める前に、次の2つのXMLおよびXPath関連ライブラリをにコピーする必要があります。 <Tomcat Installation Directory>\lib −

• XercesImpl.jar −からダウンロード https://www.apache.org/dist/xerces/j/

• xalan.jar −からダウンロード https://xml.apache.org/xalan-j/index.html

以下は、XMLJSTLタグのリストです-

S.No.	タグと説明
1	<％= ...>と同様ですが、XPath式用です。
2	属性またはタグ本体のいずれかで指定されたXMLデータを解析するために使用されます。
3	変数をXPath式の値に設定します。
4	テストXPath式を評価し、それがtrueの場合、本体を処理します。テスト条件がfalseの場合、本文は無視されます。
5	XMLドキュメント内のノードをループします。
6	相互に排他的な条件付き操作のコンテキストを確立する単純な条件付きタグ。 <when> そして <otherwise> タグ。
7	のサブタグ <choose> その表現が「真」に評価される場合、それはその本体を含みます。
8	のサブタグ <choose> それに続く <when> 以前のすべての条件が「false」と評価された場合にのみタグ付けして実行します。
9	XMLドキュメントにXSL変換を適用します
10	と一緒に使用 transform XSLTスタイルシートにパラメータを設定するためのタグ

JSTL関数

JSTLには多くの標準関数が含まれており、そのほとんどは一般的な文字列操作関数です。以下は、JSPにJSTL関数ライブラリを含めるための構文です。

<%@ taglib prefix = "fn" 
   uri = "http://java.sun.com/jsp/jstl/functions" %>

次の表に、さまざまなJSTL関数を示します。

S.No.	機能と説明
1	fn：contains（） 入力文字列に指定された部分文字列が含まれているかどうかをテストします。
2	fn：containsIgnoreCase（） 大文字と小文字を区別しない方法で、入力文字列に指定された部分文字列が含まれているかどうかをテストします。
3	fn：endsWith（） 入力文字列が指定されたサフィックスで終わるかどうかをテストします。
4	fn：escapeXml（） XMLマークアップとして解釈できる文字をエスケープします。
5	fn：indexOf（） 指定された部分文字列が最初に出現する文字列を含むインデックスを返します。
6	fn：join（） 配列のすべての要素を文字列に結合します。
7	fn：length（） コレクション内のアイテム数、または文字列内の文字数を返します。
8	fn：replace（） 入力文字列内のすべての出現箇所を指定された文字列に置き換えた結果の文字列を返します。
9	fn：split（） 文字列を部分文字列の配列に分割します。
10	fn：startsWith（） 入力文字列が指定されたプレフィックスで始まるかどうかをテストします。
11	fn：substring（） 文字列のサブセットを返します。
12	fn：substringAfter（） 特定の部分文字列に続く文字列のサブセットを返します。
13	fn：substringBefore（） 特定の部分文字列の前にある文字列のサブセットを返します。
14	fn：toLowerCase（） 文字列のすべての文字を小文字に変換します。
15	fn：toUpperCase（） 文字列のすべての文字を大文字に変換します。
16	fn：trim（） 文字列の両端から空白を削除します。

この章では、JSPを使用してデータベースにアクセスする方法について説明します。JDBCアプリケーションがどのように機能するかを十分に理解していることを前提としています。JSPを介したデータベースアクセスを開始する前に、データベースとともに適切なJDBC環境がセットアップされていることを確認してください。

JDBCを使用してデータベースにアクセスする方法とその環境設定の詳細については、JDBCチュートリアルを参照してください。

基本的な概念から始めるために、次のようにテーブルを作成し、そのテーブルにいくつかのレコードを作成しましょう。

テーブルを作成する

を作成するには Employees EMPデータベースのテーブルで、次の手順を使用します-

ステップ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>

SELECT操作

次の例は、を実行する方法を示しています SQL SELECT JSPプログラミングでJTSLを使用するステートメント-

<%@ page import = "java.io.*,java.util.*,java.sql.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix = "c"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix = "sql"%>
 
<html>
   <head>
      <title>SELECT Operation</title>
   </head>

   <body>
      <sql:setDataSource var = "snapshot" driver = "com.mysql.jdbc.Driver"
         url = "jdbc:mysql://localhost/TEST"
         user = "root"  password = "pass123"/>
 
      <sql:query dataSource = "${snapshot}" var = "result">
         SELECT * from Employees;
      </sql:query>
 
      <table border = "1" width = "100%">
         <tr>
            <th>Emp ID</th>
            <th>First Name</th>
            <th>Last Name</th>
            <th>Age</th>
         </tr>
         
         <c:forEach var = "row" items = "${result.rows}"> <tr> <td><c:out value = "${row.id}"/></td>
               <td><c:out value = "${row.first}"/></td> <td><c:out value = "${row.last}"/></td>
               <td><c:out value = "${row.age}"/></td>
            </tr>
         </c:forEach>
      </table>
 
   </body>
</html>

上記のJSPにアクセスすると、次の結果が表示されます-

 
       

        
 
         
Emp ID
 
         
First Name
 
         
Last Name
 
         
Age
 
        
 
        
 
         
100
 
         
Zara
 
         
Ali
 
         
18
 
        
 
        
 
         
101
 
         
Mahnaz
 
         
Fatma
 
         
25
 
        
 
        
 
         
102
 
         
Zaid
 
         
Khan
 
         
30
 
        
 
        
 
         
103
 
         
Sumit
 
         
Mittal
 
         
28
 
        
 
       
      

INSERT操作

次の例は、JSPプログラミングでJTSLを使用してSQLINSERTステートメントを実行する方法を示しています。

<%@ page import = "java.io.*,java.util.*,java.sql.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix = "c"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix = "sql"%>
 
<html>
   <head>
      <title>JINSERT Operation</title>
   </head>
   
   <body>
      <sql:setDataSource var = "snapshot" driver = "com.mysql.jdbc.Driver"
         url = "jdbc:mysql://localhost/TEST"
         user = "root"  password = "pass123"/>
         <sql:update dataSource = "${snapshot}" var = "result">
         INSERT INTO Employees VALUES (104, 2, 'Nuha', 'Ali');
      </sql:update>
 
      <sql:query dataSource = "${snapshot}" var = "result"> SELECT * from Employees; </sql:query> <table border = "1" width = "100%"> <tr> <th>Emp ID</th> <th>First Name</th> <th>Last Name</th> <th>Age</th> </tr> <c:forEach var = "row" items = "${result.rows}">
            <tr>
               <td><c:out value = "${row.id}"/></td> <td><c:out value = "${row.first}"/></td>
               <td><c:out value = "${row.last}"/></td> <td><c:out value = "${row.age}"/></td>
            </tr>
         </c:forEach>
      </table>
 
   </body>
</html>

上記のJSPにアクセスすると、次の結果が表示されます-

 
       

        
 
         
Emp ID
 
         
First Name
 
         
Last Name
 
         
Age
 
        
 
        
 
         
100
 
         
Zara
 
         
Ali
 
         
18
 
        
 
        
 
         
101
 
         
Mahnaz
 
         
Fatma
 
         
25
 
        
 
        
 
         
102
 
         
Zaid
 
         
Khan
 
         
30
 
        
 
        
 
         
103
 
         
Sumit
 
         
Mittal
 
         
28
 
        
 
        
 
         
104
 
         
Nuha
 
         
Ali
 
         
2
 
        
 
       
      

DELETE操作

次の例は、を実行する方法を示しています SQL DELETE JSPプログラミングでJTSLを使用するステートメント-

<%@ page import = "java.io.*,java.util.*,java.sql.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix = "c"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix = "sql"%>
 
<html>
   <head>
      <title>DELETE Operation</title>
   </head>
   
   <body>
      <sql:setDataSource var = "snapshot" driver = "com.mysql.jdbc.Driver"
         url = "jdbc:mysql://localhost/TEST"
         user = "root" password = "pass123"/>
 
      <c:set var = "empId" value = "103"/>
 
      <sql:update dataSource = "${snapshot}" var = "count"> DELETE FROM Employees WHERE Id = ? <sql:param value = "${empId}" />
      </sql:update>
 
      <sql:query dataSource = "${snapshot}" var = "result"> SELECT * from Employees; </sql:query> <table border = "1" width = "100%"> <tr> <th>Emp ID</th> <th>First Name</th> <th>Last Name</th> <th>Age</th> </tr> <c:forEach var = "row" items = "${result.rows}">
            <tr>
               <td><c:out value = "${row.id}"/></td> <td><c:out value = "${row.first}"/></td>
               <td><c:out value = "${row.last}"/></td> <td><c:out value = "${row.age}"/></td>
            </tr>
         </c:forEach>
      </table>
 
   </body>
</html>

上記のJSPにアクセスすると、次の結果が表示されます-

 
       

        
 
         
Emp ID
 
         
First Name
 
         
Last Name
 
         
Age
 
        
 
        
 
         
100
 
         
Zara
 
         
Ali
 
         
18
 
        
 
        
 
         
101
 
         
Mahnaz
 
         
Fatma
 
         
25
 
        
 
        
 
         
102
 
         
Zaid
 
         
Khan
 
         
30
 
        
 
       
      

UPDATE操作

次の例は、を実行する方法を示しています SQL UPDATE JSPプログラミングでJTSLを使用するステートメント-

<%@ page import = "java.io.*,java.util.*,java.sql.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>
<%@ taglib uri = "http://java.sun.com/jsp/jstl/core" prefix = "c"%>
<%@ taglib uri = "http://java.sun.com/jsp/jstl/sql" prefix = "sql"%>
 
<html>
   <head>
      <title>DELETE Operation</title>
   </head>
   
   <body>
      <sql:setDataSource var = "snapshot" driver = "com.mysql.jdbc.Driver"
         url = "jdbc:mysql://localhost/TEST"
         user = "root" password = "pass123"/>
 
      <c:set var = "empId" value = "102"/>
 
      <sql:update dataSource = "${snapshot}" var = "count"> UPDATE Employees SET WHERE last = 'Ali' <sql:param value = "${empId}" />
      </sql:update>
 
      <sql:query dataSource = "${snapshot}" var = "result"> SELECT * from Employees; </sql:query> <table border = "1" width = "100%"> <tr> <th>Emp ID</th> <th>First Name</th> <th>Last Name</th> <th>Age</th> </tr> <c:forEach var = "row" items = "${result.rows}">
            <tr>
               <td><c:out value = "${row.id}"/></td> <td><c:out value = "${row.first}"/></td>
               <td><c:out value = "${row.last}"/></td> <td><c:out value = "${row.age}"/></td>
            </tr>
         </c:forEach>
      </table>
 
   </body>
</html>

上記のJSPにアクセスすると、次の結果が表示されます-

 
       

        
 
         
Emp ID
 
         
First Name
 
         
Last Name
 
         
Age
 
        
 
        
 
         
100
 
         
Zara
 
         
Ali
 
         
18
 
        
 
        
 
         
101
 
         
Mahnaz
 
         
Fatma
 
         
25
 
        
 
        
 
         
102
 
         
Zaid
 
         
Ali
 
         
30
 
        
 
       
      

HTTP経由でXMLデータを送信する場合、JSPを使用して着信および発信XMLドキュメントを処理することは理にかなっています。たとえば、RSSドキュメント。XMLドキュメントは単なるテキストの集まりであるため、JSPを使用して作成する方がHTMLドキュメントを作成するよりもはるかに簡単です。

JSPからのXMLの送信

HTMLを送信するのと同じ方法で、JSPを使用してXMLコンテンツを送信できます。唯一の違いは、ページのコンテンツタイプをtext / xmlに設定する必要があることです。コンテンツタイプを設定するには、<%@page%> このようなタグ-

<%@ page contentType = "text/xml" %>

次の例は、XMLコンテンツをブラウザに送信する方法を示しています-

<%@ page contentType = "text/xml" %>

<books>
   <book>
      <name>Padam History</name>
      <author>ZARA</author>
      <price>100</price>
   </book>
</books>

さまざまなブラウザを使用して上記のXMLにアクセスし、上記のXMLのドキュメントツリーの表示を確認します。

JSPでのXMLの処理

JSPを使用してXML処理を進める前に、次の2つのXMLおよびXPath関連ライブラリをにコピーする必要があります。 <Tomcat Installation Directory>\lib −

• XercesImpl.jar −からダウンロード https://www.apache.org/dist/xerces/j/

• xalan.jar −からダウンロード https://xml.apache.org/xalan-j/index.html

以下のコンテンツをbooks.xmlファイルに入れましょう-

<books>
   <book>
      <name>Padam History</name>
      <author>ZARA</author>
      <price>100</price>
   </book>
   
   <book>
      <name>Great Mistry</name>
      <author>NUHA</author>
      <price>2000</price>
   </book>
</books>

次を試してください main.jsp、同じディレクトリに保持-

<%@ taglib prefix = "c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix = "x" uri="http://java.sun.com/jsp/jstl/xml" %>
 
<html>
   <head>
      <title>JSTL x:parse Tags</title>
   </head>

   <body>
      <h3>Books Info:</h3>
      <c:import var = "bookInfo" url="http://localhost:8080/books.xml"/>
 
      <x:parse xml = "${bookInfo}" var = "output"/> <b>The title of the first book is</b>: <x:out select = "$output/books/book[1]/name" />
      <br>
      
      <b>The price of the second book</b>: 
      <x:out select = "$output/books/book[2]/price" />
   </body>
</html>

上記のJSPにアクセスするには http://localhost:8080/main.jsp、以下の結果が表示されます-

Books Info:
The title of the first book is:Padam History

The price of the second book: 2000

JSPを使用したXMLのフォーマット

次のXSLTスタイルシートを検討してください style.xsl −

<?xml version = "1.0"?>
<xsl:stylesheet xmlns:xsl = "http://www.w3.org/1999/XSL/Transform" 
   version = "1.0">
 
   <xsl:output method = "html" indent = "yes"/>
   <xsl:template match = "/">
      <html>
         <body>
            <xsl:apply-templates/>
         </body>
      </html>
   </xsl:template>
    
   <xsl:template match = "books">
      <table border = "1" width = "100%">
         <xsl:for-each select = "book">
            <tr>
               <td>
                  <i><xsl:value-of select = "name"/></i>
               </td>
               
               <td>
                  <xsl:value-of select = "author"/>
               </td>
               
               <td>
                  <xsl:value-of select = "price"/>
               </td>
            </tr>
         </xsl:for-each>
      </table>
   
   </xsl:template>
</xsl:stylesheet>

次のJSPファイルについて考えてみましょう-

<%@ taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix = "x" uri = "http://java.sun.com/jsp/jstl/xml" %>
 
<html>
   <head>
      <title>JSTL x:transform Tags</title>
   </head>
   
   <body>
      <h3>Books Info:</h3>
      <c:set var = "xmltext">
         <books>
            <book>
               <name>Padam History</name>
               <author>ZARA</author>
               <price>100</price>
            </book>
            
            <book>
               <name>Great Mistry</name>
               <author>NUHA</author>
               <price>2000</price>
            </book>
         </books>
      </c:set>
 
      <c:import url = "http://localhost:8080/style.xsl" var = "xslt"/>
      <x:transform xml = "${xmltext}" xslt = "${xslt}"/>
   </body>
</html>

以下の結果が表示されます-

Books Info:

      
 
       

        
 
         
Padam History
 
         
ZARA
 
         
100
 
        
 
        
 
         
Great Mistry
 
         
NUHA
 
         
2000
 
        
 
       
      

JSTLを使用したXML処理の詳細については、JSP標準タグライブラリを確認してください。

JavaBeanは、Javaで記述され、JavaBeansAPI仕様に従ってコーディングされた特別に構築されたJavaクラスです。

以下は、JavaBeanを他のJavaクラスと区別する固有の特性です。

• これは、デフォルトの引数なしのコンストラクターを提供します。

• シリアル化可能であり、実装できるものである必要があります Serializable インターフェース。

• 読み取りまたは書き込みが可能ないくつかのプロパティがあります。

• それはいくつかの「getter「と」setter"プロパティのメソッド。

JavaBeansのプロパティ

JavaBeanプロパティは、オブジェクトのユーザーがアクセスできる名前付き属性です。属性は、定義するクラスを含む、任意のJavaデータ型にすることができます。

JavaBeanプロパティは read, write, read only、または write only。JavaBeanプロパティには、JavaBeanの実装クラスの2つのメソッドを介してアクセスします-

S.No.	方法と説明
1	取得するPropertyName（） たとえば、プロパティ名がfirstNameの場合、メソッド名は次のようになります。getFirstName()そのプロパティを読み取ります。このメソッドはアクセサーと呼ばれます。
2	セットするPropertyName（） たとえば、プロパティ名がfirstNameの場合、メソッド名は次のようになります。setFirstName()そのプロパティを書き込みます。この方法はミューテーターと呼ばれます。

読み取り専用属性には、 getPropertyName() メソッド、および書き込み専用属性には、 setPropertyName() 方法。

JavaBeansの例

プロパティが少ない学生クラスを考えてみましょう-

package com.tutorialspoint;

public class StudentsBean implements java.io.Serializable {
   private String firstName = null;
   private String lastName = null;
   private int age = 0;

   public StudentsBean() {
   }
   public String getFirstName(){
      return firstName;
   }
   public String getLastName(){
      return lastName;
   }
   public int getAge(){
      return age;
   }
   public void setFirstName(String firstName){
      this.firstName = firstName;
   }
   public void setLastName(String lastName){
      this.lastName = lastName;
   }
   public void setAge(Integer age){
      this.age = age;
   }
}

JavaBeansへのアクセス

ザ・ useBeanアクションは、JSPで使用するJavaBeanを宣言します。宣言されると、Beanは、JSPで使用されるスクリプト要素と他のカスタムタグの両方からアクセスできるスクリプト変数になります。useBeanタグの完全な構文は次のとおりです-

<jsp:useBean id = "bean's name" scope = "bean's scope" typeSpec/>

ここで、scope属性の値は次のようになります。 page, request, session または application basedあなたの要件に。の値id 属性は、他の中で一意の名前である限り、任意の値にすることができます useBean declarations 同じJSPで。

次の例は、useBeanアクションの使用方法を示しています-

<html>
   <head>
      <title>useBean Example</title>
   </head>
   
   <body>
      <jsp:useBean id = "date" class = "java.util.Date" /> 
      <p>The date/time is <%= date %>
   </body>
</html>

次の結果が表示されます---

The date/time is Thu Sep 30 11:18:11 GST 2010

JavaBeansプロパティへのアクセス

に加えて <jsp:useBean...> アクション、あなたは使用することができます <jsp:getProperty/> getメソッドにアクセスするためのアクションと <jsp:setProperty/>setメソッドにアクセスするためのアクション。これが完全な構文です-

<jsp:useBean id = "id" class = "bean's class" scope = "bean's scope">
   <jsp:setProperty name = "bean's id" property = "property name"  
      value = "value"/>
   <jsp:getProperty name = "bean's id" property = "property name"/>
   ...........
</jsp:useBean>

name属性は、u​​seBeanアクションによって以前にJSPに導入されたJavaBeanのIDを参照します。プロパティ属性は、の名前です。get または set 呼び出す必要のあるメソッド。

次の例は、上記の構文を使用してデータにアクセスする方法を示しています-

<html>
   <head>
      <title>get and set properties Example</title>
   </head>
   
   <body>
      <jsp:useBean id = "students" class = "com.tutorialspoint.StudentsBean"> 
         <jsp:setProperty name = "students" property = "firstName" value = "Zara"/>
         <jsp:setProperty name = "students" property = "lastName" value = "Ali"/>
         <jsp:setProperty name = "students" property = "age" value = "10"/>
      </jsp:useBean>

      <p>Student First Name: 
         <jsp:getProperty name = "students" property = "firstName"/>
      </p>
      
      <p>Student Last Name: 
         <jsp:getProperty name = "students" property = "lastName"/>
      </p>
      
      <p>Student Age: 
         <jsp:getProperty name = "students" property = "age"/>
      </p>

   </body>
</html>

作ってみましょう StudentsBean.classCLASSPATHで利用できます。上記のJSPにアクセスします。以下の結果が表示されます-

Student First Name: Zara 

Student Last Name: Ali 

Student Age: 10

この章では、JSPのカスタムタグについて説明します。カスタムタグは、ユーザー定義のJSP言語要素です。カスタムタグを含むJSPページがサーブレットに変換されると、タグはタグハンドラと呼ばれるオブジェクトに対する操作に変換されます。次に、JSPページのサーブレットが実行されると、Webコンテナがこれらの操作を呼び出します。

JSPタグ拡張機能を使用すると、JavaServerPageに直接挿入できる新しいタグを作成できます。JSP 2.0仕様では、これらのカスタムタグを書き込むためのシンプルタグハンドラーが導入されました。

カスタムタグを作成するには、単純に拡張できます SimpleTagSupport クラスをオーバーライドし、 doTag() コードを配置してタグのコンテンツを生成できるメソッド。

「こんにちは」タグを作成する

<ex：Hello>という名前のカスタムタグを定義し、本文なしで次のように使用するとします。

<ex:Hello />

カスタムJSPタグを作成するには、最初にタグハンドラとして機能するJavaクラスを作成する必要があります。作成しましょうHelloTag 次のようにクラス-

package com.tutorialspoint;

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class HelloTag extends SimpleTagSupport {
   public void doTag() throws JspException, IOException {
      JspWriter out = getJspContext().getOut();
      out.println("Hello Custom Tag!");
   }
}

上記のコードには簡単なコーディングがあります。 doTag() メソッドは、を使用して現在のJspContextオブジェクトを取得します getJspContext() メソッドとそれを使用して送信 "Hello Custom Tag!" 現在に JspWriter オブジェクト

上記のクラスをコンパイルして、環境変数CLASSPATHで使用可能なディレクトリにコピーしてみましょう。最後に、次のタグライブラリファイルを作成します。<Tomcat-Installation-Directory>webapps\ROOT\WEB-INF\custom.tld。

<taglib>
   <tlib-version>1.0</tlib-version>
   <jsp-version>2.0</jsp-version>
   <short-name>Example TLD</short-name>
   
   <tag>
      <name>Hello</name>
      <tag-class>com.tutorialspoint.HelloTag</tag-class>
      <body-content>empty</body-content>
   </tag>
</taglib>

上記で定義したカスタムタグを使用してみましょう Hello 次のようにJSPプログラムで-

<%@ taglib prefix = "ex" uri = "WEB-INF/custom.tld"%>

<html>
   <head>
      <title>A sample custom tag</title>
   </head>
   
   <body>
      <ex:Hello/>
   </body>
</html>

上記のJSPを呼び出すと、次の結果が得られます-

Hello Custom Tag!

タグ本体へのアクセス

標準のタグで見たように、タグの本文にメッセージを含めることができます。名前の付いたカスタムタグを定義したいとします<ex:Hello> ボディで次のように使いたい−

<ex:Hello>
   This is message body
</ex:Hello>

上記のタグコードに次の変更を加えて、タグの本体を処理しましょう-

package com.tutorialspoint;

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class HelloTag extends SimpleTagSupport {
   StringWriter sw = new StringWriter();
   public void doTag()
   
   throws JspException, IOException {
      getJspBody().invoke(sw);
      getJspContext().getOut().println(sw.toString());
   }
}

ここでは、呼び出しの結果の出力が最初にキャプチャされます。 StringWriterタグに関連付けられたJspWriterに書き込まれる前。TLDファイルを次のように変更する必要があります-

<taglib>
   <tlib-version>1.0</tlib-version>
   <jsp-version>2.0</jsp-version>
   <short-name>Example TLD with Body</short-name>
   
   <tag>
      <name>Hello</name>
      <tag-class>com.tutorialspoint.HelloTag</tag-class>
      <body-content>scriptless</body-content>
   </tag>
</taglib>

上記のタグを適切な本体で次のように呼び出しましょう-

<%@ taglib prefix = "ex" uri = "WEB-INF/custom.tld"%>

<html>
   <head>
      <title>A sample custom tag</title>
   </head>
   
   <body>
      <ex:Hello>
         This is message body
      </ex:Hello>
   </body>
</html>

次の結果が表示されます-

This is message body

カスタムタグ属性

カスタムタグとともにさまざまな属性を使用できます。属性値を受け入れるには、カスタムタグクラスを実装する必要がありますsetter 以下に示すJavaBeanセッターメソッドと同じメソッド-

package com.tutorialspoint;

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class HelloTag extends SimpleTagSupport {
   private String message;

   public void setMessage(String msg) {
      this.message = msg;
   }
   StringWriter sw = new StringWriter();
   public void doTag()
   
   throws JspException, IOException {
      if (message != null) {
         /* Use message from attribute */
         JspWriter out = getJspContext().getOut();
         out.println( message );
      } else {
         /* use message from the body */
         getJspBody().invoke(sw);
         getJspContext().getOut().println(sw.toString());
      }
   }
}

属性の名前は "message"、したがって、セッターメソッドは setMessage()。ここで、を使用してこの属性をTLDファイルに追加しましょう。<attribute> 次のような要素-

<taglib>
   <tlib-version>1.0</tlib-version>
   <jsp-version>2.0</jsp-version>
   <short-name>Example TLD with Body</short-name>
   
   <tag>
      <name>Hello</name>
      <tag-class>com.tutorialspoint.HelloTag</tag-class>
      <body-content>scriptless</body-content>
      
      <attribute>
         <name>message</name>
      </attribute>
   
   </tag>
</taglib>

次のようにメッセージ属性でJSPをフォローしましょう-

<%@ taglib prefix = "ex" uri = "WEB-INF/custom.tld"%>

<html>
   <head>
      <title>A sample custom tag</title>
   </head>
   
   <body>
      <ex:Hello message = "This is custom tag" />
   </body>
</html>

これにより、次の結果が生成されます-

This is custom tag

属性に次のプロパティを含めることを検討してください-

S.No.	プロパティと目的
1	name name要素は、属性の名前を定義します。各属性名は、特定のタグに対して一意である必要があります。
2	required これは、この属性が必須であるかオプションであるかを指定します。オプションの場合はfalseになります。
3	rtexprvalue タグ属性の実行時式の値が有効かどうかを宣言します
4	type この属性のJavaクラスタイプを定義します。デフォルトでは、String
5	description 情報の説明を提供できます。
6	fragment この属性値をとして扱う必要があるかどうかを宣言します JspFragment。

以下は、属性に関連するプロパティを指定する例です。

.....
   <attribute>
      <name>attribute_name</name>
      <required>false</required>
      <type>java.util.Date</type>
      <fragment>false</fragment>
   </attribute>
.....

2つの属性を使用している場合は、TLDを次のように変更できます-

.....
   <attribute>
      <name>attribute_name1</name>
      <required>false</required>
      <type>java.util.Boolean</type>
      <fragment>false</fragment>
   </attribute>
   
   <attribute>
      <name>attribute_name2</name>
      <required>true</required>
      <type>java.util.Date</type>
   </attribute>
.....

JSP式言語（EL）を使用すると、JavaBeansコンポーネントに格納されているアプリケーションデータに簡単にアクセスできます。JSP ELを使用すると、両方の式を作成できます(a) 算術と (b)論理的。JSP EL式内で、次を使用できます。integers, floating point numbers, strings, the built-in constants true and false ブール値の場合、およびnull。

単純な構文

通常、JSPタグで属性値を指定するときは、単に文字列を使用します。例-

<jsp:setProperty name = "box" property = "perimeter" value = "100"/>

JSP ELでは、これらの属性値のいずれかに式を指定できます。JSPELの簡単な構文は次のとおりです。

${expr}

ここに expr式自体を指定します。JSPELで最も一般的な演算子は次のとおりです。. そして []。これらの2つの演算子を使用すると、JavaBeansおよび組み込みJSPオブジェクトのさまざまな属性にアクセスできます。

たとえば、上記の構文 <jsp:setProperty> タグは次のような式で記述できます-

<jsp:setProperty name = "box" property = "perimeter" 
   value = "${2*box.width+2*box.height}"/>

JSPコンパイラが ${} 属性にフォームを作成すると、式を評価するコードが生成され、expressonの値が置き換えられます。

タグのテンプレートテキスト内でJSPEL式を使用することもできます。たとえば、<jsp:text>タグは、そのコンテンツをJSPの本体に挿入するだけです。以下<jsp:text> 宣言挿入 <h1>Hello JSP!</h1> JSP出力に-

<jsp:text>
   <h1>Hello JSP!</h1>
</jsp:text>

JSPEL式を本体に含めることができるようになりました <jsp:text> 同じタグ（または他のタグ） ${}属性に使用する構文。例-

<jsp:text>
   Box Perimeter is: ${2*box.width + 2*box.height}
</jsp:text>

EL式では、括弧を使用して部分式をグループ化できます。例えば、${(1 + 2) * 3} equals 9, but ${1 + (2 * 3)} equals 7。

EL式の評価を無効にするには、 isELIgnored 以下のようなページディレクティブの属性-

<%@ page isELIgnored = "true|false" %>

この属性の有効な値はtrueとfalseです。trueの場合、静的テキストまたはタグ属性に表示されるEL式は無視されます。falseの場合、EL式はコンテナによって評価されます。

ELの基本的な演算子

JSP式言語（EL）は、Javaでサポートされているほとんどの算術演算子と論理演算子をサポートしています。次の表に、最も頻繁に使用される演算子を示します-

S.No.	オペレーターと説明
1	. Beanプロパティまたはマップエントリにアクセスします
2	[] 配列またはリスト要素にアクセスします
3	( ) 部分式をグループ化して、評価順序を変更します
4	+ 添加
5	- 値の減算または否定
6	* 乗算
7	/ or div 分割
8	% or mod モジュロ（残り）
9	== or eq 平等をテストする
10	!= or ne 不平等をテストする
11	< or lt 未満のテスト
12	> or gt より大きいかどうかをテストする
13	<= or le 以下をテストする
14	>= or ge 以上をテストする
15	&& or and 論理積をテストする
16	|| or or 論理ORをテストする
17	! or not 単項ブール補数
18	empty 空の変数値をテストします

JSPELの関数

JSP ELを使用すると、式で関数を使用することもできます。これらの関数は、カスタムタグライブラリで定義する必要があります。関数の使用法の構文は次のとおりです-

${ns:func(param1, param2, ...)}

どこ ns 関数の名前空間です。 func 関数の名前であり、 param1最初のパラメータ値です。たとえば、関数fn:length、JSTLライブラリの一部です。この関数は、文字列の長さを取得するために次のように使用できます。

${fn:length("Get my length")}

タグライブラリ（標準またはカスタム）の関数を使用するには、そのライブラリをサーバーにインストールし、を使用してライブラリをJSPに含める必要があります。 <taglib> JSTLの章で説明されているディレクティブ。

JSPEL暗黙オブジェクト

JSP式言語は、次の暗黙的なオブジェクトをサポートします-

S.No	暗黙のオブジェクトと説明
1	pageScope ページスコープからのスコープ変数
2	requestScope リクエストスコープからのスコープ変数
3	sessionScope セッションスコープからのスコープ変数
4	applicationScope アプリケーションスコープからのスコープ変数
5	param パラメータを文字列としてリクエストする
6	paramValues 文字列のコレクションとしてパラメータを要求する
7	header 文字列としてのHTTPリクエストヘッダー
8	headerValues 文字列のコレクションとしてのHTTPリクエストヘッダー
9	initParam コンテキスト初期化パラメータ
10	cookie クッキーの値
11	pageContext 現在のページのJSPPageContextオブジェクト

これらのオブジェクトは、変数であるかのように式で使用できます。以下の例は、概念を理解するのに役立ちます-

pageContextオブジェクト

pageContextオブジェクトを使用すると、pageContextJSPオブジェクトにアクセスできます。pageContextオブジェクトを介して、リクエストオブジェクトにアクセスできます。たとえば、リクエストの受信クエリ文字列にアクセスするには、次の式を使用できます-

${pageContext.request.queryString}

スコープオブジェクト

ザ・ pageScope, requestScope, sessionScope、および applicationScope 変数は、各スコープレベルに格納されている変数へのアクセスを提供します。

たとえば、アプリケーションスコープ内のボックス変数に明示的にアクセスする必要がある場合は、applicationScope変数を介して次のようにアクセスできます。 applicationScope.box。

paramおよびparamValuesオブジェクト

paramオブジェクトとparamValuesオブジェクトを使用すると、通常は request.getParameter そして request.getParameterValues メソッド。

たとえば、orderという名前のパラメータにアクセスするには、式を使用します ${param.order} または ${param["order"]}。

以下は、username −という名前のリクエストパラメータにアクセスする例です。

<%@ page import = "java.io.*,java.util.*" %>
<%String title = "Accessing Request Param";%>

<html>
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>${param["username"]}</p>
      </div>
   </body>
</html>

paramオブジェクトは単一の文字列値を返しますが、paramValuesオブジェクトは文字列配列を返します。

headerおよびheaderValuesオブジェクト

headerオブジェクトとheaderValuesオブジェクトを使用すると、通常は request.getHeader そしてその request.getHeaders メソッド。

たとえば、user-agentという名前のヘッダーにアクセスするには、式を使用します ${header.user-agent} または ${header["user-agent"]}。

以下は、user-agent-という名前のヘッダーパラメーターにアクセスする例です。

<%@ page import = "java.io.*,java.util.*" %>
<%String title = "User Agent Example";%>

<html>
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>${header["user-agent"]}</p>
      </div>
   </body>
</html>

出力は次のようになります-

User Agent Example

      
 
       
Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; HPNTDF; .NET4.0C; InfoPath.2)
 
      

ヘッダーオブジェクトは単一の文字列値を返しますが、headerValuesオブジェクトは文字列配列を返します。

この章では。JSPで例外を処理する方法について説明します。JSPコードを作成しているときに、コードの任意の部分で発生する可能性のあるコーディングエラーが発生する可能性があります。JSPコードで次のタイプのエラーが発生する可能性があります-

チェックされた例外

チェックされた例外は、通常、ユーザーエラーまたはプログラマーが予測できない問題である例外です。たとえば、ファイルを開く必要があるのにファイルが見つからない場合、例外が発生します。これらの例外は、コンパイル時に単純に無視することはできません。

ランタイム例外

ランタイム例外は、おそらくプログラマーが回避できたはずの例外です。チェックされた例外とは対照的に、実行時の例外はコンパイル時に無視されます。

エラー

これらはまったく例外ではありませんが、ユーザーまたはプログラマーの制御を超えて発生する問題です。エラーについてはほとんど何もできないため、エラーは通常、コードでは無視されます。たとえば、スタックオーバーフローが発生すると、エラーが発生します。また、コンパイル時には無視されます。

さらに、JSPコードで発生する実行時の例外/エラーを処理する方法について説明します。

例外オブジェクトの使用

例外オブジェクトは、Throwableのサブクラス（例：java.lang。NullPointerException）のインスタンスであり、エラーページでのみ使用できます。次の表に、Throwableクラスで使用できる重要なメソッドを示します。

S.No.	方法と説明
1	public String getMessage() 発生した例外に関する詳細メッセージを返します。このメッセージは、Throwableコンストラクターで初期化されます。
2	public Throwable getCause() Throwableオブジェクトで表される例外の原因を返します。
3	public String toString() 次の結果と連結されたクラスの名前を返します。 getMessage()。
4	public void printStackTrace() の結果を出力します toString() スタックトレースとともに System.err、エラー出力ストリーム。
5	public StackTraceElement [] getStackTrace() スタックトレース上の各要素を含む配列を返します。インデックス0の要素は呼び出しスタックの最上位を表し、配列の最後の要素は呼び出しスタックの最下部のメソッドを表します。
6	public Throwable fillInStackTrace() このThrowableオブジェクトのスタックトレースを現在のスタックトレースで埋め、スタックトレースの以前の情報に追加します。

JSPには、指定するオプションがあります Error Page各JSPに対して。ページが例外をスローするたびに、JSPコンテナは自動的にエラーページを呼び出します。

以下は、エラーページを指定する例です。 main.jsp。エラーページを設定するには、<%@ page errorPage = "xxx" %> 指令。

<%@ page errorPage = "ShowError.jsp" %>

<html>
   <head>
      <title>Error Handling Example</title>
   </head>
   
   <body>
      <%
         // Throw an exception to invoke the error page
         int x = 1;
         
         if (x == 1) {
            throw new RuntimeException("Error condition!!!");
         }
      %>
   </body>
</html>

ここで、以下に示す1つのエラー処理JSPShowError.jspを記述します。エラー処理ページにディレクティブが含まれていることに注意してください<%@ page isErrorPage = "true" %>。このディレクティブにより、JSPコンパイラは例外インスタンス変数を生成します。

<%@ page isErrorPage = "true" %>

<html>
   <head>
      <title>Show Error Page</title>
   </head>
   
   <body>
      <h1>Opps...</h1>
      <p>Sorry, an error occurred.</p>
      <p>Here is the exception stack trace: </p>
      <pre><% exception.printStackTrace(response.getWriter()); %></pre>
   </body>
</html>

アクセスする main.jsp、次のような出力が表示されます-

java.lang.RuntimeException: Error condition!!!
......

Opps...
Sorry, an error occurred.

Here is the exception stack trace:

エラーページにJSTLタグを使用する

JSTLタグを使用してエラーページを作成できます ShowError.jsp。このページのロジックは上記の例とほぼ同じですが、構造が改善され、情報が増えています。

<%@ taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>
<%@page isErrorPage = "true" %>

<html>
   <head>
      <title>Show Error Page</title>
   </head>
   
   <body>
      <h1>Opps...</h1>
      <table width = "100%" border = "1">
         <tr valign = "top">
            <td width = "40%"><b>Error:</b></td>
            <td>${pageContext.exception}</td>
         </tr>
            
         <tr valign = "top">
            <td><b>URI:</b></td>
            <td>${pageContext.errorData.requestURI}</td> </tr> <tr valign = "top"> <td><b>Status code:</b></td> <td>${pageContext.errorData.statusCode}</td>
         </tr>
            
         <tr valign = "top">
            <td><b>Stack trace:</b></td>
            <td>
               <c:forEach var = "trace" 
                  items = "${pageContext.exception.stackTrace}"> <p>${trace}</p>
               </c:forEach>
            </td>
         </tr>
      </table>

   </body>
</html>

main.jspにアクセスすると、以下が生成されます-

Opps...

      
 
       

        
 
         
Error:
 
         
java.lang.RuntimeException: Error condition!!!
 
        
 
        
 
         
URI:
 
         
/main.jsp
 
        
 
        
 
         
Status code:
 
         
500
 
        
 
        
 
         
Stack trace:
 
         
 
org.apache.jsp.main_jsp._jspService(main_jsp.java:65)
 
org.apache.jasper.runtime.HttpJspBase.service(HttpJspBase.java:68)
 
javax.servlet.http.HttpServlet.service(HttpServlet.java:722)
 
org.apache.jasper.servlet.JspServlet.service(JspServlet.java:265)
 
javax.servlet.http.HttpServlet.service(HttpServlet.java:722)
 
 
        
 
       
      

Try ... Catchブロックを使用する

同じページ内のエラーを処理し、エラーページを発生させる代わりに何らかのアクションを実行したい場合は、 try....catch ブロック。

以下は、try ... catchブロックの使用方法を示す簡単な例です。main.jspに次のコードを入れましょう−

<html>
   <head>
      <title>Try...Catch Example</title>
   </head>
   
   <body>
      <%
         try {
            int i = 1;
            i = i / 0;
            out.println("The answer is " + i);
         }
         catch (Exception e) {
            out.println("An exception occurred: " + e.getMessage());
         }
      %>
   </body>
</html>

main.jspにアクセスすると、次のような出力が生成されます。

An exception occurred: / by zero

この章では、JSPのデバッグについて説明します。JSPとサーブレットのテスト/デバッグは常に困難です。JSPとサーブレットは、クライアントとサーバーの相互作用を大量に伴う傾向があるため、エラーが発生する可能性は高くなりますが、再現するのは困難です。

以下は、デバッグに役立つ可能性のあるいくつかのヒントと提案です。

System.out.println（）の使用

System.out.println()特定のコードが実行されているかどうかをテストするためのマーカーとして簡単に使用できます。変数値も出力できます。次の追加のポイントを考慮してください-

• SystemオブジェクトはコアJavaオブジェクトの一部であるため、追加のクラスをインストールすることなく、どこでも使用できます。これもServlets, JSP, RMI, EJB's, ordinary Beans そして classes、および standalone applications。

• ブレークポイントで停止するのと比較して、 System.out アプリケーションの通常の実行フローにあまり干渉しないため、imingが重要な場合に非常に役立ちます。

使用する構文は次のとおりです System.out.println() −

System.out.println("Debugging message");

次の例は、使用方法を示しています System.out.print() −

<%@taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>

<html>
   <head><title>System.out.println</title></head>
   <body>
      <c:forEach var = "counter" begin = "1" end = "10" step = "1" >
      
         <c:out value = "${counter-5}"/></br>
         <% System.out.println( "counter = " + pageContext.findAttribute("counter") ); %>
      </c:forEach>
      
   </body>
</html>

上記のJSPにアクセスすると、ブラウザに次の結果が表示されます-

-4
-3
-2
-1
0
1
2
3
4
5

Tomcatを使用している場合は、これらの行が末尾に追加されています。 stdout.log ログディレクトリにあります。

counter = 1
counter = 2
counter = 3
counter = 4
counter = 5
counter = 6
counter = 7
counter = 8
counter = 9
counter = 10

このようにして、変数やその他の情報をシステムログに取り込み、分析して問題の根本原因やその他のさまざまな理由を見つけることができます。

JDBロガーの使用

ザ・ J2SEロギングフレームワークは、JVMで実行されているすべてのクラスにロギングサービスを提供するように設計されています。このフレームワークを利用して、あらゆる情報をログに記録できます。

JDKロガーAPIを使用して上記の例を書き直してみましょう-

<%@taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>
<%@page import = "java.util.logging.Logger" %>

<html>
   <head><title>Logger.info</title></head>
   
   <body>
      <% Logger logger = Logger.getLogger(this.getClass().getName());%>

      <c:forEach var = "counter" begin = "1" end = "10" step = "1" >
      <c:set var = "myCount" value = "${counter-5}" />
      <c:out value = "${myCount}"/></br>
         <% String message = "counter = "
            + pageContext.findAttribute("counter") + "myCount = "
            + pageContext.findAttribute("myCount");
            logger.info( message );
         %>
      </c:forEach>
      
   </body>
</html>

上記のコードは、ブラウザとstdout.logで同様の結果を生成しますが、追加情報があります。 stdout.log。を使用しますinfo情報提供のみを目的としてメッセージをログに記録するため、ロガーのメソッド。以下は、stdout.logファイルのスナップショットです-

24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 1 myCount = -4
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 2 myCount = -3
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 3 myCount = -2
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 4 myCount = -1
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 5 myCount = 0
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 6 myCount = 1
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 7 myCount = 2
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 8 myCount = 3
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 9 myCount = 4
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 10 myCount = 5

便利な機能を利用して、さまざまなレベルでメッセージを送信できます severe(), warning(), info(), config(), fine(), finer(), そして finest()。ここでは、finest（）メソッドを使用して最も細かい情報をログに記録し、severe（）メソッドを使用して重大な情報をログに記録できます。

Log4J Frameworkを使用して、重大度レベルと重要度に基づいてさまざまなファイルにメッセージを記録できます。

デバッグツール

NetBeansは、JSPおよびサーブレット仕様をサポートするスタンドアロンJavaアプリケーションおよびWebアプリケーションの開発をサポートし、JSPデバッガーも含む無料のオープンソースJava統合開発環境です。

NetBeansは、次の基本的なデバッグ機能をサポートしています。

• Breakpoints
• コードのステップスルー
• Watchpoints

あなたは参照することができます NetBeans documentation 上記のデバッグ機能を理解する。

JDBデバッガーの使用

同じものでJSPとサーブレットをデバッグできます jdb アプレットまたはアプリケーションのデバッグに使用するコマンド。

JSPまたはサーブレットをデバッグするには、デバッグできます sun.servlet.http.HttpServer次に、ブラウザからのHTTPリクエストに応答してHttpServerがJSP /サーブレットを実行する様子を観察します。これは、アプレットのデバッグ方法と非常によく似ています。違いは、アプレットの場合、デバッグされる実際のプログラムはsun.applet.AppletViewer。

ほとんどのデバッガーは、アプレットのデバッグ方法を自動的に認識することにより、この詳細を非表示にします。それらがJSPに対して同じことをするまで、次のことを考慮してデバッガーを支援する必要があります。

• デバッガーのクラスパスを設定します。これはあなたが見つけるのに役立ちますsun.servlet.http.Http-Server および関連するクラス。

• デバッガーのクラスパスを設定します。これは、通常、JSPとサポートクラスを見つけるのに役立ちますROOT\WEB-INF\classes。

適切なクラスパスを設定したら、デバッグを開始します sun.servlet.http.HttpServer。デバッグに関心のあるJSPにブレークポイントを設定してから、Webブラウザーを使用して、指定されたJSPのHttpServerに要求を行うことができます。(http://localhost:8080/JSPToDebug)。ここでの実行はブレークポイントで停止します。

コメントの使用

コード内のコメントは、さまざまな方法でデバッグプロセスに役立ちます。コメントは、デバッグプロセスで他の多くの方法で使用できます。

JSPはJavaコメントと single line (// ...) そして multiple line (/* ... */)コメントを使用して、Javaコードの一部を一時的に削除できます。バグが消えた場合は、コメントしたコードを詳しく調べて、問題を見つけてください。

クライアントとサーバーのヘッダー

JSPが期待どおりに動作しない場合は、生のHTTP要求と応答を確認すると便利な場合があります。HTTPの構造に精通している場合は、要求と応答を読んで、それらのヘッダーで何が起こっているかを正確に確認できます。

重要なデバッグのヒント

これは、JSPデバッグに関するその他のデバッグのヒントのリストです。

• 表示しているページの生のコンテンツを表示するようにブラウザに依頼します。これは、フォーマットの問題を特定するのに役立ちます。これは通常、[表示]メニューのオプションです。

• ページのフルリロードを強制して、ブラウザが前のリクエストの出力をキャッシュしていないことを確認してください。とNetscape Navigator、 使用する Shift-Reload; とInternet Explorer 使用する Shift-Refresh。

JavaServer Pagesとサーブレットは、アプリケーションを保護するためにWeb開発者が利用できるいくつかのメカニズムを提供します。リソースは、アプリケーションデプロイメント記述子でリソースを識別し、それらにロールを割り当てることによって宣言的に保護されます。

識別子とパスワードを使用した基本認証から証明書を使用した高度な認証まで、いくつかのレベルの認証を利用できます。

ロールベースの認証

サーブレット仕様の認証メカニズムは、 role-based security。ユーザーレベルでリソースを制限するのではなく、ロールを作成し、ロールごとにリソースを制限するという考え方です。

ファイルでさまざまな役割を定義できます tomcat-users.xml、confのTomcatのホームディレクトリの外にあります。このファイルの例を以下に示します-

<?xml version = '1.0' encoding = 'utf-8'?>
<tomcat-users>
   <role rolename = "tomcat"/>
   <role rolename = "role1"/>
   <role rolename = "manager"/>
   <role rolename = "admin"/>
   <user username = "tomcat" password = "tomcat" roles = "tomcat"/>
   <user username = "role1" password = "tomcat" roles = "role1"/>
   <user username = "both" password = "tomcat" roles = "tomcat,role1"/>
   <user username = "admin" password = "secret" roles = "admin,manager"/>
</tomcat-users>

このファイルは、間の単純なマッピングを定義します username, password、および role。特定のユーザーが複数の役割を持っている可能性があることに注意してください。例えば、username = "both" 「tomcat」ロールと「role1」ロールにあります。

さまざまな役割を識別して定義すると、役割ベースのセキュリティ制限をさまざまなWebアプリケーションリソースに適用できます。 <security-constraint> の要素 web.xml WEB-INFディレクトリで利用可能なファイル。

以下はweb.xmlのサンプルエントリです-

<web-app>
   ...
   <security-constraint>
      <web-resource-collection>
         <web-resource-name>SecuredBookSite</web-resource-name>
         <url-pattern>/secured/*</url-pattern>
         <http-method>GET</http-method>
         <http-method>POST</http-method>
      </web-resource-collection>
      
      <auth-constraint>
         <description>
            Let only managers use this app
         </description>
         <role-name>manager</role-name>
      </auth-constraint>
   </security-constraint>
   
   <security-role>
      <role-name>manager</role-name>
   </security-role>
   
   <login-config>
      <auth-method>BASIC</auth-method>
   </login-config>
   ...
</web-app>

上記のエントリは次のことを意味します-

• / secured / *と一致するURLへのHTTPGETまたはPOSTリクエストは、セキュリティ制限の対象となります。

• 管理者の役割を持つ人は、保護されたリソースへのアクセスを許可されます。

• ザ・ login-config 要素は、 BASIC 認証の形式。

を含む任意のURLを閲覧しようとすると /securityディレクトリの場合、ユーザー名とパスワードを尋ねる次のダイアログボックスが表示されます。ユーザーを提供する場合"admin" とパスワード "secret"、次に一致するURLにアクセスできます /secured/* このリソースへのアクセスを許可されるマネージャーロールを持つユーザー管理者を定義したためです。

フォームベース認証

FORM認証方式を使用する場合は、ユーザー名とパスワードの入力を求めるログインフォームを提供する必要があります。以下はの簡単なコードですlogin.jsp。これは、同じ目的のフォームを作成するのに役立ちます-

<html>
   <body bgcolor = "#ffffff">
      
      <form method = "POST" action ="j_security_check">
         <table border = "0">
            <tr>
               <td>Login</td>
               <td><input type = "text" name="j_username"></td>
            </tr>
            <tr>
               <td>Password</td>
               <td><input type = "password" name="j_password"></td>
            </tr>
         </table>
         <input type = "submit" value = "Login!">
      </form>
      
   </body>
</html>

ここでは、ログインフォームに次の名前のフォーム要素が含まれている必要があることを確認する必要があります j_username そして j_password。のアクション<form> タグは j_security_check。 POSTフォームメソッドとして使用する必要があります。同時に、変更する必要があります<login-config> auth-methodをFORM-として指定するタグ

<web-app>
   ...
   <security-constraint>
      <web-resource-collection>
         <web-resource-name>SecuredBookSite</web-resource-name>
         <url-pattern>/secured/*</url-pattern>
            <http-method>GET</http-method>
            <http-method>POST</http-method>
      </web-resource-collection>
      
      <auth-constraint>
         <description>Let only managers use this app</description>
         <role-name>manager</role-name>
      </auth-constraint>
   </security-constraint>
   
   <security-role>
      <role-name>manager</role-name>
   </security-role>
   
   <login-config>
      <auth-method>FORM</auth-method>
      <form-login-config>
         <form-login-page>/login.jsp</form-login-page>
         <form-error-page>/error.jsp</form-error-page>
      </form-login-config>
   </login-config>
   ...
</web-app>

今、あなたがで任意のリソースにアクセスしようとすると URL /secured/*、ユーザーIDとパスワードを尋ねる上記のフォームが表示されます。コンテナが「j_security_check「アクション、それは発信者を認証するためにいくつかの内部メカニズムを使用します。

ログインが成功し、呼び出し元が保護されたリソースへのアクセスを許可されている場合、コンテナーはsession-idを使用して、その時点以降の呼び出し元のログインセッションを識別します。コンテナは、セッションIDを含むCookieを使用してログインセッションを維持します。サーバーはCookieをクライアントに送り返します。呼び出し元がこのCookieを後続の要求で提示する限り、コンテナーは呼び出し元が誰であるかを認識します。

ログインが失敗した場合、サーバーはform-error-page設定で識別されるページを送り返します

ここに、 j_security_checkフォームベースのログインを使用するアプリケーションがログインフォームに指定する必要があるアクションです。同じ形式で、というテキスト入力コントロールも必要です。j_username と password input control と呼ばれる j_password。これが表示されている場合は、フォームに含まれている情報がサーバーに送信され、サーバーが名前とパスワードをチェックすることを意味します。これがどのように行われるかはサーバー固有です。

標準レルムの実装を確認して、その方法を理解してくださいj_security_check Tomcatコンテナで動作します。

サーブレット/ JSPのプログラムによるセキュリティ

ザ・ HttpServletRequest オブジェクトは、実行時にセキュリティ情報をマイニングするために使用できる次のメソッドを提供します-

S.No.	方法と説明
1	String getAuthType() ザ・ getAuthType() メソッドは、サーブレットを保護するために使用される認証スキームの名前を表すStringオブジェクトを返します。
2	boolean isUserInRole(java.lang.String role) ザ・ isUserInRole() メソッドはブール値を返します。ユーザーが指定されたロールに属している場合はtrue、そうでない場合はfalseです。
3	String getProtocol() ザ・ getProtocol()メソッドは、リクエストの送信に使用されたプロトコルを表すStringオブジェクトを返します。この値をチェックして、安全なプロトコルが使用されたかどうかを判断できます。
4	boolean isSecure() ザ・ isSecure()メソッドは、リクエストがHTTPSを使用して行われたかどうかを表すブール値を返します。trueの値は、そうであり、接続が安全であることを意味します。falseの値は、要求がそうではなかったことを意味します。
5	Principle getUserPrinciple() ザ・ getUserPrinciple() メソッドは、現在認証されているユーザーの名前を含むjava.security.Principleオブジェクトを返します。

たとえば、マネージャのページにリンクするJavaServer Pageの場合、次のコードがあります。

<% if (request.isUserInRole("manager")) { %>
   <a href = "managers/mgrreport.jsp">Manager Report</a>
   <a href = "managers/personnel.jsp">Personnel Records</a>
<% } %>

JSPまたはサーブレットでのユーザーの役割を確認することにより、Webページをカスタマイズして、ユーザーがアクセスできるアイテムのみを表示することができます。認証フォームに入力されたユーザーの名前が必要な場合は、getRemoteUser リクエストオブジェクトのメソッド。

この章では、JSPでの国際化の概念について説明します。先に進む前に、次の3つの重要な用語を理解しましょう。

• Internationalization (i18n) −これは、Webサイトが、訪問者の言語または国籍に翻訳されたさまざまなバージョンのコンテンツを提供できるようにすることを意味します。

• Localization (l10n) −これは、特定の地理的または文化的地域に適応するためにWebサイトにリソースを追加することを意味します。たとえば、Webサイトへのヒンディー語翻訳などです。

• locale−これは特定の文化的または地理的な地域です。これは通常、アンダースコアで区切られた国の記号が後に続く言語記号と呼ばれます。例えば、 "en_US"は米国の英語ロケールを表します。

グローバルなウェブサイトを構築する際に注意しなければならない項目がいくつかあります。このチュートリアルでは、これについて完全に詳しく説明することはできませんが、場所、つまりロケールを区別することにより、インターネットコミュニティにさまざまな言語でWebページを提供する方法の良い例を示します。

JSPは、リクエスターのロケールに基づいてサイトの適切なバージョンを取得し、現地の言語、文化、および要件に応じて適切なサイトバージョンを提供できます。以下は、ロケールオブジェクトを返すリクエストオブジェクトのメソッドです。

java.util.Locale request.getLocale()

ロケールの検出

以下は、検出に使用できる重要なロケールメソッドです。 requester's location, language そしてもちろん locale。以下のすべてのメソッドは、リクエスターのブラウザーで設定された国名と言語名を表示します。

S.No.	方法と説明
1	String getCountry() このメソッドは、このロケールの国/地域コードをISO 31662文字形式で大文字で返します。
2	String getDisplayCountry() このメソッドは、ユーザーに表示するのに適したロケールの国の名前を返します。
3	String getLanguage() このメソッドは、このロケールの言語コードを小文字でISO639形式で返します。
4	String getDisplayLanguage() このメソッドは、ユーザーへの表示に適したロケールの言語の名前を返します。
5	String getISO3Country() このメソッドは、このロケールの国の3文字の省略形を返します。
6	String getISO3Language() このメソッドは、このロケールの言語の3文字の省略形を返します。

例

次の例は、JSPでリクエストの言語と関連する国を表示する方法を示しています。

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>
<%
   //Get the client's Locale
   Locale locale = request.getLocale();
   String language = locale.getLanguage();
   String country = locale.getCountry();
%>

<html>
   <head>
      <title>Detecting Locale</title>
   </head>

   <body>
      <center>
         <h1>Detecting Locale</h1>
      </center>
      
      <p align = "center">
         <% 
            out.println("Language : " + language  + "<br />");
            out.println("Country  : " + country   + "<br />");
         %>
      </p>
   </body>
</html>

言語設定

JSPは、英語、スペイン語、ドイツ語、フランス語、イタリア語、オランダ語などの西ヨーロッパ言語で書かれたページを出力できます。ここでは、すべての文字を正しく表示するようにContent-Languageヘッダーを設定することが重要です。

もう1つの重要なポイントは、HTMLエンティティを使用してすべての特殊文字を表示することです。例えば、"&#241;" を表す "ñ"、および "&#161;" を表す "¡" 次のように-

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>

<%
   // Set response content type
   response.setContentType("text/html");
   
   // Set spanish language code.
   response.setHeader("Content-Language", "es");
   String title = "En Español";
%>

<html>
   <head>
      <title><%  out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><%  out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>En Español</p>
         <p>¡Hola Mundo!</p>
      </div>
   </body>
</html>

ロケール固有の日付

あなたは使用することができます java.text.DateFormat クラスとその静的 getDateTimeInstance( )ロケールに固有の日付と時刻をフォーマットする方法。以下は、特定のロケールに固有の日付をフォーマットする方法を示す例です-

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>
<%@ page import = "java.text.DateFormat,java.util.Date" %>

<%
   String title = "Locale Specific Dates";
   
   //Get the client's Locale
   Locale locale = request.getLocale( );
   
   String date = DateFormat.getDateTimeInstance(
      DateFormat.FULL, 
      DateFormat.SHORT, 
      locale).format(new Date( ));
%>

<html>
   
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>Local Date: <%  out.print(date); %></p>
      </div>
   </body>
</html>

ロケール固有の通貨

あなたは使用することができます java.txt.NumberFormat クラスとその静的 getCurrencyInstance( )ロケール固有の通貨で、long型やdouble型などの数値をフォーマットする方法。以下は、特定のロケールに固有の通貨をフォーマットする方法を示す例です-

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>
<%@ page import = "java.text.NumberFormat,java.util.Date" %>

<%
   String title = "Locale Specific Currency";
   
   //Get the client's Locale
   Locale locale = request.getLocale( );
   
   NumberFormat nft = NumberFormat.getCurrencyInstance(locale);
   String formattedCurr = nft.format(1000000);
%>

<html>
   
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>Formatted Currency: <%  out.print(formattedCurr); %></p>
      </div>
   </body>
</html>

ロケール固有のパーセンテージ

あなたは使用することができます java.txt.NumberFormat クラスとその静的 getPercentInstance( )ロケール固有のパーセンテージを取得するメソッド。次の例は、特定のロケールに固有のパーセンテージをフォーマットする方法を示しています-

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>
<%@ page import = "java.text.NumberFormat,java.util.Date" %>

<%
   String title = "Locale Specific Percentage";
   
   //Get the client's Locale
   Locale locale = request.getLocale( );
   
   NumberFormat nft = NumberFormat.getPercentInstance(locale);
   String formattedPerc = nft.format(0.51);
%>

<html>
   
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>Formatted Percentage: <%  out.print(formattedPerc); %></p>
      </div>
   </body>
</html>