JavaWeb入门笔记

Java web笔记

一、HTTP协议

HTTP(超文本传输协议),它是一种主流B/S架构中应用的通信协议。具有以下特点:1、无状态服务端不会记录客户端每次提交的请求,服务器一旦相应客户端之后,就会结束本次的通信过程。客户端下一次的请求是一个新的 连接,和上一次通信没有任何关系。2、简单灵活HTTP是基于请求(request)和响应(response)的模型3、支持客户端与服务端支持主流的B/S架构的通信以及C/S架构的通信。注意:C/S架构可选的协议有多种,例如:TCP/IP,UDP,HTTP而B/S架构通常只支持HTTP协议

二、服务器

1、概念

服务器通常由硬件和软件部分构成,统一对用户提供多种不同的服务。1、硬件:包括响应的CPU、内存、磁盘等等2、软件:包括操作系统、运行环境、服务器软件、数据库等等

2、web服务器

web服务器是提供服务端程序运行的一个环境,它本身也是一个软件。例如:将我们编写HTML文件放入到web服务器中,那么外界就可以通过浏览器访问我们的html页面常见的web服务器有Apache,Tomcat、Jetty、Nginx等等。而Tomcat、Jetty这些web服务器更准确的说是一个Servlet容器。

三、JavaWeb项目结构

项目根目录,例如:myweb、ch01通常存放静态资源文件(如:html等等)
WEB-INF这个目录是当前项目私有的一个文件夹,只能提供给项目内部访问,对于客户端来说是访问不到了,通常这个目录下存放的是Java源代码、编译后的字节码文件以及Servlet的核心配置文件web.xml
src存放java源代码的目录
classes存放编译后的字节码文件
liblib目录存放当前项目所需要的jar文件
JSP用于存放JSP动态页面
web.xml项目的配置文件,用于配置Servlet的请求映射、过滤器、监听器等等信息。每一个web项目都对应一个web.xml配置文件
META-INF配置应用程序、扩展程序、类加载服务等等

四、Servlet基础

1、什么是Servlet

Servlet是JavaEE中标准组件,专门用于处理客户端提交的HTTP请求。并且它必须依赖于Servlet容器才可以运行(Tomcat就是一个标准的Servlet容器),Servlet容器给Servlet提供一个运行环境,所以Servlet组件必须要这个环境中可以运行,而不能脱离这个环境而单独执行。因为Servlet的实例是由容器创建和销毁的,并不是通过我们平常使用的new关键创建出来。

2、开发一个Servlet的步骤

1.编写一个类,然后继承HttpServlet这个父类2.重写父类的service方法,这个就是专门处理客户端请求的方法,这个方法有两个参数(HttpServletRequest,HttpServletResponse),同时这个方法会抛出两个异常(ServletException,IOException)

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;

//要让当前的类是一个Servlet,必须继承HttpServlet
public class HelloServlet extends HttpServlet{

     //重写父类的service方法,处理客户端请求,
     //这个方法私有servlet容器去调用,
     //并且request和response参数都是由servlet容器传递进来的
     public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         System.out.println("Hello Servlet");
         //响应一些信息回馈给客户端浏览器
         //1.设置要响应的类型,这里就响应简单的html文本类型
         //通过response参数来进行设置,如:text/html,text/plain
         response.setContentType("text/html;charset=utf-8");
         //2.获取输出流并写回html数据
         response.getWriter().println("<h1>Hello Servlet</h1>");
     }
}
 

3.编译Servlet,需要依赖servlet-api.jar文件4.编写web.xml,为servlet配置请求映射的URL

<?xml version="1.0" encoding="utf-8"?>
<!-- 配置根节点 -->
<web-app>
   <!-- 配置servlet类 -->
   <servlet>
         <!-- 指定servlet的别名 -->
         <servlet-name>hello</servlet-name>
         <!-- 指定Servlet的完整类名-->
         <servlet-class>HelloServlet</servlet-class>
   </servlet>
   <!-- 配置请求映射-->
   <servlet-mapping>
          <!-- 这里的servlet-name和上面的servlet-name要一一对应 -->
         <servlet-name>hello</servlet-name>
         <!-- 配置请求映射的url,必须以“/”开头-->
         <url-pattern>/test</url-pattern>
   </servlet-mapping>
</web-app>

5.将项目部署到Tomcat的webapps目录中

3、servlet处理请求的流程

1.浏览器发起http的请求,这个请求首先会被servlet容器(Tomcat)截获,然后容器会根据web.xml文件中配置servlet的<url-pattern>来找到相应的<servlet-name>这个别名,然后再根据这个别名找到具体Servlet的类,然后容器会创建这个Servlet类的实例并调用Servlet方法来处理这个请求。请求网页地址:http://127.0.0.1:8080/ch02/test

4、Servlet的生命周期

所谓的生命周期,就是从Servlet的创建一直到它销毁的整个过程。并且它的 整个生命周期都是由Servlet容器(Tomcat)负责管理和维护的。(补充:在Tomcat中,Servlet是以单实例多线程的方式处理客户端请求)

4.1 Servlet对象创建的过程

