基于httpcore(httpclient component)搭建轻量级http服务器

下面是apache官网例子

服务器端接受请求，实现接收文件请求处理器

import java.io.File;

import java.io.IOException;

import java.io.InterruptedIOException;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.URL;

import java.net.URLDecoder;

import java.nio.charset.Charset;

import java.security.KeyStore;

import java.util.Locale;

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.MethodNotSupportedException;

import org.apache.http.entity.ContentType;

import org.apache.http.entity.FileEntity;

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;

import javax.net.ssl.KeyManager;

import javax.net.ssl.KeyManagerFactory;

import javax.net.ssl.SSLContext;

import javax.net.ssl.SSLServerSocketFactory;

/**

 * Basic, yet fully functional and spec compliant, HTTP/1.1 file server.

 */

public class ElementalHttpServer {

    public static void main(String[] args) throws Exception {

        if (args.length < 1) {

            System.err.println("Please specify document root directory");

            System.exit(1);

        }

        // Document root directory

        String docRoot = args[0];

        int port = 8080;

        if (args.length >= 2) {

            port = Integer.parseInt(args[1]);

        }

        // 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();

        reqistry.register("*", new HttpFileHandler(docRoot));

        // Set up the HTTP service

        HttpService httpService = new HttpService(httpproc, reqistry);

        SSLServerSocketFactory sf = null;

        if (port == 8443) {

            // Initialize SSL context

            ClassLoader cl = ElementalHttpServer.class.getClassLoader();

            URL url = cl.getResource("my.keystore");

            if (url == null) {

                System.out.println("Keystore not found");

                System.exit(1);

            }

            KeyStore keystore  = KeyStore.getInstance("jks");

            keystore.load(url.openStream(), "secret".toCharArray());

            KeyManagerFactory kmfactory = KeyManagerFactory.getInstance(

                    KeyManagerFactory.getDefaultAlgorithm());

            kmfactory.init(keystore, "secret".toCharArray());

            KeyManager[] keymanagers = kmfactory.getKeyManagers();

            SSLContext sslcontext = SSLContext.getInstance("TLS");

            sslcontext.init(keymanagers, null, null);

            sf = sslcontext.getServerSocketFactory();

        }

        Thread t = new RequestListenerThread(port, httpService, sf);

        t.setDaemon(false);

        t.start();

    }

    static class HttpFileHandler implements HttpRequestHandler  {

        private final String docRoot;

        public HttpFileHandler(final String docRoot) {

            super();

            this.docRoot = docRoot;

        }

        public void handle(

                final HttpRequest request,

                final HttpResponse response,

                final HttpContext context) throws HttpException, IOException {

            String method = request.getRequestLine().getMethod().toUpperCase(Locale.ENGLISH);

            if (!method.equals("GET") && !method.equals("HEAD") && !method.equals("POST")) {

                throw new MethodNotSupportedException(method + " method not supported");

            }

            String target = request.getRequestLine().getUri();

            if (request instanceof HttpEntityEnclosingRequest) {

                HttpEntity entity = ((HttpEntityEnclosingRequest) request).getEntity();

                byte[] entityContent = EntityUtils.toByteArray(entity);

                System.out.println("Incoming entity content (bytes): " + entityContent.length);

            }

            final File file = new File(this.docRoot, URLDecoder.decode(target, "UTF-8"));

            if (!file.exists()) {

                response.setStatusCode(HttpStatus.SC_NOT_FOUND);

                StringEntity entity = new StringEntity(

                        "<html><body><h1>File" + file.getPath() +

                        " not found</h1></body></html>",

                        ContentType.create("text/html", "UTF-8"));

                response.setEntity(entity);

                System.out.println("File " + file.getPath() + " not found");

            } else if (!file.canRead() || file.isDirectory()) {

                response.setStatusCode(HttpStatus.SC_FORBIDDEN);

                StringEntity entity = new StringEntity(

                        "<html><body><h1>Access denied</h1></body></html>",

                        ContentType.create("text/html", "UTF-8"));

                response.setEntity(entity);

                System.out.println("Cannot read file " + file.getPath());

            } else {

                response.setStatusCode(HttpStatus.SC_OK);

                FileEntity body = new FileEntity(file, ContentType.create("text/html", (Charset) null));

                response.setEntity(body);

                System.out.println("Serving file " + file.getPath());

            }

        }

    }

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

            }

        }

    }

}

