尚硅谷课程：293-尚硅谷-Filter-什么是Filter过滤器_哔哩哔哩_bilibili

JavaWeb核心技术点：

Servlet程序、Filter过滤器、Listener监听器、jsp页面、EL表达式、JSTL标签库、jQuery框架、Cookie技术、Session会话、JSON使用、Ajax请求，

第一章、基本概念

1、B/S、C/S、RIA、

2、Web Site

也称为Web 网站,例如:某公司用来宣传的网站就是Web站点,用户浏览公司的信息,该站点不提供服务.属于静态站点.

3、 Web Application

就是通过浏览器访问的应用程序,为用户提供相关的服务,属于动态网站.例如:京东,淘宝,天猫

4、HTTP服务器：

1．定义：Web服务器,提供网上信息浏览服务

2．例子: apache nginx IIS

3．特点：使用浏览器访问web站点或者web应用,必须通过HTTP服务器.
5、Web应用服务器：

1．定义：能够运行服务器上的应用程序,并将结果返回给客户端浏览器的软件.

2．例子：Tomcat就是Web应用服务器

3．特点：兼具HTTP服务器的部分功能.

6、Request & Response

第二章、Selvet

0、Servlet是什么

宽泛讲，Servlet是用java编写的服务器端程序。

类比JDBC是后端连接数据库的规范，servlet是接收http请求的规范。

从广义上讲：

Servlet 规范是 Sun 公司制定的一套技术标准，包含与 Web 应用相关的一系列接口，是 Web 应用实现方式的宏观解决方案。而具体的 Servlet 容器负责提供标准的实现。

从狭义上讲：

查看javax包下的Servlet，servlet就是javax.servlet.Servlet接口。（包含五个方法）也可指实现了Servlet 接口的实现类。

servlet就是一个普通的类，Servlet的特殊作用就是用来在javaweb项目中，接受http请求的。

package javax.servlet;

import java.io.IOException;

public interface Servlet {
    // 初始化方法
    void init(ServletConfig var1) throws ServletException;
   // 包含一个ServletConfig
    ServletConfig getServletConfig();
    // 运行方法
    void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

    String getServletInfo();

    void destroy();
}

Servlet就是javaweb的规范，是给servlet容器的规范。它规定了：

Servlet容器遇到实现了Servlet接口的class文件，就必须加载它。
Servlet容器要创建一个ServletConfig对象。这个对象中，包含了servlet的初始化配置信息。

package javax.servlet;
import java.util.Enumeration;
public interface ServletConfig {
    String getServletName();  //的到对应的servlet的名字。
    ServletContext getServletContext();   //得到servletContext
    String getInitParameter(String var1);
    Enumeration<String> getInitParameterNames();
}


<servlet>
    <servlet-name>springMvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>  //指的就是这些信息
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring/springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

Servlet容器创建一个servlet对象，并且调用其中的init方法进行初始化。

Servlet容器接收到一个请求的时候，要针对这个请求，创建ServletRequest 和 ServletResponse 对象，并把它作为参数传给指定的servlet的service方法。

当web应用被终止时，servlet会先调用servlet对象的destroy方法，然后再销毁servlet对象。

1、Servlet容器是什么

什么是Servlet容器呢？就是javaweb服务器。如Tomcat，netty等

说是容器，本质上就是程序。Tomcat也就是一个服务器程序。服务器本质就是一台计算机，正是因为安装了Tomcat服务器程序被叫做服务器。不然就是一台裸机。

作用：Servlet 容器创建Servlet 对象，调用生命周期方法。

2、Servlet容器和Servlet的关系

Servlet是一个Java程序，一个Servlet应用有一个或多个Servlet程序。JSP页面会被转换和编译成Servlet程序。Servlet应用无法独立运行，必须运行在Servlet容器中。Servlet容器将用户的请求传递给Servlet应用，并将结果返回给用户。

3、Servlet继承体系

1、Servlet层次体系

2、Servlet接口

3、GenericServlet 抽象类

4、HttpServlet 抽象类

（1）HttpServlet 继承了 GenericServlet，并实现了 service 方法。在 service 方法中，将 ServletRequest 和 ServletResponse 强制转换为了 HttpServletRequest 和 HttpServletResponse，因为后俩者才有getmethod()方法，用来专门处理我们的 Http 请求。

