JSP、EL、JSTL

JSP(Java Server Pages)

什么是JSP

Java Server Pages（Java服务器端的页面）

使用JSP：SP = HTML + Java代码 + JSP自身的东西.
执行JSP的过程:
JSP翻译成Servlet,编译这个Servlet的类,生成class文件，得到执行。本质就是一个servlet(单例模式)。

JSP的脚本

<%!   %>        :翻译成Servlet中的成员内容. 定义变量，方法，类. -- 不建议.
<%    %>        :翻译成Servlet中service方法内部的内容. 定义类,变量
<%=   %>        :翻译成Servlet中service方法中out.print();

JSP的注释

HTML的注释     :<!-- 注释 -->    |HTML的注释：存在JSP源码中,存在于JSP翻译后的Servlet中,存在于生成的HTML中(生成的页面里被注释行任然执行)。
Java代码的注释 :// 单行注释 /*多行注释*/ /** 文档注释 */    |单行注释 存在于JSP的源代码中,翻译成Servlet后 注释也存在.但是当执行完JSP后生成HTML后,注释就消失了。
JSP的注释      :<%-- JSP的注释 --%>    |JSP的注释 ：只会存在于 JSP的源代码中.翻译成Servlet后,JSP的注释就消失了。

JSP的指令

指令的语法:
    <%@ 指令名称 属性名称=”属性值” 属性名称=”属性值” ...%>

JSP中有三个指令:page指令, include指令, taglib指令。

JSP中page指令:<%@ page %> -- 设置JSP的.
* language      :JSP脚本中使用的语言.现在只能写java.
* contentType   :设置浏览器打开这个JSP的时候采用的默认的字符集的编码.
* pageEncoding  :设置文件保存到本地硬盘,以及生成Servlet后,Servlet保存到硬盘上的编码.
* import        :在JSP中引入类对象.但是import可以出现多次.
    <%@page import="java.util.ArrayList"%>
    <%@page import="java.util.List"%>
* extends       :设置JSP翻译成Servlet后继承的类,默认值:org.apache.jasper.runtime.HttpJspBase,这个值要想修改,这个类必须是HttpServlet的子类
* autoFlush     :设置JSP的缓存自动刷出.true:自动刷出.
* buffer        :设置JSP的缓冲区的大小,默认8kb.
* session       :设置在JSP中是否可以直接使用session对象.默认值是true.
* isELIgnored   :设置在JSP中是否忽略EL表达式.默认值是false不忽略.
* errorPage     :设置错误友好页面的提示.
* isErrorPage   :通过这个设置显示JSP的错误信息.
    * 设置全局的错误友好页面：
        * 在web.xml中设置:
  <error-page>
    <error-code>404</error-code>
    <location>/404.jsp</location>
  </error-page>
  <error-page>
    <error-code>500</error-code>
    <location>/500.jsp</location>
  </error-page>

JSP中的include指令:指示JSP包含其他的页面.
<%@ include file="logo.jsp" %>
<%@ include file="menu.jsp" %>
<h1>BODY部分</h1>
<%@ include file="footer.jsp" %>

JSP中的taglib指令:指示JSP引入标签库.
<%@ taglib uri="标签的URI的路径" prefix="标签的别名" %>

JSP的内置对象

JSP的内置对象:在JSP中可以直接使用的对象。

JSP中有9大内置对象:
  名称                            真实对象                           常用方法
* request               HttpServletRequest              getParameter(),setAttribute(String name,Object value);
* response            HttpServletResponse           setHeader(String name,String value);getOutputStream();getWriter();
* session               HttpSession                         setAttribute();getAttribute();
* application          ServletContext                     setAttribute();getAttribute();
* page                   Object                                  toString();wait();
* pageContext       PageContext                        setAttribute();getAttribute();
* config                 ServletConfig                       getServletName();getServletContext();
* out                     JspWriter                              write(),print();
* exception           Throwable                            getMessage(),getCause();            设置isErrorPage=”true”

page内置对象     :真实对象是Object,就是JSP翻译成Servlet后的类的引用.

out内置对象        :out和response.getWriter是不是同一个对象?区别是什么?
* 不是out真实对象JspWriter ,response获得Writer是PrintWriter.( response.getWriter会比JspWriter先执行)

pageContext内置对象:
* 获得其他的8个内置对象   :编写通用性代码或者框架的时候.
* 向JSP的四个域中存取数据 :
    JSP的四个域范围:
        名称                     作用范围            存储数据的对象     存储数据的真实对象
    * PageScope             :当前页面中有效.       pageContext     PageContext
    * RequestScope          :一次请求范围.        request         HttpServletRequest
    * SessionScope          :一次会话范围.        session         HttpSession
    * ApplicationScope      :应用范围               application     ServletContext

