一、动态资源的获取

因为TimeServlet无法直接调用，所以获得相应的路径。

  1. package processor;
  3. import connector.ConnectorUtils;
  4. import connector.Request;
  5. import connector.Response;
  7. import javax.servlet.Servlet;
  8. import javax.servlet.ServletException;
  9. import java.io.File;
  10. import java.io.IOException;
  11. import java.lang.reflect.InvocationTargetException;
  12. import java.net.MalformedURLException;
  13. import java.net.URL;
  14. import java.net.URLClassLoader;
  16. public class ServletProcessor {
  18.     //准备好URLClassLoader
  20.     URLClassLoader getServletLoader() throws MalformedURLException {
  21.         File webRoot = new File(ConnectorUtils.WEB_ROOT);
  22.         URL webRootUrl = webRoot.toURI().toURL();
  23.         return new URLClassLoader(new URL[]{webRootUrl});
  24.     }
  26.     Servlet getServlet(URLClassLoader loader, Request request) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
  27.         /*
  28.          /servlet/TimeServlet
  29.          */
  30.         String uri = request.getRequestUri();
  31.         String servletName = uri.substring(uri.lastIndexOf("/") + 1);
  33.         Class servletClass = loader.loadClass(servletName);
  34.         Servlet servlet = (Servlet) servletClass.getDeclaredConstructor().newInstance();
  35.         return servlet;
  36.     }
  38.     public void process(Request request, Response response) throws IOException {
  39.         try {
  40.             URLClassLoader loader = getServletLoader();
  41.             Servlet servlet = getServlet(loader, request);
  42.             servlet.service(request, response);
  43.         } catch (MalformedURLException e) {
  44.             e.printStackTrace();
  45.         } catch (InstantiationException e) {
  46.             e.printStackTrace();
  47.         } catch (InvocationTargetException e) {
  48.             e.printStackTrace();
  49.         } catch (NoSuchMethodException e) {
  50.             e.printStackTrace();
  51.         } catch (IllegalAccessException e) {
  52.             e.printStackTrace();
  53.         } catch (ClassNotFoundException e) {
  54.             e.printStackTrace();
  55.         } catch (ServletException e) {
  56.             e.printStackTrace();
  57.         }
  58.     }
  59. }

二、测试ServletProcessor

  1. package processor;
  3. import connector.Request;
  4. import org.junit.jupiter.api.Assertions;
  5. import org.junit.jupiter.api.Test;
  6. import test.util.TestUtils;
  8. import javax.servlet.Servlet;
  9. import java.lang.reflect.InvocationTargetException;
  10. import java.net.MalformedURLException;
  11. import java.net.URLClassLoader;
  13. /**
  14.  * @ClassName:
  15.  * @Description:
  16.  * @author: hszjj
  17.  * @date: 2019/11/26 15:32
  18.  */
  19. public class ServletProcessorTest {
  20.     private static final String SERVLET_REQUEST="GET /servlet/TimeServlet HTTP/1.1";
  21.     @Test
  22.     public void givenServletRequest_thenLoadServlet() throws MalformedURLException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
  23.         Request request= TestUtils.createRequest(SERVLET_REQUEST);
  24.         ServletProcessor processor=new ServletProcessor();
  25.         URLClassLoader loader=processor.getServletLoader();
  26.         Servlet servlet=processor.getServlet(loader,request);
  28.         Assertions.assertEquals("webroot.TimeServlet",servlet.getClass().getName());
  29.     }
  30. }

三、使用facade模式

示例中这个代码明显出现问题，既涉及到服务器的开发也涉及到Servlet的开发，现实中这两个开发应属于不同群体。所以我们要保证服务器的开发不会被Servlet的人员过分利用，例如如下情况：
image.png
这种情况很危险，Servlet的人员可以肆意调用函数。
为了防止这种问题发生，我们需要应用Facade模式。
首先需要写如下两个函数

ResponseFacade

