BeginnersBook-JSP-教程-一-

BeginnersBook JSP 教程（一）

原文：BeginnersBook

协议：CC BY-NC-SA 4.0

{% raw %}

JSP Scriptlets

原文： https://beginnersbook.com/2013/05/jsp-tutorial-scriptlets/

Scriptlet 只是包含在<%和%>标签中的 java 代码。 JSP 容器将 JSP 中包含的语句移动到_jspService()方法，同时从 JSP 生成 Servlet。将此代码复制到服务方法的原因是：对于每个客户端的请求，调用_jspService()方法，因此其中的代码将针对客户端发出的每个请求执行。

Scriptlet 的语法：

<% 可执行的 java 代码 %>

JSP 到 Scriptlet 的 Servlet 转换：

正如我在之前的教程中所述，JSP 没有直接执行，它首先被转换为 Servlet，然后 Servlet 执行正常。另外，我在第一段中解释说，从 JSP 到 servlet 的转换，java 代码从 scriptlet 复制到_jspService()方法。让我们看看这是怎么回事。

示例 JSP 代码：

<H3> Sample JSP </H3>
<% myMethod();%>

注意：分号在 scriptlet 的末尾。

上述 JSP 代码的相应翻译 Servlet 代码：

public void _jspService(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
    response.setContentType("text/html");
    HttpSession session = request.getSession();
    JspWriter out = response.getWriter();
    out.println("<H2>Sample JSP</H2>");
    myMethod();
}

了解脚本元素的一个例子：

```html`
<%– A jsp example to learn the JSP scripting elements–%>
<%String string1 ="JSP scriptlet";%>
<%!String string2 ="";%>

JSP page: Welcome

<%–This is an Expression statement–%> Welcome to <%=string1%>

<%–sciptlet example–%>
<%if(localstring.equals("JSP scriptlet")){%>
Hi
<%}

else {%>
hello
<%} %>

<%–same thing can be done in this way also–%>
<%if(localstring.equals("JSP scriptlet"))
out.println("Hi"+string2);
else
out.println("hello");
%>

```

在上面的示例中，存在许多类型的 JSP 元素，例如表达式，JSP 注释，元素声明等。我们将在即将到来的 JSP 教程中看到它们中的每一个，但是到目前为止，您只能关注 Scriptlet。以下是上例中使用的 scriptlets 语句：

<%if(localstring.equals("JSP scriptlet"))
out.println("Hi"+string2);
else
out.println("hello");
%>

上面的代码是一个 JSP scriptlet（注意开始<%和结束%>标签）。如果您分析上面的代码，那么您会发现标签内的代码是纯 Java 代码，因此为了在 JSP 中执行 Java 代码，我们使用 scriptlet。

<%String string1 ="JSP scriptlet";%>

像上面的语句一样，这个语句是一个 java 初始化代码，它包含在标签中。

除了上面两组 scriptlet 之外，上面的例子中还有许多其他的 scriptlet 标签（注意if-else控制流逻辑）。要使用 java 的if-else控制流语句，我们在上面的示例中使用了 scriptlet。因为这是使用 scriptlet 的主要优点所以让我们借助一个例子让它更清晰 - 你必须知道我们的If-else控制语句有多重要。

使用 scriptlet 显示if-else的使用示例：

假设有一个变量num并且你想在你的网页上显示"hi"，如果它大于 5，否则你想要显示一条消息。考虑下面这个场景的代码：
如果你想在 java 中为上述情况编写一个代码，那么它看起来像这样：

if (num > 5) {
    out.println("hi");  
} else {
    out.println("num value should not be less than 6");
}

要在 JSP 中编写类似的代码，我们需要使用 JSP scriptlet - 代码就像这样：

<! DOCTYPE HTML PUBLIC "-//W3C//DTD HTML4.0 translation //EN">
<HTML>
<HEAD>
<TITLE> MY JSP PAGE </TITLE>
</HEAD>
<BODY>
<% if (num > 5) { %>
<H3> hi </H3>
<%} else {%>
<h3> num value should not be less than 6 </h3>
<% } %>
</BODY>
</HTML>

重要的一点要记住：由于里面的代码是 java 代码，必须以分号（;）结尾。现在注意所有的语句 - 你可能会发现很少的 scriptlet，我们在 java 中给分号，在这里也需要它，并以分号结束。

{% endraw %}

动作标签

JSP 动作

原文： https://beginnersbook.com/2013/06/jsp-tutorial-actions/

JSP 动作允许您执行某些动作。

指令与动作

在转换阶段使用指令，而在请求处理阶段使用动作。
与指令不同，每次访问页面时都会重新评估动作。

以下是 JSP 中使用的动作元素：

1. `<jsp:include>`动作

与include页面指令类似，此动作也用于在另一个文件中插入 JSP 文件。

<jsp:include> vs include指令：

它与我在文章开头提到的相同（指令与动作）有所不同。在<jsp:include>中在请求处理期间包含该文件，而在include指令的情况下，它已包含在转换阶段。

<jsp:include>的语法：

<jsp:include page="page URL"  flush="Boolean Value" />

这里的页面 URL 是：需要包含页面的位置，刷新值可以是true或false（布尔值）。

示例：

<html>
<head>
<title>Demo of JSP include Action Tag</title>
</head>
<body>
<h3>JSP page: Demo Include</h3>
<jsp:include page="sample.jsp" flush="false" />
</body>
</html>

page：页面值是sample.jsp，这意味着这是页面需要包含在当前文件中。只是提到的文件名显示sample.jsp在同一目录中。
flush：其值为false，表示资源缓冲区在包含到当前页面之前尚未刷新。

阅读更多： jsp include动作标签。

2. `<jsp:forward>`动作

<jsp:forward>用于重定向请求。在 JSP 页面上遇到此动作时，控件将转移到此动作中提到的页面。

<jsp:forward>的语法：

<jsp:forward page="URL of the another static, JSP OR Servlet page" />

例：

first.jsp

<html>
<head>
<title>Demo of JSP Forward Action Tag</title>
</head>
<body>
<h3>JSP page: Demo forward</h3>
<jsp:forward page="second.jsp" />
</body>
</html>

现在当 JSP 引擎执行first.jsp（上面的代码）然后在动作标签之后，请求将被转移到另一个 JSP 页面（second.jsp）。
注意：first.jsp和second.jsp 应该在同一个目录中，否则你必须指定second.jsp的完整路径。

阅读更多： JSP forward动作标签。

3. `<jsp:param>`动作

此动作对于将参数传递给其他 JSP 动作标签非常有用，例如 JSP include和 JSP 转发标签。这样，新的 JSP 页面可以使用请求对象本身访问这些参数。

<jsp:param>的语法：

<jsp: param name="param_name_here" value="value_of_parameter_here" />

现在考虑上面的例子：

first.jsp

<html>
<head>
<title>Demo of JSP Param Action Tag</title>
</head>
<body>
<h3>JSP page: Demo Param along with forward</h3>
<jsp:forward page="second.jsp">
    <jsp:param name ="date" value="20-05-2012" />
    <jsp:param name ="time" value="10:15AM" />
    <jsp:param name ="data" value="ABC" />
</jsp:forward>
</body>
</html>

在上面的例子中，first.jsp将三个参数（data，time和data）传递给second.jsp，second.jsp可以使用下面的代码访问这些参数：

Date:<%= request.getParameter("date") %>
Time:<%= request.getParameter("time") %>
My Data:<%= request.getParameter("data") %>

4. `<jsp:useBean>`动作

在这里阅读更多内容 - <jsp:useBean>，<jsp:setProperty>和<jsp:getProperty>西细节。

当您想在 JSP 页面中使用 Beans 时，此动作很有用，通过此标签可以轻松调用 bean。

<jsp:useBean>的语法：

<jsp: useBean id="unique_name_to_identify_bean"  class="package_name.class_name" />

<jsp:useBean>，<jsp:setProperty>和<jsp:getProperty>示例：

一旦使用上面的语句实例化 Bean 类，就必须使用<jsp:setProperty>和<jsp:getProperty>动作来使用 bean 的参数。我们将在此动作标签后看到setProperty和getProperty。

EmployeeBeanTest.jsp

<html>
    <head>
        <title>JSP Page to show use of useBean action</title>
    </head>
    <body>
       <h1>Demo: Action</h1>
       <jsp:useBean id="student" class="javabeansample.StuBean"/>
       <jsp:setProperty name="student" property="*"/>
       <h1>
          name:<jsp:getProperty name="student" property="name"/><br>
          empno:<jsp:getProperty name="student" property="rollno"/><br>
       </h1>
    </body>
</html>

StudentBean.java

package javabeansample;
public class StuBean {
    public StuBean() {
    }
    private String name;
    private int rollno;
    public void setName(String name)
    {
       this.name=name;
     }
    public String getName()
    {
       return name;
     }
    public void setRollno(int rollno)
    {
       this.rollno=rollno;
     }
    public int getRollno()
    {
        return rollno;
    }
}

5. `<jsp:setProperty>`动作

此动作标签用于设置 Bean 的属性，在使用此动作标签时，您可能需要指定 Bean 的唯一名称（它只是useBean动作标签的id值）。

<jsp:setProperty>的语法

<jsp: useBean id="unique_name_to_identify_bean"  class="package_name.class_name" />
....
....
<jsp:setProperty name="unique_name_to_identify_bean" property="property_name" />

或者

<jsp: useBean id="unique_name_to_identify_bean"  class="package_name.class_name">
....
....
<jsp:setProperty name="unique_name_to_identify_bean" property="property_name" />
</jsp:useBean>

在property_name中，您还可以使用'*'，这意味着任何与 Bean 的属性匹配的请求参数都将传递给相应的设置器方法。

6. `<jsp:getProperty>`动作

它用于检索或获取 Bean 属性的值。

<jsp:getProperty>的语法

<jsp: useBean id="unique_name_to_identify_bean"  class="package_name.class_name" />
....
....
<jsp:getProperty name="unique_name_to_identify_bean" property="property_name" />

或者

<jsp: useBean id="unique_name_to_identify_bean"  class="package_name.class_name">
....
....
<jsp:getProperty name="unique_name_to_identify_bean" property="property_name" />
</jsp:useBean>

其他动作标签

以下动作标签不经常使用，所以我没有详细介绍它们。

7. `<jsp:plugin>`动作

当需要插件来运行 Bean 类或 Applet 时，使用此标签。

http://docs.oracle.com/javase/7/docs/technotes/guides/plugin/developer_guide/jsp.html

8. `<jsp:body>`动作

9. `<jsp:element>`动作

10. `<jsp:text>`动作

11. `<jsp:attribute>`动作

JSP `include`动作标签

原文： https://beginnersbook.com/2013/11/jsp-include-action-tag/

Include动作标签用于将另一个资源包含到当前 JSP 页面。包含的资源可以是 HTML，JSP 页面或 Servlet 中的静态页面。我们还可以将参数及其值传递给我们所包含的资源。下面我分享了两个<jsp:include>的示例，其中一个包含一个页面而没有传递任何参数，在第二个示例中，我们将几个参数传递给正在包含的页面。

语法：

1）包含参数。

<jsp:include page="Relative_URL_Of_Page"> 
<jsp:param ... /> 
<jsp:param ... /> 
<jsp:param ... /> 
...
<jsp:param ... /> 
</jsp:include>

2）包含另一个没有共享参数的资源。

<jsp:include page="Relative_URL_of_Page" />

如果页面位于当前 JSP 所在的同一目录中，Relative_URL_of_Page将是页面名称。

示例 1：没有参数的`<jsp:include>`

在这个例子中，我们将使用没有参数的<jsp:include>动作标签。因此，页面将包含在当前 JSP 页面中：

index.jsp

<html> 
<head>
<title>JSP Include example</title>
</head>
<body> 
<b>index.jsp Page</b><br>
<jsp:include page="Page2.jsp" /> 
</body> 
</html>

Page2.jsp

<b>Page2.jsp</b><br>
<i> This is the content of Page2.jsp page</i>

输出：

Page2.jsp的内容已附加在index.jsp中。

示例 2：使用`<jsp:include>`以及`<jsp:param>`

index.jsp

我正在使用<jsp:include>和<jsp:param>动作，将参数传递给我们将要包含的页面。

<html> 
<head>
<title>JSP Include example with parameters</title>
</head>
<body> 
<h2>This is index.jsp Page</h2>
<jsp:include page="display.jsp"> 
<jsp:param name="userid" value="Chaitanya" /> 
<jsp:param name="password" value="Chaitanya" /> 
<jsp:param name="name" value="Chaitanya Pratap Singh" /> 
<jsp:param name="age" value="27" /> 
</jsp:include> 
</body> 
</html>

display.jsp

<html>
<head>
<title>Display Page</title>
</head>
<body>
<h2>Hello this is a display.jsp Page</h2>
UserID: <%=request.getParameter("userid") %><br>
Password is: <%=request.getParameter("password") %><br>
User Name: <%=request.getParameter("name") %><br>
Age: <%=request.getParameter("age") %>
</body>
</html>

输出：

正如您所看到的，display.jsp的内容已包含在index.jsp中。此外，我们传递的参数正在包含的页面中正确显示。

如果您对该主题有任何疑问和疑问，请告诉我们。我们很乐意帮助您！！

JSP 带参数的`include`动作

原文： https://beginnersbook.com/2013/12/jsp-include-with-parameter-example/

之前我们已经分享了如何使用include指令和 include动作标签将页面包含到另一个 JSP 页面。我们还讨论了include指令和include动作标签之间的区别
。在这篇文章中，我们将看到如何在使用 jsp include动作标签（<jsp:include>）时将参数传递给包含的页面。为了传递参数，我们需要使用<jsp:param>动作标签。

例

在这个例子中，我们使用jsp:include动作标签将 JSP 页面（file.jsp）包含到主 JSP 页面（index.jsp）中。要将参数从索引传递到文件页面，我们使用jsp:param动作标签。我们传递了三个参数firstname，middlename和lastname`，对于每个参数我们需要指定相应的参数名称和参数值。我们可以使用表达式语言或表达式标签和隐含的对象。

