Servlet 介绍

Servlet规范是SUN公司定义一套规则

  • 作用:
    动态资源文件开发规则
    Http服务器应该如何调用管理动态资源文件
    Servlet规范定义了规则关联的接口,实现类有Http服务器厂商提供
    Tomcat中对于Servlet规范中接口实现存放servlet-api.jar

  • web服务器
    用于提供相关的服务组件运行的环境。
    以及解决用户并发访问和处理业务逻辑的软件。
    TomCat:apache组织开源的一个服务器。
    使用版本:apache-tomcat-9.0.30
    Jboos:处理并发量很大,功能很健全的一个商用服务器。
    webLojec:与Jboos相同

  • 组件
    符合规范,实现部分功能,并且需要部署到相应的服务器中才能运行的软件模块。
    servlet就是一个符合规范的组件,需要部署才能运行。

1
2
3
4
5
Servlet请求-响应的过程
浏览器 ---> 服务器【tomcat】 ---> 数据库

处理静态资源请求。
如果需要计算,调用servlet
  • Servlet接口实现类开发规则

    • 基于servlet_2.0规范 通过配置文件通知Tomcat哪一个类是Servlet接口实现类
      1)创建Servlet接口实现类 继承 HttpServlet
      2)重写父类(HttpServlet)中(service)方法
      3)web.xml

    • 基于servlet_3.0规范 通过注解通知TomcatTomcat哪一个类是Servlet接口实现类(推荐)

如何执行

大致流程

  1. 浏览器会依据ip:端口号来【建立连接】
  2. 浏览器会将请求数据打包
  3. 发送请求数据包
  4. 服务器接收请求
  5. 服务器解析请求数据包
  6. 创建request 和 response对象
  7. 创建servlet对象
  8. 调用service方法,依据请求方式的不同在分别调用doGet 和 doPost方法
  9. 处理业务逻辑
  10. 将处理完的数据放入response对象中
  11. 服务器引擎从response对象中获取数据。
  12. 服务器引擎将响应数据打包
  13. 发送响应给请求的浏览器
  14. 浏览器接收响应数据包并解析数据渲染画面给用户。
  15. 断开连接
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

// @WebServlet():浏览器访问该servlet中value的路径(当只有一个值时候,可忽略。如:@WebServlet("/test"))
@WebServlet(name = "TestServlet",value = "/test")
// 继承HttpServlet,使本类成为Servlet
public class TestServlet extends HttpServlet {
@Override
// service重写方法
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

//请求和应答设置编码,以防乱码
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");

// resp.getWriter可输出到页面
String result = "Hello Servlet";
PrintWriter out = resp.getWriter();
out.write(result);

// 重定向
resp.sendRedirect("http://www.baidu.com");

// 关闭流
out.close();
}
}

web.xml

1
2
3
4
<!-- 欢迎页 -->
<welcome-file-list>
<welcome-file>regist.html</welcome-file>
</welcome-file-list>

获取请求参数

前台提供name属性。name属性是在浏览器打包时,会将name作为key 用户输入的值作为value

后台需要使用key才能获取value

前台:form表单中的属性:
action:服务器提交地址,比如(“test”)
method:get【默认】或者 post

后台:调用
req.getParameter(String key)
req.getParameterValues(String key);

  • 看代码
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    //调用请求对象读取请求行中参数
    String deptNo = request.getParameter("deptNo");
    String dname = request.getParameter("dname");

    String array[] = request.getParameterValues("ck");
    for(String value:array){
    System.out.println("ck = "+value);
    }

    System.out.println("deptNo = "+deptNo);
    System.out.println("dname = "+dname);
    1
    2
    3
    4
    5
    6
    7
    8
    <form action="/myWeb/four">
    部门编号:<input type="text" name="deptNo"><br/>
    部门名称:<input type="text" name="dname"><br/>
    部门业务:<input type="checkbox" name="ck" value="java">java
    <input type="checkbox" name="ck" value="mysql">mysql
    <input type="checkbox" name="ck" value="html">html<br/>
    <input type="submit" value="访问FourServlet">
    </form>

