手写服务器-----服务器底层详细讲解，附源码

本人学生党，在手写服务器过程中，对服务器底层实现有了更深层次的理解，对今后项目开发大有益处，本项目源码已上传github点击打开链接，有问题的可以留言，看到会一一解答，希望能帮助到大家。

目录结构

项目使用eclipse+jdk8，也可导入idea中(百度就有)

info包

该包存放get和post请求的示例，在书写过程中有个对照，看好中间空格和换行。

server包

• readXmlData包
  SAX解析web.xml文件，servlet和servlet-mapping对应的数据进行封装Entity和Mapping实体类。
• • Entity类
    
• • Mapping类
    

WebApp类，WebContext类，WebHandler类是读取web.xml文件中数据并保存，通过反射实现指定类。(想简单了解的用户，可以选择跳过这块)

• • WebApp类

public class WebApp {
	private static WebContext  webContext ;
	static {
		try {
			//SAX解析
			//1、获取解析工厂
			SAXParserFactory factory=SAXParserFactory.newInstance();
			//2、从解析工厂获取解析器
			SAXParser parse =factory.newSAXParser();
			//3、编写处理器
			//4、加载文档 Document 注册处理器
			WebHandler handler=new WebHandler();
			//5、解析
			parse.parse(Thread.currentThread().getContextClassLoader()
			.getResourceAsStream("util/_6net/HandServer/web.xml")
			,handler);
			//获取数据
			webContext = new WebContext(handler.getEntitys(),handler.getMappings());
		}catch(Exception e) {
			System.out.println("解析配置文件错误");
		}
	}
	/**
	 * 通过url获取配置文件对应的servlet
	 * @param url
	 * @return
	 */
	public static Servlet getServletFromUrl(String url) {		
		//假设你输入了 /login
		String className = webContext.getClz("/"+url);
		Class clz;
		try {
			System.out.println(url+"-->"+className+"-->");
			clz = Class.forName(className);
			Servlet servlet =(Servlet)clz.getConstructor().newInstance();
			return servlet;
		} catch (Exception e) {
			
		}
		return null;
	}

• • WebContext类

public class WebContext {
	private List<Entity> entitys  =null;
	private List<Mapping> mappings =null;
	
	//key-->servlet-name  value -->servlet-class
	private Map<String,String> entityMap =new HashMap<String,String>();
	//key -->url-pattern value -->servlet-name
	private Map<String,String> mappingMap =new HashMap<String,String>();
	public WebContext(List<Entity> entitys, List<Mapping> mappings) {
		this.entitys = entitys;
		this.mappings = mappings;
		
		//将entity 的List转成了对应map
		for(Entity entity:entitys) {
			entityMap.put(entity.getName(), entity.getClz());
		}
		//将map 的List转成了对应map
		for(Mapping mapping:mappings) {
			for(String pattern: mapping.getPatterns()) {
				mappingMap.put(pattern, mapping.getName());				
			}
		}
	}
	/**
	 * 通过URL的路径找到了对应class
	 * @param pattern
	 * @return
	 */
	public String getClz(String pattern) {
		String name = mappingMap.get(pattern);
		return entityMap.get(name);
	}

• • WebHandler类

public class WebHandler extends DefaultHandler{
	private List<Entity> entitys  = new ArrayList<Entity>();
	private List<Mapping> mappings = new ArrayList<Mapping>();
	private Entity entity ;
	private Mapping mapping ;
	private String tag; //存储操作标签
	private boolean isMapping = false;
	
	
	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		if(null!=qName) {
			tag = qName; //存储标签名
			if(tag.equals("servlet")) {
				entity = new Entity();
				isMapping = false;
			}else if(tag.equals("servlet-mapping")) {
				mapping = new Mapping();
				isMapping = true;
			}
		}
	}
	
	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		String contents = new String(ch,start,length).trim();
		if(null!=tag) { //处理了空
			if(isMapping) { //操作servlet-mapping
				if(tag.equals("servlet-name")) {
					mapping.setName(contents);
				}else if(tag.equals("url-pattern")) {
					mapping.addPattern(contents);
				}
			}else { //操作servlet
				if(tag.equals("servlet-name")) {
					entity.setName(contents);
				}else if(tag.equals("servlet-class")) {
					entity.setClz(contents);
				}
			}			
		}
	}
	
	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {
		if(null!=qName) { 
			if(qName.equals("servlet")) {
				entitys.add(entity);
			}else if(qName.equals("servlet-mapping")) {
				mappings.add(mapping);
			}
		}
		tag = null; //tag丢弃了
	}

	public List<Entity> getEntitys() {
		return entitys;
	}

