java web----servlet
1、第一个servlet应用(可以直接创建maven项目，产生maven目录结构)
2、在来理解servlet概念
3、Servlet生命周期
4、Servlet使用
servlet过滤器
Servlet监听器
Tomcat启动的时候，需求：加载配置文件
cookie免登陆和session综合使用

导入jar包

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
</dependency>

创建一个类

注意：创建的包名：不能以java开头， package com.zy.servlet; package java.com.zy.servlet（会报错的）

package com.zy.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class ServletDemo extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("<h1>haha</h1>");
    }
}

补充

如果重写的是service方法，那么所有的请求都当成get请求来执行下面的代码，如果需要判断get、post方法，通过req.getMethod()

public class ServletDemo extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("<h1>hahaha</h1>");
    }
}

配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!--配置servlet-->
    <servlet>
    <!--配置servlet类路径,servlet-name任意,servlet-class是一开始创建的servlet类的路径-->
        <servlet-name>ServletDemo</servlet-name>
        <servlet-class>com.zy.servlet.ServletDemo</servlet-class>
    </servlet>
    <!--servlet-name必须和上面的名字一样,url-pattern配置访问的路由 localhost:8080/my-->
    <servlet-mapping>
        <servlet-name>ServletDemo</servlet-name>
        <url-pattern>/my</url-pattern>
    </servlet-mapping>
</web-app>

启动，浏览器访问：localhost:8080/my

补充：（web3.0）可以使用注解的方式，这样就不许用配置web.xml的请求路径了

@WebServlet("/haha") //注意格式:/url ,url前必须要有"/"
public class ServletDemo implements Servlet {}   //注意这个Servlet是一个接口，HttpServlet也是继承这个接口的

如果是项目部署的时候：在tomcat的webapps目录中创建一个project目录(或者直接使用ROOT目录)

将下面的文件方进去

进入tomcat的bin目录，双击startup.bat

浏览器访问 localhost:8080/project/my 也可以

总结：如果单纯是使用servlet，每一个请求都需要在xml中单独配置，非常的不方便；

仿照HttpServlet写的接口

直接继承Servlet

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ResourceBundle;

public class ServletDemo implements Servlet {
    private static final ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.http.LocalStrings");
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("servlet begin");
    }
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        HttpServletRequest request;
        HttpServletResponse response;
        try {
            request = (HttpServletRequest)req;
            response = (HttpServletResponse)res;
        } catch (ClassCastException var6) {
            throw new ServletException(lStrings.getString("http.non_http"));
        }
        System.out.println(request.getMethod());
        response.getWriter().write(request.getMethod());
    }
    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {
        System.out.println("servlet end");
    }
}

2、在来理解servlet概念

狭义的Servlet 是指Java 语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的(servlet通俗理解就是所有实现了servlet接口的实现类，程序员自己写了类继承了HTTPServlet，而HttpServlet继承了这个servlet接口，实现了这个接口，所有支持servlet标准的容器(服务器)，就可以认识和处理我们写了servlet类了)，一般情况下，人们将Servlet理解为后者。
Servlet运行于支持Java的应用服务器中。从原理上讲，Servlet可以响应任何类型的请求，但绝大多数情况下Servlet 只用来扩展基于HTTP协议的Web服

特点：

Servlet的运行必须要支持Servlet标准的Web容器，像Tomcat、Jboss、Weblogic、WebSphere、Jetty等都支持。
Servlet的实现遵循了服务器能够识别的规则，也就是服务器会自动的根据请求调用对应的servlet进行请求处理。
简单方便，可移植性强

运行流程：

浏览器发送请求到服务器，服务器根据请求URL地址中的URI信息在webapps目录下找到对应的项目文件夹，然后在web.xml中检索对应的servlet类(找到继承了servlet接口的类)，通过反射实例化这个类。调用service方法，通过service方法来调用doget、dopost方法(注意，这个其他的方法，都是通过service方法来调用的，因为tomcat默认只会调用service方法)

3、Servlet生命周期

1、生命周期(默认)

　　当第一次servlet(类)被实例化加载到内存之后(默认第一次请求到来，才加载到内存)，一直到服务器关闭‘

2、生命周期(配置)

在web.xml中设置了load-on-startup

    <servlet>
        <servlet-name>ServletDemo</servlet-name>
        <servlet-class>com.zy.servlet.ServletDemo</servlet-class>
        <load-on-startup>1</load-on-startup>  //设置随服务器启动，就将servlet加载到内存，数字越小，越优先加载到内存中
    </servlet>
    <servlet-mapping>
        <servlet-name>ServletDemo</servlet-name>
        <url-pattern>/my</url-pattern>
    </servlet-mapping>

