基于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("<font color='red' size='7'> 今天天气真好</font>");
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。 - 抛出：
IOException- 如果发生 I/O 错误。
其实浏览器此时正在等待你的响应，所以我们需要自己界定请求头的范围。请求头的结束标志是两个连续的换行（这个换行是有标准规定的，必须为\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("<font color='red' size='7'>good</font>");
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("<font color='red' size='7'>good</font>");
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("<font color='red' size='7'>good</font>");
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("<font color='red' size='7'>good</font>");
// 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<SelectionKey> readKeys = selector.selectedKeys();
Iterator<SelectionKey> 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();
}
}
