JSP——Java Server Pages

最新推荐文章于 2021-06-18 00:31:17 发布

weixin_34174105

最新推荐文章于 2021-06-18 00:31:17 发布

阅读量89

点赞数

原文链接：https://my.oschina.net/ProgramerLife/blog/2051047

版权

2019独角兽企业重金招聘Python工程师标准>>>

1. 简介

1. Jsp技术：Jsp是一种 html代码+ Java代码 + Jsp页面代码的技术，而且其不用像Servlet哪样需要配置访问路径。

2. Jsp执行原理：第一次访问服务器web项目中的jsp页面时，会首先把jsp页面翻译成为一个标准Servlet，也就是 .java 的文件，然后将这个java文件编译生成字节码文件，然后再执行。

3. Jsp中Java代码的编写：

通过 <%! %>来定义成员变量或方法，但是成员变量会因为多线程而出现错误情况，所以不常用该脚本元素定义成员变量。
通过<%= %>来将Java代码中的常量或者变量输出到html页面，不能加分号 ";"
通过<% %>定义局部变量，或者编写代码，但是不能定义方法。

<%@ 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 'test1.jsp' starting page</title>
    
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
	<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	-->
  </head>
  
  <body>
  <%--定义局部变量a,b,c --%>
  	<% int a=10;%>
  	<% int b=10;%>
  	<% int c=a+b;%>
  	<%= "c=" %>
  	<% out.println(c); %>
  	<br>
  <%--输出3行3列的表格 --%>
    <table cellspacing="0" cellpadding="0" border="1">
	<% for(int i=1;i<=3;i++){%>
    	<tr>
		<% for(int x=1;x<=3;x++){%>
    		<td>	
    		<%=i+","+x %>
   			</td>
    	<%}%>
    	</tr>
    <%}%>
	</table>
	<%--构造LinkedList实例对象并添加元素，然后输出 --%>
	<% LinkedList<Integer> list=new LinkedList<Integer>(); 
	   for(int i=0;i<=10;i++){
	       list.add(i);
	   }
	 %>
	 <%=list.toString() %></br>
	<%--输出当前时间信息 --%>
	<% Date now=new Date();%>
	<%="当前时间：北京时间" %>
	<%=now.toLocaleString() %>
  </body>
</html>

2. Jsp指令元素

2.1 page指令

1. page指令用于设置Jsp文件属性，形式为<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>，其中可以使用一个属性，也可以使用多个属性，但是只有import属性可以多次出现，具体常用属性如下：

language:将当前页面翻译成java语言，不用设置为默认
session:设置是否开启session，即是否能够直接使用session对象，默认为true,<%@ page session="true" %>
import:用于导包，可以出现多次。<%@ page import="java.util.*" %>
extends:当前jsp文件会被翻译成一个java文件，所以可以指定继承的类,要写全限定名。
buffer:设置输出的缓冲区大小，默认8kb，<%@ page buffer="8k"%>
autoFlush:缓冲区满了是否刷新，如果满了不刷新则抛出异常，默认为true，<%@ page autoFlush="true"%>
isErrorPage:当前jsp文件是否为其他页面的errorPage属性的目标页面，默认为false；可以在web.xml文件中配置全局发生的错误对应的处理页面，即请求服务器时发生的对应的错误码，都会跳转至该页面，需要添加配置代码

  <error-page>
    <error-code>404</error-code>
    <location>/jsp/error.jsp</location>
  </error-page>

errorPage:当此页面发生错误时，指定一个isErrorPage属性值为true的jsp页面作为跳转页面来反映错误
isELIgnored:是否忽略EL表达式，默认为false
contentType:设置浏览器打开jsp中html页面的编码格式
pageEncoding:设置当前页面的编码格式，用于jsp文件翻译成.java代码时

2.2 include指令

1. 用于页面包含，可以将某些公共页面片段提取出来，用的时候在加入进行组合，指令形式如<%@ include file="" %>，具体常用属性如下

file属性:所包含文件的地址，是服务器端地址，属于静态包含（即在翻译成.java代码文件之前，先将所有代码按照引入的位置和顺序进行添加，然后再翻译称为一个完整的.java文件，再编译称为字节码文件）

2.3 taglib指令

3. Jsp内置对象

1. 在 tomcat服务器目录路径+\work\Catalina\localhost\+项目名+\org\apache\jsp\+jsp文件目录下的jsp文件对应的翻译过来的java代码文件，打开这个java代码文件，我们可以发现一系列的jsp内置对象。内置对象可以在java代码块内直接使用，而exception对象只有isErrorPage属性为true的页面内才能使用