请求方式

  1. get请求

    • 哪些情况下使用get请求。
      在点击某个链接时,使用get请求
      表单的默认提交方式。
    • 特点:
      不安全,会将请求参数值显示在浏览器地址连中
      请求数据有限,最大2K左右
  2. post请求

    • 哪些情况下使用post请求
      表单提交时一般使用post请求方式
      Ajax请求时一般使用post请求
    • 特点;
      安全,将请求数据放在from data 中
      相对请求数据会大一些

jsp

java server page【java 服务端网页】
也是一个标准的web组件,用来解决使用servlet编写网页的繁琐。
其本质就是一个servlet。但是它是以.jsp结尾的一个开源编写HTML、CSS、JS、JAVA代码的文件。
JSP在执行的时候,会被JSP引擎加载,将其中的Java代码转换成.java文件 照搬到其中
HTML采用out.writer()的方式输出,变量采用out.print()输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
JSP文件运行原理:(面试常考问题)

1.jsp文件是一种开发模板,不能被编译也不能运行
类似于预编译SQL命令
insert into dept values(?,?,?)

2.运行原理

1)Tomcat接收到浏览器对于jsp文件请求时,需要将jsp文件【编辑】为【servlet接口实现类】
将jsp文件中内容【编辑】到【servlet接口实现类】中一个方法(_jspService)
对于jsp文件中非java命令内容,统统编辑为 out.write("jsp文件内容")
对于jsp文件中java命令,则直接复制到(_jspService)

2)Tomcat通过JVM将【servlet接口实现类】【编译】为可执行文件(.class)

3)Tomcat通过反射机制要求JVM创建当前类文件的实例对象

4)Tomcat通过实例对象调用_jspService方法,在这个方法运行期间,jsp文件内容
自动的通过输出流写入到响应体

通俗的理解:.jsp文件会被转换成.java文件 最终执行的是.class文件。

语法:

1
2
3
4
5
6
7
8
9
10
11
<% 
java 代码片段
%>

<%= Java表达式 %>
<!-- Java表达式不能以";"或者其它符号结尾 -->

<%@ jsp指令 %>
<!-- 常见指令导入某某包、设置编码 -->
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page contentType="text/html; charset=UTF-8" isELIgnored="false"%>

处理请求资源路径 @WebServlet

