关于java轻量级httpserver的信息

今天给各位分享java轻量级httpserver的知识，其中也会对进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

1、关于Java JDK1.6自带的HttpServer线程接收请求的问题，哪位对这块比较熟悉，求解决2、java 如何实现 http协议传输3、如何开发自己的httpserver-nanohttpd源码解读4、java 如何搭建http服务器5、用java编写的httpserver如何处理客户端发来的表单数据6、请教如何在嵌入式上实现 http server

关于Java JDK1.6自带的HttpServer线程接收请求的问题，哪位对这块比较熟悉，求解决

输出完了要关闭连接啊。用exc.close(); 执行关闭连接。

HttpServer server = HttpServer.create(new InetSocketAddress(44444),10);

的10 表示队列能接受10个请求。如果队列的请求超过10个，就不再加入队列，而是直接断开连接。

丢失部分请求 就是因为请求超过了队列的10个 所以服务器直接丢弃了啊。

java 如何实现 http协议传输

Java 6 提供了一个轻量级的纯 Java Http 服务器的实现。下面是一个简单的例子：

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

　HttpServerProvider httpServerProvider = HttpServerProvider.provider();

　InetSocketAddress addr = new InetSocketAddress(7778);

　HttpServer httpServer = httpServerProvider.createHttpServer(addr, 1);

　httpServer.createContext(“/myapp/”, new MyHttpHandler());

　httpServer.setExecutor(null);

　httpServer.start();

　System.out.println(“started”);

}

static class MyHttpHandler implements HttpHandler{

　public void handle(HttpExchange httpExchange) throws IOException {

String response = “Hello world!”;

httpExchange.sendResponseHeaders(200, response.length());

OutputStream out = httpExchange.getResponseBody();

out.write(response.getBytes());

out.close();

　}

}

然后，在浏览器中访问

如何开发自己的httpserver-nanohttpd源码解读

现在作为一个开发人员，http server相关的内容已经是无论如何都要了解的知识了。用curl发一个请求，配置一下apache，部署一个web server对我们来说都不是很难，但要想搞清楚这些背后都发生了什么技术细节还真不是很简单的。所以新的系列将是分享我学习Http Server的过程。

NanoHttpd是Github上的一个开源项目，号称只用一个java文件就能创建一个http server，我将通过分析NanoHttpd的源码解析如何开发自己的HttpServer。Github 地址：

在开始前首先简单说明HttpServer的基本要素：

1.能接受HttpRequest并返回HttpResponse

2.满足一个Server的基本特征，能够长时间运行

关于Http协议一般HttpServer都会声明支持Http协议的哪些特性，nanohttpd作为一个轻量级的httpserver只实现了最简单、最常用的功能，不过我们依然可以从中学习很多。

首先看下NanoHttpd类的start函数

[java] view plaincopy

public void start() throws IOException {

myServerSocket = new ServerSocket();

myServerSocket.bind((hostname != null) ? new InetSocketAddress(hostname, myPort) : new InetSocketAddress(myPort));

myThread = new Thread(new Runnable() {

@Override

public void run() {

do {

try {

final Socket finalAccept = myServerSocket.accept();

registerConnection(finalAccept);

finalAccept.setSoTimeout(SOCKET_READ_TIMEOUT);

final InputStream inputStream = finalAccept.getInputStream();

asyncRunner.exec(new Runnable() {

@Override

public void run() {

OutputStream outputStream = null;

try {

outputStream = finalAccept.getOutputStream();

TempFileManager tempFileManager = tempFileManagerFactory.create();

HTTPSession session = new HTTPSession(tempFileManager, inputStream, outputStream, finalAccept.getInetAddress());

while (!finalAccept.isClosed()) {

session.execute();

}

} catch (Exception e) {

// When the socket is closed by the client, we throw our own SocketException

// to break the “keep alive” loop above.

if (!(e instanceof SocketException “NanoHttpd Shutdown”.equals(e.getMessage()))) {

e.printStackTrace();

}

} finally {

safeClose(outputStream);

safeClose(inputStream);

safeClose(finalAccept);

unRegisterConnection(finalAccept);

}

}

});

} catch (IOException e) {

}

} while (!myServerSocket.isClosed());

}

});

myThread.setDaemon(true);

myThread.setName(“NanoHttpd Main Listener”);

myThread.start();

}

1.创建ServerSocket，bind制定端口

2.创建主线程，主线程负责和client建立连接

3.建立连接后会生成一个runnable对象放入asyncRunner中，asyncRunner.exec会创建一个线程来处理新生成的连接。

4.新线程首先创建了一个HttpSession，然后while(true)的执行httpSession.exec。

这里介绍下HttpSession的概念，HttpSession是java里Session概念的实现，简单来说一个Session就是一次httpClient-httpServer的连接，当连接close后session就结束了，如果没结束则session会一直存在。这点从这里的代码也能看到：如果socket不close或者exec没有抛出异常（异常有可能是client段断开连接）session会一直执行exec方法。