（2）Servlet(ServletRequest, ServletResponse) 方法在完成对请求和响应的强转之后调用了方法，在被调用的方法中对请求类型进行了判断，各种请求调用自己相应的 doXXX 方法。而我们常用的就是 doGet() 和 doPost() 方法。

（3）在我们以后的使用中，都使用继承 HttpServlet 的方式，重写 doGet 和 doPost 方法即可。
在浏览器发送请求的时候，如果是 get 请求，将会调用 doGet()方法，如果是 post 请求，将会调用 doPost()方法。
（4）继承 HttpServlet 的新的 Servlet 写法如下(web.xml 配置与之前相同)

public class FirstServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
		public FirstServlet() {
		super();
	}
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("doGet()......");
	}
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("doPost()......");
	}
}

4、Servlet生命周期

生命周期：对象在容器中从开始创建到销毁的过程。（也就是从创建到销毁调用了几个方法。）

详细过程如下：

1、Servlet 对象的创建

默认情况下，Servlet 容器第一次收到 HTTP 请求时创建对应 Servlet 对象。容器之所以能做到这一点是由于我们在注册 Servlet 时提供了全类名，容器使用反射技术创建了Servlet的对象。

2、Servlet 对象初始化

1）Servlet 容器创建 Servlet 对象之后，会调用 init(ServletConfig config) 方法，对其进行初始化。在 javax.servlet.Servlet 接口中，public void init(ServletConfig config) 方法要求容器将 ServletConfig 的实例对象传入，这也是我们获取 ServletConfig 的实例对象的根本方法。

2）为了简化开发，GenericServlet 抽象类中实现了 init(ServletConfig config)方法，将 init(ServletConfig config)方法获取到的 ServletConfig 对象赋值给了成员变量 ServletConfig config，目的是使其它方法可以共享这个对象。这时有一个问题：如果子类重写了这个init(ServletConfig config)方法，有可能会导致成员变量 config 对象赋值失败。所以 GenericServlet抽象类另外提供了一个无参的public void init()方法，并在init(ServletConfig config)方法中调用，作为子类进行初始化操作时重写使用。而这个无参的 init()方法之所以没有设计成抽象方法，是为了避免子类继承时强制实现这个方法带来的麻烦，使用者可以根据需要选择是否要覆盖这个方法。

3、处理请求

1）在 javax.servlet.Servlet 接口中，定义了 service(ServletRequest req, ServletResponse res) 方法处理 HTTP 请求，同时要求容器将ServletRequest 对象和 ServletResponse 对象传入。

2）在 HttpServlet 抽象类中，service(ServletRequest req, ServletResponse res)方法将 ServletRequest 对象和 ServletResponse 对象强转为了 HttpServletRequest 、HttpServletResponse子类对象，这样更适合于HTTP请求的处理，所以在 doGet() 和 doPost() 方法中使用的就是 HttpServletRequest、HttpServletResponse 的实现类对象了。

4、 Servlet 对象销毁

Web 应用卸载或服务器执行停止时会销毁 Servlet 对象，而销毁之前为了执行一些诸如释放缓存、关闭连接、保存数据等操作，所以设计了 public void destroy()方法。

5、ServletConfig 接口

每一个Servlet对应一个 ServletConfig接口，得到的配置信息与web.xml中的是一一对应的！

那么本Servlet不可以获取到其他Servlet的配置信息！

封装了 Servlet 配置信息。但同时，代表当前 Web 应用的 ServletContext 对象也封装到了 ServletConfig 对象中，使 ServletConfig 对象成为了获取ServletContext 对象的一座桥梁。

获取Servlet 初始化参数：

在web.xml中配置初始化参数

<servlet>
<!--        servlet-name标签给servlet程序起一个别名-->
        <servlet-name>HelloServlet</servlet-name>
<!--        servlet-class为servlet程序的全类名-->
        <servlet-class>com.itheima.servlettest01.HelloServlet</servlet-class>
        <init-param>
            <param-name>username</param-name>
            <param-value>root</param-value>
        </init-param>
        <init-param>
            <param-name>url</param-name>
            <param-value>jdbc:mysql://localhost:3306/test</param-value>
        </init-param>
    </servlet>