JSP的动作标签

标签的作用:简化代码.

<jsp:forward />         :用于页面的转发.
* <jsp:forward page="/demo1-jsp/demo3-object/demo3.jsp"></jsp:forward>

<jsp:include />         :用于页面的包含.（动态包含）

<jsp:param />           :用于带有路径的标签下,传递参数.

<jsp:useBean />         :用于在JSP中使用JavaBean.

<jsp:setProperty />     :用于在JSP中向JavaBean设置属性的.

<jsp:getProperty />     :用于在JSP中获得JavaBean的属性.

静态包含和动态包含的区别?(<%@ include%>和<jsp:include>)

主要从以下5方面进行分析：
1.语法：
 　　静态包含：<%@ include file=""%>
 　　动态包含：<jsp:include page="">
2.静态包含时，包含页面和被包含页面中的html.head,body等标签总共只有出现一次，否则会报错；而动态包含不会。
3.静态包含不会检查所包含文件中的变化；但是动态包含，可以检查所含文件中的变化，并且可以带参数。
4.静态包含是先将文件中内容导入被包含的文件中，再一起编译，最后再展现给用户（先包含再编译）。
5.动态包含可以自动区分被包含文件是静态的还是动态的，如果是静态，则与静态包含一样处理；若是动态页面，则可以先进行动态的处理，再将结果包含进来。（先编译再包含）(由于先编译所以不能分开两部分定义和引用数据)

EL表达式

EL的概述

 什么是EL:
EL（Expression Language） 是为了使JSP写起来更加简单。表达式语言的灵感来自于 ECMAScript 和 XPath 表达式语言，它提供了在 JSP 中简化表达式的方法，让Jsp的代码更加简化。

EL的作用:
* 简化JSP的代码,而且减少<%%>

使用EL表达式:
* 语法:${ EL表达式 }

EL的功能:
* 获取数据:(JSP的四个域)只在这四个域中
* 执行运算:
* 操作WEB开发的常用的对象:
* 调用Java中方法:（很少用）

EL获取数据

<h3>存取是普通的单值数据</h3>
<%
    //pageContext.setAttribute("name", "pValue");
    //request.setAttribute("name", "rValue");
    //session.setAttribute("name", "sValue");
    application.setAttribute("name", "aValue");
%>
<%=pageContext.getAttribute("name") %> <!-- 如果没找到 返回null -->
<%=request.getAttribute("name") %>
<%=session.getAttribute("name") %>
<%=application.getAttribute("name") %>
<hr/>
${ pageScope.name } <!-- 返回的是"" -->
${ requestScope.name }
${ sessionScope.name }
${ applicationScope.name }
<hr/>
${ name } <!-- 类似findAttribute("name") 先从page域中查找,没找到去request域中查询,没有找到去session域中找，没有找到就去application域中找 -->
<h3>获取数组的数据</h3>
<%
    String[] arrs = {"李旭华","李冠希","杨凤","杨如花"};
    pageContext.setAttribute("arrs", arrs);
%>
${ arrs[0] }
${ arrs[1] }
${ arrs[2] }
${ arrs[3] }
<h3>获取List集合的数据</h3>
<%
    List<String> list = new ArrayList<String>();
    list.add("李芙蓉");
    list.add("杨芙蓉");
    list.add("王凤");
    pageContext.setAttribute("list", list);
%>
${ list[0] }
${ list[1] }
${ list[2] }
<h3>获取Map集合的数据</h3>
<%
    Map<String,String> map = new HashMap<String,String>();
    map.put("aaa","李旭华");
    map.put("bbb","杨久君");
    map.put("ccc","李芮");
    map.put("ddd","李凤");
    pageContext.setAttribute("map", map);
%>
${ map.aaa }
${ map.bbb }
${ map.ccc }
${ map.ddd }
<h3>获取对象的数据</h3>
<%
    User user = new User(1,"aaa","123");
    pageContext.setAttribute("user", user);
%>
${ user.id }
${ user.username }
${ user.password }
当对象里的成员变量又有嵌套对象的时候,user.detailuser.name
<h3>获取对象的集合的数据</h3>
<%
    User user1 = new User(1,"aaa","123");
    User user2 = new User(2,"bbb","123");
    User user3 = new User(3,"ccc","123");
    
    List<User> userList = new ArrayList<User>();
    userList.add(user1);
    userList.add(user2);
    userList.add(user3);
    
    pageContext.setAttribute("userList", userList);
%>