index.jsp

<html>
<head>
<title>JSP include with parameters example</title>
</head>
<body>
<jsp:include page="file.jsp" >
  <jsp:param name="firstname" value="Chaitanya" />
  <jsp:param name="middlename" value="Pratap" />
  <jsp:param name="lastname" value="Singh" />
</jsp:include>
</body>
</html>

file.jsp

${param.firstname}<br>
${param.middlename}<br>
${param.lastname}

输出：

如您所见，包含的页面显示了从主页面传递的参数值。为了在 file.jsp页面上显示参数，我们使用了表达式语言（${}）。但是，您也可以使用以下代码，该代码使用 JSP 表达式标签和request隐式对象。

<%= request.getParameter("firstname")%>
<%= request.getParameter("middlename")%>
<%= request.getParameter("lastname")%>

这就是我们对这个话题的全部看法。在接下来的文章中，我们将讨论如何使用include指令将参数及其值传递到另一个页面。同时，如果您有任何疑问，请在下面的评论部分中提出相同的问题。

JSP `forward`动作标签

原文： https://beginnersbook.com/2013/11/jsp-forward-action-tag/

JSP forward动作标签用于将请求转发到另一个资源（它可以是 JSP，静态页面，如 HTML 或 Servlet）。可以使用或不使用参数转发请求。在本教程中，我们将看到<jsp:forward>的示例。动作标签。

语法：

1）带参数的转发。

<jsp:forward page="display.jsp"> 
<jsp:param ... /> 
<jsp:param ... /> 
<jsp:param ... /> 
...
<jsp:param ... /> 
</jsp:forward>

2）没有参数的转发。

<jsp:forward page="Relative_URL_of_Page" />

Relative_URL_of_Page：如果页面位于主页面所在的同一目录中，则使用页面名称本身，就像我在下面的示例中所做的那样。

JSP 转发示例 1 - 不传递参数

在这个例子中，我们有两个 JSP 页面 - index.jsp和display.jsp。我们使用了index.jsp中的动作标签<jsp:forward>，用于将请求转发给display.jsp。这里我们在使用动作标签时没有传递任何参数。在下一个示例中，我们还将参数传递给另一个资源。

index.jsp

<html> 
<head>
<title>JSP forward action tag example</title>
</head>
<body> 
<p align="center">My main JSP page</p>
<jsp:forward page="display.jsp" /> 
</body> 
</html>

display.jsp

<html>
<head>
<title>Display Page</title>
</head>
<body>
Hello this is a display.jsp Page
</body>
</html>

输出：

下面是上面代码的输出。它基本上是display.jsp的内容，它清楚地表明index.jsp在将请求转发到display.jsp页面时没有显示。

JSP 转发示例 2 - 带参数

这里我们传递参数和前向请求。对于传递参数，我们使用jsp:param动作标签。在这个例子中，我们传递了 4 个参数并转发，后来我们在转发的页面上显示它们。为了获取display.jsp页面上的参数，我们使用[request隐式对象](https://beginnersbook.com/2013/11/jsp-implicit-object-request-with-examples/)的getParameter`方法。

index.jsp

<html> 
<head>
<title>JSP forward example with parameters</title>
</head>
<body> 
<jsp:forward page="display.jsp"> 
<jsp:param name="name" value="Chaitanya" /> 
<jsp:param name="site" value="BeginnersBook.com" /> 
<jsp:param name="tutorialname" value="jsp forward action" /> 
<jsp:param name="reqcamefrom" value="index.jsp" /> 
</jsp:forward> 
</body> 
</html>

display.jsp

<html>
<head>
<title>Display Page</title>
</head>
<body>
<h2>Hello this is a display.jsp Page</h2>
My name is: <%=request.getParameter("name") %><br>
Website: <%=request.getParameter("site") %><br>
Topic: <%=request.getParameter("tutorialname") %><br>
Forward Request came from the page: <%=request.getParameter("reqcamefrom") %>
</body>
</html>

输出：

上面的代码直接显示了display.jsp页面，它显示了从index.jsp页面传递的参数。

`jsp:useBean`，`jsp:setProperty`和`jsp:getProperty`动作标签

原文： https://beginnersbook.com/2013/11/jsp-usebean-setproperty-getproperty-action-tags/

在本教程中，我们将看到如何在jsp:useBean，jsp:setProperty和jsp:getProperty动作标签的帮助下在 JSP 中使用 bean 类。

jsp:useBean语法：

<jsp: useBean id="unique_name_to_identify_bean" 
class="package_name.class_name" />

jsp:setProperty的语法：

<jsp:setProperty name="unique_name_to_identify_bean" 
property="property_name" />

jsp:getProperty的语法：

<jsp:getProperty name="unique_name_to_identify_bean" 
property="property_name" />

`useBean`，`setProperty`和`getProperty`的完整示例

1）我们有一个 bean 类详细信息，我们有三个变量用户名，年龄和密码。为了在 JSP 中使用 bean 类及其属性，我们在userdetails.jsp页面中初始化了这样的类：

<jsp:useBean id="userinfo" class="beginnersbook.com.Details"></jsp:useBean>

我们使用了useBean动作来初始化类。我们的类在beginnersbook.com包中，所以我们给了一个完全限定的名字beginnersbook.com.Details。

2）我们使用setProperty动作标签映射了 bean 类和 JSP 的属性。我们在属性字段中给出'*'来根据它们的名称映射值，因为我们在 bean 类和index.jsp JSP 页面中使用了相同的属性名称。在name字段中，我们给出了我们在useBean标签中定义的唯一标识符。

<jsp:setProperty property="*" name="userinfo"/>

3）要获取属性值，我们使用了getProperty动作标签。

<jsp:getProperty property="propertyname" name="userinfo"/>

Details.java

package beginnersbook.com;
public class Details {
	public Details() {
    }
    private String username;
    private int age;
    private String password;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}

}

index.jsp

<html>
<head><title>
useBean, getProperty and setProperty example
</title></head>
<form action="userdetails.jsp" method="post"> 
User Name: <input type="text" name="username"><br> 
User Password: <input type="password" name="password"><br> 
User Age: <input type="text" name="age"><br> 
<input type="submit" value="register"> 
</form> 
</html>

userdetails.jsp

<jsp:useBean id="userinfo" class="beginnersbook.com.Details"></jsp:useBean> 
<jsp:setProperty property="*" name="userinfo"/> 
You have enterted below details:<br> 
<jsp:getProperty property="username" name="userinfo"/><br> 
<jsp:getProperty property="password" name="userinfo"/><br> 
<jsp:getProperty property="age" name="userinfo" /><br>

输出：

表达式

JSP 表达式标签

原文： https://beginnersbook.com/2013/11/jsp-expression-tag/

表达式标签评估放置在其中的表达式，将结果转换为String并通过response对象将结果发送回客户端。基本上它将结果写入客户端（浏览器）。

JSP 中表达式标签的语法：

<%= expression %>

JSP 表达式标签示例

例 1：值的表达式

这里我们只是在表达式标签内传递值的表达式。

<html>
 <head>
   <title>JSP expression tag example1</title>
 </head>
 <body>
   <%= 2+4*5 %>
 </body>
 </html>

输出：

例 2：变量的表达式

在这个例子中，我们初始化了几个变量，并在表达式标签中传递变量表达式以进行结果评估。

<html>
<head>
   <title>JSP expression tag example2</title>
