利用Java手写简单的httpserver

前言：

在看完尚学堂JAVA300中讲解如何实现一个最简单的httpserver部分的视频之后，

一、前置知识

1.HTTP协议

　　当前互联网网页访问主要采用了B/S的模式，既一个浏览器，一个服务器，浏览器向服务器请求资源，服务器回应请求，浏览器再将接收到的回应解析出来展现给用户。这一问一答的过程可以抽象成浏览器向服务器发送一个Request然后服务器返回一个Response的过程

　　其中Request和Reponse在HTTP中有有具体的格式要求

• 一个Request的例子

Method Path-to-resource Http/Version-number
User-agent 浏览器的类型Accept-charset 用户首选的编码字符集……
Accept 浏览器接受的MIME类型
Accept language 用户选择的接受语言
Accept-charset 用户首选的编码字符集
空行
Option Request Body

如表格所示，第一行首先是请求方式，后跟请求资源路径(url)如果请求方式是GET，则请求参数跟在请求路径里，以?分开，然后一个空格，后跟HTTP版本。后几行为固定格式内容。如果请求方式为POST，则隔一个空行后，跟的请求体的内容，里面有请求参数。

• 一个Response内容

Http/Version-number Statuscode message
Server 服务器的类型信息
Content-type 响应的MIME类型信息
Content-length 被包含在相应类型中的字符数量
空行
Option Response Body

和Request类似，同样包含响应头和响应体两部分。第一行的Statuscode标识了状态参数，404表示请求资源没有找到，500表示服务器错误，200表示成功。响应体里面包含的是响应内容

该部分具体可以参考博文:

2.JAVA网络编程

在Java中提供了两种网络传输方式的实现，面向数据的UDP传输方式和面向连接的TCP传输方式，这里选用TCP方式。

在TCP方式中，服务端的编写主要依靠类Socket和类ServerSocket，通过这两个类可以建立一个TCP连接。

具体方法是：

1. 首先新建一个ServerSocket对象server，指明端口号信息
2. 然后使用server.accept()函数监听端口，监听到连接以后返回一个Socket对象
3. 通过这个Socket对象，以及里面的输入流和输出流，我们就可以获得传过来的信息以及返回信息

二、具体实现

1.服务器类

首先我们需要建立一个服务器类，负责不断监听端口，获得Socket，然后再利用获得Socket新建一个分发器(Dispatcher)，该分发器支持多线程，所以一个分发器专门负责处理一个连接，而服务器只负责不断接收连接，建立分发器。

具体代码如下:

package top.dlkkill.httpserver;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

	private boolean flag=false;
	private ServerSocket server;

	public static void main(String[] args) throws IOException {
		Server myserver=new Server(8888);
		myserver.start();
	}

	public Server(int port) {
		try {
			server=new ServerSocket(port);
		} catch (IOException e) {
			this.stop();
		}
	}

	public void start() throws IOException {
		this.flag=true;
		this.revice(server);
	}

	public void revice(ServerSocket server) throws IOException {
			while(flag) {
				Socket client=server.accept();
				new Thread(new Dispatcher(client)).start();
			}
	}

	public void stop() {
		flag=false;

	}
}

2.封装Request和Response

为了方便解析Request和返回Response，我们需要抽象出两个对象(Request类和Response对象)。

首先封装Request

　　Request对象的作用是解析请求信息，将请求方式，请求资源路径，请求参数解析分离出来，构建一个Request对象我们需要传入一个参数------>输入流。这样我们就可以从输入流中读入请求信息然后开始解析。

package top.dlkkill.httpserver;

import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

public class Request {
    private String url;
    private String method;

	private String info;
    private Map<String,List<String>> paramterMapValues;
    private InputStream is;

    public static final String CRLF="\r\n";
	public static final String BANK=" ";

	private Request() {
		url=null;
		method=null;
		is=null;
		info=null;
		paramterMapValues=new HashMap<String,List<String>>();

	}

	public Request(InputStream is) {
		this();
		this.is=is;
		try {
			create();
		} catch (IOException e) {
			this.is=null;
			System.out.println("Request 创建错误");
			return;
		}

	}

	public String getMethod() {
		return this.method;
	}

	public String getUrl() {
		return url;
	}

	private void create() throws IOException{
		getInfo();
		getUrlAndParamter();

	}

	/**
	 * 根据页面name获取对应所有值
	 * @return String[]
	 */
	public String[] getparamterValues(String name) {
		List<String> paramterValues=null;
		if((paramterValues=paramterMapValues.get(name))==null) {
			return null;
		}else {
			return paramterValues.toArray(new String[0]);
		}
	}