在init()方法中使用ServletConfig的对象调用方法获取参数

public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("2、初始化方法执行--初始化servlet对象");
        System.out.println("HelloServlet程序的别名是：" + servletConfig.getServletName());
        System.out.println("初始化参数username的值是" + servletConfig.getInitParameter("username"));
        System.out.println("初始化参数url的值是" + servletConfig.getInitParameter("url"));
    }

获取 ServletContext 对象

System.out.println("servlet-context对象" + servletConfig.getServletContext());

得到结果：

servlet-context对象org.apache.catalina.core.ApplicationContextFacade@662a11a6

对比一下ServletContext与ServletConfig的范围：

一个Web工程对应一个ServletContext；

一个Web工程下有多个Servlet，每个Servlet对应一个ServletConfig配置类

6、ServletContext 接口

（1）web 容器在启动时，他会为每个 web 应用都创建一个对应的 ServletContext 对象。注意：一个web应用对应的是一个ServletContext对象。

（2）一个 web 应用程序的所有 Servlet 都共享的是同一个 ServletContext 对象，所以 ServletContext 对象也被称为 application 对象（web 应用程序对象）

ServletContext context = getServletConfig().getServletContext();

直接将在同一个web工程下不同Servlet获取到的Context对象打印得到的地址是一样的！

org.apache.catalina.core.ApplicationContextFacade@33ea6abc

得到的最终地址格式如上：

注意：

init-param是Servlet内部的初始化参数，只能由servletConfig.getInitParameter（）得到；

context-param是整个web工程的参数，只能由getServletConfig().getServletContext().getInitParameter（）得到

<!-- Web应用初始化参数 -->
    <context-param>
        <param-name>username</param-name>
        <param-value>context</param-value>
    </context-param>
    <context-param>
        <param-name>password</param-name>
        <param-value>root</param-value>
    </context-param>

获取 Web 应用初始化参数

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,IOException {
	//1.获取ServletContext对象
    ServletContext context = getServletConfig().getServletContext();
	//2.获取Web应用初始化参数
	String paramValue = context.getInitParameter("ParamName");
	System.out.println("paramValue="+paramValue);
}

servletcontext常用方法：

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        ServletContext context = getServletConfig().getServletContext();
        String username = context.getInitParameter("username");
        System.out.println("context-param参数username的值是" + username);
        System.out.println("context-param参数password的值是" + getServletConfig().getServletContext().getInitParameter("password"));
        System.out.println("当前工程路径：" + context.getContextPath());

//        / 斜杠被服务器解析为http://ip:port/工程名/  映射到IDEA代码的web目录
        System.out.println("工程部署的绝对路径：" + context.getRealPath("/"));
        System.out.println("a.html的绝对路径" + context.getRealPath("/a.html"));
    }

存取数据

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        ServletContext context = getServletContext();
        context.setAttribute("key1","value1");
        context.setAttribute("key2","value2");
        System.out.println("Context1中获取到的key1的值是：" + context.getAttribute("key1"));
        System.out.println("Context1中获取到的key2的值是：" + context.getAttribute("key2"));
        System.out.println("===========" + context);
    }

7、HttpServletRequest 接口

该接口是 ServletRequest 接口的子接口，封装了 HTTP 请求的相关信息，由 Servlet 容器创建其实现类对象并传入 service(ServletRequest req, ServletResponse res)方法中。我们请求的详细信息都可以通过 HttpServletRequest 接口的实现类对象获取。这个实现类对象一般都是容器创建的，我们不需要管理。

*获取URI与URL

URI -->/servletTest02_war/req
URL -->http://localhost:8080/servletTest02_war/req

*获取请求参数。（请求参数就是浏览器向服务器提交的数据）

浏览器向服务器如何发送数据俩方式：

附在 url 后面，如：http://localhost:8989/MyServlet/MyHttpServlet?userId=20
通过表单提交

使用HttpServletRequest对象获取请求参数

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	// 一个name 对应一个值
	String userId = request.getParameter("userId");
	System.out.println("userId="+userId);
}

