jsp(1)笔记

最新推荐文章于 2022-05-05 16:40:55 发布

lv_yishi

最新推荐文章于 2022-05-05 16:40:55 发布

阅读量253

点赞数

分类专栏： web后台http&ampservlet&jsp

本文链接：https://blog.csdn.net/lv_yishi/article/details/78887233

版权

web后台http&ampservlet&jsp 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

4.1 Jsp引入
Servlet的作用：用java语言开发动态资源的技术！！！
Jsp的作用：用java语言（+html语言）开发动态资源的技术！！！
Jsp就是servlet！！！
4.2 Jsp的特点
1）jsp的运行必须交给tomcat服务器！！！！
tomcat的work目录： tomcat服务器存放jsp运行时的临时文件
2）jsp页面既可以写html代码，也可以写java代码。
（html页面不能写java代码。而jsp页面可以写java代码）
4.4 Jsp的执行过程
问题：访问http://localhost:8080/day12/01.hello.jsp 如何显示效果？

1）访问到01.hello.jsp页面，tomcat扫描到jsp文件，在%tomcat%/work把jsp文件翻译成java源文件
(01.hello.jsp -> _01_hello_jsp.java) （翻译）
2）tomcat服务器把java源文件编译成class字节码文件（编译）
（_01_hello_jsp.java -> _01_hello_jsp.class）
3）tomcat服务器构造_01_hello_jsp类对象
4）tomcat服务器调用_01_hello_jsp类里面方法，返回内容显示到浏览器。
第一次访问jsp：走（1）（2）（3）（4）

第n次访问jsp：走（4）

