java http服务器 框架_基于Java的Http服务器几种模式演进

首先抛出问题：

程序1---错误版本

import java.io.IOException;

import java.io.InputStream;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

public class HttpSimpleServer

{

public void startServer() throws IOException

{

ServerSocket ss = new ServerSocket(10021);

Socket so = ss.accept();

InputStream in = so.getInputStream();

PrintWriter pw = new PrintWriter(so.getOutputStream(),true);

byte[] bytes = new byte[1024];

int num = 0;

while((num = in.read(bytes))!=-1)

{

String str = new String(bytes,0,num);

if(str.trim().length() <= 0)

{

break;

}

System.out.print(str);

}

pw.println(" 今天天气真好");

so.close();

ss.close();

}

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

{

new HttpSimpleServer().startServer();

}

}

上面的代码是一个基于Java的简单的HTTP服务器，输入访问地址：http://localhost:10021/ 进行访问

服务端输出：

GET /favicon.ico HTTP/1.1

Host: localhost:10021

Connection: keep-alive

User-Agent: Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.152 Safari/537.36

Accept-Encoding: gzip, deflate, sdch

Accept-Language: zh-CN,zh;q=0.8,en;q=0.6

而浏览器一直卡着，看不到输出的信息。

当浏览器访问连接:http://localhost:10021/的时候，服务端将一直阻塞，浏览器收不到响应。

出现无响应的原因在于：

浏览器和你的http服务器建立连接后，先发送请求头信息，然后并不会断开连接，所以read方法就会一直阻塞，等待服务器关闭连接(只有关闭后才会返回-1)。我么知道TCP断开连接使用的是四次分手原则，之所以使用四次分手原则，是因为TCP是个全双工的管道，每一端既可以发送也可以接受，当一端调用socket.close()之后，会发送fin关闭连接的报文(表明自己不再发送数据了，但是可以接收数据)，对方收到之后，发送ACK报文，确认自己已经收到所有信息，这样一端关闭了发送，一端关闭了接收，当被动关闭方发送完毕之后，发送fin给主动关闭方，从而全部关闭.

于是Http的TCP连接的主动关闭方一般都是服务端，是在服务端的Response通过TCP发送出去之后再调用socket.close()方法的。read方法会阻塞(流没结束并且没有断开信号)，这是主要原因。

public abstract int read()

throws IOException

从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。在输入数据可用、检测到流末尾或者抛出异常前，此方法一直阻塞。

子类必须提供此方法的一个实现。返回：下一个数据字节；如果到达流的末尾，则返回 -1。抛出：

其实浏览器此时正在等待你的响应，所以我们需要自己界定请求头的范围。请求头的结束标志是两个连续的换行(这个换行是有标准规定的，必须为\r\n而不是只使用\n)，即\r\n\r\n。于是我们在收到这个字符串后就可以不再读取数据，而开始写入数据了。

其他就是该服务程序是一次性的，访问之后就不能再访问了，起码应该写成可以多次访问，进一步可以修改成可以同时多次访问，即多线程访问的。

还有问题就是返回信息没有HTTP响应头部，可能会出现乱码或者浏览器无法识别等问题

程序2--修正版本1：

import java.io.IOException;

import java.io.InputStream;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.Scanner;

/**

* @author 作者 E-mail:

* @version 创建时间：2015-8-27 下午09:02:16 类说明

*/

public class HttpSimpleServer2

{

public void startServer() throws IOException

{

// 建立ServerSocket

ServerSocket serso = new ServerSocket(10021);

// 获取客户端对象

Socket so = serso.accept();

// 获取相关流对象

InputStream in = so.getInputStream();

PrintWriter pw = new PrintWriter(so.getOutputStream(), true);

Scanner sc = new Scanner(in);

sc.useDelimiter("\r\n\r\n");

if (sc.hasNext())

{

String header = sc.next();

System.out.println(header);

}

// HHTP响应头部信息

pw.print("HTTP/1.0 200 OK\r\n");

pw.print("Content-type:text/html; charset=utf-8\r\n");

pw.print("\r\n");

// HTTP响应内容

pw.println("good");

sc.close();

so.close();

serso.close();

}

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

{

new HttpSimpleServer2().startServer();

}

}