</head>
<body>
  <%
  int a=10;
  int b=20;
  int c=30;
  %>
  <%= a+b+c %>
</body>
</html>

输出：

示例 3：字符串和隐式对象输出

在此示例中，我们使用application隐式对象设置属性，然后使用表达式标签在另一个 JSP 页面上显示该属性和一个简单字符串。

index.jsp

<html>
<head>
<title> JSP expression tag example3 </title>
</head>
<body>
  <% application.setAttribute("MyName", "Chaitanya"); %>
  <a href="display.jsp">Click here for display</a>
</body>
</html>

display.jsp

<html>
<head>
<title>Display Page</title>
</head>
<body>
 <%="This is a String" %><br>
 <%= application.getAttribute("MyName") %>
</body>
</html>

输出：

声明

概述

JSP 声明标签

原文： https://beginnersbook.com/2013/11/jsp-declaration-tag/

声明标签是用于声明类级变量，方法和类的 java 代码块。这些标签内的任何内容都会在 JSP 初始化阶段初始化并具有类范围。 JSP 容器将此代码保留在服务方法（_jspService()）之外，以使它们成为类级变量和方法。

我们知道变量也可以使用 scriptlet 进行初始化，但这些声明放在_jspService()方法中，而不会使它们成为类范围的声明。另一方面，声明标签可用于定义类级变量，方法和类。

声明标签语法：

<%!  Declaration %>

示例 1：变量声明

在此示例中，我们在声明标签内声明了两个变量，并使用表达式标签在客户端上显示它们。

<html> 
<head>
 <title>Declaration tag Example1</title>
</head>
<body> 
<%! String name="Chaitanya"; %> 
<%! int age=27; %> 
<%= "Name is: "+ name %><br>
<%= "AGE: "+ age %> 
</body> 
</html>

输出：

例 2：方法声明

在这个例子中，我们使用 JSP 声明标签声明了一个方法sum。

<html> 
<head>
 <title>Methods Declaration</title>
</head>
<body> 
  <%! 
  int sum(int num1, int num2, int num3){ 
  return num1+num2+num3; 
  } 
  %> 

  <%= "Result is: " + sum(10,40,50) %> 
</body> 
</html>

输出：

所有三个整数的总和将显示在浏览器上。

如果你有任何疑问，请告诉我们。

JSP 隐式对象

Jsp 隐式对象

原文： https://beginnersbook.com/2013/11/jsp-implicit-objects/

这些对象由 JSP 引擎在转换阶段（将 JSP 转换为 Servlet 时）创建。它们是在服务方法中创建的，因此我们可以直接在 Scriptlet 中使用它们，而无需初始化和声明它们。 JSP 中总共有 9 个隐式对象。

隐式对象及其对应的类：


`out`	`javax.servlet.jsp.JspWriter`
`request`	`javax.servlet.http.HttpServletRequest`
`response`	javax.servlet.http.HttpServletResponse`
`session`	`javax.servlet.http.HttpSession`
`application`	`javax.servlet.ServletContext`
`exception`	`javax.servlet.jsp.JspException`
`page`	继承`java.lang.Object`
`pageContext`	`javax.servlet.jsp.PageContext`
`config`	`javax.servlet.ServletConfig`

out：用于将内容写入客户端（浏览器）。它有几种方法可用于正确格式化输出消息到浏览器和处理缓冲区。
在这里阅读全文：out隐式对象的例子。
request：request隐式对象的主要目的是获取用户在之前的 JSP 页面上输入的 JSP 页面上的数据。在 JSP 中处理登录和注册表单时，我们经常提示用户填写这些详细信息，然后使用此对象在另一个 JSP 页面（操作页面）上获取这些输入的详细信息，以进行验证和其他目的。
在这里阅读全文»使用示例request隐式对象。
response：它主要用于修改或延迟处理请求后发送给客户端（浏览器）的响应。
在这里阅读全文：response隐式对象与示例。
session：它是最常用的隐式对象，用于存储用户的数据，使其在其他 JSP 页面上可用，直到用户会话处于活动状态。
阅读全文：session隐式对象与示例。
application：这用于获取应用范围的初始化参数并在整个 JSP 应用中维护有用的数据。
在这里阅读全文：application隐式对象的例子。
exception：exception隐式对象用于异常处理以显示错误消息。此对象仅适用于将isErrorPage设置为true的 JSP 页面。
在这里阅读全文：exception隐式对象与示例。
page：page隐式对象是对当前Servlet实例的引用（转换后的 Servlet，在 JSP 页面的转换阶段生成）。我们可以简单地使用this来代替它。我没有详细介绍它，因为它很少使用，而且在构建 JSP 应用时不是一个有用的隐式对象。
pageContext：用于访问页面，请求，应用和会话属性。
在这里阅读全文：pageContext隐式对象与示例。
config：这是一个 Servlet 配置对象，主要用于访问获取配置信息，如 Servlet 上下文，Servlet 名称，配置参数等。
阅读全文：config隐式对象示例。

JSP 中的`out`隐式对象

原文： https://beginnersbook.com/2013/11/jsp-implicit-object-out-with-examples/

它是javax.servlet.jsp.JspWriter的一个实例。这允许我们访问 Servlet 输出流。需要发送到客户端（浏览器）的输出通过此对象传递。简单来说，使用隐式对象将内容写入客户端。

`out`隐式对象的方法

void print()
void println()
void newLine()
void clear()
void clearBuffer()
void flush()
boolean isAutoFlush()
int getBufferSize()
int getRemaining()

让我们详细看看每个方法：

void print()：此方法写入已传递给它的值。对于例如下面的语句将在 jSP 中显示一个句子Out Implicit Object in jSP - BeginnersBook到输出屏幕（客户端浏览器）。
```
    out.print(“Out Implicit Object in jSP - BeginnersBook”);
```
void println()：此方法类似于print()方法，print和println之间的唯一区别是println()方法在末尾添加了新行字符。让我们借助示例来了解差异。
print：
```
    out.print(“hi”);
    out.print(" ");
    out.print(“hello”);
```
浏览器输出：所有 3 个out.print语句的结果之间不会有新的界限。
```
hi hello
```
println：
```
    out.println(“hi”);
    out.println(“hello”);
```
浏览器输出：
```
hi
hello
```

void newLine()：此方法将新行添加到输出。示例 –

    out.print(“This will write content without a new line”);
    out.newLine();
    out.print(“I’m just an another print statement”);

输出：

This will write content without a new line
I’m just an another print statement

如您所知，print语句不会添加新行。我们使用newLine()方法在两个out.print语句之间添加了一个新行。

void clear()：它清除输出缓冲区，甚至不让它将缓冲区内容写入客户端。这就是它的名称：
```
    out.clear();
```
void clearBuffer()：此方法类似于clear()方法。它们之间的唯一区别是，当我们在已经刷新的缓冲区上调用out.clear()时会抛出异常，但out.clearBuffer()却没有。
void flush()：这个方法也像clear()方法一样清除缓冲区但强制它在刷新之前将内容写入输出，这意味着缓冲区中的任何内容都会被写入清除缓冲区之前的客户端屏幕。
boolean isAutoFlush()：返回布尔值true/false。它用于检查缓冲区是否自动刷新。
int getBufferSize()：此方法以字节为单位返回输出缓冲区的大小。
int getRemaining()：它返回在达到缓冲区溢出条件之前剩余的字节数。

`out`隐式对象示例

在这个例子中，我们使用out的print和println方法向客户端显示少量消息。

index.jsp

<HTML>
<HEAD> 
<TITLE> OUT IMPLICIT OBJECT EXAMPLE </TITLE>
</HEAD>
<BODY>
<%
out.print( "print statement " );
out.println( "println" );
out.print("Another print statement");
%>
</BODY>
</HTML>

输出：

print statement println
Another print statement

JSP 中的`request`隐式对象

原文： https://beginnersbook.com/2013/11/jsp-implicit-object-request-with-examples/

这里我们将讨论 JSP 中的request隐式对象。它主要用于获取用户在之前的 JSP 页面上输入的 JSP 页面上的数据。

`request`隐式对象的方法

getParameter(String name) - 此方法用于获取请求参数的值。例如，在登录页面，用户输入用户 ID 和密码，一旦验证了凭证，登录页面就会被重定向到用户信息页面，然后使用request.getParameter我们可以获得用户在登录页面输入的用户 ID 和密码的值。
```
       String Uid= request.getParameter("user-id");
       String Pass= request.getParameter("password");
```
getParameterNames() - 它返回与请求关联的所有参数名称的枚举。
```
       Enumeration e= request.getParameterNames();
```

`getParameterValues(String name) - 它返回参数值数组。

       String[] allpasswords = request.getParameterValues("password");

getAttribute(String name) - 用于获取属性值。request.getAttribute("admin")将为您提供属性admin的值。
getAttributeNames() - 它通常用于获取与当前会话关联的属性名称。它返回会话中存在的属性名称的枚举。
```
       Enumerator e = request.getAttributeNames();
```
setAttribute(String, Object) - 它将一个对象的值赋给该属性。例如，我有一个属性password和一个String对象str，其值为"admin"然后调用request.setAttribute("password", str)将赋值admin到属性password。
removeAttribute(String) - 通过使用此方法，可以删除属性，不能进一步使用。对于例如如果在 JSP 页面上有声明request.removeAttribute("userid")，那么userid属性将被完全删除，而在removeAttribute方法之后使用request.getAttribute("userid")将返回 NULL 。
getCookies() - 它返回从客户端收到的 cookie 对象数组。此方法主要用于处理 JSP 中的 cookie。
getHeader(String name) - 此方法用于获取请求的头信息。
getHeaderNames() - 返回所有标题名称的枚举。下面的代码片段将显示与请求关联的所有标头名称。

```html
        Enumeration e = request.getHeaderNames();
             while (enumeration.hasMoreElements()) {
                 String str = (String)e.nextElement();
                 out.println(str);
             }
```

getRequestURI() - 此方法（request.getRequestURI()）返回当前 JSP 页面的 URL。
getMethod() - 它返回 HTTP 请求方法。request.getMethod()。例如，它将为Get请求返回GET，为Post请求返回POST。
getQueryString() - 用于获取与 JSP 页面 URL 关联的查询字符串。它是在问号符号（?）后与 URL 相关联的字符串。

`request`隐式对象示例

在下面的示例中，我们在index.html页面中接收来自用户的输入，并使用request隐式对象在userinfo.jsp页面中显示相同的信息。

index.html

<html>
<head>
<title>Enter UserName and Password</title>
</head>
<body>
<form action="userinfo.jsp"> 
Enter User Name: <input type="text" name="uname" /> <br><br>
Enter Password: <input type="text" name="pass" /> <br><br>
<input type="submit" value="Submit Details"/> 
</form>
</body>
</html>

