搭建轻量级http服务器

下面是apache官网例子

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

import java.io.File;

import java.io.IOException;

import java.io.InterruptedIOException;

import https://www.360docs.net/doc/6a5206175.html,.ServerSocket;

import https://www.360docs.net/doc/6a5206175.html,.Socket;

import https://www.360docs.net/doc/6a5206175.html,.URL;

import https://www.360docs.net/doc/6a5206175.html,.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 https://www.360docs.net/doc/6a5206175.html,.ssl.KeyManager;

import https://www.360docs.net/doc/6a5206175.html,.ssl.KeyManagerFactory;

import https://www.360docs.net/doc/6a5206175.html,.ssl.SSLContext;

import https://www.360docs.net/doc/6a5206175.html,.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(

"

File" + file.getPath() +

" not found

",

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(

"

Access

denied

",

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 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 https://www.360docs.net/doc/6a5206175.html,.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 https://www.360docs.net/doc/6a5206175.html,.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服务器