客户端get请求实现类

import java.net.Socket;

import org.apache.http.ConnectionReuseStrategy;

import org.apache.http.HttpHost;

import org.apache.http.HttpResponse;

import org.apache.http.impl.DefaultBHttpClientConnection;

import org.apache.http.impl.DefaultConnectionReuseStrategy;

import org.apache.http.message.BasicHttpRequest;

import org.apache.http.protocol.HttpCoreContext;

import org.apache.http.protocol.HttpProcessor;

import org.apache.http.protocol.HttpProcessorBuilder;

import org.apache.http.protocol.HttpRequestExecutor;

import org.apache.http.protocol.RequestConnControl;

import org.apache.http.protocol.RequestContent;

import org.apache.http.protocol.RequestExpectContinue;

import org.apache.http.protocol.RequestTargetHost;

import org.apache.http.protocol.RequestUserAgent;

import org.apache.http.util.EntityUtils;

/**

 * Elemental example for executing multiple GET requests sequentially.

 */

public class ElementalHttpGet {

    public static void main(String[] args) throws Exception {

        HttpProcessor httpproc = HttpProcessorBuilder.create()

            .add(new RequestContent())

            .add(new RequestTargetHost())

            .add(new RequestConnControl())

            .add(new RequestUserAgent("Test/1.1"))

            .add(new RequestExpectContinue(true)).build();

        HttpRequestExecutor httpexecutor = new HttpRequestExecutor();

        HttpCoreContext coreContext = HttpCoreContext.create();

        HttpHost host = new HttpHost("localhost", 8080);

        coreContext.setTargetHost(host);

        DefaultBHttpClientConnection conn = new DefaultBHttpClientConnection(8 * 1024);

        ConnectionReuseStrategy connStrategy = DefaultConnectionReuseStrategy.INSTANCE;

        try {

            String[] targets = {

                    "/",

                    "/servlets-examples/servlet/RequestInfoExample",

                    "/somewhere%20in%20pampa"};

            for (int i = 0; i < targets.length; i++) {

                if (!conn.isOpen()) {

                    Socket socket = new Socket(host.getHostName(), host.getPort());

                    conn.bind(socket);

                }

                BasicHttpRequest request = new BasicHttpRequest("GET", targets[i]);

                System.out.println(">> Request URI: " + request.getRequestLine().getUri());

                httpexecutor.preProcess(request, httpproc, coreContext);

                HttpResponse response = httpexecutor.execute(request, conn, coreContext);

                httpexecutor.postProcess(response, httpproc, coreContext);

                System.out.println("<< Response: " + response.getStatusLine());

                System.out.println(EntityUtils.toString(response.getEntity()));

                System.out.println("==============");

                if (!connStrategy.keepAlive(response, coreContext)) {

                    conn.close();

                } else {

                    System.out.println("Connection kept alive...");

                }

            }

        } finally {

            conn.close();

        }

    }

}

客户端post请求实现类

import java.io.ByteArrayInputStream;

import java.net.Socket;

import org.apache.http.ConnectionReuseStrategy;

import org.apache.http.Consts;

import org.apache.http.HttpEntity;

import org.apache.http.HttpHost;

import org.apache.http.HttpResponse;

import org.apache.http.entity.ByteArrayEntity;

import org.apache.http.entity.ContentType;

import org.apache.http.entity.InputStreamEntity;

import org.apache.http.entity.StringEntity;

import org.apache.http.impl.DefaultBHttpClientConnection;

import org.apache.http.impl.DefaultConnectionReuseStrategy;

import org.apache.http.message.BasicHttpEntityEnclosingRequest;

import org.apache.http.protocol.HttpCoreContext;

import org.apache.http.protocol.HttpProcessor;