　　生命周期：当服务器启动一直到服务器关闭

1.加载：容器通过类加载器使用Servlet类对应的文件来加载Servlet

2.创建：通过调用Servlet的构造函数来创建一个Servlet实例

3.初始化：通过调用Servlet的init()方法来完成初始化工作，这个方法是在Servlet已经被创建，但在向客户端提供服务之前调用。（只初始化一次）

4.处理客户请求：Servlet创建后就可以处理请求，当有新的客户端请求时，Web容器都会创建一个新的线程(在并发编程下servlet是线程不安全的)来处理该请求。接着调用Servlet的Service()方法来响应客户端请求（Servic方法中根据请求的method属性来调用doGet（）和doPost（））

5.卸载：容器在卸载Servlet之前需要调用destroy()方法，让Servlet释放其占用的资源。

4、Servlet使用

request对象也可以这样获取

HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

Request对象

//获取请求头数据
//获取请求方式
    String method=req.getMethod（）；
//获取请求URL 
    StringBuffer url=req.getRequestURL（）；
    String uri=req.getRequestURI（）；
//获取协议
    String h=req.getscheme（）；
//获取请求行数据
    //获取指定的请求行信息
    String value=req.getHeader（"User-Agent"）；
//获取所有的请求行的键的枚举
    Enumeration e=req.getHeaderNames（）；
    while(e. hasMoreElements()){
    string name=(String)e. nextElement());
//获取参数
    String name=req. getParameter("uname),  //注意getparameter 不能获取同键不同值的多个数据(像复选框之类的)；
    String[] likes=req. getParameterValues("like"); //可以获取多个值了

请求的数据如果出现乱码

请求中文乱码解决：
使用公共配置
    get方式：
        步骤一：req.setcharacterEncoding（"utf-8"）；
        步骤二：
              在tomcat的目录下的conf目录中修改server.xml文件：在Connector标签中增加属性<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" useBodyEncodingForURI="true"/>  //多加了一个useBodyEncodingForURI="true";
              或者参考：https://www.jb51.net/article/145741.htm
    post方式：
        req.setCharacterEncoding（"utf-8"）；

请求转发学习

注意：无论项目是否有根路径(不是ROOT目录)，转发的地址都是"/"

请求转发学习：
　　作用：实现多个servlet联动操作处理请求，这样避免代码冗余，让servlet的职责更加明确。
　　使用：
　　　　req.getRequestDispatcher（“要转发的地址"）.forward（req，resp）；地址：相对路径，直接书写servlet的别名即可。
　　特点：
　　　　一次请求，浏览器地址栏信息不改变。
　　注意：
　　　　请求转发后直接return结束即可。
　　　　网址栏上url不变

servlet流转过程中的数据封装　　

req.setAttribute("xx","xxxxx");//往req中添加数据，注意设置的是一个对象，
(String)req.getAttrubute("xx");//获取数据;注意由于之前的封装的是String对象，此时就可以强转为String对象

请求重定向

注意：如果项目有根路径(不是ROOT目录)，转发的地址都是"/项目更目录/"

使用：
    resp.sendRedirect（"/1ogin/main"）；
特点
    两次请求，两个request对象。
    浏览器地址栏信息改变
时机：
    如果请求中有表单数据，而数据又比较重要，不能重复提交，建议使用重定向。
    如果请求被Servlet接收后，无法进行处理，建议使用重定向定位到可以处理的资源。

Cookie使用

Cookie学习：
    作用：解决了发送的不同请求的数据共享间题
使用：
    //创建Cookie对象
        Cookie c=new Cookie（string name，String value）；
    //设置cookie（可选）
        //设置有效期(默认存放在内存中，随着浏览器关闭而关闭)
        c.setMaxAge（int seconds）；
        //设置有效路径（只有访问该路径，cookie才会附带上）
        c.setPath（string uri)
    //响应Cookie信息给客户端
        resp.addCookie（c）；
注意：
    一个Cookie对象存储一条数据。多条数据，可以多创建几个Cookie对象进行存储。
特点：
    浏览器端的数据存储技术。存储的数据声明在服务器端。
    临时存储：存储在浏览器的运行内存中，浏览器关闭即失效。
    定时存储：设置了Cookie的有效期，存储在客户端的硬盘中，在有效期内符合路径要求的请求都会附带该信息。
    默认cookie信息存储好之后，每次请求都会附带，除非设置有效路径