	/**
	 * 根据页面name获取单个值
	 * @return String[]
	 */
	public String getparamterValue(String name) {
		String values[]=getparamterValues(name);
		if(values==null)
			return null;
		else
			return values[0];
	}
	/**
	 * 得到请求信息
	 * @throws IOException
	 */
	private void getInfo() throws IOException {
		byte bytes[]=new byte[20480];
		int len=is.read(bytes);
		info=new String(bytes,0,len);
	}
	/**
	 * 处理得到url资源请求路径和请求参数值
	 * @return
	 */
	private void getUrlAndParamter(){
		String firstline=info.substring(0,info.indexOf(CRLF));
		//System.out.println("FirstLine:  "+firstline);
		String paramter="";
		this.method=firstline.substring(0,firstline.indexOf("/")).trim();
		String tempurl=
				firstline.substring(firstline.indexOf("/"),firstline.indexOf("HTTP/")).trim();
		System.out.println("tempurl:  "+tempurl);
		if(this.method.equalsIgnoreCase("post")) {
			this.url=tempurl;
			paramter=info.substring(info.lastIndexOf(CRLF)).trim();
		}else {
			if(tempurl.contains("?")) {
				//split函数里面的参数实际上需要的是正则表达式,普通字符串还好，?号是特殊字符
				String[] urlarry=tempurl.split("\\?");
				this.url=urlarry[0];
				paramter=urlarry[1];
			}else {
				this.url=tempurl;
			}
		}
		//解析参数
		parseParmter(paramter);
		return;
		//System.out.println(this.url);
		//System.out.println(paramter);
	}
	/**
	 * 解析请求参数,转换成键值对形式
	 * @param str
	 */
	private void parseParmter(String str) {
		if(str==null||str.equals("")||str.trim().equals(""))
			return;
		StringTokenizer st=new StringTokenizer(str,"&");
		while(st.hasMoreTokens()) {
			String temp=st.nextToken();
			String[] KeyAndValues=temp.split("=");
			if(KeyAndValues.length==1) {
				KeyAndValues=Arrays.copyOf(KeyAndValues,2);
				KeyAndValues[1]=null;
			}
			String key=KeyAndValues[0].trim();
			String value=KeyAndValues[1]==null?null:KeyAndValues[1].trim();
			if(!paramterMapValues.containsKey(KeyAndValues[0])){
				paramterMapValues.put(key,new ArrayList<String>());
			}
			paramterMapValues.get(key).add(decode(value, "gbk"));
		}
	}
	/**
	 * 解决中文编码问题
	 * @param value
	 * @param code
	 * @return
	 */
	private String decode(String value,String code) {
		try {
			return java.net.URLDecoder.decode(value, code);
		} catch (UnsupportedEncodingException e) {

		}
		return null;
	}
}

然后我们进行封装Response.

　　Response主要分为两部分(响应头和响应体)

　　构建Response需要传入通过Socket获得的输出流，利用这个输出流我们才可以写回信息

响应头格式较为固定，所有我们在Response中应该有一个私有方法根据响应码自动构建响应头信息。

　　然后我们还需要一个共有方法void println(String msg)，其他类利用该方法写入对应的响应体部分。

最后需要有一个send()方法，自动整合响应体和响应体内容，并将所有内容发送出去。

package top.dlkkill.httpserver;

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.util.Date;

public class Response {

	public static final String CRLF="\r\n";
	public static final String BANK=" ";

	private StringBuilder headerinfo;
	private StringBuilder content;
	private BufferedWriter wr;
	private int len;

	public Response() {
		// TODO Auto-generated constructor stub
		headerinfo=new StringBuilder();
		content=new StringBuilder();
		if(content==null)
			System.out.println("error");
		len=0;
	}

	public Response(OutputStream os){
		this();
		wr=new BufferedWriter(new OutputStreamWriter(os));
	}

	public void createHeaderinfo(int code) {
		System.out.println("code is "+code);
		headerinfo.append("HTTP/1.1").append(BANK);
		switch (code) {
		case 200:
			headerinfo.append(code).append(BANK).append("OK");
			break;
		case 404:
			headerinfo.append(code).append(BANK).append("404 not found");
			break;
		case 500:
			headerinfo.append(code).append(BANK).append("error");
			break;
		default:
			headerinfo.append(code).append(BANK).append("error");
			break;
		}
		headerinfo.append(CRLF);
		headerinfo.append("Server:dlkkill server/0.1").append(CRLF);
		headerinfo.append("Date:").append(new Date()).append(CRLF);
		headerinfo.append("Content-type:text/html;charset=GBK").append(CRLF);
		//正文长度，字节长度
		headerinfo.append("Content-Length:").append(len).append(CRLF);
		//空行分隔符
		headerinfo.append(CRLF);
		//System.out.println(headerinfo.toString());
	}

	public Response println(String msg) {
		//System.out.println(msg);
		if(content==null)
			System.out.println(msg);
		content.append(msg);
		len+=msg.getBytes().length;
		return this;
	}