${ userList[0].id } - ${ userList[0].username } - ${ userList[0].password }<br/>
${ userList[1].id } - ${ userList[1].username } - ${ userList[1].password }<br/>
${ userList[2].id } - ${ userList[2].username } - ${ userList[2].password }<br/>
***** .和[]的区别.  
    * []用于有下标的数据(数组,list集合) .用于有属性的数据(map,对象)
    * 如果属性名中包含有特殊的字符.必须使用[]

EL执行运算

<h1>EL的功能二:执行运算</h1>
<h3>EL执行算数运算</h3>
<%
    pageContext.setAttribute("n1", "10");
    pageContext.setAttribute("n2", "20");
    pageContext.setAttribute("n3", "30");
    pageContext.setAttribute("n4", "40");
%>
${ n1 + n2 + n3 }
<h3>EL执行逻辑运算</h3>
${ n1 < n2 } - ${ n1 lt n2 } <!-- less than --><br/>
${ n1 > n2 } - ${ n1 gt n2 } <!-- great than --><br/>
${ n1 <= n2 } - ${ n1 le n2 } <!-- less equal --><br/>
${ n1 >= n2 } - ${ n1 ge n2 } <!-- great equal --><br/>
${ n1 == n2 } - ${ n1 eq n2 } <!-- equal --><br/>

<h3>EL执行关系运算</h3>
${ n1<n2 && n3 < n4 } - ${ n1<n2 and n3 < n4 }<br/>
${ n1<n2 || n3 < n4 } - ${ n1<n2 or n3 < n4 }<br/>
${ !(n1 < n2) } - ${ not(n1<n2) }

<h3>EL执行三元运算</h3>
${ n1 < n2 ? "正确":"错误" }

<h3>empty运算</h3>
${ user == null } - ${ empty user }
${ user != null } - ${ not empty user }

EL操作WEB开发的常用对象11个

<h1>EL功能三:操作WEB开发常用的对象</h1>
<!-- 
    pageScope,requestScope,sessionScope,applicationScope - 获取JSP中域中的数据
    param,paramValues     - 接收参数.
    header,headerValues - 获取请求头信息
    initParam            - 获取全局初始化参数
    cookie                - WEB开发中cookie
    pageContext            - WEB开发中的pageContext.
PageScope和pageContext的区别:pageScope是专门用来获取page域中的数据;pageContext可以获取request等其他八个域对象.
 -->
<h3>接收请求的参数</h3>
<%= request.getParameter("id") %>
<%= request.getParameter("name") %>
<%= Arrays.toString(request.getParameterValues("hobby")) %>
<hr/>
${ param.id }
${ param.name }
${ paramValues.hobby[0] }
${ paramValues.hobby[1] }
<h3>获取请求头</h3>
<%= request.getHeader("User-Agent") %>
<hr/>
${ header["User-Agent"] }
<h3>获取全局初始化参数</h3>
${ initParam.username }
<h3>获取Cookie中的值</h3>
${ cookie.history.value }    如果没有值返回的是””,而不是null
<h3>获取PageContext中的对象</h3>
IP地址：${ pageContext.request.remoteAddr }
工程路径:${ pageContext.request.contextPath }

JSTL

JSTL的概述

什么是JSTL:
JSTL（JavaServer Pages Standard Tag Library，JSP标准标签库)是一个不断完善的开放源代码的JSP标签库，是由apache的jakarta小组来维护的。JSTL只能运行在支持JSP1.2和Servlet2.3规范的容器上，如tomcat 4.x。在JSP 2.0中也是作为标准支持的。
JSTL 1.0 发布于 2002 年 6 月，由四个定制标记库（core、format、xml 和 sql）和一对通用标记库验证器（ScriptFreeTLV 和 PermittedTaglibsTLV）组成。core 标记库提供了定制操作，通过限制了作用域的变量管理数据，以及执行页面内容的迭代和条件操作。它还提供了用来生成和操作 URL 的标记。顾名思义，format 标记库定义了用来格式化数据（尤其是数字和日期）的操作。它还支持使用本地化资源束进行 JSP 页面的国际化。xml 库包含一些标记，这些标记用来操作通过 XML 表示的数据，而 sql 库定义了用来查询关系数据库的操作。
如果要使用JSTL，则必须将jstl.jar和 standard.jar文件放到classpath中，如果你还需要使用XML processing及Database access (SQL)标签，还要将相关JAR文件放到classpath中，这些JAR文件全部存在于下载回来的zip文件中。

JSTL的作用:
* JSTL和EL结合 替换页面中<%%>

JSTL版本:
* JSTL1.0        :不支持EL表达式.
* JSTL1.1 和 1.2 :支持EL表达式.

JSTL的标签库:包含了五类标签.
* core(核心标签),fmt(国际化标签),xml(XML标签),sql(SQL标签),fn(JSTL提供EL函数库)

