理解与模拟一个简单servlet容器

servlet接口

　　使用servlet编程需要实现或者继承实现了javax.servlet.Servlet接口的类,其中定义了5个签名方法：

public void init(ServletConfig config) throws ServletException
public void service(ServletRequest req,ServletResponse res) throws ServletException,java.io.IOException
public void destroy()
public ServletConfig getServletConfig()
public java.lang.String getServletInfo()

init(),service(),destroy对应着servlet的生命周期，init只在加载该servlet时执行且只此一次，容器根据用户请求调用对应servlet的service执行方法，当实例销毁移除前容器调用destroy处理后续操作。

模拟容器主要工作流程：

• 等待http请求
• 根据请求创建对应Request与Response对象
• 如果请求的是静态资源，则调用StaticResourceProcessor发送对应资源
• 如果请求是servlet，则加载该类并执行其service方法

简单servlet容器

 主要类信息如下：

1. HttpServer  与web服务器类似，不同的是加入了servlet请求判断，并调用ServletProcessor处理对应servlet
2. Request   与上一篇web服务器类似，但是实现了ServletRequest接口
3. Response   与上一篇web服务器类似，但是实现了ServletResponse接口
4. StaticResourceProcessor  用于处理请求静态资源时调用
5. ServletProcessor 用于当请求是servlet时调用
6. Constant 定义一些常量
7. MyLogger 自己定义在控制台打印日志信息，可以忽略
8. PrimitiveServlet 实现servlet接口，自定义servlet程序用于请求调用

说明：部分接口只是实现了需要用到的方法，并没有完全实现所有方法，使用默认即可，代码里面没有贴出来