userinfo.jsp

<%@ page import = " java.util.* " %>
<html> 
<body> 
<% 
String username=request.getParameter("uname"); 
String password=request.getParameter("pass"); 
out.print("Name: "+username+" Password: "+password);
%> 
</body> 
</html>

上述例子的快照

一旦运行上面的 JSP 代码。它会显示以下屏幕，其中包含两个用户名和密码的文本字段。

这是userinfo.jsp页面的输出。这里我们获取了用户在登录页面中输入的 id 和密码。

如果您对 JSP request隐式对象有任何疑问，请告诉我们。我们很乐意帮助您！！

JSP 中的`response`隐式对象

原文： https://beginnersbook.com/2013/11/jsp-implicit-object-response-with-examples/

在这篇文章中，我们将讨论 JSP 中的response隐式对象。它是javax.servlet.http.HttpServletRequest的一个实例，主要用于修改处理客户端请求后发送给浏览器的响应。

`response`隐式对象的方法

void setContentType(String type)
void sendRedirect(String address)
void addHeader(String name, String value)
void setHeader(String name, String value)
boolean containsHeader(String name)
void addCookie(Cookie value)
void sendError(int status_code, String message)
boolean isCommitted()
void setStatus(int statuscode)

让我们详细了解每种方法：

void setContentType(String type) - 此方法通过设置 MIME 类型和字符编码告诉浏览器，响应数据的类型。此方法设置的信息有助于浏览器解释响应。示例：
```
    response.setContentType("text/html");
    response.setContentType("image/gif");
    response.setContentType("image/png");
    response.setContentType("application/pdf");
```
void sendRedirect(String address) - 它将控件重定向到新的 JSP 页面。对于例如当浏览器检测到以下语句时，它将从当前 JSP 页面重定向到beginnersbook.com。
```
    response.sendRedirect("http://beginnersbook.com");
```
void addHeader(String name, String value) - addHeader方法为响应添加一个标题，基本上它包含一个标题名称及其值。例如 - 以下语句将在响应中包含标题"Site"，其值为"BeginnersBook.com"。
```
    response.addHeader("Site", "BeginnersBook.com");
```
void setHeader(String name, String value) - 设置标头值。此方法使用新值覆盖标头的当前值。假设我正在修改标头"Site"的值。以下声明会将当前值BeginnersBook.com修改为新值BB.com
```
    response.setHeader("Site", "BB.com");
```
boolean containsHeader(String name) - 它返回一个布尔值true/false。它基本上检查响应中是否存在标题。例如 - 在上面，在addHeader方法示例中，我们在响应中添加了Site标头，因此以下语句将返回true。
```
    response.containsHeader("Site");
```
void addCookie(Cookie cookie) - 此方法将 cookie 添加到响应中。以下陈述将在回复中添加 2 个 Cookie Author和Siteinfo。
```
    response.addCookie(Cookie Author);
    response.addCookie(Cookie Siteinfo);
```
void sendError(int status_code, String message) - 它用于通过代码和错误消息发送错误响应。例如：
```
    response.sendError(404, "Page not found error");
```

boolean isCommitted() - 检查 Http 响应是否已发送到客户端，如果是，则返回true，否则返回false。

    <% if(response.isCommited())
       {
           <%--do something --%>
       }else
        {
           <%--do something else --%>
        } %>

void setStatus(int statuscode) - 此方法用于将 HTTP 状态设置为给定值。对于例如以下语句将 HTTP 响应代码设置为 404（找不到页面）。
```
    response.setStatus(404);
```

`response`隐式对象示例

在下面的示例中，我们从登录页面接收 id 和密码，然后我们将它们与硬编码的正确id/pass匹配。如果凭据正确，则登录页面会重定向到成功页面，否则会重定向到登录失败的 JSP 页面。

index.html

<html>
<head>
<title>Login Page</title>
</head>
<body>
<form action="checkdetails.jsp"> 
UserId: <input type="text" name="id" /> <br><br>
Password: <input type="text" name="pass" /> <br><br>
<input type="submit" value="Sign In!!"/> 
</form>
</body>
</html>

此 JSP 页面根据硬编码值验证输入id/pass。

checkdetails.jsp

<html> 
<head><title>Check Credentials</title>
</head>
<body> 
<% 
String uid=request.getParameter("id"); 
String password=request.getParameter("pass"); 
session.setAttribute("session-uid", uid);
if(uid.equals("Chaitanya") && password.equals("BeginnersBook"))
{
 response.sendRedirect("success.jsp");
}
else
{
 response.sendRedirect("failed.jsp");
}
%> 
</body> 
</html>

如果id/pass与硬编码的用户 ID /密码匹配，则会执行此 JSP 页面。

success.jsp

<html> 
<head><title>Success Page</title>
</head>
<body> 
<% 
String data=(String)session.getAttribute("session-uid");
out.println("Welcome "+ data+"!!");
%> 
</body> 
</html>

如果用户输入的凭据错误，控件将重定向到此页面。

failed.jsp

<html> 
<head><title>Sign-in Failed Page</title>
</head>
<body> 
<% 
String data2=(String)session.getAttribute("session-uid");
out.println("Hi "+ data2+". Id/Password are wrong. Please try Again.");
%> 
</body> 
</html>

输出截图：

登录页面

成功页面：当userId和密码正确时。

登录时错误的细节。

登录失败页面：当 Id 和密码错误时。

目前为止就这样了。如果您对 JSP 中的response隐式对象有任何疑问和疑问，请告诉我们。

JSP 中的`Session`隐式对象

原文： https://beginnersbook.com/2013/11/jsp-implicit-object-session-with-examples/

Session是 JSP 中最常用的隐式对象。它的主要用途是访问所有用户的数据，直到用户会话处于活动状态。

`session`隐式对象的方法

setAttribute(String, object) - 此方法用于通过为对象分配唯一字符串来保存会话中的对象。之后，可以使用相同的String从会话中访问该对象，直到会话处于活动状态。setAttribute和getAttribute是在 JSP 中处理会话时最常用的两种方法。
getAttribute(String name) - setAttribute方法存储的对象是使用getAttribute方法从session获取的。例如，如果我们需要访问每个 jsp 页面上的userid，直到会话处于活动状态，那么我们应该使用setAttribute方法将user-id存储在会话中，并且可以在需要时使用getAttribute方法进行访问。
removeAttribute(String name) - 可以使用此方法从会话中删除存储在会话中的对象。将唯一字符串标识符作为removeAttribute的方法传递。
getAttributeNames - 它返回会话中存储的所有对象。基本上，它会导致对象的枚举。
getCreationTime - 此方法返回会话创建时间，即会话启动的时间（变为活动状态）。
getId - Servlet 容器在创建会话时为会话分配唯一的字符串标识符。getId方法返回该唯一字符串标识符。
isNew() - 用于检查会话是否是新的。它返回布尔值（true或false）。主要用于跟踪客户端是否启用了 cookie。如果禁用 cookie，session.isNew()方法将始终返回true。
invalidate() - 它会终止会话并中断会话与所有存储对象的关联。
getMaxInactiveInterval - 以秒为单位返回会话的最大停用时间间隔。
getLastAccessedTime - 通常用于知道会话的最后访问时间。

`session`隐式对象示例

下面的 HTML 页面将显示一个文本框和一个提交按钮。提交操作会将控件转移到session.jsp页面。

index.html

<html> 
<head>
<title>Welcome Page: Enter your name</title>
</head>
<body> 
<form action="session.jsp"> 
<input type="text" name="inputname"> 
<input type="submit" value="click here!!"><br/> 
</form> 
</body> 
</html>

session.jsp页面显示用户在索引页面中输入的名称，它将相同的变量存储在session对象中，以便可以在任何页面上获取它，直到会话变为非活动状

session.jsp

<html> 
<head>
<title>Passing the input value to a session variable</title>
</head>
<body> 
<% 
String uname=request.getParameter("inputname"); 
out.print("Welcome "+ uname);
session.setAttribute("sessname",uname); 
%> 
<a href="output.jsp">Check Output Page Here </a>
</body> 
</html>

在这个页面中，我们从session对象中获取变量的值并显示它。

output.jsp

<html> 
<head>
<title>Output page: Fetching the value from session</title>
</head>
<body> 
<% 
String name=(String)session.getAttribute("sessname"); 
out.print("Hello User: You have entered the name: "+name); 
%> 
</body> 
</html>

输出屏幕

JSP 中的`application`隐式对象

原文： https://beginnersbook.com/2013/11/jsp-implicit-object-application-with-examples/

Application隐式对象是javax.servlet.ServletContext的一个实例。它主要用于获取初始化参数和共享属性和它们在整个 JSP 应用中的值，这意味着application隐式对象设置的任何属性都可用于所有 JSP 页面。

方法：

Object getAttribute(String attributeName)
void setAttribute(String attributeName, Object object)
void removeAttribute(String objectName)
Enumeration getAttributeNames()
String getInitParameter(String paramname)
Enumeration getInitParameterNames()
String getRealPath(String value)
void log(String message)
URL getResource(String value)
InputStream getResourceAsStream(String path)
String getServerInfo()
String getMajorVersion()
String getMinorVersion()

Object getAttribute(String attributeName)：它返回存储在给定属性名称中的对象。例如，下面的语句将返回存储在属性"MyAttr"中的对象。
```
    String s = (String)application.getAttribute("MyAttr");
```
void setAttribute(String attributeName, Object object)：它设置属性的值，或者换句话说，它将属性及其值存储在应用程序上下文中，可在整个 JSP 应用程序中使用。示例 –
```
    application.setAttribute(“MyAttribute”, “This is the value of Attribute”);
```
上面的语句将存储属性及其值。如果我们在任何 JSP 页面中使用以下语句，那么's'的值是多少？
```
    String s= (String) application.getAttribute(“MyAttribute”);
```
字符串的值将是"This is the value of Attribute"，因为我们使用setAttribute方法设置它。
void removeAttribute(String objectName)：此方法用于从应用中删除给定属性。对于例如 - 它将从应用中删除属性"MyAttr"。如果我们尝试使用getAttribute方法获取已删除属性的值，则它将返回Null。
```
    application.removeAttribute(“MyAttr”);
```
Enumeration getAttributeNames()：此方法返回存储在application隐式对象中的所有属性名称的枚举。
```
    Enumeration e= application.getAttributeNames();
```
String getInitParameter(String paramname)：它返回给定参数名称的Initialization参数的值。示例web.xml：
```
    <web-app>
    …
    <context-param>
    <param-name>parameter1</param-name>
    <param-value>ValueOfParameter1</param-value>
    </context-param>
    </web-app>
```
假设上面是我的web.xml文件
```
    String s=application.getInitParameter(“parameter1”);
```
s的值将是ValueOfParameter1。仍然困惑它来自哪里？请参阅web.xml文件中的param-value标签。
Enumeration getInitParameterNames()：它返回所有Initialization参数的枚举。
```
    Enumeration e= application.getinitParameterNames();
```
String getRealPath(String value)：它将给定路径转换为文件系统中的绝对路径。
```
    String abspath = application.getRealPath(“/index.html”);
```
abspath的值将是基于现有文件系统的完整 HTTP URL。
void log(String message)：此方法将给定消息写入与该应用程序关联的 JSP 引擎（JSP 容器）的默认日志文件。
```
    application.log(“This is error 404 Page not found”);
```
上面的调用会将消息"This is error 404 Page not found"写入默认日志文件。
String getServerInfo()：此方法返回 JSP 容器（JSP 引擎）的名称和版本。
```
    application.getServerInfo();
```