注意：
1）jsp文件修改了或jsp的临时文件被删除了，要重新走翻译（1）和编译（2）的过程
问题：为什么Jsp就是servlet！！！
jsp翻译的java文件：
public final class _01_hello_jsp extends org.apache.jasper.runtime.HttpJspBase(tomact里面的一个包)
implements org.apache.jasper.runtime.JspSourceDependent {

HttpJspBase类：
public abstract class org.apache.jasper.runtime.HttpJspBase extends javax.servlet.http.HttpServlet implements javax.servlet.jsp.HttpJspPage {
（HttpJspBase继承HttpServlet）
结论： Jsp就是一个servlet程序！！！
servlet的技术可以用在jsp程序中
jsp的技术并不是全部适用于servlet程序！
Servlet的生命周期：
1）构造方法（第1次访问）
2）init方法（第1次访问）
3）service方法
4）destroy方法
Jsp的生命周期
1）翻译： jsp->java文件
2）编译： java文件->class文件（servlet程序）
3）构造方法（第1次访问）
4）init方法（第1次访问）：_jspInit()
5）service方法：_jspService()
6）destroy方法：_jspDestroy()

5 Jsp语法
5.1 Jsp模板
jsp页面中的html代码就是jsp的模板
5.2 Jsp表达式
语法：<%=变量或表达式%>
作用：向浏览器输出变量的值或表达式计算的结果
注意：
1）表达式的原理就是翻译成out.print(“变量” );通过该方法向浏览器写出内容
2）表达式后面不需要带分号结束。
5.3 Jsp的脚本
语法：<%java代码 %>
作用：执行java代码
注意：
1）原理把脚本中java代码原封不动拷贝到_jspService方法中执行。
5.4 Jsp的声明
语法：<%! 变量或方法 %>
作用：声明jsp的变量或方法
注意:
1）变量翻译成成员变量，方法翻译成成员方法。
（脚本中不能写入方法，因为脚本中的内容添加到方法里面，再写方法只会形成方法嵌套方法，但是方法不能嵌套方法）
2）jsp声明中不能重复定义翻译好的一些方法，比如声明里面编译中里面已经存在的public void _jspInit()
5.5 Jsp的注释
语法： <%!-- jsp注释 --%>
注意;
1)html的注释会被翻译和执行。而jsp的注释不能被翻译和执行。
(html注释：)

6 Jsp的三大指令
6.1 include指令
作用：在当前页面用于包含其他页面
语法： <%@include file="common/header.jsp"%> (ctrl按住鼠标键能够点击进去就是可以)
注意：
1）原理是把被包含的页面（header.jsp）的内容翻译到包含页面(index.jsp)中,合并成翻译成一个java源文件，再编译运行！！，这种包含叫静态包含（源码包含）
2）如果使用静态包含，被包含页面中不需要出现全局的html标签了！！！（如html、head、body）
6.2 page指令
作用：告诉tomcat服务器如何翻译jsp文件
<%@ page
language="java" --告诉服务器使用什么动态语言来翻译jsp文件
import="java.util.*" --告诉服务器java文件使用什么包
导入包，多个包之间用逗号分割
pageEncoding="utf-8" --告诉服务器使用什么编码翻译jsp文件（成java文件）
contentType="text/html; charset=utf-8" 服务器发送浏览器的数据类型和内容编码
注意：在开发工具中，以后只需要设置pageEncoding即可解决中文乱码问题
errorPage="error.jsp"
isErrorPage="false"
buffer="8kb"
session="true"
isELIgnored="false"
%>
重要属性:3个
contentType:设置响应流的编码,及通知浏览器用什么编码打开.设置文件的mimetype
pageEncoding:设置页面的编码
import:导入所需要的包
contentType和pageEncoding联系:
若两者都出现的时候,各自使用各自的编码
若只出现一者,两个都使用出现的这个编码
若两者都不出现,使用服务器默认的编码 tomcat7使用的iso-8859-1
了解属性:
language:当前jsp页面里面可以嵌套的语言
buffer:设置jsp页面的流的缓冲区的大小
autoFlush:是否自动刷新
extends:声明当前jsp的页面继承于那个类.必须继承的是httpservlet 及其子类
session:设置jsp页面是否可以使用session内置对象
isELIgnored:是否忽略el表达式
errorPage:当前jsp页面出现异常的时候要跳转到的jsp页面
isErrorPage:当前jsp页面是否是一个错误页面
若值为true,可以使用jsp页面的一个内置对象 exception

异常错误相关的：
errorPage: 指定当前jsp页面的错误处理页面。
isErorrPage: 指定当前页面是否为错误处理页面。false，不是错误处理页面，则不能使用exception内置对象；true，是错误处理页面，可以使用exception内置对象。
errorPage:
当前的页面出现问题后会跳转的另一个页面里面耐心等待

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>page指令</title>
  </head>
  
  <body>
    <%
     String name=null;
     name.charAt(1);
     %>
     
  </body>
</html>

跳转到一个等待的页面：error.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"
%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    <title>My JSP 'error.jsp' starting page</title>
  </head>
  
  <body>
   系统发生一点小的错误，请耐心等待
  </body>
</html>

isErorrPage: 在error.jsp里面使用
isErrorPage="true"----->exception.getMessage() isErrorPage为false就不能使用里面的内置对象exception.getMessage()
当前页面index,jsp发生错误后跳转到error.jsp里面显示错误的原因：
前提是指定错误显示页面在error.jsp里面
index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8" errorPage="common/error.jsp"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>page指令</title>
  </head>
  
  <body>
    <%
     String name=null;
     name.charAt(1);
     %>
     
  </body>
</html>

error.jsp:

<%@ page language="java" import="java.util.*"
 pageEncoding="UTF-8"
 isErrorPage="true"
%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    <title>My JSP 'error.jsp' starting page</title>
  </head>
  
  <body>
   系统发生一点小的错误，请耐心等待
   错误的原因：<%= exception.getMessage() %>
  </body>
</html>

但是每个网页都要写把自己错误的信息配置到error.jsp里面太过麻烦，现在使用一个全局变量：
在web.xml里面配置全局变量：

 <!-- 全局错误处理页面配置 -->
  <error-page>     ******服务器错误
  	<error-code>500</error-code>
  	<location>/common/500.jsp</location>
  </error-page>
  <error-page>       *****客户端错误
  	<error-code>404</error-code>
  	<location>/common/404.html</location>
  </error-page>

相论优先级：在index.jsp里面errorPage的优先级高于全局变量
index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>page指令</title>
  </head>
  
  <body>
    <%
     String name=null;
     name.charAt(1);
     %>
     
  </body>
</html>

500.jsp:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8" isErrorPage="true"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>500处理页面</title>
  </head>
  
  <body>
   500错误！系统正在抢修中
   <%= exception.getMessage() %>
  </body>
</html>

400.html: （资源访问不到也是一种）

<!DOCTYPE html>
<html>
  <head>
    <title>404处理页面</title>
	
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="this is my page">
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
    
    <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->

  </head>
  
  <body>
   亲，你需要访问的页面已经被移除，你是不是想访问首页。
  </body>
</html>

session: 是否开启session功能。false，不能用session内置对象；true，可以使用session内置对象。
buffer: jsp页面的缓存区大小。
isELIgnore：是否忽略EL表达式。

Jsp的内置对象（重点）

什么是内置对象？
在jsp开发中，会频繁使用到一些对象。例如HttpSession,ServletContext,ServletContext,HttpServletRequet。如果我们每次要使用这些对象都去创建这些对象就显示非常麻烦。所以Sun公司设计Jsp时，在jsp页面加载完毕之后就会自动帮开发者创建好这些对象，而开发者只需要直接使用这些对象调用方法即可！，这些创建好的对象就叫内置对象！！！！

9大内置对象
内置对象名类型
request HttpServletRequest
response HttpServletResponse
config ServletConfig
application ServletContext
session HttpSession
exception Throwable
page Object(this)
out JspWriter
pageContext PageContext

Out对象
out对象类型，JspWriter类，相当于带缓存的PrintWriter
PrintWriter：
wrier(内容)：直接向浏览器写出内容。
JspWriter
writer(内容): 向jsp缓冲区写出内容
当满足以下条件之一，缓冲区内容写出：
1）缓冲区满了
2）刷新缓存区
3）关闭缓存区
4）执行完毕jsp页面

<%
  out.write("abc");
  response.getWriter().write("123");
%>
输出：123abc   abc进入缓冲区，执行完jsp页面再输出

<%
  out.write("abc");
  //刷新缓存
  out.flush();
  response.getWriter().write("123");
%>
输出：abc123

关闭缓存：（设置缓存区大小为0）
01.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8" buffer="0kb"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>My JSP '01.jsp' starting page</title>
  </head>
  
  <body>
    <%
  out.write("abc");
  //刷新缓存
  //out.flush();
  response.getWriter().write("123");
%>
  </body>
</html>

缓存区满的情况下：

<%@ page language="java" import="java.util.*" pageEncoding="utf-8" buffer="1kb"%><%
		for(int i=1;i<=1024;i++){
    		out.write("a");
    	}
    	//查看缓存区大小
    	System.out.println("当前缓存区大小："+out.getBufferSize());
    	//查看缓存区剩余大小
    	System.out.println("缓存区剩余大小："+out.getRemaining());
    	//刷新缓存
    	//out.flush();
    	response.getWriter().write("123");
     %>
  </body>
</html>

先输出1024个a再输出123

如果i<=1023 缓冲区没有满就先输出123再输出1023个a

pageContext对象
pageContext对象的类型是PageContext，叫jsp的上下文对象
pageContext对象是JSP技术中最重要的一个对象，它代表当前JSP页面的运行环境，这个对象不仅封装了对其它8大隐式对象的引用，它自身还是一个域对象，可以用来保存数据。并且，这个对象还封装了web开发中经常涉及到的一些常用操作，例如包含和跳转其它资源、检索其它域对象中的属性等。

1）可以获取其他八个内置对象
getException方法返回exception隐式对象
getPage方法返回page隐式对象
getRequest方法返回request隐式对象
getResponse方法返回response隐式对象
getServletConfig方法返回config隐式对象
getServletContext方法返回application隐式对象
getSession方法返回session隐式对象
getOut方法返回out隐式对象

本身是一个域对象
ServletContext context域
HttpServletRequet request域
HttpSession session域 --Servlet学习的
PageContext page域 --jsp学习的
Servlet有三个域对象，jsp里面有四个域对象
作用：保存数据和获取数据，用于共享数据

#保存数据
1）默认情况下，保存到page域
pageContext.setAttribute("name");
2）可以向四个域对象保存数据
pageContext.setAttribute("name",域范围常量)
#获取数据
1）默认情况下，从page域获取
pageContext.getAttribute("name")
2）可以从四个域中获取数据
pageContext.getAttribute("name",域范围常量)

<%
     //保存数据。默认情况下，保存在page域中
      	pageContext.setAttribute("message","page's message");
      	pageContext.setAttribute("message","request's messsage",PageContext.REQUEST_SCOPE);//保存到request域中
     //request.setAttribute("message","request's message"); 等价于上面的代码
%>
 <%
       	//获取数据
	//pageContext的page域范围只在这个页面所以就在这个页面里获取数据   
       	String message = (String)pageContext.getAttribute("message");
       	out.write(message);
	  
%>

域范围常量:
PageContext.PAGE_SCOPE
PageContext.REQUEST_SCOPE
PageContext..SESSION_SCOPE
PageContext.APPLICATION_SCOPE

<%
   //保存数据。默认情况下，保存在page域中
   pageContext.setAttribute("message","page's message");
   pageContext.setAttribute("message","request's messsage",PageContext.REQUEST_SCOPE);//保存到request域中
   //request.setAttribute("message","request's message"); 等价于上面的代码
   pageContext.setAttribute("message","session's messsage",PageContext.SESSION_SCOPE);//保存到sessio域中
   pageContext.setAttribute("message","application's messsage",PageContext.APPLICATION_SCOPE);//保存到context域中
 %>

<%--从request域中取出数据 --%>
<%--
    原则： 
1）在哪个域中保存数据，就必须从哪个域取出数据！！！
 --%>
<%=pageContext.getAttribute("message",PageContext.PAGE_SCOPE) %>
<%=pageContext.getAttribute("message",PageContext.REQUEST_SCOPE) %>
<%=pageContext.getAttribute("message",PageContext.SESSION_SCOPE) %>
<%=pageContext.getAttribute("message",PageContext.APPLICATION_SCOPE) %>

自动在四个域中搜索数据
pageContext.findAttribute("name");
顺序： page域 -> request域 -> session域- > context域（application域）
<%=pageContext.findAttribute("message") %>

3 Jsp中的四个域对象
四个域对象：
pageContext page域
request request域
session session域
application context域

1）域对象作用：
保存数据和获取数据，用于数据共享。

2）域对象方法：
setAttribute("name",Object) 保存数据
getAttribute("name") 获取数据
removeAttribute("name") 清除数据

3）域对象作用范围：
page域：只能在当前jsp页面中使用（当前页面）
request域：只能在同一个请求中使用（转发）
session域：只能在同一个会话（session对象）中使用（私有的）
context域：只能在同一个web应用中使用。（全局的）
5 EL表达式：

5.1 EL作用：
jsp的核心语法： jsp表达式 <%=%>和 jsp脚本<% %>。
以后开发jsp的原则：尽量在jsp页面中少写甚至不写java代码。
使用EL表达式替换掉jsp表达式
EL表达式作用：向浏览器输出域对象中的变量值或表达式计算的结果！！！
语法： ${变量或表达式}

5.2 EL语法
1）输出基本数据类型变量
1.1 从四个域获取
${name}
1.2 指定域获取
${pageScope.name}
域范围： pageScoep / requestScope / sessionScope / applicationScope

2）输出对象的属性值
Student
3）输出集合对象
List 和 Map
4）EL表达式计算

（1）从域中获取：
   一般的访问方式：
      <%String name = "rose";%>
      <%=name%>
   使用EL获取方式：
      <%
       String name = "rose";
       //放入到域中：默认是放到page域中
       pageContext.setAttribute("name", name);
     %>
     EL表达式：${name}

（2）输出对象的属性值：

<%@ page language="java" import="java.util.*,gz.itcast.b_student.*" pageEncoding="UTF-8"%>    ********导包
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>EL显示对象的属性</title>
  </head>
  
  <body>
    <%--EL输出对象的属性 --%>
    <%
    	//保存数据
    	Student student = new Student("eirc",20);
    	//将数据放到域中
    	pageContext.setAttribute("student", student);  ******第一个student带表着下面的student的调用的引用，第二个代表着上面创建的对象
     %>
    ${student.name}-${student.age}
  </body>
</html>

package gz.itcast.b_student;
public class Student {
	private String name;
	private int age;
	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 Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}	
}