	public void pushToClient(int code) throws IOException {
		if(wr==null) {
			code=500;
		}
		createHeaderinfo(code);
		wr.write(headerinfo.toString());
		wr.write(content.toString());
		wr.flush();
	}
}

3.创建分发器

　　我们需要有一个类专门一对一处理一个连接，并且该类要支持多线程。所以我们抽象出来一个分发器类。该类负责专门一对一处理一个连接

　　该类拥有一个私有属性Socket client。利用该属性，该类可以创建一个Request和一个Response，然后该类再根据请求的url，利用Webapp类（该类用于生成处理不同请求的不同的类）获得对应的类，启动该类进行处理。

最后该类再调用Response提供的pushToClient方法将所有信息推送给浏览器，然后关闭连接。

具体代码如下：

package top.dlkkill.httpserver;

import java.io.IOException;
import java.net.Socket;

public class Dispatcher implements Runnable {
	private Socket client;
	private Request req;
	private Response rep;
	private int code=200;

	public Dispatcher(Socket client) {
		this.client=client;
		try {
			req=new Request(client.getInputStream());
			rep=new Response(client.getOutputStream());
		} catch (IOException e) {
			code=500;
		}
	}

	@Override
	public void run() {
		System.out.println(req.getUrl()+"   ***");
		Servlet servlet=Webapp.getServlet(req.getUrl());
		if(servlet!=null)
			servlet.service(req, rep);
		else
			code=404;
		try {
			rep.pushToClient(code);
		} catch (IOException e) {
			code=500;
		}
		try {
			rep.pushToClient(code);
		} catch (IOException e) {

		}
		CloseUtil.closeAll(client);
	}
}

4.抽象处理类Servlet

首先我们将该处理类抽象成一个abstract Servlet类，该类负责根据不同的请求进行处理

该抽象类提供多个抽象方法doGet、doPost方法等分别处理不同的请求，传入参数为(Request,Response)这两个参数，在该方法内进行处理。

提供一个service方法根据不同的请求调用不同的方法

具体代码：

package top.dlkkill.httpserver;

import java.net.Socket;

public abstract class Servlet {

	public Servlet() {

	}

	public void service(Request req,Response rep) {
		if(req.getMethod().equalsIgnoreCase("get")) {
			this.doGet(req, rep);
		}else {
			this.doPost(req, rep);
		}
	}

	public abstract void doGet(Request req,Response rep);

	public abstract void doPost(Request req,Response rep);
}

一个实例：

package top.dlkkill.httpserver;

public class loginServlet extends Servlet {

	@Override
	public void doGet(Request req, Response rep) {
		rep.println("<head>" +
				"    <title>test</title>" +
				"</head>" +
				"<body>" +
				"<p>hellow</p>"+
				"<form action=\"http://localhost:8888/index\" method=\"POST\">" +
				"name: <input type=\"text\" name=\"name\">" +
				"password: <input type=\"password\" name=\"pwd\">" +
				"<input type=\"submit\" value=\"submit\">" +
				"</form>" +
				"</body>");
	}

	@Override
	public void doPost(Request req, Response rep) {
		this.doGet(req, rep);
	}

}

5.处理类生成工厂

为了编程的灵活性，我们将该httpserver写出可以根据一个xml配置文件知道有多少种分别处理什么url请求的类，该xml就负责记录这种映射关系

首先需要一个ServletContext类，该类有两个属性private Map<String,String> servlet和private Map<String,String> map，分别用来记录名称到类存储地址之间的映射和url到名称之间的映射

package top.dlkkill.httpserver;

import java.util.HashMap;
import java.util.Map;

public class ServletContext {

	//名称到类存储地址之间的映射
	private Map<String,String> servlet;
	//url到名称之间的映射
	private Map<String,String> map;

	public void setServlet(Map<String, String> servlet) {
		this.servlet = servlet;
	}

	public void setMap(Map<String, String> map) {
		this.map = map;
	}
	public ServletContext() {
		servlet=new HashMap<String, String>();
		map=new HashMap<String, String>();
	}

	public Map<String, String> getServlet() {
		return servlet;
	}

	public Map<String, String> getMap() {
		return map;
	}

}

然后需要一个Webapp类

该类负责读入xml文件并且进行解析，根据xml文件配置的内容，为分发器生成不同的servlet处理类。

生成不同的类利用的Java的类加载机制，可以在代码中获取class信息然后new一个类出来

解析xml文件我们使用的是SAXParser解析器，为了利用该解析器，我们还需要实现一个继承于DefaultHandler的类

实现代码：

package top.dlkkill.httpserver;

import java.io.IOException;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.SAXException;

