今天我们来写一个类似于Tomcat的简易服务器。可供大家深入理解一下tomcat的工作原理，本文仅供新手参考，请各位大神指正！
首先我们要准备的知识是：
Socket编程
HTML
HTTP协议
服务器编写
反射
XML解析
有了上面的知识，我们可以开始写我们的代码了~~
1、首先我们要应用Socket编程写一个简单的服务端用来接收服务器端发来的请求:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) {
Server server = new Server();
//1、创建一个服务器端并开启
server.start();
}
public void start(){
try {
ServerSocket ss = new ServerSocket(8888);
//2、接收来自浏览器的请求
this.recevie(ss);
} catch (IOException e) {
e.printStackTrace();
}
}
private void recevie(ServerSocket ss){
try {
Socket client = ss.accept();
//3、将来自浏览器的信息打印出来
BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
StringBuilder httpMessage = new StringBuilder();
while(br.read()!=-1){
httpMessage.append(br.readLine());
httpMessage.append("
");
}
System.out.println(httpMessage.toString());
} catch (IOException e) {
e.printStackTrace();
}
}
}
以下是浏览器访问上述服务器时产生的请求内容：HTTP知识补充：
以下是浏览器访问上述服务器时产生的请求内容：
POST请求内容:（远不止这些，大家可以通过wireshark来抓包分析请求协议格式）
POST / HTTP/1.1
Host: localhost:8888
Connection: keep-alive
Content-Length: 25
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Origin: null
User-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.8
username=ss&password=aaaa
GET请求内容:
GET /?username=aa&password=ssss HTTP/1.1
Host: localhost:8888
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.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36
Accept-Encoding: gzip, deflate, sdch
Accept-Language: zh-CN,zh;q=0.8
下面给出一个服务器响应内容：
通用头域包含请求和响应消息都支持的头域，通用头域包含Cache-Control、 Connection、Date、Pragma、Transfer-Encoding、Upgrade、Via。
HTTP/1.1 200 OK
Cache-Control:private, max-age=0, no-cache：
Control说明：
Cache-Control指定请求和响应遵循的缓存机 制。
Public指示响应可被任何缓存区缓存。
Private指示对于单个用户的整个或部分响应消息，不能被共享缓存处理。这允许服务器仅仅描述当用户的部分响应消息，此响应消息对于其他用户的请求无效。
no-cache指示请求或响应消息不能缓存
no-store用于防止重要的信息被无意的发布。在请求消息中发送将使得请求和响应消息都不使用缓存。
max-age指示客户机可以接收生存期不大于指定时间（以秒为单位）的响应。
min-fresh指示客户机可以接收响应时间小于当前时间加上指定时间的响应。
max-stale指示客户机可以接收超出超时期间的响应消息。如果指定max-stale消息的值，那么客户机可以接收超出超时期指定值之内的响应消息。
Content-Type:image/gif
Content-Type说明：
Content-Type实体头用于向接收方指示实体的介质类型，指定HEAD方法送到接收方的实体介质类型，或GET方法发送的请求介质类型Content-Range实体头
Date:Sat, 08 Aug 2015 03:23:23 GMT
Date说明：
Date头域表示消息发送的时间，时间的描述格式由rfc822定义。
Pragma:no-cache
Pragma说明：
Pragma头域用来包含实现特定的指令，最常用的是Pragma:no-cache。在HTTP/1.1协议中，它的含义和Cache-Control:no-cache相同。
Server:apache
Server说明：
Server响应头包含处理请求的原始服务器的软件信息。此域能包含多个产品标识和注释，产品标识一般按照重要性排序。
Content-Length:43
重点补充：
Status-Code的第一个数字定义响应的类别，后两个数字没有分类的作用。第一个数字可能取5个不同的值：
1xx:信息响应类，表示接收到请求并且继续处理
2xx:处理成功响应类，表示动作被成功接收、理解和接受
3xx:重定向响应类，为了完成指定的动作，必须接受进一步处理
4xx:客户端错误，客户请求包含语法错误或者是不能正确执行
5xx:服务端错误，服务器不能正确执行一个正确的请求
以上补充有利于项目排错哦~~很重要哦~~
2、我们根据上面的服务器相应内容来写一个针对浏览器客户端的响应：
public class Server {
private static final String ENTER = "
";
private static final String SPACE = " ";
public static void main(String[] args) {
Server server = new Server();
//1、创建一个服务器端并开启
server.start();
}
public void start(){
try {
ServerSocket ss = new ServerSocket(8888);
//2、接收来自浏览器的请求
this.recevie(ss);
} catch (IOException e) {
e.printStackTrace();
}
}
private void recevie(ServerSocket ss){
BufferedReader br = null;
try {
Socket client = ss.accept();
//3、将来自浏览器的信息打印出来
br = new BufferedReader(new InputStreamReader(client.getInputStream()));
StringBuilder httpRequest = new StringBuilder();
String meg = null;
while(!(meg = br.readLine().trim()).equals("")){
httpRequest.append(meg);
httpRequest.append("
");
}
System.out.println(httpRequest);
this.httpResponse(client);
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private void httpResponse(Socket client){
BufferedWriter bw = null;
try {
bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
StringBuilder contextText = new StringBuilder();
contextText.append("<html><head></head><body>This is my page</body></html>");
StringBuilder sb = new StringBuilder();
/*通用头域begin*/
sb.append("HTTP/1.1").append(SPACE).append("200").append(SPACE).append("OK").append(ENTER);
sb.append("Server:myServer").append(SPACE).append("0.0.1v").append(ENTER);
sb.append("Date:Sat,"+SPACE).append(new Date()).append(ENTER);
sb.append("Content-Type:text/html;charset=UTF-8").append(ENTER);
sb.append("Content-Length:").append(contextText.toString().getBytes().length).append(ENTER);
/*通用头域end*/
sb.append(ENTER);//空一行
sb.append(contextText);//正文部分
System.out.println(sb.toString());
bw.write(sb.toString());//写会
bw.flush();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3、封装response和request
3.1封装response
步骤：
A:构建报文头
B:构建响应的HTML正文内容
C：将报文头和HTML正文内容发送给客户端（浏览器）
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.Date;
public class Response {
private static final String ENTER = "
";
private static final String SPACE = " ";
//存储头信息
private StringBuilder headerInfo ;
//2、存储正文信息
private StringBuilder textContent;
//3、记录正文信息长度
private int contentLength ;
//4、构建输出流
private BufferedWriter bw ;
public Response() {
headerInfo = new StringBuilder();
textContent = new StringBuilder();
contentLength = 0;
}
public Response(OutputStream os) {
this();
bw = new BufferedWriter(new OutputStreamWriter(os));
}
/**
* 创建头部信息 html报文
* @param code
*/
private void createHeader(int code){
headerInfo.append("HTTP/1.1").append(SPACE).append(code).append(SPACE);
switch (code) {
case 200:
headerInfo.append("OK").append(ENTER);
break;
case 404:
headerInfo.append("NOT FOUND").append(ENTER);
break;
case 500:
headerInfo.append("SERVER ERROR").append(ENTER);
break;
default:
break;
}
headerInfo.append("Server:myServer").append(SPACE).append("0.0.1v").append(ENTER);
headerInfo.append("Date:Sat,"+SPACE).append(new Date()).append(ENTER);
headerInfo.append("Content-Type:text/html;charset=UTF-8").append(ENTER);
headerInfo.append("Content-Length:").append(contentLength).append(ENTER);
headerInfo.append(ENTER);
}
/**
* 响应给浏览器解析的内容（html正文）
* @param content
* @return
*/
public Response htmlContent(String content){
textContent.append(content).append(ENTER);
contentLength += (content+ENTER).toString().getBytes().length;
return this;
}
/**
* 发送给浏览器端
* @param code
*/
public void pushToClient(int code){
createHeader(code);
try {
bw.append(headerInfo.toString());
System.out.println(headerInfo.toString());
bw.append(textContent.toString());
System.out.println(textContent.toString());
bw.flush();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3.2封装request
步骤：
A:接受浏览器发送的请求
B:解析浏览器发送来的请求
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Request {
private static final String ENTER = "
";
//接收请求
private BufferedReader request ;
//储存接受信息
private String requestHeader;
//通过解析头信息得到请求方法
private String method ;
//通过解析头信息得到请求url
private String action ;
//通过解析头信息得到传过来的请求参数 ，可能存在一Key多Value的情况所以用list
private Map<String, List<String>> parameter;
//得到浏览器发过来的头信息
public Request() {
requestHeader = "";
method = "";
action = "";
parameter = new HashMap<String, List<String>>();
}
public Request(InputStream inputStream) {
this();
request = new BufferedReader(new InputStreamReader(inputStream));
//接收到头部信息
try {
String temp;
while(!(temp=request.readLine()).equals("")){
requestHeader += (temp+ENTER);
}
System.out.println(requestHeader);
} catch (IOException e) {
e.printStackTrace();
}
//解析头部信息
parseRequestHeader();
}
/**
* 解析头信息
*/
public void parseRequestHeader(){
//声明一个字符串，来存放请求参数
String parameterString = "";
//读取都头信息的第一行
String firstLine = requestHeader.substring(0, requestHeader.indexOf(ENTER));
//开始分离第一行
//splitPoint分割点1
int splitPointOne = firstLine.indexOf("/");
method = firstLine.substring(0, splitPointOne).trim();
//splitPoint分割点2
int splitPointTwo = firstLine.indexOf("HTTP/");
String actionTemp = firstLine.substring(splitPointOne,splitPointTwo).trim();
if(method.equalsIgnoreCase("post")){
//此处代码为得到post请求的参数字符串，哈哈哈哈，读者自己想想该怎么写哦~~
this.action = actionTemp;
}else if(method.equalsIgnoreCase("get")){
if(actionTemp.contains("?")){
parameterString = actionTemp.substring((actionTemp.indexOf("?")+1)).trim();
this.action = actionTemp.substring(0, actionTemp.indexOf("?"));
}else{
this.action = actionTemp;
}
//将参数封装到Map中哦
parseParameterString(parameterString);
}
}
/**
* 解析参数字符串，将参数封装到Map中
* @param parameterString
*/
private void parseParameterString(String parameterString) {
if("".equals(parameterString)){
return;
}else{
String[] parameterKeyValues = parameterString.split("&");
for (int i = 0; i < parameterKeyValues.length; i++) {
String[] KeyValues = parameterKeyValues[i].split("=");
//可能会出现有key没有value的情况
if(KeyValues.length == 1){
KeyValues = Arrays.copyOf(KeyValues, 2);
KeyValues[1] = null;
}
String key = KeyValues[0].trim();
String values = null == KeyValues[1] ? null : decode(KeyValues[1].trim(),"UTF-8");
//将key和values封装到Map中
if(!parameter.containsKey(key)){//如果不存在key,就创建一个
parameter.put(key, new ArrayList<String>());
}
List<String> value = parameter.get(key);
value.add(values);
}
}
}
/**
* 反解码：使用指定的编码机制对 application/x-www-form-urlencoded 字符串解码。
* @param string
* @param encoding
* @return
*/
public String decode(String string,String encoding){
try {
return URLDecoder.decode(string, encoding);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return null;
}
/**
* 根据名字得到多个值
* @param name
* @return
*/
public String[] getParamterValues(String name){
List<String> values = parameter.get(name);
if(values == null){
return null;
}else{
return values.toArray(new String[0]);
}
}
/**
* 根据名字返回单个值
* @param name
* @return
*/
public String getParamter(String name){
String[] value = getParamterValues(name);
if(value == null){
return null;
}else{
return value[0];
}
}
public String getAction() {
return action;
}
public void setAction(String action) {
this.action = action;
}
public String getMethod() {
return method;
}
public void setMethod(String method) {
this.method = method;
}
}
3.3 此时我们可以将代码优化一下
新建Servlet类来转码处理请求和响应的业务
/**
* 专门处理请求和响应
* @author SNOOPY
*
*/
public class Servlet {
public void service(Request request, Response response){
String username = request.getParamter("user");
response.htmlContent("<html><head></head><body>This is my page<br><br>");
response.htmlContent("欢迎："+username+" 来到我的地盘</body></html>");
}
}
此时我们的服务器端可以简化为：
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
*
* @author SNOOPY
* @version 02
*/
public class Server02 {
public void start(){
try {
ServerSocket serverSocket = new ServerSocket(8888);
//2、接收来自浏览器的请求
this.recevie(serverSocket);
} catch (IOException e) {
e.printStackTrace();
}
}
private void recevie(ServerSocket serverSocket){
try {
Socket client = serverSocket.accept();
Servlet servlet = new Servlet();
Request request = new Request(client.getInputStream());
Response response = new Response(client.getOutputStream());
servlet.service(request, response);
response.pushToClient(200);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Server02 server = new Server02();
//1、创建一个服务器端并开启
server.start();
}
}
4、多线程实现
写到这里我们会发现，此时的代码只能处理一个请求，而现实中的情况是往往会有很多很多的客户端发请求，所以这里我们要用多线程来实现
因此我们把与客户端浏览器的通信封装到一个线程当中。
import java.io.IOException;
import java.net.Socket;
/**
* 分发
* @author SNOOPY
*
*/
public class Dispatch implements Runnable{
private Socket client;
private Request request;
private Response response;
private int code = 200;
public Dispatch(Socket client) {
this.client = client;
try {
request = new Request(client.getInputStream());
response = new Response(client.getOutputStream());
} catch (IOException e) {
//e.printStackTrace();
code = 500;
return ;
}
}
@Override
public void run() {
Servlet servlet = new Servlet();
servlet.service(request, response);
response.pushToClient(code);
try {
client.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
此时我们的服务器只能应对单一的请求与响应，结束后会自动关闭，而现实中的服务器是一直开启等待客户端的请求。
所以我们的服务器端可以优化为：
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
*
* @author SNOOPY
* @version 03
*/
public class Server03 {
private boolean isShutDown = false;
/**
* 启动服务器
*/
public void start(){
start(8888);
}
/**
* 指定服务器端口
* @param port
*/
public void start(int port){
try {
ServerSocket serverSocket = new ServerSocket(port);
//2、接收来自浏览器的请求
this.recevie(serverSocket);
} catch (IOException e) {
//e.printStackTrace();
stop();
}
}
/**
* 关闭服务器
*/
private void stop() {
isShutDown = true;
}
/**
* 接受客户端信息
* @param serverSocket
*/
private void recevie(ServerSocket serverSocket){
try {
while(!isShutDown){
Socket client = serverSocket.accept();
new Thread(new Dispatch(client)).start();
}
} catch (IOException e) {
e.printStackTrace();
//如果这里面有问题直接关闭服务器
isShutDown = true;
}
}
public static void main(String[] args) {
Server03 server = new Server03();
//1、创建一个服务器端并开启
server.start();
}
}
到此时我们会发现我们发过来的请求会有很多，也就意味着我们应该会有很多的servlet，例如：RegisterServlet、LoginServlet等等还有很多其他的访问。
那么我们要用到类似于工厂模式的方法处理，来随时产生很多的servlet，来满足不同的功能性的请求。
那么我们要抽象servlet。
在我们抽象servlet之前，我们先来思考一个问题：
我们会写很多的servlet，那么我们怎么将请求与各种的servlet相匹配呢？
接下来我们要先写一个关于servlet的上下文，来封装servlet与请求。说到这里你是不是想到了什么呢？？
import java.util.HashMap;
import java.util.Map;
/**
* servlet的上下文
* @author SNOOPY
*
*/
public class servletContext {
//通过类名创建servlet对象
private Map<String, Servlet> servlet ;
//通过请求名找到对应的servlet类名
private Map<String , String> mapping ;
public servletContext() {
servlet = new HashMap<String,Servlet>();
mapping = new HashMap<String,String>();
}
public Map<String, Servlet> getServlet() {
return servlet;
}
public void setServlet(Map<String, Servlet> servlet) {
this.servlet = servlet;
}
public Map<String, String> getMapping() {
return mapping;
}
public void setMapping(Map<String, String> mapping) {
this.mapping = mapping;
}
}
其实说白了servletContext这个类就是一个容器，用来存放请求与对应的Servlet的。
那么接下来我们模拟一下，往这个容器里面存放请求与对应的Servlet，但是在这之前我们需要有不同的servlet，所以我们接下来要把Servlet进行抽象，
以便于我们可以随意产生不同的servlet。
/**
* 专门处理请求和响应
* @author SNOOPY
*
*/
public abstract class Servlet {
public void service(Request request, Response response) throws Exception{
String method = request.getMethod();
if(method.equalsIgnoreCase("post")){
this.doPost(request, response);
}else if(method.equalsIgnoreCase("get")){
this.doGet(request, response);
}
}
public void doGet(Request request, Response response) throws Exception{
}
public void doPost(Request request, Response response) throws Exception{
}
}
上面的抽象其实很简单，那么当我们抽象结束后，我们写一个WebApp类来存储一些我们会用到的servlet上下文，并且提供获取他们的方法：
import java.util.HashMap;
import java.util.Map;
/**
* servlet的上下文
* @author SNOOPY
*
*/
public class servletContext {
//通过对应的servlet类名创建servlet对象
private Map<String, Servlet> servlet ;
//通过请求名（action）找到对应的servlet类名
private Map<String , String> mapping ;
public servletContext() {
servlet = new HashMap<String,Servlet>();
mapping = new HashMap<String,String>();
}
public Map<String, Servlet> getServlet() {
return servlet;
}
public void setServlet(Map<String, Servlet> servlet) {
this.servlet = servlet;
}
public Map<String, String> getMapping() {
return mapping;
}
public void setMapping(Map<String, String> mapping) {
this.mapping = mapping;
}
}
接下来我们要修改一下分发的程序了：
import java.io.IOException;
import java.net.Socket;
/**
* 分发
* @author SNOOPY
*
*/
public class Dispatch implements Runnable{
private Socket client;
private Request request;
private Response response;
private int code = 200;
public Dispatch(Socket client) {
this.client = client;
try {
request = new Request(client.getInputStream());
response = new Response(client.getOutputStream());
} catch (IOException e) {
//e.printStackTrace();
code = 500;
return ;
}
}
@Override
public void run() {
try{
String action = request.getAction();
Servlet servlet = WebApp.getServlet(action);
if(servlet == null){
this.code = 404;
response.pushToClient(code);
return;
}
servlet.service(request, response);
} catch (Exception e) {
e.printStackTrace();
code = 500;
}
response.pushToClient(code);
try {
client.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
这样一个简易的原理过程就出来了，别急，还没有结束呢。
我们现在写的代码用来存储servlet上下文的时候用的是Servlet抽象类吧？就是说我们每次存储的时候都要存储一个类，这样是不是有点消耗内存呢？如果换成字符串呢？
还有一点就是如果我们每次修改这个类是不是都要重启一下服务器？是不是很麻烦？？所以。。。你想到了什么？
随你便啦~~其实如果你写过非框架的web应用，那么应该接触过配置文件。那么应该想到的就是web.xml
接下来讲一下配置文件吧，哈哈哈哈哈哈
一说到配置文件，肯定是要解析配置文件的，一解析配置又牵扯到类与对象，少不了的技术就是反射机制哦！！
首先让我们稍微修改一下ServletContext类；
import java.util.HashMap;
import java.util.Map;
/**
* servlet的上下文
* @author SNOOPY
*
*/
public class ServletContext {
//通过对应的servlet类名创建servlet对象
//private Map<String, Servlet> servlet ;
private Map<String, String> servlet ;
//通过请求名（action）找到对应的servlet类名
private Map<String , String> mapping ;
public ServletContext() {
servlet = new HashMap<String,String>();
mapping = new HashMap<String,String>();
}
public Map<String, String> getServlet() {
return servlet;
}
public void setServlet(Map<String, String> servlet) {
this.servlet = servlet;
}
public Map<String, String> getMapping() {
return mapping;
}
public void setMapping(Map<String, String> mapping) {
this.mapping = mapping;
}
}
那么接下来我们要做的就是解析XML文件并且将解析好的值放入servlet上下文中。
解析xml文件之前我们先要用实体类来封装xml文件
/**
*
* @author SNOOPY
*
*/
public class XmlServlet {
private String servlet_name;
private String servlet_class;
public String getServlet_name() {
return servlet_name;
}
public void setServlet_name(String servlet_name) {
this.servlet_name = servlet_name;
}
public String getServlet_class() {
return servlet_class;
}
public void setServlet_class(String servlet_class) {
this.servlet_class = servlet_class;
}
}
import java.util.ArrayList;
import java.util.List;
/**
* 一个servlet可以对应多个action
* @author SNOOPY
*
*/
public class XmlMapping {
private String servlet_name;
private List<String> url_pattern;
public XmlMapping() {
url_pattern = new ArrayList<String>();
}
public String getServlet_name() {
return servlet_name;
}
public void setServlet_name(String servlet_name) {
this.servlet_name = servlet_name;
}
public List<String> getUrl_pattern() {
return url_pattern;
}
public void setUrl_pattern(List<String> url_pattern) {
this.url_pattern = url_pattern;
}
}
然后再解析XML文件并且将解析好的值放入servlet上下文中。
import java.io.IOException;
import java.io.InputStream;
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;
/**
* 存储一些我们会用到的servlet上下文，并且提供获取他们的方法
* @author SNOOPY
*
*/
public class WebApp {
private static ServletContext context;
static {
context = new ServletContext();
//创建存放servlet上下文的容器
Map<String, String> mapping = context.getMapping();
Map<String, String> servlet = context.getServlet();
//解析配置文件，将对应的字符串存入里面
/*补充知识：
* 解析配置文件的方法有很多，最基本的是SAX解析和DOM解析：SAX解析式基于事件流的解析，DOM解析是基于XML文档树结构的解析
* 另外还有DOM4J和JDOM都可以解析。
* DOM和SAX的区别：
* DOM解析适合于对文件进行修改和随机存取的操作，但是不适合于大型文件的操作；
* SAX采用部分读取的方式，所以可以处理大型文件，而且只需要从文件中读取特定内容，SAX解析可以由用户自己建立自己的对象模型。
* 所以DOM解析适合于修改，SAX解析适合于读取大型文件，2者结合的话可以用JDOM
*
* 本次示例为了方便就选择SAX解析，步骤一共分三步：
* 1、获得解析工程类。
* 2、工程获取解析器
* 3、加载文档注册处理器
*/
//1、获得工厂类
SAXParserFactory factory = SAXParserFactory.newInstance();
try {
//2、从解析工程获取解析器
SAXParser parser = factory.newSAXParser();
//3、加载文档并注册处理器（handle）。注意：此处的文档可以用file的形式也可以用流的形式，随便,便于学习，下面提供两种。
//String filePath = "";
//parser.parse(new File(filePath), handler);
XMLHandler handler = new XMLHandler();
InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("com/httpservlet/WEB-INF/web.xml");
parser.parse(is, handler);
List<XmlServlet> serv = handler.getServlet();
for (XmlServlet xmlServlet : serv) {
servlet.put(xmlServlet.getServlet_name(), xmlServlet.getServlet_class());
}
List<XmlMapping> map = handler.getMapping();
for (XmlMapping maps : map) {
List<String> actions = maps.getUrl_pattern();
for (String action : actions) {
mapping.put(action, maps.getServlet_name());
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static Servlet getServlet(String action){
if("".equals(action) || action == null){
return null;
}
//通过action找到servlet-name
String servlet_name = context.getMapping().get(action);
//通过反射，找到相应的类，创建其对象并返回
String classPath = context.getServlet().get(servlet_name);//通过action得到类路径
Servlet servlet = null;
if(classPath != null){
Class<?> clazz = null;
try {
clazz = Class.forName(classPath);
servlet = (Servlet)clazz.newInstance();//要确保空构造存在
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
return servlet;
}
}
这里还需要一个XMLHandler处理器来处理xml文件
import java.util.ArrayList;
import java.util.List;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
/**
* 存储对象
* @author SNOOPY
*
*/
public class XMLHandler extends DefaultHandler {
private List<XmlServlet> servlet ;
private List<XmlMapping> mapping ;
public List<XmlServlet> getServlet() {
return servlet;
}
public void setServlet(List<XmlServlet> servlet) {
this.servlet = servlet;
}
public List<XmlMapping> getMapping() {
return mapping;
}
public void setMapping(List<XmlMapping> mapping) {
this.mapping = mapping;
}
private XmlServlet serv ;
private XmlMapping map ;
private String beginTag;
private boolean isMap;
@Override
public void startDocument() throws SAXException {
servlet = new ArrayList<XmlServlet>();
mapping = new ArrayList<XmlMapping>();
}
@Override
public void startElement(String uri, String localName, String qName,
Attributes attributes) throws SAXException {
if(null!=qName){
beginTag = qName;
if(qName.equals("servlet")){
serv = new XmlServlet();
isMap = false;
}else if(qName.equals("servlet-mapping")){
map = new XmlMapping();
isMap = true;
}
}
}
@Override
public void characters(char[] ch, int start, int length)
throws SAXException {
if(beginTag != null){
String info = new String(ch, start, length);
if(isMap){
if(beginTag.equals("servlet-name")){
map.setServlet_name(info.trim());
}else if(beginTag.equals("url-pattern")){
map.getUrl_pattern().add(info);
}
}else{
if(beginTag.equals("servlet-name")){
serv.setServlet_name(info);
}else if(beginTag.equals("servlet-class")){
serv.setServlet_class(info);
}
}
}
}
@Override
public void endElement(String uri, String localName, String qName)
throws SAXException {
if(null!=qName){
if(qName.equals("servlet")){
servlet.add(serv);
}else if(qName.equals("servlet-mapping")){
mapping.add(map);
}
}
beginTag = null;
}
@Override
public void endDocument() throws SAXException {
//文档结束
}
}
万事具备只欠东风！---->处理一下分发的类：
import java.io.IOException;
import java.net.Socket;
/**
* 分发
* @author SNOOPY
*
*/
public class Dispatch implements Runnable{
private Socket client;
private Request request;
private Response response;
private int code = 200;
public Dispatch(Socket client) {
this.client = client;
try {
request = new Request(client.getInputStream());
response = new Response(client.getOutputStream());
} catch (IOException e) {
//e.printStackTrace();
code = 500;
return ;
}
}
@Override
public void run() {
try{
String action = request.getAction();
Servlet servlet = WebApp.getServlet(action);
if(servlet == null){
this.code = 404;
response.pushToClient(code);
return;
}
servlet.service(request, response);
/*String method = request.getMethod();
if(method.equalsIgnoreCase("post")){
servlet.doPost(request, response);
}else if(method.equalsIgnoreCase("get")){
servlet.doGet(request, response);
}*/
} catch (Exception e) {
e.printStackTrace();
code = 500;
}
response.pushToClient(code);
try {
client.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
经过以上的分析以及代码的书写，一个简易的web服务器就这样诞生了！
各位看官可以动手尝试一下哦~~
当然代码有很多的地方还很值得去优化和修正，希望有心的大神能指正错误，我会及时修正！！
注意：此文仅适用于刚入门的同学，帮助理解服务器原理。
附：手写服务器包结构（最终整理）