protected void doPost(HttpServletRequest request, HttpServletResponse response) throwsServletException, IOException {
	// 一个name 对应一组值
	String[] soccerTeams = request.getParameterValues("soccerTeam");
	for(int i = 0; i < soccerTeams.length; i++){
	System.out.println("team "+i+"="+soccerTeams[i]);
}

表单提交

在表单中要指定提交到的URL

<form action="http://localhost:8080/servletTest02_war/reqP" method="get">
      用户名：<input type = "text" name="username"></br>
      密码：<input type = "text" name="password"></br>
      兴趣爱好：<input type = "checkbox" name = "hobby" value = "cpp">C++
      <input type = "checkbox" name = "hobby" value = "java">Java
      <input type = "checkbox" name = "hobby" value = "js">JavaScript</br>
      <input type = "submit">
  </form>

*在请求域中保存数据。

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	//将数据保存到request对象的属性域中
	request.setAttribute("attrName", "attrValueInRequest");
	//两个Servlet要想共享request对象中的数据，必须是转发的关系
	request.getRequestDispatcher("/ReceiveServlet").forward(request, response);
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	//从request属性域中获取数据
	Object attribute = request.getAttribute("attrName");
	System.out.println("attrValue="+attribute);
}

*post请求中文乱码问题

//       解决post请求方法中文乱码问题；设置请求体的字符集UTF-8
        req.setCharacterEncoding("UTF-8");

8、HttpServletResponse 接口

HttpServletResponse 是 ServletResponse 接口的子接口，封装了 HTTP 响应的相关信息，由Servlet 容器创建其实现类对象并传入 service(ServletRequest req, ServletResponse res) 方法中。

功能一：使用 PrintWriter 对象向浏览器输出数据。

//通过PrintWriter对象向浏览器端发送响应信息
PrintWriter writer = res.getWriter();
writer.write("Servlet response");
writer.close();

功能二：实现请求重定向

9、Servlet API

包含4个Java包：

（1）javax.servlet 其中包含定义servlet和servlet容器之间契约的类和接口。

（2）javax.servlet.http 其中包含定义HTTP Servlet 和Servlet容器之间的关系。

（3）javax.servlet.annotation 其中包含标注servlet，Filter,Listener的标注。它还为被标注元件定义元数据。

（4）javax.servlet.descriptor，其中包含提供程序化登录Web应用程序的配置信息的类型。

10、Servlet程序实例与详细分析

也就是实现servlet接口

1、具体业务类实现servlet接口

public class HelloServlet implements Servlet {}

2、实现service方法

public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
         System.out.println("实现了处理请求和响应");
    }

3、web.xml文件配置servlet程序的实际地址（全类名）与虚拟地址（URL）

<!--    配置实际地址-->
<!--    servlet标签给Tomcat配置servlet程序-->
    <servlet>
<!--        servlet-name标签给servlet程序起一个别名-->
        <servlet-name>HelloServlet</servlet-name>
<!--        servlet-class为servlet程序的全类名-->
        <servlet-class>com.itheima.servlettest01.HelloServlet</servlet-class>
    </servlet>

<!--    实际地址与实际地址联系的桥梁就是servlet程序的别名-->

<!--    配置虚拟地址-->
<!--    servlet-mapping标签给servlet程序配置访问地址-->
    <servlet-mapping>
        <!--        此处servlet-name标签作用是告诉服务器我当前配置的地址给那个servlet程序使用-->
        <servlet-name>HelloServlet</servlet-name>
<!--        url-pattern标签配置访问地址
            / 斜杠在服务器解析的时候表示地址为： http://ip:port/工程路径
            最终完整的地址为： http://ip:port/工程路径/hello
-->
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

IDEA配置Tomcat服务器插件

自定义服务器名、选择Tomcat版本（不要最新！）

《创建工程路径》

**通过url找到具体的service方法的寻径过程**

**GET与POST请求的分发处理**

//        servlet只有一个service方法，那我怎么怎么针对不同的请求方法做出不同的处理呢？

//         类型强转 （因为ServletRequest的子接口HttpServletRequest有getmethod()方法）
    HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
    String method = httpServletRequest.getMethod();
    if("GET".equals(method)){
        doGet();
    }
    else if ("POST".equals(method)){
        doPost();
    }
    }
    public void doGet(){
        System.out.println("get请求");
    }
    public void doPost(){
        System.out.println("post请求");
    }

