How tomcat work连载2:简易的Servlet容器

How tomcat work连载二:简易的Servlet容器

以下代码是仿照《How tomcat work》第二章:如何创建一个简易的Servlet容器，当然会是在上一篇文章http://bestchenwu.iteye.com/blog/1513984的基础上创建的。

代码示例如下:

先创建一个简易的Servlet，如下所示:

package ex02.pyrmont;

import static util.DateUtil.getCurrentDateInTranditional;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import org.apache.log4j.Logger;

/**
 * 类PrimeServlet.java的实现描述：
 */
public class PrimeServlet implements Servlet {

    private static final Logger log = Logger.getLogger("actionLog");

    @Override
    public void init(ServletConfig config) throws ServletException {
        if (log.isInfoEnabled()) {
            log.info("PrimeServlet init on:" + getCurrentDateInTranditional());
        }
    }

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

    @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        if (log.isInfoEnabled()) {
            log.info("PrimeServlet service on:" + getCurrentDateInTranditional());
        }
        PrintWriter pw = res.getWriter();
        pw.println("Hello world");
        pw.flush();
    }

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

    @Override
    public void destroy() {
        if (log.isInfoEnabled()) {
            log.info("PrimeServlet destroy on:" + getCurrentDateInTranditional());
        }
    }

}

这里我引入了一个自己编写的日期操作类的静态方法，代码如下所示:

package util;

import java.text.Format;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 类DateUtil.java的实现描述：
 */
public class DateUtil {

    private static final Format format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    /**
     * 返回当前时间
     * 
     * @return {@link java.util.Date}
     */
    public static Date getCurrentDate() {
        return new Date();
    }

    /**
     * 返回日期的表示时间，类似与yyyy-MM-dd hh:MM:ss
     * 
     * @return 格式化后的日期
     */
    public static String getCurrentDateInTranditional() {
        return format.format(getCurrentDate());
    }
}

然后我们还是按照HttpServer、Request、Response的方式来创建:

先创建HttpServer:

import static ex02.pyrmont.HttpConstants.SHUT_DOWN;

import static util.DateUtil.getCurrentDateInTranditional;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

import org.apache.log4j.Logger;

/**
 * 类HttpServer.java的实现描述：
 */
public class HttpServer {

    private static final Logger log = Logger.getLogger("actionLog");
    private ServerSocket        httpServer;

    /**
     * 初始化监听Server
     * 
     * @param port 监听端口
     * @param backLog 监听队列的最大长度
     * @param serverName 监听机器的域名
     */
    public HttpServer(int port, int backLog, String serverName){
        try {
            httpServer = new ServerSocket(port, backLog, InetAddress.getByName(serverName));
            if (log.isInfoEnabled()) {
                log.info("HttpServer init on:" + getCurrentDateInTranditional());
            }
        } catch (UnknownHostException e) {
            log.error(e.getMessage(), e);
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        }
    }

    public static void main(String[] args) {
        HttpServer httpServer = new HttpServer(HttpConstants.port, 1, "127.0.0.1");
        httpServer.listen();
    }

