servlet三种方式实现servlet接口

最新推荐文章于 2024-09-19 16:46:29 发布
最新推荐文章于 2024-09-19 16:46:29 发布
阅读量2k 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42981419/article/details/86162090
版权

servlet三种方式实现servlet接口

简单介绍

Servlet接口实现类

1、Servlet接口SUN公司定义了两个默认实现类，分别为：GenericServlet、HttpServlet。

2、HttpServlet指能够处理HTTP请求的servlet，它在原有Servlet接口上添加了一些与HTTP协议处理方法，它比Servlet接口的功能更为强大。因此开发人员在编写Servlet时，通常应继承这个类，而避免直接去实现Servlet接口。

3、HttpServlet在实现Servlet接口时，覆写了service方法，该方法体内的代码会自动判断用户的请求方式，如为GET请求，则调用HttpServlet的doGet方法，如为Post请求，则调用doPost方法。因此，开发人员在编写Servlet时，通常只需要覆写doGet或doPost方法，而不要去覆写service方法。

接口分离原则：

    将一个包含多功能的单一接口根据函数功能分离称多个独立的接口，同时每个接口都有自己特有的、有意义的、具有实际哦那功能的修饰器。
    多重接口修饰：
         每个修饰器设计时都需要首先实现他要修饰的接口，可以配合应用 适配器和修饰器这两个模式来构建多重修饰器，同时也能保证代码量最少。
客户端构建：
    为客户端提供接口实例的方式一定程度上取决于接口实现的数目。如果每个接口都有自己特有的实现，那就需要构造所有实现的实例并提供给客户端。或者如果所有的接口的实现都包含在单个类中，那么只需要构建该类的实例就能够满足客户端的所有依赖。
    1、多接口、多实例：
        控制器类：将所有方法整合到控制器类中（构造函数传入参数为各个接口）。控制器类中的每个方法都需要一个不同的接口来执行他的功能。
    2、单接口、单实例：
        在单个类中继承并实现所有接口。这样将每个接口的实现方法都整合到一个类中。（一般用于叶子实现类）

Servlet的作用：

1.接收请求数据

2.处理请求

3.完成响应

Servlet接口中的五大方法：

其中有三个是生命周期方法：

1.void init(ServletConfig).当Servlet对象被服务器创建时调用，仅调用一次。

2.void service(ServletRequest, ServletResponse).可被服务器调用多次。

3.void destroy().服务器关闭连接之前调用，仅一次。

另外的两个：

4.ServletConfig getServletConfig()

5.String getServletInfo()

Servlet代码源

package javax.servlet;

import java.io.IOException;

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

    ServletConfig getServletConfig();

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

    String getServletInfo();

    void destroy();
}
View Code

HttpServlet代码源