**继承HttpServlet实现Servlet程序**


public class HelloServlet2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("HttpServlet2的get请求方法");
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("HttpServlet2的POST请求方法");
    }
}

**IDEA菜单生成Servlet程序**

配置Servlet信息

则会自动生成Servlet类继承HttpServlet 以及类下的doGet、doPost方法

web.xml中也会自动写好实际地址，手动写一下servlet-mapping虚拟地址就ok。

第三章、会话

1、会话概念与作用

会话：浏览器和服务器之间的一次连续的通讯过程叫做会话.

会话跟踪技术作用：

1.能够跟踪客户端与服务器端的交互，

2.保存和记忆相关的信息，

3.保存请求的状态信息。

4.解决HTTP协议的无状态的弊端

四大类会话跟踪技术：

1.URL方式：需要保存的信息直接追加到URL后，例如：http://127.0.0.1:8080/chapter03/viewList?pageNo=12

2.隐藏域方式：可以使用表单中的隐藏域保存相关信息，例如： <input type=“hidden” name=“status" value=“true">

3.Cookie方式：将状态信息保存到客户端，服务器能够获得相关信息进行分析，从而生成对客户端的响应；例如简化登录功能就可以使用Cookie实现；

4.Session方式：将状态信息保存到服务器的会话对象中，通过唯一标记的ID值与客户端进行绑定使用；例如访问控制功能就可以使用Session实现.

2、Cookie原理与基本操作

（1）浏览器端第一次发送请求到服务器端
（2）服务器端创建Cookie，该Cookie中包含用户的信息，然后将该Cookie发送到浏览器端
（3）浏览器端再次访问服务器端时会携带服务器端创建的Cookie
（4）服务器端通过Cookie中携带的数据区分不同的用户

1、服务器创建cookie并发送给浏览器

一般是前端页面点击后转到后端的方法，执行创建cookie，并返回。

protected void createCookie(HttpServletRequest request, HttpServletResponse response) throws IOException {
//        1、创建cookie对象
        Cookie cookie = new Cookie("key1","value1");
        Cookie cookie2 = new Cookie("key2","value2");
//        2、通知客户端保存cookie
        response.addCookie(cookie);
        response.addCookie(cookie2);
        response.getWriter().write("cookie创建成功");
    }

2、服务器获取cookie识别会话

 protected void getCookie(HttpServletRequest request, HttpServletResponse response) throws IOException {
//获取cookie数组
         Cookie cookies[] = request.getCookies();
//服务器将获取到的cookie返回给浏览器显示
         for (Cookie cookie:cookies) {
             response.getWriter().write("Cookie[" + cookie.getName() + " = " + cookie.getValue() + "] <br/>>");
         }
     }

3、修改cookie值

方案一：直接创建新的cookie对象键设为要修改的cookie对象的键再返回给浏览器。

方案二：使用setValue()方法

4、设置cookie生命时间

使用setMaxAge（）方法

5、cookie的path过滤属性

6、Cookie应用之免用户登录

登录表单：

<form action = "http://localhost:8080/13_cookie_session_war/loginServlet" method = "get">
        用户名：<input type = "text" name = "username" value = "${cookie.username.value}"> </br>
        密码：<input type = "password" name = "password" ></br>
        <input type = "submit" value = "登录">
    </form>

服务器判断用户名与密码--创建Cookie

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username = req.getParameter("username");
        String password = req.getParameter("password");

        if("wbj".equals(username) && "731290".equals(password)) {
            Cookie cookie = new Cookie("username",username);
            cookie.setMaxAge(60 * 60 * 24 * 7);
            resp.addCookie(cookie);
            System.out.println("登录成功");
        }else{
            System.out.println("登录失败");
        }
    }

3、Session原理与基本操作

（1）浏览器端第一次发送请求到服务器端，服务器端创建一个Session，同时会创建一个特殊的Cookie（name为JSESSIONID的固定值，value为session对象的ID），然后将该Cookie发送至浏览器端
（2）浏览器端发送第N（N>1）次请求到服务器端,浏览器端访问服务器端时就会携带该name为JSESSIONID的Cookie对象
（3）服务器端根据name为JSESSIONID的Cookie的value(sessionId),去查询Session对象，从而区分不同用户。
name为JSESSIONID的Cookie不存在（关闭或更换浏览器），返回1中重新去创建Session与特殊的Cookie
name为JSESSIONID的Cookie存在，根据value中的SessionId去寻找session对象
value为SessionId不存在**（Session对象默认存活30分钟）**，返回1中重新去创建Session与特殊的Cookie
value为SessionId存在，返回session对象