(一）HttpServer 

public class HttpServer {
    MyLogger logger = new MyLogger<>(HttpServer.class);
    private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";
    private boolean  shutdown = false;
    
    public void await() {
        ServerSocket serverSocket = null;
        int port = 8080;
        try {
            serverSocket = new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
            logger.log("server started......." + "at " + serverSocket.toString());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.exit(1);
        }
        while (!shutdown){
            Socket socket = null;
            InputStream inputStream = null;
            OutputStream outputStream = null;
            try {
                socket = serverSocket.accept();
                logger.log("accepted new request...");
                inputStream = socket.getInputStream();
                outputStream = socket.getOutputStream();
                Request request = new Request(inputStream);
                request.Parse();
                Response response = new Response(outputStream);
                response.setRequest(request);
                logger.log("inition done,begin process.......");
                if(request.getUri() == null){
                    logger.log("request uri is null...close socket");
                    socket.close();
                    continue;
                }
                else if(request.getUri().startsWith("/servlet/")){
                    logger.log("execute servlet...");
                    ServletProcessor servletProcessor = new ServletProcessor();
                    servletProcessor.process(request, response);
                }
                else {
                    logger.log("send staticResource...");
                    StaticResourceProcessor staticResourceProcessor = new StaticResourceProcessor();
                    staticResourceProcessor.process(request, response);
                }
                socket.close();
                shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

(二）Request 

public class Request implements ServletRequest{
    
    MyLogger logger = new MyLogger(ServletRequest.class);
    private String uri;
    private InputStream in;
    
    public Request(InputStream in){
        this.in = in;
    }
    
    public String parseUri(String request){
        int index1,index2;
        index1 = request.indexOf(" ");
        if (index1 != -1){
            index2 = request.indexOf(" ", index1+ 1);
            if (index1 < index2)
                return request.substring(index1 + 1, index2);
        }
        return null;
    }
    
    public void Parse(){
        StringBuffer request = new StringBuffer(2048);
        byte[] bs = new byte[2048];
        int i;
        try {
            i = in.read(bs);
        } catch (IOException e) {
            e.printStackTrace();
            i = -1;
        }
        
        for(int j=0; j<i; j++){
            request.append((char)bs[j]);
        }
        
        logger.log(request.toString());
        uri = parseUri(request.toString());
        if(uri != null)
        logger.log("uri is " + uri);
    }
    
    public String getUri() {
        return uri;
    }
}

(三）Response 

public class Response implements ServletResponse{
    
    MyLogger logger = new MyLogger(Response.class);
    private static final int BUFFER_SIZE = 1024;
    private Request request;
    private OutputStream out;
    private PrintWriter writer;
    
    public  Response(OutputStream out) {
        this.out = out;
    }
    
    public  void setRequest(Request request) {
        this.request = request;
    }
    //假设请求的是图片资源
    public void sendStaticResource() throws IOException{
        byte[] buffer = new byte[BUFFER_SIZE];
        FileInputStream fis = null;
        File file = new File(Constant.WEB_ROOT, request.getUri());
        try {
            logger.log("Begin read file + " + file.toString());
            fis = new FileInputStream(file);
            String headerMsg = "HTTP/1.1 200 OK
" + 
                    "Content-Type: image/jpg
" + 
                    "Content-Length: " + file.length() + "
" +
                    "
" ;
            logger.log("headerMsg->
" + headerMsg);
            out.write(headerMsg.getBytes());
            int ch = fis.read(buffer, 0, BUFFER_SIZE);
            while (ch != -1){
                out.write(buffer, 0, BUFFER_SIZE);
                ch = fis.read(buffer, 0, BUFFER_SIZE);
            }
        } catch (FileNotFoundException e) {
            String html = "<h1>file not found</h1>";
            logger.log("FileNotFoundException");
            String errorMsg = "HTTP/1.1 404 file not found
" + 
                    "Content-Type: text/html
" + 
                    "Content-Length: " + html.getBytes().length + "
" +
                    "
" +
                    html;
            out.write(errorMsg.getBytes());
            logger.log("errorMsg->" + errorMsg);
        }
        finally {
            if(fis != null){
                fis.close();
            }
        }
    }
}

(四）StaticResourceProcessor 

public class StaticResourceProcessor {
    public void process(Request request,Response response) {
        try {
            response.sendStaticResource();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

(五）ServletProcessor 

public class ServletProcessor {
    public void process(Request request,Response response){
        String uri = request.getUri();
        String servletName = uri.substring(uri.lastIndexOf("/") + 1);
        URLClassLoader loader = null;
        
        URL[] urls = new URL[1];
        URLStreamHandler urlStreamHandler = null;
        File classPath = new File(Constant.WEB_ROOT);
        try {
            String repository = (new URL("file",null,classPath.getCanonicalPath() + 
                    File.separator)).toString();
            urls[0] = new URL(null,repository,urlStreamHandler);
            loader = new URLClassLoader(urls);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Class myClass = null;
        try {
            myClass = loader.loadClass(servletName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
        Servlet servlet = null;
        try {
            servlet = (Servlet) myClass.newInstance();
            servlet.service((ServletRequest)request, (ServletResponse) response);
        
        } catch (InstantiationException | IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ServletException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

(六）MyLogger 

public  class MyLogger<T> {
    private String classStr = "";
    
    public  void log(T msg){
        System.out.println(classStr + "(" + 
                (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).format(new Date()) + ")" + ": " + msg);
    }
    public MyLogger(Class classz){
        classStr = classz.getName();
    }
}

(七）PrimitiveServlet 

public class PrimitiveServlet implements Servlet{
    MyLogger Logger = new MyLogger<>(PrimitiveServlet.class);
    @Override
    public void destroy() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public ServletConfig getServletConfig() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public String getServletInfo() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void init(ServletConfig arg0) throws ServletException {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
        Logger.log("service execute.....");
        PrintWriter writer = response.getWriter();
        writer.println("Hey,welcome on board!");
        writer.println("lets rock!");
    }

}

(八）Constant 

public class Constant {
    public static final String WEB_ROOT = 
            System.getProperty("user.dir") + File.separator + "bin";
}