application隐式对象示例

一个 JSP 页面，用于捕获使用应用的命中数。在此示例中，我们使用application隐式对象计算 JSP 页面的命中数。

counter.jsp

<%@ page import="java.io.*,java.util.*" %>
<html>
<head>
<title>Application Implicit Object Example</title>
</head>
<body>
<%
 //Comment: This would return null for the first time
 Integer counter= (Integer)application.getAttribute("numberOfVisits");
 if( counter ==null || counter == 0 ){
 //Comment: For the very first Visitor 
 counter = 1;
 }else{
 //Comment: For Others 
 counter = counter+ 1;
 }
 application.setAttribute("numberOfVisits", counter);
%>
<h3>Total number of hits to this Page is: <%= counter%></h3>
</body>
</html>

输出截图

首次访问者的点击次数为 1。

刷新页面时，点击次数增加了。

如果您喜欢该教程，请在 Facebook 和 Google+ 上与您的朋友分享。

JSP 中的`exception`隐式对象

原文： https://beginnersbook.com/2013/11/jsp-implicit-object-exception-with-examples/

在本教程中，我们将讨论 JSP 的exception隐式对象。它是java.lang.Throwable的一个实例，经常用于 JSP 中的异常处理。此对象仅适用于错误页面，这意味着 JSP 页面的isErrorPage应为true，以便使用exception隐式对象。让我们在下面的例子的帮助下理解这一点：

`exception`隐式对象示例

在这个例子中，我们从用户那里获取两个整数输入，然后我们在它们之间进行划分。我们在下面的例子中使用了exception隐式对象来处理任何类型的异常。

index.html

<html>
<head>
<title>Enter two Integers for Division</title>
</head>
<body>
<form action="division.jsp"> 
Input First Integer:<input type="text" name="firstnum" />
Input Second Integer:<input type="text" name="secondnum" /> 
<input type="submit" value="Get Results"/> 
</form>
</body>
</html>

这里我们将exception.jsp指定为errorPage，这意味着如果在此 JSP 页面中发生任何异常，控件将立即转移到exception.jsp JSP 页面。注意：我们使用了page指令的errorPage属性来指定异常处理 JSP 页面（<%@ page errorPage="exception.jsp" %>）。

division.jsp

<%@ page errorPage="exception.jsp" %> 
<% 
String num1=request.getParameter("firstnum"); 
String num2=request.getParameter("secondnum"); 
int v1= Integer.parseInt(num1);
int v2= Integer.parseInt(num2);
int res= v1/v2;
out.print("Output is: "+ res);
%>

在下面的 JSP 页面中，我们将isErrorPage设置为true，它也是page指令的一个属性，用于使页面有资格进行异常处理。由于此页面在division.jsp中定义为异常页面，因此在任何异常情况下都将调用此页面。这里我们使用exception隐式对象向用户显示错误消息。

exception.jsp

<%@ page isErrorPage="true" %> 
Got this Exception: <%= exception %> 
Please correct the input data.

输出

屏幕，带有两个输入字段，用于两个整数。

当我们提供第二个整数为零时的算术异常消息。

如果您对 JSP 中的exception隐式对象有任何疑问，请告诉我们。这是在 JSP 中构建应用时最常用的隐式对象之一。作为替代方案，您还可以通过在 JSP scriptlet 中使用try catch来处理 JSP 中的异常。

JSP 中的`pageContext`隐式对象

原文： https://beginnersbook.com/2013/11/jsp-implicit-object-pagecontext-with-examples/

它是javax.servlet.jsp.PageContext的一个实例。使用此对象，您可以在以下任何级别找到属性，获取属性，设置属性和删除属性：

JSP 页面 - 范围：PAGE_CONTEXT
HTTP 请求 - 范围：REQUEST_CONTEXT
HTTP 会话 - 范围：SESSION_CONTEXT
应用级别 - 范围：APPLICATION_CONTEXT

`pageContext`隐式对象的方法

Object findAttribute(String AttributeName)：**此方法按以下顺序搜索所有四个级别中的指定属性 - 页面，请求，会话和应用。当在任何级别找不到属性时，它返回NULL。
Object getAttribute (String AttributeName, int Scope): 它在指定范围内查找属性。此方法类似于findAttribute方法。唯一的区别是findAttribute会按顺序在所有四个级别中查找，而getAttribute则在指定的范围中查找。例如在以下语句中，getAttribute方法将在会话范围（或会话级别/层）中搜索属性"BeginnersBook"。如果找到该属性，则将其分配给Object obj，否则将返回Null。
```
    Object obj = pageContext.getAttribute("BeginnersBook", PageContext.SESSION_CONTEXT);
```
同样，该方法也可用于其他范围：
```
    Object obj = pageContext.getAttribute("BeginnersBook", PageContext. REQUEST_CONTEXT);
    Object obj = pageContext.getAttribute("BeginnersBook", PageContext. PAGE_CONTEXT);
    Object obj = pageContext.getAttribute("BeginnersBook", PageContext. APPLICATION_CONTEXT);
```
void removeAttribute(String AttributeName, int Scope)：此方法用于从给定范围中删除属性。例如 - 下面的 JSP 语句将从页面范围中删除属性"MyAttr"。
```
    pageContext.removeAttribute(“MyAttr”, PageContext. PAGE_CONTEXT);
```
void setAttribute(String AttributeName, Object AttributeValue, int Scope)：它在给定范围内写入属性。示例–下面的语句将在应用程序范围内存储值为"This is my data"的属性"mydata"。
```
    pageContext.setAttribute(“mydata”, “This is my data”, PageContext. APPLICATION_CONTEXT);
```
类似地，这将在请求范围中创建名为attr1的属性，其值为"Attr1 value"。
```
    pageContext.setAttribute(“attr1”, “Attr1 value”, PageContext. REQUEST_CONTEXT);
```

`pageContext`隐式对象示例

index.html

在这里，我们只是要求用户输入登录详细信息。

<html>
<head>
<title> User Login Page – Enter details</title>
</head>
<body>
<form action="validation.jsp">
Enter User-Id: <input type="text" name="uid"><br>
Enter Password: <input type="text" name="upass"><br>
<input type="submit" value="Login">
</form>
</body>
</html>

validation.jsp

在此页面中，我们使用pageContext隐式对象和会话范围存储用户凭据，这意味着我们将能够访问详细信息，直到用户的会话处于活动状态。我们还可以使用其他范围参数存储属性，例如页面，应用和请求。

<html>
<head> <title> Validation JSP Page</title>
</head>
<body>
<% 
String id=request.getParameter("uid");
String pass=request.getParameter("upass");
out.println("hello "+id);
pageContext.setAttribute("UName", id, PageContext.SESSION_SCOPE);
pageContext.setAttribute("UPassword", pass, PageContext.SESSION_SCOPE);
%>
<a href="display.jsp">Click here to see what you have entered </a>
</body>
</html>

display.jsp

在这个 JSP 页面中，我们使用getAttribute方法获取存储的属性。这里需要注意的是，我们已经使用会话范围存储了属性，因此我们必须将范围指定为会话才能获取这些属性的值。

<html>
<head>
<title>Displaying User Details</title>
</head>
<body>
<%
String username= (String) pageContext.getAttribute("UName", PageContext.SESSION_SCOPE);
String userpassword= (String) pageContext.getAttribute("UPassword", PageContext.SESSION_SCOPE);
out.println("Hi "+username);
out.println("Your Password is: "+userpassword);
%>
</body>
</html>

示例输出的屏幕截图：

我们从用户接收用户 ID 和密码的登录页面。

有详细页面链接的页面：

用户凭据显示页面，我们已通过pageContext实例从登录页面传递到此页面。

如果您对pageContext隐式对象有任何疑问，请随时通过删除评论来询问。我们非常乐意为您提供帮助！

Java 服务器页面简介

原文： https://beginnersbook.com/2013/05/jsp-tutorial-introduction/

JSP 是一种服务器端技术，可以完成服务器上的所有处理。它用于创建动态 Web 应用，使用 java 作为编程语言。

基本上，只需将文件扩展名从.html更改为.jsp，任何 HTML 文件都可以转换为 JSP 文件，它运行得很好。 JSP 与 HTML 的区别在于能够在 HTML 中使用 Java 代码。在 JSP 中，您可以使用 JSP 标签在 Java 中嵌入 Java 代码。例如运行下面的代码，每次运行它时，它都会显示当前时间。这就是使这段代码充满活力的原因。

<HTML>
<BODY>
Hello BeginnersBook Readers! 
Current time is: <%= new java.util.Date() %>
</BODY>
</HTML>

你的第一个 JSP

让我们开始用简单 JSP 学习 JSP。

<%-- JSP comment --%>
<HTML>
<HEAD>
<TITLE>MESSAGE</TITLE>
</HEAD>
<BODY>
<%out.print("Hello, Sample JSP code");%>
</BODY>
</HTML>

上面的 JSP 生成以下输出："Hello, Sample JSP code"。

上述代码的说明

1）行<%-- JSP comment --%>表示名为 JSP 注释的 JSP 元素，在向 JSP 页面添加注释时可以使用此标签，我们将在后续帖子中详细讨论。
注意：JSP 注释必须以标签<%--开头，以--%>结尾。

2）Head，Title和Body标签是 HTML 标签 - 它们是 HTML 标签，经常用于静态网页。无论他们拥有什么内容，都会传递给客户端（Web 浏览器）。

3）<%out.print("Hello, Sample JSP code");%>是一个 JSP 元素，称为 Scriptlet。 Scriptlet 可以包含 Java 代码。 scriptlet 的语法是：<%Executable java code>。由于 Scriptlets 中的代码是 java 语句，因此它们必须以分号（;）结尾。out.print("Hello, Sample JSP code");是一个 java 语句，它打印"Hello, Sample JSP code"。

如上所述，JSP 用于创建动态网页。动态网页通常是静态和动态内容的混合。

