基于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开发的开篇,也是基础.本篇博客的内容干货还是比较多的,而且比较实用,并且都是采用目前最新版本的工具 ...

随机推荐

log4net 使用指南，最常遇到的问题整理。。。
一. Log4net特征 Log4net是一个用于.NET开发环境的日志记录组件,由于它的超快及超灵活,很多大型的应用都会用到. 它有如下特点: 1.自定义日志输出级别 ...
Linux操作系统多线程信号总结
linux 多线程信号编程总结 linux 多线程信号总结(一) 1. 在多线程环境下,产生的信号是传递给整个进程的,一般而言,所有线程都有机会收到这个信号,进程在收到信号的的线程上下文执行信号处理函 ...
Java 将字符串转换为字符数组 toCharArray()
Java 手册 toCharArray public char[] toCharArray() 将此字符串转换为一个新的字符数组. 返回: 一个新分配的字符数组,它的长度是此字符串的长度,它的内容被初 ...
django rest_framework 框架的使用02
rest_framework 访问频率的限制(节流) 对于用户访问频率的显示,rest_framework 也有自己的类进行约束先来一个自己的基于它的类的节流类的限制 class VisitCont ...
python数据库连接池基于DBUtils
DBUtils模块的使用的两种方式 DBUtils是Python的一个用于实现数据库连接池的模块安装 pip install DBUtils 1.使用姿势一(不建议此方法) 为每个线程 (资源占用过 ...
WPF DatePicker 默认显示当前时间
两种方法: 1.通过后台赋值: this.datePicker.SelectedDate = DateTime.Now; 2.前台控件的属性直接赋值 xmlns:sys="clr-names ...
Delphi7 [Fatal Error] ClassPas.pas(8): File not found: 'DesignIntf.dcu'
Delphi7 [Fatal Error] ClassPas.pas(8): File not found: 'DesignIntf.dcu' Add path to Project>Optio ...
XE: Changing the default http port
Oracle XE uses the embedded http listener that comes with the XML DB (XDB) to serve http requests. T ...
获取当前函数名 __FUNCTION__ 的使用<转>
vs项目中见过这种获取当前函数名的调用.觉得挺方便的就记录一下. ============================================================== 转载地 ...
servlet中关于下载
package com.huawei.response; import java.io.BufferedInputStream;import java.io.IOException;import ja ...

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

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

随机推荐

热门专题