cookie获取

//获取Cookie信息数组
    Cookie[]cks=req.getcookies（）；
//遍历数组获取Cookie信息
    使用for循环遍历即可，示例：
        if（cks！=nul1）{
            For（Cookie c:cks）{
                String name=c.getName（）；
                String value=c.getValue（）；            
                system.out.print1n（name+"："+value）；
        }}

Session使用

sessionid生命周期

1、浏览器第一次请求服务器时，服务器会生成一个sessionId，并返回给浏览器，这个sessionId会被保存在浏览器的会话cookie中。

2、在浏览器不关闭的情况下，之后的每次请求请求头都会携带这个sessionId到服务器（一般会设置更新服务器session时间）

3、如果浏览器一直到30分钟后，才发起第二次请求，此时的服务器session已经清空，服务器就会生成一个新的sessionId给浏览器（伴随着一个新的session存在服务器），替代之前的浏览器的sessionid

4、第三次请求，就带上的新的sessionid（cookie中保存着sessionId，如果禁用了cookie，我们可以使用url重写技术，将sessionId当作参数放到url后面）。

默认情况，session在服务器上储存为30分钟，保存了用户的一些信息，一旦session清除，用户这次登陆的所有的数据都全部清除。那我们是不是又要手动重新登陆了？我们是需要重新登陆的，只是cookie帮我们自动登录了，一般服务器会给我们浏览器上保存一个cookie，用来验证身份登陆的。每次都会默默的帮我们登陆，其实每次我们打开浏览器，打开某一个网址，这时候，cookie就会帮我们默默等登陆，只是我们感受不到而已。

所以，我们一般验证用户信息的时候（拦截器），一般先看session中是否保存了user对象，如果没有，获取cookie中的账号和密码看看是否可以登录，如果还是不行，直接跳转到登录页面;

使用：
    创建session对象/获取session对象
        HttpSession hs=req.getSession（）；如果请求中拥有session的标识符也就是JSESSIONID，则返回其对应的session对象，
　　　　　　　　　　　　　　　　　　　　　　　 　 如果请求中没有session的标识符也就是JSESSIONID，则创建新的session对象，并将其JSESSIONID作为从cookie数据存放到浏览器上。
                                          如果session对象是失效了，也会重新创建一个session对象，并将其JSESSIONID存储在浏览器内存中。

设置session存储时间(单位：秒)，默认30分钟，每一个请求都会重新设置失效时间
　　hs.setMaxInactiveInterval（5）；
获取sessionid
　　hs.getId()：
设置session强制失效
　　hs.invalidate（）；l
存储数据
　　hs.setAttribute("name",name);
获取数据
　　hs.getAttribute("name")
使用时机：
一般用户在登陆web项目时会将用户的个人信息存储到Sesion中，供该用户的其他请求使用。

直接配置session过期时间

1、在tomcat中的web.xml（conf目录下）修改这个时间

<session-config>
        <session-timeout>30</session-timeout>
</session-config>

2、在项目中添加上面的代码；并设置失效的时间

ServletContext对象

　　需求：不同的用户需要使用同一个对象

　　特点：服务器创建，用户共享

　　生命周期：服务器启动到服务器关闭

　　作用域：整个项目内

getParameter()是获取POST/GET传递的参数值；
getInitParameter获取Tomcat的server.xml中设置Context的初始化参数
getAttribute()是获取对象容器中的数据值；
getRequestDispatcher是请求转发。

使用1

获取方式：
//第一种方式(常用)
    ServletContext sc=this.getservletContext（）；
//第二种方式
    ServletContext sc2=this.getServletConfig（）.getServletContext（）；
//第三种方式(常用)
    ServletContext sc3=req.getSession（）.getServletContext（）；
//数据存储
    sc.setAttribute（String name，Object value）；
//数据获取
    sc.getAttribute（"str"）返回的是0bject类型

使用2　

　　获取项目中web.xm1文件中的全局配置数据

　　作用：使静态数据和代码进行解耦

1、在web.xml 配置全局数据

<!--配置全局数据-->
    <context-param>  //注意一个context-param只能配置一个键值对
        <param-name>name</param-name>
        <param-value>zhangsan</param-value>
</context-param>

2、获取

获取项目中web.xm1文件中的全局配置数据
    sc.getInitParameter（String name）；根据键的名字返回web.xml中配置的全局数据的值，返回String类型。如果数据不存在返回nul1。
    sc.getInitParameterNames（）；返回键名的枚举