把ServletResponse放置在ResponseFacade中就可以有效防止这种非法转型。

  1. package connector;
  3. import javax.servlet.ServletOutputStream;
  4. import javax.servlet.ServletResponse;
  5. import java.io.IOException;
  6. import java.io.PrintWriter;
  7. import java.util.Locale;
  9. public class ResponseFacade implements ServletResponse {
  11.     private ServletResponse response = null;
  13.     public ResponseFacade(Response response) {
  14.         this.response = response;
  15.     }
  17.     @Override
  18.     public String getCharacterEncoding() {
  19.         return response.getCharacterEncoding();
  20.     }
  22.     @Override
  23.     public String getContentType() {
  24.         return response.getContentType();
  25.     }
  27.     @Override
  28.     public ServletOutputStream getOutputStream() throws IOException {
  29.         return response.getOutputStream();
  30.     }
  32.     @Override
  33.     public PrintWriter getWriter() throws IOException {
  34.         return response.getWriter();
  35.     }
  37.     @Override
  38.     public void setCharacterEncoding(String s) {
  39.         response.setCharacterEncoding(s);
  40.     }
  42.     @Override
  43.     public void setContentLength(int i) {
  44.         response.setContentLength(i);
  45.     }
  47.     @Override
  48.     public void setContentLengthLong(long l) {
  49.         response.setContentLengthLong(l);
  50.     }
  52.     @Override
  53.     public void setContentType(String s) {
  54.         response.setContentType(s);
  55.     }
  57.     @Override
  58.     public void setBufferSize(int i) {
  59.         response.setBufferSize(i);
  60.     }
  62.     @Override
  63.     public int getBufferSize() {
  64.         return response.getBufferSize();
  65.     }
  67.     @Override
  68.     public void flushBuffer() throws IOException {
  69.         response.flushBuffer();
  70.     }
  72.     @Override
  73.     public void resetBuffer() {
  74.         response.resetBuffer();
  75.     }
  77.     @Override
  78.     public boolean isCommitted() {
  79.         return response.isCommitted();
  80.     }
  82.     @Override
  83.     public void reset() {
  84.         response.reset();
  85.     }
  87.     @Override
  88.     public void setLocale(Locale locale) {
  89.         response.setLocale(locale);
  90.     }
  92.     @Override
  93.     public Locale getLocale() {
  94.         return response.getLocale();
  95.     }
  96. }

RequestFacade

同理

  1. package connector;
  3. import javax.servlet.*;
  4. import java.io.BufferedReader;
  5. import java.io.IOException;
  6. import java.io.UnsupportedEncodingException;
  7. import java.util.Enumeration;
  8. import java.util.Locale;
  9. import java.util.Map;
  11. public class RequestFacade implements ServletRequest {
  12.     private ServletRequest request = null;
  14.     public RequestFacade(Request request) {
  15.         this.request = request;
  16.     }
  19.     @Override
  20.     public Object getAttribute(String s) {
  21.         return request.getAttribute(s);
  22.     }
  24.     @Override
  25.     public Enumeration<String> getAttributeNames() {
  26.         return request.getAttributeNames();
  27.     }
  29.     @Override
  30.     public String getCharacterEncoding() {
  31.         return request.getCharacterEncoding();
  32.     }
  34.     @Override
  35.     public void setCharacterEncoding(String s) throws UnsupportedEncodingException {
  36.         request.setCharacterEncoding(s);
  37.     }
  39.     @Override
  40.     public int getContentLength() {
  41.         return request.getContentLength();
  42.     }
  44.     @Override
  45.     public long getContentLengthLong() {
  46.         return request.getContentLengthLong();
  47.     }
  49.     @Override
  50.     public String getContentType() {
  51.         return request.getContentType();
  52.     }
  54.     @Override
  55.     public ServletInputStream getInputStream() throws IOException {
  56.         return request.getInputStream();
  57.     }
  59.     @Override
  60.     public String getParameter(String s) {
  61.         return request.getParameter(s);
  62.     }
  64.     @Override
  65.     public Enumeration<String> getParameterNames() {
  66.         return request.getParameterNames();
  67.     }
  69.     @Override
  70.     public String[] getParameterValues(String s) {
  71.         return request.getParameterValues(s);
  72.     }
  74.     @Override
  75.     public Map<String, String[]> getParameterMap() {
  76.         return request.getParameterMap();
  77.     }
  79.     @Override
  80.     public String getProtocol() {
  81.         return request.getProtocol();
  82.     }
  84.     @Override
  85.     public String getScheme() {
  86.         return request.getScheme();
  87.     }
  89.     @Override
  90.     public String getServerName() {
  91.         return request.getServerName();
  92.     }
  94.     @Override
  95.     public int getServerPort() {
  96.         return request.getServerPort();
  97.     }
  99.     @Override
  100.     public BufferedReader getReader() throws IOException {
  101.         return request.getReader();
  102.     }
  104.     @Override
  105.     public String getRemoteAddr() {
  106.         return request.getRemoteAddr();
  107.     }
  109.     @Override
  110.     public String getRemoteHost() {
  111.         return request.getRemoteHost();
  112.     }
  114.     @Override
  115.     public void setAttribute(String s, Object o) {
  116.         request.setAttribute(s,o);
  117.     }
  119.     @Override
  120.     public void removeAttribute(String s) {
  121.         request.removeAttribute(s);
  122.     }
  124.     @Override
  125.     public Locale getLocale() {
  126.         return request.getLocale();
  127.     }
  129.     @Override
  130.     public Enumeration<Locale> getLocales() {
  131.         return request.getLocales();
  132.     }
  134.     @Override
  135.     public boolean isSecure() {
  136.         return request.isSecure();
  137.     }
  139.     @Override
  140.     public RequestDispatcher getRequestDispatcher(String s) {
  141.         return request.getRequestDispatcher(s);
  142.     }
  144.     @Override
  145.     public String getRealPath(String s) {
  146.         return request.getRealPath(s);
  147.     }
  149.     @Override
  150.     public int getRemotePort() {
  151.         return request.getRemotePort();
  152.     }
  154.     @Override
  155.     public String getLocalName() {
  156.         return request.getLocalName();
  157.     }
  159.     @Override
  160.     public String getLocalAddr() {
  161.         return request.getLocalAddr();
  162.     }
  164.     @Override
  165.     public int getLocalPort() {
  166.         return request.getLocalPort();
  167.     }
  169.     @Override
  170.     public ServletContext getServletContext() {
  171.         return request.getServletContext();
  172.     }
  174.     @Override
  175.     public AsyncContext startAsync() throws IllegalStateException {
  176.         return request.startAsync();
  177.     }
  179.     @Override
  180.     public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException {
  181.         return request.startAsync();
  182.     }
  184.     @Override
  185.     public boolean isAsyncStarted() {
  186.         return request.isAsyncStarted();
  187.     }
  189.     @Override
  190.     public boolean isAsyncSupported() {
  191.         return request.isAsyncSupported();
  192.     }
  194.     @Override
  195.     public AsyncContext getAsyncContext() {
  196.         return request.getAsyncContext();
  197.     }
  199.     @Override
  200.     public DispatcherType getDispatcherType() {
  201.         return request.getDispatcherType();
  202.     }
  203. }