比如路径为D:\apache-tomcat-8.5.24\work\Catalina\localhost\Servlet\org\apache\jsp\jsp\test1_jsp.java,打开后代码为

package org.apache.jsp.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import java.util.*;

public final class test1_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports {

//删除部分代码，下面的就是jsp中的内置对象
    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;
    } 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);
    }
  }
}

2. 内置对象用法：

request:表示HttpServletRequest对象
response:表示HttpServletResponse对象
session:表示HttpSession对象
application:表示ServletContext对象，也就是整个web应用
out:表示JspWriter对象，和response.getWriter()一样，都用于向返回客户端的html页面输出数据。但JspWriter与response.getWriter()得到的字符输出流对象肯定不是同一个，JspWriter会将输出的数据先保存在自己的缓冲区中，然后再将缓冲区中的数据发送到response.getWriter()中，再向页面写出，因为只有response.getWriter()才能向页面输出数据。

pageContext:表示PageContext对象，该对象可以获取另外的8个对象，且此对象也是jsp中独有的一个域对象，但其中的数据只能在本页面生效，并且可以向其他的域对象中存取值。方法如下
- pageContext.setAttribute(String name,Object value, int scope)：将一个属性值，存储到request、session、application三个域对象内，比如 pageContext.setAttribute("name", "vn", pageContext.APPLICATION_SCOPE)，就是将属性存储在application域内，其他两个域对象范围用 REQUEST_SCOPE，SESSION_SCOPE 表示，对于PAGE_SCOPE就表示pageContext域对象。
- pageContext.getAttribute(name, scope)：指定在某个域对象范围内获取属性。比如pageContext.getAttribute("name", pageContext.REQUEST_SCOPE)
- pageContext.setAttribute(String name,Object value)：向pageContext域对象内存储属性值。
- pageContext.getAttribute(name)：从pageContext域对象内获取属性值。
- pageContext.findAttribute(name)：先从pageContext对象自身内部查找属性，然后依次从request、session、application三个域对象中获取属性，找到之后就会返回属性值，不会继续查找。
page:Object（代表当前Servlet对象的Object类型引用）
config:表示ServletConfig对象
exception:表示Throwable对象

JSP中的4个域对象访问范围（由小到大）：
pageContext：仅当前jsp页面范围，通过该域可得到其他所有域中的值，默认从自身存储的数据中开始查找，然后范围有小到大访问其他域
request：请求范围，在请求生效的范围中均可访问其中的值
session：整个会话范围
application：整个web应用范围

4. Jsp常用标签

1. <jsp:forward page="url"></jsp:forward>：转发标签，实现转发功能。page属性指转发到哪个页面上去，转发的路径的写法和Servlet中一样，写服务器绝对路径（不包含包含项目名称）

2. <jsp:param value="" name=""/>：转发时传递参数，需要被包括在jsp:forward 标签之内。name 指参数的名称， value代表参数的值

3. <jsp:include page=""></jsp:include>：动态包含（和静态包含结果是一样的，原理是不一样的），page属性指被包含的页面的路径，动态包含会在源码的文件下，对每个jsp都生成了.java和.class的文件。

4. 在Jsp中封装数据所使用的标签：通过这些标签可以实例化一个类的对象，通常可以将请求中携带的参数，通过其属性名也就是name与类的属性名称进行对比，相同名称的将会进行自动注入。假如现在有一个请求被一个jsp页面接受到，请求里包括了两个请求参数，分别是

name="vn"&password="123"，而有一个用于封装数据的标准JavaBean规范的类如下

package servlet.JSP;

/**
 * @ClassName:User
 * @Description:一个符合JavaBean规范的数据封装工具类，其必须满足三大规范
 * 必须有无参构造器
 * 实例变量必须是私有的，对外不可见
 * 对于每个实例变量都必须有一个public修饰的get与set方法，来实现外界对实例变量的读写
 * @author: 
 * @date:2018年9月11日
 */
public class User {
	private String name;
	private String password;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
}