获取资源的绝对路径和资源的流对象

获取项目webroot下的资源的绝对路径。
    String path=sc.getRealPath（String path）；获取的路径为项目根目录，                
    path参数为项目根目录中的路径
获取webroot下的资源的流对象
    InputStream is=sc.getResourceAsStream（String path）；
    注意：
        此种方式只能获取项目根目录下的资源流对象，c1ass文件的流对象需要使用类加载器获取。
        path参数为项目根目录中的路径

webroot：在tomcat服务器上，就相当于webapps的绝对路径

ServletConfig对象

作用：专门给servlet自己做配置的对象，别的servlet获取不到该数据。
操作：在web.xml配置

<servlet>
        <servlet-name>ServletDemo</servlet-name>
        <servlet-class>com.zy.servlet.ServletDemo</servlet-class>
        <init-param>  //注意只能在自己的servlet中配置数据
            <param-name>name</param-name>
            <param-value>zhangsan</param-value>
        </init-param>
</servlet>

获取

//获取ServletConfig对象
    ServletConfig sc=this.getServletConfig（）；
//获取web.xm1中的配置数据
    String name=sc.getInitParameter（"name"）；    
    System.out.print1n（name）；

Response对象

//设置响应头
    resp.setHeader（String name，String value）；//在响应头中添加多个响应信息，但是同键会覆盖
    resp.addHeader（String name，String value）；//在响应头中添加多个响应信息，但是不会覆盖。
//设置响应状态码
    resp. sendError(405,"this Method is not supported");
//设置响应实体(在页面上展示的)
    resp.getWriter（）.write（"this is resp study"）；
//设置响应编码格式,解决乱码
    resp.setHeader("content-type","text/html;charset=utf-8");
    resp.setContentType("text/html;charset=utf-8");//简写，text/html，会将<b></b>等html标签解析
    resp.setContentType("text/plain;charset=utf-8"); //会把<b></b>等标签当做普通的文本显示在浏览器上
    resp.setContentType("text/xml;charset=utf-8"); //会把响应的数据以xml的格式显示在浏览器上

web.xml解析

区别：
　　　　Web项目下的web.xml文件为局部配置，针对本项目的位置。
　　　　Tomcat下的web.xml文件为全局配置，配置公共信息。

内容（核心组件）：
　　　　全局上下文配置（全局配置参数）
　　　　Servlet配置　　
　　　　过滤器配置
　　　　监听器配置

　　　　　加载顺序：　　　　　　　　

　　　　　　　Web容器会按ServletContext->context-param->listener->filter->servlet这个顺序加载组件，这些元素可配置在web.xml文件中的任意位置。

　　　　　　加载时机：
　　　　　　　　服务器启动时。

server.xml解析

核心组件

<Server>
    <Service> //一个server下可以配置多个service，可以在配置端口，就可以通过不同的端口访问
        <Connector/>   //配置端口，可以配置多个
        <Connector/>
        <Engine>       //引擎，只能配置一个
            <Host>         //配置项目的存放位置的根目录
            　　<Context/>
            </Host>
        </Engine>
    </Service>
</Server>

热部署

在Host中配置，如果将项目删除了，记得tomcat的server.xml要将这段代码删除掉，否则会报错，但是tomcat其他的项目还是正常的启动。

<Context path ="/Pet" reloadable ="true" docBase="F:/PetWeb"/>

　　解释：/Pet ：虚拟路径，请求的时候需要带上

　　　　 /F:/PetWeb ：热部署的项目;

servlet过滤器

<filter>
  <filter-name>LogFilter</filter-name>
  <filter-class>com.runoob.test.LogFilter</filter-class>
  <init-param>
    <param-name>Site</param-name>
    <param-value>菜鸟教程</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>LogFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

　　补充：Filter不仅可以通过url-pattern来指定拦截哪些url匹配的资源。而且还可以通过servlet-name来指定拦截哪个指定的servlet(专门为某个servlet服务了,servlet-name对应Servlet的相关配置)。

注意doFilter既可以拦截请求，可以拦截响应（是典型的责任链模式）

chain.doFilter（request，response）；
Systen.out.println（"--MyFilter过滤器执行之后"）；

参考：https://www.runoob.com/jsp/jsp-writing-filters.html

https://my.oschina.net/u/1171518/blog/265467

Servlet监听器

监听器Listener就是在application，session，request三个对象创建，销毁，或者往其中添加修改删除属性时自动执行代码的功能组件。Listener是Servlet的监听器，可以监听客户端的请求，服务端的操作等。