import org.apache.http.protocol.HttpProcessorBuilder;

import org.apache.http.protocol.HttpRequestExecutor;

import org.apache.http.protocol.RequestConnControl;

import org.apache.http.protocol.RequestContent;

import org.apache.http.protocol.RequestExpectContinue;

import org.apache.http.protocol.RequestTargetHost;

import org.apache.http.protocol.RequestUserAgent;

import org.apache.http.util.EntityUtils;

/**

 * Elemental example for executing multiple POST requests sequentially.

 */

public class ElementalHttpPost {

    public static void main(String[] args) throws Exception {

        HttpProcessor httpproc = HttpProcessorBuilder.create()

            .add(new RequestContent())

            .add(new RequestTargetHost())

            .add(new RequestConnControl())

            .add(new RequestUserAgent("Test/1.1"))

            .add(new RequestExpectContinue(true)).build();

        HttpRequestExecutor httpexecutor = new HttpRequestExecutor();

        HttpCoreContext coreContext = HttpCoreContext.create();

        HttpHost host = new HttpHost("localhost", 8080);

        coreContext.setTargetHost(host);

        DefaultBHttpClientConnection conn = new DefaultBHttpClientConnection(8 * 1024);

        ConnectionReuseStrategy connStrategy = DefaultConnectionReuseStrategy.INSTANCE;

        try {

            HttpEntity[] requestBodies = {

                    new StringEntity(

                            "This is the first test request",

                            ContentType.create("text/plain", Consts.UTF_8)),

                    new ByteArrayEntity(

                            "This is the second test request".getBytes("UTF-8"),

                            ContentType.APPLICATION_OCTET_STREAM),

                    new InputStreamEntity(

                            new ByteArrayInputStream(

                                    "This is the third test request (will be chunked)"

                                    .getBytes("UTF-8")),

                            ContentType.APPLICATION_OCTET_STREAM)

            };

            for (int i = 0; i < requestBodies.length; i++) {

                if (!conn.isOpen()) {

                    Socket socket = new Socket(host.getHostName(), host.getPort());

                    conn.bind(socket);

                }

                BasicHttpEntityEnclosingRequest request = new BasicHttpEntityEnclosingRequest("POST",

                        "/servlets-examples/servlet/RequestInfoExample");

                request.setEntity(requestBodies[i]);

                System.out.println(">> Request URI: " + request.getRequestLine().getUri());

                httpexecutor.preProcess(request, httpproc, coreContext);

                HttpResponse response = httpexecutor.execute(request, conn, coreContext);

                httpexecutor.postProcess(response, httpproc, coreContext);

                System.out.println("<< Response: " + response.getStatusLine());

                System.out.println(EntityUtils.toString(response.getEntity()));

                System.out.println("==============");

                if (!connStrategy.keepAlive(response, coreContext)) {

                    conn.close();

                } else {

                    System.out.println("Connection kept alive...");

                }

            }

        } finally {

            conn.close();

        }

    }

}

代码不需要过多的解释，参考官网的例子我们可以很容易构建简单的http服务器

基于httpcore(httpclient component)搭建轻量级http服务器的更多相关文章

