【JSP笔记02】JSP注释、脚本、表达式、JSP三大指令、JSP七大动作的介绍及使用
这篇文章主要介绍JSP注释、脚本、表达式、JSP三大指令、JSP七大动作的介绍及使用，以及如何在JSP页面中使用Java代码编写程序。
【JSP笔记01】为什么会出现JSP，到底什么是JSP，JSP的本质又是什么，JSP的生命周期介绍
目录
一、JSP的注释
（1）HTML注释
（2）JSP注释
二、JSP脚本
（1）什么是脚本
（2）JSP声明脚本
（3）JSP表达式
（4）JSP普通脚本
三、JSP中的三大指令
（1）page指令
（1.1）import属性
（1.2）errorPage和isErrorPage属性
（1.3）session属性
（1.4）isELIgnored属性
（2）include指令
（3）taglib指令
四、JSP中的七大动作
（1）jsp:include动作
（2）jsp:forward动作
（3）jsp:param动作
（4）jsp:useBean动作
（4.1）如何使用【jsp:useBean】动作呢？？？
（4.2）【jsp:useBean】动作中scope属性使用
（5）jsp:setProperty动作
（6）jsp:getProperty动作
（7）jsp:plugin动作
一、JSP的注释
注释，我们都知道是啥了，就是解释说明你的代码是干啥的，注释是不影响程序的运行的。
注释最大的作用就是：提高代码的可读性，这样你写的代码给别人看，别人只要看注释就知道，你这个代码是干啥的，有啥功能。。。。。
在JSP页面中，可以使用两种类型的注释，分别是：
- HTML注释
- 因为JSP页面可以直接编写HTML代码，所以也支持HTML的注释。
- HTML注释通过查看网页源代码是可以看见的。
- JSP注释
- JSP自己定义了注释，类似Java中的注释。
- 使用JSP注释通过查看网页源代码是看不见的。
（1）HTML注释
HTML注释的语法格式：
- HTML注释，采用尖括号开头和结尾，开头采用【<!--】，结尾采用【-->】，注释内容写在两个尖括号之间即可。
<!-- 这里编写注释内容 -->（2）JSP注释
JSP注释的语法格式：
- JSP注释是Sun公司规定的，采用【<%--】开头，【--%>】结尾，然后在开头和结尾之间编写注释内容即可。
- JSP注释，会被JSP解析引擎解析，注释内容不会被输出到浏览器客户端。
<%-- 这里编写注释内容 --%>注释案例代码：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>JSP注释</title>
</head>
<body><!-- HTML注释使用HTML注释，可以通过查看网页源代码看到注释内容--><h3>使用HTML注释，可以通过查看网页源代码看到注释内容</h3><%-- JSP注释 --%><h3>使用JSP注释，通过查看网页源代码看不到注释内容</h3></body>
</html>访问上面的JSP文件，然后我们查看浏览器源代码，可以看见两个注释的区别：
以上就是JSP中的注释，简单了解一下就可以了。
二、JSP脚本
（1）什么是脚本
我们说JSP是可以直接在HTML代码中嵌入Java代码，那既然能够嵌入Java代码，那就需要一定的规范，如果没有规范，JSP解析的时候就不知道哪些是HTML代码，哪些是Java代码，所以Sun公司定义JSP的时候，也定义了JSP中嵌入Java代码的规范，我们把这些直接嵌入Java代码的内容称为：脚本。
JSP中脚本可以大致分为如下几类：
- 声明脚本
- 表达式脚本
- 普通脚本
注意：JSP中所有编写的Java代码都是包含在【<%】和【%>】之间的。
下面我们会详细的介绍这几类脚本。
（2）JSP声明脚本
- 声明脚本
- 所谓的声明脚本，就是用于声明Java中的一些成员变量，方法等内容的代码块。
- 声明脚本语法格式
- 声明脚本，通过【<%!】开头，【%>】结尾，在开头和结尾之间，可以编写Java代码。
<%!// 这里可以编写Java代码// 声明一个全局变量int num = 520;// 定义一个方法public void demo() {System.out.println("Hello，我是CSDN_朱友斌");}
%>注意：声明脚本中只能定义成员变量，方法。
我们来看下，声明脚本的Java代码，最终会被JSP解析变成什么内容？？？
- 这里我们编写一个【index.jsp】测试页面，然后访问查看编译生成后的java类文件。
<%-- 设置字符集contentType：告诉Servlet容器在采用response输出内容时候，采用utf-8字符集，并且输出html类型文件--%>
<%@page contentType="text/html; charset=UTF-8" language="java" %>
<html>
<head><meta charset="utf-8"/><title>Title</title>
</head>
<body><h3>JSP声明脚本</h3><%!// 这里可以编写Java代码// 声明一个全局变量int num = 520;// 定义一个方法public void demo() {System.out.println("Hello，我是CSDN_朱友斌");}%>
</body>
</html>
查看生成的java类文件，可以发现，JSP声明脚本里面的内容，编译之后都会被放在Java类文件里面。
- 从上面的图，可以看到，我们编写的JSP声明脚本，如果是变量，那这个变量就是全局变量，如果是方法，那就是类中的方法。
PS注意：
- JSP声明脚本，它一般都是用于声明一些变量，方法，然后提供给其他的脚本进行使用。
（3）JSP表达式
- JSP表达式
- JSP提供的表达式，是用于将内容输出到JSP页面上，从而可以在浏览器中看见。
- JSP表达式的语法格式
- JSP表达式，采用【<%=】开头，【%>】结尾，并且在开头和结尾之间，只能有一个语句，并且不能写【;】分号。
语法格式：
<%= 表达式 %>举例如下：<%="Hello，我是CSDN朱友斌" %>下面给出JSP表达式的案例代码，以及JSP表达式编译之后，对应生成的Java类文件中的哪部分内容。
<%-- 设置字符集contentType：告诉Servlet容器在采用response输出内容时候，采用utf-8字符集，并且输出html类型文件--%>
<%@page contentType="text/html; charset=UTF-8" language="java" %>
<html>
<head><meta charset="utf-8"/><title>Title</title>
</head>
<body><h3>JSP表达式</h3><%="Hello，我是CSDN朱友斌" %>
</body>
</html>
- 查看JSP生成的Java类文件，查看类中的【_jspService()】方法，可以看下如下内容：
从上面的图片中，可以看到，我们编写的JSP表达式内容，编译之后它是会被替换成【out.print()】方法，然后将表达式的内容输出。
哦，原来如此，JSP的表达式就是解析之后，采用【out.print()】方法替换而已，是不是很简单呀。
（4）JSP普通脚本
- JSP普通脚本
- JSP普通脚本里面可以编写任意的Java语句、变量、调用方法等等代码。
- JSP普通脚本的内容，会被嵌入到【_jspService()】里面。
- JSP普通脚本语法格式
- JSP普通脚本，采用【<%】开头，【%>】结尾，在开头和结尾之间就可以编写Java、使用变量、调用方法之类的代码。
- JSP普通脚本，每一个语句必须使用【；】分号结尾（因为Java是采用分号表示一个语句结束）。
JSP脚本语法格式：<% 这里可以写任意的java代码
%>下面给个案例，看下JSP脚本编译之后，生成的Java类文件源代码。
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>JSP脚本</title>
</head>
<body><%// 定义变量int num = 520;// 使用分支语句if (num > 520) {System.out.println("num大于520");}%>
</body>
</html>
查看JSP页面对应的Java源代码，如下所示：
哎，从上面图片中可以发现，通过JSP普通脚本编写的内容，经过JSP编译解析之后，它会将JSP普通脚本的内容放到【_jspService()】方法内部，作为方法的局部变量、代码片段等相关语句。
三、JSP中的三大指令
什么是指令？？？
指令，是JSP用于告诉Servlet容器应该如何处理JSP的请求和响应，Servlet容器会解析JSP的指令，然后生成对应的Java类文件。
JSP中指令分为三个，分别是：page、include、taglib。
JSP中规定，所有的指令都是按照【<%@】开头，【%>】结尾，然后在中间编写指令名称、属性名称和属性值。
下面会详细介绍每一种指令的使用。
（1）page指令
page指令：
- page指令的作用主要是定义了一些和JSP页面相关的属性。
- 例如：页面采用哪种字符集解析、页面是否使用session、页面是否为错误页面等等。
- page指令的使用语法格式：
<%@ page 属性名称="属性值" 属性名称="属性值" %>- page指令常用的属性
- contentType：设置响应的文件类型、以及字符集。例如：contentType="text/html;charset=utf-8"。
- import：用于导入java类包。例如：import="java.util.Date"。
- language：指定JSP中使用的语言。例如：language="java"。
- errorPage：声明当前页面发生异常错误时候需要跳转到哪个页面。例如：errorPage="error.jsp"。
- isErrorPage：声明当前JSP页面是否作为错误跳转页面。例如：isErrorPage="true"。默认是false，即：不作为错误页面。
- session：指定当前JSP页面中是否可以使用session对象。例如：session="true"使用session对象。默认是true，即：使用session对象。
- isELIgnored：指定当前JSP页面是否忽略EL表达式。例如：isELIgnored="true"。默认是true。
（1.1）import属性
- 一个【page】指令中只能使用一个【import】属性，如果需要导入多个包，可以采用下面两种方式：
- 第一种方式：import属性中，通过【，】逗号，将多个包路径分隔开。
<%-- 导入多个包路径 --%>
<%@ page import="java.util.ArrayList,java.util.LinkedList,java.util.HashSet" %>上面代码，执行完成之后，JSP生成的Java代码中，就会自动导入对应的包，如下图所示：
- 第二种方式：采用多个page指令，每个page指令中编写一个【import】属性，导入需要的包。
<%-- 导入多个包路径 --%>
<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.LinkedList" %>
<%@ page import="java.util.HashSet" %>通过这种方式导入多个不同的包，缺点是需要编写多个page指令，代码会有冗余，所以一般都不采用这种方式，而是采用第一种方式。
（1.2）errorPage和isErrorPage属性
- errorPage和isErrorPage属性，是用来处理程序出现异常，给用户友好的提示信息。
- 例如：当程序报错时候，可以给用户返回【系统繁忙，请稍后重试】之类的提示语，而不是一大堆错误信息。
编写【demo.jsp】测试页面
<%-- errorPage: 指定当前页面出现异常时候，跳转到 error.jsp 页面 --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" errorPage="error.jsp" %>
<html>
<head><title>测试页面</title>
</head>
<body><%// 模拟出错int num = 10;if (num / 0 == 0) {System.out.println("执行if语句");}%>
</body>
</html>
编写【error.jsp】错误跳转页面
<%-- isErrorPage="true"，指定当前页面是错误信息 --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" isErrorPage="true" %>
<html>
<head><title>错误页面</title>
</head>
<body><h3>500！！！出现错误啦，请稍后重试！！！</h3><%--声明当前页面是 isErrorPage="true" 之后，我们就可以在当前页面 获取异常信息使用 exception 对象，就可以获取到异常信息--%><h4>错误信息：<%= exception.getMessage() %></h4>
</body>
</html>启动工程，我们访问【demo.jsp】页面，然后此时看到的结果就是返回的错误提示信息。
从上面的运行结果可以看到，当页面发生错误时候，会输出我们定义的【error.jsp】 的页面，并且当前页面的地址不会变化。
地址栏地址不变化？？？那说明就是采用【请求转发】实现的呗，我们来看下具体的实现逻辑。
打开访问【demo.jsp】页面之后生成的【demo_jsp.java】类文件，找到【_jspService()】方法，里面可以看见我们编写的JSP脚本代码，如下图所示：
从图上可以知道，我们编写的代码是被【try...catch】代码块包裹起来，如果出现异常，则会被捕获，并且会将异常详细通过【请求转发】的形式，转发到对应的错误处理页面。
上面源代码可以看到，当我们在JSP页面中使用了【errorPage】属性之后，编译之后的JSP代码获取到【error.jsp】错误跳转页面，然后就会执行转发操作。
如果你没有写【errorPage】属性，JSP编译之后，获取到的转发路径就是【null】。
那么当你JSP页面出现错误时候，此时会返回异常信息。
以上，就是errorPage和isErrorPage属性。
（1.3）session属性
- session属性，是可以指定我们能否在JSP的页面中使用session对象。
- 如果设置【session="true"】，则JSP会创建一个session对象，然后我们就可以在JSP页面中直接使用session对象；（默认就会创建session）。
<%-- session属性，默认等于 true --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" session="true" %>
<html>
<head><title>测试页面</title>
</head>
<body><%// 使用sessionsession.setAttribute("uid", "CSDN_朱友斌");%>
</body>
</html>
设置【session="true"】之后，在生产的java代码中，可以看到创建session的语句。
- 如果设置【session="false"】，则JSP不会创建session对象，也就不能使用session了。
我们设置【session="false"】再次查看生成的java代码，发现没有创建session的语句了。
（1.4）isELIgnored属性
这个属性，之后我们介绍了EL表达式再详细的介绍一下，这里先跳过一下。
（2）include指令
include指令：
- include意思是包含，作用就是在当前的JSP页面，可以引入其他的JSP页面。
- include指令的使用语法格式：
<%@ include 属性名称="属性值" %>- include指令的属性：
- file：指定引入其他JSP页面的文件路径和名称。
下面编写一个案例，来解释include指令。
案例需求：
- 我们编写三个jsp页面，分别是【header.jsp】、【main.jsp】、【footer.jsp】名称。
- 然后在【main.jsp】页面中引入【header.jsp】和【footer.jsp】两个页面。
编写【header.jsp】页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>头部内容</title>
</head>
<body><h3>这是header头部内容</h3>
</body>
</html>
编写【footer.jsp】页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>底部内容</title>
</head>
<body><h3>这是footer底部内容</h3>
</body>
</html>
编写【main.jsp】页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%-- 引入 header 头部内容 --%>
<%@ include file="header.jsp" %>
<html>
<head><title>主体内容</title>
</head>
<body><h3>这是main主体内容</h3>
</body>
</html>
<%-- 引入 footer 底部内容 --%>
<%@include file="footer.jsp" %>浏览器访问【main.jsp】页面
- 打开浏览器，访问main.jsp页面，可以发现，main页面中将header和footer页面的内容也显示出来了，这就是include指令的作用。
注意：
include指令是静态包含，所谓的静态包含，就是main.jsp页面是直接将header.jsp和footer.jsp页面的内容，直接拼接到【main.jsp】编译之后生成的Java代码里面，即：将header.jsp和footer.jsp页面的内容，直接嵌入到main.jsp对应的【_jspService】方法里面。
- 使用include指令时候，由于是静态包含，并且我们访问的只有【main.jsp】页面，所以编译之后，也只会生成main.jsp对应的java源代码，而【header.jsp】和【footer.jsp】我们没有访问，所以不会编译生成java源代码文件。
下面，我们看下编译之后生成java源代码，就很清楚了。
看图片，明白了吧，JSP的include指令引入其他页面，是通过【out.write()】将其他页面的内容输出到一起。
include指令的缺点
- 使用JSP的include指令引入其他页面的时候，有一个缺点，由于include指令是静态引入，会将所有内容嵌入到同一个service方法里面，所以，如果在不同的页面中，如果定义了相同的变量名称，那么在编译之后就会报错。
- 因为编译之后，java代码里面存在相同的变量名称，从而导致程序报错。
（3）taglib指令
taglib指令：
- taglib中文含意思是标签库，它主要作用就是引入第三方的标签库，例如：JSTL标签库。
- taglib指令的使用语法格式：
<%@ taglib 属性名称="属性值" %>- taglib指令，具有如下属性：
- uri：指定标签库的命名空间（也就是标签库的地址）。
- prefix：给引入的标签库起一个别名（避免和其他标签库重名）。
PS注意：taglib是引入其他的标签库，这里先不做介绍，后面介绍JSTL标签库的时候，我们再来详细的说下taglib指令。
四、JSP中的七大动作
什么是JSP动作？？？其实我个人也是不知道该如何描述什么是JSP动作，我只能介绍一下如何使用JSP动作相关内容。
如果大家对JSP动作有所理解的，可以告诉我一下，一起学习学习，^v^。。。。
JSP提供了七个动作标签，通过JSP动作就可以控制Servlet容器的一些行为，例如：动态的赋值、使用Bean对象、重定向、转发之类的。
JSP动作和JSP指令最大的区别就是：
- JSP指令是发生在编译期间，只会编译一次；而JSP动作则是发生在运行期间，每次HTTP请求都会执行一次。
JSP动作的语法格式：
- JSP动作，采用XML的形式进行定义。
单标签形式：<jsp:动作名称 属性名称="属性值" />也可以是双标签：<jsp:动作名称 属性名称="属性值"></jsp:动作名称>下面介绍一下JSP中常用的七个动作。
（1）jsp:include动作
jsp:include动作：
- 这个动作的主要作用是引入其他文件。
- 和之前学的【include】指令作用是一样的。
- 唯一的区别就是include是静态引入、jsp:include是动态引入。
jsp:include语法格式：
<jsp:include page="文件路径" flush="是否刷新缓冲区"/>- page属性：page是指定需要引入哪个文件，例如：HTML、JSP、CSS之类的文件。
- flush属性：引入文件之前是否刷新输出流缓冲区。默认是false，不刷新缓冲区。
缓冲区什么意思呢？？？
其实就是服务器输出内容给浏览器的时候，首先会将内容输出到一个缓冲区里面（相等于中间仓库），当缓冲区满了之后，就会将缓冲区中所有内容输出到浏览器。而我们如果需要缓冲区在没有满的情况下，就输出到浏览器，那就可以调用【flush()】方法，强制将缓冲区中的数据输出到浏览器里面，这就是刷新缓冲区的意思。
下面举个案例，理解一下jsp:include动态包含是如何实现的。
- 还是采用【header.jsp】、【main.jsp】、【footer.jsp】三个案例，只不过，我们在【main.jsp】页面中，我们采用【jsp:include】动作进行引入另外两个文件。
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%-- 引入 header 头部内容 --%>
<jsp:include page="header.jsp" flush="false"/>
<html>
<head><title>主体内容</title>
</head>
<body><h3>这是main主体内容</h3>
</body>
</html>
<%-- 引入 footer 底部内容 --%>
<jsp:include page="footer.jsp" flush="false"/>- 打开浏览器，访问一下，查看效果。我们直接看下编译之后生成java类代码。
从上面我们可以发现，【jsp:include动作】和【include指令】的区别之一，就是是否会生成引入文件的java文件。
- 【jsp:include动作】：会将外部引入的JSP文件也编译，并且生成对应的java文件。
- 【include指令】：不会生成外部引入的JSP文件的java代码，只有访问了才会生成。
我们再来看戏【main.jsp】对应的java代码里面是否如何实现内容引入的。
到这里，就可以知道jsp:include动作的实现啦，本质就是通过请求包含实现的。
【jsp:include动作】可以很好的避免变量名称重复的问题，即：在不同的jsp页面中，我们可以定义相同的名称，而运行过程中不会发生冲突。
这是因为【jsp:include动作】是将包含的文件作为输出内容嵌入到当前JSP文件里面，而不是嵌入到当前页面进行编译，所以不会产生编译问题。
（2）jsp:forward动作
jsp:forward动作：
- 作用：实现请求的转发功能。
- 其实就是将Servlet中的请求转发，变成了JSP里面的一个动作。
- jsp:forward动作的语法格式
<jsp:forward page="转发地址"/>- page属性：这里需要指定请求转发的相对路径，并且只能是同一个web应用程序中的路径。
编写【A.jsp】页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>A页面</title>
</head>
<body><h3>这是A页面</h3><%-- jsp:forward 转发 --%><jsp:forward page="B.jsp"></jsp:forward>
</body>
</html>
编写【B.jsp】页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>B页面</title>
</head>
<body><h3>这是B页面</h3><h4>这是A页面使用jsp:forward动作转发过来的</h4>
</body>
</html>
访问【A.jsp】页面之后，页面显示的内容就是转发之后的了。
老规矩，还是直接查看编译之后生成的java代码，看看jsp:forward转发动作是如何实现的。
本质上，【jsp:forward动作】转发还是将代码嵌入到【_jspService()】方法里面，然后调用请求的【forward()】方法转发。
（3）jsp:param动作
上面我们介绍了jsp:forward动作，但是我们在请求转发过程中是可以携带参数的，那通过jsp的动作如何携带参数呢？？？这个时候就需要使用【jsp:param动作】。
jsp:param动作：
- 作用：用于定义请求过程中携带的参数内容。
- jsp:param动作的语法格式
<jsp:param name="参数名称" value="参数值"/>- 【jsp:param动作】结合【jsp:forward动作】实现请求转发携带参数
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>A页面</title>
</head>
<body><h3>这是A页面</h3><%// 设置一下参数字符集request.setCharacterEncoding("utf-8");%><%-- jsp:forward 转发 --%><%-- 定义转发的参数 --%><jsp:forward page="B.jsp"><jsp:param name="uid" value="CSDN_朱友斌"/><jsp:param name="uname" value="朱友斌"/></jsp:forward>
</body>
</html>- 我们可以在转发后的页面中获取到请求参数。
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>B页面</title>
</head>
<body><h3>这是B页面</h3><h4>这是A页面使用jsp:forward动作转发过来的</h4><h4>转发的参数：<%=request.getParameter("uid") %> <br><%=request.getParameter("uname") %></h4>
</body>
</html>
- 之后访问【A.jsp】页面，可以看到如下效果，能够从转发请求中获取参数内容。
注意之处：
- 在【jsp:forward动作】标签之间，千万不能编写任何的注释内容，否则运行报错。
我一开始就是写了注释，代码如下所示：
<%-- jsp:forward 转发 --%>
<jsp:forward page="B.jsp"><%-- 这里不能写注释，否则报错 定义转发的参数 --%><jsp:param name="uid" value="CSDN_朱友斌"/><%-- 这里不能写注释，否则报错 定义转发的参数 --%><jsp:param name="uname" value="朱友斌"/>
</jsp:forward>如果写了注释内容在【jsp:forward动作】标签之间，程序会报错，报错信息如下所示：
/A.jsp (行.: [14], 列: [8]) 使用“name”和“value”属性期望“jsp:param”标准操作
意思大致就是不符合jsp的动作标准操作。jsp动作之间不能编写任何其他的注释内容，JSP注释和HTML注释都不能写。
（4）jsp:useBean动作
jsp:useBean动作：
- jsp:useBean动作的作用：在指定的作用域范围里面，首先查找对应的Bean实例，如果没有找到bean对象，则会实例化一个新的bean对象。
- 也就是说，我们之前是在Servlet里面通过new创建一个bean对象的，但是现在是在JSP里面，我们要如何获取和创建对象呢？？？
- JSP就通过jsp:useBean动作来解决bean对象的获取和创建问题。
【jsp:useBean】动作的语法格式
<jsp:useBean id="给bean对象起个名称，也就是变量名称" class="类的全限定名称和路径" scope="bean对象作用域" />- id属性：这个就是给当前需要获取和创建的bean对象，起一个唯一的变量名称。
- class属性：对应哪个类路径。（底层就是通过反射机制实例化对象）
- scope属性：这是指定创建的bean对象作用域，有四个属性值：page、request、session、application。
（4.1）如何使用【jsp:useBean】动作呢？？？
- 首先我们创建一个【User】实体类
public class User {private Integer uid;private String uname;public Integer getUid() {return uid;}public void setUid(Integer uid) {this.uid = uid;}public String getUname() {return uname;}public void setUname(String uname) {this.uname = uname;}
}- 接着，我们编写一个【bean.jsp】页面，然后在JSP页面中创建bean对象。
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>useBean动作使用</title>
</head>
<body><%-- 创建bean对象 --%><jsp:useBean id="user" class="com.example.demo.pojo.User"/><%-- 这里我们输出一下，看下创建的对象 --%><h3><%=user %></h3>
</body>
</html>- 我们打开浏览器，访问bean.jsp页面，多次访问，页面上的输出是不一样的，也就是说明，jsp:useBean动作创建的bean对象是多实例的，每次访问都会创建一个新的bean对象。
（4.2）【jsp:useBean】动作中scope属性使用
前面说了，【jsp:useBean】动作具有scope属性，这个属性有四个属性值，分别是：
- page：这个表示当前创建的bean对象只能在当前的JSP页面中使用，其他JSP页面无法使用。（默认的作用域）
- request：表示创建的bean对象只能在同一次request请求中使用，其他request请求无法使用。
- session：表示创建的bean对象只能在同一次会话里面使用，其他session会话中无法使用。
- application：表示创建的bean对象可以在整个web应用程序中使用，任何JSP页面都可以获取到bean对象。
下面分别对上面四个属性做一个代码演示。
《1》scope="page"属性
- page属性值，是将创建的bean对象放入到【pageContext】作用域里面。
- 我们查看一下编译之后生成的java代码，如下所示：
- 从生成的java代码，可以知道，设置scope="page"属性值后，每次创建bean对象之前，先从【pageContext】作用域获取，如果存在，则直接不创建；如果不存在，则创建一个新的bean对象，然后将创建的bean对象放入【pageContext】作用域。
我们知道，【pageContext】作用域，只能在当前JSP页面有效，所以创建的bean对象也就只能在当前JSP页面使用。
不信的话，我们写个案例，测试一下就知道了。编写一个【bean.jsp】和【bean2.jsp】，在【bean2.jsp】中获取【bean.jsp】页面创建的bean对象，查看效果。
《2》scope="request"属性
- request属性值，是将创建的对象放入request作用域里面，在同一次HTTP请求中，可以使用同一个bean对象（也就是转发过程中可以使用同一个bean对象呗）。
- 查看编译之后生成的java代码，如下所示：
《3》scope="session"属性
- session属性值，是将创建的bean对象放入到同一个session作用域。
- 查看编译之后生成的java代码如下所示：
《4》scope="application"属性
- application属性值，这个application其实就是Servlet中的ServletContext域对象，只不过在JSP中叫做application域对象。它是存在于整个web应用程序里面的域对象，只有一个。
- 查看编译之后生成的java代码，如下所示：
（5）jsp:setProperty动作
- 上面，我们介绍了【jsp:useBean】动作，它只能用于创建bean对象，但是只能创建bean对象，不能够满足我们的需求呀，我们还需要给创建的bean对象的属性赋值之类的操作，这个时候就需要使用到【jsp:setProperty】动作。
jsp:setProperty动作：
- 作用：给创建的bean对象的属性赋值。
- jsp:setProperty动作的语法格式
<jsp:setProperty name="bean对象的名称" property="属性名称，也就是bean对象的字段" value="属性值" />- name属性：对应哪个bean对象，就是需要给哪个bean实例进行属性赋值操作。
- property属性：给哪个bean对象中的字段进行赋值。
- value属性：设置的属性值。
<%-- 创建bean对象 --%>
<jsp:useBean id="user" class="com.example.demo.pojo.User"><%-- 设置属性值 --%><jsp:setProperty name="user" property="uid" value="520"/><%-- 设置属性值 --%><jsp:setProperty name="user" property="uname" value="朱友斌"/>
</jsp:useBean>注意：
- 我们一般习惯将【jsp:setProperty】动作写在【jsp:useBean】动作标签之间，但是，也可以写在标签外面。
- 但是绝对不能写在【jsp:useBean】动作标签之前，因为写在前面，bean对象的都还没有实例化，就不能先进行赋值操作。
- 我们来看下【jsp:setProperty】动作是如何设置属性值的？？？
从上面编译之后的java代码可以看出，其实JSP页面编译之后，是从对应的scope作用域里面获取创建的bean对象，然后给bean对象设置属性值。
注意：
- jsp:setProperty动作，会根据scope作用域，从小到大（page、request、session、application），依次查找是否具有对应的bean对象，默认是第一个找到的进行赋值；如果四个作用域都没有找到，则报错。
（6）jsp:getProperty动作
- 和【jsp:setProperty】动作类似，只不过【jsp:getProperty】动作是用于获取bean对象的属性值。
- jsp:getProperty动作的语法格式：
<jsp:getProperty name="bean对象名称" property="bean对象的属性名称（字段）"/>- name属性：对应哪个bean对象。
- property属性：获取bean对象中的哪个属性。
案例代码如下所示：
<h3><%-- 获取bean对象的属性值 --%><jsp:getProperty name="user" property="uid"/> <br/><jsp:getProperty name="user" property="uname"/>
</h3>- 【jsp:getProperty】动作，它是获取到对应bean对象的属性值后，然后将内容输出到浏览器。
- 查看对应的实现代码：
- 从上面编译后的java代码，可以看到，【jsp:getProperty】动作就是从scope作用域里面获取到属性值，然后通过【out.write()】方法输出给浏览器客户端显示。
注意：
- jsp:getProperty动作，会根据scope作用域，从小到大（page、request、session、application），依次查找是否具有对应的bean对象，默认是第一个找到的进行获取值；如果四个作用域都没有找到，则报错。
（7）jsp:plugin动作
- jsp:plugin动作主要是可以在浏览器端运行一些插件。
- 不常用，这里就不介绍了，只需要记住前面6大动作即可。
以上，就是对JSP中的脚本、注释、表达式、JSP三大指令、JSP七大动作进行了介绍，以及如何使用。
如果文章有哪些写的不正确的地方，请纠正一下。
【JSP笔记02】JSP注释、脚本、表达式、JSP三大指令、JSP七大动作的介绍及使用相关推荐
- JSP三大指令、七大动作、九大对象
<%---------------------- JSP三大指令 -----------------------------%> <%-- 1. page: language imp ...
- Cookie和Session-学习笔记02【Cookie案例、JSP改造Cookie案例】
Java后端 学习路线 笔记汇总表[黑马程序员] Cookie和Session-学习笔记01[Cookie_快速入门.Cookie_细节] Cookie和Session-学习笔记02[Cookie案例 ...
- JSP、EL和JSTL-学习笔记02【MVC】
Java后端 学习路线 笔记汇总表[黑马程序员] JSP.EL和JSTL-学习笔记01[JSP基础语法] JSP.EL和JSTL-学习笔记02[MVC] JSP.EL和JSTL-学习笔记03[EL介绍 ...
- JSP基本语法：文件结构、脚本元素、指令元素、动作元素
JSP语法分为三种不同的类型: 脚本元素(SCRIPTING) 指令元素(DIRECTIVE) 例如: <%@ page import="java.io.*" %> 动 ...
- JSP页面的各种注释
1,css注释:/* 这里是CSS注释* /:2,js注释://这里是JS注释:3,html注释:< !- - 这是一个JSP文件 - ->:4,Java注释://这里是java小脚本:5 ...
- JSP第四篇【EL表达式介绍、获取各类数据、11个内置对象、执行运算、回显数据、自定义函数、fn方法库】...
什么是EL表达式? 表达式语言(Expression Language,EL),EL表达式是用"${}"括起来的脚本,用来更方便的读取对象! EL表达式主要用来读取数据,进行内容的 ...
- [原创]java WEB学习笔记36：Java Bean 概述，及在JSP 中的使用，原理
本博客为原创:综合 尚硅谷(http://www.atguigu.com)的系统教程(深表感谢)和 网络上的现有资源(博客,文档,图书等),资源的出处我会标明 本博客的目的:①总结自己的学习过程,相当 ...
- JSP学习 三大指令、九个内置对象、JavaBean、EL表达式
1.page-->最复杂:<%@page language="java" info="xxx"...%>* pageEncoding和cont ...
- JSP第四篇【EL表达式介绍、获取各类数据、11个内置对象、执行运算、回显数据、自定义函数、fn方法库】(修订版)...
前言 只有光头才能变强. 文本已收录至我的GitHub仓库,欢迎Star:https://github.com/ZhongFuCheng3y/3y 什么是EL表达式? 表达式语言(Expression ...
- JSP第四篇【EL表达式介绍、获取各类数据、11个内置对象、执行运算、回显数据、自定义函数、fn方法库】
什么是EL表达式? 表达式语言(Expression Language,EL),EL表达式是用"${}"括起来的脚本,用来更方便的读取对象! EL表达式主要用来读取数据,进行内容的 ...
最新文章
- 影像组学视频学习笔记(15)-ROC曲线及其绘制、Li‘s have a solution and plan.
- linux chown命令 改变文件拥有者
- Linux中assert头文件,linux系统下如何使用assert函数
- Spring：源码解读Spring IOC原理
- 每日源码分析 - lodash(debounce.js和throttle.js)
- Android studio2.3.1 更新以后Error:Failed to open zip file. Gradle's dependency cache may be corrupt
- php数组有没有类似next方法,PHP 数组current跟next用法
- 【转】pthread_cond_signal 虚假唤醒问题
- 【Web crawler】simulated DFS web crawler
- 使用Python语言实现凯撒密码的加密和解密
- 给大家推荐12款好用的3D编辑器
- 空间相关分析与SDM
- 推荐几款微信小程序常用组件库
- 1957：【12NOIP普及组】质因数分解
- python 回溯法 01背包问题_Python基于回溯法解决01背包问题实例
- postman接口自动化（三）变量设置与使用
- 【Vuejs】1017- Vue3 效率提升主要表现在哪些方面？
- oracle 日期 区别,oracle中日期类型 to_date 和to_timestamp什么区别啊？
- STM32 CAN模块问题：1、CAN收发器断电后重新上电，CAN模块死机（离线）现象；2、过滤器配置完之后没有过滤效果
- C语言绘制象棋棋盘/残局