Java Servlet和Sun的简单HTTP服务器之间是否有一座桥梁

我有一个使用的现有应用程序，我无法轻松更改它。现在我想添加一个现有的Servlet实现作为这个http服务器的一部分，但是简单的http服务器显然不支持完整的Servlet规范，因此没有直接添加Servlet的方法

那么，是否有一段代码至少可以通过某种桥从运行一个基本的Servlet到一个普通的Servlet？

这段代码来自，我自己也使用过

class HttpHandlerWithServletSupport implements HttpHandler {
    private HttpServlet servlet;

    private final class RequestWrapper extends HttpServletRequestWrapper {
        private final HttpExchange ex;
        private final Map<String, String[]> postData;
        private final ServletInputStream is;
        private final Map<String, Object> attributes = new HashMap<>();

        private RequestWrapper(HttpServletRequest request, HttpExchange ex,
                Map<String, String[]> postData, ServletInputStream is) {
            super(request);
            this.ex = ex;
            this.postData = postData;
            this.is = is;
        }

        @Override
        public String getHeader(String name) {
            return ex.getRequestHeaders().getFirst(name);
        }

        @Override
        public Enumeration<String> getHeaders(String name) {
            return new Vector<String>(ex.getRequestHeaders().get(name))
                    .elements();
        }

        @Override
        public Enumeration<String> getHeaderNames() {
            return new Vector<String>(ex.getRequestHeaders().keySet())
                    .elements();
        }

        @Override
        public Object getAttribute(String name) {
            return attributes.get(name);
        }

        @Override
        public void setAttribute(String name, Object o) {
            this.attributes.put(name, o);
        }

        @Override
        public Enumeration<String> getAttributeNames() {
            return new Vector<String>(attributes.keySet()).elements();
        }

        @Override
        public String getMethod() {
            return ex.getRequestMethod();
        }

        @Override
        public ServletInputStream getInputStream() throws IOException {
            return is;
        }

        @Override
        public BufferedReader getReader() throws IOException {
            return new BufferedReader(new InputStreamReader(
                    getInputStream()));
        }

        @Override
        public String getPathInfo() {
            return ex.getRequestURI().getPath();
        }

        @Override
        public String getParameter(String name) {
            String[] arr = postData.get(name);
            return arr != null ? (arr.length > 1 ? Arrays.toString(arr)
                    : arr[0]) : null;
        }

        @Override
        public Map<String, String[]> getParameterMap() {
            return postData;
        }

        @Override
        public Enumeration<String> getParameterNames() {
            return new Vector<String>(postData.keySet()).elements();
        }
    }

    private final class ResponseWrapper extends HttpServletResponseWrapper {
        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        final ServletOutputStream servletOutputStream = new ServletOutputStream() {

            @Override
            public void write(int b) throws IOException {
                outputStream.write(b);
            }
        };

        private final HttpExchange ex;
        private final PrintWriter printWriter;
        private int status = HttpServletResponse.SC_OK;

        private ResponseWrapper(HttpServletResponse response,
                HttpExchange ex) {
            super(response);
            this.ex = ex;
            printWriter = new PrintWriter(servletOutputStream);
        }

        @Override
        public void setContentType(String type) {
            ex.getResponseHeaders().add("Content-Type", type);
        }

        @Override
        public void setHeader(String name, String value) {
            ex.getResponseHeaders().add(name, value);
        }

        @Override
        public javax.servlet.ServletOutputStream getOutputStream()
                throws IOException {
            return servletOutputStream;
        }

        @Override
        public void setContentLength(int len) {
            ex.getResponseHeaders().add("Content-Length", len + "");
        }

        @Override
        public void setStatus(int status) {
            this.status = status;
        }

        @Override
        public void sendError(int sc, String msg) throws IOException {
            this.status = sc;
            if (msg != null) {
                printWriter.write(msg);
            }
        }

        @Override
        public void sendError(int sc) throws IOException {
            sendError(sc, null);
        }

        @Override
        public PrintWriter getWriter() throws IOException {
            return printWriter;
        }

        public void complete() throws IOException {
            try {
                printWriter.flush();
                ex.sendResponseHeaders(status, outputStream.size());
                if (outputStream.size() > 0) {
                    ex.getResponseBody().write(outputStream.toByteArray());
                }
                ex.getResponseBody().flush();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                ex.close();
            }
        }
    }

    public HttpHandlerWithServletSupport(HttpServlet servlet) {
        this.servlet = servlet;
    }

    @SuppressWarnings("deprecation")
    @Override
    public void handle(final HttpExchange ex) throws IOException {
        byte[] inBytes = getBytes(ex.getRequestBody());
        ex.getRequestBody().close();
        final ByteArrayInputStream newInput = new ByteArrayInputStream(
                inBytes);
        final ServletInputStream is = new ServletInputStream() {

            @Override
            public int read() throws IOException {
                return newInput.read();
            }
        };

        Map<String, String[]> parsePostData = new HashMap<>();

        try {
            parsePostData.putAll(HttpUtils.parseQueryString(ex
                    .getRequestURI().getQuery()));

            // check if any postdata to parse
            parsePostData.putAll(HttpUtils
                    .parsePostData(inBytes.length, is));
        } catch (IllegalArgumentException e) {
            // no postData - just reset inputstream
            newInput.reset();
        }
        final Map<String, String[]> postData = parsePostData;

        RequestWrapper req = new RequestWrapper(
                createUnimplementAdapter(HttpServletRequest.class), ex,
                postData, is);

        ResponseWrapper resp = new ResponseWrapper(
                createUnimplementAdapter(HttpServletResponse.class), ex);

        try {
            servlet.service(req, resp);
            resp.complete();
        } catch (ServletException e) {
            throw new IOException(e);
        }
    }