当第一次请求某个Servlet的时候,容器会先查找之前有没有创建过这个Servlet的实例,如果没有则创建一个实例并缓存起来。后续 所有请求这个Servlet的时候,都会使用这个缓存的对象来处理客户端请求。(注意“这里说的是第一次请求时创建。另外一种情况则是在容器启动的时候就创建Servlet的实例,在web.xml中为Servlet指定<load-on-startup>配置,这个配置的值是一个整形,数值越小,则初始化 的优先级别越高)

4.2 生命周期方法

方法名描述
init在Servlet对象创建之后立即执行的初始化方法,且只执行一次
service核心的请求处理方法,这个方法可以执行多次
destroy容器准备销毁Servlet实例之前执行的方法,也是执行一次

5、HTTP请求报文

5.1 请求报文

请求行:请求报文的第一行就是请求行。包括请求方法、请求URL地址、HTTP协议版本请求头:请求行之后的信息就是请求头,它是以“名称:内容”的格式体现。主要包括服务器主机地址及端口号、连接状态、接收的数据类型、编码、语言等等请求体:请求头结束之后会有一个空行,空行之后就是请求体的内容。通常使用POST提交的数据信息会存放在请求体中,然后传递给服务器。

5.2 响应报文

状态行:主要包括HTTP协议、响应状态码(例如:200表示OK,成功响应)响应头:主要包括服务器信息、响应的类型及编码、内容的长度、响应的时间等响应体:服务器将信息携带到响应体中,带回客户端。

6、HTTP请求方法

在HTTP/1.1协议中,请求方法主要包括8个,下面列举常用的请求方法进行说明。
|请求方法|说明|
|----|----|
|GET|向服务器请求指定的资源,并返回响应主体。一般来说GET方法应该只用于数据的读取(类似于查询)|
|POST|向指定的服务器提交数据(例如:表单数据的提交、文件上传等),并且提交的数据会放入请求体中(类似于新增)|
|PUT|向服务器提交数据,但是和POST有所区别。如果服务器不存在此资源的时候,则执行新增,如果存在则执行修改。(类似于修改)|
|DELETE|根据uri的表示删除服务器上的某个资源(类似于删除)|
|...|...|

备注:GET与POST区别:1.GET主要用于获取数据,POST用于提交数据。2.GET请求所带的参数是放在请求行的url地址后面,而POST这是放在请求体中。3.通常浏览器会对GET请求的url长度有所限制 ,而POST通常在请求体中,可以提交更多的数据信息。4.浏览器会对GET请求进行缓存。

7、Servlet的请求处理方法

方法说明
service可以处理任何的请求类型
doGet处理对应的GET请求
doPOST处理对应的POST请求
doPut处理对应的PUT请求
doDelete处理对应的DELETE请求

说明:通过HttpServlet的源代码得知,默认的所有请求都会先经过service方法,然后service方法根据请求的方法类型判断来决定交给doGet或者是doPOST方法来处理请求。如果子类重写了service方法同时还重写了其他的doXxx的方法,那么只有service方法会处理请求,其他方法将失效。

8、请求和响应对象

当web容器调用某个Servlet的Service方法时,会创建一个HTTPServletRequest和HTTPServletResponse对象作为参数传入到这个方法中,那么我们可以通过HTTPServletRequest来获取相关的请求内容等,而响应客户端可以利用HttpServletResponse对象来完成。

8.1 HttpServletRequest常用API

方法说明
getParameter(String name)获取请求参数的值,根据请求参数的name指定
getParameterValues(String name)获取相同name的请求参数,返回的是字符串数组
getParameterMap()获取所有请求参数,包括参数名称和值
getMethod()获取请求方法的类型
getHeader(Stirng name)根据请求头的名称获取响应的信息
getRemoteAddr()获取远程客户端的IP地址
getServletPath()获取Servlet的请求地址,也就是url-pattern
getRequestURL()获取请求完整的URL地址
getRealPath(String path)获取项目的绝对路径。(这个方法在request对象中已废弃,建议通过ServletContext对象获取)
其他...
public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
        System.out.println("---------------获取参数值----------------");
        //获取请求参数,根据请求的参数名
        String name = request.getParameter("uname");
        String age = request.getParameter("age");
        System.out.println(name);
        System.out.println(age);
        //获取相同参数名的参数
        String[] addrs = request.getParameterValues("address");
        for (String addr : addrs) {
            System.out.println(addr);
        }
        System.out.println("--------------获取参数名---------------");
        //获取所有的参数名
        Enumeration<String> es = request.getParameterNames();
        //枚举使用迭代器来循环遍历
        while(es.hasMoreElements()) {
            String paramName = es.nextElement();
            System.out.println(paramName);
        }
        System.out.println("---------------获取所有的参数名和参数值-------------------");
        //map泛型的第一个参数表示请求的参数名称,第二个参数是请求的参数值,值可以有多个,所以是数组
        Map<String,String[]> map = request.getParameterMap();
        //map的key对应的是参数名,value就是参数的值
        for (String key : map.keySet()) {
            System.out.println("参数名:" + key);
            System.out.println("参数值: ");
            String[] values = (String[])map.get(key);
            for (String value : values) {
                System.out.println(value);
            }
            System.out.println("~~~~~~~~~~~");
        }
        System.out.println("-------------获取客户端的请求方法--------------");
        String method = request.getMethod();
        System.out.println("请求方法:" + method);
        System.out.println("--------------获取请求头部的信息---------------");
        String header = request.getHeader("Host");
        System.out.println("请求头信息:" + header);
        System.out.println("--------------获取远程客户端的IP地址--------------");
        String addr = request.getRemoteAddr();
        System.out.println("客户端的IP地址" + addr);
        System.out.println("------------获取Servlet的url-pattern---------------");
        String servletPath = request.getServletPath();
        System.out.println("url-pattern: " + servletPath);
        System.out.println("------------获取请求的完整URL---------------------------");
        String url = request.getRequestURL().toString();
        System.out.println(url);
        System.out.println("-------------获取项目的绝对路径------------------");
        String path = request.getServletContext().getRealPath("/");
        System.out.println(path);
    }

