JavaEE

JavaEE

基于web开发。浏览器与服务器之间的传递

MVC开发模式

M：Model模型层（三个组成部分） 主要是与数据库进行连接的

vo层：实体类（pojo...）

dao层：数据库编程的代码（jdbc）

service层：写的是业务逻辑的代码

V：View视图层 用户可以看见的.html/.jsp(网页)

C：Controller控制层 是V与M的桥梁，起到连接作用（Servlet）

Servlet

c

Servlet是一个接口，GenericServlet是Servlet的实现类，在使用时用的是HttpServlet是GenericServlet子类。

Servlet对象，只实例化一次，即单例模式

如果创建Servlet对象3.0之前

1.创建一个类，习惯上以Servlet结尾

2.继承HttpServlet

3.重写service方法（或者doGet和doPost）

4.需要在web.xml中进行配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <display-name>servlet01</display-name>
    <!-- 配置Servlet -->
    <servlet>
        <!-- Servlet的名字 -->
        <servlet-name>/helloServlet</servlet-name>
        <!-- Servlet的类全名（包名+类名） -->
        <servlet-class>com.zretc.servlet.HelloServlet</servlet-class>
    </servlet>
    <!-- 配置Servlet映射 -->
    <servlet-mapping> 
        <!-- 名称和配置节中Servlet-name必须保持一致 -->
        <servlet-name>/helloServlet</servlet-name>
        <!-- 请求映射路径 -->
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

在service方法中有两个对象，分别是请求与响应，当客户端发出请求时，会产生请求对象，请求对象中可以携带请求参数等数据，服务端会产生一个响应对象，携带一些数据

请求对象方法（request）：

setCharacterEncoding 设置请求编码集

getParameter 接收前端传过来的请求参数

getParameterValues 接收同名键的多个值

getParameterMap 将请求参数用Map集合接收

响应对象方法（response）：

setContentType 设置响应对象的内容类型和编码

getWriter 获得响应输出流

Servlet3.0之后，可以采用注解和配置文件

1.创建一个类，习惯上以Servlet结尾

2.继承HttpServlet

3.重写service方法（或者doGet和doPost）

4.在类上加注解@WebServlet()/web.xml

Servlet生命周期

1.实例化阶段

2.初始化（init方法）

3.服务阶段/就绪阶段（service）

4.销毁阶段（destroy）

其中实例化对象，初始化，销毁只执行一次

常见问题

404 资源未找到=》项目是否部署，重启服务器，名字是否错误

500 服务器错误，服务端发生异常，可能是java代码错误

AJAX

AJAX (Asynchronous JavaScript And XML，异步的JS和XML)

在页面的后方提交数据，整个页面不刷新

用于提交AJAX请求的方法：$.ajax()

提交地址：url

设置提交方式，默认是get提交：type

请求参数：data

是否异步，默认是异步，可以设置同步（false）：async