jsp页面可以使用 <jsp:useBean id="" class="" scope="" beanName="" type=""></jsp:useBean> 标签用来自动生成一个指定的类的对象：
- class属性指定实例化的类的全限定名
- scope属性指定这个对象存储在那个域对象的范围内（域对象范围从小到大依次是page —>request —>session —>application）
- id属性可以视为该User对象的引用，通过这个id，又可以使用 <jsp:setProperty property="" name="" param="" value=""/> 标签与<jsp:getProperty property="" name="u"/> 标签来对该对象的属性进行读写，如下

<jsp:useBean id="u" class="servlet.JSP.User" scope="request"></jsp:useBean>
<jsp:getProperty property="name" name="u"/>
<jsp:setProperty property="name" name="u" param="name" value="uzi"/>

<jsp:getProperty property="" name=""/>：
- name 属性的值指向已创建的对象的id，也就是<jsp:useBean>中id属性
- property 属性指定的值用来指定获取所对应对象中的属性的值。
<jsp:setProperty property="" name="" param="" value=""/> ：
- param属性的值指的是在数据封装类中的对应类的属性的set方法中的参数名
- value就是参数的值，通过这个标签就可以设置对象的属性值，另外，value的属性值也可以是<jsp:useBean>标签中id属性指定的值。
- param与value属性可以忽略不写，当请求中带有请求参数时，会通过参数的属性名与类的属性名称进行对比，相同名称的将会把请求参数中的值自动注入进入指定对象，param与value属性用于手动设置对象属性值。
- property值指定需要注入值的对象的属性，当对象的属性过多时，可以写 * 来表示所有属性的值都需要注入。
- name属性值指向已创建的对象的id，也就是<jsp:useBean>中id属性。

5. java内省技术

1. 内省技术的简单使用

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.MethodDescriptor;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.junit.Test;

/**
 * @ClassName:TestIntrospector
 * @Description:Java内省技术，其底层通过反射技术实现。主要的类为Introspector
 * @author: 
 * @date:2018年9月11日
 */
public class TestIntrospector {
	@Test
	public void testIntrospector() throws IntrospectionException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
		User user=new User();
		//测试内省,获取User这个JavaBean类的信息
		BeanInfo info=Introspector.getBeanInfo(user.getClass());
		//获取这个JavaBean类的所有属性信息
		PropertyDescriptor[] pros= info.getPropertyDescriptors();
		for(PropertyDescriptor p:pros){
			if(!"class".equals(p.getName())){
				System.out.println(p.getName());//获取属性名
				Method method1=p.getWriteMethod();//获取该属性的写入方法，也就是set方法
				method1.invoke(user, "vn");//调用每个属性的set方法
			}
		}
		for(PropertyDescriptor p:pros){
			if(!"class".equals(p.getName())){
				System.out.println(p.getName());//获取属性名
				Method method2=p.getReadMethod();//获取该属性的读取方法，也就是get方法
				System.out.println(method2.invoke(user, null));//调用每个属性的读取方法，并输出
			}
		}
		//获取这个JavaBean类的所有方法信息
		MethodDescriptor[] meths=info.getMethodDescriptors();
		for(MethodDescriptor m:meths){
			System.out.println(m.getName());//获取方法名
			Method method=m.getMethod();//转换为反射中的Method类
		}
		
	}
}

2. 通过内省技术在一个Servlet类里实现数据封装：

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class UserServlet
 */
@WebServlet("/UserServlet")
public class UserServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
 
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		Map<String, String[]> parameter = request.getParameterMap();
		User user=new User();
		try {
			populate(user,parameter);
		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException
				| IntrospectionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	private static void populate(Object o,Map<String, String[]> map) throws IntrospectionException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
		//获取数据封装类型信息
		BeanInfo info=Introspector.getBeanInfo(o.getClass());
		//获取类中所有属性的信息
		PropertyDescriptor[] pds=info.getPropertyDescriptors();
		for(PropertyDescriptor p:pds){
			if(!"class".equals(p) && map.containsKey(p.getName())){
				Method m=p.getWriteMethod();
				m.invoke(o, map.get(p.getName())[0]);
			}
		}
	}

3. 使用BeanUtils工具类来封装数据到一个对象中：