注意：
${student.name}等价于 (.相对于调用getXX()方法)
<%((Student)pageContext.findAttribute("student")).getName()%>
在Student里面name和age都是私有的变量，所以不能够直接的调用，调用的只是里面的getXX()方法,所以$(student.name)里面的name就是
public String getName() getName的Name小写，和变量无关

（3）输出集合对象：List

<% 
   //List
   List<Student>  list = new ArrayList<Student>();
   list.add(new Student("rose",18));
   list.add(new Student("jack",28));
   list.add(new Student("lucy",38));
   //放入域中
   pageContext.setAttribute("list",list);
%>
${list }

输出三个list对象：
[gz.itcast.b_student.Student@22e1469c,
gz.itcast.b_student.Student@73e2bda7,
gz.itcast.b_student.Student@2b115a61]
现在拿出student对象的内容：

 ${list[0].name } - ${list[0].age }<br/>
 ${list[1].name } - ${list[1].age }<br/>
 ${list[2].name } - ${list[2].age }
<%--

<%--
list[0]等价于       (中括号相对于调用get(参数)方法)
             ((List)pageContext.findAttribute("list")).get(0)
 --%>

（3-1）输出集合对象：Map

<%//Map
     	Map<String,Student> map = new HashMap<String,Student>();
     	map.put("100",new Student("mark",20));
     	map.put("101",new Student("maxwell",30));
     	map.put("102",new Student("narci",40));
     	//放入域中
     	pageContext.setAttribute("map",map);