    private static byte[] getBytes(InputStream in) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        while (true) {
            int r = in.read(buffer);
            if (r == -1)
                break;
            out.write(buffer, 0, r);
        }
        return out.toByteArray();
    }

    @SuppressWarnings("unchecked")
    private static <T> T createUnimplementAdapter(Class<T> httpServletApi) {
        class UnimplementedHandler implements InvocationHandler {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                throw new UnsupportedOperationException("Not implemented: "
                        + method + ", args=" + Arrays.toString(args));
            }
        }

        return (T) Proxy.newProxyInstance(
                UnimplementedHandler.class.getClassLoader(),
                new Class<?>[] { httpServletApi },
                new UnimplementedHandler());
    }
}

类HttpHandlerWithServletSupport实现HttpHandler{
私有HttpServlet；
私有最终类RequestWrapper扩展了HttpServletRequestWrapper{
私有最终HttpEx交易所；
私有最终地图数据；
私有最终服务输入流为；
私有最终映射属性=新HashMap（）；
私有RequestWrapper（HttpServletRequest请求，HttpExchange-ex，
映射postData，ServletiInputStream为）{
超级（请求）；
this.ex=ex；
this.postData=postData；
this.is=is；
}
@凌驾
公共字符串getHeader（字符串名称）{
返回例如getRequestHeaders（）.getFirst（名称）；
}
@凌驾
公共枚举getHeaders（字符串名称）{
返回新向量（例如getRequestHeaders（）.get（名称））
.elements（）；
}
@凌驾
公共枚举getHeaderNames（）{
返回新向量（例如getRequestHeaders（）.keySet（））
.elements（）；
}
@凌驾
公共对象getAttribute（字符串名称）{
返回attributes.get（name）；
}
@凌驾
公共void setAttribute（字符串名称，对象o）{
this.attributes.put（name，o）；
}
@凌驾
公共枚举getAttributeNames（）{
返回新向量（attributes.keySet（））.elements（）；
}
@凌驾
公共字符串getMethod（）{
返回例如getRequestMethod（）；
}
@凌驾
公共ServletiInputStream getInputStream（）引发IOException{
回报是；
}
@凌驾
public BufferedReader getReader（）引发IOException{
返回新的BufferedReader（新的InputStreamReader(
getInputStream（））；
}
@凌驾
公共字符串getPathInfo（）{
返回例如getRequestURI（）.getPath（）；
}
@凌驾
公共字符串getParameter（字符串名称）{
字符串[]arr=postData.get（名称）；
返回arr！=null？（arr.length>1？Arrays.toString（arr）
：arr[0]）：null；
}
@凌驾
公共映射getParameterMap（）{
返回postData；
}
@凌驾
公共枚举getParameterNames（）{
返回新向量（postData.keySet（））.elements（）；
}
}
私有最终类ResponseWrapper扩展了HttpServletResponseWrapper{
final ByteArrayOutputStream outputStream=新建ByteArrayOutputStream（）；
最终ServletOutputStream ServletOutputStream=新ServletOutputStream（）{
@凌驾
公共无效写入（int b）引发IOException{
outputStream.write（b）；
}
};
私有最终HttpEx交易所；
私人最终印刷撰稿人印刷撰稿人；
private int status=HttpServletResponse.SC\u正常；
私有响应包装器（HttpServletResponse-response，
httpex）{
超级（响应）；
this.ex=ex；
printWriter=新的printWriter（servletOutputStream）；
}
@凌驾
公共void setContentType（字符串类型）{
例如，getResponseHeaders（）.add（“内容类型”，类型）；
}
@凌驾
public void setHeader（字符串名称、字符串值）{
例如，getResponseHeaders（）.add（名称、值）；
}
@凌驾
public javax.servlet.ServletOutputStream getOutputStream（）
抛出IOException{
返回servletOutputStream；
}
@凌驾
公共void setContentLength（int len）{
例如getResponseHeaders（）.add（“内容长度”，len+”）；
}
@凌驾
公共无效设置状态（int状态）{
这个状态=状态；
}
@凌驾
public void sendError（int sc，String msg）引发IOException{
这个.status=sc；
如果（msg！=null）{
printWriter.write（msg）；
}
}
@凌驾
公共void发送错误（int sc）引发IOException{
sendError（sc，null）；
}
@凌驾
公共PrintWriter getWriter（）引发IOException{
返回打印机；
}
public void complete（）引发IOException{
试一试{
printWriter.flush（）；
例如sendResponseHeaders（状态，outputStream.size（））；
如果（outputStream.size（）>0）{
例如getResponseBody（）.write（outputStream.toByteArray（））；
}
例如getResponseBody（）.flush（）；
}捕获（例外e）{
e、 printStackTrace（）；
}最后{
例如close（）；
}
}
}
公共HttpHandlerWithServletSupport（HttpServletServlet）{
this.servlet=servlet；
}
@抑制警告（“弃用”）
@凌驾
公共无效句柄（最终HttpExchange）引发IOException{
字节[]inBytes=getBytes（例如getRequestBody（））；
例如getRequestBody（）.close（）；
最终ByteArrayInputStream newInput=新ByteArrayInputStream(
内生细胞）；
最终ServletInputStream为=新ServletInputStream（）{
@凌驾