package javax.servlet.http;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.MessageFormat;
import java.util.Enumeration;
import java.util.ResourceBundle;
import javax.servlet.DispatcherType;
import javax.servlet.GenericServlet;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public abstract class HttpServlet extends GenericServlet {
    private static final long serialVersionUID = 1L;
    private static final String METHOD_DELETE = "DELETE";
    private static final String METHOD_HEAD = "HEAD";
    private static final String METHOD_GET = "GET";
    private static final String METHOD_OPTIONS = "OPTIONS";
    private static final String METHOD_POST = "POST";
    private static final String METHOD_PUT = "PUT";
    private static final String METHOD_TRACE = "TRACE";
    private static final String HEADER_IFMODSINCE = "If-Modified-Since";
    private static final String HEADER_LASTMOD = "Last-Modified";
    private static final String LSTRING_FILE = "javax.servlet.http.LocalStrings";
    private static final ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.http.LocalStrings");

    public HttpServlet() {
    }

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

    }

    protected long getLastModified(HttpServletRequest req) {
        return -1L;
    }

    protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        if (DispatcherType.INCLUDE.equals(req.getDispatcherType())) {
            this.doGet(req, resp);
        } else {
            NoBodyResponse response = new NoBodyResponse(resp);
            this.doGet(req, response);
            response.setContentLength();
        }

    }

    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);
        }

    }

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

    }

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

    }

    private static Method[] getAllDeclaredMethods(Class<?> c) {
        if (c.equals(HttpServlet.class)) {
            return null;
        } else {
            Method[] parentMethods = getAllDeclaredMethods(c.getSuperclass());
            Method[] thisMethods = c.getDeclaredMethods();
            if (parentMethods != null && parentMethods.length > 0) {
                Method[] allMethods = new Method[parentMethods.length + thisMethods.length];
                System.arraycopy(parentMethods, 0, allMethods, 0, parentMethods.length);
                System.arraycopy(thisMethods, 0, allMethods, parentMethods.length, thisMethods.length);
                thisMethods = allMethods;
            }

            return thisMethods;
        }
    }

    protected void doOptions(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Method[] methods = getAllDeclaredMethods(this.getClass());
        boolean ALLOW_GET = false;
        boolean ALLOW_HEAD = false;
        boolean ALLOW_POST = false;
        boolean ALLOW_PUT = false;
        boolean ALLOW_DELETE = false;
        boolean ALLOW_TRACE = true;
        boolean ALLOW_OPTIONS = true;
        Class clazz = null;

        try {
            clazz = Class.forName("org.apache.catalina.connector.RequestFacade");
            Method getAllowTrace = clazz.getMethod("getAllowTrace", (Class[])null);
            ALLOW_TRACE = (Boolean)getAllowTrace.invoke(req, (Object[])null);
        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | ClassNotFoundException var14) {
            ;
        }

        for(int i = 0; i < methods.length; ++i) {
            Method m = methods[i];
            if (m.getName().equals("doGet")) {
                ALLOW_GET = true;
                ALLOW_HEAD = true;
            }

            if (m.getName().equals("doPost")) {
                ALLOW_POST = true;
            }

            if (m.getName().equals("doPut")) {
                ALLOW_PUT = true;
            }

            if (m.getName().equals("doDelete")) {
                ALLOW_DELETE = true;
            }
        }

        String allow = null;
        if (ALLOW_GET) {
            allow = "GET";
        }

        if (ALLOW_HEAD) {
            if (allow == null) {
                allow = "HEAD";
            } else {
                allow = allow + ", HEAD";
            }
        }

        if (ALLOW_POST) {
            if (allow == null) {
                allow = "POST";
            } else {
                allow = allow + ", POST";
            }
        }

        if (ALLOW_PUT) {
            if (allow == null) {
                allow = "PUT";
            } else {
                allow = allow + ", PUT";
            }
        }

        if (ALLOW_DELETE) {
            if (allow == null) {
                allow = "DELETE";
            } else {
                allow = allow + ", DELETE";
            }
        }

        if (ALLOW_TRACE) {
            if (allow == null) {
                allow = "TRACE";
            } else {
                allow = allow + ", TRACE";
            }
        }

        if (ALLOW_OPTIONS) {
            if (allow == null) {
                allow = "OPTIONS";
            } else {
                allow = allow + ", OPTIONS";
            }
        }

        resp.setHeader("Allow", allow);
    }

    protected void doTrace(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String CRLF = "\r\n";
        StringBuilder buffer = (new StringBuilder("TRACE ")).append(req.getRequestURI()).append(" ").append(req.getProtocol());
        Enumeration reqHeaderEnum = req.getHeaderNames();

        while(reqHeaderEnum.hasMoreElements()) {
            String headerName = (String)reqHeaderEnum.nextElement();
            buffer.append(CRLF).append(headerName).append(": ").append(req.getHeader(headerName));
        }

        buffer.append(CRLF);
        int responseLength = buffer.length();
        resp.setContentType("message/http");
        resp.setContentLength(responseLength);
        ServletOutputStream out = resp.getOutputStream();
        out.print(buffer.toString());
        out.close();
    }

    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);
        }

    }

    private void maybeSetLastModified(HttpServletResponse resp, long lastModified) {
        if (!resp.containsHeader("Last-Modified")) {
            if (lastModified >= 0L) {
                resp.setDateHeader("Last-Modified", lastModified);
            }

        }
    }

    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);
    }
}
View Code

GenericServlet代码源

package javax.servlet;

import java.io.IOException;
import java.io.Serializable;
import java.util.Enumeration;

public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
    private static final long serialVersionUID = 1L;
    private transient ServletConfig config;

    public GenericServlet() {
    }

    public void destroy() {
    }

    public String getInitParameter(String name) {
        return this.getServletConfig().getInitParameter(name);
    }

    public Enumeration<String> getInitParameterNames() {
        return this.getServletConfig().getInitParameterNames();
    }

    public ServletConfig getServletConfig() {
        return this.config;
    }

    public ServletContext getServletContext() {
        return this.getServletConfig().getServletContext();
    }

    public String getServletInfo() {
        return "";
    }

    public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
    }

    public void init() throws ServletException {
    }

    public void log(String msg) {
        this.getServletContext().log(this.getServletName() + ": " + msg);
    }

    public void log(String message, Throwable t) {
        this.getServletContext().log(this.getServletName() + ": " + message, t);
    }

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

    public String getServletName() {
        return this.config.getServletName();
    }
}
View Code

 

 实现接口代码：

