手撸一个简单的WebServer服务器

WebServer服务器

java的学习来到了反射部分，手撸一个WebServer服务器作为练习
要用到的知识点有：
反射：把java类中的各种结构方法（方法、属性、构造器、类名）映射成一个个的java对象
获取Class对象的三种方式：
1、对象.getClass()
Iphone iphone = new Iphone();
Class clz = iphone.getClass();
2、类.class()
Class clz = Iphone.getClass();
3、Class.forName(“包名.类名”)（推荐）
Class.forName(“完整路径”);
可以动态创建对象（用构造器创建）
Iphone iphone2 = (Iphone)clz.getConstructor().newInstance();

Server类

这个类没有什么新奇的地方，看过我之前写的聊天室的朋友就知道，建立服务端，给端口，然后把每一个客户端都当作一个线程处理
获取请求协议
1、创建ServerSocket
2、建立连接获取Socket
3、通过输入流获取请求协议

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

public class Server {
	private ServerSocket serverSocket;
	private boolean isRunning;

	public static void main(String[] args) {
		Server server = new Server();
		server.start();
	}

	// 启动服务
	public void start() {
		try {
			serverSocket = new ServerSocket(8888);
			isRunning = true;
			receive();
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("服务器启动失败");
			stop();
		}
	}

	// 接受连接处理
	public void receive() {
		while (isRunning) {
			try {
				Socket client = serverSocket.accept();
				System.out.println("一个客户端建立了连接");
				// 多线程处理
				new Thread(new Dispatcher(client)).start();
			} catch (IOException e) {
				e.printStackTrace();
				System.out.println("客户端错误");
			}
		}
	}