静态内容可以使用基于文本的格式，如 HTML，XML 等，动态内容由 JSP 标签使用 HTML 内部的 Java 代码生成。

Servlet 与 JSP

与 JSP 一样，Servlet 也用于生成动态网页。这是他们之间的比较。

它们之间的主要区别在于 servlet 在 java 中添加了 HTML 代码，而 JSP 在 HTML 中添加了 Java 代码。还有一些其他值得注意的要点如下：

Servlets：

Servlet 是一个支持 HTML 标签的 Java 程序。
通常用于开发企业应用的业务层（复杂计算代码）。
Servlet 由 Java 开发人员创建和维护。

JSP：

JSP 程序也是支持 java 语句的 HTML 代码。更准确地说，JSP 使用 JSP 标签在 java 中嵌入 java。
用于开发企业应用的表示层
经常用于设计网站并由 Web 开发人员使用。

JSP 的优点

JSP 具有 Servlet 的所有优点，如：比 CGI 更好的性能内置会话功能，它还继承了 Java 技术的特性，如多线程，异常处理，数据库连接等。
JSP 支持将内容生成与内容呈现分离。这使它更灵活。
使用 JSP，Web 设计人员现在可以轻松地显示需要的信息。
Web 应用程序员可以专注于如何处理/构建信息。

JSP 应用的架构

在我们开始开发 Web 应用之前，我们应该对架构有一个基本的想法。根据请求处理发生的位置（Servlet 或者 JSP（Java 服务器页面）），JSP 有两种架构。它们是 - 模型架构 1 和模型架构 2。

1）模型架构 1：在这个模型中，JSP 起着关键作用，它负责处理客户端发出的请求。客户端（Web 浏览器）发出请求，JSP 然后创建一个 bean 对象，然后完成请求并将响应传递给 JSP。 JSP 然后将响应发送回客户端。与模型架构 2 不同，在此模型中，大多数处理都是由 JSP 本身完成的。

2）模型架构 2：在这个模型中，Servlet 扮演着重要角色，它负责处理客户端（Web 浏览器）请求。演示部分（GUI 部分）将由 JSP 处理，并在 bean 的帮助下完成，如下图所示。 servlet 充当控制器并负责请求处理。如果 JSP 页面需要，它会创建 bean 对象并调用相应的 JSP 页面。 JSP 使用 bean 对象处理表示部分。在这个模型中，JSP 不进行任何处理，Servlet 根据客户端的请求创建 bean 对象并调用 JSP 程序。

JSP 中的`config`隐式对象

原文： https://beginnersbook.com/2013/11/jsp-implicit-object-config-with-examples/

它是javax.servlet.ServletConfig的一个实例。Config隐式对象用于获取特定 JSP 页面的配置信息。使用application隐式对象，我们可以获得应用范围的初始化参数，但是使用Config我们可以获得单个 servlet 映射的初始化参数。

`config`隐式对象的方法

String getInitParameter(String paramname) - 与我们在application隐式对象教程中讨论的相同。
Enumeration getInitParameterNames() - 返回Initialization参数的枚举。
ServletContext getServletContext() - 此方法返回对 Servlet 上下文的引用。
String getServletName() - 它返回我们在<servlet-name>里面的web.xml文件中定义的 servlet 的名称。标签。

config隐式对象示例

web.xml

让我们说下面是我的web.xml文件。我只是在其中定义 servlet 名称和 servlet 映射。稍后，我将使用config隐式对象从该文件中获取一些细节。

<web-app>
<servlet> 
<servlet-name>BeginnersBookServlet</servlet-name> 
<jsp-file>/index.jsp</jsp-file> 
</servlet> 

<servlet-mapping> 
<servlet-name>BeginnersBookServlet</servlet-name> 
<url-pattern>/index</url-pattern> 
</servlet-mapping> 
</web-app>

index.jsp

在这个 JSP 页面中，我们调用config对象的getServletName()方法，用于从web.xml文件中获取 servlet 名称。

<html>
<head> <title> Config Implicit Object</title>
</head>
<body>
<% 
String sname=config.getServletName(); 
out.print("Servlet Name is: "+sname); 
%>
</body>
</html>

输出：

这是上述 JSP 页面的输出屏幕。

这就是config隐式对象的全部内容。如果您有任何问题，请随时在下面发表评论。

JSP 中的表达式语言（EL）

JSP 表达式语言（EL）

原文： https://beginnersbook.com/2013/11/jsp-expression-language-el/

表达式语言（EL）已在 JSP 2.0 中引入。它的主要目的是简化从 bean 属性和隐式对象访问数据的过程。 EL 也包括算术运算符，关系运算符和逻辑运算符。

EL 语法：

${expression}

大括号内的任何内容在运行时被评估并被发送到输出流。

示例 1：表达式语言评估表达式

在这个例子中，我们在 EL 的帮助下评估表达式。

<html> 
<head>
 <title>Expression language example1</title>
</head>
<body> 
${1<2}
${1+2+3}
</body> 
</html>

输出：

示例 2：使用表达式语言获取param变量的值

在此示例中，我们提示用户输入名称和卷号。在另一个 JSP 页面上，我们使用 EL 的param变量获取输入的详细信息。

index.jsp

<html> 
<head>
 <title>Expression language example2</title>
</head>
<body> 
<form action="display.jsp"> 
Student Name: <input type="text" name="stuname" /><br>
Student RollNum:<input type="text" name="rollno" /><br>
<input type="submit" value="Submit Details!!"/> 
</form> 
</body> 
</html>

display.jsp

<html>
<head>
<title>Display Page</title>
</head>
<body>
 Student name is ${ param.stuname } <br>
 Student Roll No is ${ param.rollno }
</body>
</html>

输出：

示例 3：从应用对象获取值。

在这个例子中，我们使用application隐式对象设置了属性，在显示页面上我们使用表达式语言的applicationScope获得了这些属性。

index.jsp

<html>
 <head>
 <title>EL example3</title>
 </head>
 <body>
 <%
 application.setAttribute("author", "Chaitanya");
 application.setAttribute("Site", "BeginnesBook.com");
 %>
 <a href="display.jsp">Click</a>
 </body>
 </html>

display.jsp

<html>
 <head>
 <title>Display Page</title>
 </head>
 <body>
 ${applicationScope.author}<br>
 ${applicationScope.Site}
 </body>
 </html>

输出：

EL 预定义变量：

与 JSP 中的隐式对象类似，我们在 EL 中预定义了变量。在上面的例子中我们使用了param和applicationScope，它们也是这些变量的一部分。

pageScope：它有助于获取存储在page范围中的属性。
pageContext：与 JSP PageContext对象相同。
sessionScope：从session对象设置的会话范围中获取属性。
requestScope：用于从请求范围获取属性。由request隐式对象设置的属性。
param：类似于ServletRequest.getParameter。参考例 2。
applicationScope：用于获取Applicaton级别属性。与我们在示例 3 中看到的相同。
header：它有助于将 HTTP 请求标头作为字符串获取。
headerValues：用于获取所有 HTTP 请求头。
initParam：它链接到上下文初始化参数。
paramValues：与ServletRequest.getParmeterValues相同。
cookie：它映射到 Cookie 对象。

异常处理

JSP 中的异常处理

原文： https://beginnersbook.com/2013/11/jsp-exception-handling/

在通过 JSP 中的异常处理之前，让我们了解什么是异常以及它与错误的区别。

异常：这些只是中断正常执行流程的异常情况。大多数情况下，它们是由于用户输入的错误数据而发生的。必须处理异常才能向用户提供有意义的消息，以便用户能够理解问题并采取适当的措施。

错误：这可能是代码或系统相关问题的问题。我们不应该处理错误，因为它们是要修复的。

处理异常的方法：

我们可以使用以下两种方法处理异常。

使用exception隐式对象进行异常处理
使用 scriptlet 中的try catch块进行异常处理

使用`exception`隐式对象进行异常处理

在下面的例子中 - 我们使用page指令的errorPage属性指定了异常处理页面。如果主 JSP 页面中发生任何异常，控件将被转移到errorPage属性中提到的页面。

处理程序页面应将isErrorPage设置为true，以便使用exception隐式对象。这就是我们为errorpage.jsp设置isErrorPage为true的原因。

index.jsp

<%@ page errorPage="errorpage.jsp" %>
<html>
<head>
  <title>JSP exception handling example</title>
</head>
<body>
<%
     //Declared and initialized two integers
     int num1 = 122;
     int num2 = 0;

     //It should throw Arithmetic Exception
     int div = num1/num2;
%>
</body>
</html>

errorpage.jsp

<%@ page isErrorPage="true" %>
<html>
<head>
  <title>Display the Exception Message here</title>
</head>
<body>
   <h2>errorpage.jsp</h2>
   <i>An exception has occurred in the index.jsp Page.
   Please fix the errors. Below is the error message:</i>
   <b><%= exception %></b>
</body>
</html>

输出：

使用 scriptlet 中的try catch块进行异常处理

我们在下面的示例中使用try catch块处理了异常。因为try catch块是 java 代码所以它必须放在 sciptlet 中。在下面的例子中，我声明了一个长度为 5 的数组，并尝试访问不存在的第 7 个元素。它导致ArrayIndexOutOfRange异常。

error.jsp

<html>
 <head>
 <title>Exception handling using try catch blocks</title>
 </head>
 <body>
 <%
 try{
     //I have defined an array of length 5
     int arr[]={1,2,3,4,5};
     //I'm assinging 7th element to int num
     //which doesn't exist
     int num=arr[6];
     out.println("7th element of arr"+num);
 }
 catch (Exception exp){
     out.println("There is something wrong: " + exp);
 }
 %>
 </body>
 </html>

示例 2 的输出：

让我们知道您更喜欢哪种方法来处理异常以及原因。如果您有任何疑问，请随时将其放在下面的评论部分。

自定义标签

JSP 自定义标签

原文： https://beginnersbook.com/2014/01/jsp-custom-tags-with-example-jsp-tutorial/

用户定义的标签称为自定义标签。在本教程中，我们将了解如何创建自定义标签并在 JSP 中使用它。

要创建自定义标签，我们需要三件事：

1）标签处理程序类：在此类中，我们指定自定义标签在 JSP 页面中使用时将执行的操作。

2）TLD 文件：标签描述符文件，我们将在其中指定我们的标签名称，标签处理程序类和标签属性。

3）JSP 页面：我们将使用自定义标签的 JSP 页面。

示例：

在下面的示例中，我们创建了一个自定义标签MyMsg，当在 JSP 页面中使用时，它将显示消息This is my own custom tag。

标签处理程序类：

