理解tomcat之搭建简易http服务器

最新推荐文章于 2024-07-13 13:55:40 发布

weixin_33851177

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量351

点赞数

文章标签： java

原文链接：https://my.oschina.net/wf1994/blog/685699

版权

做过java web的同学都对tomcat非常熟悉。我们在使用tomcat带来的便利的同时，是否想过tomcat是如何工作的呢？tomcat本质是一个http服务器，本篇文章将搭建一个简单的http服务器。

1 Catalina模型

　　　首先我们先了解一下tomcat的大致工作原理。tomcat的核心是servlet容器，我们称它为Catalina(为什么叫这个名字？我也不知道￣へ￣)。模型图如1.1

Connector是用来“连接”容器里边的请求的。它的工作是为接收到每一个 HTTP 请求构造一个 request 和 response 对象。然后它把流程传递给容器。容器从连接器接收到 requset 和 response 对象之后调用 servlet 的 service 方法用于响应。谨记,这个描述仅仅是冰山一角而已。这里容器做了相当多事情。例如,在它调用 servlet 的 service 方法之前,它必须加载这个 servlet,验证用户(假如需要的话),更新用户会话等等。以此为思路，我们就开始我们的构造http服务器之旅吧。

2 服务器搭建

　　首先我们明确一下我们的服务器的功能点。

　　1. 需要有一个类去接收http请求；

　　2. 需要一个自定义Request类和Response类，把接收到的请求构造成这两个类；

　　3. 根据请求的格式来确定处理方式：返回静态资源 or 进入Servlet ？

　　4. 需要一个Servlet类执行业务逻辑

　　UML图如下2.1

　　　　　　　　　　　　　　　　　　　图2.1

2.1 HttpServer　

首先构造HttpServer类