创建几个java类实现监听接口

package com.zy.listener;

import javax.servlet.*;
import javax.servlet.http.*;

public class RequestListener implements ServletRequestListener, ServletRequestAttributeListener , HttpSessionListener , HttpSessionAttributeListener,ServletContextListener,ServletContextAttributeListener{
    //对request对象
    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        //如果某些数据有用,在销毁的前,将他存放到ServletContext中
        Object xx = sre.getServletRequest().getAttribute("xx");
        sre.getServletContext().setAttribute("xx",xx);
        System.out.println("request对象被销毁");
    }
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        System.out.println("request对象初始化");
    }
    //对request属性监听
    @Override
    public void attributeAdded(ServletRequestAttributeEvent srae) {
        String name = srae.getName();
        Object value = srae.getValue();
    }
    @Override
    public void attributeRemoved(ServletRequestAttributeEvent srae) {

    }

    @Override
    public void attributeReplaced(ServletRequestAttributeEvent srae) {

    }

    //对session对象监听
    @Override
    public void sessionCreated(HttpSessionEvent se) {

    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {

    }
    //对session属性的监听
    @Override
    public void attributeAdded(HttpSessionBindingEvent se) {

    }

    @Override
    public void attributeRemoved(HttpSessionBindingEvent se) {

    }

    @Override
    public void attributeReplaced(HttpSessionBindingEvent se) {

    }
    //对servletcontext对象监听
    @Override
    public void contextInitialized(ServletContextEvent sce) {

    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {

    }
    //对servletcontext属性的监听
    @Override
    public void attributeAdded(ServletContextAttributeEvent scae) {

    }

    @Override
    public void attributeRemoved(ServletContextAttributeEvent scae) {

    }

    @Override
    public void attributeReplaced(ServletContextAttributeEvent scae) {

    }
}

web.xml配置

Listener的配置信息必须在Filter和Servlet的配置之前，Listener的初始化(ServletContextListener初始化)比Servlet和Filetr都优先，而销毁比Servlet和Filter都慢。

<listener>
        <listener-class>com.zy.listener.RequestListener</listener-class>
</listener>

Tomcat启动的时候，需求：加载配置文件

1、方式1：使用servlet--->init方法---><load-on-startup>

2、方式2：使用filter--->init方法--->web.xml注册过滤器之后自动调用初始化

3、方式3：使用监听器，ContextLoaderLister（spring推荐使用）

使用方式3：

需要额外导入jar包，spring-web

参考我的另一篇博客：https://i.cnblogs.com/EditPosts.aspx?postid=10827203&update=1

cookie免登陆和session综合使用

关于token：https://www.cnblogs.com/minsons/p/7058837.html

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
import java.io.IOException;

@WebServlet("/login")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Cookie[] cookies = req.getCookies();
        for (Cookie cookie:cookies){
            if ("username".equals(cookie.getName())){
                String value = cookie.getValue();
                //判断用户是否存在（查数据库,验证用户是否存在）
                if ("admin".equals(value)){
                    //设置session,存放会话
                    HttpSession session = req.getSession();
                    session.setAttribute("username",value);
                    resp.sendRedirect("/home");
                    return;
                }
            }
        }
        resp.sendRedirect("/login.jsp");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username = req.getParameter("username");
        String pwd = req.getParameter("pwd");
        //查询数据库,如果有用户,就设置session
        if (true){
            //设置cookie,免登陆
            Cookie cookie = new Cookie("username",username);
            cookie.setMaxAge(60*5);
            cookie.setPath("/");
            resp.addCookie(cookie);
            //设置session,存放会话
            HttpSession session = req.getSession();
            session.setAttribute("username",username);
            session.setAttribute("pwd",pwd);
            resp.sendRedirect("/home");
        }
    }
}

@WebServlet("/home")
public class ServletDemo extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        HttpSession session = req.getSession();
        Object username = session.getAttribute("username");
        if(username==null){
            resp.sendRedirect("/login");
            return;
        }
        resp.setHeader("content-type","text/html;charset=utf-8");
        resp.getWriter().write((String)username+"登录成功");
    }
}

java web----servlet 1、第一个servlet应用(可以直接创建maven项目，产生maven目录结构) 2、在来理解servlet概念 3、Servlet生命周期 4、Servlet使用 servlet过滤器 Servlet监听器 Tomcat启动的时候，需求：加载配置文件 cookie免登陆和session综合使用