服务端输出：

GET / HTTP/1.1

Host: localhost:10021

Connection: keep-alive

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8

User-Agent: Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.152 Safari/537.36

Accept-Encoding: gzip, deflate, sdch

Accept-Language: zh-CN,zh;q=0.8,en;q=0.6

缺点：①不能多线程访问 ②只能访问一次，程序就运行结束了

程序3---修正版本2：

import java.io.IOException;

import java.io.InputStream;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.Scanner;

import java.util.concurrent.TimeUnit;

/**

* 现在这个请求仍然是阻塞的，单线程的，同一时刻只能有一个程序进行访问

* @author 作者 E-mail:

* @version 创建时间：2015-8-27 下午09:08:26 类说明

*/

public class HttpSimpleServer3

{

public void startServer() throws IOException, InterruptedException

{

// 建立ServerSocket 这里默认的backlog 是50 可以有50个请求在排队等待

ServerSocket serso = new ServerSocket(10021);

while (true)

{

// 获取客户端对象

Socket so = serso.accept();

// 获取相关流对象

InputStream in = so.getInputStream();

PrintWriter pw = new PrintWriter(so.getOutputStream(), true);

Scanner sc = new Scanner(in);

sc.useDelimiter("\r\n\r\n");

if (sc.hasNext())

{

String header = sc.next();

System.out.println(header);

}

// HHTP响应头部信息

pw.print("HTTP/1.0 200 OK\r\n");

pw.print("Content-type:text/html; charset=utf-8\r\n");

pw.print("\r\n");

// HTTP响应内容

pw.println("good");

pw.flush();

Thread.sleep(100000); //单线程程序在多个同时访问的时候就会受限

sc.close();

//在sc关闭之前是写不出去的，因为没有flush

so.close();

}

}

public static void main(String[] args) throws IOException, InterruptedException

{

new HttpSimpleServer3().startServer();

}

}

使用while循环持续监听client连接

缺点:仍旧不能多线程访问

程序4:----修正版本3

import java.io.IOException;

import java.io.InputStream;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.Scanner;

/**

* @author 作者 E-mail:

* @version 创建时间：2015-8-27 下午09:16:50 类说明

*/

class Runner implements Runnable

{

private final Socket socket;

public Runner(Socket socket)

{

this.socket = socket;

}

@Override

public void run()

{

// 获取相关流对象

try

{

InputStream in = socket.getInputStream();

PrintWriter pw = new PrintWriter(socket.getOutputStream(), true);

Scanner sc = new Scanner(in);

sc.useDelimiter("\r\n\r\n");

if (sc.hasNext())

{

String header = sc.next();

System.out.println(header);

}

// HTTP响应头部信息

pw.print("HTTP/1.0 200 OK\r\n");

pw.print("Content-type:text/html; charset=utf-8\r\n");

pw.print("\r\n");

// HTTP响应内容

pw.println("good");

pw.flush();

try

{

Thread.sleep(100000);

}

catch(InterruptedException e)

{

e.printStackTrace();

}

sc.close(); //服务器端的关闭请求。

socket.close();

}

catch(IOException e1)

{

// TODO Auto-generated catch block

e1.printStackTrace();

}

}

}

//实现了多线程的访问，但是效率明显有点低哈哈哈哈

public class HttpSimpleServer4

{

public void startServer() throws IOException

{

// 建立ServerSocket 这里默认的backlog 是50 可以有50个请求在排队等待

ServerSocket serso = new ServerSocket(10021);

while (true)

{

// 获取客户端对象

Socket so = serso.accept();

Runnable runner = new Runner(so);

Thread thread = new Thread(runner);

// run就相当于在本线程当中调用，start才是启动的新线程

thread.start();

}

}

public static void main(String[] args) throws IOException,

InterruptedException

{

new HttpSimpleServer4().startServer();

}

}