成功回调函数：success:function(data){｝

失败的回调函数：error:function(request, text, e){ }

JSON字符串

JS：JavaScript，O：对象，N：转换。

就是JS对象转换格式

第三方的JSON库： GSON， Jackson …

JSON的格式，是一种键值对的格式：

{“键”:”值”,“键”:”值”,…}

[{“键”:”值”,“键”:”值”,…},{“键”:”值”,“键”:”值”,...},…]

Servlet设置初始化参数

局部初始化参数，设置在Servlet中，只许当前Servlet进行访问，访问有两种方式

1.getInitParameter(参数名字)；例：this.getInitParameter("row")

2.getServletConfig().getInitParameter(参数名字)

<servlet>
    <servlet-name>sanjiao</servlet-name>
    <servlet-class>com.zretc.servlet.SanJiaoServlet</servlet-class>
    <!-- 初始化参数 -->
    <init-param>
        <!-- 键 -->
        <param-name>row</param-name>
        <!-- 值 -->
        <param-value>7</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>sanjiao</servlet-name>
    <url-pattern>/sanjiao</url-pattern>
  </servlet-mapping>

全局初始化参数，设置在web.xml，整个项目都可以进行访问，getServletContext().getInitParameter(参数名字)

getServletContext()是获得Servlet上下文

    <!-- 全局初始化参数/上下文初始化参数 -->
    <context-param>
        <param-name>n</param-name>
        <param-value>5</param-value>
    </context-param>  

Servlet三大范围对象

HttpServletRequest 请求 同一个请求

HttpSession 会话 同一个绘画

ServletContext Servlet上下文 整个项目

设置参数时：setAttribute(key,value);

取值：getAttribute（key）

移除数据removeAttribute(key)

Cookie

是存在在浏览器中的技术，可以存储字符串类型的键值对

1.默认是关闭浏览器后数据消失，也叫会话级Cookie,默认是-1

2.正数：超过此秒数后数据消失

3.0：则不记录Cookie信息，也就是如果是0的话，直接就删了

写入Cookie时，需要建立一个Cookie对象，增加到响应中，通过setMaxAge设置有效时长

读取Cookie时，是从请求中获得Cookie数组，getName获得Cookie名字，getValue获得Cookie的值

@WebServlet("/setcookie")
public class SetCookieServlet extends HttpServlet{
    
    @Override
    protected void service(HttpServletRequest request, 
            HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
        // 创建Cookie对象，并设置键值对
        Cookie cookie = new Cookie("username", "Tom");
        // 设置超时时间
        cookie.setMaxAge(60);
        // 将Cookie对象添加到响应对象，以便存储在客户端
        response.addCookie(cookie);
    }
}

@WebServlet("/getcookie")
public class GetCookieServlet extends HttpServlet{
    @Override
    protected void service(HttpServletRequest request, 
            HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        // 获取Cookie
        Cookie[] cookies = request.getCookies();
        if(cookies != null) {
            for (Cookie cookie : cookies) {
                //cookie对象.getName():获取键
                if("username".equals(cookie.getName())) {
                    //cookie对象.getValue()：获取值
                    out.print(cookie.getValue());
                    break;
                }
            }
        }
    }
}

Session

代表是会话的意思，一个会话是一个session对象，存储在服务器中（JSessionID在cookie里），对应的类HttpSession

session有有效时长，没有设置时长时默认是30分钟

设置session时长方式：

1.在web.xml中设置session标签

<!-- 设置超时时间 -->
  <session-config>
    <!-- 超时时间，单位是分钟，最少是一分钟 -->
    <session-timeout>20</session-timeout>
    <!-- 在默认情况下，关闭浏览器后，就访问不到Session，不是Session没了，而是因为Session         要依据jsessionid来查找，jsessionid它存放在Cookie中，关闭浏览器后jsessionid消         失，导致找不到Session我们可以通过设置Cookie的超时时间，来解决这个问题
     -->
    <cookie-config>
        <!-- 单位秒 -->
        <max-age>3600</max-age>
    </cookie-config>
  </session-config>

2.session对象设置有效时长，setMaxInactiveInterval 单位是秒

Session失效情况

1.清除cookie了

2.时长过了

3.调用invalidate方法

@WebServlet("/setsession")
public class SetSessionServlet extends HttpServlet {
​
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        // 获取HttpSession对象
        HttpSession session = request.getSession();
        // 设置Session值
        session.setAttribute("username", "gosling");
        // 设置超时时间，单位是秒，如果不设置，默认为1800秒
        // session.setMaxInactiveInterval(30);
        // 获取超时时间
        out.print(session.getMaxInactiveInterval());
        // 重定向到getSession，response.encodeURL()重写URL地址，它将会携带JSessionID
        response.sendRedirect(response.encodeURL("getsession"));
​
        // 移除session
        // session.removeAttribute("username");
        session.invalidate();
    }
}

@WebServlet("/getsession")
public class GetSessionServlet extends HttpServlet{
​
    @Override
    protected void service(HttpServletRequest request, 
            HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        HttpSession session = request.getSession();
        // 获取session的值
        String username = (String)session.getAttribute("username");
        out.print(username);
    }
}
​

Session和Cookie的区别

1.Session保存在服务端，Cookie保存在客户端

2.Session安全，Cookie不安全

3.Session可以存储任何类型数据，Cookie只能存储字符串

4.Session可以存储大量信息，Cookie只能存储少量信息

5.浏览器可以禁用Cookie，但是不能禁用Session

6.Cookie可以在浏览器中手动清除，Session不能

7.Session不能在多态服务器中共享信息，Cookie可以

过滤器

Filter 在请求之前执行的

Filter生命周期

是单例模式，在启动服务器时执行了

1.加载类

2.创建对象（实例化）

3.初始化init方法

