第七章Servlet

什么是Servlet

为什么需要Servlet

Servlet名字的含义

• Servlet=Server+applet
• Server：服务器
• applet：小程序
• Servlet含义是服务器端的小程序

我们需要将一次HTTP请求-响应(不限于HTTP)，对应到Java的语句（Java的语句一定放在方法中）——将请求-响应的处理过程对应到某个类下的方法对应起来——Servelet容器的功能

生活中的例子

对应的web应用

• 在整个Web应用中，Servlet主要负责处理请求、协调调度功能。我们可以把Servlet称为Web应用中的**『控制器』**

• Servlet是Java提供的一门动态web资源开发的技术，如何称为动态，也就是不同的用户访问一个资源，所展现的页面是不一样的，比如张三访问是张三欢迎你，李四访问是李四欢迎你，我访问是你不能访问该页面，类似这种功能的实现

• Servlet是JavaEE的规范之一，其实就是一个接口，将来我们需要具有Servlet功能的类型来实现Servlet接口，并由web服务器来运行Servlet

• Tomcat是一个轻量级的web服务器，可以称为web容器，Servlet容器，web服务器封装了http协议，简化我们的开发，其次将web项目部署到服务器中，可以对外提供网上浏览服务

从不同角度来看Servlet

总过程

Servlet之间的继承关系

Servlet的继承关系 - 重点查看的是服务方法（service()）

• javax.servlet.Servlet接口
  • javax.servlet.GenericServlet抽象类
    • javax.servlet.http.HttpServlet抽象子类

Servlet接口接口中方法

public interface Servlet {
    void init(ServletConfig var1) throws ServletException;

    ServletConfig getServletConfig();

    void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

    String getServletInfo();

    void destroy();
}

• 这是Servlet的源码，我们看到有

  • void init(config) - 初始化方法

  • void service(request,response) - 服务方法

  • ​ void destory() - 销毁方法

GenericServlet抽象方法

  public abstract void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

• void service(request,response) - 我们仍然是抽象的

HttpServlet 抽象子类

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("non-HTTP request or response");
        }

        this.service(request, response);
    }
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getMethod();
        long lastModified;
        if (method.equals("GET")) {
            lastModified = this.getLastModified(req);
            if (lastModified == -1L) {
                this.doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader("If-Modified-Since");
                } catch (IllegalArgumentException var9) {
                    ifModifiedSince = -1L;
                }

                if (ifModifiedSince < lastModified / 1000L * 1000L) {
                    this.maybeSetLastModified(resp, lastModified);
                    this.doGet(req, resp);
                } else {
                    resp.setStatus(304);
                }
            }
        } else if (method.equals("HEAD")) {
            lastModified = this.getLastModified(req);
            this.maybeSetLastModified(resp, lastModified);
            this.doHead(req, resp);
        } else if (method.equals("POST")) {
            this.doPost(req, resp);
        } else if (method.equals("PUT")) {
            this.doPut(req, resp);
        } else if (method.equals("DELETE")) {
            this.doDelete(req, resp);
        } else if (method.equals("OPTIONS")) {
            this.doOptions(req, resp);
        } else if (method.equals("TRACE")) {
            this.doTrace(req, resp);
        } else {
            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[]{method};
            errMsg = MessageFormat.format(errMsg, errArgs);
            resp.sendError(501, errMsg);
        }

    }

• void service(HttpServletRequest req, HttpServletResponse resp) - 不是抽象的
• String method = req.getMethod(); 这个方法是获取请求的方式
  • 然后通过后面的if和else if的结构来通过什么类型的方法去执行不同的逻辑
    • 决定调用的是哪个do开头的方法

 protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = lStrings.getString("http.method_post_not_supported");
        if (protocol.endsWith("1.1")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }

• 在HttpServlet这个抽象类中，do方法都差不多
• 那么在HttpServlet中这些do方法默认都是405的实现风格-要我们子类去实现对应的方法，否则默认会报405错误

小结

1. 继承关系： HttpServlet -> GenericServlet -> Servlet
   2) Servlet中的核心方法： init() , service() , destroy()
   3) 服务方法： 当有请求过来时，service方法会自动响应（其实是tomcat容器调用的）
   在HttpServlet中我们会去分析请求的方式：到底是get、post、head还是delete等等
   然后再决定调用的是哪个do开头的方法
   那么在HttpServlet中这些do方法默认都是405的实现风格-要我们子类去实现对应的方法，否则默认会报405错误
   4) 因此，我们在新建Servlet时，我们才会去考虑请求方法，从而决定重写哪个do方法

Servlet生命周期

从Servlet接口方法开始

我们所谓Servlert 生命周期：从出生到死亡的过程就是生命周期。对应Servlet中的三个方法：init(),service(),destroy()

例子

//演示Servlet的生命周期
public class Demo2 extends HttpServlet {
    public Demo2(){
        System.out.println("正在实例化....");
    }

    @Override
    public void init() throws ServletException {
        System.out.println("正在初始化.....");
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("正在服务.....");
    }

    @Override
    public void destroy() {
        System.out.println("正在销毁......");
    }
}

执行结果

//第一次访问Demo2
正在实例化....
正在初始化.....
正在服务.....
//第二次访问Demo2
正在服务.....
//第三次访问Demo3
正在服务.....

结论

默认情况下：

• 第一次接收请求时，这个Servlet会进行实例化(调用构造方法)、初始化(调用init())、然后服务(调用service())

• 从第二次请求开始，每一次都是服务

• 当容器关闭时，其中的所有的servlet实例会被销毁，调用销毁方法 destroy()