public class TestBeanUtils {
	@Test
	/**
	 * @Title:testBeanUtils
	 * @Description:BeanUtils的简单使用,首先需要导入commons-logging和commons-beanutils两个jar包
	 * @author: 
	 * @date:
	 * @param:
	 * @return:void
	 * @throws InvocationTargetException 
	 * @throws IllegalAccessException 
	 * @throws:
	 */
	public void testBeanUtils() throws IllegalAccessException, InvocationTargetException{
		User user=new User();
		//模拟从请求中取得的参数Map
		Map<String, String[]> map=new HashMap<String, String[]>(10);
		String[] s1={"vn"};
		String[] s2={"12345"};
		map.put("name", s1);
		map.put("password", s2);
		//使用工具类封装数据,将数据封装到user对象中
		BeanUtils.populate(user, map);
		
		//查看是否封装成功
		System.out.println(user.getName());
		System.out.println(user.getPassword());
	}
}

4. 编写代码，实现将字符串转换为自己想要的数据类型（以将字符串转换为日期类型数据为例）：

首先需要编写一个转换器类，并实现接口Converter，然后实现Converter接口中的convert方法来完成数据转换逻辑。
然后将这个转换器类注册到BeanUtils工具类中，就可以实现数据封装到对象中时，可以将日期格式的字符串数据转换为日期数据类型。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.commons.beanutils.Converter;
public class StringToDateConverter implements Converter{
	/**
	 * @Title:convert
	 * @Description:将字符串转为日期类型
	 * @param c
	 * @param o 需要被转换的数据
	 * @return
	 * @see org.apache.commons.beanutils.Converter#convert(java.lang.Class, java.lang.Object)
	 */
	@Override
	public Object convert(Class c, Object o) {
		String str=(String)o;
		SimpleDateFormat f=new SimpleDateFormat("yyyy-MM-dd");//字符串格式指定
		Date date=null;
		try {
			date=f.parse(str);
			
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return date;
	}
	
}

//编写一个包含Date类型属性的JavaBean
import java.util.Date;
public class Birthday{
	Date birth;
	public Date getBirth() {
		return birth;
	}
	public void setBirth(Date birth) {
		this.birth = birth;
	}
}

//测试数据封装
public class TestBeanUtils {
	@Test
	public void testMyConverter() throws IllegalAccessException, InvocationTargetException{
		//将自己的转换器注册到ConvertUtils中，第一个参数是自己编写的转换器的实例对象，第二个参数是数据
		//转换的目标类型，当把数据封装到某一个对象的时候，如果对象中有Date类的属性，就会使用该转换器
		ConvertUtils.register(new StringToDateConverter(), Date.class);
		Birthday day=new Birthday();
		Map<String, String[]> map=new HashMap<String, String[]>();
		String[] s=new String[]{"1997-10-24"};
		map.put("birth", s);
		BeanUtils.populate(day, map);
		System.out.println(day.getBirth().toString());
	}
	
}

6. Jsp中的EL表达式

Jsp内置的一种表达式，EL表达式可以获取数据、执行运算、获取web开发常用对象、调用Java方法四个用途。

语法形式为： ${ 表达式内容 }

1. 获取域对象中的属性值：从四个域中取属性值，默认从范围最小的域中开始取值，即顺序为：pageContext->request->session->application

<%@ 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 'demo5.jsp' starting page</title>
  </head>
 <% pageContext.setAttribute("username", "1");
   request.setAttribute("username", "2");
   session.setAttribute("username", "3");
   application.setAttribute("username", "4");
 %>
  <body>
	<h5>
	${username}
	<!-- 从四个域中取属性值，默认从范围最小的域中开始取值，即顺序为：pageContext->request->session->application -->
	</h5>
	<div>存取数组：<br/>
	<%
		int[] arr={1,2,3,4};
		pageContext.setAttribute("arr", arr);
	%>
		<p>${ arr[0] }</p>
	</div>
	<div>存取集合：<br/>
	<%
		List<String> list=new ArrayList<String>();
		list.add("1");
		list.add("2");
		list.add("3");
		pageContext.setAttribute("list", list);
	%>
		<p>${ list[0] }</p>
	</div>
	<div>存取Map集合：<br/>
	<%
		Map<String,String> map=new HashMap<String,String>(); 
		map.put("1", "1");
		map.put("2", "2");
		map.put("3", "3");
		map.put("a.a", "4");
		map.put("a", "a");
		pageContext.setAttribute("map", map);
	%>
		<p>${ map.a }</p>
		<p>${ map["1"] }</p>
		<p>${ map["a.a"] }</p><!-- 特殊字符使用中括号 -->
	</div>
  </body>
</html>

2. EL表达式常用的部分内部隐藏对象:

pageContext：表示jsp页面中的pageContext对象
pageScope:代表page域中用于保存属性的Map对象
requestScope：代表request域中用于保存属性的Map对象
sessionScope：代表session域中用于保存属性的Map对象
applicationScope：代表application域中用于保存属性的Map对象
param:表示一个保存了所有请求参数的Map对象，这个Map对象就保存了所有请求参数的键值对，通过参数名称返回的是一个String
paramValues:表示一个保存了所有请求参数的Map对象，通过参数名返回的是一个String[]，适用于一个参数名对应一个参数值数组的请求
header：表示一个保存了所有请求头键值对的Map对象，通过请求头名称返回的是一个String
headerValues：表示一个保存了所有请求头键值对的Map对象，通过请求头名称返回的是一个String[]
cookie：表示请求中的所有cookie键值对，如 ${ cookie.last} 表示获取cookie中名为last的cookie对象；${ cookie.last.key}表示获取last这个cookie的名称，也就是 last ；${ cookie.last.value}表示获取名为last的cookie对象的值。

3. EL表达式支持运算：加减乘除，关系运算，逻辑运算：

<div>EL表达式支持运算：加减乘除，关系运算，逻辑运算<br/>
	<%pageContext.setAttribute("n1", 10);
  	  request.setAttribute("n2", 20);
   	  session.setAttribute("n3", 30);
      application.setAttribute("n4", 40); 
    %>
	<p>
	<!-- ${n1 }就相当于 ${ pageContext.n1 } -->
	${n1 }+${n2 }=${n1+n2 }
	${n1==n2 }或${n1 eq n2 }
	${true && true }
	</p>
</div>

7. JSTL标签

7.1 JSTL标签的使用

1. 引入JSTL核心标签库：<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<%--JSTL标签库：jstl，即jsp内置标签，其运行在服务器中并与html标签区分，用于简化标签，去掉<%%> --%>

<%--引入JSTL标签库： --%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    <title>My JSP 'demo6.jsp' starting page</title>
  </head>
  <%pageContext.setAttribute("n", 10); %>
  <body>
   <div>
   	<c:if test="${n==10 }">
   		<p>test=true</p>
   	</c:if>
   	<c:choose></c:choose>
   </div>
  </body>
</html>

2. 使用方法：<c:标签名属性>输出内容（可以是HTML标签）</c:标签名>

3. 常用标签库：

核心标签库（core，也就是<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>）
另一个是 fn.tld，是EL函数库。

7.2 JSTL核心标签库

1. <c:out value="" default="" escapeXml="true"></c:out>：用于查找jsp四个域对象中的属性，并输出值

value属性写EL表达式或者任意字符串，对于普通字符串不会做任何处理
如果value中的字符串写的是HTML标签的字符串，比如 "<div></div> "，则可以通过escapeXml属性来设置是否将该HTML标签字符串输出到页面时转换为HTML标签，默认为true表示不执行，false表示执行转换，会直接输出到页面中
default属性表示当value中的属性值无效时，或未设置value属性时，则默认输出这个字符串。支持EL表达式，属性类型为String

2. <c:set property="" scope="" value="" target="" var=""></c:set>：用于设置jsp四个域对象中存储属性，也可以向JavaBean或Map对象中设置属性

var表示属性名，不支持EL表达式，属性类型为String
value表示属性值，支持EL表达式，属性类型为Object
scope表示存储在那个域对象中，包括page、request、session、application四个，不支持EL表达式，属性类型为String
target用于指定要设置属性值的JavaBean对象，支持EL表达式，属性类型为Object
property用于指定要设置的属性，支持EL表达式，属性类型为String

3. <c:remove var="" scope=""/>：用于删除域对象中的属性

var表示属性名，不支持EL表达式，属性类型为String
scope表示指定删除的属性在那个域对象中，包括page、request、session、application四个，不支持EL表达式，属性类型为String

4. <c:catch var=""></c:catch>：用于捕获发生的异常，var属性表示如果发生了异常，就把异常信息保存到var指定的变量中。

5. <c:if test="" scope="" var=""></c:if>：用于判断，标签间可以写当判断为true时，则输出JSTL标签间的内容，可以是HTML标签

test属性必须出现，其值应该为true或false，支持EL表达式
var指定一个变量存储test属性中计算后的值，也就是说只会为true或false
scope表示var指定变量存储在哪个域变量中。

6. <c:choose><c:when test=""></c:when><c:otherwise></c:otherwise></c:choose>：也用于判断，相当于if-else语句

7. <c:forEach items="" begin="" end="" step="" var="" varStatus=""></c:forEach>：用于遍历数组或迭代数据集合

items表示要被遍历的数组对象或者是集合（Map与List），支持EL表达式
begin表示从第几个元素开始遍历，最小值为1
end表示遍历到第几个元素结束
step指定一个变量来表示下一次遍历会遍历到第 begin+=step 个元素
var指定一个变量表示当前被遍历到的元素
varStatus表示循环遍历的过程中产生的信息，比如
- index下标值
- count计数器
- 判断是否有第一个
- 判断是否有最后一个

8. <c:url context="" scope="" value="" var=""></c:url>：与提交的地址相关，比如超链接等

value指定要构造的url值，支持EL表达式，String类型的值
var指定将url值保存到jsp域对象中属性名称
scope指定将url值保存到那个jsp域对象中
context指定项目路径，url值是请求路径，context+value就是一个完整的路径，可以不指定，默认当前的web项目路径

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<%--JSTL标签库：jstl，即jsp内置标签，其运行在服务器中并与html标签区分，用于简化标签，去掉<%%> --%>

<%--引入JSTL标签库： --%>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    <title>My JSP 'demo6.jsp' starting page</title>
  </head>
  <%pageContext.setAttribute("n", 10); %>
  <body>
  <!-- JSTL核心标签库中的out标签,用于查找jsp四个域对象中的属性，并输出值 -->
  <div>
  	<c:out value="${n}" default="查找失败"></c:out>
  	<c:out value="<a href='http://www.baidu.com'>百度</a>" escapeXml="false"></c:out>
  </div>
  