public class Webapp {
	private static ServletContext servletcontext;
	static{
		servletcontext=new ServletContext();
		Map<String,String> servlet=servletcontext.getServlet();
		Map<String,String> map=servletcontext.getMap();
//		servlet.put("index", "top.dlkkill.httpserver.indexServlet");
//		servlet.put("login", "top.dlkkill.httpserver.loginServlet");
//		map.put("/login", "login");
//		map.put("/index", "index");
		SAXParserFactory parserfactor=SAXParserFactory.newInstance();
		WebHandler hd=new WebHandler();
		SAXParser parser;
		try {
			parser=parserfactor.newSAXParser();
			if(null==Thread.currentThread().getContextClassLoader().getResourceAsStream("top/dlkkill/httpserver/web.xml"))
				System.out.println("error");
			parser.parse(
					Thread.currentThread().getContextClassLoader()
					.getResourceAsStream("top/dlkkill/httpserver/web.xml"),
					hd);
			List<Entity> entityList=hd.getEntityList();
			List<Mapping> mappingList=hd.getMappingList();
			for (Mapping mapping : mappingList) {
				String name=mapping.getName();
				List<String> urlList=mapping.getUrl();
				for (String url:urlList) {
					map.put(url, name);
				}
			}
			for (Entity entity:entityList) {
				String servletname=entity.getName();
				String clz=entity.getClz();
				servlet.put(servletname, clz);
			}
		} catch (ParserConfigurationException | SAXException |IOException e) {

		}

	}
	public static Servlet getServlet(String url) {
		Map<String,String> servlet=servletcontext.getServlet();
		Map<String,String> map=servletcontext.getMap();
		String className=servlet.get(map.get(url));
		Servlet temp=null;
		Class<?> clz=null;
		try {
			System.out.println("classname:"+className);
			if(className!=null)
			clz=Class.forName(className);
		} catch (ClassNotFoundException e) {
			return null;
		}
		try {
			if(clz!=null)
			temp=(Servlet)clz.newInstance();
		} catch (InstantiationException e) {
			return null;
		} catch (IllegalAccessException e) {
			return null;
		}
		return temp;
	}
}

package top.dlkkill.httpserver;

import java.util.ArrayList;
import java.util.List;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class WebHandler extends DefaultHandler {

	private List<Entity> entityList;

	private List<Mapping> mappingList;

	private Entity entity;
	private Mapping mapping;

	private String tag;
	private boolean isMap;

	public WebHandler() {

	}
	public List<Entity> getEntityList() {
			return entityList;
		}

	public List<Mapping> getMappingList() {
			return mappingList;
		}
	@Override
	public void startDocument() throws SAXException {
		entityList=new ArrayList<Entity>();
		mappingList=new ArrayList<Mapping>();
	}

	@Override
	public void endDocument() throws SAXException {
//		for (Mapping mapping : mappingList) {
//			if(mapping==null)
//				continue;
//			String name;
//			if(mapping.getName()!=null)
//				name=mapping.getName();
//			else
//				name="null";
//			List<String> urlList=mapping.getUrl();
//			for (String url:urlList) {
//				System.out.println(name+"---->"+url);
//			}
//		}
//		for (Entity entity:entityList) {
//			String servletname=entity.getName();
//			String clz=entity.getClz();
//			System.out.println(servletname+"---->"+clz);
//		}
	}

	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		//System.out.println("开始处理"+"--->"+qName);
		if(null!=qName) {
			if(qName.equals("servlet")) {
				isMap=false;
				entity=new Entity();
			}else if(qName.equals("servlet-mapping")){
				isMap=true;
				mapping=new Mapping();
			}
		}
		tag=qName;
	}

	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {
		//System.out.println("结束处理"+"--->"+qName);
		if(null!=qName) {
			if(qName.equals("servlet")) {
				entityList.add(entity);
			}else if(qName.equals("servlet-mapping")){
				mappingList.add(mapping);
			}
		}
		tag=null;
	}

	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		String str=new String(ch, start, length);
		//System.out.println("处理中"+"--->"+str);
		if(tag!=null&&str!=null&&!str.trim().equals("")) {
			if(!isMap) {
				if(tag.equals("servlet-name"))
					entity.setName(str);
				else if(tag.equals("servlet-class"))
					entity.setClz(str);
			}else {
				if(tag.equals("servlet-name"))
					mapping.setName(str);
				else if(tag.equals("url"))
					mapping.getUrl().add(str);
			}
		}
	}

}

6.一个工具类

该类负责关闭连接，连接关闭了那与该连接有关的流也就关闭了

package top.dlkkill.httpserver;

import java.io.Closeable;

public class CloseUtil {
	public static void closeAll(Closeable ...io) {
		for (Closeable closeable : io) {
			try {
				if(closeable!=null)
					closeable.close();
			}catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
	}
}