基于socket阻塞模式的 java 简单服务器

没怎么关注socket这地块..多半是知其然,不知其所以然

闲着无聊..写了一个简单的java服务器,供新人复习.

把类贴到jee工程中 将静态文件放至wwwroot目录 运行main函数即可访问

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

/**
 * 基于阻塞 模式的简单的java服务器
 * 
 * @author 衣旧 2010-06-06
 */
public class HttpServer {

	/**
	 * 监听本地端口
	 */
	private ServerSocket serverSocket;

	/**
	 * 根目录
	 */
	public static final String WEB_ROOT = System.getProperty("user.dir")+ File.separator + "wwwroot";
	/**
	 * 服务器监听端口, 默认为 80.
	 */
	public static int PORT = 80;

	/**
	 * 开始服务器 Socket 线程.
	 */
	public HttpServer() {
		try {
			serverSocket = new ServerSocket(PORT);
			while (true) {
				Socket client = serverSocket.accept();
				new IoHandler(client);
			}
		} catch (Exception e) {
			System.out.println("无法启动HTTP服务器:" + e.toString());
		}
		if (serverSocket == null)
			System.exit(1);// 无法开始服务器
		System.out.println("HTTP 服务器正在运行,端口:" + PORT);
	}

	/**
	 * 打印用途说明.
	 */
	private static void usage() {
		System.out
				.println("Usage: java serverSocket <port>\nDefault port is 80.");
	}

	/**
	 * 启动简易 HTTP 服务器
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		try {
			if (args.length != 1) {
				usage();
			} else if (args.length == 1) {
				PORT = Integer.parseInt(args[0]);
			}
		} catch (Exception ex) {
			System.err.println("初始端口. 必须是大于0的整数!\n" + ex.toString());
		}
		new HttpServer();
	}

	/**
	 * 响应http请求
	 * 
	 * @author liucf
	 * 
	 */
	class IoService {

		private IoProcessor request;
		private PrintWriter out;
		private PrintStream outs;
		private int BUFFER_SIZE = 1024;

		IoService(PrintWriter output, PrintStream outs) {
			this.out = output;
			this.outs = outs;
		}

		public IoProcessor getRequest() {
			return request;
		}

		public void setRequest(IoProcessor request) {
			this.request = request;
		}

		public void responseInfo() {
			if ("POST".equalsIgnoreCase(request.getMethod())
					&& request.getContentLength() > 0) {
//				System.out.println("以下内容为 POST 方式提交的表单数据");
//				for (int i = 0; i < request.getContentLength(); i++) {
//					try {
//						System.out.print((char) request.getIn().read());
//					} catch (IOException e) {
//						e.printStackTrace();
//					}
//				}
			}

			if ("GET".equalsIgnoreCase(request.getMethod())) {
				doGet();
			}
		}

		public void doGet() {
			File file = new File(HttpServer.WEB_ROOT, request.getUri());
			if (file.isDirectory()) {
				out.println("HTTP/1.0 200 OK");// 返回应答消息,并结束应答
				out.println("Content-Type:text/html;charset=GBK");
				out.println();
				out.println("<h1>不允许访问文件夹!!</h1>");
			} else if (file.exists()) {
				byte[] bytes = new byte[BUFFER_SIZE];
				FileInputStream fis = null;
				if (file.exists()) {
					try {
						fis = new FileInputStream(file);
						int ch = fis.read(bytes, 0, BUFFER_SIZE);
						while (ch != -1) {
							outs.write(bytes, 0, ch);
							ch = fis.read(bytes, 0, BUFFER_SIZE);
						}
					} catch (FileNotFoundException e) {
						e.printStackTrace();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			} else {
				out.println("HTTP/1.0 404 Not found");// 返回应答消息,并结束应答
				out.println("Content-Type:text/html;charset=GBK");
				out.println();
				out.println("<h1>访问路径不存在!!</h1>");
			}
		}
	}

	/**
	 * 
	 * 封装处理http请求信息
	 * 
	 * @author liucf
	 * 
	 */
	class IoProcessor {
		private BufferedReader in;
		private String uri;
		private String method;
		private int contentLength;
		private Map<String, Object> http = new HashMap<String, Object>();

		public IoProcessor(BufferedReader in) {
			this.in = in;
			parseRequstInfo();
		}

		private void parseRequstInfo() {
			String line = null;
			try {
				line = in.readLine();
				// 读取第一行, 请求地址
				System.out.println(line);
				String resource = line.substring(line.indexOf('/'), line
						.lastIndexOf('/') - 5);
				// 获得请求的资源的地址
				uri = URLDecoder.decode(resource, "UTF-8");// 反编码
				// 地址
				method = new StringTokenizer(line).nextElement().toString();// 获取请求方法,

				// 读取所有浏览器发送过来的请求参数头部信息
				while ((line = in.readLine()) != null) {
					if (line.equals(""))
						break;
					if (line.indexOf(":") != -1) {
						String key = line.substring(0, line.indexOf(':'))
								.trim();
						String value = line.substring(line.indexOf(':') + 1)
								.trim();
						http.put(key, value);
						// 读取 POST 等数据的内容长度
						if (line.startsWith("Content-Length")) {
							try {
								contentLength = Integer.parseInt(line
										.substring(line.indexOf(':') + 1)
										.trim());
							} catch (Exception e) {
								e.printStackTrace();
							}
						}
					}
				}
			} catch (IOException e) {
				System.out.println("解析请求出错!");
				e.printStackTrace();
			}
		}

		public BufferedReader getIn() {
			return in;
		}

		public void setIn(BufferedReader in) {
			this.in = in;
		}

		public String getUri() {
			return uri;
		}

		public void setUri(String uri) {
			this.uri = uri;
		}

		public String getMethod() {
			return method;
		}

		public void setMethod(String method) {
			this.method = method;
		}

		public int getContentLength() {
			return contentLength;
		}

		public void setContentLength(int contentLength) {
			this.contentLength = contentLength;
		}

		public Map<String, Object> getHttp() {
			return http;
		}

		public void setHttp(Map<String, Object> http) {
			this.http = http;
		}
	}

	/**
	 * 响应客户端请求
	 * 
	 * @author liucf
	 *
	 */
	class IoHandler implements Runnable {

		private Socket client;// 客户端连接

		private BufferedReader input;// 接收外部信息的流

		private PrintWriter printWriter;// 输出流

		private PrintStream printStream;

		public IoHandler(Socket socket) {
			this.client = socket;
			try {
				input = new BufferedReader(new InputStreamReader(client
						.getInputStream()));
				printWriter = new PrintWriter(new OutputStreamWriter(client
						.getOutputStream(), "GBK"), true);
				printStream = new PrintStream(client.getOutputStream(), true);
			} catch (IOException e) {
				e.printStackTrace();
			}
			this.run();
		}

		public void run() {
			System.out.println("连接到服务器的用户:" + client);
			try {
				IoProcessor request = new IoProcessor(input);
				IoService response = new IoService(printWriter, printStream);
				response.setRequest(request);
				response.responseInfo();
				closeSocket(client);
			} catch (Exception e) {
				System.out.println("HTTP 服务器错误:" + e.toString());
			}
		}

		/**
		 * 关闭客户端 socket 并打印一条调试信息.
		 * 
		 * @param socket
		 *            客户端 socket.
		 */
		public void closeSocket(Socket socket) {
			try {
				printWriter.close();
				socket.close();
			} catch (IOException ex) {
				ex.printStackTrace();
			}
			System.out.println(socket + "离开了HTTP服务器!\n");
		}
	}
}