一个HttpSession中存储了一次网络连接中server应该保存的信息，比如：URI，METHOD，PARAMS，HEADERS，COOKIES等。

5.这里accept一个client的socket就创建一个独立线程的server模型是ThreadServer模型，特点是一个connection就会创建一个thread，是比较简单、常见的socket server实现。缺点是在同时处理大量连接时线程切换需要消耗大量的资源，如果有兴趣可以了解更加高效的NIO实现方式。

当获得client的socket后自然要开始处理client发送的httprequest。

Http Request Header的parse：

[plain] view plaincopy

// Read the first 8192 bytes.

// The full header should fit in here.

// Apache’s default header limit is 8KB.

// Do NOT assume that a single read will get the entire header at once!

byte[] buf = new byte[BUFSIZE];

splitbyte = 0;

rlen = 0;

{

int read = -1;

try {

read = inputStream.read(buf, 0, BUFSIZE);

} catch (Exception e) {

safeClose(inputStream);

safeClose(outputStream);

throw new SocketException(“NanoHttpd Shutdown”);

}

if (read == -1) {

// socket was been closed

safeClose(inputStream);

safeClose(outputStream);

throw new SocketException(“NanoHttpd Shutdown”);

}

while (read 0) {

rlen += read;

splitbyte = findHeaderEnd(buf, rlen);

if (splitbyte 0)

break;

read = inputStream.read(buf, rlen, BUFSIZE – rlen);

}

}

1.读取socket数据流的前8192个字节，因为http协议中头部最长为8192

2.通过findHeaderEnd函数找到header数据的截止位置，并把位置保存到splitbyte内。

[java] view plaincopy

if (splitbyte rlen) {

inputStream.unread(buf, splitbyte, rlen – splitbyte);

}

parms = new HashMapString, String();

if(null == headers) {

headers = new HashMapString, String();

}

1.http协议规定header和body之间使用两个回车换行分割

1.Http协议第一行是Method URI HTTP_VERSION

2.后面每行都是KEY:VALUE格式的header

3.uri需要经过URIDecode处理后才能使用

4.uri中如果包含？则表示有param，httprequest的param一般表现为:/index.jsp?username=xiaomingid=2

下面是处理cookie，不过这里cookie的实现较为简单，所以跳过。之后是serve方法，serve方法提供了用户自己实现httpserver具体逻辑的很好接口。在NanoHttpd中的serve方法实现了一个默认的简单处理功能。

[java] view plaincopy

发送response的步骤如下：

1.设置mimeType和Time等内容。

2.创建一个PrintWriter，按照HTTP协议依次开始写入内容

3.第一行是HTTP的返回码

4.然后是content-Type

5.然后是Date时间

6.之后是其他的HTTP Header

7.设置Keep-Alive的Header，Keep-Alive是Http1.1的新特性，作用是让客户端和服务器端之间保持一个长链接。

8.如果客户端指定了ChunkedEncoding则分块发送response，Chunked Encoding是Http1.1的又一新特性。一般在response的body比较大的时候使用，server端会首先发送response的HEADER，然后分块发送response的body，每个分块都由chunk length\r\n和chunk data\r\n组成，最后由一个0\r\n结束。

9.如果没指定ChunkedEncoding则需要指定Content-Length来让客户端指定response的body的size，然后再一直写body直到写完为止。

java 如何搭建http服务器

看你具体是想做什么，现在现成的开源的java的http服务器有很多，像tomcat之类的都有http服务器功能，如果你只是单纯的需要用的话，直接用tomcat就好了

但是如果你是做要自己用java实现一个http服务器的话就要稍微麻烦一点

http服务器，本质上还是基于tcpip协议的服务器，首先用java的ServerSocket监听一个端口（也可以使用开源的server组件，如quickserver之类的），然后对客户端发上来的数据进行处理，这里就需要了解一下http协议了，因为上来的数据，都是按照http协议来组织的，你需要将请求数据解析后，将响应数据组织成http的响应，发回给客户端。这样一个简单的http服务器就实现了。

但是这个请求和响应都有很多种类，一个完整的http服务器应该要都能够支持，所以这里面的工作量还是有一点的。

另外，上面说的http服务器只是一个静态的服务器，如果你想让你写的服务具有动态功能，那你的服务器还得提供javaee的容器功能，这样做下去，没准你也能写一个tomcat出来了……

用java编写的httpserver如何处理客户端发来的表单数据

获得客户端发送的变量用request.getAttribute(“变量名”)就可以获得，想交给另一个页面处理就转发到（dispatch）另一个页面

请教如何在嵌入式上实现 http server

一、使用SUN公司在JDK6中提供的新包com.sun.net.httpserver

JDK6提供了一个简单的Http

Server API,据此我们可以构建自己的嵌入式Http

Server,它支持Http和Https协议,提供了HTTP1.1的部分实现，没有被实现的那部分可以通过扩展已有的Http Server