4.doFilter执行

5.销毁destroy

执行一次的是实例化对象，初始化init，销毁destroy只执行一次

一般会利用过滤器做编码集设置，与登录状态验证

3.0之前

1.创建一个类，实现Filter接口

2.实现init，doFilter，destroy方法

3.在web.xml中配置

<!-- 配置过滤器 -->
  <filter>
      <!-- 过滤器的名字 -->
    <filter-name>login</filter-name>
      <!-- 过滤器的路径 -->
    <filter-class>com.zretc.filter.LoginFilter</filter-class>
  </filter>
  <!-- 配置过滤器映射 -->
  <filter-mapping>
      <!-- 过滤器的名字 与上面名字一致 -->
    <filter-name>login</filter-name>
      <!-- 过滤路径 -->
    <url-pattern>/*</url-pattern>
  </filter-mapping>

3.0之后

1.创建一个类，实现Filter接口

2.实现init，doFilter，destroy方法

3.在实现类上@WebFilter(过滤路径)/在web.xml中配置

@WebFilter("/*")
public class EncodingFilter implements Filter{
​
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // TODO Auto-generated method stub
        
    }
​
    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest)req;
        HttpServletResponse response = (HttpServletResponse)resp;
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
        // 放行请求
        chain.doFilter(request, response);
        
    }
​
    @Override
    public void destroy() {
        // TODO Auto-generated method stub
        
    }
​
}

配置监听器

<listener>
    <listener-class>com.zretc.listener.SessionListener</listener-class>
</listener>

JSP

Java Server Pages 动态结合的技术，既可以写java，有可以写html，每一个Jsp是一个Servlet类，jsp中有一些内置对象（request，response，session等）可以直接使用

方式一：JSP小脚本 <% %>，可以写Java代码，可以使用JSP内置对象，不能直接定义方法，在Java代码中，注释// /**/，<%--注释JSP脚本--%>

方式二：JSP表达式<%= %>，可以放表达式，有返回值的方法调用，可以取代out输出

方法三：JSP声明<%! %>，可以定义方法，不能使用JSP内置对象

JSP的声明周期

1.编译阶段 =》利用Servlet容器，将jsp，译成Servlet文件

2.初始化阶段 =》加载类，创建对象，初始化方法（jspInit()）

3.执行阶段 =》调用服务方法（jspService）

4.销毁阶段 =》调用销毁方法（jspDestroy()）

转发重定向

重定向：response.sendRedirect();

转发：RequestDispatcher rd = request.getRequestDispatcher("");

rd.forward(request,response);

合并：request.getRequestDispatcher("").forward(request,response);

转发和重定向的区别

1.转发是服务端行为，重定向是客户端行为

2.转发是一次请求，重定向是两次请求

3.转发地址不变，重定向地址改变

4.转发可以携带request作用域的数据，重定向不能

5.转发可以访问WEB-INF，重定向不能

6.转发只能访问站内地址，但是重定向可以访问站外地址

JSP的九大内置对象

JSP对象	类型	描述
request	HttpServletRequest	请求对象
response	HttpServletResponse	响应对象
session	HttpSession	会话对象
application	ServletContext	应用程序对象
config	ServletConfig	配置对象
page	Object	页面对象
pageContext	pageContext	页面上下文对象
out	JspWriter	输出对象
exception	Throwable	异常对象

在JSP中获取初始化参数

  <!-- 全局初始化参数 -->
  <context-param>
    <param-name>name</param-name>
    <param-value>高斯林</param-value>
  </context-param> 
  <!-- 局部初始化参数 -->
  <servlet>
    <servlet-name>config</servlet-name>
    <!-- 指定jsp文件名 -->
    <jsp-file>/03-jsp_object.jsp</jsp-file>
    <init-param>
        <param-name>name</param-name>
        <param-value>埃里森</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>config</servlet-name>
    <url-pattern>/jsp_object</url-pattern>
  </servlet-mapping>

<%=application.getInitParameter("name") %><!-- 高斯林 -->
<%=config.getInitParameter("name") %><!-- 埃里森 -->

错误页配置

