Skip to content

B
beginnersbook-zh

OpenDocCN / beginnersbook-zh
10 个月 前同步成功

通知 0
Star 107
Fork 30
B
beginnersbook-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 4565aedb 编写于 作者: W wizardforcel
浏览文件
操作

2019-08-05 16:07:52

上级 35f9ae72
隐藏空白更改
内联 并排
Showing with 2861 addition and 0 deletion
docs/jsp/10.md 0 → 100644
浏览文件 @ 4565aedb
# JSP Scriptlets
> 原文： [https://beginnersbook.com/2013/05/jsp-tutorial-scriptlets/](https://beginnersbook.com/2013/05/jsp-tutorial-scriptlets/)
[**«上一个教程：JSP 指令**](https://beginnersbook.com/2013/05/jsp-tutorial-directives/)
[**下一个教程：JSP 动作»**](https://beginnersbook.com/2013/06/jsp-tutorial-actions/)
**Scriptlet 只是包含在**＆lt;％和％＆gt;中的 java 代码**了。标签**。 JSP 容器将 JSP 中包含的语句移动到 **_jspService（）**方法，同时从 JSP 生成 servlet。将此代码复制到服务方法的原因是：对于每个客户端的请求，调用 _jspService（）方法，因此其中的代码将针对客户端发出的每个请求执行。
**Scriptlet 的语法：**
[code language =“java”]＆lt;％可执行的 java 代码％＆gt; [/ code]
### JSP 到 Scriptlet 的 Servlet 转换 -
正如我在之前的教程中所述，JSP 没有直接执行，它首先被转换为 Servlet，然后 Servlet 执行正常。另外，我在第一段中解释说，从 JSP 到 servlet 的转换，java 代码从 scriptlet 复制到 _jspService（）方法。让我们看看这是怎么回事。
**示例 JSP 代码：**
[code language =“html”]
＆lt; H3＆gt;样本 JSP＆lt; / H3＆gt;
＆lt;％myMethod（）;％＆gt;
[/ code]
**注意：**分号在 scriptlet 的末尾。
**上述 JSP 代码的相应翻译 Servlet 代码：**
[code language =“java”]
public void _jspService（HttpServletRequest request，
HttpServletResponse response）
抛出 ServletException，IOException {
response.setContentType（“text / html”）;
HttpSession session = request.getSession（）;
JspWriter out = response.getWriter（）;
out.println（“＆lt; H2＆gt; Sample JSP＆lt; / H2＆gt;”）;
myMethod（）;
} [/ code]
### **了解脚本元素的一个例子：**
[code language =“java”]
＆lt;％ - 学习 JSP 脚本元素的 jsp 示例 - ％＆gt;
＆lt;％String string1 =“JSP scriptlet”;％＆gt;
＆lt;％！String string2 =“”;％＆gt;
＆lt; html＆gt;
＆lt; head＆gt;
＆lt; title＆gt; JSP 页面：欢迎＆lt; / title＆gt;
＆lt; / head＆gt;
＆lt; body＆gt;
＆lt; h1＆gt;
＆lt;％ - 这是一个表达式声明 - ％＆gt;
欢迎使用＆lt;％= string1％＆gt;
＆lt; / h1＆gt;
＆lt;％ - sciptlet 示例 - ％＆gt;
＆lt;％if（localstring.equals（“JSP scriptlet”））{％＆gt;
你好
＆lt;％}
别的{％＆gt;
你好
＆lt;％}％＆gt;
＆lt;％ - 同样可以用这种方式完成 - ％＆gt;
＆lt;％if（localstring.equals（“JSP scriptlet”））
out.println（“Hi”+ string2）;
其他
out.println（“你好”）;
％＆gt;
＆lt; / body＆gt;
＆lt; / html＆gt; [/ code]
在上面的示例中，存在许多类型的 JSP 元素，例如 Expression，JSP comment，Declaration 元素等。我们将在即将到来的 JSP 教程中看到它们中的每一个，但是到目前为止，您只能关注 Scriptlet。以下是上例中使用的 scriptlets 语句 -
[code language =“java”]
＆lt;％if（localstring.equals（“JSP scriptlet”））
out.println（“Hi”+ string2）;
其他
out.println（“你好”）;
％＆gt; [/ code]
上面的代码是一个 JSP scriptlet（通知开始＆lt;％和结束％＆gt;标记）。如果您分析上面的代码，那么您会发现标签内的代码是纯 Java 代码，因此为了在 JSP 中执行 Java 代码，我们使用 scriptlet。
[code language =“java”]＆lt;％String string1 =“JSP scriptlet”;％＆gt; [/ code]
像上面的语句一样，这个语句是一个 java 初始化代码，它包含在标记中。
除了上面两组 scriptlet 之外，上面的例子中还有许多其他的 scriptlet 标签（注意 if-else 控制流逻辑）。要使用 java 的 if-else 控制流语句，我们在上面的示例中使用了 scriptlet。因为这是使用 scriptlet 的主要优点所以让我们借助一个例子让它更清晰 - 你必须知道我们的 If - else 控制语句有多重要。
**使用 scriptlet 显示 if -else 的使用示例 -**
假设有一个变量 num 并且你想在你的网页上显示“hi”，如果它大于 5，否则你想要显示一条消息。考虑下面这个场景的代码 -
**如果你想在 java 中为上述情况编写一个代码，那么它看起来像这样 -**
[code language =“java”]
if（num＆gt; 5）
{
out.println（“hi”）;
}
其他
{
out.println（“num 值不应小于 6”）;
} [/ code]
**要在 JSP 中编写类似的代码，我们需要使用 JSP scriptlet - 代码就像这样 -**
[code language =“html”]
＆lt;！ DOCTYPE HTML PUBLIC“ - // W3C // DTD HTML4.0 translation // EN”＆gt;
＆lt; HTML＆gt;
＆lt; HEAD＆gt;
＆lt; TITLE＆gt;我的 JSP PAGE＆lt; / TITLE＆gt;
＆lt; / HEAD＆gt;
＆lt; BODY＆gt;
＆lt;％if（num＆gt; 5）{％＆gt;
＆lt; H3＆gt;嗨＆lt; / H3＆gt;
＆lt;％} else {％＆gt;
＆lt; h3＆gt; num 值不应小于 6＆lt; / h3＆gt;
＆lt;％}％＆gt;
＆lt; / BODY＆gt;
＆lt; / HTML＆gt;
[/ code]
**重要的一点要记住：** 由于里面的代码是 java 代码，**必须以分号（;）结尾。** 现在注意所有的陈述 - 你可能会发现~~所有~~很少的 scriptlet，我们在 java 中给分号，在这里也需要它，并以分号结束。
[**« Previous Tutorial: JSP Directives**](https://beginnersbook.com/2013/05/jsp-tutorial-directives/)
[**Next Tutorial: JSP Actions »**](https://beginnersbook.com/2013/06/jsp-tutorial-actions/)
\ No newline at end of file
docs/jsp/11.md 0 → 100644
浏览文件 @ 4565aedb
# 动作标签
\ No newline at end of file
docs/jsp/12.md 0 → 100644
浏览文件 @ 4565aedb
# JSP 操作 - Java Server Pages
> 原文： [https://beginnersbook.com/2013/06/jsp-tutorial-actions/](https://beginnersbook.com/2013/06/jsp-tutorial-actions/)
JSP Actions 允许您执行某些操作。
## 指令与行动
1. 在转换阶段使用指令，而在请求处理阶段使用操作。
2. 与指令不同，每次访问页面时都会重新评估操作。
以下是 JSP 中使用的操作元素：
## 1.＆lt; jsp：include＆gt;行动
与**包含页面指令**类似，此操作也用于在另一个文件中插入 JSP 文件。
**＆lt; jsp：include＆gt; vs include 指令：**
它与我在文章开头提到的相同（指令与行动）有所不同。在＆lt; jsp：include＆gt;中在请求处理期间包含该文件，而在 include 指令的情况下，它已包含在转换阶段。
**＆lt; jsp：include＆gt;的语法：**
```
<jsp:include page="page URL"  flush="Boolean Value" />
```
这里的页面 URL 是：需要包含页面的位置＆amp;刷新值可以是 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>
```
**页面**：页面值是 sample.jsp，这意味着这是页面需要包含在当前文件中。只是提到的文件名显示 sample.jsp 在同一目录中。
**flush** ：其值为 false，表示资源缓冲区在包含到当前页面之前尚未刷新。
阅读更多： [jsp 包含动作标签](https://beginnersbook.com/2013/11/jsp-include-action-tag/)。
## 2.＆lt; jsp：forward＆gt;行动
＆LT; JSP：正向＆GT;用于重定向请求。在 JSP 页面上遇到此操作时，控件将转移到此操作中提到的页面。
**＆lt; jsp：forward＆gt;的语法：**
```
<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（上面的代码）然后在 action 标记之后，请求将被转移到另一个 JSP 页面（second.jsp）。
**注意**：first.jsp 和 second.jsp 应该在同一个目录中，否则你必须指定 second.jsp 的完整路径。
阅读更多： [JSP 转发动作标签](https://beginnersbook.com/2013/11/jsp-forward-action-tag/)。
## 3.＆lt; jsp：param＆gt;行动
此操作对于将参数传递给其他 JSP 操作标记非常有用，例如 JSP include＆amp; JSP 转发标记。这样，新的 JSP 页面可以使用请求对象本身访问这些参数。
**＆lt; jsp：param＆gt;的语法：**
```
<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＆amp; data）传递给 second.jsp，second.jsp 可以使用下面的代码访问这些参数 -
```
Date:<%= request.getParameter("date") %>
Time:<%= request.getParameter("time") %>
My Data:<%= request.getParameter("data") %>
```
## 4.＆lt; jsp：useBean＆gt;行动
在这里阅读更多内容 - [＆lt; jsp：useBean＆gt;，＆lt; jsp：setProperty＆gt;和＆lt; jsp：getProperty＆gt;详细](https://beginnersbook.com/2013/11/jsp-usebean-setproperty-getproperty-action-tags/)。
当您想在 JSP 页面中使用 Beans 时，此操作很有用，通过此标记可以轻松调用 bean。
**＆lt; jsp：useBean＆gt;的语法：**
```
<jsp: useBean id="unique_name_to_identify_bean"  class="package_name.class_name" />
```
**＆lt; jsp：useBean＆gt;，＆lt; jsp：setProperty＆gt;的示例＆安培; ＆lt; jsp：getProperty＆gt;：**
一旦使用上面的语句实例化 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.＆lt; jsp：setProperty＆gt;行动
此操作标记用于设置 Bean 的属性，在使用此操作标记时，您可能需要指定 Bean 的唯一名称（它只是 useBean 操作标记的 id 值）。
＆lt; jsp：setProperty＆gt;的**语法**
```
<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 的属性匹配的请求参数都将传递给相应的 setter 方法。
## 6.＆lt; jsp：getProperty＆gt;行动
它用于检索或获取 Bean 属性的值。
＆lt; jsp：getProperty＆gt;的**语法**
```
<jsp: useBean id="unique_name_to_identify_bean"  class="package_name.class_name" />
....
....
<jsp:getProperty name="unique_name_to_identify_bean" property="property_name" />
```
OR
```
<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.＆lt; jsp：plugin＆gt;行动
当需要插件来运行 Bean 类或 Applet 时，使用此标记。
[http://docs.oracle.com/javase/7/docs/technotes/guides/plugin/developer_guide/jsp.html](https://docs.oracle.com/javase/7/docs/technotes/guides/plugin/developer_guide/jsp.html)
### 8.＆lt; jsp：body＆gt;行动
### 9.＆lt; jsp：element＆gt;行动
### 10.＆lt; jsp：text＆gt;行动
### 11.＆lt; jsp：attribute＆gt;行动
\ No newline at end of file
docs/jsp/13.md 0 → 100644
浏览文件 @ 4565aedb
# JSP 包含动作标记 - JSP Tutorial
> 原文： [https://beginnersbook.com/2013/11/jsp-include-action-tag/](https://beginnersbook.com/2013/11/jsp-include-action-tag/)
Include 动作标记用于将另一个资源包含到当前 JSP 页面。包含的资源可以是 HTML，JSP 页面或 Servlet 中的静态页面。我们还可以将参数及其值传递给我们所包含的资源。下面我分享了两个＆lt; jsp：include＆gt;的示例，其中一个包含一个页面而没有传递任何参数，在第二个示例中，我们将几个参数传递给正在包含的页面。
**语法：**
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：＆lt; jsp：include＆gt;没有参数
在这个例子中，我们将使用＆lt; jsp：include＆gt;没有参数的动作标签。因此，页面将包含在当前 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 中。
![IncludeAction-output](img/4054a6bc72927a2fdb8f17310517730d.jpg)
### 示例 2：使用＆lt; jsp：include＆gt;以及＆lt; jsp：param＆gt;
index.jsp
我正在使用**＆lt; jsp：include＆gt;动作**和＆lt; jsp：param＆gt;用于将参数传递给我们将要包含的页面。
```
<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>
```
**Output:**
正如您所看到的，display.jsp 的内容已包含在 index.jsp 中。此外，我们传递的参数正在包含的页面中正确显示。
![include-action-with-parameters-output](img/cbc52656a6a5048a5834e8cd173d03a2.jpg)
如果您对该主题有任何疑问和疑问，请告诉我们。我们很乐意帮助您！！
\ No newline at end of file
docs/jsp/14.md 0 → 100644
浏览文件 @ 4565aedb
# JSP 包含带参数示例的操作
> 原文： [https://beginnersbook.com/2013/12/jsp-include-with-parameter-example/](https://beginnersbook.com/2013/12/jsp-include-with-parameter-example/)
之前我们已经分享了如何使用 [include 指令](https://beginnersbook.com/2013/11/jsp-include-directive/)和 [include action](https://beginnersbook.com/2013/11/jsp-include-action-tag/) 标签将页面包含到另一个 JSP 页面。我们还讨论了 include 指令和 include 动作标签之间的[区别。在这篇文章中，我们将看到如何在使用 jsp include action 标签（＆lt; JSP：Include＆gt;）时将参数传递给包含的页面。为了传递参数，我们需要使用**＆lt; jsp：param＆gt;动作标签**。](https://beginnersbook.com/2013/12/difference-between-include-directive-and-include-tag-in-jsp/)
## 例
在这个例子中，我们使用＆lt; jsp：include＆gt;将 JSP 页面（file.jsp）包含到主 JSP 页面（index.jsp）中。动作标签。要将参数从索引传递到文件页面，我们使用＆lt; jsp：param＆gt;动作标签。我们传递了三个参数 firstname，middlename 和 lastname，对于每个参数我们需要指定相应的参数名称和参数值。我们可以使用表达式语言或表达式标签＆amp; amp;隐含的对象。
的 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}
```
**输出：**
![jsp-param-action](img/6a4f96bd45f7e354a608165b9633e1d8.jpg)
如您所见，包含的页面显示了从主页面传递的参数值。为了在 file.jsp 页面上显示参数，我们使用了[表达式语言（$ {}）](https://beginnersbook.com/2013/11/jsp-expression-language-el/)。但是，您也可以使用以下代码，该代码使用 JSP [表达式标记](https://beginnersbook.com/2013/11/jsp-expression-tag/)和[请求隐式对象](https://beginnersbook.com/2013/11/jsp-implicit-object-request-with-examples/)。
```
<%= request.getParameter("firstname")%>
<%= request.getParameter("middlename")%>
<%= request.getParameter("lastname")%>
```
这就是我们对这个话题的全部看法。在接下来的文章中，我们将讨论如何使用 include 指令将参数及其值传递到另一个页面。同时，如果您有任何疑问，请在下面的评论部分中提出相同的问题。
\ No newline at end of file
docs/jsp/15.md 0 → 100644
浏览文件 @ 4565aedb
# JSP 转发动作标签 - JSP Tutorial
> 原文： [https://beginnersbook.com/2013/11/jsp-forward-action-tag/](https://beginnersbook.com/2013/11/jsp-forward-action-tag/)
JSP 转发动作标记用于将请求转发到另一个资源（它可以是 JSP，静态页面，如 html 或 Servlet）。可以使用或不使用参数转发请求。在本教程中，我们将看到＆lt; jsp：forward＆gt;的示例。动作标签。
**语法：**
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。我们使用了＆lt; jsp：forward＆gt; index.jsp 中的 action 标记，用于将请求转发给 display.jsp。这里我们在使用 action 标签时没有传递任何参数。在下一个示例中，我们还将参数传递给另一个资源。
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>
```
**输出：**
下面是上面 cpde 的输出。它基本上是 display.jsp 的内容，它清楚地表明 index.jsp 在将请求转发到 **display.jsp** 页面时没有显示。
![JSPForward-Output](img/73b4897b68343893370487ffd11d4743.jpg)
### JSP 转发示例 2 - 带参数
这里我们传递参数和前向请求。对于传递参数，我们使用＆lt; jsp：param＆gt;动作标签。在这个例子中，我们传递了 4 个参数和前进，后来我们在转发的页面上显示它们。为了获取 display.jsp 页面上的参数，我们使用[请求隐式对象](https://beginnersbook.com/2013/11/jsp-implicit-object-request-with-examples/ "Request implicit object")的 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>
```
**Output:**
上面的代码直接显示了 display.jsp 页面，它显示了从 index.jsp 页面传递的参数。
![forward-param-output](img/c295f2d1097f295c5c01fd6d053120d0.jpg)
\ No newline at end of file
docs/jsp/16.md 0 → 100644
浏览文件 @ 4565aedb
# jsp：useBean，jsp：setProperty 和 jsp：getProperty Action Tags
> 原文： [https://beginnersbook.com/2013/11/jsp-usebean-setproperty-getproperty-action-tags/](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>
```
**输出：**
![useBean-output1](img/b62f01b6c78686843a03c68b29a0f214.jpg)
![useBean-output2](img/680b3485730b9081fedec3ebf42a87d9.jpg)
\ No newline at end of file
docs/jsp/17.md 0 → 100644
浏览文件 @ 4565aedb
# 表达式
\ No newline at end of file
docs/jsp/18.md 0 → 100644
浏览文件 @ 4565aedb
# JSP Expression Tag - JSP 教程
> 原文： [https://beginnersbook.com/2013/11/jsp-expression-tag/](https://beginnersbook.com/2013/11/jsp-expression-tag/)
Expression 标记评估放置在其中的表达式，将结果转换为 String 并通过[响应对象](https://beginnersbook.com/2013/11/jsp-implicit-object-response-with-examples/ "Response implicit object")将结果发送回客户端。基本上它将结果写入客户端（浏览器）。
**JSP 中表达式标记的语法：**
```
<%= expression %>
```
## JSP 表达式标记示例
**例 1：值的表达**
这里我们只是在表达式标记内传递值的表达式。
```
<html>
<head>
<title>JSP expression tag example1</title>
</head>
<body>
<%= 2+4*5 %>
</body>
</html>
```
**输出：**
![expression-tag-example1](img/8b7794be234d1b04f137fd4c05ab57c9.jpg)
**例 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>
```
**Output:**
![expression-tag-example2](img/4723ff956f637c354e65e4b608ba1ef7.jpg)
**示例 3：字符串和隐式对象输出**
在此示例中，我们使用[应用程序隐式对象](https://beginnersbook.com/2013/11/jsp-implicit-object-application-with-examples/ "Application object")设置属性，然后使用表达式标记在另一个 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>
```
**Output:**
![expression-tag-output1](img/6ba49b31d74e9a3c85519df9e3e4ee81.jpg)
![expression-tag-output2](img/8788b99b914cad53ec924c6c5dbb6ee7.jpg)
\ No newline at end of file
docs/jsp/19.md 0 → 100644
浏览文件 @ 4565aedb
# 声明
\ No newline at end of file
docs/jsp/2.md 0 → 100644
浏览文件 @ 4565aedb
# 概观
\ No newline at end of file
docs/jsp/20.md 0 → 100644
浏览文件 @ 4565aedb
# JSP 声明标记 - JSP 教程
> 原文： [https://beginnersbook.com/2013/11/jsp-declaration-tag/](https://beginnersbook.com/2013/11/jsp-declaration-tag/)
声明标记是用于声明类宽变量，方法和类的 java 代码块。这些标记内的任何内容都会在 JSP 初始化阶段初始化并具有类范围。 JSP 容器将此代码保留在服务方法（_jspService（））之外，以使它们成为类级变量和方法。
我们知道变量也可以使用 [scriptlet](https://beginnersbook.com/2013/05/jsp-tutorial-scriptlets/ "Scriptlet") 进行初始化，但这些声明放在 _jspService（）方法中，而不会使它们成为类范围的声明。另一方面，**声明标签**可用于定义类级变量，方法和类。
**声明标签语法：**
```
<%!  Declaration %>
```
**示例 1：变量声明**
在此示例中，我们在声明标记内声明了两个变量，并使用[表达式标记](https://beginnersbook.com/2013/11/jsp-expression-tag/ "Expression tag")在客户端上显示它们。
```
<html>
<head>
<title>Declaration tag Example1</title>
</head>
<body>
<%! String name="Chaitanya"; %>
<%! int age=27; %>
<%= "Name is: "+ name %><br>
<%= "AGE: "+ age %>
</body>
</html>
```
**输出**：
![declaration-tag-example1](img/4590137956e81273edbd33a58435e1d7.jpg)
**例 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>
```
**输出：**
所有三个整数的总和将显示在浏览器上。
![methods-declaration](img/a29e76a131232cc6378913dc9f358190.jpg)
如果你有任何疑问，请告诉我们。
\ No newline at end of file
docs/jsp/21.md 0 → 100644
浏览文件 @ 4565aedb
# JSP 隐式对象
\ No newline at end of file
docs/jsp/22.md 0 → 100644
浏览文件 @ 4565aedb
# Jsp 隐式对象
> 原文： [https://beginnersbook.com/2013/11/jsp-implicit-objects/](https://beginnersbook.com/2013/11/jsp-implicit-objects/)
这些对象由 JSP Engine 在转换阶段（将 JSP 转换为 Servlet 时）创建。它们是在服务方法中创建的，因此我们可以直接在 **Scriptlet** 中使用它们，而无需初始化和声明它们。 JSP 中总共有 9 个隐式对象。
**隐式对象及其对应的类：**
| 出 | javax.servlet.jsp.JspWriter |
| 请求 | javax.servlet.http.HttpServletRequest |
| 响应 | javax.servlet.http.HttpServletResponse |
| 会议 | 的 javax.servlet.http.HttpSession |
| 应用 | javax.servlet.ServletContext |
| 例外 | javax.servlet.jsp.JspException |
| 页 | java.lang.Object 继承 |
| 的 pageContext | javax.servlet.jsp.PageContext |
| 配置 | javax.servlet.ServletConfig |
1. **Out** ：用于将内容写入客户端（浏览器）。它有几种方法可用于正确格式化输出消息到浏览器和处理缓冲区。
在这里阅读全文» [OUT 隐含对象的例子](https://beginnersbook.com/2013/11/jsp-implicit-object-out-with-examples/ "OUT")。
2. **Request** ：请求隐式对象的主要目的是获取用户在之前的 JSP 页面上输入的 JSP 页面上的数据。在 JSP 中处理登录和注册表单时，我们经常提示用户填写这些详细信息，然后使用此对象在另一个 JSP 页面（操作页面）上获取这些输入的详细信息，以进行验证和其他目的。
在这里阅读全文»[使用示例请求隐式对象](https://beginnersbook.com/2013/11/jsp-implicit-object-request-with-examples/ "Request")。
3. **响应**：它主要用于修改或延迟处理请求后发送给客户端（浏览器）的响应。
在这里阅读全文»[回复隐含对象与示例](https://beginnersbook.com/2013/11/jsp-implicit-object-response-with-examples/ "Response")。
4. **会话：**它是最常用的隐式对象，用于存储用户的数据，使其在其他 JSP 页面上可用，直到用户会话处于活动状态。
阅读全文»会话隐含对象与示例。
5. **应用程序：**这用于获取应用程序范围的初始化参数并在整个 JSP 应用程序中维护有用的数据。
在这里阅读全文»[应用隐含对象的例子](https://beginnersbook.com/2013/11/jsp-implicit-object-application-with-examples/ "Application")。
6. **异常：**异常隐式对象用于异常处理以显示错误消息。此对象仅适用于将 isErrorPage 设置为 true 的 JSP 页面。
在这里阅读全文»[异常隐含对象与示例](https://beginnersbook.com/2013/11/jsp-implicit-object-exception-with-examples/ "Exception")。
7. **页面：**页面隐式对象是对当前 Servlet 实例的引用（转换后的 Servlet，在 JSP 页面的转换阶段生成）。我们可以简单地使用**来代替它**。我没有详细介绍它，因为它很少使用，而且在构建 JSP 应用程序时不是一个有用的隐式对象。
8. **pageContext** ：用于访问页面，请求，应用程序和会话属性。
在这里阅读全文» [pageContext 隐含对象与示例](https://beginnersbook.com/2013/11/jsp-implicit-object-pagecontext-with-examples/ "PageContext")。
9. **配置：**这是一个 Servlet 配置对象，主要用于访问获取配置信息，如 servlet 上下文，servlet 名称，配置参数等。
阅读全文»[用示例配置隐式对象](https://beginnersbook.com/2013/11/jsp-implicit-object-config-with-examples/ "Config")。
\ No newline at end of file
docs/jsp/23.md 0 → 100644
浏览文件 @ 4565aedb
# 用例子中的 JSP 中的隐式对象
> 原文： [https://beginnersbook.com/2013/11/jsp-implicit-object-out-with-examples/](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（）
让我们详细看看每个方法 -
1. **void print（）**：此方法写入已传递给它的值。对于例如下面的语句将在 jSP 中显示一个句子 Out Implicit Object - BeginnersBook 到输出屏幕（客户端浏览器）。
```
out.print(“Out Implicit Object in jSP - BeginnersBook”);
```
2. **void println()**: This method is similar to the print() method, the only difference between print and println is that the println() method adds a new line character at the end. Let’s have a look at the difference with the help of an example.
**print:**
```
out.print(“hi”);
out.print(" ");
out.print(“hello”);
```
浏览器输出：所有 3 个 out.print 语句的结果之间不会有新的界限。
你好
**println：**
```
out.println(“hi”);
out.println(“hello”);
```
浏览器输出：
hi
你好
3. **void newLine()**: This method adds a new line to the output. Example –
```
out.print(“This will write content without a new line”);
out.newLine();
out.print(“I’m just an another print statement”);
```
**输出：**
这将写入没有换行的内容
我只是另一个打印声明
如您所知，print 语句不会添加新行。我们使用 newLine（）方法在两个 out.print 语句之间添加了一个新行。
4. **void clear（）**：它清除输出缓冲区，甚至不让它将缓冲区内容写入客户端。这就是它的名称 -
```
out.clear();
```
5. **void clearBuffer（）**：此方法类似于 clear（）方法。它们之间的唯一区别是，当我们在已经刷新的缓冲区上调用 out.clear（）时会抛出异常，但 out.clearBuffer（）却没有。
6. **void flush（）**：这个方法也像 clear（）方法一样清除缓冲区但强制它在刷新之前将内容写入输出，这意味着缓冲区中的任何内容都会被写入清除缓冲区之前的客户端屏幕。
7. **boolean isAutoFlush（）**：返回布尔值 true / false。它用于检查缓冲区是否自动刷新。
8. **int getBufferSize（）**：此方法以字节为单位返回输出缓冲区的大小。
9. **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>
```
**输出：**
打印语句 println
另一个打印语句
\ No newline at end of file
docs/jsp/24.md 0 → 100644
浏览文件 @ 4565aedb
# 使用示例在 JSP 中请求隐式对象
> 原文： [https://beginnersbook.com/2013/11/jsp-implicit-object-request-with-examples/](https://beginnersbook.com/2013/11/jsp-implicit-object-request-with-examples/)
这里我们将讨论 JSP 中的请求隐式对象。它主要用于获取用户在之前的 JSP 页面上输入的 JSP 页面上的数据。
### 请求隐式对象的方法
1. **getParameter（String name）** - 此方法用于获取请求参数的值。例如，在登录页面，用户输入用户 ID 和密码，一旦验证了凭证，登录页面就会被重定向到用户信息页面，然后使用 request.getParameter 我们可以获得用户输入的用户 ID 和密码的值。登录页面。
```
String Uid= request.getParameter("user-id");
String Pass= request.getParameter("password");
```
2. **getParameterNames（） -** 它返回与请求关联的所有参数名称的枚举。
```
Enumeration e= request.getParameterNames();
```
3. **getParameterValues（String name） -** 它返回参数值数组。
```
String[] allpasswords = request.getParameterValues("password");
```
4. **getAttribute（String name） -** 用于获取属性值。 request.getAttribute（“admin”）将为您提供属性 admin 的值。
5. **getAttributeNames（） -** 它通常用于获取与当前会话关联的属性名称。它返回会话中存在的属性名称的枚举。
```
Enumerator e = request.getAttributeNames();
```
6. **setAttribute（String，Object） -** 它将一个对象的值赋给该属性。例如，我有一个属性**密码**和一个 String 对象 str，其值为**“admin”**然后调用 request.setAttribute（“password”，str）将赋值 **admin** 到属性**密码**。
7. **removeAttribute（String） -** 通过使用此方法，可以删除属性，不能进一步使用。对于例如如果在 JSP 页面上有声明 **request.removeAttribute（“userid”）**，那么 userid 属性将被完全删除，而 request.getAttribute（“userid”）将返回 **NULL** 在 removeAttribute 方法之后使用。
8. **getCookies（） -** 它返回从客户端收到的 cookie 对象数组。此方法主要用于处理 JSP 中的 cookie。
9. **getHeader（String name） -** 此方法用于获取请求的头信息。
10. **getHeaderNames（） -** 返回所有标题名称的枚举数。下面的代码片段将显示与请求关联的所有标头名称。
```
Enumeration e = request.getHeaderNames();
while (enumeration.hasMoreElements()) {
String str = (String)e.nextElement();
out.println(str);
}
```
11. **getRequestURI（） -** 此方法（request.getRequestURI（））返回当前 JSP 页面的 URL。
12. **getMethod（） -** 它返回 HTTP 请求方法。 request.getMethod（）。例如，它将为 Get 请求返回 GET，为 Post Request 返回 POST。
13. **getQueryString（） -** 用于获取与 JSP 页面 URL 关联的查询字符串。它是在问号符号（？）后与 URL 相关联的字符串。
### 请求隐式对象示例
在下面的示例中，我们在 index.html 页面中接收来自用户的输入，并使用请求隐式对象在 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 代码。它会显示以下屏幕，其中包含两个用户名和密码的文本字段。
![LoginPage](img/291c80e2f77ee54e6fff9a1525f2e6ae.jpg)
这是 **userinfo.jsp** 页面的输出。这里我们获取了用户在登录页面中输入的 id 和密码。
![UserInfoPage](img/a5e9c89b44125c74a1671d7e738c0f16.jpg)
如果您对 JSP 请求隐式对象有任何疑问，请告诉我们。我们很乐意帮助您！！
\ No newline at end of file
docs/jsp/25.md 0 → 100644
浏览文件 @ 4565aedb
# 使用示例在 JSP 中响应隐式对象
> 原文： [https://beginnersbook.com/2013/11/jsp-implicit-object-response-with-examples/](https://beginnersbook.com/2013/11/jsp-implicit-object-response-with-examples/)
在这篇文章中，我们将讨论 JSP 中的响应隐式对象。它是 **javax.servlet.http.HttpServletRequest** 的一个实例，主要用于修改处理客户端请求后发送给浏览器的响应。
**快速链接：**
* [响应隐式对象完成示例](#example)
* [输出截图](#output)
### 响应隐式对象的方法
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 值）
void sendError（int status_code，String message）
boolean isCommitted（）
void setStatus（int statuscode）
让我们详细了解每种方法 -
1. **void setContentType（String type） -** 此方法通过设置 MIME 类型和字符编码告诉浏览器，响应数据的类型。此方法设置的信息有助于浏览器解释响应。示例 -
```
response.setContentType("text/html");
response.setContentType("image/gif");
response.setContentType("image/png");
response.setContentType("application/pdf");
```
2. **void sendRedirect（String address） -** 它将控件重定向到新的 JSP 页面。对于例如当浏览器检测到以下语句时，它将从当前 JSP 页面重定向到 beginnersbook.com。
```
response.sendRedirect("http://beginnersbook.com");
```
3. **void addHeader（String name，String value） -** addHeader 方法为响应添加一个标题，基本上它包含一个标题名称及其值。例如 - 以下语句将在响应中包含标题“Site”，其值为“BeginnersBook.com”。
```
response.addHeader("Site", "BeginnersBook.com");
```
4. **void setHeader（String name，String value） -** 设置标头值。此方法使用新值覆盖标头的当前值。假设我正在修改 Header“ **Site** ”的值。以下声明会将当前值 BeginnersBook.com 修改为新值 BB.com
```
response.setHeader("Site", "BB.com");
```
5. **boolean containsHeader（String name） -** 它返回一个布尔值 true / false。它基本上检查响应中是否存在标题。例如 - 在上面，在 addHeader 方法示例中，我们在响应中添加了 **Site** Header，因此以下语句将返回 true。
```
response.containsHeader("Site");
```
6. **void addCookie（Cookie cookie） -** 此方法将 cookie 添加到响应中。以下陈述将在回复中添加 2 个 Cookie **作者**和 **Siteinfo** 。
```
response.addCookie(Cookie Author);
response.addCookie(Cookie Siteinfo);
```
7. **void sendError（int status_code，String message） -** 它用于通过代码和错误消息发送错误响应。例如 -
```
response.sendError(404, "Page not found error");
```
8. **boolean isCommitted（）** - 检查 Http Response 是否已发送到客户端，如果是，则返回 true，否则返回 false。
```
&lt;% if(response.isCommited())
{
&lt;%--do something --%&gt;
}else
{
&lt;%--do something else --%&gt;
} %&gt;
```
9. **void setStatus（int statuscode）** - 此方法用于将 HTTP 状态设置为给定值。对于例如以下语句将 HTTP 响应代码设置为 404（找不到页面）。
```
response.setStatus(404);
```
### 响应隐式对象示例
在下面的示例中，我们从登录页面接收 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>
```
### 输出截图：
登录页面
![LoginPage](img/6b90af409aff5dc567dcf8936ffb5fd8.jpg)
成功页面：当 userId 和密码正确时。
![SuccessPage](img/7854ea5260331546b631c3bd2a6c7aee.jpg)
登录时错误的细节。
![IncorrectInput](img/be67d1871d1bc4cc91567fec9c972b05.jpg)
登录失败页面：当 Id 和密码错误时。
![SignIn-Failed](img/8dd24ea6f942e814fb69af760035f8af.jpg)
目前为止就这样了。如果您对 JSP 中的响应隐式对象有任何疑问和疑问，请告诉我们。
\ No newline at end of file
docs/jsp/26.md 0 → 100644
浏览文件 @ 4565aedb
# JSP 中的 Session 隐式对象及其示例
> 原文： [https://beginnersbook.com/2013/11/jsp-implicit-object-session-with-examples/](https://beginnersbook.com/2013/11/jsp-implicit-object-session-with-examples/)
Session 是 JSP 中最常用的隐式对象。它的主要用途是访问所有用户的数据，直到用户会话处于活动状态。
### 会话隐式对象的方法
1. **setAttribute（String，object） -** 此方法用于通过为对象分配唯一字符串来保存会话中的对象。之后，可以使用相同的 String 从会话中访问该对象，直到会话处于活动状态。 setAttribute 和 getAttribute 是在 JSP 中处理会话时最常用的两种方法。
2. **getAttribute（String name） -** setAttribute 方法存储的对象是使用 getAttribute 方法从 session 获取的。例如，如果我们需要访问每个 jsp 页面上的 userid，直到会话处于活动状态，那么我们应该使用 setAttribute 方法将 user-id 存储在会话中，并且可以在需要时使用 getAttribute 方法进行访问。
3. **removeAttribute（String name） -** 可以使用此方法从会话中删除存储在会话中的对象。将唯一字符串标识符作为 removeAttribute 的方法传递。
4. **getAttributeNames -** 它返回会话中存储的所有对象。基本上，它会导致对象的枚举。
5. **getCreationTime -** 此方法返回会话创建时间，即会话启动的时间（变为活动状态）。
6. **getId -** Servlet 容器在创建会话时为会话分配唯一​​的字符串标识符。 **getId** 方法返回该唯一字符串标识符。
7. **isNew（） -** 用于检查会话是否是新的。它返回布尔值（true 或 false）。主要用于跟踪客户端是否启用了 cookie。如果禁用 cookie，session.isNew（）方法将始终返回 **true** 。
8. **invalidate（） -** 它会终止会话并中断会话与所有存储对象的关联。
9. **getMaxInactiveInterval -** 以秒为单位返回会话的最大停用时间间隔。
10. **getLastAccessedTime -** 通常用于知道会话的最后访问时间。
### 会话隐式对象示例
下面的 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.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-welcome-page](img/5ff7d1250a54296a6bc4f727b5c30394.jpg)
![User-jsp-page](img/64926bce4c1999bda12040344ca8ac0d.jpg)
![output-screen](img/209bae8354e2d8abf534651782c8f1f1.jpg)
\ No newline at end of file
docs/jsp/27.md 0 → 100644
浏览文件 @ 4565aedb
# JSP 中的应用程序隐式对象及其示例
> 原文： [https://beginnersbook.com/2013/11/jsp-implicit-object-application-with-examples/](https://beginnersbook.com/2013/11/jsp-implicit-object-application-with-examples/)
Application 隐式对象是 **javax.servlet.ServletContext** 的一个实例。它主要用于获取初始化参数和共享属性＆amp;它们在整个 JSP 应用程序中的值，这意味着**应用程序隐式对象**设置的任何属性都可用于所有 JSP 页面。
**方法：**
* Object getAttribute（String attributeName）
* void setAttribute（String attributeName，Object object）
* void removeAttribute（String objectName）
* 枚举 getAttributeNames（）
* String getInitParameter（String paramname）
* 枚举 getInitParameterNames（）
* String getRealPath（String value）
* void log（String message）
* URL getResource（String value）
* InputStream getResourceAsStream（String path）
* String getServerInfo（）
* String getMajorVersion（）
* String getMinorVersion（）
1. **Object getAttribute（String attributeName）：**它返回存储在给定属性名称中的对象。例如，下面的语句将返回存储在属性“MyAttr”中的对象。
```
String s = (String)application.getAttribute("MyAttr");
```
2. **void setAttribute(String attributeName, Object object):** It sets the value of an attribute or in other words it stores an attribute and its value in application context, which is available to use across JSP application. Example –
```
application.setAttribute(“MyAttribute”, “This is the value of Attribute”);
```
上面的语句将存储属性及其值。如果我们在任何 JSP 页面中使用以下语句，那么's'的值是多少？
```
String s= (String) application.getAttribute(“MyAttribute”);
```
字符串的值将是“这是属性的值”，因为我们使用 setAttribute 方法设置它。
3. **void removeAttribute（String objectName）：**此方法用于从应用程序中删除给定属性。对于例如 - 它将从应用程序中删除属性“MyAttr”。如果我们尝试使用 getAttribute 方法获取已删除属性的值，则它将返回 Null。
```
application.removeAttribute(“MyAttr”);
```
4. **Enumeration getAttributeNames（）：**此方法返回存储在应用程序隐式对象中的所有属性名称的枚举。
```
Enumeration e= application.getAttributeNames();
```
5. **String getInitParameter(String paramname):** It returns the value of Initialization parameter for a given parameter name. Example –web.xml
```
&lt;web-app&gt;
…
&lt;context-param&gt;
&lt;param-name&gt;parameter1&lt;/param-name&gt;
&lt;param-value&gt;ValueOfParameter1&lt;/param-value&gt;
&lt;/context-param&gt;
&lt;/web-app&gt;
```
假设上面是我的 web.xml 文件
```
String s=application.getInitParameter(“parameter1”);
```
s 的值将是“ValueOfParameter1”。仍然困惑它来自哪里？请参阅 web.xml 文件中的 param-value 标记。
6. **Enumeration getInitParameterNames（）：**它返回所有 Initialization 参数的枚举。
```
Enumeration e= application.getinitParameterNames();
```
7. **String getRealPath(String value):** It converts a given path to an absolute path in the file system.
```
String abspath = application.getRealPath(“/index.html”);
```
abspath 的值将是基于现有文件系统的完整 http URL。
8. **void log(String message):** This method writes the given message to the JSP Engine’s (JSP container’s) default log file associated to the application.
```
application.log(“This is error 404 Page not found”);
```
上面的调用会将消息“这是找不到错误 404 页面”写入默认日志文件。
9. **String getServerInfo（）：**此方法返回 JSP 容器（JSP Engine）的名称和版本。
```
application.getServerInfo();
```
**应用隐式对象示例**
一个 JSP 页面，用于捕获使用应用程序的命中数。在此示例中，我们使用应用程序隐式对象计算 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。
![application1](img/cc49f2285d5766b9bfc7e8e7fa14dd6d.jpg)
刷新页面时，点击次数增加了。
![application2](img/540faaa321ba3bb2e0c03a32e54d4bf2.jpg)
如果您喜欢该教程，请在 Facebook 和 Google+上与您的朋友分享。
\ No newline at end of file
docs/jsp/28.md 0 → 100644
浏览文件 @ 4565aedb
# JSP 中的异常隐式对象，带有示例
> 原文： [https://beginnersbook.com/2013/11/jsp-implicit-object-exception-with-examples/](https://beginnersbook.com/2013/11/jsp-implicit-object-exception-with-examples/)
在本教程中，我们将讨论 JSP 的异常隐式对象。它是 java.lang.Throwable 的一个实例，经常用于 JSP 中的异常处理。此对象仅适用于错误页面，这意味着 JSP 页面的 isErrorPage 应为 true，以便使用异常隐式对象。让我们在下面的例子的帮助下理解这一点 -
### 异常隐式对象示例
在这个例子中，我们从用户那里获取两个整数输入，然后我们在它们之间进行划分。我们在下面的例子中使用了异常隐式对象来处理任何类型的异常。
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 Directive 的 **errorPage 属性来指定异常处理 JSP 页面（＆lt;％@ page errorPage =“exception.jsp”％＆gt;）。**
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.jsp
```
<%@ page isErrorPage="true" %>
Got this Exception: <%= exception %>
Please correct the input data.
```
**输出**
屏幕，带有两个输入字段，用于两个整数。
![inputPage](img/7965054e324d77ec7839986ddc91ec1d.jpg)
当我们提供第二个整数为零时的算术异常消息。
![exceptionPage](img/1dcec75b0e559850cdbcd7512a10a230.jpg)
如果您对 JSP 中的异常隐式对象有任何疑问，请告诉我们。这是在 JSP 中构建应用程序时最常用的隐式对象之一。作为替代方案，您还可以通过在 JSP scriptlet 中使用 try catch 来处理 JSP 中的异常。
\ No newline at end of file
docs/jsp/29.md 0 → 100644
浏览文件 @ 4565aedb
# pageContext JSP 中的隐式对象，带有示例
> 原文： [https://beginnersbook.com/2013/11/jsp-implicit-object-pagecontext-with-examples/](https://beginnersbook.com/2013/11/jsp-implicit-object-pagecontext-with-examples/)
它是 **javax.servlet.jsp.PageContext** 的一个实例。使用此对象，您可以在以下任何级别找到属性，获取属性，设置属性和删除属性 -
1. JSP 页面 - 范围：PAGE_CONTEXT
2. HTTP 请求 - 范围：REQUEST_CONTEXT
3. HTTP 会话 - 范围：SESSION_CONTEXT
4. 应用程序级别 - 范围：APPLICATION_CONTEXT
**快速链接：**
* [pageContext 隐式对象完整示例](#example)
* [示例输出](#output)的屏幕截图
### pageContext 隐式对象的方法
1. **Object findAttribute（String AttributeName）：**此方法按以下顺序搜索所有四个级别中的指定属性 - 页面，请求，会话和应用程序。当在任何级别找不到属性时，它返回 NULL。
2. **Object getAttribute (String AttributeName, int Scope):** It looks for an attribute in the specified scope. This method is similar to findAttribute method; the only difference is that findAttribute looks in all the four levels in a sequential order while getAttribute looks in a specified scope. For e.g. – In the below statement the getAttribute method would search for the attribute “BeginnersBook” in **Session scope (or Session level/layer).** If it finds the attribute it would assign it to Object obj else it would return 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);
```
3. **void removeAttribute（String AttributeName，int Scope）：**此方法用于从给定范围中删除属性。例如 - 下面的 JSP 语句将从页面范围中删除属性“MyAttr”。
```
pageContext.removeAttribute(“MyAttr”, PageContext. PAGE_CONTEXT);
```
4. **void setAttribute(String AttributeName, Object AttributeValue, int Scope):** It writes an attribute in a given scope. Example – Below statement would store an Attribute “mydata” in application scope with the value “This is my data”.
```
pageContext.setAttribute(“mydata”, “This is my data”, PageContext. APPLICATION_CONTEXT);
```
类似地，这将在 Request 范围中创建名为 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 和密码的登录页面。
![pageContext1](img/348d540e90f7672dc94f476b690d7be2.jpg)
有详细页面链接的页面 -
![pageContext2](img/4b84badc5e0bdc088b98a734cce5c676.jpg)
用户凭据显示页面，我们已通过 **pageContext** 实例从登录页面传递到此页面。
![pageContext3](img/23ba9a9822a70bb54d3a2dcdec8cae04.jpg)
如果您对 pageContext 隐式对象有任何疑问，请随时通过删除评论来询问。我们非常乐意为您提供帮助！
\ No newline at end of file
docs/jsp/3.md 0 → 100644
浏览文件 @ 4565aedb
# Java Server Pages 简介 - JSP 教程
> 原文： [https://beginnersbook.com/2013/05/jsp-tutorial-introduction/](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，示例 JSP 代码**。
**上述代码**
的说明 1）行**＆lt;％ - JSP Comment - ％＆gt;** 表示名为 JSP Comment 的 JSP 元素，在向 JSP 页面添加注释时可以使用此标记，我们将在后续帖子中详细讨论。
**注意：** JSP 注释必须以标签**＆lt;％ -** 开头，以 **- ％＆gt;结尾。**
**2）Head，Title 和 Body 标签是 HTML 标签** - 它们是 HTML 标签，经常用于静态网页。无论他们拥有什么内容，都会传递给客户端（Web 浏览器）。
3）**＆lt;％out.print（“Hello，Sample JSP code”）;％＆gt;** 是一个 JSP 元素，称为 Scriptlet。 Scriptlet 可以包含 Java 代码。 scriptlet 的**语法是：**＆lt;％Executable java code％＆gt;。由于 Scriptlets 中的代码是 java 语句，因此它们必须以分号（;）结尾。 out.print（“Hello，示例 JSP 代码”）是一个 java 语句，它打印“Hello，Sample JSP code”。
如上所述，JSP 用于创建动态网页。动态网页通常是静态和网络的混合。动态内容。
**静态内容**可以使用基于文本的格式，如 HTML，XML 等，**动态内容**由 JSP 标签使用 HTML 内部的 Java 代码生成。
## Servlet 与 JSP
与 JSP 一样，Servlet 也用于生成动态网页。这是他们之间的比较。
它们之间的主要区别在于 servlet 在 java 中添加了 HTML 代码，而 JSP 在 HTML 中添加了 Java 代码。还有一些其他值得注意的要点如下：
**Servlets** -
1. Servlet 是一个支持 HTML 标签的 Java 程序。
2. 通常用于开发企业应用程序的业务层（复杂计算代码）。
3. Servlet 由 Java 开发人员创建和维护。
**JSP** -
1. JSP 程序也是支持 java 语句的 HTML 代码。更准确地说，JSP 使用 JSP 标记在 java 中嵌入 java。
2. 用于开发企业应用程序的表示层
3. 经常用于设计网站并由 Web 开发人员使用。
## JSP 的优点
1. JSP 具有 servlet 的所有优点，如：比 CGI 更好的性能内置会话功能，它还继承了 Java 技术的特性，如多线程，异常处理，数据库连接等。
2. JSP 支持将内容生成与内容呈现分离。这使它更灵活。
3. 使用 JSP，Web 设计人员现在可以轻松地显示需要的信息。
4. Web 应用程序程序员可以专注于如何处理/构建信息。
## JSP 应用程序的体系结构
在我们开始开发 Web 应用程序之前，我们应该对架构有一个基本的想法。根据请求处理发生的位置（Servlet OR JSP（Java 服务器页面）），JSP 有两种体系结构。它们是 - Model1 Architecture＆amp; Model2 架构。
**1）Model1 架构**：在这个模型中，JSP 起着关键作用，它负责处理客户端发出的请求。客户端（Web 浏览器）发出请求，JSP 然后创建一个 bean 对象，然后完成请求并将响应传递给 JSP。 JSP 然后将响应发送回客户端。与 Model2 体系结构不同，在此模型中，大多数处理都是由 JSP 本身完成的。
![JSP Architecture Model 1](img/a3567344da7f269bc8b86ee8b87bdd51.jpg)
**2）Model2 架构**：在这个模型中，Servlet 扮演着重要角色，它负责处理客户端（Web 浏览器）请求。演示部分（GUI 部分）将由 JSP 处理，并在 bean 的帮助下完成，如下图所示。 servlet 充当控制器并负责请求处理。如果 jsp 页面需要，它会创建 bean 对象并调用相应的 jsp 页面。 jsp 使用 bean 对象处理表示部分。在这个模型中，JSP 不进行任何处理，Servlet 根据客户端的请求创建 bean Object 并调用 JSP 程序。
![JSP Architecture Model 2](img/20b52bd26df647be1f1860b8b346fca0.jpg)
\ No newline at end of file
docs/jsp/30.md 0 → 100644
浏览文件 @ 4565aedb
# 使用示例在 JSP 中配置隐式对象
> 原文： [https://beginnersbook.com/2013/11/jsp-implicit-object-config-with-examples/](https://beginnersbook.com/2013/11/jsp-implicit-object-config-with-examples/)
它是 **javax.servlet.ServletConfig** 的一个实例。 Config Implicit 对象用于获取特定 JSP 页面的配置信息。使用应用程序隐式对象，我们可以获得应用程序范围的初始化参数，但是使用 Config 我们可以获得单个 servlet 映射的初始化参数。
### 配置隐式对象的方法
1. **String getInitParameter（String paramname）** - 与我们在应用程序隐式对象教程中讨论的相同。
2. **Enumeration getInitParameterNames（）** - 返回 Initialization 参数的枚举。
3. **ServletContext getServletContext（）** - 此方法返回对 Servlet 上下文的引用。
4. **String getServletName（）** - 它返回我们在＆lt; servlet-name＆gt;里面的 web.xml 文件中定义的 servlet 的名称。标签。
**配置隐式对象示例**
web.xml
让我们说下面是我的 **web.xml** 文件。我只是在其中定义 servlet 名称和 servlet 映射。稍后，我将使用 config implicit object 从该文件中获取一些细节。
```
<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](img/9610caf21acdc03aa5f7ca3c3b8a1eb4.jpg)
这就是配置隐式对象的全部内容。如果您有任何问题，请随时在下面发表评论。
\ No newline at end of file
docs/jsp/31.md 0 → 100644
浏览文件 @ 4565aedb
# JSP 中的表达式语言（EL）
\ No newline at end of file
docs/jsp/32.md 0 → 100644
浏览文件 @ 4565aedb
# JSP 表达式语言（EL） - JSP 教程
> 原文： [https://beginnersbook.com/2013/11/jsp-expression-language-el/](https://beginnersbook.com/2013/11/jsp-expression-language-el/)
表达式语言（EL）已在 JSP 2.0 中引入。它的主要目的是简化从 [bean](https://beginnersbook.com/2013/11/jsp-usebean-setproperty-getproperty-action-tags/) 属性和[隐式对象](https://beginnersbook.com/2013/11/jsp-implicit-objects/ "Implicit objects")访问数据的过程。 EL 也包括算术运算符，关系运算符和逻辑运算符。
**EL 语法：**
```
${expression}
```
大括号内的任何内容在运行时被评估并被发送到输出流。
**示例 1：表达式语言评估表达式**
在这个例子中，我们在 EL 的帮助下评估表达式。
```
<html>
<head>
<title>Expression language example1</title>
</head>
<body>
${1<2}
${1+2+3}
</body>
</html>
```
**输出：**
![EL-example1](img/9c9ccd5a38aff4425433926d29b4970c.jpg)
**示例 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>
```
输出：
![EL-example2](img/a8a76a273da3e76e646bec2f1e5b5800.jpg)
![Expression-lang-example2](img/1cd2ab3cd1a8b84c3cc207b5d767772d.jpg)
**示例 3：从应用程序对象获取值。**
在这个例子中，我们使用应用程序隐式对象设置了属性，在显示页面上我们使用表达式语言的 **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>
```
Output:
![Expression-lang-example3](img/623e07a80b3eede04471dbcf846dadb8.jpg)
![EL-example3](img/24aecd33192f868d4ea1e42c36d15b7f.jpg)
**EL 预定义变量：**
与 JSP 中的隐式对象类似，我们在 EL 中预定义了变量。在上面的例子中我们使用了 param 和 applicationScope，它们也是这些变量的一部分。
**pageScope** ：它有助于获取存储在 Page 范围中的属性。
**pageContext** ：与 JSP [PageContext 对象](https://beginnersbook.com/2013/11/jsp-implicit-object-pagecontext-with-examples/)相同。
**sessionScope** ：从[会话对象](https://beginnersbook.com/2013/11/jsp-implicit-object-session-with-examples/)设置的会话范围中获取属性。
**requestScope** ：用于从请求范围获取属性。由[设置的属性请求隐式对象](https://beginnersbook.com/2013/11/jsp-implicit-object-request-with-examples/)。
**param** ：类似于 **ServletRequest.getParameter** 。参考例 2\.
**applicationScope** ：用于获取 [Applicaton](https://beginnersbook.com/2013/11/jsp-implicit-object-application-with-examples/) 级别属性。与我们在示例 3 中看到的相同。
**标头**：它有助于将 HTTP 请求标头作为字符串获取。
**headerValues** ：用于获取所有 HTTP 请求头。
**initParam** ：它链接到上下文初始化参数。
**paramValues** ：与 ServletRequest.getParmeterValues 相同。
**cookie** ：它映射到 Cookie 对象。
\ No newline at end of file
docs/jsp/33.md 0 → 100644
浏览文件 @ 4565aedb
# 异常处理
\ No newline at end of file
docs/jsp/34.md 0 → 100644
浏览文件 @ 4565aedb
# JSP 中的异常处理
> 原文： [https://beginnersbook.com/2013/11/jsp-exception-handling/](https://beginnersbook.com/2013/11/jsp-exception-handling/)
在通过 JSP 中的**异常处理之前，让我们了解什么是异常以及它与错误的区别。**
**异常：**这些只是中断正常执行流程的异常情况。大多数情况下，它们是由于用户输入的错误数据而发生的。必须处理异常才能向用户提供有意义的消息，以便用户能够理解问题并采取适当的措施。
**错误：**这可能是代码或系统相关问题的问题。我们不应该处理错误，因为它们是要修复的。
**处理例外的方法：**
我们可以使用以下两种方法处理异常。
* 使用异常[隐式对象](https://beginnersbook.com/2013/11/jsp-implicit-objects/)进行异常处理
* 使用 scriptlet 中的 try catch 块进行异常处理
### 使用异常隐式对象进行异常处理
在下面的例子中 - 我们使用 [Page 指令](https://beginnersbook.com/2013/05/jsp-tutorial-directives/ "Page Directive")的 **errorPage** 属性指定了异常处理页面。如果主 JSP 页面中发生任何异常，控件将被转移到 errorPage 属性中提到的页面。
处理程序页面应将 **isErrorPage 设置为 true** ，以便使用[异常隐式对象](https://beginnersbook.com/2013/11/jsp-implicit-object-exception-with-examples/ "Exception implicit object")。这就是我们为 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>
```
**输出：**
### ![exception-example-output1](img/aca9c8fa8fd912b1c58bbe36b4c154da.jpg)
使用 scriptlet 中的 try catch 块进行异常处理
我们在下面的示例中使用 try catch 块处理了异常。因为 try catch 块是 java 代码所以它必须放在 [sciptlet](https://beginnersbook.com/2013/05/jsp-tutorial-scriptlets/ "Scriptlet") 中。在下面的例子中，我声明了一个长度为 5 的数组，并尝试访问不存在的第 7 个元素。它导致 Array Index 超出范围异常。
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 的**输出：**
![exception-example-output2](img/2eadbc63308048039fc41b036113c318.jpg)
让我们知道您更喜欢哪种方法来处理异常以及原因。如果您有任何疑问，请随时将其放在下面的评论部分。
\ No newline at end of file
docs/jsp/35.md 0 → 100644
浏览文件 @ 4565aedb
# 自定义标签
\ No newline at end of file
docs/jsp/36.md 0 → 100644
浏览文件 @ 4565aedb
# 带有示例的 JSP Custom 标签 - JSP Tutorial
> 原文： [https://beginnersbook.com/2014/01/jsp-custom-tags-with-example-jsp-tutorial/](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** 扩展名。
**注：**
`&lt;name&gt;`标签：自定义标签名称。在这个例子中，我们将它作为`MyMsg`
`&lt;tag-class&gt;`标签给出：完全限定的类名。我们的标签处理程序类`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`。
自定义标签的调用方式如下：`&lt;prefix:tagName/&gt;`。我们的前缀是`myprefix`，标签名称是`MyMsg`，所以我们在下面的 JSP 页面中将其称为`&lt;myprefix:MyMsg/&gt;`。
```
<%@ 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/)
\ No newline at end of file
docs/jsp/37.md 0 → 100644
浏览文件 @ 4565aedb
# 如何在 JSP 教程中访问 Custom 标签的主体
> 原文： [https://beginnersbook.com/2014/01/how-to-access-body-of-custom-tags-in-jsp-tutorial/](https://beginnersbook.com/2014/01/how-to-access-body-of-custom-tags-in-jsp-tutorial/)
在上一个教程中，我们学习了[如何在 JSP](https://beginnersbook.com/2014/01/jsp-custom-tags-with-example-jsp-tutorial/) 中创建和使用自定义标签。在本教程中，我们将了解如何访问自定义标记的主体。对于例如如果我们的自定义标签是`xyz`，那么我们将学习访问`&lt;prefix: xyz&gt;`和`&lt;/prefix:xyz&gt;`之间的内容
```
<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
```
\ No newline at end of file
docs/jsp/4.md 0 → 100644
浏览文件 @ 4565aedb
# Java Server Pages（JSP）生命周期
> 原文： [https://beginnersbook.com/2013/05/jsp-tutorial-life-cycle/](https://beginnersbook.com/2013/05/jsp-tutorial-life-cycle/)
[**«上一个教程：JSP 介绍**](https://beginnersbook.com/2013/05/jsp-tutorial-introduction/)
[**下一个教程：JSP 指令»**](https://beginnersbook.com/2013/05/jsp-tutorial-directives/)
JSP 页面以.jsp 扩展名保存，这使服务器知道这是一个 JSP 页面，需要经历 JSP 生命周期阶段。
在我之前关于 JSP 介绍的文章中，我解释说 JSP 不是这样处理的，它们首先被转换为 Servelts，然后相应的 servlet 由 Server 处理。
当客户端向 Server 发出请求时，它首先转到容器。然后容器检查 servlet 类是否比 jsp 页面旧（确保 JSP 文件被修改）。如果是这种情况，那么容器再次执行转换（将 JSP 转换为 Servlet），否则它会跳过转换阶段（即，如果 JSP 网页未被修改，那么它不会进行转换以提高性能，因为此阶段需要时间并且每次重复这一步都不是时间可行的）
**jsp 页面生命周期中的步骤是：**
1. 翻译
2. 汇编
3. 载入中
4. 实例化
5. 初始化
6. RequestProcessing
7. 毁坏
![JSP-life-cycle](img/836c79b3dfd672a382ebd75720ea4e3b.jpg)
**让我们更详细地看一下 JSP 的生命周期 -**
1）如上所述，只要容器收到来自客户端的请求，它只在 servlet 类比 JSP 页面更旧时才进行转换。其他它跳过这个阶段（我上面解释的原因）。
2）然后容器 -
* 编译相应的 servlet 程序
* 加载相应的 servlet 类
* 实例化 servlet 类
* 调用 **jspInit（）方法**来初始化 servlet 实例（仅当 servlet 文件的实例未运行或者它比 jsp 文件旧时，Jsp 容器才会执行此作业。）
[code language =“java”]
public void jspInit（）
{
//初始化 Servlet 实例的代码
} [/ code]
3）然后创建一个新线程，它调用 **_jspService（）方法**，请求（HttpServletRequest）和响应（HttpServletRespnse）对象作为参数 - 如下所示。
[code language =“java”]
void _jspService（HttpServletRequest req，HttpServletResponse res）
{
//代码到这里
} [/ code]
4）调用 **jspDestroy（）方法**来销毁 servlet 类的实例。代码如下所示 -
[code language =“java”]
public void jspDestory（）
{
//代码删除 servlet 类的实例
} [/ code]
[**« Previous Tutorial: JSP Introduction**](https://beginnersbook.com/2013/05/jsp-tutorial-introduction/)
[**Next Tutorial: JSP Directives »**](https://beginnersbook.com/2013/05/jsp-tutorial-directives/)
\ No newline at end of file
docs/jsp/5.md 0 → 100644
浏览文件 @ 4565aedb
# 指令
\ No newline at end of file
docs/jsp/6.md 0 → 100644
浏览文件 @ 4565aedb
# JSP 指令 - 页面，包含和 TagLib
> 原文： [https://beginnersbook.com/2013/05/jsp-tutorial-directives/](https://beginnersbook.com/2013/05/jsp-tutorial-directives/)
指令控制整个 JSP 页面的处理。它向服务器提供有关页面处理的指示。
**指令语法：**
```
<%@ directive name [attribute name=“value” attribute name=“value” ........]%>
```
**JSP 中有三种类型的指令：**
1）页面指令
2）包含指令
3）TagLib 指令
## 1）页面指令
有几个属性，与 Page Directives 一起使用，它们是 -
1. 进口
2. 会议
3. isErrorPage
4. 的 errorPage
5. 内容类型
6. isThreadSafe
7. 扩展
8. 信息
9. 语言
10. 自动冲洗
11. 缓冲
### 1.导入：
此属性用于导入包。在进行编码时，您可能需要包含多个包。在这种情况下，此页面指令的属性非常有用，因为它允许您在逗号（，）之间用同一位置提及多个包。或者，您可以拥有多个页面元素实例，每个实例都包含不同的包。
**导入属性的语法 -**
```
<%@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.会话：
通常在构建用户交互式 JSP 应用程序时，我们确保允许用户访问以获取他/她的个人数据，直到会话处于活动状态。考虑一个登录到您的银行帐户的示例，我们可以访问您的所有数据，直到我们退出（或会话到期）。为了维护页面的会话，会话属性应为 true。
此属性用于处理 JSP 页面的 HTTP 会话。它可以有两个值：true 或 false。会话属性的默认值为 true，这意味着如果您不提及此属性，则服务器可能会认为此页面需要 HTTP 会话。
**此属性的默认值：** true
**会话属性语法：**
```
<%@ page session="value"%>
```
这里的值是**是真还是假**
**会议举例：**
```
<%@ page session="true"%>
```
上面的代码将允许页面具有会话隐式对象。
```
<%@ page session="false"%>
```
如果在 JSP 页面中指定了此代码，则意味着会话对象将不可用于该页面。因此，无法为该页面维护会话。
### 3\. isErrorPage ：
此属性用于指定当前 JSP 页面是否可用作另一个 JSP 页面的错误页面。如果 isErrorPage 的值为 true，则表示该页面可用于其他页面的异常处理。通常，这些页面具有错误/警告消息或异常处理代码，并且当发生异常时由另一个 JSP 页面调用。
isErrorPage 属性还有另一种用法 - [异常隐式对象](https://beginnersbook.com/2013/11/jsp-implicit-object-exception-with-examples/ "Exception implicit object")只能用于 isErrorPage 设置为 true 的那些页面。如果值为 false，则页面不能使用异常隐式对象。
**默认值：** false
**isErrorPage 属性的语法：**
```
<%@ page isErrorPage="value"%>
```
这里的值是 true 或 false。
**isErrorPage 示例：**
```
<%@ page isErrorPage="true"%>
```
这使得 JSP 页面成为异常处理页面。
### 4\. errorPage ：
如上所述，当 isErrorPage 属性对于特定页面为 true 时，则表示在异常情况下该页面可以被另一个页面调用。 errorPage 属性用于指定将 isErrorPage attrbute 设置为 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.缓冲区：
此属性用于指定缓冲区大小。如果在编码期间将此值指定为 none，则输出将由 JSPWriter 直接写入 Response 对象。并且，如果指定缓冲区大小，则输出首先写入缓冲区，然后它将可用于响应对象。
**缓冲区属性的语法：**
```
<%@ page buffer="value"%>
```
值为**大小，单位为 kb** 或**无**。
**缓冲区示例：**
此页面没有缓冲区：
```
<%@ page buffer="none"%>
```
页面的 5 kb 缓冲区大小，代码如下：
```
<%@ page buffer="5kb"%>
```
### 8.扩展：
像 java 一样，这里的属性也用于扩展（继承）类。
**extends 属性的语法：**
```
<%@ page extends="value"%>
```
值为 package_name.class_name。
**延伸示例：**
下面的代码将从包中继承 SampleClass：mypackage
```
<%@ page extends="mypackage.SampleClass"%>
```
### 9.信息：
它提供了对 JSP 页面的描述。当我们调用 getServletInfo（）方法时，info 中指定的字符串将返回。
**信息语法：**
```
<%@ page info="value"%>
```
这里的值是消息或描述
**信息属性示例：**
```
<%@ page info="This code is given by Chaitanya Singh"%>
```
### 10.语言：
它指定页面中使用的脚本语言（基础语言）。
**语言语法：**
```
<%@ page language="value"%>
```
值是这里的脚本语言。
**语言属性示例：**
```
<%@ page language="java"%>
```
### 11\. autoFlush ：
如果为 true，则表示缓冲区应该在满时刷新。当缓冲区溢出时，false 将抛出异常。
**默认值**：True
**autoFlush 的语法：**
```
<%@ page autoFlush="value"%>
```
值可以是真或假。
**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 指令用于将一个 JSP 页面的内容复制到另一个 JSP 页面。这就像将一个文件的代码包含在另一个文件中。
**包含指令的语法：**
```
<%@include file ="value"%>
```
这里的值是需要包含的 JSP 文件名。如果文件位于同一目录中，则只需指定文件名，否则需要在值字段中提及完整的 URL（或路径）。
**注意：它可以在页面的任何地方使用。**
**示例：**
```
<%@include file="myJSP.jsp"%>
```
您可以在 JSP 页面中使用上述代码来复制 myJSP.jsp 文件的内容。但是，在这种情况下，两个 JSP 文件必须位于同一目录中。如果 myJSP.jsp 位于不同的目录中，那么您需要在上面的代码中指定完整路径，而不仅仅是文件名。
**必须通过示例详细阅读**： [Include 指令。](https://beginnersbook.com/2013/11/jsp-include-directive/ "Include directive")
## 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 具有自定义标记库的位置，前缀标识自定义标记的前缀。
注意：在上面的例子中 - ＆lt; demotag：welcome＆gt;有一个前缀 demotag。
\ No newline at end of file
docs/jsp/7.md 0 → 100644
浏览文件 @ 4565aedb
# 在 JSP 中包含指令
> 原文： [https://beginnersbook.com/2013/11/jsp-include-directive/](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 页面所在的文件夹相同，那么我们只需提及文件名，否则需要指定文件的相对路径。
### 包括指令示例
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 页面中。
![Include-Directive-example-output](img/4c8a811a47fc4c451663c03e02704918.jpg)
如果您对此有任何疑问，请告诉我们。
\ No newline at end of file
docs/jsp/8.md 0 → 100644
浏览文件 @ 4565aedb
# JSP include 指令带参数示例
> 原文： [https://beginnersbook.com/2013/12/jsp-include-directive-with-parameters-example/](https://beginnersbook.com/2013/12/jsp-include-directive-with-parameters-example/)
在上一个教程中，我们讨论了 [JSP 包含参数](https://beginnersbook.com/2013/12/jsp-include-with-parameter-example/)的动作。这里我们将看到在使用 [JSP include 指令](https://beginnersbook.com/2013/11/jsp-include-directive/)时如何传递参数。
## 例
在这个例子中，我们将三个字符串参数传递给包含的 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>
```
上面，我使用[声明标签](https://beginnersbook.com/2013/11/jsp-declaration-tag/)初始化字符串， [scriptlet](https://beginnersbook.com/2013/05/jsp-tutorial-scriptlets/) 用于在[会话对象](https://beginnersbook.com/2013/11/jsp-implicit-object-session-with-examples/)中设置它们。由于 sciptlet 的使用被忽视了长背，或者你可以使用[＆lt; c：set＆gt; JSTL 标签](https://beginnersbook.com/2013/11/jstl-cset-core-tag/)做同样的事 - 代码就像这样 -
```
<%@ 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") %>
```
输出：
![include-directive-param](img/538309ecc53c87802d302f61accb171c.jpg)
在上面的例子中，我使用会话隐式对象传递了参数，但是您也可以使用请求，页面和应用程序隐式对象传递它们。
\ No newline at end of file
docs/jsp/9.md 0 → 100644
浏览文件 @ 4565aedb
# 小脚本
\ No newline at end of file
docs/jsp/SUMMARY.md 0 → 100644
浏览文件 @ 4565aedb
+ [概观](2.md)
+ [Java Server Pages 简介 - JSP 教程](3.md)
+ [Java Server Pages（JSP）生命周期](4.md)
+ [指令](5.md)
+ [JSP 指令 - 页面，包含和 TagLib](6.md)
+ [在 JSP 中包含指令](7.md)
+ [JSP include 指令带参数示例](8.md)
+ [小脚本](9.md)
+ [JSP Scriptlets](10.md)
+ [动作标签](11.md)
+ [JSP 操作 - Java Server Pages](12.md)
+ [JSP 包含动作标记 - JSP Tutorial](13.md)
+ [JSP 包含带参数示例的操作](14.md)
+ [JSP 转发动作标签 - JSP Tutorial](15.md)
+ [jsp：useBean，jsp：setProperty 和 jsp：getProperty Action Tags](16.md)
+ [表达式](17.md)
+ [JSP Expression Tag - JSP 教程](18.md)
+ [声明](19.md)
+ [JSP 声明标记 - JSP 教程](20.md)
+ [JSP 隐式对象](21.md)
+ [Jsp 隐式对象](22.md)
+ [用例子中的 JSP 中的隐式对象](23.md)
+ [使用示例在 JSP 中请求隐式对象](24.md)
+ [使用示例在 JSP 中响应隐式对象](25.md)
+ [JSP 中的 Session 隐式对象及其示例](26.md)
+ [JSP 中的应用程序隐式对象及其示例](27.md)
+ [JSP 中的异常隐式对象，带有示例](28.md)
+ [pageContext JSP 中的隐式对象，带有示例](29.md)
+ [使用示例在 JSP 中配置隐式对象](30.md)
+ [JSP 中的表达式语言（EL）](31.md)
+ [JSP 表达式语言（EL） - JSP 教程](32.md)
+ [异常处理](33.md)
+ [JSP 中的异常处理](34.md)
+ [自定义标签](35.md)
+ [带有示例的 JSP Custom 标签 - JSP Tutorial](36.md)
+ [如何在 JSP 教程中访问 Custom 标签的主体](37.md)
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或