Zimg—轻量级图片服务器搭建利器
在一个互联网应用中,图片扮演着越来越重要的角色.有稳定的可扩展的图片存储服务器就显得尤为的重要,云厂商们提供了便利的图片存储服务,花钱就可以解决了.这里简单介绍一个开源的一个分布式图片存储服务器--z ...
基于 Dropbear & Zlib 搭建轻量级的ssh server
[目的] 移植dropbear & zlib 在AM335X开发板上搭建轻量级的ssh server [环境] 1. Ubuntu 16.04发行版 2. MC183平台 3. 交叉编译 ...
搭建私有 Nuget 服务器教程(1)
对于 .NET 开发者来说,nuget 是必不可少的程序包管理工具.相应地,大部分开发团队都需要在内部搭建 Nuget 服务器,以管理私有 nupkg 包.本教程所使用的 Nuget 服务器,不是微软 ...
基于netty http协议栈的轻量级流程控制组件的实现
今儿个是冬至,所谓“冬大过年”,公司也应景五点钟就放大伙儿回家吃饺子喝羊肉汤了,而我本着极高的职业素养依然坚持留在公司(实则因为没饺子吃没羊肉汤喝,只能呆公司吃食堂……).趁着这一个多小时的时间,想跟 ...
Centos6一键搭建L2TP VPN服务器
用VPS在墙上打洞还有一种叫L2TP,也是常见的一种方式.本脚本结合了L2TP(Layer Tunneling Protocol)和IPSec(Internet Protocol Security), ...
面向服务体系架构（SOA）和数据仓库（DW）的思考基于 IBM 产品体系搭建基于 SOA 和 DW 的企业基础架构平台
面向服务体系架构(SOA)和数据仓库(DW)的思考基于 IBM 产品体系搭建基于 SOA 和 DW 的企业基础架构平台当前业界对面向服务体系架构(SOA)和数据仓库(Data Warehouse, ...
Nginx搭建flv视频点播服务器
Nginx搭建flv视频点播服务器前一段时间使用Nginx搭建的多媒体服务器只能在缓冲过的时间区域内拖放, 而不能拖放到未缓冲的地方. 这就带来了一个问题: 如果视频限速的速率很小, 那么客户端观看 ...
基于CentOS与VmwareStation10搭建Oracle11G RAC 64集群环境：4.安装Oracle RAC FAQ-4.4.无法图形化安装Grid Infrastructure
无法图形化安装: [grid@linuxrac1 grid]$ ./runInstaller Starting Oracle Universal Installer... Checking Temp ...
JavaEE开发基于Eclipse的环境搭建以及Maven Web App的创建
本篇博客就完整的来聊一下如何在Eclipse中创建的Maven Project.本篇博客是JavaEE开发的开篇,也是基础.本篇博客的内容干货还是比较多的,而且比较实用,并且都是采用目前最新版本的工具 ...

随机推荐

【linux】less &&more
命令 : less [文件名] ...
【python】smtp邮件发送
纯文本: #!/usr/bin/env python3 #coding: utf-8 import smtplib from email.mime.text import MIMEText from ...
WebHttpBinding.ReaderQuotas 无法设置或者无法点出来
项目需要引用System.Runtime.Serialization.dll 才能设置各项值: binding.ReaderQuotas.MaxDepth = ; binding.ReaderQuot ...
memcache 命令行操作
今天找了很久,如何在服务器直接查看memcache 的值, 来确定php中memcache是否已经写进去了 https://www.ttlsa.com/memcache/memcache-list-a ...
python3 关联规则Apriori代码模版
#!/usr/bin/env python3 # -*- coding: utf-8 -*- from numpy import * def loadDataSet(): return [['a', ...
python 多态、多继承、函数重写、迭代器
用于类的函数 issubclass(cls,class_or_tuple) 判断一个类是否继承自其他的类,如果此类cls是class或tuole中的一个派生(子类)则返回True,否则返回False ...
python的requests模块
使用python进行接口测试得时候可以使用requests模块,是基于 urllib,采用 Apache2 Licensed 开源协议的 HTTP 库安装requests是模块 pip instal ...
安装Android studio出现'tools.jar' seems to be not in Android Studio classpath......的解决方法
安装Android studio出现'tools.jar' seems to be not in Android Studio classpath......的解决方法原创 2015年07月31日 ...
8种常被忽视的SQL错误用法
作者:一杯甜酒原文:https://blog.csdn.net/u012562943/article/details/71403500 sql语句的执行顺序: FROM <left_table ...
Angular: Can't bind to 'ngModel' since it isn't a known property of 'input'问题解决
https://blog.csdn.net/h363659487/article/details/78619225 最初使用 [(ngModel)] 做双向绑定时,如果遇见Angular: Can't ...

基于httpcore(httpclient component)搭建轻量级http服务器

基于httpcore(httpclient component)搭建轻量级http服务器的更多相关文章

随机推荐

热门专题