package com.wbg;

import javax.servlet.*;
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("/MyServlet")
public class MyServlet implements Servlet {

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

    @Override
    public ServletConfig getServletConfig() {
        System.out.println("getServletConfig()");
        return null;
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("正在销毁");
    }

    @Override
    public String getServletInfo() {
        System.out.println("getServletInfo()");
        return null;
    }

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

 

 

 

浏览器访问servlet时，需要将servlet与路径绑定，需要在web.xml中对servlet进行配置：

<?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-name>testservlet</servlet-name>
        <servlet-class>com.wbg.testservlet</servlet-class>
    </servlet>
</web-app>

实现接口的意义:

1、接口和实现分离给软件系统提供了无限的想像空间，才使得软件世界如此丰富多彩。

2、接口和实现分离使得多态变为可能

3、接口和实现分离使得解耦变为可能

4、接口和实现分离使得组合更有意义

5、接口和实现分离使得设计模式变为可能，才能衍生出23种设计模式。

简单的说接口和实现分离给软件系统提供了无限的想象空间、多态变为可能、解耦变为可能、组合更有意义、设计模式变为可能，才能衍生出23钟设计模式(创建型、结构型、行为型)

posted @ 2018-08-13 08:20 韦邦杠 阅读( ...) 评论( ...) 编辑 收藏
邦杠
关注
Struts2访问Servlet的三种方式
08-30
因此，Struts2 提供了三种方式来访问 Servlet API，这三种方式分别是实现特定接口、通过 ServletActionContext 类和通过 ActionContext 类。 第一种方式：实现特定接口 这种方式需要 Action 实现特定的接口，如 ...
servlet类的java怎么删除_JavaWeb知识回顾－Servlet常用类、接口及其方法
weixin_28866737的博客
02-24 350
今天主要把servlet的一些常用的类、接口和方法简单回顾一下。javax.servlet包1.javax.servlet.Servlet接口接口用于开发servlet，所有的servlet都要直接或间接地实现这个接口，这个接口定义了servlet的生命周期的方法。一般不直接实现该接口，可以扩展javax.servlet.GenericServlet来实现一般协议的Servlet，也可以扩展jav...
Servlet接口中有哪些方法？
qq_44761854的博客
03-14 1029
Servlet接口定义了5个方法： 1、void init(ServletConfig config) throws ServletException 2、void service(ServletRequest req, ServletResponse resp) throws ServletException, java.io.IOException 3、void destory() 4、java.lang.String getServletInfo() 5、ServletConfig getServle
Servlet
最新发布
Dongdong20021203的博客
09-19 1287
Servlet是JavaWeb最为核心的内容，它是Java提供的一门动态web资源开发技术。使用Servlet就可以实现，根据不同的登录用户在页面上动态显示不同内容。Servlet是JavaEE规范之一，其实就是一个接口，将来我们需要定义Servlet类实现Servlet接口，并由web服务器运行Servlet介绍完Servlet是什么以后，接下来我们就按照快速入门->执行流程->生命周期->体系结构->urlPattern配置->XML配置。
servlet 接口方法的介绍
yyy800sui的博客
04-15 2322
1. init() init　：起始方法，仅在服务器开启时执行一次。 2 .service() service ： 服务方法，更新开启服务器都会执行。 3 . destroy() destroy： 摧毁方法，仅在服务器正常关闭时执行一次 。 以上三种方法，统称为servlet的生命周期方法，是servlet最主要的功能 4. getServletConfig() getServletConfig():获取servlet的配置信息。 5 .getServletInfo() getServletInf
Servlet接口（保姆级）
乌鸦喜欢写字台
11-26 1706
一、Servlet概述 概念：运行在服务器端的小程序 servlet就是一个接口，定义了java类被浏览器访问到（tomcat识别）的规则 可以自定义一个类，实现Servlet接口，复写方法。 步骤： 1.创建JavaEE项目 2.定义类可以实现servlet接口的抽象方法 3.配置Servlet 在web的web.xml中配置 将标签贴在这里 <!--配置Servlet--> <servlet> <servlet-name>.
Servlet（接口编程）
希望有点用
06-25 2305
Servlet（接口编程）
SpringBoot注册Servlet的三种方法详解
08-26
另一种注册Servlet的方式是实现`ServletContainerInitializer`接口，并在类上使用`@HandlesTypes`注解声明处理的Servlet类型。这种方式通常用于全局初始化逻辑，如监听Servlet的加载。 ```java import javax....
servlet的三种方法的实现
10-09
这种方式比直接实现Servlet接口稍好，因为它提供了一定程度的抽象。然而，由于GenericServlet是协议无关的，对于处理HTTP请求，它的功能还是不够具体。 3. **继承HttpServlet** HttpServlet是GenericServlet的子类...
深入了解tomcat中servlet的创建方式实现
01-09
通俗解释一下：就是我们开发人员所编写的一个类，必须直接或者间接实现这个javaEE的核心规范，也就是实现Servlet接口，因为这种类产生的对象可以被浏览器访问到，因此称之为Servlet,并且javaEE中规定了只有Servlet的...
浅析javax.servlet.Servlet,ServletContext接口
09-05
这两个接口是Servlet API的核心部分，它们为Web应用程序提供了一种标准的方式来处理HTTP请求并管理全局数据。 首先，让我们来了解一下`Servlet`接口。`Servlet`是所有Servlet类必须实现的基础接口，它定义了Servlet...
Servlet接口实现类
TSCCG的博客
08-12 3007
JavaWeb-03-Servlet-02-Servlet接口实现类 1.什么是Servlet接口，有什么用？ Servlet接口来自于Servlet规范中的一个接口，这个接口存在于Http服务器所提供的jar包中。 Servlet接口的具体位置：位于Tomcat服务器下的lib文件中的servlet-api.jar，在jar包中的位置:【javax.servlet.Servlet】。 在Servlet规范中，Http服务器能调用的【动态资源文件】必须是一个实现了Servlet接口的java类。 如： c
Servlet的三种实现类型
weixin_45614136的博客
10-22 1475
1、实现servlet接口 servlet是一个接口，其中有很多种方法，如：init()、service()、destroy()等 先写一个java类，继承servlet接口，重写未实现的方法。其中最关键的是service()方法，之后还需配置web.xml文件，如图： public class Servlet1 implement Servlet{ @Override public void...
基于Spring2.5.6搭建技术开发框架
huchen0907的专栏
10-16 414
列表内容 web.xml配置：<context-param> <param-name>contextConfigLocation</param-name> <param-value> classpath:resources/spring/ApplicationContext.xml </param-value> </context-pa
Servlet接口五种方法介绍
dinggujiao8462的博客
07-11 1137
Servlet接口定义了5种方法： init() service() destroy() getServletConfig() getServletInfo() init() 在Servlet实例化后，Servlet容器会调用init()方法来初始化该对象，主要是为了让Servlet对象在处理客户请求前可以完成一些初始化工作，例如：建立数据库的连接，获取配置信息...
Servlet接口
Lxn2zh的博客
05-01 1624
原文链接 [https://zhhll.icu/2021/javaweb/基础/1.Servlet接口/] 在java web中不管是使用J2EE原生的servlet/jsp还是使用springmvc/springboot，在web服务器看来只是对外暴露出来的Servlet，而这个Servlet是javax.servlet.Servlet接口，该接口定义了Servlet引擎与Servlet程序之间通信的协议约定。
07详细分析开发一个Servlet的步骤从实现Servlet接口,继承GenericServlet抽象类,继承HttpServlet抽象类逐步完善
欢迎阅读我的博客
06-09 2371
jakarta.servlet.GenericServlet 是官方提供的标准通用的Servlet抽象类不需要我们手写 , 但是我们可以仿造手写一个。第二步：重写doGet方法或者重写doPost方法，到底重写谁javaweb程序员说了算( 重写父类某个方法有快捷键 ctrl + o )手机不能直接插到220V的电压上,可以找一个充电器/适配器(Adapter)连接220V的电压解决问题。jakarta.servlet.Servlet是Servlet规范中的核心接口。
Servlet接口实现类开发步骤及对象生命周期
qq_39579087的博客
01-28 367
servlet接口实现类的开发步骤： 创建一个类，让其继承HttpServlet类，使之成为servlet接口实现类 重写HttpServlet中的doPost和doGet方法，以编写处理这两种请求的逻辑 将servlet接口实现类的信息注册到Tomcat服务器 我们先来看第一步，创建一个类，让其继承HttpServlet类，使之成为servlet接口实现类： 一个类需要实现servlet的接口才能被服务器操作，如创建这个servlet实现类的对象，之后根据此实例对象调用service方法处理当前请求(
Servlet核心技术：实现Servlet接口与应用详解
本资源主要讲解了如何在Java中实现Servlet接口，它是Servlet编程的基础。Servlet是一种用于处理HTTP请求的Java组件，它运行在Web服务器上，负责执行服务器端的处理逻辑。Servlet的核心功能在于实现`javax.servlet....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值