前言：
在看完尚学堂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连接。
具体方法是：
- 首先新建一个ServerSocket对象server，指明端口号信息
- 然后使用server.accept()函数监听端口，监听到连接以后返回一个Socket对象
- 通过这个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> 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>();
}
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 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());
}
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("" +
" test " +
"" +
"" +
"hellow
"+
"" +
"");
}
@Override
public void doPost(Request req, Response rep) {
this.doGet(req, rep);
}
}
5.处理类生成工厂
为了编程的灵活性，我们将该httpserver写出可以根据一个xml配置文件知道有多少种分别处理什么url请求的类，该xml就负责记录这种映射关系
首先需要一个ServletContext类，该类有两个属性private Map
package top.dlkkill.httpserver;
import java.util.HashMap;
import java.util.Map;
public class ServletContext {
//名称到类存储地址之间的映射
private Map servlet;
//url到名称之间的映射
private Map map;
public void setServlet(Map servlet) {
this.servlet = servlet;
}
public void setMap(Map map) {
this.map = map;
}
public ServletContext() {
servlet=new HashMap();
map=new HashMap();
}
public Map getServlet() {
return servlet;
}
public Map 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 servlet=servletcontext.getServlet();
Map 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 entityList=hd.getEntityList();
List mappingList=hd.getMappingList();
for (Mapping mapping : mappingList) {
String name=mapping.getName();
List 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 servlet=servletcontext.getServlet();
Map 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 entityList;
private List mappingList;
private Entity entity;
private Mapping mapping;
private String tag;
private boolean isMap;
public WebHandler() {
}
public List getEntityList() {
return entityList;
}
public List getMappingList() {
return mappingList;
}
@Override
public void startDocument() throws SAXException {
entityList=new ArrayList();
mappingList=new ArrayList();
}
@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 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();
}
}
}
}