1、Session创建与获取id

protected void createOrGetSession(HttpServletRequest request, HttpServletResponse response) throws IOException {
        //创建和获取Session会话对象
        HttpSession session = (HttpSession)request.getSession();
        //判断当前的session会话是否是新创建的
        boolean isNew = session.isNew();
        //获取Session会话的唯一标识
        String id = session.getId();
        response.getWriter().write("得到的Session，id是：" + id + "</br>");
        response.getWriter().write("这个Session是否是新创建的：" + isNew + "</br>");
    }

2、获取session对象往域中存储数据

protected void setAttribute(HttpServletRequest request,HttpServletResponse response) throws IOException{
        request.getSession().setAttribute("key1","value2");
//        此处request.getSession()如果在请求的信息中得到session则直接用，没有则创建新的session
        response.getWriter().write("创建或获取对象成功并向域中存储数据");
    }
    protected void getAttribute(HttpServletRequest request,HttpServletResponse response) throws IOException{
        Object attribute = request.getSession().getAttribute("key1");
        response.getWriter().write("从Session中获取key1的数据是：" + attribute);
    }

3、获取默认生命时长

protected void defaultLife(HttpServletRequest request, HttpServletResponse response) throws IOException {
        int maxtime = request.getSession().getMaxInactiveInterval();
        response.getWriter().write("session默认最大时长:" + maxtime);
    }

4、修改默认超时时长（范围为整个web工程与具体某个session）

protected void life3(HttpServletRequest request, HttpServletResponse response) throws IOException {
//        获取session对象
        HttpSession session = request.getSession();
//        设置当前session3秒后超时
        session.setMaxInactiveInterval(3);
        response.getWriter().write("session已设置最大时长3秒超时");
    }

5、浏览器和session关联的技术内幕

session技术底层是基于Cookie技术实现的。

session是浏览器关闭或者超时会被销毁。

当浏览器第一次访问服务器，服务器创建session 与Cookie 对应着jsessionid， session对象存储在服务器内存中，Cookie响应给浏览器。当再次访问服务器，请求信心会携带Cookie的jsessionid，服务器会根据id寻找到对应的session。

如果浏览器删除了Cookie信息，则再次访问服务器，服务器中中session对象还未超时，但是无法根据Cookie信息中的id寻找到对应的session对象只能再次创建新的对象与Cookie。

4、cookie与session

共同点：cookie和session都是用来跟踪浏览器用户身份的会话方式。

对比：
(1)cookie数据存放在客户的浏览器上，session数据放在服务器上
(2)cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗,如果主要考虑到安全应当使用session
(3)session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能，如果主要考虑到减轻服务器性能方面，应当使用COOKIE
(4)单个cookie在客户端的限制是3K，就是说一个站点在客户端存放的COOKIE不能3K。
(5)所以：将登陆信息等重要信息存放为SESSION;其他信息如果需要保留，可以放在COOKIE中
大佬博客：JavaWeb（四）——Web会话（cookie、session）_java会话的作用_TaoTie830的博客-CSDN博客

第四章、JSP

1、前置知识：动态网页的执行原理

1.容器初始化Servlet实例，根据请求方法，调用相应的doXXX方法，并初始化请求和响应对象，作为doXXX方法的参数使用；

2.执行doXXX方法后，将响应对象中的数据流写到客户端；

3.客户端浏览器将收到的数据进行解析，显示给用户；

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        JspWriter
        // 通过响应的回传流回传html页面数据
        resp.setContentType("text/html; charset=UTF-8");
        PrintWriter writer = resp.getWriter();
        writer.write("<!DOCTYPE html>\r\n");
        writer.write("  <html lang=\"en\">\r\n");
        writer.write("  <head>\r\n");
        writer.write("      <meta charset=\"UTF-8\">\r\n");
        writer.write("      <title>Title</title>\r\n");
        writer.write("  </head>\r\n");
        writer.write(" <body>\r\n");
        writer.write("    这是html页面数据 \r\n");
        writer.write("  </body>\r\n");
        writer.write("</html>\r\n");
        writer.write("\r\n");
    }