%>
${map}

输出三个对象：
{102=gz.itcast.b_student.Student@6d3cba41,
101=gz.itcast.b_student.Student@2de8396e,
100=gz.itcast.b_student.Student@69127c4d}
输出对象里面的值：

<%--使用EL获取Map对象 --%>
${map['100'].name } -  ${map['100'].age }<br/>
${map['101'].name } -  ${map['101'].age }<br/>
${map['102'].name } -  ${map['102'].age }<br/>

（4）EL表达式计算：
表达式和一般的表达式没有区别：
1)empty既可以判断空又可以判断null

<%
   //String name = "eric";
   //String name = null;
   String name = "";
   pageContext.setAttribute("name",name);
%>

另一种判空写法： ${empty name }

6.2 Jsp标签分类

1）内置标签（动作标签）：不需要在jsp页面导入标签
2）jstl标签：需要在jsp页面中导入标签
3）自定义标签：开发者自行定义，需要在jsp页面导入标签

转发标签： <jsp:forward />
参数标签： <jsp:pararm/>
包含标签： <jsp:include/>
原理：包含与被包含的页面先各自翻译成java源文件，然后再运行时合并在一起。
（先翻译再合并），动态包含

静态包含 vs 动态包含的区别？

1）语法不同
静态包含语法： <%@inclue file="被包含的页面"%>
动态包含语法：　<jsp:include page="被包含的页面">