匹配规则:

  • 精确匹配
    要求:@WebServlet(value = “/delete”)中的value值必须一致。【value可以省略】
  • 通配符匹配
    要求:使用 * 代替 ,代表任意字符串
    比如:/abc/*
  • 后缀匹配
    要求:不能以 “/“ 开头,要求 .任意字符
    比如:
    .do 或 *.action *.com

处理多种请求

String path = request.getRequestURI();

String path = uri.substring(uri.lastIndexOf("/") + 1,uri.lastIndexOf("."));

例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 只要输入xxx.com的都进入到这个文件
@WebServlet("*.com")
public class ActionServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

//获取用户请求的URI
String uri = req.getRequestURI();
//解析用户的操作
String path = uri.substring(uri.lastIndexOf("/") + 1, uri.lastIndexOf("."));

//根据不同的uri,调用不同的业务方法
if (path.equals("add")){
// 业务内容
}else if(path.equals("del")){
// 业务内容
}else if(path.equals("updata")){
// 业务内容
}else if(path.equals("list")){
// 业务内容
}
}

重定向

1.什么是重定向?
服务器向浏览器响应的时候,会在响应数据包中,添加一个状态码。302状态码,当浏览器解析响应数据包时,如果解析到302状态码,浏览器会立即向302状态所指向的url地址重新发送一个新的请求。

2.如何进行重定向
response.sendRedirect(String url);

3.重定向的特点
重定向的地址是任意的

转发

什么是转发?
转发就是一个web组件将一件没有完成的任务
转交给另一个web组件继续完成的过程。
通俗的理解:一个任务多个组件协同完成。

转发是各个组件可以共享数据以及 request 和response对象

转发的特点
1.转发后浏览器地址栏地址不变。因为转发是服务器内部的,浏览器无感知
2.转发必须共享request和response对象
3.转发必须先绑定后获取

如何转发

1
2
3
4
5
6
7
8
9
10
// 1. 先将处理好的数据绑定到request对象中
request.setAttribute("strs",strs);//将处理好的数据先进行绑定。【数据"strs"绑定在request对象里】,
// 2.转发到forword.jsp文件中。
request.getRequestDispatcher("forword.jsp").forward(request,response);


解释:
setAttribute():绑定数据
getRequestDispatcher(String uri):获取转发器
forward(request,response);转发到转发器所指向的uri地址
  • 什么是状态管理?
    将浏览器与web服务器之间多次交互当做是一个整体来处理,
    并且将多次交互产生的数据【状态】保存下来。
    比如:验证码

  • Cookie类
    将状态保存在浏览器端

    浏览器在访问服务器时,服务器会将一些数据以 set-cookie 消息头的形式发送给浏览器。
    浏览器将这些数据保存起来。当浏览器在次访问服务器时,会将这些数据以cookie消息头的
    形式,发送给服务器,通过这种方式来保存用户状态。

    可以理解为,服务器临时保存在浏览器端的少量数据。

    • 设置cookie的路径
      浏览器在向服务器发送cookie的时候,会先比较cookie的路径与请求的路径是否匹配,如果匹配会将匹配的cookie发送到服务器,否则不发送
      比如:
      创建cookie保存的路径是,/day04_war_exploded/cookie
      1.访问cookie的路径如果是:/day04_war_exploded/cookie/findCookie.jsp 能访问到
      2.访问cookie的路径如果是:/day04_war_exploded/findCookie.jsp 访问不到
      3.访问cookie的路径如果是:/day04_war_exploded/cookie/cookie2/findCookie.jsp 能访问到

      结论:
      只要是创建路径下的子路径都可以访问。

      方法:
      request.setPath(String path):设置cookie的路径
      request.getContextPath():获取 Application Context【】

      例子:

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      /*
      创建cookie并发送到浏览器端
      */
      @WebServlet("/cookie")
      public class CreateCookie extends HttpServlet {

      @Override
      protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

      //创建cookie
      Cookie cookie = new Cookie("isdn", UUID.randomUUID().toString());
      //设置cookie的生命周期
      cookie.setMaxAge(60);//秒
      //发送cookie
      response.addCookie(cookie);
      }
      }
  • HttpSession接口
    将状态保存在服务器端

    浏览器访问服务器时,服务器会创建一个session对象,session对象中保存一个唯一的ID 称为JSESSIONID,服务器会将JSESSIONID以cookie的形式,发送给浏览器端,浏览器进行保存。
    当浏览器第二次访问服务器时,浏览器将JSESSIONID再次发送给服务器,服务器依据JSESSIONID查找对应的session对象,如果找到,则使用,否则创建一个新的session对象。

    总结:
    session对象的创建是服务器创建的

    方法:
    HttpSession session = request.getSession():获取服务器创建的session对象。
    session.setAttribute(Object key,Object value):绑定数据到session中
    Object obj = session.getAttribute(Object key):根据key获取value

    例子:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    /*
    session对象获取绑定数据
    */
    @WebServlet("/session")
    public class SessionObject extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    //获取服务器创建的session对象
    HttpSession session = request.getSession();
    System.out.println(session.getId());

    //将数据绑定到session对象中
    session.setAttribute("checkcode","123456");

    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    /*
    验证验证码是否正确
    */
    @WebServlet("/sessioncheckcode")
    public class CheckCodeServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    //获取服务器创建的session对象
    HttpSession session = request.getSession();
    System.out.println(session.getId());

    //获取
    String code = (String) session.getAttribute("checkcode");

    //从前台获取name来判断是否相等
    String checkcode = request.getParameter("checkcode");
    if (code.equals(checkcode)) {
    System.out.println("验证码正确");
    } else {
    System.out.println("验证码错误");
    }
    }
    }

    注意:
    request也有setAttribute
    session也有setAttribute
    存在的区别是生命周期的长短
    reuqest:请求到响应-死亡
    session:浏览器关闭、session超时、服务器关闭

ServletContext

  • 概念
    web 服务器在启动时,会为每一个工程都创建一个唯一的 ServletContext 对象。
    该实例会一直存在,除非服务器宕机,或者关机。(生命周期长)

获取ServletContext实例

1
2
3
4
5
6
7
8
 //方式一
ServletContext servletContext = this.getServletContext();

//方式二
ServletContext servletContext1 = request.getServletContext();

//方式三
ServletContext servletContext2 = request.getSession().getServletContext();

如何使用ServletContext实例?
1.绑定数据
2.获取绑定数据