jsp的特点

1.JSP运行在服务器端，本质是Servlet程序

2.JSP文件以.jsp为后缀，在工程目录中存在WebContent目录下

3.JSP文件可以直接在浏览器中访问

4.JSP文件中的内容就是 HTML+Java代码，静态部分使用HTML和文本即可，动态部分使用Java代码

2、jsp 的本质

jsp 页面本质上是一个 Servlet 程序。

其底层实现，也是通过输出流。把 html 页面数据回传给客户端

当我们第一次访问 jsp 页面的时候。 Tomcat 服务器会帮我们把 jsp 页面翻译成为一个 java 源文件。并且对它进行编译成为 .class 字节码程序。我们打开 java 源文件不难发现其里面的内容是：

我们跟踪原代码发现， HttpJspBase 类。它直接地继承了 HttpServlet 类。也就是说。 jsp 翻译出来的 java 类，它间接了继承了 HttpServlet 类。也就是说，翻译出来的是一个 Servlet 程序

JSP的执行过程是：翻译-编译-实例化-提供服务

3、jsp 头部的 page 指令

4、声明脚本(极少使用)

声明脚本的格式是： <%! 声明 java 代码 %>

作用：可以给 jsp 翻译出来的 java 类定义属性和方法甚至是静态代码块。内部类等

5、表达式脚本（常用）

表达式脚本的格式是： <%= 表达式 %>

表达式脚本的作用是：的 jsp 页面上输出数据。

表达式脚本的特点：

1、所有的表达式脚本都会被翻译到 _jspService() 方法中

2、表达式脚本都会被翻译成为 out.print() 输出到页面上

3、由于表达式脚本翻译的内容都在 _jspService() 方法中 , 所以 _jspService() 方法中的对象都可以直接使用。

4、表达式脚本中的表达式不能以分号结束。

5、代码脚本

代码脚本的格式是： <% java 语句 %>

代码脚本的作用是：可以在 jsp 页面中，编写我们自己需要的功能（写的是 java 语句）。

代码脚本的特点是：

1、代码脚本翻译之后都在 _jspService 方法中

2、代码脚本由于翻译到 _jspService() 方法中，所以在 _jspService() 方法中的现有对象都可以直接使用。

3、还可以由多个代码脚本块组合完成一个完整的 java 语句。

4、代码脚本还可以和表达式脚本一起组合使用，在 jsp 页面上输出数据

第五章、Listener监听器

1、Listener 介绍

1、 Listener 监听器它是 JavaWeb 的三大组件之一。 JavaWeb 的三大组件分别是： Servlet 程序、 Filter 过滤器、 Listener 监听器。

2、 Listener 它是 JavaEE 的规范，就是接口

3、监听器的作用是，监听某种事物的变化。然后通过回调函数，反馈给客户（程序）去做一些相应的处理。

2、ServletContextListener接口

ServletContextListener 它可以监听 ServletContext 对象的创建和销毁。

ServletContext 对象在 web 工程启动的时候创建，在 web 工程停止的时候销毁。

监听到创建和销毁之后都会分别调用 ServletContextListener 监听器的方法反馈。

public interface ServletContextListener extends EventListener {
    /*** 在 ServletContext 对象创建之后马上调用，做初始化 */ 
    public void contextInitialized(ServletContextEvent sce);
    /*** 在 ServletContext 对象销毁之后调用 */ 
    public void contextDestroyed(ServletContextEvent sce);
}

使用 ServletContextListener 监听器监听 ServletContext 对象。

使用步骤如下：

1 、编写一个类去实现 ServletContextListener

2 、实现其两个回调方法

3 、到 web.xml 中去配置监听器

监听器实现类

public class MyServletContextListenerImpl implements ServletContextListener { 
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("ServletContext 对象被创建了"); 
    }
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("ServletContext 对象被销毁了");
    } 
}

web.xml配置
<listener>
        <listenerclass>com.itheima.Servlet.MyServletContextListenerImpl</listener-class>
</listener>

第六章、

Web核心基础总结