JSP
比较Servlet
Servlet的作用：
1. 接受浏览器的请求，获取数据
2. 转发、重定向
3. 负责调用业务层
Servlet缺点：不适合展示数据
jsp是什么
全称： Java Server Pages,java服务器页面。和Servlet一样，是sun公司定义的一种动态网页开发技术。
特点：基于html模版，可以在html模版嵌入java代码和jsp中的标签。
tomcat可以包含的资源：
静态资源：
html:静态页面。
CSS:修饰美化html页面。
JavaScript:动态修改html页面和css样式。
动态资源
Servlet：运行在服务器上的java小程序。适合编写java代码，写网页困难,适合业务处理
Servlet三个用途:1 接受浏览器发送的数据 2 负责调用业务层 3转发重定向
JSP:适合编写动态内容，不适合写java代码，主要用于显示页面。
为什么要用jsp
1 jsp性能好，可以在html页面中动态嵌入元素
2 服务器调用的是已经编译好的JSP文件
3 JSP基于Java Servlet Api,有很多强大企业的支持。
4 JSP可以与处理业务逻辑的Servlet一起使用，该模式被Java Servlet模版引擎所支持。
jsp的优势
1 与纯 Servlet 相比：JSP可以很方便的编写或者修改HTML网页而不用去面对大量的println语句
2 与JavaScript相比：虽然JavaScript可以在客户端动态生成HTML，但是很难与服务器交互，因此不能提供复杂的服务，比如访问数据库和图像处理等等。
3 与静态HTML相比：静态HTML不包含动态信息
jsp语法
JSP页面中可以包含指令，Java语句、变量、方法或表达式、静态内容(html、css、javascript)
jsp语法格式：
指令:
<%@ page language=“java” contentType="text/html; charset=UTF-8"pageEncoding=“UTF-8”%>
脚本：
<% java代码 %>
<% int i=10;%>
脚本表达式：
输出变量： <%=2+3%>等价于输出语句 (注意：不能使用分号来结束表达式)
声明：
<%!
定义方法
%>
静态资源：HTML、CSS、JS
jsp注释
格式： <%-- 网页注释 --%>：安全，省流量
网页注释：
,特点，不安全，耗流量
<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>jsp语法</title>
</head>
<body>
jsp中可以包含
<ul>
<li>指令</li>
<li>脚本：变量 方法</li>
<li>脚本表达式：表达式</li>
<li>静态内容：html css js</li>
</ul>
<%
//脚本块
String name = "张三";
int age = 20;
int num = 100;
//System.out.println(name + " : " + age);
out.println("<br/>");
out.println(name + ":" + age);
out.println("<br/>");
out.println(new Date());
%>
<%--脚本表达式--%>
<br/>
<%=num%>
<%--声明：定义方法--%>
<%!
public String getUpper(String s) {
return s.toUpperCase();
}
%>
<%=getUpper(getUpper("hello"))%>
<%--
静态包含，就是把页面中的代码直接拿过来了
<%@include file="footer.jsp"%>
--%>
<%@include file="footer.jsp"%>
<%--动态包含,不属于同一个页面--%>
<jsp:include page="jsp语法.jsp"></jsp:include>
<jsp:include page="footer.jsp"></jsp:include>
</body>
</html>
通过查看源码，发现所有的jsp页面都变成类, (文件名_jsp.java),类继承HttpJspBase, HttpJsbBase又继承HttpServlet,所有的jsp页面都是Servlet
jsp指令
告诉JSP引擎如何解析jsp文件中的内容
语法： <%@ 指令名称 属性名称1＝“属性值1” 属性名称2＝“属性值2” …%>
示例：<%@ page language=“java” contentType=“text/html; charset=UTF-8” pageEncoding=“UTF-8”%>
page指令
作用：用于定义JSP页面的各种属性
import和java代码的含义一样
<%@ page import=“java.util.Date,java.util.List”%>
或者：
<%@ page import=“java.util.Date”%>
<%@ page import=“java.util.List”%>
session:是否会自动创建session对象，默认值为true;
buffer:JSP中有java.servlet.jsp.JspWriter输出字符流。设置输出数据的缓存大小。默认8kb.
errorPage:如果页面中有错误，跳转到指定的资源 errorPage="/uri" 如果写“/”则代表当前应用的目录 下，绝对路径。 如果不写“/”则代表相对路径
isErrorPage:是否创建throwable对象。默认是false
contentType:等同于response.setContentType(“text/html;charset=utf-8”);服务器发送客户端的内容编码
pageEncoding: Jsp文件本身的编码
isELIgnored: 是否支持EL表达式。 默认是false,支持表达式;是true表示不支持表达式，${1+1};false输出结果2 true按照原样输出
include指令
include指令
静态包含：把其它资源包含到当前页面中 <%@ include file=“header.jsp” %>
动态包含： <jsp:include page=“header.jsp"></jsp:include>
两者的区别：翻译的时间段不同(可在tomcat工作目录下查看)
静态包含：在翻译时就把两个文件进行合并,运行时效率高。
动态包含：不会合并文件，当代码执行到include时，才包含另一个文件的内容
taglib指令
作用：在JSP页面中导入JSTL标签库。JSTL替换jsp中的java代码片段。
<%@ taglib uri="http://java.sun.com/jsp/jstl/core"prefix=“c” %>
jsp的6个动作标签
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
request.setCharacterEncoding("utf-8");
%>
<html>
<head>
<title>jsp6个标签</title>
</head>
<body>
<h1>jsp标签（动作标签）</h1>
<ul>
<li>jsp:include 动态包含</li>
<li>jsp:forward 转发</li>
<li>jsp:param 包含或转发的参数</li>
<li>jsp:useBean 创建java对象</li>
<li>jsp:setProperty 设置java对象属性</li>
<li>jsp:getProperty 获取java对象属性</li>
</ul>
<jsp:include page="footer.jsp">
<jsp:param name="username" value="张三"></jsp:param>
</jsp:include>
<jsp:forward page="sub.jsp?username=张三">
<jsp:param name="age" value="25"></jsp:param>
</jsp:forward>
<jsp:useBean id="user" class="com.qf.domain.User"></jsp:useBean>
<jsp:setProperty name="user" property="username" value="zs"></jsp:setProperty>
<jsp:getProperty name="user" property="username"></jsp:getProperty>
</body>
</html>
内置对象
Servlet中内置对象:request 、response、session、application、out(PrintWriter)
Jsp本质是Servlet，包含九个内置对象
| 对象名 | 类型 | 说明 |
|---|---|---|
| request | javax.servlet.http.HttpServletRequest | |
| response | javax.servlet.http.HttpServletResponse | |
| session | javax.servlet.http.HttpSession | 由session=“true”开关 |
| application | javax.servlet.ServletContext | |
| config | javax.servlet.ServletConfig | |
| exception | java.lang.Throwable | 由isErrorPage=“false”开关 |
| out | javax.servlet.jsp.JspWriter | javax.servlet.jsp.JspWriter |
| pageContext | javax.servlet.jsp.PageContext | |
| page | java.lang.Object当前对象this | 当前servlet实例 |
r r s a c e o p p
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>jsp就大内置对象</title>
</head>
<body>
<h1>jsp九大内置对象</h1>
<ul>
<li>request</li>
<li>response</li>
<li>session</li>
<li>application</li>
<li>config</li>
<li>exception</li>
<li>out</li>
<li>pageContext</li>
<li>page</li>
<li>r r s a c e o p p</li>
</ul>
<h1>out对象</h1>
<h3>jsp中的out和Servlet中的response.getWriter()区别</h3>
<nl>
<li>类型不同，jsp中的out类型为JspWriter，response.getWriter()的类型是PrintWriter</li>
<li>输出位置不同：jsp中的out输出首先会放到缓存中，response.getWriter()直接写入到response中</li>
</nl>
<%--<%
out.println("jsp中的out");
out.flush();
response.getWriter().println("response中的getWriter()");
//如果不加flush，会导致 "response中的getWriter()" 先输出，因为提交给浏览器的是在response中的内容
%>--%>
<h2>pageContext对象</h2>
<ul>
<li>1.获取其他八个内置对象</li>
<li>2.当做容器使用</li>
</ul>
<%
pageContext.setAttribute("page_username", "猪八戒");
String page_username = (String) pageContext.getAttribute("page_username");
out.println(page_username);
//可以操作其他三个
pageContext.setAttribute("request_username", "沙僧", PageContext.REQUEST_SCOPE);
pageContext.setAttribute("session_username", "孙悟空", PageContext.SESSION_SCOPE);
pageContext.setAttribute("application_username", "唐僧", PageContext.APPLICATION_SCOPE);
out.println("11111111111111111");
%>
out.println("22222222222222222222");
<jsp:forward page="sub2.jsp"></jsp:forward>
</body>
</html>
jsp的out和getWriter()方法的区别
1 out是JspWriter类型，getWriter()是PrintWriter类型
2 out输出到缓冲区中，没有写到response中，getWriter()直接写到response中。
3 out一般用在jsp中，getWriter()用在Servlet中
pageContext对象
pageContext作用：
1 代表页面上下文,获取其他八个内置对象
2 作用容器使用
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%
Object request_username = pageContext.getAttribute("request_username", PageContext.REQUEST_SCOPE);
out.println(request_username);
Object session_username = pageContext.getAttribute("session_username", PageContext.SESSION_SCOPE);
out.println(session_username);
Object application_username = pageContext.getAttribute("application_username", PageContext.APPLICATION_SCOPE);
out.println(application_username);
Object request_username1 = pageContext.findAttribute("request_username");
out.println(request_username1);
Object session_username1 = pageContext.findAttribute("session_username");
out.println(session_username1);
Object application_username1 = pageContext.findAttribute("application_username");
out.println(application_username1);
%>
</body>
</html>
域对象
jsp中共包含四个域对象分别是request、session、application、pageContext
request域的使用场景:本次请求之后，数据就不再使用了，根据学号查询学生，根据新闻id查询新闻。
session域的使用场景:同一个会话中共享的数据，使用session，用户登录信息
application（ServletContext）域的使用场景:所有用户共享的数据。整个程序的配置信息
pageContext域的使用场景：当前页面。
其中pageContext可以操作其他三个域对象(request,session,application)的数据
EL表达式
基本语法
EL表达式:Expression Language表达式语言
目的:简化jsp中java代码开发，代替脚本表达式<%=username%>
它不是一种开发语言，是jsp中获取数据的一种规范
格式如： ${EL表达式} 等价于<%=pageContext.findAttribute(name)%>
案例1：获取简单数据，对象中的数据，集合中的数据
【注意】：在获取数据之前，一定要先把数据放到域中
用到的User类
public class User {
private String username;
private String password;
private int age;
private Address address;
public User() {
}
public User(String username, String password, int age) {
this.username = username;
this.password = password;
this.age = age;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
", age=" + age +
'}';
}
}
<%@ page import="com.qf.domain.User" %>
<%@ page import="com.qf.domain.Address" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.HashMap" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>EL表达式的使用</title>
</head>
<body>
<h2>El表达式的作用</h2>
<h3>1.获取简单数据</h3>
<%
pageContext.setAttribute("username", "张三");
request.setAttribute("age", "25");
session.setAttribute("phone", "13838383838");
application.setAttribute("address", "北京昌平沙河");
User user = new User("李四", "123", 25);
Address address = new Address("河南", "周口");
user.setAddress(address);
//一定要把数据放入域中
pageContext.setAttribute("user", user);
%>
<h5>不使用EL表达式：</h5>
<%=pageContext.findAttribute("username")%><br/>
<%=pageContext.findAttribute("age")%><br/>
<%=pageContext.findAttribute("phone")%><br/>
<%=pageContext.findAttribute("address")%><br/>
<h5>使用EL表达式：</h5>
${"username"}<br/>
${username}<br/>
${age}<br/>
${phone}<br/>
${address}<br/>
<h2>2.获取对象属性</h2>
${user}<br/>
${user.username}<br/>
${user.password}<br/>
${user.age}<br/>
${user.address.province}<br/>
${user.address.city}<br/>
<h3>3.使用List和Map集合</h3>
<%
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("华为");
arrayList.add("小米");
arrayList.add("vivo");
arrayList.add("oppo");
ArrayList<User> users = new ArrayList<>();
users.add(new User("zhangsan", "123", 23));
HashMap<String, String> map = new HashMap<>();
map.put("cn", "中国");
map.put("usa", "美国");
map.put("uk", "英国");
map.put("1", "日本");
map.put("2", "韩国");
map.put("3", "伊拉克");
//先把数据放在域中！！！！！
pageContext.setAttribute("list", arrayList);
pageContext.setAttribute("users",users);
pageContext.setAttribute("map", map);
%>
<h5>arraylist集合</h5>
获取集合中的数据，使用list[]时。下标如果不存在，则不执行<br/>
${list[0]}<br/>
${list[1]}<br/>
${list[2]}<br/>
${list[3]}<br/>
${list[4]}<br/>
使用list集合的get(index)方法，下标不能越界<br/>
${list.get(0)}<br/>
${list.get(1)}<br/>
${list.get(2)}<br/>
${list.get(3)}<br/>
<%--${list.get(4)}<br/>--%>
获取对象中的数据<br/>
${users.get(0).username}<br/>
${users.get(0).password}<br/>
${users.get(0).age}<br/>
<h5>map集合</h5>
${map["cn"]}<br/>
${map["usa"]}<br/>
${map["uk"]}<br/>
${map.cn}<br/>
${map.usa}<br/>
${map.uk}<br/>
<%--只能用${map[]}--%>
当map集合中的键是数字的时候，只能用map{[]}<br/>
${map["1"]}<br/>
${map["2"]}<br/>
${map["3"]}<br/>
</body>
</html>
关系运算
<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.List" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>EL表达式执行运算，empty关键字</title>
</head>
<body>
<h2>EL表达式执行运算，empty关键字</h2>
<h4>算数运算</h4>
${10+5}<br/>
${10-5}<br/>
${10*5}<br/>
${10/5}<br/>
<h4>关系运算</h4>
>${10>5}<br/>
<${10<5}<br/>
>=${10>=5}<br/>
<=${10<=5}<br/>
!=${10!=5}<br/>
<%
pageContext.setAttribute("s1", new String("hello"));
pageContext.setAttribute("s2", new String("hello"));
%>
${"abc"=="abc"}<br/>
${s1==s2}<br/>
${s1 eq s2}<br/>
<h4>逻辑运算</h4>
${true && false}<br/>
${true || false}<br/>
${!true}<br/>
${true and false}<br/>
${true or false}<br/>
${not true}<br/>
<h4>empty运算符，判断元素是否为null "" 集合元素0</h4>
<%
pageContext.setAttribute("phone", "");
ArrayList<String> list = new ArrayList<>();
pageContext.setAttribute("list", list);
%>
${empty user}<br/>
${empty phone}<br/>
${empty list}<br/>
<h4>三目运算符</h4>
<%
pageContext.setAttribute("score", 90);
pageContext.setAttribute("gender", 1);
pageContext.setAttribute("user", "zhangsan");
%>
${score>80 ? "优秀" : "还行"}<br/>
${gender==1 ? "男" : "女"}<br/>
${empty user ? true : false}<br/>
</body>
</html>
隐式对象
JSP 表达式语言定义了一组隐式对象，其中许多对象在 JSP servlet和表达式中可用：
**pageContext：**页面上下文，可以获取jsp中其他八个内置对象
pageScope、requestScope、sessionScope、applicationScope表示四个域对象中集合
param 表示request.getParameter(“username”); ${param.username}
paramvalues 表示request.getPrameterValues(“hobby”); ${paramValues.hobby}
header 表示 request.getHeader(“accept”); ${header.accept};
headerValues 表示 request.getHeaderValues(“accept-encoding”); ${headerValues[“accept-encoding”][0]}
cookie 表示 request.getCookies(); ${cookie.JSESSIONID}
initParam 表示 ServletContext(application)初始化参数
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>EL隐式对象11个</title>
</head>
<body>
<h2>EL隐式对象11个</h2>
<ul>
<li>pageContext</li>
<li>pageScope</li>
<li>requestScope</li>
<li>sessionScope</li>
<li>applicationScope</li>
</ul>
${pageContext}<br/>
!!!!!获取项目名称：
${pageContext.request.contextPath}【常用】
<form action="${pageContext.request.contextPath}/userservlet">
</form>
<h4>pageScope、
requestScope、
sessionScope、
applicationScope、
表示集合
</h4>
<%
pageContext.setAttribute("address", "北京");
request.setAttribute("address", "上海");
session.setAttribute("address", "广州");
application.setAttribute("address", "深圳");
%>
${address}<br/>
${pageScope.address}<br/>
${requestScope.address}<br/>
${sessionScope.address}<br/>
${applicationScope.address}<br/>
<h4>param paramValues获取浏览器的参数</h4>
</body>
</html>
JSTL
什么是JSTL
JSTL:全称Java Server Pages Standard Tag Library,JSP标准标签库,代替jsp页面的脚本，实现逻辑控制
JSTL的作用
实现JSP页面中逻辑处理。如判断， 循环等；
下载JSTL库，https://archive.apache.org/dist/tomcat/taglibs/
把jstl.jar、standard.jar放入WEB-INF/lib目录下
如何使用JSTL
必须在JSP页面添加tablib指令库
<% @taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core">
常用标签介绍
通用标签set,out,remove
<!-- 基础标签:声明变量，输出变量，移除变量，变量默认值 -->
<h3>基础标签:声明变量，输出变量，移除变量，变量默认值</h3>
<!--1.声明变量k var：是变量名 value:变量的值(必须是EL表达式)-->
<c:set var="k" value="${1+1}"></c:set>
<!--2.输出变量k value:使用EL表示表示变量-->
移除前输出的内容：<c:out value="${k}"></c:out><br>
<!--3.移除指定变量 -->
<c:remove var="k"/>
移除后输出的内容：<c:out value="${k}"></c:out><br>
<!--4.给指定变量赋默认值 -->
默认值：<c:out value="${m}" default="123456"></c:out>
条件标签if,choose
<c:if>
<!-- 条件标签：if choose -->
<!-- test属性中是条件，但是条件需要使用EL表达式来书写 -->
<h3>条件标签：if</h3>
<c:if test="${8>2 }">
8大于2是成立的
</c:if>
<c:if test="${8<2 }">
8小于2是成立的
</c:if>
<br>
<%-- 如果只是一个基本数据类型直接书写不需要${} --%>
<c:set var="m" value="5"></c:set>
<c:if test="${m>3}">
5大于3是成立的
</c:if>
<c:choose>
<h3>条件标签：choose(等价于java中switch)</h3>
<%-- 测试成绩等级 >90 优秀 >80 良好 >70 中等 >60及格--%>
<c:set var="score" value="80"></c:set>
<c:choose>
<c:when test="${score>=90 }">优秀</c:when>
<c:when test="${score>=80 }">良好</c:when>
<c:when test="${score>=70 }">中等</c:when>
<c:when test="${score>=60 }">及格</c:when>
<c:otherwise>不及格</c:otherwise>
</c:choose>
迭代标签foreach
for基础遍历
<!-- 遍历for:输出1到10 的值 -->
<!--var: 变量，把遍历的每一个值都存储在变量中进行输出
begin：开始 如果是变量使用EL表达式表示
end:结束 如果是变量使用EL表达式表示
step:间隔的长度
for( int i=0;i<10;i++){
System.out.println(i);
}
-->
示例代码：
<c:forEach var="i" begin="1" end="10" step="2">
${i}<br>
</c:forEach>
foreach遍历
<h3>测试list集合遍历获取学生列表</h3>
<table border="1" width="80%" bordercolor="red" cellspacing="0"
align="center">
<tr>
<th>学号</th>
<th>姓名</th>
<th>成绩</th>
<th>班级</th>
<th>是否是第一个</th>
<th>是否是最后一个</th>
<th>计数count</th>
<th>索引index</th>
</tr>
<!-- varStatus:变量状态：遍历出的每一项内容的状态：
isFirst() first
isLast() last
getCount() count 计数 重要的
getIndex() index
-->
<!-- var :遍历出的每一项使用变量先存储
items：集合(使用El表达式)
-->
<c:forEach var="stu" items="${students}" varStatus="vs">
<tr>
<td>${stu.id}</td>
<td>${stu.name}</td>
<td>${stu.score}</td>
<td>${stu.classes}</td>
<td>${vs.first}</td>
<td>${vs.last}</td>
<td>${vs.count}</td>
<td>${vs.index}</td>
</tr>
</c:forEach>
</table>
url标签
<c:url var="" value="">
举例：
<c:url var="loc" value="/stu.jsp">
<c:param name="username" value="张三"></c:param>
</c:url>
<a href="${loc}">学生列表</a>
2935
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
