一、JSP的使用
1. JSP的引入
有一种特殊的文件,我们可以在它内部编写HTML代码、CSS代码、js代码还有Java代码。编写完之后,再有一个工具,将这个特殊的文件转换成Servlet,在转换好的Servlet中,之前写的Java代码还在,而HTML、css、js代码都使用writer的方式给写好。这个特殊的文件就是jsp文件。这个工具就是Tomcat服务器中的jsp引擎。
2. JSP展示数据实例
<%@ page import="java.util.List" %>
<%@ page import="com.bjsxt.pojo.Emp" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.Date" %>
<%@ page import="java.text.SimpleDateFormat" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>$Title$</title>
<style>
table{
width: 550px;
margin: 0 auto;
border: 1px solid red;
border-collapse:collapse;
text-align: center;
}
td,th{
border: 1px solid red;
}
</style>
</head>
<body>
<%
//从数据库中查询
List<Emp> list = new ArrayList<>();
list.add(new Emp(1, "张无忌", "经理", new Date(), 5000.0));
list.add(new Emp(2, "赵敏", "主管", new Date(), 3000.0));
list.add(new Emp(3, "金毛狮王", "职员", new Date(), 2000.0));
list.add(new Emp(4, "灭绝师太", "职员", new Date(), 2000.0));
list.add(new Emp(5, "周芷若", "总监", new Date(), 8000.0));
%>
<table>
<tr>
<th>编号</th>
<th>姓名</th>
<th>职位</th>
<th>生日</th>
<th>工资</th>
</tr>
<% SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); %>
<% for (Emp emp : list) {%>
<tr>
<td><%out.write(emp.getId()+"");%></td>
<td><%out.write(emp.getName());%></td>
<td><%out.write(emp.getPosition());%></td>
<td><%out.write(sdf.format(emp.getBirthday()));%></td>
<td><%out.write(emp.getSalary()+"");%></td>
</tr>
<% }%>
</table>
</body>
</html>
3. JSP执行原理及流程
-
JSP看似是HTML代码,看似是页面,但其实是一种后端技术。
-
当我们第一次发送请求访问jsp资源时,Tomcat服务器中的JSP加载引擎会将该JSP资源转换成一个 .java 文件(Servlet)。
-
这个 .java文件其实就是一个Servlet,在这个Servlet中已经将写在JSP中的HTML代码以writer.print()的方式编写好了,然后将数据响应给浏览器的。
-
JSP本质上就是一个Servlet,JSP中的HTML代码就相当于我们之前在Servlet中写的writer.write()代码。
3.1 JSP执行过程
JSP的执行过程大致可以分为三个时期:转换、编译、执行。
转换/翻译(translation) | Tomcat中的JSP引擎将JSP网页转换成Servlet,得到一个.java文件。 |
编译(compile) | 通过javac命令将.java文件编译成 .class文件。 |
运行 | 运行.class字节码文件,处理请求。 |
具体运行过程:
浏览器发起请求访问jsp。
Tomcat服务器接收到请求后调用对应的Servlet处理请求,调用JspServlet。
JspServlet将请求的jsp文件转换成对应的Java文件并完成编译。
将编译后的class文件加载到内存并执行,其实就是运行一个Servlet。
最后得到结果数据响应浏览器。
转换后的代码如下:
package org.apache.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import java.util.List;
import com.bjsxt.pojo.Emp;
import java.util.ArrayList;
import java.util.Date;
import java.text.SimpleDateFormat;
public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent,
org.apache.jasper.runtime.JspSourceImports {
private static final javax.servlet.jsp.JspFactory _jspxFactory =
javax.servlet.jsp.JspFactory.getDefaultFactory();
private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;
private static final java.util.Set<java.lang.String> _jspx_imports_packages;
private static final java.util.Set<java.lang.String> _jspx_imports_classes;
static {
_jspx_imports_packages = new java.util.HashSet<>();
_jspx_imports_packages.add("javax.servlet");
_jspx_imports_packages.add("javax.servlet.http");
_jspx_imports_packages.add("javax.servlet.jsp");
_jspx_imports_classes = new java.util.HashSet<>();
_jspx_imports_classes.add("java.util.List");
_jspx_imports_classes.add("com.bjsxt.pojo.Emp");
_jspx_imports_classes.add("java.util.Date");
_jspx_imports_classes.add("java.text.SimpleDateFormat");
_jspx_imports_classes.add("java.util.ArrayList");
}
private volatile javax.el.ExpressionFactory _el_expressionfactory;
private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;
public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
return _jspx_dependants;
}
public java.util.Set<java.lang.String> getPackageImports() {
return _jspx_imports_packages;
}
public java.util.Set<java.lang.String> getClassImports() {
return _jspx_imports_classes;
}
public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
if (_el_expressionfactory == null) {
synchronized (this) {
if (_el_expressionfactory == null) {
_el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
}
}
}
return _el_expressionfactory;
}
public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
if (_jsp_instancemanager == null) {
synchronized (this) {
if (_jsp_instancemanager == null) {
_jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
}
}
}
return _jsp_instancemanager;
}
public void _jspInit() {
}
public void _jspDestroy() {
}
public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
throws java.io.IOException, javax.servlet.ServletException {
final java.lang.String _jspx_method = request.getMethod();
if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method) && !javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSPs only permit GET, POST or HEAD. Jasper also permits OPTIONS");
return;
}
final javax.servlet.jsp.PageContext pageContext;
javax.servlet.http.HttpSession session = null;
final javax.servlet.ServletContext application;
final javax.servlet.ServletConfig config;
javax.servlet.jsp.JspWriter out = null;
final java.lang.Object page = this;
javax.servlet.jsp.JspWriter _jspx_out = null;
javax.servlet.jsp.PageContext _jspx_page_context = null;
try {
response.setContentType("text/html;charset=UTF-8");
pageContext = _jspxFactory.getPageContext(this, request, response,
null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;
out.write("\n");
out.write("\n");
out.write("\n");
out.write("\n");
out.write("\n");
out.write("\n");
out.write("<html>\n");
out.write(" <head>\n");
out.write(" <title>$Title$</title>\n");
out.write("\n");
out.write(" <style>\n");
out.write(" table{\n");
out.write(" width: 550px;\n");
out.write(" margin: 0 auto;\n");
out.write(" border: 1px solid red;\n");
out.write(" border-collapse:collapse;\n");
out.write(" text-align: center;\n");
out.write(" }\n");
out.write(" td,th{\n");
out.write(" border: 1px solid red;\n");
out.write(" }\n");
out.write(" </style>\n");
out.write(" </head>\n");
out.write(" <body>\n");
out.write("\n");
out.write(" ");
//从数据库中查询
List<Emp> list = new ArrayList<>();
list.add(new Emp(1, "张无忌", "经理", new Date(), 5000.0));
list.add(new Emp(2, "赵敏", "主管", new Date(), 3000.0));
list.add(new Emp(3, "金毛狮王", "职员", new Date(), 2000.0));
list.add(new Emp(4, "灭绝师太", "职员", new Date(), 2000.0));
list.add(new Emp(5, "周芷若", "总监", new Date(), 8000.0));
out.write("\n");
out.write("\n");
out.write(" <table>\n");
out.write(" <tr>\n");
out.write(" <th>编号</th>\n");
out.write(" <th>姓名</th>\n");
out.write(" <th>职位</th>\n");
out.write(" <th>生日</th>\n");
out.write(" <th>工资</th>\n");
out.write(" </tr>\n");
out.write("\n");
out.write(" ");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
out.write("\n");
out.write(" ");
for (Emp emp : list) {
out.write("\n");
out.write("\n");
out.write(" <tr>\n");
out.write(" <td>");
out.write(emp.getId()+"");
out.write("</td>\n");
out.write(" <td>");
out.write(emp.getName());
out.write("</td>\n");
out.write(" <td>");
out.write(emp.getPosition());
out.write("</td>\n");
out.write(" <td>");
out.write(sdf.format(emp.getBirthday()));
out.write("</td>\n");
out.write(" <td>");
out.write(emp.getSalary()+"");
out.write("</td>\n");
out.write(" </tr>\n");
out.write("\n");
out.write(" ");
}
out.write("\n");
out.write(" </table>\n");
out.write(" </body>\n");
out.write("</html>\n");
} catch (java.lang.Throwable t) {
if (!(t instanceof javax.servlet.jsp.SkipPageException)){
out = _jspx_out;
if (out != null && out.getBufferSize() != 0)
try {
if (response.isCommitted()) {
out.flush();
} else {
out.clearBuffer();
}
} catch (java.io.IOException e) {}
if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
else throw new ServletException(t);
}
} finally {
_jspxFactory.releasePageContext(_jspx_page_context);
}
}
}
3.2 JSP的性能问题
JSP的执行性能和Servlet的执行性能上的差别只在第一次的执行上。因为在第一次执行jsp时,jsp要经过转换、编译、执行三个过程。而之后再次访问jsp页面时,就直接执行第一次所产生的Servlet即可,不需要每次都转换、编译。
JSP和HTML相比的话肯定是要慢的,他们的机制就不一样,JSP本质上是Servlet,在请求jsp时,要经过执行,其内部是通过大量的IO流形式将内容发送给页面的,IO流就是一种比较耗费资源的操作。而HTML本身资源是已经存在的,不需要服务器执行什么操作。
但JSP是动态资源,可以动态的展示数据。
3.3 JSP加载引擎
查看Tomcat conf/web.xml文件发现,这里默认配置了一个JSP的加载引擎-JspServlet。
<servlet>
<servlet-name>jsp</servlet-name>
<servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
<init-param>
<param-name>fork</param-name>
<param-value>false</param-value>
</init-param>
<init-param>
<param-name>xpoweredBy</param-name>
<param-value>false</param-value>
</init-param>
<load-on-startup>3</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>jsp</servlet-name>
<url-pattern>*.jsp</url-pattern>
<url-pattern>*.jspx</url-pattern>
</servlet-mapping>
可以看到,请求jsp页面的请求都会被jsp加载引擎所匹配到,那么该引擎有什么作用?
- 转换JSP页面:将JSP页面转换成一个Servlet。
- 编译JSP对应的Java文件:JSP引擎调用Java编译器对这个Servlet进行编译,得到可执行文件class。
- 请求处理:JSP引擎调用java虚拟机来解释执行class文件,得到结果响应浏览器。
4. JSP的继承结构
JSP文件转换成JAVA代码之后,它默认继承了HttpJspBase,实现了JspSourceDependent,和JspSourceImports两个接口,其中HttpJspBase又继承了HttpServlet ,也就是说,JSP本质上就是一个Servlet。
HttpJSPBase代码:
public abstract class HttpJSPBase extends HttpServlet implements HttpJSPPage {
private static final long serialVersionUID = 1L;
protected HttpJSPBase() {
}
@Override
public final void init(ServletConfig config)
throws ServletException {
super.init(config);
JSPInit();
_JSPInit();
}
@Override
public String getServletInfo() {
return Localizer.getMessage("JSP.engine.info", Constants.SPEC_VERSION);
}
@Override
public final void destroy() {
JSPDestroy();
_JSPDestroy();
}
@Override
public final void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException
{
_JSPService(request, response);
}
@Override
public void JSPInit() {
}
public void _JSPInit() {
}
@Override
public void JSPDestroy() {
}
protected void _JSPDestroy() {
}
@Override
public abstract void _JSPService(HttpServletRequest req,HttpServletResponse resp)
throws ServletException, IOException;
}
HttpJSPBase重写了init,service和destory方法。并且自定义了 jspInit, jspService, jspDestory。
然后在重写的init方法中调用了 JSPInit,在重写的service方法中调用了 jspService,在重写的destory方法中调用了 jspDestory。
我们JSP的文件编译成JAVA代码后,继承HttpJspBase重写的方法是 jspInit, jspService, jspService。
5. JSP中的java代码
在jsp中可以通过 <%%> 和 <%!%>两种方式来书写代码,这两种方式中写的Java代码在转换后生成的代码在Servlet中位置是不一样的,前者在_jspService方法中,后者在Servlet中作为类的成员。
下面以定义变量举例,在jsp中定义局部变量和成员变量:
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%-- 定义局部变量 --%>
<%
int a = 10;
%>
<%-- 定义成员变量 --%>
<%!
int b = 20;
%>
</body>
</html>
JSP本质上是Servlet,在Servlet中我们是不推荐定义一些成员变量的。
6. JSP中的注释
JSP中可以写HTML、Java、CSS、JS代码,那么也就可以写这些语言的注释,并且JSP也有自己的注释方式。JSP的注释格式是:<%--注释内容--%>
不同的注释是有差异的,通过下面案例对比一下:
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
<style>
/*我是css注释*/
</style>
<script>
//我是JS注释
/*我是JS注释*/
</script>
</head>
<body>
<!--我是HTML注释-->
<%--我是jsp注释--%>
</body>
</html>
通过查看转换后的文件和查看浏览器中的页面源码发现:
注释类型 | 进入转译文件 | 响应给浏览器 |
---|---|---|
JSP注释 | no | no |
JAVA注释 | yes | no |
HTML,css,js注释 | yes | yes |
7. JSP的使用建议
JSP和Servlet本质上是相同的。所以说,JSP页面功能和Servlet中功能完全可以互换。
JSP的编码风格是在HTML中嵌入少量的Java代码,它用于展示数据比较方便。
Servlet适合编写Java代码。
所以在MVC分层上,我们往往将Servlet作为控制层,将JSP作为视图层。
以后通过Servlet去处理请求,得到结果,然后通过JSP来进行结果展示。
二、JSP中的常用指令标签
1. 概述
指令标签是JSP页面上的一种特殊标签,JSP指令可以用来设置整个JSP页面相关的属性,如网页的编码方式、网页使用的脚本语言、导包等。
指令标签的语法: <%@ directive attribute="value" %>
JSP中的三种指令标签:
指令 | 描述 |
---|---|
<%@ page %> | 定义网页依赖属性,如脚本语言、error页面、缓存需求等等 |
<%@ include %> | 包含其他文件 |
<%@ taglib %> | 引入标签库的定义 |
2. page指令标签
属性 | 描述 |
---|---|
buffer | 指定out对象使用缓冲区的大小 |
autoFlush | 控制out对象的 缓存区 |
contentType | 指定当前JSP页面的MIME类型和字符编码 |
errorPage | 指定当JSP页面发生异常时需要转向的错误处理页面 |
isErrorPage | 指定当前页面是否可以作为另一个JSP页面的错误处理页 |
extends | 指定servlet从哪一个类继承 |
import | 导入要使用的Java类 |
info | 定义JSP页面的描述信息 |
isThreadSafe | 指定对JSP页面的访问是否为线程安全 |
language | 定义JSP页面所用的脚本语言,默认是Java |
session | 指定JSP页面是否使用session,默认是使用 |
isELIgnored | 指定是否执行EL表达式 |
isScriptingEnabled | 确定脚本元素能否被使用 |
<%@ page contentType="text/html;charset=UTF-8" language="java"
import="com.bjsxt.pojo.Emp" pageEncoding="utf-8" errorPage="error500.jsp"
isErrorPage="true" %>
<%--
contentType:告诉浏览器响应的数据类型及编码格式
language:设置jsp页面中使用的脚本语言
import:导包
pageEncoding:当前页面的编码格式
errorPage:指定错误页,当前页面发生错误时,显示错误页面的信息
isErrorPage:指定当前页面为错误提示页,也可以接收异常对象
--%>
<html>
<head>
<title>Title</title>
</head>
<body>
<%
int a = 1/0;
%>
</body>
</html>
errorPage是一种处理错误提示页的功能。除了jsp的这种错误提示功能外,我们也可以在web.xml中配置各种错误提示页。
注意:如果jsp中配置的错误页和web.xml中配置的错误页冲突的话,以jsp中指定的errorPage为准,它的优先级更高。
<error-page>
<error-code>500</error-code>
<location>/error500.jsp</location>
</error-page>
<error-page>
<error-code>404</error-code>
<location>/error404.jsp</location>
</error-page>
3. include指令标签
-
JSP可以通过include指令来包含其他文件。被包含的文件可以是jsp文件、HTML文件或文本文件。
-
包含的文件就像是jsp文件的一部分,会被同时编译执行。
-
除了使用include指令标签可以实现引入外,使用jsp:include动作也可以实现引入。
案例:
这个是hello1.jsp文件:
<body>
我是hello1.jsp页面内容。<br>
<%--
静态引入,被引入的jsp页面不会单独生成java代码文件,当前页和被引入页会生成一个java文件
--%>
<%@ include file="hello2.jsp"%>
<%--
动态引入:被引入的页面会生成独立的java代码,在当前页生成的java代码中使用
org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response, "hello3.jsp", out, false);
引入其他页面
--%>
<jsp:include page="hello3.jsp"></jsp:include>
</body>
静态引入: @include 被引入的网页和当前页生成代码后形成了一个java文件。
动态引入: jsp:include 被引入的JSP页面会生成独立的java代码。
4. taglib指令标签
taglib就是标签库的意思,我们可以在jsp页面中引入其他的标签库,帮我们去快速简单的做一些事情,后面JSTL标。签库会详细介绍。
taglib指令的语法:<%@ taglib uri="uri" prefix="prefixOfTag" %>
三、JSP内置对象
1. 什么是内置对象
因为JSP的本质是Servlet,在JSP文件经过转译之后,生成JAVA代码,在运行时,JSP给我们准备好了九个可以直接使用而不用我们自己去new的对象,这九个对象我们称之为内置对象。
内置对象完全由JSP自行去维护, 我们直接使用即可。
2. 九大内置对
2. 九大内置对象
2.1 对象介绍
四个域对象 | pageContext | page域 | 当前页面内可用。 |
request | reqeust域 | 一次请求。 | |
session | session域 | 一次会话, 多次请求。 | |
application | application域 | 整个项目运行, 多次请求, 多次会话。 | |
响应对象 | response | 响应对象 | |
输出流对象 | out | 打印流对象。 | |
其他三个对象 | servletConfig | 由于JSP本身也是一个Servlet,所以容器也会给我们准备一个ServletConfig。 | |
page | 就是JSP转换的Servlet的对象,也就是当前JSP对象本身 。 | ||
exception | 异常对象,在错误提示页上使用,当isErrorpage=true 才具有该对象。 |
2.2 注意事项
response对象:
当服务器创建request对象时会同时创建用于响应客户端的response对象。
out对象 :
是 JspWriter 类的实例,不是PrinterWriter的实例;用来在response对象中写入内容。JspWriter类包含了大部分java.io.PrintWriter类中的方法。不过,JspWriter增了一些专为处理缓存而设计的方法。另外JspWriter类会抛出IOExceptions异常。 最初的JspWriter类对象根据页面是否有缓存来进行不同的实例化操作。可以在page指令中使用。buffered='false'属性来轻松关闭缓存。
pageContext对象:
PageContext类的实例,用来代表整个JSP页面;提供对JSP页面所有对象以及命名空间的访问。
3. Servlet与JSP的联系和区别
联系:
-
JSP和Servlet都是Sun公司推出的动态网页技术。
-
基于Servlet开发页面的繁琐性,推出JSP来简化页面开发。
-
JSP本质上是一个Servlet,会翻译成一个Servlet。
区别:
-
JSP使人们把显示和逻辑分隔成为可能,这意味着两者的开发可并行进行;而Servlet并没有把两者分开。
-
JSP是在HTML代码里写JAVA代码,框架是HTML;而Servlet是在JAVA代码中写HTML代码,本身是个JAVA类。
-
Servlet需要在web.xml中配置,而JSP无需配置。
-
目前JSP主要用在视图层负责显示,而Servlet主要用在控制层负责调度
强调:JSP表面上是一个HTML,本质上是一个Servlet。
4. JSP的使用总结
-
创建Jsp文件,在项目的web目录下创建。
-
使用page指令设置Jsp的转译细节(一般自动生成的就够用)。
-
使用tablib指令引入第三方的自定义标签来使用(JSTL标签)。
-
使用HTML,CSS,JQuery完成页面的开发。
-
使用<%%>声明java脚本片段完成数据的动态拼接。
-
<%%>:生成在_jspService()方法中
-
<%! %>:生成在类中
-
<%= %>:生成在_jspService()方法中,输出
-
-
获取request或者session中的数据拼接到当前页面中(内置对象)。
四、EL表达式
可以在jsp页面中使用EL表达式来获取域对象中的数据(核心思想获取数据)。
1. 特点
- 可以获取作用域对象中的数据。
- 底层使用的是反射,在使用的时候可以通过键名即可获取对应的值。
- 简化了在jsp页面中使用<%%>获取域对象数据的方式。
2. 使用
2.1 基本语法
- ${键名},键名是域对象中存储的数据的键。
- ${键名.属性名.属性名…},可以获取域对象中级联属性的值。
- ${键名[角标]},获取域对象中存储的list集合或者数组中指定角标的数据。
注意:${} 不仅可获取域对象中的数据,而且会将该数据打印到浏览器中。如果获取不到数据,也不会报错,只是不显示而已。
2.2 作用域数据查找顺序
使用EL表达式获取域数据的时候,如果没有指明作用域,那会按照作用域由小到大的顺序去找,直到找到为止: pageContext ---> request ---> session ---> application
2.3 指定获取某个作用域中的数据
-
${pageScope.键名} 获取page域对象中的数据
-
${requestScope.键名} 获取request域对象中的数据
-
${sessionScope.键名} 获取session域对象中的数据
-
${applicationScope.键名} 获取application域对象中的数据
2.4 获取request对象中的请求数据
${param.键名},可以获取request中携带的请求参数的数据
2.5 获取request对象中Cookie的key value
- ${cookie.JSESSIONID.name}
- ${cookie.JSESSIONID.value}
2.6 EL表达式使用比较运算和算术运算
- ${键名 逻辑运算符 键名}
- ${键名 算术运算符 键名}
注意: + 表示的是算术运算,而不是字符串拼接。
3. 案例
<%@ page import="com.bjsxt.pojo.Emp" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.Map" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h2>使用脚本方式获取数据</h2>
<ul>
<li>获取简单数据:<%out.write(request.getAttribute("name").toString());%></li>
<li>获取对象数据:<%out.write(((Emp)request.getAttribute("emp")).getName());%></li>
<li>获取list集合数据:<%out.write(((List)request.getAttribute("list")).get(0).toString());%></li>
<li>获取map集合数据:<%out.write(((Map)request.getAttribute("map")).get("key1").toString());%></li>
</ul>
<h2>使用EL表达式方式获取数据</h2>
<ul>
<li>获取简单数据:${name}</li>
<li>获取对象数据:${emp}</li>
<li>获取list集合数据:${list[0]}</li>
<li>获取map集合数据:${map.key1}</li>
</ul>
<h2>指明域对象获取数据</h2>
<ul>
<li>获取request域数据:${requestScope.requestParam}</li>
<li>获取session域数据:${sessionScope.sessionParam}</li>
<li>获取application域数据:${applicationScope.applicationParam}</li>
</ul>
<h2>使用逻辑表达式</h2>
${3 > 4}<br>
${5 + 8}
</body>
</html>
五、JSTL标签库学习
(核心思想:使用数据)
可以使用JSTL标签来完成一些例如循环、判断等情况的与数据输出。JSTL的作用就是:替换在Jsp中声明的Java逻辑代码。
1. 介绍
JSTL标签库是第三方发明的自定义的标签,每个标签都有自己特定的含义表示一个具体的java逻辑。我们要在JSP中使用JSTL必须使用taglib标签引入第三方的标签库资源。 标签库的内容有:
- 核心标签库
- SQL标签库
- 函数标签库
- 格式化标签库
- XML标签库
2. 使用
使用步骤:
-
在项目中导入JSTL的jar包。
-
在jsp页面中通过taglib指令引入jstl标签库。
-
使用jstl标签完成开发。
3.案例
3.1 判断
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%
request.setAttribute("gender", "0");
%>
<%--
c:if 标签的作用就相当于Java中的if判断
格式是: <c:if test="${EL 比较运算符 值}">条件成立输出的内容</c:if>
--%>
<c:if test="${gender == '0'}">
性别是男。
</c:if>
</body>
</html>
3.2 循环
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<c:forEach items="${list}" var="emp">
${emp.id}---${emp.name}---${emp.position} <br>
</c:forEach>
<c:forEach begin="0" end="10" var="i" step="1" varStatus="status">
${i} --- ${status.index}
</c:forEach>
</body>
</html>