public class HttpServer {

private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";
private static boolean shutdown = false;

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

public static void await() {
ServerSocket serverSocket = null;
int port = 8080;
try {
serverSocket = new ServerSocket(port, 1,
InetAddress.getByName("127.0.0.1"));
} catch (IOException e) {
e.printStackTrace();
System.exit(1);
}
// Loop waiting for a request
while (!shutdown) {
Socket socket = null;
InputStream input = null;
OutputStream output = null;
try {
socket = serverSocket.accept();
input = socket.getInputStream();
output = socket.getOutputStream();
// create Request object and parse
Request request = new Request(input);
request.parseUrl();
// create Response object
Response response = new Response(output);
response.setRequest(request);

if (request.getUri().startsWith("/v2/")) {
ServletProcessor processor = new ServletProcessor();
processor.process(request, response);
}
else {
StaticResourceProcessor processor =
new StaticResourceProcessor();
processor.process(request, response);
}
// Close the socket
socket.close();
//check if the previous URI is a shutdown command
shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
}
}

　　我们的服务器启动入口放在了HttpServer里面。await()方法负责接收Socket连接，只有当用户输入了代表shutdown的URL时，服务器才会停止运行。Request类提供了解析请求的功能,根据请求的url，来决定是返回静态资源，或者进入对应的servlet类执行service逻辑。

这里我们需要关注一下ServerSocket这个类的用法。Socket 类代表一个客户端套接字,即任何时候你想连接到一个远程服务器应用的时候，你都会第一时间想到这个类。而ServerSocket 和 Socket 不同,服务器套接字的角色是等待来自客户端的连接请求。一旦服务器套接字获得一个连接请求,它创建一个 Socket 实例来与客户端进行通信。 ServletSocket套接字的其中一个构造函数为

public ServerSocket(int port, int backLog, InetAddress bindingAddress);

port代表端口号，backLog代表这个套接字可支持的最大连接数量，bindingAddress代表服务器绑定的地址。一旦你有一个 ServerSocket 实例，你可以通过调用 ServerSocket 类的 accept 方法j。这个监听当前地址的当前端口上的请求，方法只会在有连接请求时才会返回,并且返回值是一个 Socket 类的实例。

2.2 Request Response

servlet 的 service 方法从 servlet 容器中接收一个 javax.servlet.ServletRequest 实例和一个 javax.servlet.ServletResponse 实例。这就是说对于每一个 HTTP 请求,servlet 容器必须构造一个 ServletRequest 对象和一个 ServletResponse 对象并把它们传递给正在服务的 servlet 的 service 方法。

public class Request implements ServletRequest {

private InputStream input;
private String uri;

public Request(InputStream input) {
this.input = input;
}

public String getUri(){
return uri;
}

public void parseUrl() {
StringBuffer request = new StringBuffer(2048);
int i;
byte[] buffer = new byte[2048];

try {
i = input.read(buffer);
} catch (IOException e) {
e.printStackTrace();
i = -1;
}

for (int j = 0; j < i; j++) {
request.append((char) buffer[j]);
}

System.out.print(request.toString());
uri = parseUri(request.toString());
}

private static String parseUri(String requestString) {
int index1, index2;
index1 = requestString.indexOf(' ');
if (index1 != -1) {
index2 = requestString.indexOf(' ', index1 + 1);
if (index2 > index1)
return requestString.substring(index1 + 1, index2);
}
return null;
}

@Override
public Object getAttribute(String name) {
return null;
}

@Override
public Enumeration getAttributeNames() {
return null;
}

@Override
public String getCharacterEncoding() {
return null;
}

@Override
public void setCharacterEncoding(String env) throws UnsupportedEncodingException {

}

@Override
public int getContentLength() {
return 0;
}

@Override
public String getContentType() {
return null;
}

@Override
public ServletInputStream getInputStream() throws IOException {
return null;
}

@Override
public String getParameter(String name) {
return null;
}

@Override
public Enumeration getParameterNames() {
return null;
}

@Override
public String[] getParameterValues(String name) {
return new String[0];
}

@Override
public Map getParameterMap() {
return null;
}

@Override
public String getProtocol() {
return null;
}

@Override
public String getScheme() {
return null;
}

@Override
public String getServerName() {
return null;
}

@Override
public int getServerPort() {
return 0;
}

@Override
public BufferedReader getReader() throws IOException {
return null;
}

@Override
public String getRemoteAddr() {
return null;
}

@Override
public String getRemoteHost() {
return null;
}

@Override
public void setAttribute(String name, Object o) {

}

@Override
public void removeAttribute(String name) {

}

@Override
public Locale getLocale() {
return null;
}

@Override
public Enumeration getLocales() {
return null;
}

@Override
public boolean isSecure() {
return false;
}

@Override
public RequestDispatcher getRequestDispatcher(String path) {
return null;
}

@Override
public String getRealPath(String path) {
return null;
}

@Override
public int getRemotePort() {
return 0;
}

@Override
public String getLocalName() {
return null;
}

@Override
public String getLocalAddr() {
return null;
}

@Override
public int getLocalPort() {
return 0;
}
}

Request类代表一个 request 对象并被传递给 servlet 的 service 方法。就本身而言,它必须实现 javax.servlet.ServletRequest 接口。这个类必须提供这个接口所有方法的实现。不过,我们想要让它非常简单并且仅仅提供实现其中一些方法，比如解析url的功能。在Request初始化时初始化成员变量inputStream，并且用parseUrl()方法创建了一个字节数组来读入输入流，并转化为成一个StringBuffer对象，进而解析url。

public class Response implements ServletResponse {

private static final int BUFFER_SIZE = 1024;
Request request;
OutputStream output;
PrintWriter writer;

public Response(OutputStream output) {
this.output = output;
}

public void setRequest(Request request) {
this.request = request;
}

public void sendStaticResource() throws IOException {
byte[] bytes = new byte[BUFFER_SIZE];
FileInputStream fis = null;
try {
File file = new File(HttpServer.WEB_ROOT, request.getUri());
if (file.exists()) {
fis = new FileInputStream(file);
int ch = fis.read(bytes, 0, BUFFER_SIZE);
while (ch != -1) {
output.write(bytes, 0, ch);
ch = fis.read(bytes, 0, BUFFER_SIZE);
}
} else {
String errorMessage = "HTTP/1.1 404 File Not Found\r\n" +
"Content-Type: text/html\r\n" + "Content-Length: 23\r\n" + "\r\n" +
"<h1>File Not Found</h1>";
output.write(errorMessage.getBytes());
}
} catch (Exception e) {
System.out.println(e.toString());
} finally {
if (fis != null)
fis.close();
}
}

@Override
public String getCharacterEncoding() {
return null;
}

@Override
public String getContentType() {
return null;
}

@Override
public ServletOutputStream getOutputStream() throws IOException {
return null;
}

@Override
public PrintWriter getWriter() throws IOException {
writer = new PrintWriter(output, true);
return writer;

}

@Override
public void setCharacterEncoding(String charset) {

}

@Override
public void setContentLength(int len) {

}

@Override
public void setContentType(String type) {

}

@Override
public void setBufferSize(int size) {

}

@Override
public int getBufferSize() {
return 0;
}

@Override
public void flushBuffer() throws IOException {

}

@Override
public void resetBuffer() {

}

@Override
public boolean isCommitted() {
return false;
}

@Override
public void reset() {

}

@Override
public void setLocale(Locale loc) {

}

@Override
public Locale getLocale() {
return null;
}
}

Response类则提供了发送静态资源的功能。sendStaticResource()方法根据request内解析过的url，在本地寻找指定文件。如果找得到，把文件内容读出到浏览器，如果找不到，那么返回404的错误码。

2.3 PrimitiveServlet类

public class PrimitiveServlet implements Servlet {

@Override
public void init(ServletConfig config) throws ServletException {
System.out.println("init");
}

@Override
public ServletConfig getServletConfig() {
return null;
}

@Override
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
System.out.println("from service");
PrintWriter out = res.getWriter();
out.println("Hello. Roses are red.");
out.print("Violets are blue.");
}

@Override
public String getServletInfo() {
return "this is v2 info";
}

@Override
public void destroy() {
System.out.println("destroy");
}
}

PrimitiveServlet实现了标准的Servlet接口。我们简单的实现了Servlet生命周期的其他方法，并在service()方法我们做了最简单的向浏览器吐文字的操作。

2.4 ServletProcessor 和 StaticResourceProcessor

public class ServletProcessor {

public void process(Request request, Response response) {
String uri = request.getUri();
String servletName = uri.substring(uri.lastIndexOf("/") + 1);
Class myClass = null;
try {
myClass = Class.forName("tomcat.v2." + servletName);
} catch (ClassNotFoundException e) {
System.out.println(e.toString());
}
Servlet servlet = null;
try {
servlet = (Servlet) myClass.newInstance();
servlet.service((ServletRequest) request, (ServletResponse) response);
} catch (Exception e) {
e.printStackTrace();
} catch (Throwable e) {
e.printStackTrace();
}
}
}