8.2 HttpServletResponse常用API

方法说明
setContentType(String str)设置响应内容的类型及编码
getWriter()获取响应字符输出流
getOutputStream()获取字节输出流
setHeader(String name,String value)设置响应头信息,如果存在响应头信息,则执行更新
addHeader(String name,String value)设置响应头,不管存不存在都会新加入一个
setStatus(int code)设置响应状态码
其他...

public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //设置响应的内容类型及编码,包括(text/html,text/plain,application/json)
        response.setContentType("text/html;charset=utf-8");
        //设置响应头信息
        response.addHeader("myheader", "hello header");
        response.addHeader("myheader", "my servlet");
        //设置响应的状态码
        response.setStatus(200);
        //获取字节输出流
        OutputStream os = response.getOutputStream();
        //获取响应的字符输出流
        PrintWriter pw = response.getWriter();
        pw.println("<html>");
        pw.println("<head><title>index</title></head>");
        pw.println("<body>");
        pw.println("<h3>Hello Servlet</h3>");
        pw.println("</body>");
        pw.println("</html>");
        
    }
 

8.3 常见的响应状态码

状态码说明
200请求成功
401禁止访问,未授权
404找不到请求的资源
405请求的行的方法不被支持
500服务器内部错误
其他...

9、Servlet之间的通信

9.1 转发

所谓转发,就是在多个Servlet之间共享请求和响应对象,所有参与转发过程的Servlet都可以获取同一个请求对象的信息。在Servlet的API中,转发的操作是有HttpServletRequest对象完成的。示例代码:

public class ServletA extends HttpServlet{
    
    public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
        //获取页面提交的参数
        String name = request.getParameter("userName");
        
        //转发由HttpServletRequest完成
        //第一步先获取一个请求转发器RequestDispatcher
        //获取请求转发器的同时要告诉转发器转发到哪里,转发给谁
        //如果要转发给ServletB,那么就是对应ServletB的url-pattern
        RequestDispatcher rd = request.getRequestDispatcher("servletB");
        //调用转发器的forward方法执行转发,同时将request和response对象一并转发ServletB
        rd.forward(request, response);
        
    }
}
public class ServletB extends HttpServlet{

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        //这里在同一个请求中再次获取页面的参数
        String name = request.getParameter("userName");
        System.out.println("ServletB获取请求参数:"+name);
    }
}

转发的特点:1、URL地址栏不会发生改变2、转发的过程是在服务端自动完成请求作用域:每一个请求对象都有一个独立的空间,这个空间我们称之为请求作用域(RequestScope),可以为当前这个请求携带额外的一些数据信息,这些信息同样可以在多个Servlet之间进行共享。示例代码:


public class ServletA extends HttpServlet{
    
    public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
        
        //在ServletA中为request对象设置请求作用域
        request.setAttribute("age", 35)
    }
}
public class ServletB extends HttpServlet{

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //在ServletB中获取统一个请求对象作用域的值域的值
        Integer age = (Integer)request.getAttribute("age");
    }
}

9.2 重定向

重定向的机制和转发不同,一次重定向的过程中会有两次请求和两次响应,服务端在接收第一次请求后会先做一次302的响应(302表示重定向状态码),告诉客户端浏览器必须发起一个新的地址,服务端再次接收这个请求处理,最后再次响应客户端。
图片描述
重定向特点:1、URL地址栏会发生改变2、重定向的操作是在客户端浏览器完成的示例代码:方式一:

public class ServletC extends HttpServlet {

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //执行重定向
        //方式一:设置302响应状态码,并在响应头中添加location属性指定重定向的地址
        response.setStatus(302);
        response.addHeader("location", "http://localhost:8080/ch06/servletD");
    }
}

方式二:


public class ServletC extends HttpServlet {

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("请求到达ServletC");
        System.out.println("ServletC获取请求参数:"+request.getParameter("userName"));
        //执行重定向
        
        //方式二:使用response的sendRedirect方法
        response.sendRedirect("servletD");
    }
}

10、会话跟踪

由于HTTP协议是无状态的,服务端并不会记录每一个客户端的状态,因此,如果想要实现服务器能记录客户端的状态的话,那么就需要会话跟踪技术。

10.1 cookie