  <!-- set标签,用于向jsp四个域对象中存储更改属性,也可以向JavaBean或Map对象中设置属性 -->
  <div>
  	<c:set property="" scope="session" value="vn" target="" var="name"></c:set>
  	<c:out value="${name }"></c:out>
  </div>
  
  <!-- remove标签,用于向jsp四个域对象中存储属性 -->
  <div>
  	<c:remove var="n" scope=""/>
  </div>
  
  <!-- catch标签,用于捕获发生的异常 -->
  <div>
  	<c:catch var="e">
  		<%!int a=10/0; %>
  	</c:catch>
  	<c:out value="${e.message }"></c:out>
  </div>
  
  <!-- if标签 ,用于判断条件-->
   <div>
   	<c:if test="${n==10 }" scope="session" var="flag">
   		<p>test=true</p>
   	</c:if>
   	<c:out value="${i }"></c:out>
   </div>
   
   <!-- choose标签 ,用于判断条件-->
  <c:choose>
  	<c:when test="${i }">
  	条件为true
  	</c:when>
  	<c:when test="${i == null }">
  	条件为空
  	</c:when>
  	<c:otherwise>
  	条件为false
  	</c:otherwise>
  </c:choose>
  
  <!-- forEach标签，用于遍历数组或迭代数据集合 -->
  <div>
  	<%!
  		int[] arr={1,23,4,5,12};
  		List<Integer> list=new ArrayList<Integer>();
  		list.add(2);
  		list.add(4);
  		list.add(52);
  		list.add(22);
  		request.setAttribute("list", list);
  	 %>
  	 <!-- 相当于增强for循环 ，即 for(int i:list){} -->
  	<c:forEach items="${list }" var="i">
  		<c:out value="${i }"></c:out>
  	</c:forEach>
  	<!-- 普通for循环 ，即 for(int i=0;i<10;i++){} -->
  	<c:forEach items="${list }" var="i" begin="1" end="3" step="1" varStatus="status">
  		<c:out value="${i }"></c:out>
  		<c:out value="${step }"></c:out>
  		<c:out value="${status.count }"></c:out>
  	</c:forEach>
  </div>
  
  <!-- url标签，value中的路径可以不写项目名-->
  <div>
  	<c:url value="/jsp/demo5.jsp"></c:url>
  </div>
  
  </body>
</html>

8. EL函数库

1. EL函数：用来操作字符串，需要引入<%@taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn"%>

2. 用法：

<!-- EL 函数标签 -->
  <%pageContext.setAttribute("str", "abcdefg"); %>
  ${fn:contains(str,"ab") }
  ${fn:indexOf(str,"c") }

转载于:https://my.oschina.net/ProgramerLife/blog/2051047

weixin_34174105

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JSP——Java Server Pages

2019独角兽企业重金招聘Python工程师标准>>> ...
复制链接

扫一扫