JSP与EL、JSTL表达式
JSP与EL、JSTL表达式
JSP基本语法
什么是JSP
Java Server Page
为什么有JSP
- Servlet显示HTML的页面元素的时候有缺陷.
- JSP的简单的使用: JSP = JSP自身东西+HTML的东西+Java代码.
JSP的执行原理
JSP 页面文件通常以 .jsp 为扩展名，而且可以安装到任何能够存放普通 Web 页面的地方。虽然从代码编写来看，JSP 页面更像普通 Web 页面而不像 Servlet，但实际上，JSP 最终会被转换成正规的 Servlet，静态 HTML 直接输出到和 Servlet service 方法关联的输出流。
JSP 到 Servlet 的转换过程一般在出现第一次页面请求时进行。因此，如果希望第一个用户不会由于 JSP 页面转换成 Servlet 而等待太长的时间，并且希望确保 Servlet 已经正确地编译并装载，你可以在安装 JSP 页面之后自己请求这个页面，这样 JSP 页面就转换成 Servlet 了。
使用JSP
-
JSP的脚本：<% %>
-
JSP的注释: <%-- --%>
-
JSP的内置对象: request 、 response 、 session 、 application、out、 page、 pageContext、 exception、config、 、
-
JSP的指令: <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ include file="foot.jsp" %>
- JSP的标签：<jsp:include page="top.jsp"/>
JSP的脚本
- <%! JSP声明 %>: 定义类，方法，属性. 翻译成Servlet内部的内容
- <% JSP代码块%> : Java代码.定义类，属性. 翻译成Servlet的service方法内部内容.
- <%= JSP的表达式%>:表达式. 翻译成out.print();
JSP的注释
-
HTML的注释:可以存在JSP源码中,翻译成的Servlet中的注释也存在,在HTML的代码中也会存在；
-
Java代码注释：
<% // 单行注释 可以存在于JSP源码中在翻译成Servlet的时候，Java代码的注释也是会存在的.但是生成HTML的页面之后,注释就会消失了. /* 多行注释 */ /** *文档注释 */ %> -
JSP的注释：<%-- --%>只会存在于JSP的源代码中,当代表翻译成Servlet了 JSP的注释就消失了
JSP的指令
JSP中的三大指令。
JSP 指令是为 JSP 引擎（比如 Tomcat）而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理 JSP 页面中的其余部分。一般都会把 JSP 指令放到 JSP 文件的最上方，但这不是必须的。
JSP 引擎会根据 JSP 的指令信息来编译 JSP，生成 Java 文件。在生成的 Java 文件中，指令就不存在了。
指令通常以<%@ 标记开始，以%>标记结束，它的具体语法如下：
<%@ 指令名称 属性1="属性值1" 属性2="属性值2" ... 属性n="属性值n" %>
JSP 中有三大指令，它们分别是 page、include 和 taglib，以下是对它们的简要说明。
-
page指令:
page 指令用于定义 JSP 页面的各种属性。page 是最复杂的一个指令，它的属性很多，常用的属性有 import、language、pageEncoding 等。具体属性含义如下：
-
language：JSP的语言的属性.现在只能是java.
-
contentType：设置浏览器默认的MIME类型及页面的字符集编码.
-
pageEncoding：设置JSP文件保存到硬盘,以及翻译成Servlet保存到硬盘的编码格式.
-
import：设置JSP中引入其他的类.import属性可以出现多次的.
-
extends：设置JSP被翻译成Servlet后继承的类:默认值: org.apache.jasper.runtime.HttpJspBase. 修改这个值得话一定要使这个类是一个Servlet才可以.
-
autoFlush：设置自动刷出缓存
-
buffer：JSP的缓冲区的大小。默认8kb
-
session：默认值是true.设置JSP的页面中是否可以直接使用session对象.
-
isELIgnored：设置JSP是否忽略EL表达式.默认值false 不忽略，即可以在JSP中写EL表达式.
-
isErrorPage：设置JSP页面中出现错误信息应该如何处理的.
-
errorPage：设置JSP页面中出现错误信息应该如何处理的.
-
-
include指令:用于引入其他的页面
include静态包含指令，用于引入其它 JSP 文件。使用 include 指令引入的其它 JSP 文件，JSP 引擎将把这两个 JSP 文件翻译成一个 servlet，所以将 include 称为静态包含。
-
file属性：属性中不能使用变量,不能传递参数
<%@include file="logo.jsp" %> <%@include file="menu.jsp" %> <h1>Body</h1> <%@include file="footer.jsp" %>
-
-
taglib指令：
taglib 用于在 JSP 页面中导入标签库（JSP 标准标签库、第三方标签库、自定义标签库）。
<%@ taglib uri=""prefix="" %>
JSP的动作标签
JSP 动作利用 XML 语法格式的标记来控制服务器的行为，完成各种通用的 JSP 页面功能，也可以实现一些处理复杂业务逻辑的专用功能。如利用 JSP 动作可以动态地插入文件、重用 JavaBean 组件、把用户重定向到另外的页面、为 Java 插件生成 HTML 代码。
JSP 动作与 JSP 指令的不同之处是，JSP 页面被执行时首先进入翻译阶段，程序会先查找页面中的 JSP 指令标识；并将它们转换成 Servlet，所以，这些指令标识会首先被执行，从而设置了整个 JSP 页面，所以，JSP 指令是在页面转换时期被编译执行的，且编译一次；而 JSP 动作是在客户端请求时按照在页面中出现的顺序被执行的，它们只有被执行的时候才会去实现自己所具有的功能，且基本上是客户每请求一次，动作标识就会执行一次。
JSP 动作的通用格式如下：
<jsp:动作名 属性1="属性值1"...属性n="属性值n" />
或者
<jsp:动作名; 属性1="属性值1"...属性n="属性值n">相关内容</jsp: 动作名>
JSP 中常用的动作包括 <jsp: include>、<jsp: param>、<jsp: forward>、<jsp: plugin>、<jsp: useBean>、<jsp: setProperty>、<jsp: getProperty>。
JSP的内置对象
内置对象：JSP中可以直接使用的对象.
JSP的内置对象有哪些？常用的方法？真实对象是谁？
JSP中有9个内置对象:
JSP内置对象：
| 对象名 | 类型 | 常用方法 |
|---|---|---|
| request | HttpServletRequest | getParameter ()（获取请求参数值）、setAttribute ()（设置属性）、getAttribute ()（获取属性） |
| response | HttpServletResponse | setStatus ()（设置响应状态码）、sendRedirect ()（发送重定向）、getOutputStream ()（获取输出流） |
| session | HttpSession | setAttribute ()（设置会话属性）、getAttribute ()（获取会话属性）、removeAttribute ()（移除会话属性） |
| application | ServletContext | setAttribute ()（设置应用程序属性）、getAttribute ()（获取应用程序属性）、removeAttribute ()（移除应用程序属性） |
| page | Object | toString ()（转换为字符串）、wait ()（使线程等待），是 JSP 被翻译成 Servlet 的引用 |
| pageContext | PageContext | setAttribute ()（设置页面上下文属性）、getAttribute ()（获取页面上下文属性）、removeAttribute ()（移除页面上下文属性） |
| out | JspWriter | write ()（写入内容）、print ()（打印内容） |
| config | ServletConfig | getInitParameter ()（获取初始化参数值）、getInitParameterNames ()（获取所有初始化参数名称） |
| exception | Throwable | getMessage ()（获取异常信息）、getCause ()（获取异常原因） |
-
out对象：
out对象是 javax.servlet.jsp.JspWriter 类的实例，用来在response对象中写入内容。
最初的JspWriter类对象根据页面是否有缓存来进行不同的实例化操作。可以在page指令中使用buffered='false'属性来轻松关闭缓存。
JspWriter类包含了大部分java.io.PrintWriter类中的方法。不过，JspWriter新增了一些专为处理缓存而设计的方法。还有就是，JspWriter类会抛出IOExceptions异常，而PrintWriter不会。
使用out对象管理输出缓冲区：
默认情况下，服务端要输出到客户端的内容不直接写到客户端，而是先写到一个输出缓冲区中。使用 out 对象的 getBufferSize() 方法取得当前缓冲区的大小（单位是 KB），用 getRemaining() 方法取得当前使用后还剩余的缓冲区的大小（单位是 KB）。
JSP 只有在下面三种情况下，才会把缓冲区的内容输出到客户端。
-
该 JSP 网页已完成信息的输出。
-
输出缓冲区己满。
-
JSP 中调用了 out.flush() 或 response.flushBuffer()。
另外，调用 out 对象的 clear() 方法，可以清除缓冲区的内容，类似于重置响应流，以便重新开始操作。如果响应已经提交，则会产生 IOException 异常。此外，另一种方法 clearBuffer() 可以清除缓冲区“当前”内容，而且即使内容已经提交给客户端，也能够访问该方法。
-
-
四个域对象
名称 作用域名称 作用域描述 pageContext pageScope 页面范围，仅在当前 JSP 页面有效，页面跳转后失效 request requestScope 请求范围，在一次请求内有效，请求转发时可共享数据，请求结束则数据消失 session sessionScope 会话范围，在一次会话（浏览器打开到关闭期间）内有效，不同页面间可共享数据 application applicationScope 应用范围，在整个 Web 应用程序生命周期内有效，所有用户和页面都可访问该范围内的数据 -
request对象：
客户端可通过 HTML 表单或在网页地址后面提供参数的方法提交数据，然后通过 request 对象的相关方法来获取这些数据。request 对象封装了客户端的请求信息，包括用户提交的信息以及客户端的一些信息，服务端通过 request 对象可以了解到客户端的需求，然后做出响应。
request 对象是 HttpServletRequest（接口）的实例。请求信息的内容包括请求的标题头（Header）信息（如浏览器的版本信息语言和编码方式等），请求的方式（如 HTTP 的 GET 方法、POST 方法等），请求的参数名称、参数值和客户端的主机名称等。
request 对象提供了一些方法，主要用来处理客户端浏览器提交的请求中的各项参数和选项。
request对象的作用：
- 获取请求客户端信息
- 获取请求参数
- 获取查询字符串信息
-
session:
客户与服务器之间的通信是通过 HTTP 协议完成的。HTTP 是一种无状态的协议，当客户向服务器发出请求，服务器接收请求并返回响应后，该连接就被关闭了。此时，服务器端不保留连接的有关信息，要想记住客户的连接信息，可以使用 JSP 提供的 session 对象。
用户登录网站时，系统将为其生成一个独一无二的 session 对象，用以记录该用户的个人信息。一旦用户退出网站，那么，所对应的 session 对象将被注销。session 对象可以绑定若干个用户信息或者 JSP 对象，不同的 session 对象的同名变量是不会相互干扰的。
当用户首次访问服务器上的一个 JSP 页面时，JSP 引擎便产生一个 session 对象，同时分配一个 String 类型的 ID 号，JSP 引擎同时将这个 ID 号发送到客户端，存放在 Cookie 中，这样，session 对象和客户端之间就建立了一一对应的关系。
当用户再次访问该服务器的其他页面时，不再分配给用户新的 session 对象，直到用户关闭浏览器，或者在一定时间（系统默认在 30 分钟内，但可在编写程序时，修改这个时间限定值或者显式地结束一个会话）客户端不向服务器发出应答请求，服务器端就会取消该用户的 session 对象，与用户的会话对应关系消失。当用户重新打开浏览器，再次连接到该服务器时，服务器为该用户再创建一个新的 session 对象。
session 对象保存的是每个用户专用的私有信息，可以是与客户端有关的，也可以是一般信息，可以根据需要设定相应的内容，并且所保存的信息在当前 session 属性范围内是共享的。
- 创建及获取客户会话属性：setAttribute()
- 从会话中移除指定的对象：removeAttribute()
- 设置会话时限: session.setMaxInactiveInterval(60*5); //设置session的有效时间为5分钟
-
application：
JSP application 对象是 javax.servlet.ServletContext 类的实例，这有助于查找有关 Servlet 引擎和 Servlet 环境的信息。它的生命周期从服务器启动到关闭。在此期间，对象将一直存在。这样，在用户的前后连接或不同用户之间的连接中，可以对此对象的同一属性进行操作。在任何地方对此对象属性的操作，都会影响到其他用户的访问，可以实现共享数据。
方法 说明 getAttribute(String arg) 获取 application 对象中含有关键字的对象 getAttributeNames() 获取 application 对象的所有参数名字 getMajorVersion() 获取服务器支持 Servlet 的主版本号 getMinorVersion() 获取服务器支持 Servlet 的从版本号 removeAttribute(java.lang.String name) 根据名字删除 application 对象的参数 setAttribute(String key, Object obj) 将参数 Object 指定的对象 obj 添加到 application 对象中，并为添加的对象指定一个索引关键字 应用举例：用 application 对象的 setAttribute() 和 getAttribute() 方法实现网页计数器功能
-
pageContext对象
pageContext 是页面上下文对象，这个特殊的对象提供了 JSP 程序执行时所需要用到的所有属性和方法，如 session、application、config、out 等对象的属性，也就是说，它可以访问本页所有的 session，也可以取本页所在的 application 的某一属性值，它相当于页面中所有其他对象功能的集大成者，可以用它访问本页中所有的其他对象。
pageContext 对象是 javax.servlet:jsp.pageContext 类的一个实例，它的创建和初始化都是由容器来完成的，JSP 页面里可以直接使用 pageContext 对象的句柄，pageContext 对象的 getXxx()、setXxx() 和 findXxx() 方法可以根据不同的对象范围实现对这些对象的管理。
提示：
pageContext 对象在实际 JSP 开发过程中很少使用，因为 request 和 response 等对象可以直接调用方法进行使用，而通过 pageContext 来调用其他对象，会觉得有些麻烦。
-
JavaBean
咖啡豆，咖啡的实体
JavaBean有特定的写法：
- 必须要有一个无参构造
- 属性必须私有化
- 必须对应的get/set方法
一般用来和数据库的字段做映射 ORM
ORM：对象关心映射
- 表-->类
- 字段-->属性
- 行记录-->对象
people表
| id | name | age | address |
|---|---|---|---|
| 1 | 1 号 | 3 | 邯郸 |
| 2 | 2 号 | 18 | 邯郸 |
| 3 | 3 号 | 100 | 邯郸 |
实体类
package com.javaee.pojo;
//pojo和entity都是放实体类的
//实体类
public class People {
//实体类 我们一般都是和数据库中的表结构一一对应!
private int id;
private String name;
private int age;
private String address;
public People() {
}
public People(int id, String name, int age, String address) {
this.id = id;
this.name = name;
this.age = age;
this.address = address;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "People{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}
}
JSP页面
<%@page import="com.javaee.pojo.People" language="java" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<jsp:useBean id="people" class="com.javaee.pojo.People" scope="page"/>
<jsp:setProperty name="people" property="address" value="秦皇岛"/>
<jsp:setProperty name="people" property="id" value="1"/>
<jsp:setProperty name="people" property="age" value="15"/>
<jsp:setProperty name="people" property="name" value="ario"/>
<jsp:getProperty name="people" property="id"/>
<jsp:getProperty name="people" property="name"/>
<jsp:getProperty name="people" property="age"/>
<jsp:getProperty name="people" property="address"/>
<%
//下面与上面等价，知识没传参数
// People people1 = new People();
// people1.setAddress();
// people1.setId();
// people1.setName();
// people1.setAge();
//
// people1.getAddress();
// people1.getAge();
// people1.getId();
// people1.getName();
%>
</body>
</html>
Dao
DAO（Data Access Object） 模型就是写一个类，把访问数据库的代码封装起来，DAO在数据库与业务逻辑（Service）之间。
Dao是数据访问层，Dao的作用是封装对数据库的访问：增删改查，不涉及业务逻辑，只是达到按某个条件获得指定数据的要求。
让程序员用面向对象的方式访问数据库，操作数据库跟操作对象一样简单
案例代码：
接口
//接口
public interface BookDao {
// 得到所有的book.list
ArrayList<Book> getBookList();
void addBook(Book var1);
void delBook(int var1);
Book getBookById(int var1);
void modifyBook(Book var1);
}
实现类
//实现类
public class BookDaoImpl implements BookDao {
@Override
public ArrayList<Book> getBookList() {
ArrayList<Book> booklist = new ArrayList();
Connection conn = ConnFactory.getConn();
Statement stmt = null;
ResultSet rs = null;
try {
stmt = conn.createStatement();
rs = stmt.executeQuery("SELECT * FROM book");
while(rs.next()) {
Book book = new Book(rs.getInt("id"), rs.getString("book_name"), rs.getString("book_author"), rs.getString("book_publish"));
booklist.add(book);
}
} catch (SQLException var6) {
var6.printStackTrace();
}
ConnFactory.closeConn(conn);
return booklist;
}
@Override
public void addBook(Book var1) {
Connection conn = ConnFactory.getConn();
Statement stmt = null;
//预处理的stmt
PreparedStatement pstmt = null;
try {
// stmt = conn.createStatement();
// String insert = "insert into book(book_name,book_author,book_publish) values ('"+ var1.getBookName()+"','"+ var1.getBookAuthor()+"','"+ var1.getBookPublish()+ "')";
//// System.out.println(insert);
// stmt.execute(insert);
String insert = "insert into book(book_name,book_author,book_publish) values (?, ?, ?)";
pstmt = conn.prepareStatement(insert);
pstmt.setString(1, var1.getBookName());
pstmt.setString(2,var1.getBookAuthor());
pstmt.setString(3,var1.getBookPublish());
pstmt.execute();
} catch (SQLException var6) {
var6.printStackTrace();
}
ConnFactory.closeConn(conn);
}
@Override
public void delBook(int var1) {
Connection conn = ConnFactory.getConn();
PreparedStatement pstmt = null;
try {
String insert = "delete from book where id = ?";
pstmt = conn.prepareStatement(insert);
pstmt.setInt(1, var1);
pstmt.execute();
} catch (SQLException var6) {
var6.printStackTrace();
}
ConnFactory.closeConn(conn);
}
@Override
public Book getBookById(int var1) {
Connection conn = ConnFactory.getConn();
Statement stmt = null;
ResultSet rs = null;
Book book = null;
try {
stmt = conn.createStatement();
for(rs = stmt.executeQuery("SELECT * FROM book where id=" + var1); rs.next(); book = new Book(rs.getInt("id"), rs.getString("book_name"), rs.getString("book_author"), rs.getString("book_publish"))) {
}
} catch (SQLException var7) {
var7.printStackTrace();
}
ConnFactory.closeConn(conn);
return book;
}
@Override
public void modifyBook(Book var1) {
Connection conn = ConnFactory.getConn();
PreparedStatement pstmt = null;
try {
String insert = "update book set book_name=?,book_author=?,book_publish=? where id = ?";
pstmt = conn.prepareStatement(insert);
pstmt.setString(1, var1.getBookName());
pstmt.setString(2,var1.getBookAuthor());
pstmt.setString(3,var1.getBookPublish());
pstmt.setInt(4,var1.getId());
pstmt.execute();
} catch (SQLException var6) {
var6.printStackTrace();
}
ConnFactory.closeConn(conn);
}
}
这里的connFactory
public class ConnFactory {
public static final String URL = "jdbc:mysql://localhost:3306/sql?characterEncoding=UTF-8&eroDateTimeBehavior=convertToNull";
public static final String USER = "root";
public static final String PASSWORD = "root";
public ConnFactory() {
}
public static Connection getConn() {
Connection conn = null;
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/sql?characterEncoding=UTF-8&eroDateTimeBehavior=convertToNull", "root", "root");
return conn;
} catch (SQLException | ClassNotFoundException var5) {
var5.printStackTrace();
return conn;
} finally {
;
}
}
//关闭连接
public static void closeConn(Connection conn) {
try {
conn.close();
} catch (SQLException var2) {
var2.printStackTrace();
}
}
}
MVC三层架构
什么是MVC：Model view Controller 模型、视图、控制器
传统模式
MVC模式
项目架构图
EL（Expression Language）表达式
EL表达式概念及基础语法
表达式是JSP必备的语法元素。EL 表达式语言来自于标准化脚本语言 ECMAScript 和 XPath。EL 表达式简化了 JSP 语言的写法。在 EL 表达式出现之前，开发 Java Web 应用时经常需要将大量的 Java 代码嵌入 JSP 页面中，使页面的可读性变得很差，使用 EL 可以使页面变得很好。
EL 表达式定义了许多运算符，如算术运算符、关系运算符、逻辑运算符等，使用这些运算符，将使得 JSP 页面更加简洁。因此，复杂的操作可以使用 Servlet 或 JavaBean 完成， 而简单的内容则可以使用 EL 提供的运算符。
EL表达式基本语法：${EL 表达式}
EL 表达式的基本语法很简单，它以“${”开头，以“}”结束，中间为合法的表达式。
EL 表达式可以是字符串或是 EL 运算符组成的表达式。例如：
${sessionScope.user.name}
上述 EL 范例的意思是从 session 取得用户的 name。使用 EL 之前，JSP 的代码如下：
<%
User user=(User)session.getAttribute("user");
String name=user.getName();
%>
两者相比较之下可以发现，EL 的语法比传统的 JSP 代码更为方便、简洁。
EL表达式的用途
- 获取数据
- EL执行运算
- 获得常用WEB开放的对象
- 调用Java的函数
[]和. 的区别
EL 提供“.”（点操作）和 [ ] 两种运算符来实现数据存取运算。“.”（点操作）和 [] 是等价的，可以相互替换。
-
一般情况下[ ]用于获取带有下标的（数组、List）等引用类型对象中的数据
-
“.”用于获得某个对象的属性，或者获得某个JavaBean中的属性数据。
例如，下面两者所代表的意思是一样的。
${sessionScope.user.sex}等价于${sesionScope.user["sex"]}但是，需要保证要取得对象的那个属性有相应的 setXxx() 和 getXxx() 方法才行。
有时，“.”和 [] 也可以混合使用，例如：$
提示：注意下面两种情况，“."（点操作）和[]不能互换
-
当要存取的数择名称中包含不是字母或数字的特殊字符时，只能使用 [ ]。例如：
${sessionScope.user.["user-sex"]}不能写成${sessionScope.user.usis-sex} -
当取得的数据为动态值时，只能使用 [ ]。例如：
${sessionScope.user[param]}其中，param 是自定义的变量，其值可以是 user 对象的 name、sex、age 等。
EL用来获取数据
- 获得普通的值；
- 获得数组的数据；
- 获得List集合的数据；
- 获得Map集合的数据；
- 获得JavaBean的属性数据；
EL执行运算
-
执行算数运算：+ - * / %
EL算术运算符 说明 范例 结果 +加 ${15+2}17-减 ${15-2}13*乘 ${15*2}30/或div除 ${15/2}或${15 div 2}7%或mod求余 ${15%2}或${15 mod 2}1EL 的“+”运算符与 java 的“+”运算符不一样，它无法实现两个字符串的连接运算，如果该运算符连接的两个值不能转换为数值型的字符串，则会拋出异常。如果使用该运算符连接两个可以转换为数值型的字符串，EL 会自动地将这两个字符转换为数值型数据，再进行加法运算。
-
执行关系运算：&& || !
EL逻辑运算符 范例(A、B为逻辑型表达式) 结果 &&或and${A && B}或${A and B}true/false` 或or`!或not${!A}或${not A}true/false -
执行逻辑运算:> < >= <= != ==
EL关系运算符 说明 范例 结果 ==或eq等于 ${6==6}或${6 eq 6}<br>${"A"="a"}或${"A" eq "a"}truefalse!=或ne不等于 ${6!=6}或${6 ne 6}<br>${"A"!= "a"}或${"A" ne "a"}falsetrue<或lt小于 ${3<8}或${3 lt 8}<br>${"A"<"a"}或${"A" lt "a"}truetrue>或gt大于 ${3>8}或${3 gt 8}<br>${"A">"a"}或${"A" gt "a"}falsefalse<=或le小于等于 ${3<=8}或${3 le 8}<br>${"A"<="a"}或${"A" le "a"}truetrue>=或ge大于等于 ${3>=8}或${3 ge 8}<br>${"A">="a"}或${"A" ge "a"}falsefalse<h1>EL执行运算</h1> <h3>EL执行算数运算</h3> <% pageContext.setAttribute("n1","10"); pageContext.setAttribute("n2","20"); pageContext.setAttribute("n3","40"); pageContext.setAttribute("n4","60"); %> ${n1+n2+n3 } <h3>EL执行逻辑运算</h3> ${n1 < n2 } ${n1 > n2 } <h3>EL执行关系运算</h3> ${n1<n2 && n3<n4 } ${n1<n2 || n3<n4 } <% Person person = new Person(); pageContext.setAttribute("person",person); %> ${empty person } ${not empty person }
EL获得WEB开发的常用的对象：（EL的内置对象）
EL常用的对象：11个.
${pageScope}${requestScope}${sessionScope}${applicationScope}- ${param } :相当于request.getParameter();
- ${paramValues } :相当于request.getParameterValues();
- ${header } :获得请求头一个key对应一个value
- ${headerValues } :获得请求头一个key对应多个value
- ${initParam } :获得初始化参数
- ${cookie } :获得Cookie的信息
- ${pageContext} :相当于pageContext对象.
JSTL标签库
JSTL的标签库概述
- JSP标准标签库（JSTL）是一个JSP标签集合，它封装了JSP应用的通用核心功能。
- JSTL支持通用的、结构化的任务，比如迭代，条件判断，XML文档操作，国际化标签，SQL标签。 除了这些，它还提供了一个框架来使用集成JSTL的自定义标签。
- 使用任何库，你必须在每个 JSP 文件中的头部包含
<taglib>标签。
例如：<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>就是指在该JSP页面中可以使用JSTL的核心标签。
JSTL标签库的作用
结合EL替换页面中的<% %>
JSTL标签的分类
根据JSTL标签所提供的功能，可以将其分为5个类别。即JSTL的五大标签库:Core(核心库)、I18N(国际化标签库)、SQL标签库、XML标签库、Functions（JSTL函数）
-
核心库（core）: 核心标签，是最常用的 JSTL标签。我们学习的重点；
-
国际化标签(I18N)： 只需要学习两个标签即可；
-
SQL 标签( sql)： 数据库标签库，使用的不多；
-
XML 标签(x): 使用的不多;
-
JSTL 函数(fn): 主要定义对字符串操作的函数库，在EL表达式中运行。
每个核心标签库对应的URI和前缀如下图所示：
标签库名称 标签库的URI 常用前缀 Core（核心库） http://java.sun.com/jsp/jstl/core c I18N（国际化） http://java.sun.com/jsp/jstl/fmt fmt SQL http://java.sun.com/jsp/jstl/sql sql XML http://java.sun.com/jsp/jstl/xml x Functions http://java.sun.com/jsp/jstl/functions fn JSTL的版本: JSTL1.0 JSTL1.1 JSTL1.2
-
JSTL1.0是EL还没有被纳入规范的时候使用标签.
-
JSTL1.1和1.2的版本中 EL已经被纳入到规范中.JSTL可以支持EL表达式了.
Servlet、JSP、JSTL等各种不同版本的对应关系如下：
JSTL标签库的使用
-
下载标签库的dtd文件，并添加至所需项目
下载jstl1.2.jar文件。因为之前的JSTL标签库安装需要下载jstl1.2.jar 和 standard.jar两个jar包，不过JSTL 1.2中已经不需要安装standard.jar包了。
标签库文件下载后，需要在Idea中需要使用该标签库的项目中把该jar包添加到项目中。即需要在项目配置窗口的Moudle配置中的dependencies面板中添加该jar包
注意：需要注意的是有的时候在该项目中设置jstl1.2.jar包所在的文件夹lib指定为该项目的jar包资源的目录也会出现导入不成功的现象。所以需要将该jar包文件添加到Dependencies中来。
-
在需要使用标签库的页面顶端使用taglib指令引入标签库.
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
-
直接在JSP页面中使用标签库
JSTL Core核心标签库
Core 标签库，又被称为核心标签库，该标签库的工作是对于 JSP 页面一般处理的封装。在该标签库中的标签一共有 14 个，被分为了四类，分别是：
- 多用途核心标签：
<c:out>、<c:set>、<c:remove>、<c:catch>。 - 条件控制标签：
<c:if>、<c:choose>、<c:when>、<c:otherwise>。 - 循环控制标签：
<c:forEach>、<c:forTokens>。 - URL 相关标签：
<c:import>、<c:url>、<c:redirect>、<c:param>。
以下是各核心标签的功能：
| 标签 | 描述 |
|---|---|
<c:out> |
用于在JSP中显示数据，就像<%=... %> |
<c:set> |
用于保存数据 |
<c:remove> |
用于删除数据 |
<c:catch> |
用来处理产生错误的异常状况，并且将错误信息储存起来 |
<c:if> |
与我们在一般程序中用的if一样 |
<c:choose> |
本身只当做<c:when>和<c:otherwise>的父标签 |
<c:when> |
<c:choose>的子标签，用来判断条件是否成立 |
<c:otherwise> |
<c:choose>的子标签，接在<c:when>标签后，当<c:when>标签判断为false时被执行 |
<c:import> |
检索一个绝对或相对URL，然后将其内容暴露给页面 |
<c:forEach> |
基础迭代标签，接受多种集合类型 |
<c:forTokens> |
根据指定的分隔符来分隔内容并迭代输出 |
<c:param> |
用来给包含或重定向的页面传递参数 |
<c:redirect> |
重定向至一个新的URL |
<c:url> |
使用可选的查询参数来创造一个URL |
-
用于显示的
<c:out>标签<c:out>标签用来显示一个表达式的结果，与<%= %>作用相似，它们的区别就是<c:out>标签可以直接通过"."操作符来访问属性。举例来说，如果想要访问customer.address.street，只需要这样写：<c:out value="customer.address.street">。
<c:out>标签会自动忽略XML标记字符，所以它们不会被当做标签来处理。又例如：<c:out value="${sessionScope.salary}"/>该语句的作用为输出session域中名字为salary的属性值。功能等同于<%=session.getAttribute("salary")%>
属性 描述 value输出到页面的数据，可以是EL表达式或常量（必须） default当 value为null时显示的数据（可选）escapeXml当设置为 true时会主动替换特殊字符，比如“<,>,&”（可选，默认为true）注意：escapeXml属性默认为true,会主动把Xml标记更换为转义字符：
例如：java后台数据如下：name=刘德华, 在jsp页面使用
<c:out>便签输出：<c:out value="${info.name}"></c:out>页面显示应为：“姓名： 刘德华”但是查看html页面源码却为：“姓名： <span style="color:red">刘德华</span>”
所以应该将
<c:out>的escapeXml属性置为false：<c:out value="${info.name}" escapeXml="false">就可以正常显示了！ -
用于赋值的
<c:set>标签<c:set>标签用于设置变量值和对象属性。<c:set>标签就是<jsp:setProperty>行为标签的孪生兄弟。这个标签之所以很有用呢，是因为它会计算表达式的值，然后使用计算结果来设置 JavaBean 对象或 java.util.Map 对象的值。
例如：<c:set var="salary" scope="session" value="${30000*2}"></c:set>
该语句的作用是在session域中存储一个名字为salary的变量，其值为60000；
<c:set>标签有如下属性属性 描述 是否必要 默认值 value要存储的值 否 主体的内容 target要修改的属性所属的对象 否 无 property要修改的属性 否 无 var存储信息的变量 否 无 scopevar属性的作用域否 Page -
用于删除的
<c:remove>标签<c:remove>标签用于删除存在于 scope 中的变量，该标签有两个属性，var属性表示要被删除的变量名，scope属性表示要删除的变量的作用域；例如：<c:remove var="salary" scope="session"/>表示移除session域中名字为salary的变量。
-
用于判断的
<c:if><c:if>标签判断表达式的值，如果表达式的值为 true 则执行其主体内容。<c:if>有如下属性：属性 描述 是否必要 默认值 test条件 是 无 var用于存储条件结果的变量 否 无 scopevar属性的作用域否 page<c:set var="salary" scope="session" value="${30000*2}"></c:set> <c:if var="result" test="${sessionScope.salary>3000}"></br> 结果为<c:out value="${result}"/></br> 您的工资为：<c:out value="${sessionScope.salary}"/> </c:if> -
<c:choose>, <c:when>, <c:otherwise>标签<c:choose>标签与Java中的switch语句的功能一样，为多分支选择语句。其中的<c:when>标签对应switch语句中的case，而<c:otherwise>对应switch语句中的default。<c:choose>标签没有属性；<c:when>标签只有一个属性是test代表条件；<c:otherwise>标签没有属性。<!--c:choose,c:when,c:otherwise标签的使用--> <c:set var="salary" scope="session" value="${30000*2}"></c:set> 你的工资为：<c:out value="${sessionScope.salary}"/></br> <c:choose> <c:when test="${salary <=1000}"> 太惨了！ </c:when> <c:when test="${salary > 2000 && salary<6000}"> 可怜的薪水，刚刚够活。 </c:when> <c:when test="${salary >= 6000}"> 不错的薪水，生活没有问题。 </c:when> <c:otherwise> 没人要我，什么都没有。 </c:otherwise> </c:choose> -
用于循环的
<c:forEach>标签<c:forEach>为循环控制标签。该标签封装了Java中的for，while，do-while循环。<c:forEach>标签加通非常好，我们经常使用它迭代一个集合中的对象。该标签的属性如下：
属性 描述 是否必要 默认值 items要被循环的信息 否 无 begin开始的元素（0=第一个元素，1=第二个元素） 否 0 end最后一个元素（0=第一个元素，1=第二个元素） 否 Last element step每一次迭代的步长 否 1 var代表当前条目的变量名称 否 无 varStatus代表循环状态的变量名称 否 无 - 使用<c：forEach>标签实现对集合的遍历
- 使用<c:forEach>标签实现普通的for循环
JSTL的函数库(EL的函数库)
JSTL包含一系列标准函数，大部分是通用的字符串处理函数。EL函数库标签导入的taglib指令如下：
<%@taglib uri="http://java.sun.com/jsp/jstl/functions"prefix="fn" %>
| 函数 | 描述 |
|---|---|
fn:contains() |
测试输入的字符串是否包含指定的子串 |
fn:containsIgnoreCase() |
测试输入的字符串是否包含指定的子串，大小写不敏感 |
fn:endsWith() |
测试输入的字符串是否以指定的后缀结尾 |
fn:escapeXml() |
跳过可以作为XML标记的字符 |
fn:indexOf() |
返回指定字符串在输入字符串中出现的位置 |
fn:join() |
将数组中的元素合成一个字符串然后输出 |
fn:length() |
返回字符串长度 |
fn:replace() |
将输入字符串中指定的位置替换为指定的字符串然后返回 |
fn:split() |
将字符串用指定的分隔符分隔后组成一个子字符串数组并返回 |
fn:startsWith() |
测试输入字符串是否以指定的前缀开始 |
fn:substring() |
返回字符串的子集 |
fn:substringAfter() |
返回字符串在指定子串之后的子集 |
fn:substringBefore() |
返回字符串在指定子串之前的子集 |
fn:toLowerCase() |
将字符串中的字符转为小写 |
fn:toUpperCase() |
将字符串中的字符转为大写 |
fn:trim() |
移除首尾的空白符 |
浙公网安备 33010602011771号