cookie是客户端浏览器的内部的一个文本文件,专门用于记录服务器发送过来的一些文本信息,那么在每次请求的时候,客户端都把这个cookie信息由提交回给相应的服务器,那么服务器就可以获取cookie的信息,达到会话跟踪的目的。使用cookie的机制是基于客户端浏览器来维护与服务器的状态跟踪。
图片描述
示例代码:设置cookie

public class SetCookieServlet extends HttpServlet{

    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //创建一个Cookie的实例
        Cookie cookie = new Cookie("userId","10001");
        //将cookie对象设置到响应对象中
        response.addCookie(cookie);
        System.out.println("成功设置cookie");
    }
}

获取cookie

public class GetCookieServlet extends HttpServlet{

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse repsonse) throws ServletException, IOException {
        //cookie是通过request对象来得到的
        //从请求中可以获取多个cookie对象
        Cookie[] cookies = request.getCookies();
        for (Cookie cookie : cookies) {
            //判断cookie,只获取name为userId的cookie对象
            if("userId".equals(cookie.getName())) {
                System.out.println(cookie.getValue());
            }
        }
    }    
}

cookie保存中文:在保存cookie的时候如果需要保存中文,那么中文信息需要经过编码后才可以写入cookIe示例代码:编码使用URLEncoder


String str=URLEncoder.encode("张三","utf-8");
Cookie cookie = new Cookie("userName",str);

解码使用URLDecoder


String str=URLDecoder.decode(cookie.getValue(),"utf-8");
System.out.println(str);

cookie的生命周期:默认cookie只会保存在浏览器进程的内存中,并不会写入cookie文件,如果关闭了浏览器,那么浏览器的进程也就消失了,那么对应的内存就会释放空间,因此cookie的也就销毁。如果想将cookie写入文件,那么就必须设置cookie的生命时长,一旦设置了生命时长,那么就表示这个cookie会在文件中保留多长时间,到了这个时间之后,浏览器就会自动销毁这个cookie。设置cookie存活时间:


//设置为0表示立即删除cookie
cookie.setMaxAge(0);
//设置为正数表示cookie在cookie文件的存活时间,单位:秒
cookie.setMaxAge(5);
//设置为-1表示cookie只保留在浏览器的进程中,关闭浏览器之后会销毁cookie
cookie.setMaxAge(-1);

10.2 Session

Session是基于服务端来保存用户的信息,这个是和cookie的最大区别。不同的客户端在请求服务器的时候,服务器会为每一个客户端创建一个Session对象并保存在服务器端,这个Session对象是每个客户端所独有的,相互之间不能访问。服务器为了区别不同的Session属于哪一个客户端,因此Session对象也有一个唯一标识,叫做SessionID。而这个SessionID是以cookie的机制保存在客户端浏览器。每次请求的时候,浏览器都会把这个SessionID带回服务端,服务端根据这个SessionID就可以找到对应的Session对象。示例代码:

public class SessionServlet extends HttpServlet{

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //HttpSession对象是在第一次调用request的getSession()方法时才会创建
        //注意:getSession()的方法会先判断之前是否为客户端创建了session实例,
        //如果创建了,则使用之前创建好的Session对象,没有则创建一个新的Session
        HttpSession session = request.getSession();
        //创建HttpSession的同时,会创建一个唯一的标识SessionID
        //这个sessionId会保存在浏览器的cookie中,每次请求会带回这个id找到相应的session对象
        String sessionId = session.getId();
        System.out.println(sessionId);
    }
}

session的生命周期:1.SessionId是保存在浏览器的cookie中,但是不会写入cookie文件,这也就表示当关闭浏览器之后SessionId就会销毁。SessionId销毁以后,服务端的Session就没有任何作用了。但是服务器并不会立刻销毁这个Session对象,至于什么时候销毁是由服务器自己决定的。除非我们手动调用了session.invalidate()方法,服务器就会立即销毁这个session实例。示例代码:


HttpSession session=request.getSession();
//立即销毁session
session.invalidate();

2.Session默认也有存活时间,服务器在创建Session的时候为Session设置默认的存活时间为30分钟,如果在30分钟之内,客户端没有发起任何到服务器,那么服务器就会销毁这个Session对象。我们也可以设置Session的存活时间。可以为当前的Session设置,也可以为全局(服务器端的所有Session)的Session设置。设置当前Session的存活时:


HttpSession session=request.getSession();
//设置当前Session的存活时间,单位:秒
session.setMaxInactiveInterval(3600);

设置 全局的Session的存活时间 :在web.xml中进行设置


<!-- 设置全局Session的存活时间,单位:分钟 -->
<session-config>
    <session-timeout>60</session-timeout>
</session-config>

Session的作用域:当我们需要将一些数据信息存入Session的时候,就需要操作Session作用域(SessionScope),它和请求作用域类似,也有相应setAttitude和getAttribute方法,只不过Session作用域的范围要比请求作用域更宽。请求作用域在一次请求响应只有就会消失(因为响应之后请求就会销毁)。而Session对象只要浏览器不关闭或者未超时,那么Session对象会一直驻留在服务器端,因此不管重新请求 多少次还是转发和重定向,都可以从Session中获取之前保存的数据信息。示例代码:

User user = new User();
user.setUid("1001");
user.setUserName("wangl");
HttpSession session = request.getSession();
//将数据保存在会话作用域中
session.setAttribute("user", user);

从会话作用域取值

HttpSession session = request.getSession();
//取值
User user = (User)session.getAttribute("user");

URL重写:浏览器是可以禁用cookie的,一旦禁用了cookie,那么SessionID将无法写入cookie的缓存中,这样就导致无法实现会话跟踪了,因此解决办法就是使用URL重写。URL重写的目的就是把SessionID放在请求URL地址的后面提交回服务器(类似GET请求后面带上参数,而这个参数就是一个SessionID),服务器会解析和这个URL的地址并得到SessionID。示例代码:

//重写请求的URL地址,这个地址后面会自动带上SessionId
String url = response.encodeRedirectURL("getSession");
//重定向URL
response.sendRedirect(url);

浏览器地址演示

 http://localhost:8080/ch07/getSession;jsessionid=6F1 BA8C92D7E5D7CC479ED8DD30D3ED0

注意:“;”后面跟着就是SessionID

11、Servlet上下文

web容器在启动时会为每一个web应用创建唯一的上下文对象,这个对象就是Servlet上下文对象(ServletContext),这个上下文对象可以理解为是当前项目的一个共享内存空间,为项目中的所有Servlet提供一个共享的区域。常用API:
|方法|说明|
|----|----|
|getContextPath()|获取项目的相对路径|
|getRealPath(String path)|获取项目的绝对路径|
|getInitParameter(String name)|获取上下文的初始化参数(web.xml中配置的)|
|setAttribute(String name, String value)|将数据放入上下文作用域|
|getAttribute(String name)|从上下文作用域中去获取数据|

上下文作用域:上下文作用域是为当前项目所有Servlet提供的一个共享内存区域,可以将需要的数据信息保存在作用域中。这个作用域的的范围是最大的,只要容器没有停止,它就会一直存在。三种作用域:结合前面所学的作用域,那么一共有三个,分别是:请求作用域,会话作用域,上下文作用域。范围从小到大来划分:请求作用域<会话作用域<上下文作用域

12、过滤器

过滤器可以在请求到达Servlet之前和Servlet响应客户端之前进行拦截,相当于一个拦截器,主要用于进行一些请求和响应的预处理操作。常用的场景有权限的控制、统一字符编码等等。
图片描述

12.1 编写过滤器

要实现一个过滤器,必须实现一个Filter接口,只有实现了这个接口的类才称之为过滤器。示例代码


public class DemoFilter implements Filter{
    ...
}

web.xml配置过滤器:


<filter>
        <filter-name>demoFilter</filter-name>
        <filter-class>edu.nf.ch09.filter.DemoFilter</filter-class>
        <!-- 初始化参数 -->
        <init-param>
            <param-name>param</param-name>
            <param-value>hello</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>demoFilter</filter-name>
        <!-- 什么请求可以经过此过滤器,/*表示所有请求 -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>

12.2 过滤器的生命周期

与Servlet类似,Filter同样也是有容器负责创建和销毁,与Servlet的区别在于,容器会在启动的时候最先创建所有的过滤器,并执行init方法进行初始化。生命周期方法:
|方法|说明|
|----|----|
|init|初始化方法,容器启动时执行一次|
|doFilter|请求过滤方法,决定请求是否放行|
|destroy|容器销毁过滤器之前执行的方法|

示例代码:


public class DemoFilter implements Filter{
​
    @Override
    public void destroy() {
        
        System.out.println("准备销毁DemoFilter");
    }
​
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        //FilterChain表示一个过滤链对象,因为过滤器可能会存在多个
        //同时这个对象将决定是否放行当前请求,
        //放行的话则请求会继续到达下一个过滤器或者servlet中
        System.out.println("请求经过DemoFileer..放行");
        chain.doFilter(request, response);
        System.out.println("响应前经过DemoFilter...");
    }
​
    @Override
    public void init(FilterConfig config) throws ServletException {
        String name = config.getInitParameter("param");
        System.out.println("初始化DemoFilter,获取初始化参数:"+name);
    }
​
}

12.3 过滤链

在一个web项目中可能存在多个过滤器,当有多个过滤器存在的时候就会形成一个过滤链。请求会按照过滤器链的顺序一直传递下去,最终到达某个Servlet来处理请求。(注意:过滤链的顺序是按照web.xml中的先后配置顺序决定的)配置示例:


<!-- 按先后顺序配置 -->
    <!-- 配置第一个过滤器 -->
    <filter>
        <filter-name>firstFilter</filter-name>
        <filter-class>edu.nf.ch09.filter.FirstFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>firstFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!-- 配置第二个过滤器 -->
    <filter>
        <filter-name>secondFilter</filter-name>
        <filter-class>edu.nf.ch09.filter.SecondFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>secondFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

13、监听器

监听器用于监听对象的上的事件发生,在Servlet中监听器主要监听请求对象、会话对象、上下文对象以及监听这些对象的作用操作。JavaEE为我们提供了一系列的监听器接口,开发时按需实现响应的接口即可。

13.1 监听作用域对象的创建于销毁

监听器说明
ServletRequestListener监听请求对象的创建和销毁
HttpSessionListener监听会话对象的创建和销毁
ServletContextListener监听Servlet上下文对象的创建和销毁

代码实例:1.请求对象监听器


public class DemoRequestListener implements ServletRequestListener{
​
    /**
     * 当请求对象销毁后容器执行此方法
     * 销毁方法中同样也有一个ServletRequestEvent事件对象
     */
    @Override
    public void requestDestroyed(ServletRequestEvent event) {
        //通过这个事件对象就可以获取当前的请求对象
        HttpServletRequest request = (HttpServletRequest)event.getServletRequest();
        System.out.println("销毁请求对象..."+request);
    }