	public List<Mapping> getMappings() {
		return mappings;
	}	

• Server类
  1.创建ServerSocket
  2.建立连接获取Socket
  3.执行多线程

public class Server {
	private ServerSocket serverSocket;
	//只要服务器启动就一直while执行的标志
	private boolean isRunning;
	public static void main(String[] args) {
		Server server = new Server();
		server.start();
	}
	//启动服务
	public void start() {
		try {
			serverSocket = new ServerSocket(7777);
			isRunning = true;
			receive();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	//接收连接并处理
	public void receive() {
		while(isRunning) {
			try {
				Socket client = serverSocket.accept();
				System.out.println("一个客户建立了连接。。。。");
				//多线程
				new Thread(new Dispatcher(client)).start();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
	}
	//停止服务
	public void stop() {
		try {
			this.serverSocket.close();
			isRunning = false;
			System.out.println("服务器已停止。。。。");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

• Dispatcher类
  多线程类，不断接收客户端连接，并生成对应request和response。

public class Dispatcher implements Runnable{
	private Socket client;
	private Request request;
	private Response response ;
	public Dispatcher(Socket client) {
		this.client = client;
		try {
			//获取请求协议
			//获取响应协议
			request =new Request(client);
			response =new Response(client);
		} catch (IOException e) {
			e.printStackTrace();
			this.release();
		}
	}
	
	@Override
	public void run() {
		try {
			if(null== request.getUrl() || request.getUrl().equals("")) {
				InputStream is =Thread.currentThread().getContextClassLoader().getResourceAsStream("util/_6net/HandServer/index.html");
				byte[] datas = new byte[1024*1024];
				is.read(datas);
				response.print((new String(datas)));
				response.pushToBrower(200);
				is.close();
				return ;
			}
			Servlet servlet= WebApp.getServletFromUrl(request.getUrl());
			if(null!=servlet) {
				servlet.service(request, response);
				//关注了状态码
				response.pushToBrower(200);
			}else {
				//错误....
				InputStream is =Thread.currentThread().getContextClassLoader().getResourceAsStream("util/_6net/HandServer/error.html");
				byte[] datas = new byte[1024*1024];
				is.read(datas);
				response.print((new String(datas)));
				response.pushToBrower(404);
				is.close();
			}		
		}catch(Exception e) {
			try {
				response.println("服务器维护中------");
				response.pushToBrower(500);
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		}		
		release();
	}
	
	//释放资源
	private void release() {
		try {
			client.close();
		} catch (IOException e1) {
			e1.printStackTrace();
		}
	}

• Request类
  封装请求协议: 封装请求参数为Map，中间有对接收中文的处理

public class Request {
	//协议信息
	private String requestInfo;
	//请求方式
	private String method; 
	//请求url
	private String url; 
	//请求参数
	private String queryStr;
	//存储参数
	private Map<String,List<String>> parameterMap;
	private final  String CRLF = "\r\n";
	
	public Request(Socket client) throws IOException {
		this(client.getInputStream());
	}
	public Request(InputStream is) {		
		parameterMap = new HashMap<String,List<String>>();
		byte[] datas = new byte[1024*1024*1024];
		int len;
		try {
			len = is.read(datas);
			this.requestInfo = new String(datas,0,len);			
		} catch (IOException e) {
			e.printStackTrace();
			return ;
		}
		//分解字符串
		parseRequestInfo();
	}
	//分解字符串
	private void parseRequestInfo() {
		System.out.println("------分解-------");
		System.out.println("---1、获取请求方式: 开头到第一个/------");
		this.method = this.requestInfo.substring(0, this.requestInfo.indexOf("/")).toLowerCase();
		this.method=this.method.trim();
		System.out.println("---2、获取请求url: 第一个/ 到 HTTP/------");
		System.out.println("---可能包含请求参数? 前面的为url------");
		//1)、获取/的位置
		int startIdx = this.requestInfo.indexOf("/")+1;
		//2)、获取 HTTP/的位置
		int endIdx = this.requestInfo.indexOf("HTTP/");
		//3)、分割字符串
		this.url = this.requestInfo.substring(startIdx, endIdx).trim();		
		//4)、获取？的位置
		int queryIdx =this.url.indexOf("?");	
		if(queryIdx>=0) {//表示存在请求参数
			String[] urlArray = this.url.split("\\?");
			this.url =urlArray[0];
			queryStr =urlArray[1];
		}
		System.out.println(this.url);
		System.out.println("---3、获取请求参数:如果Get已经获取,如果是post可能在请求体中------");
		if(method.equals("post")) {
			String qStr =this.requestInfo.substring(this.requestInfo.lastIndexOf(CRLF)).trim();
			System.out.println(qStr+"-->"); 
			if(null==queryStr) {
				queryStr =qStr;
			}else { 
				queryStr +="&"+qStr;
			}
		}
		queryStr = null==queryStr?"":queryStr;
		System.out.println(method+"-->"+url+"-->"+queryStr);
		//转成Map fav=1&fav=2&uname=shsxt&age=18&others=
		convertMap();
	}
	private void convertMap() {
		//1、分割字符串 &
		String[] keyValues =this.queryStr.split("&");
		for(String queryStr:keyValues) {
			//2、再次分割字符串  =
			String[] kv = queryStr.split("=");
			kv =Arrays.copyOf(kv, 2);	//出现uname=情况，让kv始终保持2个数组长度
			//获取key和value
			String key = kv[0];
			String value = kv[1]==null?null:decode( kv[1],"utf-8");
			//存储到map中
			if(!parameterMap.containsKey(key)) { //第一次
				parameterMap.put(key, new ArrayList<String>());
			}
			parameterMap.get(key).add(value);			
		}
	}
	/**
	 * request协议传过来：处理中文
	 * @return
	 */
	private String decode(String value,String enc) {
		try {
			return java.net.URLDecoder.decode(value, enc);
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

	
	/**
	 * 通过name获取对应的多个值
	 * @param key
	 * @return
	 */
	public String[] getParameterValues(String key) {
		List<String> values = this.parameterMap.get(key);
		if(null==values || values.size()<1) {
			return null;
		}
		return values.toArray(new String[0]);
	}
	/**
	 * 通过name获取对应的一个值
	 * @param key
	 * @return
	 */
	public String getParameter(String key) {
		String []  values =getParameterValues(key);
		return values ==null?null:values[0];
	}
	public String getMethod() {
		return method;
	}
	
	public String getUrl() {
		return url;
	}
	
	public String getQueryStr() {
		return queryStr;
	}

• Response类
  目标：封装响应信息
  1.内容可以动态添加
  2.关注状态吗，拼装好响应的协议信息

public class Response {
	//响应的数据流
	private BufferedWriter bw;
	//正文
	private StringBuilder content;
	//协议头（状态行与请求头 回车）信息
	private StringBuilder headInfo;
	private int len; //正文的字节数
	//内部
	private final String BLANK = " ";
	private final String CRLF = "\r\n";	//回车换行
	private Response() {
		content =new StringBuilder();
		headInfo=new StringBuilder();
		len =0;
	}
	public Response(Socket client) {
		this();
		try {
			bw=new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
		} catch (IOException e) {
			e.printStackTrace();
			headInfo = null;
		}
	}
	public Response(OutputStream os) {
		this();
		bw=new BufferedWriter(new OutputStreamWriter(os));
	}
	
	//动态添加内容-->用户看到的信息
	public Response print(String info) {
		content.append(info);
		len+=info.getBytes().length;
		return this;
	}
	public Response println(String info) {
		content.append(info).append(CRLF);
		len+=(info+CRLF).getBytes().length;
		return this;
	}
	//推送响应信息
	public void pushToBrower(int code) throws IOException {
		if(null ==headInfo) {
			code = 505;
		}
		createHeadInfo(code);
		bw.append(headInfo);
		bw.append(content);
		bw.flush();
	}
	/**
	 * 目标：构建头信息-->http协议所需的必要信息
	 *  1.状态行：HTTP/1.0 200 OK
		2.请求头：
		Date：Mon,31Dec209904:25:57GMT
		Server:hang Server/0.0.1;charset=GBK
		Content-type:text/html
		Content-length:39725423
		3.请求正文（注意与请求头之间有个空行）
		
		******
	 * @param code
	 */
	private void createHeadInfo(int code){
		//1、响应行: HTTP/1.1 200 OK
		headInfo.append("HTTP/1.1").append(BLANK);
		headInfo.append(code).append(BLANK);
		switch(code) {
			case 200:
				headInfo.append("OK").append(CRLF);
				break;
			case 404:
				headInfo.append("NOT FOUND").append(CRLF);
				break;	
			case 505:
				headInfo.append("SERVER ERROR").append(CRLF);
				break;	
		}
		//2、响应头(最后一行存在空行):
		headInfo.append("Date:").append(new Date()).append(CRLF);
		headInfo.append("Server:").append("hang Server/0.0.1;charset=GBK").append(CRLF);
		headInfo.append("Content-type:text/html").append(CRLF);
		headInfo.append("Content-length:").append(len).append(CRLF);
		headInfo.append(CRLF);	
	}

• Servlet接口
  Servlet将业务代码解耦到对应的业务类中(具体的Servlet())

public interface Servlet {
	void service(Request request,Response response);
}

user包

通过观察可以发现java书写html太麻烦，就到了jsp的出现。

public class LoginServlet implements Servlet{

	@Override
	public void service(Request request, Response response) {
		response.print("<html>"); 
		response.print("<head>"); 
		//告知浏览器接下来的内容是什么字符集，防止返回的中文数据出现乱码
		response.print("<meta http-equiv=\"content-type\" content=\"text/html;charset=utf-8\">" ); 
		response.print("<title>");
		response.print("第一个servlet");
		response.print("</title>");
		response.print("</head>");
		response.print("<body>");
		response.print("欢迎回来:"+request.getParameter("uname"));
		response.print("</body>");
		response.print("</html>");
	}

}

项目测试

给大家推荐一款插件Postman测试非常方便，大家可以百度进行安装，或留言处邮箱会发给大家。

本例源码：https://github.com/WarmedHeart/SimpleServer-