1.在web.xml中设置发生错误时的跳转界面

 <!-- 配置错误页 -->
  <error-page>
    <!-- 配置异常类型 -->
    <!-- <exception-type>java.lang.Exception</exception-type> -->
    <!-- 配置错误页地址 -->
    <!-- <location>/WEB-INF/errorpages/05-error.jsp</location> -->
    
    <!-- 配置状态码，依据状态码来转向错误页 -->
    <error-code>错误码</error-code>
        <location>跳转路径</location>
    </error-page>
  
    <error-page>
        <error-code>404</error-code>
        <location>/WEB-INF/errorpages/05-404.jsp</location>
    </error-page>

2.在错误页中加isErrorPage="true"，才可以获得异常信息

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"
    isErrorPage="true"%><!-- 如果想在jsp中，使用exception对象，需要在配置指令中加入isErrorPage="true" -->
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>出错啦~~~~~~~~~</h1>
异常类型：<%= exception.getClass()%><br/>
异常信息：<%= exception.getMessage() %>
</body>
</html>

JSP四大作用

范围从大到小

application，应用程序作用

只要服务器不关，数据一直存在，不建议使用

在本程序中，任何一个位置都可以访问

session，会话作用域，只要session不超时，数据一直存在

request，请求作用，同一个请求内，数据有效

pageContext，页面作用，在本JSP页面内数据有效

设置参数时：setAttribute(key, value)

取值：getAttribute(key)

移除数据：removeAttribute(key)

JSP指令

page指令：可以设置服务端语言，内容类型，页面编码，属性import负责导入类

include指令：导入页面文件

taglib指令：导入标签库

<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<!-- page指令：可以设置服务端语言，内容类型，页面编码，属性import负责导入类 -->
<% List<String> list; %>

<!-- include指令：导入页面文件 -->
<%@ include file="01-hello.jsp" %>
<hr/>
</body>
</html>

el表达式

EL：Expression Language 表达式语言，用于简化JSP ${}

运算符： 1.算术运算符：+，-，*，/(div)（不是整除），% 2.关系运算符：>(gt),>=(ge),<(lt),<=(le),==(eq),!=(ne) 3.逻辑运算符：&&(and)、||(or)、!(not) 4.条件运算符：?:

EL表达式可以进行自动类型识别，比如"1" + 2 ，结果是3

数据类型：布尔类型，整数类型，浮点类型，字符串类型，null EL表达式的变量，不是Java中的变量，而是四大作用域中的值 如果四大作用域的键重复了，获取重名中作用域最低的那个值

EL表达式的四大作用域对象

pageScope

requestScope

sessionScope

applicationScore

获取作用域内变量：

1.作用域对象.变量名 2.作用域对象["变量名"]

参数对象

param：获取请求参数 request.getParameter方法

paramValues：获取同名请求参数的多个值 request.getParameterValues方法

全局初始化参数

initParam

Cookie对象

语法：cookie.key的值.value

页面上下文对象

pageContext，主要是可以调用其他内置对象

请求头对象

header：获得某个请求头对象，例：请求中的host属性 ${header.host}

headerValues：获取所有请求头的信息集合

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<!--  
EL表达式：Expression Language 表达式语言，用于简化JSP的 
​
运算符：
1.算术运算符：+，-，*，/，%
2.关系运算符：>(gt),>=(ge),<(lt),<=(le),==(eq),!=(ne)
3.逻辑运算符：&&(and)、||(or)、!(not)
4.条件运算符：?:
-->
${1+2}<br/>
${5/2 }<br/><!-- 2.5 不是整除 -->
${2 gt 5 }<br/>
${2>5 }<br/>
${true and false}<br/>
${2>1 && 3==3}<br/>
${2>1 ? "ok" : "no" }<br/>
<!-- EL表达式可以进行自动类型识别，比如"1" + 2 ，结果是3 --> <%-- ${} --%>
${"1" + 2 }<br/>
​
<!-- 
    数据类型：布尔类型，整数类型，浮点类型，字符串类型，null
    EL表达式的变量，不是Java中的变量，而是四大作用域中的值
    如果四大作用域的键重复了，获取重名中作用域最低的那个值
 -->
 <%int a = 1; %>
 <%
    pageContext.setAttribute("a", 10);
    request.setAttribute("a", 20);
    session.setAttribute("a", 30);
    application.setAttribute("--0a", 40);
 %>
${a }<br/>
<hr/>
<!--  
    EL表达式的四大作用域对象：pageScope，requestScope，sessionScope，applicationScore
    获取作用域内变量：
    1.作用域对象.变量名
    2.作用域对象["变量名"]
