Java Apache httpserver响应非常慢（httpcore 4.3.2 libs）

我正在使用httpcore库4.3.2创建一个自定义http服务器，以便与一些客户端（android设备）通信

客户端设法与服务器通信（发布xml），但服务器的响应非常慢

我的代码基于apache示例的ElementalHttpServer。我能在其他地方找到更好的httpcore库示例吗？ 此外，我找不到如何设置参数或微调httpserver，因为HttParams库已被弃用

如果我使用com.sun.net.httpserver.httpserver-httpserver，我的客户端连接没有问题。还是使用apaches更好

提前谢谢

这是我使用的代码：

import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.ServerSocket;
import java.net.Socket;
import javax.net.ssl.SSLServerSocketFactory;
import org.apache.http.ConnectionClosedException;
import org.apache.http.HttpConnectionFactory;
import org.apache.http.HttpEntity;
import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpException;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.HttpServerConnection;
import org.apache.http.HttpStatus;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.DefaultBHttpServerConnection;
import org.apache.http.impl.DefaultBHttpServerConnectionFactory;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.protocol.HttpProcessor;
import org.apache.http.protocol.HttpProcessorBuilder;
import org.apache.http.protocol.HttpRequestHandler;
import org.apache.http.protocol.HttpService;
import org.apache.http.protocol.ResponseConnControl;
import org.apache.http.protocol.ResponseContent;
import org.apache.http.protocol.ResponseDate;
import org.apache.http.protocol.ResponseServer;
import org.apache.http.protocol.UriHttpRequestHandlerMapper;
import org.apache.http.util.EntityUtils;

public class Thread_Main_httpcore2 implements Runnable {

    public Thread_Main_httpcore2() {

    }//Thread_Main()

    @Override
    public void run() {
        int port = 20010;

        // Set up the HTTP protocol processor
        HttpProcessor httpproc = HttpProcessorBuilder.create()
                .add(new ResponseDate())
                .add(new ResponseServer("Test/1.1"))
                .add(new ResponseContent())
                .add(new ResponseConnControl()).build();

        // Set up request handlers
        UriHttpRequestHandlerMapper reqistry = new UriHttpRequestHandlerMapper();

        //// Set up the HTTP service
        HttpService httpService = new HttpService(httpproc, reqistry);

        reqistry.register("*", new Thread_Main_httpcore2.HttpReqHandler());

        SSLServerSocketFactory sf = null;

        try {
            Thread t = new RequestListenerThread(port, httpService, sf);
            t.setDaemon(false);
            t.start();
        } catch (Exception ex) {
            ex.printStackTrace();
        }

    }

    static class HttpReqHandler implements HttpRequestHandler {

        public HttpReqHandler() {
            super();
        }

        public void handle(
                final HttpRequest request,
                final HttpResponse response,
                final HttpContext context) throws HttpException, IOException {

                String xml_stream="";


            if (request instanceof HttpEntityEnclosingRequest) {
                HttpEntity entity = ((HttpEntityEnclosingRequest) request).getEntity();
                byte[] entityContent;
                if (entity == null) {
                    entityContent = new byte[0];
                } else {
                    entityContent = EntityUtils.toByteArray(entity);
                }

                //byte[] entityContent = EntityUtils.toByteArray(entity);
                System.out.println("Incoming entity content (bytes): " + entityContent.length);

                xml_stream = new String(entityContent);
            }

            StringBuilder resp_xml = new StringBuilder();
                resp_xml.append("Returns an xml to the client");

            StringEntity entity;
            try {
                response.setStatusCode(HttpStatus.SC_OK);
                entity = new StringEntity(resp_xml.toString(), ContentType.create("text/html", "UTF-8"));
                response.setEntity(entity);

            } catch (Exception ex_send_resp) {
                System.out.println("HttpFileHandler.ex_send_resp "+ ex_send_resp.toString());
            }

        }

    }

    static class RequestListenerThread extends Thread {

        private final HttpConnectionFactory<DefaultBHttpServerConnection> connFactory;
        private final ServerSocket serversocket;
        private final HttpService httpService;

        public RequestListenerThread(
                final int port,
                final HttpService httpService,
                final SSLServerSocketFactory sf) throws IOException {
            this.connFactory = DefaultBHttpServerConnectionFactory.INSTANCE;
            this.serversocket = sf != null ? sf.createServerSocket(port) : new ServerSocket(port);
            this.httpService = httpService;
        }

        @Override
        public void run() {
            System.out.println("Listening on port " + this.serversocket.getLocalPort());
            while (!Thread.interrupted()) {
                try {
                    // Set up HTTP connection
                    Socket socket = this.serversocket.accept();
                    System.out.println("Incoming connection from " + socket.getInetAddress());
                    HttpServerConnection conn = this.connFactory.createConnection(socket);

                    // Start worker thread
                    Thread t = new WorkerThread(this.httpService, conn);
                    t.setDaemon(true);
                    t.start();
                } catch (InterruptedIOException ex) {
                    break;
                } catch (IOException e) {
                    System.err.println("I/O error initialising connection thread: "
                            + e.getMessage());
                    break;
                }
            }
        }
    }

    static class WorkerThread extends Thread {

        private final HttpService httpservice;
        private final HttpServerConnection conn;

        public WorkerThread(
                final HttpService httpservice,
                final HttpServerConnection conn) {
            super();
            this.httpservice = httpservice;
            this.conn = conn;
        }