1.配置全局初始化参数【了解】
2.获取全局初始化参数

  • 绑定且获取数据

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    import javax.servlet.ServletContext;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;

    @WebServlet("/context")
    public class Test extends HttpServlet {
    public Test() {
    System.out.println("无参构造器运行。。。");
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // 获取ServletContext实例
    ServletContext servletContext = this.getServletContext();
    //绑定数据
    servletContext.setAttribute("name", "葫芦啊葫芦");
    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    <body>
    <!-- 获取数据 -->
    <%
    Object name = application.getAttribute("name");
    %>
    <!-- 输出“葫芦啊葫芦” -->
    <h1><%=name%></h1>
    </body>
  • 配置全局初始化参数 且 获取全局初始化参数

    1
    2
    3
    4
    <context-param>
    <param-name>url</param-name>
    <param-value>jdbc:mysql://127.0.0.1:3306/gz2107?useUnicode=true&amp;characterEncoding=utf8</param-value>
    </context-param>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    @WebServlet("/context")
    public class Test extends HttpServlet {
    public Test() {
    System.out.println("无参构造器运行。。。");
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext servletContext = this.getServletContext();

    //获取初始化参数
    String url = servletContext.getInitParameter("url");
    System.out.println(url);
    // 最后输出 jdbc:mysql://127.0.0.1:3306/gz2107?useUnicode=true&characterEncoding=utf8
    }
    }

生命周期

  • 概念
    Servlet 容器如何创建 Servlet 实例,分配其资源,调用其方法,并且销毁其 实例 的整个过程。

  • 阶段一:
    实例化【创建servlet对象,调用其构造器】
    1.当请求到达容器时,容器会查找该servlet实例是否存在,如果不存在,则创建新的实例。
    2.容器在启动的时候,会查找每个Servlet中是否配置了loadOnStartUp配置,如果有,会立即创建该servlet的实例。
    loadOnStartup的值越小优先级越高。最高10

  • 阶段二:
    初始化
    为servlet分配资源,调用init(ServletConfig config)方法
    config 对象可以访问到servlet的初始化参数。
    ServletConfig:servlet对象一旦创建会自动调用init方法获取初始化参数。

  • 阶段三:
    就绪/调用
    容器调用servlet实例的service方法根据请求类型的不同
    来分别调用不同请求类型所对应的方法。
  • 阶段四:
    销毁
    容器依据自身算法,将不再使用的servlet实例删除掉
    在删除之前会调用servlet实例的destroy方法来释放资源。

注意:init方法和destroy方法只会执行一次,而service方法每一个请求都会执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@WebServlet(value = "/context",loadOnStartup = 7,initParams = {@WebInitParam(name = "admin",value = "这是amdin的值")})
public class Test extends HttpServlet {
public Test() {
System.out.println("无参构造器运行。。。");
}

@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
}

@Override
public void init(ServletConfig config) throws ServletException {
String admin = config.getInitParameter("admin");
System.out.println(admin);
// 输出以下两句:
// 无参构造器运行。。。
// 这是amdin的值
}
}

监听器 @WebListener

  1. 什么是监听器?
    监视容器中的各种对象的事件。它是一个特殊的接口
    一般与servlet的生命周期相关。
  1. 如何写一个监听器
    写一个java类实现特定监听器的接口【依据要监听的事件类型】
    在接口中实现回到方法。
    配置监听器

例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
// 监听一
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

@WebListener
public class SessionObejctListenter implements HttpSessionListener {
@Override
public void sessionCreated(HttpSessionEvent se) {
System.out.println("session被创建了……");
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
System.out.println("session被销毁了……");
}
}


// 监听二
import javax.servlet.ServletContextAttributeEvent;
import javax.servlet.ServletContextAttributeListener;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class ServletContextCreateListenter implements ServletContextListener,ServletContextAttributeListener {
@Override
public void contextInitialized(ServletContextEvent sce) {
System.out.println("ServletContext被初始化……");
}

@Override
public void attributeAdded(ServletContextAttributeEvent scae) {
System.out.println("ServletContext被初始化的attribute方法被调用...");
}
}

// 监听三
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class RequestObjectListenter implements ServletRequestListener {
@Override
public void requestInitialized(ServletRequestEvent sre) {
System.out.println("request对象被创建……");
}

@Override
public void requestDestroyed(ServletRequestEvent sre) {
System.out.println("request对象被销毁……");
}
}

过滤器 @WebFilter

  • 概念
    请求到达servlet之前,会对请求进行拦截,过滤、筛查到达Servlet实例的请求是否符合标准。(请求时先到达过滤器。)

写一个过滤器
实现Filter接口,并实现其doFilter方法。配置Filter访问路径。

doFilter方法:
参数介绍:
ServletRequest 是 HttpServletRequest的父类
ServletResponse 是 HttpServletResponse的父类

FilterChain:过滤器链
过滤器链有一个方法:doFilter(request,response);
//调用后续过滤器,如果没有过滤器则调用servlet

例子:过滤敏感字

1
2
3
4
5
6
7
8
9
10
11
12
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="evaluate" method="post">
评价:<input type="text" name="evaluate" /><br/>
<input type="submit" name="提交" />
</form>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

@WebFilter("/evaluate")
public class ContentFielter implements Filter {

@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) servletRequest;
HttpServletResponse response = (HttpServletResponse) servletResponse;
request.setCharacterEncoding("utf-8");
response.setContentType("text/html;charset=utf-8");
PrintWriter out = response.getWriter();

//获取用户的评价内容
String evaluate = request.getParameter("evaluate");
if(evaluate.contains("伞兵")){
out.println("<h1>不允许出现“伞兵”等文字</h1>");
}else{
//调用后续过滤器,如果没有过滤器则调用servlet
out.println("没用敏感字,可以通过");
filterChain.doFilter(request,response);
}
}
}