​
    /**
     * 当请求对象创建之后容器调用此方法
     * ServletRequestEvent这个参数就是一个事件对象
     */
    @Override
    public void requestInitialized(ServletRequestEvent event) {
        //通过这个事件对象就可以获取当前的请求对象
        HttpServletRequest request = (HttpServletRequest)event.getServletRequest();
        System.out.println("初始化了请求对象..."+request);
    }
​
}

web.xml 配置


<!-- 配置监听器 -->
  <listener>
    <!-- 指定监听器的完整类名 -->
    <listener-class>edu.nf.ch10.listener.DemoRequestListener</listener-class>
  </listener>

2.会话对象监听器


public class DemoSessionListener implements HttpSessionListener{
​
    /**
     * 监听HttpSession对象的创建
     * HttpSessionEvent参数是一个事件对象
     * 通过它可以获得当前的HttpSession
     */
    @Override
    public void sessionCreated(HttpSessionEvent event) {
        HttpSession session = event.getSession();
        System.out.println("创建了Session对象"+session);
    }
​
    /**
     * 监听HttpSession对象的销毁
     */
    @Override
    public void sessionDestroyed(HttpSessionEvent event) {
        HttpSession session = event.getSession();
        System.out.println("销毁了Session对象"+session);
    }
}

注意:当第一次调用了request.getSession()方法创建Session时,监听器才会起作用。web.xml配置


<listener>
    <!-- 指定监听器的完整类名 -->
    <listener-class>edu.nf.ch10.listener.DemoSessionListener</listener-class>
  </listener>

3.Servlet上下文监听器


public class DemoContextListener implements ServletContextListener{
​
    /**
     * 监听ServletContext的销毁
     */
    @Override
    public void contextDestroyed(ServletContextEvent event) {
        //通过事件对象获取ServletContext
        ServletContext sc = event.getServletContext();
        System.out.println("销毁了ServletContext对象..."+sc);
    }
​
    /**
     * 监听SerlvetContext的创建
     */
    @Override
    public void contextInitialized(ServletContextEvent event) {
        //通过事件对象获取ServletContext
        ServletContext sc = event.getServletContext();
        System.out.println("创建了ServletContext对象..."+sc);
    }
}

web.xml


 
<listener>
    <!-- 指定监听器的完整类名 -->
    <listener-class>edu.nf.ch10.listener.DemoContextListener</listener-class>
  </listener>

13.2 监听作用域的操作

监听器说明
ServletRequestAttributeListener监听请求作用域的操作
HttpSessionAttributeListener监听会话作用域的操作
ServletContextAttributeListener监听Servlet上下文作用域的操作

示例代码:这里以HttpSessionAttributeListener说明,其他作用域监听器用法相似。


public class DemoSessionAttributeListener implements HttpSessionAttributeListener{
​
    /**
     * 当有数据添加到会话作用域时,执行此方法
     */
    @Override
    public void attributeAdded(HttpSessionBindingEvent event) {
        //获取存入作用域的键和值
        System.out.println("存入会话作用域..."+event.getName() + " : " + event.getValue());
        
    }
​
    /**
     * 当从会话作用域移除数据时,执行此方法
     */
    @Override
    public void attributeRemoved(HttpSessionBindingEvent event) {
        System.out.println("移除会话作用域..."+event.getName() + " : " + event.getValue());
        
    }
​
    /**
     * 当替换了会话作用域中的某个数据时,执行此方法
     */
    @Override
    public void attributeReplaced(HttpSessionBindingEvent event) {
        HttpSession session = event.getSession();
        System.out.println("替换的值: "+session.getAttribute("userName").toString());
        //注意:这里event.getValue()获取到的是被替换的值
        System.out.println("替换会话作用域..."+event.getName() + " : " + event.getValue());
    }
}

web.xml


<listener>
    <!-- 指定监听器的完整类名 -->
    <listener-class>edu.nf.ch10.listener.DemoSessionAttributeListener</listener-class>
  </listener>

14、注解配置

Servlet3.0开始提供了一系列的注解来配置Servlet、Filter、Listener等等。这种方式可以极大的简化在开发中大量的xml的配置。从这个版本开始,web.xml可以不再需要,使用相关的注解同样可以完成相应的配置。
|注解|说明|
|----|----|
|@WebServlet|这个注解标识在类上,用于配置Servlet。例如:@WebServlet(name="hello",urlPatterns="/hello")也可以简化配置@WebServlet("/hello")|
|@WebFilter|这个注解标识在类上,用于配置Filter。例如:@WebFilter(filterName="encode",urlPatterns="/")也可以简化配置@WebFilter("/")|
|@WebListener|这个注解标识在类上,用于配置监听器|