使用JSTL：
* 引入JSTL的相关的jar包.
* 在页面中引入标签库.<%@ taglib uri=”” prefix=””%>

JSTL的核心标签的用法

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<c:set var="n1" value="10" scope="page"></c:set>
<c:set var="n2" value="20" scope="page"></c:set>
<c:if test="${ n1 < n2 }" var="flag" scope="page">
    n1 小于 n2
</c:if>
<c:if test="${ n1 >= n2 }">
    n1 大于等于 n2
</c:if>

<c:if test="${ flag }">
    n1 小于 n2
</c:if>

<h1>JSTL的常用标签:forEach</h1>
<%
    String[] arrs = {"李旭华","李冠希","董阳阳"};
    pageContext.setAttribute("arrs", arrs);
%>
<c:forEach var="i" items="${ arrs }">
    ${ i }
</c:forEach>

<h3>遍历List集合</h3>
<%
    List<String> list = new ArrayList<String>();
    list.add("李旭华");
    list.add("李冠希");
    list.add("董阳阳");
    pageContext.setAttribute("list", list);
%>
<c:forEach var="i" items="${ list }">
    ${ i }
</c:forEach>

<h3>遍历Map集合</h3>
<%
    Map<String,String> map = new HashMap<String,String>();
    map.put("aaa","李旭华");
    map.put("bbb","叽里咕噜");
    map.put("ccc","咿咿呀呀");
    pageContext.setAttribute("map", map);
%>
<c:forEach var="entry" items="${ map }">
    ${ entry.key }-${ entry.value }
</c:forEach>

<h3>遍历从1到10</h3>
<c:forEach var="i" begin="1" end="10" step="2">
    ${ i }
</c:forEach>

<h3>遍历从100到300</h3>
<c:forEach var="i" begin="100" end="300" step="5" varStatus="status">
    <c:if test="${ status.count % 3 == 0 }">
        <font color="red">${ i }</font>
    </c:if>
    <c:if test="${ status.count % 3 != 0 }">
        ${ i }
    </c:if>
</c:forEach>

JSTL的提供EL的函数库

<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="c" %>

<h1>JSTL提供的EL的函数库</h1>
${ fn:contains("Hello World","Hello") }
${ fn:length("HelloWorld") }
${ fn:toLowerCase("ABCDE") }
<c:forEach var="i" items='${ fn:split("a-b-c-d","-") }'>
    ${ i }
</c:forEach>

创建数据库：
CREATE TABLE `product` (
  `pid` varchar(32) NOT NULL,
  `pname` varchar(50) DEFAULT NULL,
  `market_price` double DEFAULT NULL,
  `shop_price` double DEFAULT NULL,
  `pimage` varchar(200) DEFAULT NULL,
  `pdate` date DEFAULT NULL,
  `is_hot` int(11) DEFAULT NULL,
  `pdesc` varchar(255) DEFAULT NULL,
  `pflag` int(11) DEFAULT NULL,
  `cid` varchar(32) DEFAULT NULL,
  PRIMARY KEY (`pid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

页面显示:
    <c:forEach var="p" items="${list }">
    <tr>
        <td>${ p.pid }</td>
        <td>${ p.pname }</td>
        <td>${ p.shop_price }</td>
        <td>
            <c:if test="${ p.is_hot == 1 }">
                是
            </c:if>
            <c:if test="${ p.is_hot != 1 }">
                否
            </c:if>
        </td>
        <td>${ p.pdesc }</td>
    </tr>   
    </c:forEach>

JSP的开发模式

动态网页开发模式的发展

 

JSP + Servlet + JavaBean 称为MVC的设计模式.
MVC:
M:Model:模型层
V:View:视图层
C:Controller:控制层

 

MVC和EE开发三层结构的关系 

velocity 和 jsp

velocity有自己的标签：#if()...#else(#else if)...#end、#set()、#foreach()...#end，页面中数据的显示可以使用"$"或者"$!",如"$!userName"。

jsp
1.编译器指示(page指令) <%@ 编译器指示 %> ，就是导入包 page 和标签库 taglib。
<%@ page language="java" import="java.util.*" pageEncoding="GBK"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%> 引入了JSTL标签库才能使用<c:forEach>、<c:if>这些标签。

2.声明 <%! 声明 %>，通常里面定义一些java的变量和方法。

3.表达式 <%= 表达式 %> ，显示输出，等同于EL表达式。 EL的语法:${ EL exprission } ${ bean.name } 或 ${ bean['name'] }。EL 主要用来显示数据的。

4.程序代码段/小型指令 <% 程序代码片段 %> ，就是在写普通的java代码。

Freemarker 和 jsp

。。。