实现了多线程访问，

缺点：是阻塞式的，每个访问都要启用一个线程，没有数据输入线程就会阻塞，线程重复创建和销毁

程序5---修正版本4

草稿

import java.io.IOException;

import java.io.InputStream;

import java.io.PrintWriter;

import java.net.InetSocketAddress;

import java.nio.ByteBuffer;

import java.nio.channels.SelectionKey;

import java.nio.channels.Selector;

import java.nio.channels.ServerSocketChannel;

import java.nio.channels.SocketChannel;

import java.util.Iterator;

import java.util.Scanner;

import java.util.Set;

/**

* @author 作者 E-mail:

* @version 创建时间：2015-8-27 下午09:37:25 类说明

*/

interface Handler

{

void doHandle(SelectionKey key);

}

class AcceptHandler implements Handler

{

@Override

public void doHandle(SelectionKey key)

{

ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();

SocketChannel socketChannel = null;

// 在非阻塞模式下，serverSocketChannel.accept()有可能返回null

// 判断socketChannel是否为null，可以使程序更加健壮，避免NullPointException

try

{

socketChannel = serverSocketChannel.accept();

socketChannel.configureBlocking(false);

if (socketChannel == null)

return;

System.out.println("接收到客户链接，来自：" + socketChannel.socket().getInetAddress() + ":" + socketChannel.socket().getPort());

RequestHandler requestHandler = new RequestHandler(socketChannel);

socketChannel.register(key.selector(), SelectionKey.OP_READ, requestHandler);

}

catch(IOException ex)

{

ex.printStackTrace();

}

}

}

class RequestHandler implements Handler

{

private SocketChannel socketChannel = null;

public RequestHandler(SocketChannel socketChannel)

{

this.socketChannel = socketChannel;

}

@Override

public void doHandle(SelectionKey key)

{

try

{

ByteBuffer buffer = ByteBuffer.allocate(1024);

socketChannel.read(buffer);

if(buffer.position()!=0)

{

System.out.println(new String(buffer.array()));

}

else

{

// 这里可能出现问题

System.out.println(buffer.toString());

}

buffer.flip();

// System.out.println(buffer)

// buffer.wrap(array)

// // HTTP响应头部信息

// S

// pw.print("HTTP/1.0 200 OK\r\n");

// pw.print("Content-type:text/html; charset=utf-8\r\n");

// pw.print("\r\n");

// // HTTP响应内容

// pw.println("good");

// pw.flush();

}

catch(IOException ex)

{

ex.printStackTrace();

}

}

}

public class HttpSimpleServer5

{

private Selector selector = null;

private ServerSocketChannel serverSocketChannel = null;

private int port = 10021;

public HttpSimpleServer5() throws IOException

{

// 创建一个Selector对象

selector = Selector.open();

// 创建一个ServerSocketChannel对象

serverSocketChannel = ServerSocketChannel.open();

// 使ServerSocketChannel工作处于非阻塞模式

serverSocketChannel.configureBlocking(false);

// 使得在同一个主机上关闭了服务器程序，紧接着再启动该服务器程序时

// 可以顺利的绑定到相同的端口

serverSocketChannel.socket().setReuseAddress(true);

// 把服务器进程与一个本地端口绑定

serverSocketChannel.socket().bind(new InetSocketAddress(10021));

}

void startServer() throws IOException

{

serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT, new AcceptHandler());

while (selector.select() > 0)

{

// 获得Selector的selector-keys集合

Set readKeys = selector.selectedKeys();

Iterator it = readKeys.iterator();

while (it.hasNext())

{

SelectionKey key = it.next();

it.remove();

// 由Handler处理连接就绪事件

final Handler handler = (Handler) key.attachment();

handler.doHandle(key);

}

}

}

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

{

new HttpSimpleServer5().startServer();

}

}