五、JSP基础

1、简介

JSP全名为Java Server Pages,中文名叫java服务器页面,是一种动态页面技术,而HTML是属于静态页面JSP可以在HTML中嵌入java脚本代码,因为JSP本质上还是一个Servlet,因此JSP也必须依赖于web容器才能运行。JSP的出现并不是为了取代Servlet,而是简化了Servlet的工作,将Servlet中繁琐的视图呈现代码脱离出来,交给JSP来完成,让Servlet专注于请求的处理,所以在开发中通常将JSP和Servlet结合一起使用。

2、JSP引擎

由于JSP本质上就是一个Servlet,那么JSP引擎主要负责将JSP文件转义成一个Servlet的java源文件,然后再通过javac将这个源文件,编译成class字节码文件并装载到JVM中执行。JSP引擎的核心类是JSPServlet,位于Jasper.jar文件中,并且在Tomcat的web.xml中也默认就配置好了这个类(JspServlet也是一个Servlet)。因此,凡是以".jsp"结尾的请求都会先经过JspServlet,那么这个引擎就可以开始工作。通常引擎转义和编译后的文件放在容器的work工作目录中。
图片描述
注意:如果第一次访问Jsp文件的时候,由于work目录中并不存在源文件和字节码文件,JSP引擎就必须完成这两个工作,因此,有可能在第一次访问JSP时会比较缓慢。当字节码编译出来加载后,第二次访问时速度就会很快了。

3、JSP的三大元素

3.1 指令元素

语法:<%@ %>
|指令|说明|
|----|----|
|page指令|用于设置JSP页面的相关信息以及编码|
|include指令|用于静态包含其他的JSP页面代码,所谓静态包含,就是在编译期,将另外的JSP页面的代码合并到当前的JSP中,最终只会产生一个java源文件|
|taglib|这个指令用于引入标签库|

3.2 动作元素

语法:< jsp:xxx >
|动作|说明|
|----|----|
|include|动态包含其他JSP页面的内容,所谓的动态包括是指在编译期将不同的JSP文件转义成不同java源文件,然后在运行时在将目标内容包含到当前的JSP页面中|
|forward|相当于Servlet中的转发,转发到其他的JSP页面或者Servlet|
|param|用于传递参数,通常结合其他的动作一起使用,例如转发时需要提交一些额外的参数|
|useBean|用于在JSP页面中使用JavaBean对象,通常结合setProperty和getProperty来使用,完成bean对象的赋值和取值操作|

3.3 脚本元素

脚本元素主要就是在JSP中嵌入java脚本代码,包括声明、表达式、java脚本声明语法:<%! %>表达式:<%= %>java脚本:<% %>示例代码:


<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
   <%-- 声明变量和方法,这里声明的变量a是实例变量 --%>
   <%! 
        int a = 10;
        public void say(){
            System.out.println("hello");
        }
    %>
    
    <%-- 表达式,注意:表达式后面是不允许有;号结束的 --%>
 + 1 = <%=3+1%>
<%-- Java脚本,脚本代码最终会生成在servlet中的service方法中作为代码片段 --%> <table border="1"> <tr> <th>Name</th> <th>Age</th> </tr> <% for(int i=0;i<5;i++){%> <tr> <td>user<%=i%></td> <td><%=10+i%></td> </tr> <%}%> </table> </body> </html>

4、JSP内置对象

内置对象,是在容器运行时将创建好的9个对象内嵌在JSP中,在JSP里可以直接拿来使用的对象。
|对象|说明|
|----|----|
|out|字符流输出对象|
|config|等同于Servlet中的ServletConfig|
|page|表示当前JSP页面,类似于Java类中的this关键字|
|request|等同于 Servlet中的HTTPServletRequest|
|response|等同于 Servlet中的HTTPServletResponse|
|session|等同于Servlet中的HTTPSession|
|application|等同于Servlet中的Servlet|
|pageContext|表示当前JSP页面的上下文对象|
|exception|表示当前JSP中的异常对象|

示例代码:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
  <%-- 常用内置对象 --%>
  <%
     //使用request,API使用同HttpServletRequest一样
     request.getParameter("userName");
     request.setAttribute("user", "user1");
     request.getAttribute("user");
     
     //使用session,API使用等同于HttpSession
     session.setAttribute("user", "user2");
     session.getAttribute("user");
     session.getId();
     
     //使用response
     //response.sendRedirect("demo.jsp");
     
     //out对象,等同于字符输出流对象,在JSP页面输出相关内容
     out.println("hello world");
     //这个是输出在控制中
     System.out.println("hello");
     
     //使用application,等同于ServletContext
     application.setAttribute("userName", "user3");
     
     //pageContext使用
     //从pageContext中获取相关的其他对象
     HttpServletRequest req = (HttpServletRequest)pageContext.getRequest();
     HttpServletResponse res = (HttpServletResponse)pageContext.getResponse();
     HttpSession ses = pageContext.getSession();
     ServletConfig conf = pageContext.getServletConfig();
     ServletContext sc = pageContext.getServletContext();
     //也可以通过pageContext来统一设置不同的作用域
     //第三个参数表示要放入到哪个作用域,是一个int类型的参数
     //1代表page作用域(当前页面有效)PageContext.APPLICATION_SCONPE
     //2代表请求作用域 PageContext.SESSION_SCOPE
     //3代表会话作用域 PageContext.REQUEST_SCOPE
     //4代表上下文作用域 PageContext.PAGE_SCOPE
     pageContext.setAttribute("userName", "zhangsan", 2);
     //也可以指定中哪个作用域取出相应的值
     String name = (String)pageContext.getAttribute("userName", 2);
     out.println(name);
  %>