跨域 与 同源 请求

浏览器的同源策略:
是浏览器最核心也是最基本的安全功能。出于安全考虑 如果请求的域名、协议、端口有一个不同就不是同源,三者均相同,这两个网站才是同源。

跨域请求:
这里的域指的是这样的一个概念:我们认为如果 “协议 + 域名 + 端口号” 均相同,那么就是同域。
当前发起请求的域与该请求指向的资源所在的域不一样。

解决跨域请求:过滤器添加这三条

1
2
3
res.setHeader("Access-Control-Allow-Origin", "*");
res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Accept,X-Requested-With");

JSTL

英文:java stander taglib
是java 标准标签库,使用需要导jar包
是用来将jsp页面中的java代码采用类似于html标签的形式来输出的一种技术。

看代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
1.如何使用JSTL?

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

<!-- uri的值是在.jar包中的c.tld文件中 -->

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>

<!-- isELIgnored="false" 表示不忽略表达式 -->



2.分支判断标签

<c:if test="">
</c:if>

<!-- test属性:用于接收当前值是否是true,如果是true执行标签体中的内容 -->


3.分支判断标签

<c:choose>
<c:when test="${empty user}">
<h1>user是空对象</h1>
</c:when>
<c:otherwise>
<h1>${user.hobbys[0]}</h1>
</c:otherwise>
</c:choose>

4.循环标签

<c:forEach items="${user.hobbys}" var="hobby" varStatus="status">
<h1>${hobby}</h1>
<h1>${status.index}</h1>
<h1>${status.count}</h1>
</c:forEach>

EL表达式

Expression language 表达式语言
是一种可以在JSP页面获取数据的一种方式。
完整语法:${作用域对象别名.共享数据名.属性名}
简写语法:${共享数据名}

  • 执行原理:
    依次查找pageContext、request、session、application所绑定的key
    如果查找到,则调用key所绑定的value值的getXXX方法来获取数据。

  • 作用域
    requestScope:只在request作用域中查找指定的绑定名
    sessionScope:只在session作用域中查找指定的绑定名
    applicationScope:只在servletContext作用域中查找指定的绑定名

  • 注意:
    el表达式只能获取数据,不能设置数据。
    el表达式可以进行计算,可以调用方法。
    el表达式不能进行字符串的拼接

  • 支持运算

    大于 大于等于 等于 小于 小于等于 不等于
    gt ge eq lt le !=
    > >= = < <= !=
  • 时间格式化

    1
    <formatDate value="${你的时间对象}" pattern="yyyy-MM-dd" />

json

java对象转换成json对象传给前台
需要导入jar包,(这里我选择jackson)

例子:

1
2
3
ObjectMapper om = new ObjectMapper();           //新建对象
String suser = om.writeValueAsString(user); //把java对象user转为suser的json对象(json是字符串)
resp.getWriter().println(suser); //发送给前台