应用

修改Processor代码

  1. public void process(Request request, Response response) throws IOException {
  2.         URLClassLoader loader = getServletLoader();
  3.         try {
  4.             Servlet servlet = getServlet(loader, request);
  5.             RequestFacade requestFacade=new RequestFacade(request);
  6.             ResponseFacade responseFacade=new ResponseFacade(response);
  7.             servlet.service(requestFacade, responseFacade);
  8.         } catch (MalformedURLException e) {
  9.             e.printStackTrace();
  10.         } catch (InstantiationException e) {
  11.             e.printStackTrace();
  12.         } catch (InvocationTargetException e) {
  13.             e.printStackTrace();
  14.         } catch (NoSuchMethodException e) {
  15.             e.printStackTrace();
  16.         } catch (IllegalAccessException e) {
  17.             e.printStackTrace();
  18.         } catch (ClassNotFoundException e) {
  19.             e.printStackTrace();
  20.         } catch (ServletException e) {
  21.             e.printStackTrace();
  22.         }
  23.     }

四、动态资源支持的实现

首先修改Connector的代码：

  1. public void run() {
  2.         try {
  3.             server=new ServerSocket(port);
  4.             System.out.println("服务器已启动，监听端口【"+port+"】");
  5.             while (true){
  6.                 Socket socket=server.accept();
  7.                 InputStream input=socket.getInputStream();
  8.                 OutputStream output=socket.getOutputStream();
  10.                 Request request=new Request(input);
  11.                 request.parse();
  12.                 Response response=new Response(output);
  13.                 response.setRequest(request);
  15.                 if (request.getRequestUri().startsWith("/servlet/")){
  16.                     ServletProcessor processor=new ServletProcessor();
  17.                     processor.process(request,response);
  18.                 }else {
  19.                     StaticProcessor processor = new StaticProcessor();
  20.                     processor.process(request, response);
  21.                 }
  23.                 shutDown(socket);
  24.             }
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         }
  28.     }