    /**
     * 启动HttpServer的监听程序
     */
    public void listen() {
        if (httpServer == null) {
            throw new IllegalStateException("httpServer is null");
        }
        boolean isShutdown = false;
        Socket client;
        InputStream is;
        OutputStream os;
        while (!isShutdown) {
            try {
                client = httpServer.accept();
                is = client.getInputStream();
                os = client.getOutputStream();
                Request request = new Request(is);
                request.parse();
                Response response = new Response(request);
                response.setOutput(os);
                /** 检查uri是否是Servelt **/
                if (request.checkIsServlet()) {
                    /** 发送动态消息 **/
                    Processor processor = new DynamicProcessor(request, response);
                    processor.sendMessage();
                } else {
                    /** 发送静态消息 **/
                    Processor processor = new StaticProcessor(request, response);
                    processor.sendMessage();
                }
                client.close();
                /** 判断是否是关闭命令 **/
                isShutdown = request.getUri().equalsIgnoreCase(SHUT_DOWN);
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
        /** 监听结束，调用关闭HttpServer程序 **/
        close();
    }

    /**
     * 关闭HttpServer
     */
    public void close() {
        if (httpServer != null && !httpServer.isClosed()) {
            try {
                httpServer.close();
                if (log.isInfoEnabled()) {
                    log.info("httpServer destroy on:" + getCurrentDateInTranditional());
                }
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
    }
}

看到与之前的HttpServer的区别没？这里的HttpServer尝试去判断uri是否是去请求一个servlet，我们假定所有的Servlet请求都是以/servlet/Servelt类名来结尾的。

接下来是Request、Response，这次Request改为实现ServletRequest、ServletResponse，当然很多方法我们都是仅提供默认实现或者空实现。

Request代码如下所示:

package ex02.pyrmont;

import static ex02.pyrmont.HttpConstants.BUFFER_SIZE;
import static ex02.pyrmont.HttpConstants.SERVLET_PREFIX;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.security.Principal;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletInputStream;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.log4j.Logger;

/**
 * 类Request.java的实现描述：
 */
public class Request implements HttpServletRequest {

    private static final Logger log = Logger.getLogger("actionLog");
    private InputStream         is;
    private String              uri;

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

    /**
     * 将读取到的HttpRequest提取出uri
     */
    public void parse() {
        StringBuffer sb = new StringBuffer(BUFFER_SIZE);
        byte[] buffers = new byte[BUFFER_SIZE];
        int ch;
        try {
            ch = is.read(buffers);
            if (ch != -1) {
                for (int i = 0; i < ch; i++) {
                    sb.append((char) buffers[i]);
                }
            }
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        }
        if (log.isDebugEnabled()) {
            log.debug("Request:" + sb.toString());
        }
        this.uri = parseUri(sb.toString());
    }

    /**
     * 提取出request中第一行的uri 类似于GET/POST /page/index.html HTTP1.1/1.0
     * 
     * @param request
     */
    private String parseUri(String request) {
        int index1, index2;
        index1 = request.indexOf(' ');
        if (index1 > -1) {
            index2 = request.indexOf(' ', index1 + 1);
            if (index2 > index1) {
                return request.substring(index1 + 1, index2);
            }
        }
        return "";
    }

    /**
     * @return the uri
     */
    public String getUri() {
        return uri;
    }

    /**
     * 检查请求的uri是否是Servlet<br/>
     * 即uri是否是
     * 
     * @return boolean true
     */
    public boolean checkIsServlet() {
        return this.getUri().startsWith(SERVLET_PREFIX);
    }

   //...  一些
}

Response代码如下所示:

package ex02.pyrmont;

import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Locale;

import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

/**
 * 类Response.java的实现描述：
 */
public class Response implements ServletResponse {

    private Request      request;
    private OutputStream os;

    public Response(ServletRequest request){
        this.request = (Request) request;
    }

    public void setOutput(OutputStream os) {
        this.os = os;
    }

    public OutputStream getOutput() {
        return this.os;
    }
  
   /**
    * 这个方法覆盖是必须的，用来向页面输出
    */  
   @Override
    public PrintWriter getWriter() throws IOException {
        PrintWriter pw = new PrintWriter(new OutputStreamWriter(os));
        return pw;
    }
}

常量接口类如下所示:

package ex02.pyrmont;

import java.io.File;

/**
 * 类HttpConstants.java的实现描述：
 */
public interface HttpConstants {

    /** HttpServer监听的端口 **/
    public static final int    port           = 8773;

    /** 读取或者写入的缓冲区大小 **/
    public static final int    BUFFER_SIZE    = 2048;

    /** servlet请求时候的前缀 **/
    public static final String SERVLET_PREFIX = "/servlet/";

    /** 静态文件的公共目录 **/
    public static final String WEB_ROOT       = System.getProperty("user.dir") + File.separator + "webRoot";

    /** HttpServer关闭命令 **/
    public static final String SHUT_DOWN      = "/shutdown";
  
    /**  静态文件找不到的时候的错误提示页面 **/
    public static final String ERROR_HTML     = "<html><body><div><h1>can't find your request</h1></div></body></html>";
}

接下来是分别针对于静态文件和Servlet的处理类，抽象类实现如下所示:

package ex02.pyrmont;

import static ex02.pyrmont.HttpConstants.SHUT_DOWN;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import org.apache.log4j.Logger;

/**
 * 类Processor.java的实现描述：
  */
public abstract class Processor {

    protected static final Logger log = Logger.getLogger("actionLog");
    protected Request             request;
    protected Response            response;

    public Processor(ServletRequest request, ServletResponse response){
        this.request = (Request) request;
        this.response = (Response) response;
    }

    /**
     * 检查uri是否合格
     * 
     * @return boolean
     */
    protected boolean checkUriIsValid() {
        String uri = request.getUri();
        if (uri.equalsIgnoreCase(SHUT_DOWN)) {
            return false;
        }
        return true;
    }

    /**
     * 发送消息
     */
    public abstract void sendMessage();

    @Override
    public String toString() {
        return String.format("Processor=%s[request=%s,response=%s]", this.getClass().getSimpleName(), this.request,
                             this.response);
    }
}

静态文件的处理类如下所示:

package ex02.pyrmont;

import static ex02.pyrmont.HttpConstants.BUFFER_SIZE;
import static ex02.pyrmont.HttpConstants.ERROR_HTML;
import static ex02.pyrmont.HttpConstants.WEB_ROOT;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

/**
 * 类StaticProcessor.java的实现描述：
 */
public class StaticProcessor extends Processor {

    public StaticProcessor(ServletRequest request, ServletResponse response){
        super(request, response);
    }

    @Override
    public void sendMessage() {
        if (!super.checkUriIsValid()) {
            return;
        }
        try {
            OutputStream os = response.getOutput();
            File file = new File(WEB_ROOT, request.getUri());
            if (!file.exists()) {
                log.error("can't find uri:" + request.getUri());
                os.write(ERROR_HTML.getBytes());
            } else {
                int ch;
                InputStream is = new FileInputStream(file);
                byte[] buffers = new byte[BUFFER_SIZE];
                while ((ch = is.read(buffers, 0, BUFFER_SIZE)) != -1) {
                    /** 输出页面到前台展示页面 **/
                    os.write(buffers, 0, ch);
                }
                closeIO(is);
            }
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        }
    }

    /**
     * 关闭I/O资源
     * 
     * @param is
     */
    private void closeIO(InputStream is) {
        if (is != null) {
            try {
                is.close();
            } catch (IOException e) {
                log.error(e.getMessage(), e);
            }
        }
    }
}

动态文件的处理类如下所示:

至此，一个简易的 Servlet容器创建完毕，先启动HttpServer，然后在浏览器里输入:

http://127.0.0.1:8773/servlet/ex02.pyrmont.PrimeServlet

http://127.0.0.1:8773/pages/index.html

看下是不是可以看到我们的响应输出

当然这里所述的文件寻址目录都位于工程下的webRoot一级目录，所以你需要确保所有的静态文件、servlet在运行期间都会存在于该目录下，比较简单的方法就是把静态文件也放到src目录下，为它们创建一个单独的目录，比如pages

这个容器还有个小问题，就是我们的servlet去服务的时候，传入的参数还是Request、Response类型，这里我们可以创建一个适配所有ServletRequest 、ServletResponse的接口，让我们的servlet的服务方法传入的参数是这个适配接口，就像下面这样:

import java.io.BufferedReader;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;

/**
 * 类RequestFacade.java的实现描述：
 */
public class RequestFacade implements ServletRequest {

    private ServletRequest request;

    public RequestFacade(Request request){
        this.request = request;
    }
}

response也是这样

这样的话，servlet处理器只需要像下面这样修改:

            Class<Servlet> servletClass = (Class<Servlet>) loader.loadClass(servletClassName);
            Servlet servlet = (Servlet) servletClass.newInstance();
            /** 初始化Servlet **/
            servlet.init(null);
            /** 执行它的服务方法 **/
            RequestFacade requestFacade = new RequestFacade(request);
            ResponseFacade responseFacade = new ResponseFacade(response);
            servlet.service(requestFacade, responseFacade);
            /** 销毁Servlet **/
            servlet.destroy();

再次启动HttpServer，看下修改后是否能通过。

How tomcat work连载2:简易的Servlet容器

相关推荐