-->
${pageScope.a }<br/>
${requestScope.a }<br/>
${sessionScope.a }<br/>
<%-- ${applicationScope.--0a }<br/> 错误 --%>
<hr/>
${pageScope["a"] }<br/>
${requestScope["a"]}<br/>
${sessionScope["a"]}<br/>
${applicationScope["--0a"] }<br/>
​
<hr>
<%-- <% pageContext.setAttribute("b", 10); %> --%>
${pageScope.b}<!-- EL表达式如果遇到null值，会显示成空，而不会直接显示null -->
<%=pageContext.getAttribute("b") %>
​
</body>
</html>

 

<%@page import="java.util.Arrays" %>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" isELIgnored="false"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<!--  
获取请求参数的
param：获取请求参数
paramValues：获取同名请求参数多个值
-->
${param.username}<br/>
${param["username"]}<br/>
<!-- 相当于Java中的 -->
<%=request.getParameter("username") %><br/>
​
${paramValues.hobby[0] }<br/>
<%-- ${Arrays.toString(paramValues.hobby) }<br/> --%>
​
<!-- initParam:获取全局初始化参数 -->
${initParam.name }<br/>
<%=application.getInitParameter("name") %><br/>
​
<!-- Cookie对象 cookie -->
${cookie.username.value }<br/>
​
<!-- pageContext:页面上下文对象 -->
项目根路径：${pageContext.request.contextPath }<br/>
获取请求的URI：${pageContext.request.requestURI }<br/>
获取请求的URL：${pageContext.request.requestURL }<br/>
​
<!-- 请求头对象 header，headerValues -->
${header}<br/>
${header.host }<br/>
<hr/>
${headerValues.host[0] }<br/>
​
<hr/>
<!-- 忽略EL表达式：\${...}
    禁用EL表达式，在page指令中，加上属性isELIgnored="true"，默认是false
 -->
\${tom hello}
​
</body>
</html>
​

JSTL：JSP标准标签库

core（核心标签库），fmt(格式标签库)，functions（函数库），sql（SQL标签库），xml(XML标签库)

引入两个jar包放在lib下

需要在jsp中引入，<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

taglib指令：导入标签库

uri:标签库名称

prefix：标签库前缀

这里的变量，不是Java中的变量，是作用域中的键值对，默认是页面作用域

<c:set var="score" value="${null }" scope="request"/>
${score}<br/>

总结

作用域名称	JSP内置对象	EL表达式对象	JSTL
应用程序作用	application	applicationScope	application
会话作用域	session	sessionScope	session
请求作用域	request	requestScope	request
页面作用域	pageContext	pageScope	page

core核心标签库中14大标签

set标签：声明、赋值变量，var：变量名，value：值，scope：作用域（page，request,session,application）

out 输出标签，可以指定默认值

remove：删除变量的标签，var：变量名，scope：作用域

如果不指定scope，则四大作用域中所有的指定名称的变量全部删除

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<c:set var="score" value="${null }" scope="request"/>
${score}<br/>

<c:out value="${score}" default="0"/><br/>
${score==null?0:score}<br/>

<c:remove var="score"/>
${score }
</body>
</html>

if：判断标签，test：判断条件，如果满足条件，就执行标签体内容

<c:if test="${score>=60}">及格</c:if><br/>

choose:多分支标签

when：相当于if或else if

otherwise：所有的when都不满足条件时，执行此部分

<c:choose>
	<c:when test="${score>=90 }">优</c:when>
	<c:when test="${score>=80 }">良</c:when>
	<c:when test="${score>=60 }">中</c:when>
	<c:otherwise>差</c:otherwise>
</c:choose>

forEach:循环标签，var是循环变量，begin：开始值，end：结束值，step:步长，默认是1

<c:forEach var="i" begin="1" end="5">
    ${i}
</c:forEach><br/>
​
<!-- 直角三角形 -->
<c:forEach var="i" begin="1" end="5">
    <c:forEach var="j" begin="1" end="${i}">*</c:forEach>
    <br/>
</c:forEach>
​
<!-- 输出1~10的奇数 -->
<c:forEach var="i" begin="1" end="10" step="2">${i}</c:forEach>
​
<!-- 倒着输出10~1 -->
<%-- <c:forEach var="i" begin="10" end="1" step="-1">${i}</c:forEach> 错误--%>
<c:forEach var="i" begin="1" end="10" >${11-i}</c:forEach>