更改TestClient类

  1. import java.io.IOException;
  2. import java.io.InputStream;
  3. import java.io.OutputStream;
  4. import java.net.Socket;
  5. /**
  6.  * @ClassName:
  7.  * @Description:
  8.  * @author: hszjj
  9.  * @date: 2019/11/26 14:33
  10.  */
  11. public class TestClient {
  12.     public static void main(String[] args) {
  13.         try {
  14.             Socket socket=new Socket("localhost",9999);
  15.             OutputStream outputStream=socket.getOutputStream();
  16.             outputStream.write("GET /servlet/TimeServlet HTTP/1.1".getBytes());
  17.             socket.shutdownOutput();
  19.             InputStream inputStream=socket.getInputStream();
  20.             byte[] buffer=new byte[2048];
  21.             int length=inputStream.read(buffer);
  22.             StringBuilder response=new StringBuilder();
  23.             for (int j=0;j<length;j++){
  24.                 char a=(char)buffer[j];
  25.                 response.append(a);
  26.             }
  27.             System.out.println(response.toString());
  28.             socket.shutdownInput();
  30.             socket.close();
  31.         } catch (IOException i) {
  32.             i.printStackTrace();
  33.         }
  34.     }
  35. }

结果显示如下：

image.png

五、使用NIO模型重写

  1. package connector;
  3. import processor.ServletProcessor;
  4. import processor.StaticProcessor;
  6. import java.io.Closeable;
  7. import java.io.IOException;
  8. import java.io.InputStream;
  9. import java.io.OutputStream;
  10. import java.net.InetSocketAddress;
  11. import java.net.ServerSocket;
  12. import java.net.Socket;
  13. import java.nio.channels.SelectionKey;
  14. import java.nio.channels.Selector;
  15. import java.nio.channels.ServerSocketChannel;
  16. import java.nio.channels.SocketChannel;
  17. import java.util.Set;
  19. public class NioConnector implements Runnable {
  20.     private static final int DEFAULT_PORT = 9999;
  22.     private ServerSocketChannel server;
  23.     private Selector selector;
  24.     private int port;
  26.     private void shutDown(Closeable... closeables) {
  27.         try {
  28.             for (Closeable shut : closeables) {
  29.                 if (shut != null) {
  30.                     shut.close();
  31.                 }
  32.             }
  33.         } catch (IOException e) {
  34.             e.printStackTrace();
  35.         }
  36.     }
  38.     public NioConnector(int port) {
  39.         this.port = port;
  40.     }
  42.     public NioConnector() {
  43.         this(DEFAULT_PORT);
  44.     }
  46.     public void start() {
  47.         try {
  48.             server = ServerSocketChannel.open();
  49.             server.configureBlocking(false);
  50.             server.socket().bind(new InetSocketAddress(port));
  52.             selector=Selector.open();
  53.             server.register(selector, SelectionKey.OP_ACCEPT);
  54.             System.out.println("启动服务器，监听端口["+port+"]");
  56.             while (true){
  57.                 selector.select();
  58.                 Set<SelectionKey> selectionKeys=selector.selectedKeys();
  59.                 for (SelectionKey key:selectionKeys){
  60.                     handles(key);
  61.                 }
  62.                 selectionKeys.clear();
  63.             }
  64.         } catch (IOException e) {
  65.             e.printStackTrace();
  66.         }finally {
  67.             shutDown(selector,server);
  68.         }
  69.     }
  71.     private void handles(SelectionKey key) throws IOException {
  72.         //ACCEPT
  73.         if (key.isAcceptable()) {
  74.             ServerSocketChannel server = (ServerSocketChannel) key.channel();
  75.             SocketChannel client = server.accept();
  76.             client.configureBlocking(false);
  77.             client.register(selector, SelectionKey.OP_READ);
  78.         }else if (key.isReadable()){
  79.             SocketChannel client= (SocketChannel) key.channel();
  80.             key.cancel();
  81.             client.configureBlocking(true);
  82.             Socket clientSocket=client.socket();
  83.             InputStream inputStream=clientSocket.getInputStream();
  84.             OutputStream outputStream=clientSocket.getOutputStream();
  86.             Request request=new Request(inputStream);
  87.             request.parse();
  89.             Response response=new Response(outputStream);
  90.             response.setRequest(request);
  92.             if (request.getRequestUri().startsWith("/servlet/")){
  93.                 ServletProcessor processor=new ServletProcessor();
  94.                 processor.process(request,response);
  95.             }else {
  96.                 StaticProcessor processor=new StaticProcessor();
  97.                 processor.process(request,response);
  98.             }
  99.         }
  100.     }
  102.     @Override
  103.     public void run() {
  104.         new Thread(this).start();
  105.     }
  106. }

六、测试重写

image.png