2）参数传递不同
静态包含不能向被包含页面传递参数
动态包含可以向被包含页面传递参数

3）原理不同
静态包含：先合并再翻译
动态包含：先翻译再合并

(1)转发功能：
[1-1普通的转发]
09.action.jsp:
<%request.getRequestDispatcher("/09.action2.jsp?name=eric").forward(request, response);%>
09.action2.jsp:
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
  
    <title>动作标签09.action2.jsp</title>
  </head>
  
  <body>
    <%= request.getParameter("name")%><br>
    <%=request.getParameter("password") %>
  </body>
</html>
输出：eric null

[1-2] <jsp:forward />:
    <jsp:forward page="/09.action2.jsp">
        <jsp:param value="jacky" name="name"/>
        <jsp:param value="123456" name="password"/>
    </jsp:forward>
输出：jacky
123456

（2）包含：
[2-1]普通的包含
09.action.jsp:
 <%@include file="common/header.jsp" %>
header.jsp：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>  
    <title>My JSP 'header.jsp' starting page</title>

  </head>
  
  <body>
    通用的头部页面的内容<br/>
    参数： <%=request.getParameter("name") %>
  </body>
</html>
输出：
通用的头部页面的内容
参数： null

[2-2]<jsp:include/>并传递参数：
 <jsp:include page="/common/header.jsp">
   <jsp:param value="lucy" name="name"/>
 </jsp:include>
输出：
通用的头部页面的内容
参数： lucy

6.4 JSTL标签
JSTL (全名：java standard tag libarary - java标准标签库 )

核心标签库（c标签库）天天用
国际化标签（fmt标签库）
EL函数库（fn函数库）
xml标签库（x标签库）
sql标签库（sql标签库）
6.5 使用JSTL标签步骤
1）导入jstl支持的jar包（标签背后隐藏的java代码）
注意：使用javaee5.0的项目自动导入jstl支持jar包
2）使用taglib指令导入标签库
<%@taglib uri="tld文件的uri名称" prefix="简写" %>
3）在jsp中使用标签

核心标签库的重点标签：
保存数据：
<c:set></c:set>
获取数据：
<c:out value=""></c:out>
单条件判断
<c:if test=""></c:if>
多条件判断
<c:choose></c:choose>
<c:when test=""></c:when>
<c:otherwise></c:otherwise>
循环数据
<c:forEach></c:forEach>
<c:forTokens items="" delims=""></c:forTokens>
重定向
<c:redirect></c:redirect>