• 从调用构造方法可以看出 Servlet实例tomcat只会创建一个，所有的请求都是这个实例去响应。

  • 一般情况下，第一次请求时，tomcat才会去实例化，初始化，然后再服务.这样的好处是什么？ 提高系统的启动速度 。 这样的缺点是什么？ 第一次请求时，耗时较长。

    • 因此得出结论： 如果需要提高系统的启动速度，当前默认情况就是这样。如果需要提高响应速度，我们应该设置Servlet的初始化时机。

Servlet在容器中是：单例的、线程不安全的
- 单例：所有的请求都是同一个实例去响应
- 线程不安全：一个线程需要根据这个实例中的某个成员变量值去做逻辑判断。但是在中间某个时机，另一个线程改变了这个成员变量的值，从而导致第一个线程的执行路径发生了变化
- 我们已经知道了servlet是线程不安全的，给我们的启发是： 尽量的不要在servlet中定义成员变量。如果不得不定义成员变量，那么不要去：
- ①不要去修改成员变量的值
- ②不要去根据成员变量的值做一些逻辑判断

修改Servlet创建对象的时机

<!-- 配置Servlet本身 -->
<servlet>
    <!-- 全类名太长，给Servlet设置一个简短名称 -->
    <servlet-name>HelloServlet</servlet-name>

    <!-- 配置Servlet的全类名 -->
    <servlet-class>com.atguigu.servlet.HelloServlet</servlet-class>

    <!-- 配置Servlet启动顺序 -->
    <load-on-startup>1</load-on-startup>
</servlet>

• 我们可以通过来设置servlet启动的先后顺序,数字越小，启动越靠前，最小值0,
• 修改启动顺序后：创建就在Web应用启动过程中

小结

名称	时机	次数
创建对象	默认情况：接收到第一次请求 修改启动顺序后：Web应用启动过程中	一次
初始化操作	创建对象之后	一次
处理请求	接收到请求	多次
销毁操作	Web应用卸载之前	一次

Servlet容器

容器

在开发使用的各种技术中，经常会有很多对象会放在容器中。

容器提供的功能

容器会管理内部对象的整个生命周期。对象在容器中才能够正常的工作，得到来自容器的全方位的支持。

• 创建对象
• 初始化
• 工作
• 清理

容器本身也是对象

• 特点1：往往是非常大的对象
• 特点2：通常的单例的

典型Servlet容器产品举例

• Tomcat
• jetty
• jboss
• Weblogic
• WebSphere
• glassfish

Servlet相关的保存作用域

• 原始情况下，保存作用域我们可以认为有四个： page（页面级别，现在几乎不用） , request（一次请求响应范围） , session（一次会话范围） ,application（整个应用程序范围）

request：一次请求响应范围

@WebServlet("/demo1")
public class Demo1 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1向request保存作用域保存数据
        request.setAttribute("uname","lili");
        //向demo2进行客户端重定向
        response.sendRedirect("demo2");
        //向demo2进行服务器端转发
        request.getRequestDispatcher("demo2").forward(request,response);
    }
}

@WebServlet("/demo2")
public class Demo2  extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        Object uname = request.getAttribute("uname");
        System.out.println("uname="+uname);
    }
}

• 根据打印结果 ：
  • 进行客户端重定向 我们的Demo2输出null，说明获取不到name这个属性的数据
  • 进行服务器转发 我们的Demo2输出了lsc,说明获得到了name这个属性的数据

session：一次会话范围有效

@WebServlet("/demo3")
public class Demo3 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpSession session=request.getSession();
        session.setAttribute("uname","lili");
        //向demo2进行客户端重定向
//        response.sendRedirect("demo2");
        //3.服务器端转发
        request.getRequestDispatcher("demo2").forward(request,response);
    }

@WebServlet("dem04")
public class Demo4 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpSession session = request.getSession();
        System.out.println("uname"+session.getAttribute("uname"));
    }
}

根据打印结果 ：

• 我们使用同一个客户端（打开浏览器不关闭），不管是客户端重定向还是服务器转发都能获取到name的属性值
• 如果使用的不是同一个客户端，不管是客户端重定向还是服务器转发都获取不到name的属性值

application： 一次应用程序范围有效

@WebServlet("/demo5")
public class Demo5 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.向application保存作用域保存数据
        //ServletContext : Servlet上下文
        ServletContext application = request.getServletContext();
        application.setAttribute("uname","lili");
        //2.客户端重定向
        response.sendRedirect("demo06");

        //3.服务器端转发
        //request.getRequestDispatcher("demo04").forward(request,response);
    }
}

@WebServlet("/demo6")
public class Demo6 extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.获取application保存作用域保存的数据，key为uname
        ServletContext application = request.getServletContext();
        Object unameObj = application.getAttribute("uname");
        System.out.println("unameObj = " + unameObj);
    }
}

• 不管是不是同一个客户端，不管是转发还是重定向都能获取到数据

ServletContext : Servlet上下文

• 什么叫上下文：

  • 拿生活中的例子，比如张三和李四在聊天，聊一个关于小明的八卦，他两已经聊了一会，突然王五来了说你们在聊啥，我想一起聊，王五想聊，就必须要知道张三和李四之前聊天的内容，才能加入他们一起聊小明的八卦，王五听张三和李四之前聊天的内容就是所谓的上下文
  • 我们的Servlet容器是Tomcat，我们可以不严谨的称为Servlet应用程序（因为有大量的Servlet），也就是我们的Servlet上下文，我们TomCat这次启动，也就是上下文开始

• 代表：整个Web应用

• 是否单例：是

• xxxxxxxxxx1 1request.getContextPath()java

  • 获取某个资源的真实路径：getRealPath()
  • 获取整个Web应用级别的初始化参数：getInitParameter()
  • 作为Web应用范围的域对象
    • 存入数据：setAttribute()
    • 取出数据：getAttribute()