标签处理程序类应该实现Tag/IterationTag/BodyTag接口，或者它也可以扩展TagSupport/BodyTagSupport/SimpleTagSupport类。所有支持自定义标签的类都存在于javax.servlet.jsp.tagext中。在下面我们扩展了类SimpleTagSupport。

Details.java

package beginnersbook.com;
import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;
public class Details extends SimpleTagSupport {
   public void doTag() throws JspException, IOException {
      /*This is just to display a message, when
       * we will use our custom tag. This message
       * would be displayed
       */
      JspWriter out = getJspContext().getOut();
      out.println("This is my own custom tag");
   }
}

TLD 文件

此文件应出现在以下位置：Project Name/WebContent/WEB-INF/，它应该有.tld扩展名。

注：

<name>标签：自定义标签名称。在这个例子中，我们将它作为MyMsg

<tag-class>标签给出：完全限定的类名。我们的标签处理程序类Details.java在包beginnersbook.com 中，因此我们将值赋予beginnersbook.com.Details。

message.tld

<taglib>
 <tlib-version>1.0</tlib-version>
 <jsp-version>2.0</jsp-version>
 <short-name>My Custom Tag</short-name>
 <tag>
 <name>MyMsg</name>
 <tag-class>beginnersbook.com.Details</tag-class>
 <body-content>empty</body-content>
 </tag>
</taglib>

在 JSP 中使用自定义标签：

上面我们创建了一个名为MyMsg的自定义标签。我们将在这里使用它。
注意：taglib指令应该在uri字段中有 TLD 文件路径。上面我们创建了message.tld文件，因此我们给出了该文件的路径。
选择任何前缀并在taglib指令的前缀字段中指定它。这里我们将其指定为myprefix。
自定义标签的调用方式如下：<prefix:tagName/>;。我们的前缀是myprefix，标签名称是MyMsg，所以我们在下面的 JSP 页面中将其称为<myprefix:MyMsg/>。

<%@ taglib prefix="myprefix" uri="WEB-INF/message.tld"%>
<html>
 <head>
    <title>Custom Tags in JSP Example</title>
 </head>
 <body>
    <myprefix:MyMsg/>
 </body>
</html>

输出：

This is my own custom tag

如何访问自定义标签的主体

原文： https://beginnersbook.com/2014/01/how-to-access-body-of-custom-tags-in-jsp-tutorial/

在上一个教程中，我们学习了如何在 JSP 中创建和使用自定义标签。在本教程中，我们将了解如何访问自定义标签的主体。对于例如如果我们的自定义标签是xyz，那么我们将学习访问<prefix: xyz>和</prefix:xyz>之间的内容

<prefix: xyz>
Body of custom tag: This is what we will access in the below example
</prefix:xyz>

示例：

在此示例或自定义标签中，将String附加到其自己的主体并显示结果。

标签处理程序类：Details.java

package beginnersbook.com;
import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class Details extends SimpleTagSupport {
   //StringWriter object
   StringWriter sw = new StringWriter();

   public void doTag() throws JspException, IOException
   {
       getJspBody().invoke(sw);
       JspWriter out = getJspContext().getOut();
       out.println(sw.toString()+"Appended Custom Tag Message");
   }
}

TLD 文件：message.tld，请记住将此文件放在WEB-INF文件夹中。

<taglib>
<tlib-version>1.0</tlib-version>
<jsp-version>2.0</jsp-version>
<short-name>My Custom Tag: MyMsg</short-name>
<tag>
<name>MyMsg</name>
<tag-class>beginnersbook.com.Details</tag-class>
<body-content>scriptless</body-content>
</tag>
</taglib>

JSP 页面：index.jsp

<%@ taglib prefix="myprefix" uri="WEB-INF/message.tld"%>
<html>
<head>
  <title>Accessing Custom Tag Body Example</title>
</head>
<body>
  <myprefix:MyMsg>
    Test String
  </myprefix:MyMsg>
</body>
</html>

输出：

Test String Appended Custom Tag Message

Java 服务器页面（JSP）生命周期

原文： https://beginnersbook.com/2013/05/jsp-tutorial-life-cycle/

JSP 页面以.jsp扩展名保存，这使服务器知道这是一个 JSP 页面，需要经历 JSP 生命周期阶段。
在我之前关于 JSP 介绍的文章中，我解释说 JSP 不是这样处理的，它们首先被转换为 Servelts，然后相应的 Servlet 由服务器处理。

当客户端向服务器发出请求时，它首先转到容器。然后容器检查 Servlet 类是否比 JSP 页面旧（确保 JSP 文件被修改）。如果是这种情况，那么容器再次执行转换（将 JSP 转换为 Servlet），否则它会跳过转换阶段（即，如果 JSP 网页未被修改，那么它不会进行转换以提高性能，因为此阶段需要时间并且每次重复这一步都不是时间可行的）

JSP 页面生命周期中的步骤是：

翻译
汇编
载入中
实例化
初始化
请求处理
销毁

让我们更详细地看一下 JSP 的生命周期：

1）如上所述，只要容器收到来自客户端的请求，它只在Servlet类比 JSP 页面更旧时才进行转换。其他它跳过这个阶段（我上面解释的原因）。

2）然后容器：

编译相应的Servlet程序
加载相应的Servlet类
实例化Servlet类
调用jspInit()方法来初始化Servlet实例（仅当Servlet文件的实例未运行或者它比 JSP 文件旧时，JSP 容器才会执行此作业。）

public void jspInit() {
    //初始化 Servlet 实例的代码
}

3）然后创建一个新线程，它调用_jspService()方法，请求（HttpServletRequest）和响应（HttpServletRespnse）对象作为参数 - 如下所示。

void _jspService(HttpServletRequest req, HttpServletResponse res) {
    // 代码在这里
}

4）调用jspDestroy()方法来销毁Servlet类的实例。代码如下所示：

public void jspDestory()
{
    //删除 Servlet 类的实例的代码
}

指令

JSP 指令 - `page`，`include`和`TagLib`

原文： https://beginnersbook.com/2013/05/jsp-tutorial-directives/

指令控制整个 JSP 页面的处理。它向服务器提供有关页面处理的指示。

指令语法：

 <%@ directive name [attribute name=“value” attribute name=“value” ........]%>

JSP 中有三种类型的指令：

1）page指令

2）include指令

3）TagLib指令

1）`page`指令

有几个属性，与page指令一起使用，它们是：

import
session
isErrorPage
errorPage
ContentType
isThreadSafe
extends
info
language
autoflush
buffer

1.`import`

此属性用于导入包。在进行编码时，您可能需要包含多个包。在这种情况下，此page指令的属性非常有用，因为它允许您在逗号（,）之间用同一位置提及多个包。或者，您可以拥有多个页面元素实例，每个实例都包含不同的包。

导入属性的语法：

<%@page import="value"%>

这里的值是包名。

导入示例： 以下是如何使用page指令的import属性导入多个包的示例。

 <%@page import="java.io.*%>
 <%@page import="java.lang.*%>
 <%--Comment: OR Below Statement: Both are Same--%>
 <%@page import="java.io.*, java.lang.*"%>

2.`session`

通常在构建用户交互式 JSP 应用时，我们确保允许用户访问以获取他/她的个人数据，直到会话处于活动状态。考虑一个登录到您的银行帐户的示例，我们可以访问您的所有数据，直到我们退出（或会话到期）。为了维护页面的会话，会话属性应为true。

此属性用于处理 JSP 页面的 HTTP 会话。它可以有两个值：true或false。会话属性的默认值为true，这意味着如果您不提及此属性，则服务器可能会认为此页面需要 HTTP 会话。

此属性的默认值：true

会话属性语法：

<%@ page session="value"%>

这里的值是是true或者false

会话示例：

<%@ page session="true"%>

上面的代码将允许页面具有session隐式对象。

<%@ page session="false"%>

如果在 JSP 页面中指定了此代码，则意味着session对象将不可用于该页面。因此，无法为该页面维护会话。

3. `isErrorPage`

此属性用于指定当前 JSP 页面是否可用作另一个 JSP 页面的错误页面。如果isErrorPage的值为true，则表示该页面可用于其他页面的异常处理。通常，这些页面具有错误/警告消息或异常处理代码，并且当发生异常时由另一个 JSP 页面调用。

isErrorPage属性还有另一种用法 - exception隐式对象只能用于isErrorPage设置为true的那些页面。如果值为false，则页面不能使用exception隐式对象。

默认值： false

isErrorPage属性的语法：

<%@ page isErrorPage="value"%>

这里的值是true或false。

isErrorPage示例：

<%@ page isErrorPage="true"%>

这使得 JSP 页面成为异常处理页面。

4. `errorPage`：

如上所述，当isErrorPage属性对于特定页面为true 时，则表示在异常情况下该页面可以被另一个页面调用。errorPage属性用于指定将isErrorPage属性设置为true的 JSP 页面的 URL。它处理页面中未处理的异常。

errorPage属性的语法：

<%@ page errorPage="value"%>

这里的值是一个 JSP 页面名称，它具有异常处理代码（并且isErrorPage设置为true）。

errorPage示例：

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

这意味着如果在放置此代码的 JSP 页面上发生任何异常，则需要调用ExceptionHandling.jsp（此页面应具有isErrorPage true）页面。

5. `contentType`

此属性用于设置 JSP 页面的内容类型。

默认值：text/html

contentType属性的语法：

<%@ page contentType="value"%>

这里内容类型的值可以是诸如：text/html，text/xml等。

contentType示例：

下面的代码可用于text/html页面。

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

对于基于text/xml的页面：

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

6. `isThreadSafe`

让我们通过一个例子来理解这一点。假设您已经创建了一个 JSP 页面并将isThreadSafe提到为true，这意味着 JSP 页面支持多线程（多个线程可以同时执行 JSP 页面）。另一方面，如果将其设置为false，则 JSP 引擎将不允许多线程，这意味着只有单个线程将执行页面代码。

isThreadSafe属性的默认值：true。

isThreadSafe属性的语法：

<%@ page isThreadSafe="value"%>

这里的值可以是true或false。

isThreadSafe示例：

<%@ page isThreadSafe="false"%>

只有一个线程负责 JSP 页面执行。

7. `buffer`

此属性用于指定缓冲区大小。如果在编码期间将此值指定为none，则输出将由JSPWriter直接写入Response对象。并且，如果指定缓冲区大小，则输出首先写入缓冲区，然后它将可用于response对象。

buffer属性的语法：

<%@ page buffer="value"%>

值为大小（单位为 KB）或none。

缓冲区示例：

此页面没有缓冲区：

<%@ page buffer="none"%>

页面的 5 kb 缓冲区大小，代码如下：

<%@ page buffer="5kb"%>

8. `extends`

像 java 一样，这里的属性也用于扩展（继承）类。

extends属性的语法：

<%@ page extends="value"%>

值为package_name.class_name。