forEach增强for循环

items：集合

varStatus：循环状态的变量，可以获取索引，是否是第一次寻，是否最后一次循环等

<c:forEach var="num" items="${nums}">${num}</c:forEach>
<br/>
<!-- varStatus:循环状态的变量 -->
<c:forEach var="num" items="${nums}" varStatus="s">
    值：${num}<br/>
    索引：${s.index}<br/>
    索引：${s.count}<br/>
    是否是第一次循环：${s.first}<br/>
    是否是最后一次循环：${s.last}<br/>
    当前值：${s.current}<br/>
</c:forEach>

forTokens:进行字符串分割的循环

items：带有指定格式的字符串

delims：分隔符

<c:set var="langs" value="Java-Python-PHP"/>
<c:forTokens var="lang" items="${langs}" delims="-">${lang} </c:forTokens>

import：导入页面

param：传递请求参数

<%@page import="java.net.URLEncoder"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<c:set var="module" value="员工子系统" scope="request"/>
<c:import url="16-head.jsp">
    <%-- 编码 --%>
    <c:param name="username" value="${URLEncoder.encode('高斯林','UTF-8') }"></c:param>
</c:import>
<br/>
import.jsp页面
​
</body>
</html>

<%@page import="java.net.URLDecoder"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<h1>员工管理系统</h1>
<hr/>
登录用户：${URLDecoder.decode(param.username,"UTF-8")} <br/><!-- 解码 -->
登录系统：${module}

redirect：重定向标签 url是重定向的地址

<c:redirect url="17-import.jsp">
    <c:param name="name" value="tom"></c:param>
</c:redirect>

url：生成一个标准的URL的标签

var：报错标准的URL的变量

value：URL地址

如果请求参数有汉字，会自动进行URL编码

<c:url var="str" value="17-import.jsp">
    <c:param name="username" value="高斯林"/>
</c:url>
​
${str}

catch：异常处理的标签

<c:catch var="e">
    <% int a = 0/0; %>
</c:catch>
${e}

fmt格式化标签

formatDate：将日期对象转成格式化字符串的标签

var：用于保存格式化字符串的变量

value：日期对象

pattern：格式

parseDate：将格式化字符串转成日期对象

var：用于保存日期对象的变量

value：格式化字符串

pattern：依据哪种格式转换

<%@page import="java.util.Date"%><!-- Alt+/(?) -->
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<%
    Date now = new Date();
    pageContext.setAttribute("now", now);
%>
${now}<br/>
​
<fmt:formatDate var="str" value="${now}" pattern="yyyy年M月d日HH:mm:ss"/>
${str}<br/>
​
<fmt:parseDate var="date" value="${str}" pattern="yyyy年M月d日HH:mm:ss"/>
${date}
</body>
</html>

formatNumber：保留小数点后指定位数的标签

var：保存最终结果的变量

value：小数

pattern：格式，四舍五入

maxFractionDigits：小数点后最大位数

<fmt:formatNumber var="num" value="12.1297" pattern="0.00"/>
${num}<br/><!-- 12.13 -->
​
<c:set var="a" value="12.3"/>
<fmt:formatNumber var="num2" value="${a}" pattern="0.00"/>
${num2}<br/><!-- 12.30 -->
​
<!-- maxFractionDigits:小数点后最大位数 -->
<fmt:formatNumber var="num3" value="${a}" maxFractionDigits="2"/>
${num3}<br/><!-- 12.3 -->
​
<fmt:formatNumber var="num4" value="${5/2}" maxFractionDigits="0"/>
${num4}<!-- 2 -->

functions函数库

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!-- functions:函数库 -->
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<c:set var="str" value="HelloWorld    "/>
获取长度：${fn:length(str)}<br/>
是否包含某子串：${fn:contains(str,"lo")}<br/>
截取子串：${fn:substring(str,1,4)}<br/>
字符串替换：${fn:replace(str,"o","x")}<br/>
字符串分隔：${fn:split(str,"o") }<br/>
<c:forEach var="num" items="${fn:split(str,'o')}">${num} </c:forEach><br/>
依据子串查找索引：${fn:indexOf(str,"o")}<br/>
去掉左右两边空格：${fn:trim(str)}
</body>
</html>