        @Override
        public void run() {
            System.out.println("New connection thread");
            HttpContext context = new BasicHttpContext(null);
            try {
                while (!Thread.interrupted() && this.conn.isOpen()) {
                    this.httpservice.handleRequest(this.conn, context);
                }
            } catch (ConnectionClosedException ex) {
                System.err.println("Client closed connection");
            } catch (IOException ex) {
                System.err.println("I/O error: " + ex.getMessage());
            } catch (HttpException ex) {
                System.err.println("Unrecoverable HTTP protocol violation: " + ex.getMessage());
            } finally {
                try {
                    this.conn.shutdown();
                } catch (IOException ignore) {
                }
            }
        }

    }

}

import java.io.IOException；
导入java.io.InterruptedIOException；
导入java.net.ServerSocket；
导入java.net.Socket；
导入javax.net.ssl.SSLServerSocketFactory；
导入org.apache.http.ConnectionClosedException；
导入org.apache.http.HttpConnectionFactory；
导入org.apache.http.HttpEntity；
导入org.apache.http.HttpEntityEnclosingRequest；
导入org.apache.http.HttpException；
导入org.apache.http.HttpRequest；
导入org.apache.http.HttpResponse；
导入org.apache.http.HttpServerConnection；
导入org.apache.http.HttpStatus；
导入org.apache.http.entity.ContentType；
导入org.apache.http.entity.StringEntity；
导入org.apache.http.impl.DefaultBHttpServerConnection；
导入org.apache.http.impl.DefaultBHttpServerConnectionFactory；
导入org.apache.http.protocol.BasicHttpContext；
导入org.apache.http.protocol.HttpContext；
导入org.apache.http.protocol.HttpProcessor；
导入org.apache.http.protocol.HttpProcessorBuilder；
导入org.apache.http.protocol.HttpRequestHandler；
导入org.apache.http.protocol.HttpService；
导入org.apache.http.protocol.responseCONTROL；
导入org.apache.http.protocol.ResponseContent；
导入org.apache.http.protocol.ResponseDate；
导入org.apache.http.protocol.ResponseServer；
导入org.apache.http.protocol.UriHttpRequestHandlerMapper；
导入org.apache.http.util.EntityUtils；
公共类线程\u Main\u httpcore2实现可运行{
公共线程\u Main\u httpcore2（）{
}//线程_Main（）
@凌驾
公开募捐{
int端口=20010；
//设置HTTP协议处理器
HttpProcessor httpproc=HttpProcessorBuilder.create（）
.add（新的ResponseDate（））
.添加（新响应服务器（“测试/1.1”））
.add（新的ResponseContent（））
.add（新响应控制（））.build（）；
//设置请求处理程序
UriHttpRequestHandlerMapper-Requistry=新的UriHttpRequestHandlerMapper（）；
////设置HTTP服务
HttpService HttpService=新的HttpService（httpproc，Requistry）；
requistry.register（“*”，新线程\u Main\u httpcore2.HttpReqHandler（））；
SSLServerSocketFactory sf=null；
试一试{
线程t=新的RequestListenerThread（端口，httpService，sf）；
t、 setDaemon（false）；
t、 start（）；
}捕获（例外情况除外）{
例如printStackTrace（）；
}
}
静态类HttpRequestHandler实现HttpRequestHandler{
公共HttpReqHandler（）{
超级（）；
}
公共无效句柄(
最终HttpRequest请求，
最终HttpResponse响应，
最终HttpContext上下文）引发HttpException，IOException{
字符串xml_stream=“”；
if（HttpEntityEnclosingRequest的请求实例）{
HttpEntity实体=（（HttpEntityEnclosingRequest）请求）.getEntity（）；
字节[]entityContent；
if（实体==null）{
entityContent=新字节[0]；
}否则{
entityContent=EntityUtils.toByteArray（实体）；
}
//字节[]entityContent=EntityUtils.toByteArray（实体）；
System.out.println（“传入实体内容（字节）：”+entityContent.length）；
xml_stream=新字符串（entityContent）；
}
StringBuilder resp_xml=新的StringBuilder（）；
append（“将xml返回给客户端”）；
实体；
试一试{
response.setStatusCode（HttpStatus.SC_OK）；
entity=newStringEntity（resp_xml.toString（），ContentType.create（“text/html”，“UTF-8”）；
响应。设置实体（实体）；
}捕获（异常ex_send_resp）{
System.out.println（“HttpFileHandler.ex_send_resp”+ex_send_resp.toString（））；
}
}
}
静态类RequestListenerThread扩展线程{
私有最终HttpConnectionFactory；
私有最终服务器套接字服务器套接字；
专用最终HttpService HttpService；
公共RequestListenerThread(
最终国际端口，
最终HttpService HttpService，
最终SSLServerSocketFactory（sf）引发IOException{
this.connFactory=DefaultBHttpServerConnectionFactory.INSTANCE；
this.serversocket=sf！=null？sf.createServerSocket（端口）：新的serversocket（端口）；
this.httpService=httpService；
}
@凌驾
公开募捐{
System.out.println（“侦听端口”+this.serversocket.getLocalPort（））；
而（！Thread.interrupted（））{
试一试{
//设置HTTP连接
套接字=this.serversocket.accept（）；
System.out.println（“来自”+socket.getInetAddress（）的传入连接）；
HttpServerConnection conn=this.connFactory.createConnection（套接字）；
//启动工作线程
线程t=新的WorkerThread（this.httpService，conn）；
t、 setDaemon（true）；