延伸示例：

下面的代码将从包中继承SampleClass.mypackage

<%@ page extends="mypackage.SampleClass"%>

9. `info`

它提供了对 JSP 页面的描述。当我们调用getServletInfo()方法时，info中指定的字符串将返回。

info语法：

<%@ page info="value"%>

这里的值是消息或描述

info属性示例：

<%@ page info="This code is given by Chaitanya Singh"%>

10. `language`

它指定页面中使用的脚本语言（基础语言）。

language语法：

<%@ page language="value"%>

值是这里的脚本语言。

语言属性示例：

<%@ page language="java"%>

11. `autoFlush`

如果为true，则表示缓冲区应该在满时刷新。当缓冲区溢出时，false将抛出异常。

默认值：true

autoFlush的语法：

<%@ page autoFlush="value"%>

值可以是true或false。

autoFlush属性示例：

缓冲区将在满时刷新：

<%@ page autoFlush="true"%>

由于溢出条件，缓冲区满时会抛出异常

<%@ page autoFlush="true"%>

12. `isScriptingEnabled`

它已被删除而未被使用。

13. `isELIgnored`

此属性指定是否评估表达式。

默认值：true

isELIgnored的语法：

<%@ page isELIgnored="value"%>

value can be true or false.

isELIgnored属性示例：

JSP 页面中存在的任何表达式都不会被评估：

<%@ page isELIgnored="false"%>

将评估表达式（true是默认值，因此无需指定）：

<%@ page isELIgnored="true"%>

2）`include`指令

Include指令用于将一个 JSP 页面的内容复制到另一个 JSP 页面。这就像将一个文件的代码包含在另一个文件中。

include指令的语法：

<%@include file ="value"%>

这里的值是需要包含的 JSP 文件名。如果文件位于同一目录中，则只需指定文件名，否则需要在值字段中提及完整的 URL（或路径）。

注意：它可以在页面的任何地方使用。

示例：

<%@include file="myJSP.jsp"%>

您可以在 JSP 页面中使用上述代码来复制myJSP.jsp文件的内容。但是，在这种情况下，两个 JSP 文件必须位于同一目录中。如果myJSP.jsp位于不同的目录中，那么您需要在上面的代码中指定完整路径，而不仅仅是文件名。

必须通过示例详细阅读：Include指令。

3）`Taglib`指令

该指令基本上允许用户在 JSP 中使用Custom标签。我们将在即将到来的 JSP 教程中详细讨论Custom标签。Taglib指令可帮助您在 JSP 页面中声明自定义标签。

Taglib指令语法：

<%@taglib uri ="taglibURI" prefix="tag prefix"%>

其中 URI 是统一资源定位符，用于标识自定义标签的位置，标签前缀是一个字符串，可以标识 URI 标识的位置中的自定义标签。

Targlib的例子：

<%@ taglib uri="http://www.sample.com/mycustomlib" prefix="demotag" %>
<html>
<body>
<demotag:welcome/>
</body>
</html>

如您所见，URI 具有自定义标签库的位置，前缀标识自定义标签的前缀。

注意：在上面的例子中 - <demotag:welcome>有一个前缀demotag。

JSP 中的`Include`指令

原文： https://beginnersbook.com/2013/11/jsp-include-directive/

Include 指令用于在转换阶段将外部文件合并到当前 JSP 页面（JSP 转换为等效 Servlet 的阶段）。

为什么我们需要使用include指令？我们不能简单地在当前 JSP 中添加文件的内容而不是使用指令吗？

我们可以复制外部文件的内容并将其粘贴到主 JSP 中，但是不是一个好习惯。让我们借助一个例子理解这一点 - 我有 100 个外部文件和 1 个主 JSP 文件。如果我只是复制主 JSP 中所有文件的内容，那么只要任何外部文件发生更改，我就必须编辑它，而是我们可以使用指令包含所有文件，并在需要时编辑特定文件。

此外，通过使用include指令，您可以增强代码的可重用性 - 假设在您的应用的所有 JSP 页面中都需要存在某些代码或数据，那么您可以简单地使用该代码/数据在一个文件中，并在所有 JSP 页面中包含该文件。

以上两个原因可以被认为是使用include指令的优点。

语法：

这是 JSP 中include指令的语法。

<%@ include file="URL of the file" %>

我们必须指定相对 URL：

如果file与当前 JSP 页面所在的文件夹相同，那么我们只需提及文件名，否则需要指定文件的相对路径。

`Include`指令示例

index.jsp

<html>
<head>
<title>Main JSP Page</title>
</head>
<body>
<%@ include file="file1.jsp" %>
Main JSP Page: Content between two include directives.
<%@ include file="file2.jsp" %>
</body>
</html>

file1.jsp

<p align="center">
This is my File1.jsp and I will include it in index.jsp using include directive
</p>

file2.jsp

<p align="center">
This is File2.jsp
</p>

输出：运行上面的代码时输出如下所示。如您所见，我们在include指令的帮助下将file1和file2的内容包含在主 JSP 页面中。

如果您对此有任何疑问，请告诉我们。

JSP 带参数的`include`指令

原文： https://beginnersbook.com/2013/12/jsp-include-directive-with-parameters-example/

在上一个教程中，我们讨论了 JSP include参数的动作。这里我们将看到在使用 JSP include指令时如何传递参数。

例

在这个例子中，我们将三个字符串参数传递给包含的 JSP 页面。

index.jsp

<html>
<head>
<title>Passing Parameters to Include directive</title>
</head>
<body>
<%@ include file="file1.jsp" %>
<%!
String country="India"; 
String state="UP";
String city="Agra";
%>
<% 
session.setAttribute("co", country);
session.setAttribute("st", state);
session.setAttribute("ci", city);
%>
</body>
</html>

上面，我使用声明标签初始化字符串， scriptlet 用于在session对象中设置它们。由于 sciptlet 的使用被忽视了长背，或者你可以使用<c:set> JSTL 标签做同样的事 - 代码就像这样：

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<c:set var="co" value="India" scope="session"/>
<c:set var="st" value="UP" scope="session"/>
<c:set var="ci" value="Agra" scope="session"/>
<%@ include file="file1.jsp" %>

file1.jsp

<%=session.getAttribute("co") %>
<%=session.getAttribute("st") %>
<%=session.getAttribute("ci") %>

输出：

在上面的例子中，我使用session隐式对象传递了参数，但是您也可以使用请求，页面和application隐式对象传递它们。

Scriptlets

posted @ 2024-10-24 18:12 绝不原创的飞龙阅读(39) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

BeginnersBook-JSP-教程-一-

BeginnersBook JSP 教程（一）

JSP Scriptlets

JSP 到 Scriptlet 的 Servlet 转换：

了解脚本元素的一个例子：

<%–This is an Expression statement–%> Welcome to <%=string1%>

动作标签

JSP 动作

指令与动作

1. <jsp:include>动作

2. <jsp:forward>动作

3. <jsp:param>动作

4. <jsp:useBean>动作

5. <jsp:setProperty>动作

6. <jsp:getProperty>动作

其他动作标签

7. <jsp:plugin>动作

8. <jsp:body>动作

9. <jsp:element>动作

10. <jsp:text>动作

11. <jsp:attribute>动作

JSP include动作标签

示例 1：没有参数的<jsp:include>

示例 2：使用<jsp:include>以及<jsp:param>

JSP 带参数的include动作

例

JSP forward动作标签

JSP 转发示例 1 - 不传递参数

JSP 转发示例 2 - 带参数

jsp:useBean，jsp:setProperty和jsp:getProperty动作标签

useBean，setProperty和getProperty的完整示例

表达式

JSP 表达式标签

JSP 表达式标签示例

声明

概述

JSP 声明标签

JSP 隐式对象

Jsp 隐式对象

JSP 中的out隐式对象

out隐式对象的方法

out隐式对象示例

JSP 中的request隐式对象

request隐式对象的方法

request隐式对象示例

JSP 中的response隐式对象

response隐式对象的方法

response隐式对象示例

输出截图：

JSP 中的Session隐式对象

session隐式对象的方法

session隐式对象示例

JSP 中的application隐式对象

JSP 中的exception隐式对象

exception隐式对象示例

JSP 中的pageContext隐式对象

pageContext隐式对象的方法

pageContext隐式对象示例

Java 服务器页面简介

你的第一个 JSP

Servlet 与 JSP

JSP 的优点

JSP 应用的架构

JSP 中的config隐式对象

config隐式对象的方法

JSP 中的表达式语言（EL）

JSP 表达式语言（EL）

异常处理

JSP 中的异常处理

使用exception隐式对象进行异常处理

自定义标签

JSP 自定义标签

如何访问自定义标签的主体

Java 服务器页面（JSP）生命周期

指令

JSP 指令 - page，include和TagLib

1）page指令

1.import

1. `<jsp:include>`动作

2. `<jsp:forward>`动作

3. `<jsp:param>`动作

4. `<jsp:useBean>`动作

5. `<jsp:setProperty>`动作

6. `<jsp:getProperty>`动作

7. `<jsp:plugin>`动作

8. `<jsp:body>`动作

9. `<jsp:element>`动作

10. `<jsp:text>`动作

11. `<jsp:attribute>`动作

JSP `include`动作标签

示例 1：没有参数的`<jsp:include>`

示例 2：使用`<jsp:include>`以及`<jsp:param>`

JSP 带参数的`include`动作

JSP `forward`动作标签

`jsp:useBean`，`jsp:setProperty`和`jsp:getProperty`动作标签

`useBean`，`setProperty`和`getProperty`的完整示例

JSP 中的`out`隐式对象

`out`隐式对象的方法

`out`隐式对象示例

JSP 中的`request`隐式对象

`request`隐式对象的方法

`request`隐式对象示例

JSP 中的`response`隐式对象

`response`隐式对象的方法

`response`隐式对象示例

JSP 中的`Session`隐式对象

`session`隐式对象的方法

`session`隐式对象示例

JSP 中的`application`隐式对象

JSP 中的`exception`隐式对象

`exception`隐式对象示例

JSP 中的`pageContext`隐式对象

`pageContext`隐式对象的方法

`pageContext`隐式对象示例

JSP 中的`config`隐式对象

`config`隐式对象的方法

使用`exception`隐式对象进行异常处理

JSP 指令 - `page`，`include`和`TagLib`

1）`page`指令

1.`import`

2.`session`

3. `isErrorPage`

4. `errorPage`：

5. `contentType`

6. `isThreadSafe`

7. `buffer`

8. `extends`

9. `info`

10. `language`

11. `autoFlush`

12. `isScriptingEnabled`

13. `isELIgnored`

2）`include`指令

3）`Taglib`指令

JSP 中的`Include`指令

`Include`指令示例

JSP 带参数的`include`指令