</body>
</html>

5、EL表达式

EL(Expression Language),全球叫做表达式语言,是JSP2.0推出的一种技术。主要简化了在JSP中使用Java脚本表达式。EL表达式的特点在于使用简单,支持四则运算、逻辑运算等,并且还可以对Servlet API中的对象进行数据访问。EL的语法:$运算:
|示例|结果|
|----|----|
|${1+1}|2|
|${2*2}|4|
|${1==1}|true|
|${2>5}|false|
|${"10"==10}|true|
|其他|...|

数据访问:1.使用“.”来访问
|示例|说明|
|----|----|
|${param.参数名}|获取请求参数的值,相当于使用request.getParameter()方法|
|$
|从请求作用域中访问数据|
|$
|从会话作用域中访问数据|
|$
|从上下文作用域中访问数据|
|$
|不指定作用域范围时,默认按照作用域范围从小到大的顺序自动查找|
|其他|...|

示例代码:


姓名:${param.userName}
<%-- 访问请求作用域 --%> 请求作用域:${requestScope.userName}
会话作用域: ${sessionScope.userName}
上下文作用域: ${applicationScope.userName}
自动从作用域中取值: ${userName}
<h2>访问对象中的属性</h2> Name:${userName}
Age:${age}

2.使用"[]"来访问
|示例|说明|
|----|----|
|${requestScope[“userName”]}|从请求作用域中取值|
|${sessionScope[“userName”]}|从会话作用域取值|
|其他...|同上|

示例代码:

<h2>使用"[]"来访问数据</h2>
<!-- 可以获取使用带.的参数名称-->
   请求作用域:${requestScope["user.userName"]}
会话作用域: ${sessionScope["user.userName"]}
上下文作用域: ${applicationScope["user.userName"]}

注意:通常使用"[]"来访问数据的时候,主要是访问一些特殊的名称,例如:request.setAttribute("user.userName")这种方式如果使用$是访问不到的,应该改为${requestScope["user.userName"]}来访问

6、JSTL核心标签库

JSTL是JSP中的标准标签库,主要用于取代JSP中大量的Java脚本代码,让页面看起来更趋向于HTML。使用也很简单,通常结合EL表达式一起使用示例:
|核心标签库(core)|说明|
|----|----|
|c:out|输出标签|
|c:set|声明某个变量并存入指定的作用域|
|c:redirect|重定向标签|
|c:if|条件判断|
|c:forEach|循环标签|
|其他|...|

备注:其他标签库请参阅相关官方文档代码示例:


<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>   
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSTL</title>
</head>
<body>
  <%
    out.println("hello JSTL");
  %>
  <!-- 使用输出标签替换上面的脚本 -->
  <c:out value="hello JSTL"></c:out>
  
  <%
    session.setAttribute("userName", "wangl");
  %>
  <!-- 使用set标签替换上面的脚本,var指定变量名,value指定值,scope指定要放入的作用域 -->
  <c:set var="userName" value="wangl" scope="session"></c:set>
  <!-- 重定向标签 -->
  <%--<c:redirect url="demo.jsp"/>--%>
  
  <!-- 使用条件判断 -->
  <c:set var="age" value="70"/>
  <c:if test="${age<=18}">
    <h2>很年轻</h2>
  </c:if>
  <c:if test="${age>18 &amp;&amp; age<50}">
    <h2>还好</h2>
  </c:if>
  <c:if test="${age>60}">
    <h2>老了</h2>
  </c:if>
</body>
</html>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>       
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
  <!-- 声明变量i,起始为0, 到10结束 -->
  <%-- 
  <c:forEach var="i" begin="0" end="10">
     ${i}
</c:forEach> --%> <table border="1"> <tr> <th>姓名</th> <th>年龄</th> <th>性别</th> <th>籍贯</th> <th>班级</th> </tr> <!-- list中存放的map “List<Map<String,Object>>”--> <%-- <c:forEach items="${list}" var="m"> <tr> <td>${m.s_name}</td> <td>${m.s_age}</td> <td>${m.s_sex}</td> <td>${m.origin}</td> <td>${m.c_name}</td> </tr> </c:forEach> --%> <!-- list中放的是Object[] “List<Object[]>” --> <c:forEach items="${requestScope.list}" var="o"> <tr> <td>${o[0]}</td> <td>${o[1]}</td> <td>${o[2]}</td> <td>${o[3]}</td> <td>${o[4]}</td> </tr> </c:forEach> </table> </body> </html>