	// 停止服务
	public void stop() {
		isRunning = false;
		try {
			this.serverSocket.close();
			System.out.println("服务器已停止");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

Request类

封装请求信息Request

这里的请求信息也就是我们输入的网址，不明白其中原理的建议了解一下http协议，我们需要把请求信息分割开来，然后获得我们需要的信息，用反射来创建相应的对象
1、通过分解字符串获取method，URL和请求参数(POST请求参数可能在请求体中还存在）
2、通过Map封装请求参数

import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.util.*;

/*
封装请求协议：封装请求参数为Map
 */
public class Request {
	private final String CRLF = "\r\n";
	// 协议信息
	private String requestInfo;
	// 请求方式
	private String method;
	// 请求url
	private String url;
	// 请求参数
	private String queryStr;
	// 存储参数
	private Map<String, List<String>> parameterMap;

	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];
		int len = 0;
		try {
			len = is.read(datas);
			this.requestInfo = new String(datas, 0, len);
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}
		// 分解字符串
		this.parseRequestInfo();
	}

	// 分解字符串
	private void parseRequestInfo() {
		System.out.println("----分解开始----");
		// System.out.println(requestInfo);
		System.out.println("-----1、获取请求方式：开头到第一个/-----");
		this.method = this.requestInfo.substring(0, this.requestInfo.indexOf("/")).toLowerCase().trim();
		System.out.println(method);
		System.out.println("-----1、获取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();
		System.out.println(this.url);
		// 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();
			if (null == queryStr) {
				queryStr = qStr;
			} else {
				queryStr += "&" + qStr;
			}
		}
		queryStr = null == queryStr ? "" : queryStr;
		System.out.println(method + "->" + url + "->" + queryStr);
		// 转成Map fav=1&fav=2&uname=lijing&others=
		convertMap();
	}

	// 处理请求参数为Map
	public void convertMap() {
		// 1、分割字符串
		String[] KeyValues = this.queryStr.split("&");
		for (String quertstr : KeyValues) {
			// 再次分割字符串=
			// System.out.println("jdjdksa--->"+quertstr);
			String[] kv = quertstr.split("=");
			kv = Arrays.copyOf(kv, 2);// 保证有两个值 参数others=null时赋空
			// 获取key和value
			String key = kv[0];
			String value = kv[1] == null ? null : decode(kv[1], "utf-8");

			// 存储到map中 现在map容器中找是否有相同key值若有加入其对应value，若无加入容器中
			// System.out.println("hhhhhh"+kv[0]+"--->"+kv[1]);
			if (!parameterMap.containsKey(key)) {// 第一次
				parameterMap.put(key, new ArrayList<String>());
			}
			parameterMap.get(key).add(value);
		}
	}

	// 处理中文
	private String decode(String value, String enc) {
		try {
			return java.net.URLDecoder.decode(value, enc);// enc为传入处理的字符集
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return null;
	}

	/*
	 * 通过name获取对应的多个值
	 */
	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获取对应的一个值
	 */
	public String getParameter(String key) {
		String[] values = getParameterValues(key);
		return values == null ? null : values[0];
	}

	public String getUrl() {
		return url;
	}

	public String getMethod() {
		return method;
	}

	public String getQueryStr() {
		return queryStr;
	}

}

Response类

与Request类相对应的，当我们收到了请求信息以后，也就是我们web被申请访问以后，我们要根据对方的不同请求，给与不同的响应，换句话说是显示不同的页面
返回响应协议
1、准备内容
2、获取字节数的长度
3、拼接响应协议 （注意空格与换行）
4、使用输出流输出
封装响应协议 Response
1、动态添加内容print
2、累加字节数的长度
3、根据状态吗拼接响应头协议
4、根据状态码统一推送出去
调用处：动态调用print+传入状态码推送

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

/*
Response
1、动态添加内容print
2、累加字节数的长度
3、根据状态码拼接响应头协议
4、根据状态码同一推送出去
 */
public class Response {
	BufferedWriter bw;
	// 正文
	private StringBuilder content;
	// 协议头信息(状态行与请求头 回车)信息
	private StringBuilder headInfo;
	private int len;// 正文的字节数
	private final String BLANK = " ";
	private final String CRLF = "\r\n";

	public 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 pushToBrowser(int code) throws IOException {
		if (null == headInfo) {
			code = 505;
		}
		creatHeadInfo(code);// 先有内容才构建头信息
		bw.append(headInfo);
		bw.append(content);
		bw.flush();
	}

	// 构建头信息
	private void creatHeadInfo(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 FOUNF").append(CRLF);
			break;
		case 505:
			headInfo.append("SERVER ERROR").append(CRLF);
			break;
		}
		// 2、响应头(最后一行存在空行) 字节数
		headInfo.append("Date:").append(new Date()).append(CRLF);
		headInfo.append("Server06:").append("server:Server02/0.0.1;charset=GBK").append(CRLF);
		headInfo.append("Content-type:test/html").append(CRLF);
		headInfo.append("Content-length:").append(len).append(CRLF);
		headInfo.append(CRLF);

	}
}

Servlet类

接下来就是准备我们的接口，把接口丢出去给别人用，同样也是为了更好的封装性
引入Servlet
将业务代码解耦到对应的业务类中（具体的Servlet，这也是web阶段主要写的内容。ep：登陆业务
先写好loginServlet 再在配置文件web.xml中进行相应配置
即配置"url-pattern" /login 对外公布接口
写前台页面login.html时在action中加入路径

/*
服务器小脚本接口
 */
public interface Servlet {
	void service(Request request, Response response);
}

LoginServlet类

这个类实现我们的接口，也是相当于举例运用

public class LoginServlet implements Servlet {
	public void service(Request request, Response response) {
		response.print("<html>");
		response.print("<head>");
		response.print("<title>");
		response.print("<我的服务器噢>");
		response.print("</title>");
		response.print("</head>");
		response.print("<body>");
		response.print("<欢迎回来，悦悦大笨蛋！:" + request.getParameter("uname"));
		response.print("</body>");
		response.print("</html>");
	}
}

RegisterServlet类

没什么营养，也没实现什么方法，就是简单的一个输出，也就是测试而已

public class RegisterServlet implements Servlet{

	@Override
	public void service(Request request, Response response) {
		// TODO Auto-generated method stub
		response.println("我爱你哦");
	}

}

OthersServlet

没什么营养，也没实现什么方法，就是简单的一个输出，也就是测试而已

public class OthersServlet implements Servlet {

	@Override
	public void service(Request request, Response response) {
		// TODO Auto-generated method stub
		response.println("朱玥大傻逼注册成功");
	}

}

配置xml文件

根据配置文件动态的读取类名，再进行反射获取具体的Servlet来处理业务
这里算是最重要的一步了，很多时候运行报错就是这里出了问题，我重写了十多次代码，每次都是因为这里的问题，切记不能有中文符号，不能有多余空格不能把地址给错

<?xml version="1.0" encoding="utf-8"?>
<web-app>
    <servlet>
        <servlet-name>login</servlet-name>
        //这里可以看到我刚才写的业务类在这里面被配置了，服务器被访问时就能启用
        //但是切记地址不能写错，包名.类名->WebServer.LoginServlet
        //最后复制这段xml的时候建议把这三段注释去掉，我只是为了说明
        <servlet-class>WebServer.LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>login</servlet-name>
        <url-pattern>/login</url-pattern>
        <url-pattern>/g</url-pattern>
        <url-pattern>/hhh</url-pattern>
    </servlet-mapping>
    <servlet>
        <servlet-name>reg</servlet-name>
        <servlet-class>WebServer.RegisterServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>reg</servlet-name>
        <url-pattern>/reg</url-pattern>
        <url-pattern>/r</url-pattern>
    </servlet-mapping>
    <servlet>
        <servlet-name>others</servlet-name>
        <servlet-class>WebServer.OthersServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>others</servlet-name>
        <url-pattern>/o</url-pattern>
    </servlet-mapping>
</web-app>

Dispatcher类

这里就是上面的Serve类中用到的线程类
这里是我最得意的地方，因为我的jdk版本比较老，I/O里没有readAllBytes这个方法，我懒得更新jdk了，网上查了很久也没查到这个方法怎么写的，所以我手动实现了这个方法，还改进了一下

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

/*
分发器：加入状态内容处理 404，505，首页
加入了多线程，可以同时处理多个请求，使用的时短连接
读取错误、首页内容即可
 */
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("index.html");
				response.println(readAllBytes(is));
				response.pushToBrowser(200);
				is.close();
			}
			Servlet servlet = WebApp.getServletFromUrl(request.getUrl());
			System.out.println("servlet:" + servlet);
			if (null != servlet) {
				servlet.service(request, response);
				// 关注了状态码
				response.pushToBrowser(200);
			} else {
				// 错误页面
				InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("error.html");
				response.println(readAllBytes(is));
				response.pushToBrowser(404);
				is.close();
			}
		} catch (Exception e) {
			try {
				response.println("Dispatcher出错了");
				response.pushToBrowser(500);
			} catch (Exception e1) {
				e1.printStackTrace();
			}
		}
		release();// 短连接，用完释放
	}

	// 释放资源
	private void release() {
		try {
			client.close();
		} catch (IOException e1) {
			e1.printStackTrace();
		}
	}
    //实现readAllBytes方法，传入InputStream对象读到的文件，然后直接读成String，还节省了一大步
	public static String readAllBytes(InputStream is) {
		String str = "";
		byte[] flush = new byte[1024];
		int len = -1;
		try {
			while ((len = is.read(flush)) != -1) {
				str = new String(flush, 0, len).trim();//去空格
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return str;

	}
}

Entity类

存储xml元素的类，全是set get 方法

public class Entity {
	private String name;
	private String clz;

	public Entity() {
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getClz() {
		return clz;
	}

	public void setClz(String clz) {
		this.clz = clz;
	}

}

Mapping

也是存储xml元素的类，全是set get 方法，跟上面不一样的地方在于存储的类型不一样，至于为什么要分开，等你学了前端就懂了

import java.util.HashSet;
import java.util.Set;

/**
 * <servlet-mapping> <servlet-name>login</servlet-name>
 * <url-pattern>/login</url-pattern> <url-pattern>g</url-pattern>
 * </servlet-mapping>
 *
 */
public class Mapping {
	private String name;
	private Set<String> patterns;

	public Mapping() {
		super();
		patterns = new HashSet<String>();
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Set<String> getPatterns() {
		return patterns;
	}

	public void setPatterns(Set<String> patterns) {
		this.patterns = patterns;
	}

	public void addPatterns(String pattern) {
		this.patterns.add(pattern);
	}

}

WebApp类

解析xml文件,这里就用到我们说的反射了

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

public class WebApp {
	private static WebContext webContext;
	static {
		try {
			// 1、获取解析工厂
			SAXParserFactory factory = SAXParserFactory.newInstance();
			// 2、从解析工厂获取解析器
			SAXParser parse = factory.newSAXParser();
			// 3、编写处理器
			// 4、加载文档Document注册处理器
			WebHandler handler = new WebHandler();
			// 5、解析
			parse.parse(Thread.currentThread().getContextClassLoader().getResourceAsStream("web.xml"), handler);
			webContext = new WebContext(handler.getEntitys(), handler.getMappings());
		} catch (Exception e) {
			// 获取数据

		}
	}

	public static Servlet getServletFromUrl(String url) {
		// 假设你输入了/login
		String className = webContext.getClz("/" + url);
		Class clz;
		try {
			clz = Class.forName(className);
			Servlet servlet = (Servlet) clz.getConstructor().newInstance();
			return servlet;
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		return null;
	}

}

WebHandler类

是个处理器，给上面WebApp用的

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> entitys = new ArrayList<Entity>();
	private List<Mapping> mappings = new ArrayList<Mapping>();
	private Entity entity;
	private Mapping mapping;
	private String tag;// 存储操作标签
	private boolean isMapping = false;

	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		// System.out.println(qName + "--->解析开始");
		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;
		}
	}

	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.addPatterns(contents);
				}
			} else {// 操作servlet
				if (tag.equals("servlet-name")) {
					entity.setName(contents);
				} else if (tag.equals("servlet-class")) {
					entity.setClz(contents);
				}
			}

		}
	}

	public void endElement(String uri, String localName, String qName) throws SAXException {
		// System.out.println(qName + "--->解析结束");
		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 void setEnitys(List<Entity> entitys) {
		this.entitys = entitys;
	}

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

	public void setMappings(List<Mapping> mappings) {
		this.mappings = mappings;
	}

}