API来实现,程序员必须自己实现HttpHandler接口,HttpServer会调用HttpHandler实现类的回调方法来处理客户端请求,在这里,我们把一个Http请求和它的响应称为一个交换,包装成HttpExchange类,HttpServer负责将HttpExchange传给HttpHandler实现类的回调方法.

实现Http

Server

实现Http

Server比较简单，我就不我做解释，只要看下面的代码就能明白。

实现Https Server

HTTPS是以安全为目标的HTTP通道，简单讲是HTTP的安全版。即HTTP下加入SSL层，HTTPS的安全基础是SSL，SSL

使用证书来进行验证。对于需要使用 SSL 来保证通信安全的客户端和服务器，都必须创建证书。JSSE 使用的证书要用与 J2SE 一起发布的 Java

keytool 来创建。用下列命令来为 HTTP 服务器创建一个 RSA 证书。

prompt keytool -genkey

-keystore serverkeys -keyalg rsa -alias qusay

这个命令会产生一个由别名 qusay

引用的证书，并将其保存在一个名为 serverkeys

的文件中。产生证书的时候，这个工具会提示我们输入一些信息。

下面代码演示了怎样创建自己的Http Server 和Https

Server：

Java代码

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.InetSocketAddress;

import com.sun.net.httpserver.HttpExchange;

import com.sun.net.httpserver.HttpHandler;

import com.sun.net.httpserver.HttpServer;

public class MyHTTPServer {

public static void main(String[] args)

{

try {

//实现HTTP SERVER

HttpServer hs = HttpServer.create(new InetSocketAddress(8888),0);// 设置HttpServer的端口为80

hs.createContext(“/hujun”, new MyHandler());// 用MyHandler类内处理到/的请求

hs.setExecutor(null); // creates a default executor

hs.start();

//实现HTTPS SERVER

HttpsServer hss = HttpsServer.create(new InetSocketAddress(443),0); 　//设置HTTPS端口这443

KeyStore ks = KeyStore.getInstance(“JKS”); //建立证书库

ks.load(new FileInputStream(“证书名” ), “密码”); 　//载入证书

KeyManagerFactory kmf = KeyManagerFactory.getInstance(“SunX509”); 　//建立一个密钥管理工厂

kmf.init(ks, “密码”); 　//初始工厂

SSLContext sslContext = SSLContext.getInstance(“SSLv3”); 　//建立证书实体

sslContext.init(kmf.getKeyManagers(), null, null); //初始化证书

HttpsConfigurator conf = new HttpsConfigurator(sslContext); 　//在https配置

hss.setHttpsConfigurator(conf); //在https server载入配置

hss.setExecutor(null); // creates a default executor

hss.createContext(“/”, new MyHandler());// 用MyHandler类内处理到/的请求

hss.start();

} catch (Exception e){

e.printStackTrace();

}

}

}

class MyHandler implements HttpHandler {

public void handle(HttpExchange t) throws IOException {

InputStream is = t.getRequestBody();

String response = “font color=’#ff0000’come on baby/font”;

t.sendResponseHeaders(200, response.length());

OutputStream os = t.getResponseBody();

os.write(response.getBytes());

os.close();

}

}

二、使用Jetty

Jetty

是一个开源的servlet容器，它为基于Java的web内容，例如JSP和servlet提供运行环境。Jetty是使用Java语言编写的，它的API以一组JAR包的形式发布。开发人员可以将Jetty容器实例化成一个对象，可以迅速为一些独立运行（stand-alone）的Java应用提供网络和web连接。

需要最少的包：

commons-logging.jar

javax.servlet.jar

org.mortbay.jetty.jar

org.mortbay.jmx.jar

下面直接看代码，以嵌入模式启动Jetty，目前貌似不支持HTTPS

Java代码

import org.mortbay.http.HttpContext;

import org.mortbay.http.HttpServer;

import org.mortbay.http.SocketListener;

import org.mortbay.http.handler.ResourceHandler;

public class JettySample {

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

{

//创建Jetty HttpServer对象

HttpServer server = new HttpServer();

//在端口8080上给HttpServer对象绑上一个listener，使之能够接收HTTP请求

SocketListener listener = new SocketListener();

listener.setPort(8080);

server.addListener(listener);

//创建一个HttpContext，处理HTTP请求。

HttpContext context = new HttpContext();

//用setContextPath把Context映射到（/web）URL上。

context.setContextPath(“/web”);

//setResourceBase方法设置文档目录以提供资源

context.setResourceBase(“C:\\j2sdk1.4.1_05”);

//添加资源处理器到HttpContext，使之能够提供文件系统中的文件

context.addHandler(new ResourceHandler());

server.addContext(context);

//启动服务器

server.start();

}

}

Jetty的运行速度较快，而且是轻量级的，可以在Java中可以从test

case中控制其运行。从而可以使自动化测试不再依赖外部环境，顺利实现自动化测试。

三、使用tomcat

embedded

关于java轻量级httpserver和的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。