<%@ page language="java" import="java.util.*,gz.itcast.b_entity.*" pageEncoding="utf-8"%>
<%--导入标签库 --%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head> 
    <title>核心标签库</title>  
  </head>
  
  <body>
    <%--使用标签 --%>
    <%--set标签 :保存数据(保存到域中)默认保存到page域 --%>
    <c:set var="name" value="rose" scope="request"></c:set>

	<%--等同：pageContext.setAttribute("name","rose");%--> 

    <% 
    	String msg = null;
    	pageContext.setAttribute("msg",msg);
     %>
    
    ${msg }
    <br/>
    <%--out标签： 获取数据（从域中） 
    default： 当value值为null时，使用默认值
    escapeXml: 是否对value值进行转义，false，不转义，true，转义（默认）
    --%>
    <c:out value="${msg}" default="<h3>标题3</h3>" escapeXml="true"></c:out>
			default:里面没有转义就当做标签处理，转义了就当做文本处理。
    <hr/>
    
    <%--if标签 ：单条件判断 没有else--%>
    <c:if test="${!empty msg}">
    	条件成立
    </c:if>
    
    <hr/>
    <%--choose标签+when标签+otherwirse标签: 多条件判断 --%>
    <c:set var="score" value="56"></c:set>
    
    <c:choose>
    	<c:when test="${score>=90 && score<=100}">
    		优秀
    	</c:when>
    	<c:when test="${score>=80 && score<90}">
    		良好
    	</c:when>
    	<c:when test="${score>=70 && score<80}">
    		一般
    	</c:when>
    	<c:when test="${score>=60 && score<70}">
    		及格
    	</c:when>
    	<c:otherwise>
    		不及格
    	</c:otherwise>
    </c:choose>
    
    <%-- forEach标签：循环 --%>
    <%
    	//List
     	List<Student>  list = new ArrayList<Student>();
     	list.add(new Student("rose",18));
     	list.add(new Student("jack",28));
     	list.add(new Student("lucy",38));
     	//放入域中
     	pageContext.setAttribute("list",list);
     	
     	//Map
     	Map<String,Student> map = new HashMap<String,Student>();
     	map.put("100",new Student("mark",20));
     	map.put("101",new Student("maxwell",30));
     	map.put("102",new Student("narci",40));
     	//放入域中
     	pageContext.setAttribute("map",map);
     %>
     <hr/>
     <%--
      begin="" : 从哪个元素开始遍历，从0开始.默认从0开始
      end="":     到哪个元素结束。默认到最后一个元素
      step="" ： 步长    (每次加几)  ，默认1
      items=""： 需要遍历的数据（集合） 
      var=""： 每个元素的名称 
      varStatus=""： 当前正在遍历元素的状态对象。（count属性：当前位置，从1开始）
      
     --%>
	<%-- <c:forEach begin="0" end="2" step="2" items="${list}" var="student" varStatus="varSta">   考虑选择奇偶性--%>
    <c:forEach items="${list}" var="student" varStatus="varSta">
    	序号：${varSta.count} - 姓名：${student.name } - 年龄：${student.age}<br/>
    </c:forEach>
    
    <hr/>
    
    <c:forEach items="${map}" var="entry">
    	${entry.key } - 姓名： ${entry.value.name } - 年龄：${entry.value.age }<br/>
    </c:forEach>
    <hr/>
    <%-- forToken标签： 循环特殊字符串 --%>
    <%
    	String str = "java-php- net-平面";
    	pageContext.setAttribute("str",str);
     %>
    
    <c:forTokens items="${str}" delims="-" var="s">
    	${s }<br/>
    </c:forTokens>
    
    <%--redrict:重定向 --%>
    <c:redirect url="http://www.baidu.com"></c:redirect>
    
  </body>
</html>

lv_yishi

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
jsp(1)笔记

4.1 Jsp引入Servlet的作用：用java语言开发动态资源的技术！！！Jsp的作用：用java语言（+html语言）开发动态资源的技术！！！ Jsp就是servlet！！！4.2 Jsp的特点1）jsp的运行必须交给tomcat服务器！！！！tomcat的work目录： tomcat服务器存放jsp运行时的临时文件2）jsp页面既可以写html代码，也可以写j
复制链接

扫一扫

专栏目录