WebContext类

跟WebHandler类一样，是个工具类，用来处理数据的

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

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());
		}
		// 将mapping的List转成对应的map
		for (Mapping mapping : mappings) {
			for (String pattern : mapping.getPatterns()) {
				mappingMap.put(pattern, mapping.getName());
			}
		}

	}

	/**
	 * @author 帝国 通过URL的路径找到对应class
	 */
	public String getClz(String pattern) {
		String name = mappingMap.get(pattern);
		return entityMap.get(name);
	}

}

下面三个是我们不同页面用到的html文件

这三个文件建议直接放在src下，路径简单，不放的话要把路径写清楚，否则会报错，找不到之类的
login.html

<html>
  <head>
   <title>第一个登录</title>
  </head>
    <body>
      <h1>表单的使用</h1>
      <pre>
        post:提交，基于http协议不同 量大 请求参数url不可见 安全<br/>
        get:默认，获取，基于http协议不同 量小 请求参数url可见 不 安全<br/>
        action:请求web服务器的资源<br/>
        name:作为后端使用，区分为一：请求服务器，必须存在，数据不能提交<br/>
        id:作为前端使用，区分唯一<br/>
       <pre>
      <form method="post" action="http://localhost:8888/login">
                        用户名:<input type = "text"name = "uname"id="uname"/>
                        密码:<input type = "password"name = "pwd"id="pwd"/>
             <input type="submit"value="登录"/>           
      </form>
    </body>
</html>

index.html

<html>
  <head>
   <title>首页</title>
  </head>
    <body>
      <h1>欢迎使用朱邦政建立的服务器噢</h1>
    </body>
</html>

error.html

<html>
  <head>
   <title>404页面</title>
  </head>
    <body>
      <h1>你懂的</h1>
    </body>
</html>

以上就是我们的WebServer了，有一点点难，多咀嚼会有很大的收获。
总结一下

Server服务器—>Request获取请求—>Servlet接口—>LoginServlet等类实现接口里的方法—>配置xml文件—>Enitity和Mapping类存储xml文件的元素—>WebApp、WebContext、WebHandler三个类通过存储的元素解析xml文件并用反射生成对象—>调用相应的html页面或是调用相应的输出方法—>Response返回响应
就这样啦
over~