简单的tomcat实现

做了长时间web开发，一直都是用spring，导致自己成了操作工，按照既定的模子，重复的劳动，没有丝毫的进步，所以想深入的了解一番干了这么长时间的web的整个运行流程，绝大多数web开发学习应该都是servlet开始的吧，所以又重拾了servelt狠狠的研究了一番，最后发现servlet其实就是些标准，那啥为标准，说白了，就是定了些接口，导致看源码的过程很不过瘾，感觉没啥提升，就决定了解下更底层的工作原理，也就是tomcat。 开始我并不知道tomcat是java写的，对tomcat那是神秘，惧怕，感觉太过高大上，自己做的那点web开发和tomcat这种红遍全球的软件相比简直小巫见大巫，技术含量压根儿就不是一个层次。不过我还是想一窥究竟，偶然的机会，看到了《深入剖析Tomcat》，作者对tomcat源码讲解的很是详细，通过循序渐进的例子，非常认真的讲出了tomcat的精髓，我是受益匪浅。现在我想自己也写一个，来作为这阶段学习的一个交代，就叫tiny-tomcat吧，同样通过循序渐进，慢慢完善，源码在github上：https://github.com/esiyuan/tiny-tomcat.git

简单的web服务器

git checkout step-001：主要功能如下

接受http请求 private void handlerRequest() throws IOException { while(true) { Socket socket = serverSocket.accept(); logger.info("获取连接[ address: " + socket.getInetAddress() + ", port: " + socket.getPort() + " ]"); Request request = new Request(socket.getInputStream()); request.parse(); Response response = new Response(request.getUri(), socket.getOutputStream()); response.sendStaticResource(); socket.close(); } }

通过ServerSocket监听本地端口，serverSocket.accept()等待请求。

解析请求uri public void parse() throws IOException { BufferedReader reader = IOUtil.getBufferedReader(inputStream); String requestString = reader.readLine(); this.uri = parseUri(requestString); }

为了分开请求和响应，贴合servlet风格，我们通过Request对象，解析请求字符串，request对象构造的时候，传入socket的输入流，由于我们只对第一行感兴趣，所以在只读取了第一行进行解析，解析出uri作为属性保存。

根据uri定位html文件，并返回响应

最后通过 Response对象进行html响应，而response在构造的时候，传入socket的输出流。

/** * 输出响应 * <p>文件找到uri对应的文件，则进行输出，否则输出404 * @throws IOException */ public void sendStaticResource() throws IOException { File file = new File(Constants.WEB_ROOT, uri); if (file.exists()) { sendFile(file); } else { sendDefault(); } }

简单的servlet容器

git checkout step-002 主要在前一节代码上进行了部分改造，增加了响应servlet的功能，并分出了简单的servlet处理器，因为HttpServletRequest和HttpServletResponse是接口，为了达到演示的效果，避免request和response类过于复杂，使用了门面RequestFacade和ResponseFacade。

public class ServletProcessor { private ConcurrentHashMap<String, Servlet> cache = new ConcurrentHashMap<String, Servlet>(); /** * servlet没有加载，则加载并初始化 * <p>如有加载直接取缓存 * @param request * @param response */ public void process(Request request, Response response){ Servlet servlet = cache.get(request.getServerName()); if(servlet != null) { try { servlet.service(request, response); } catch (ServletException | IOException e) { e.printStackTrace(); } return; } try(URLClassLoader classLoader = new URLClassLoader(new URL[]{new URL("file://" + Constants.TOMCAT_CLASSLOADER_REPOSITORY)});) { Class<?> clazz = classLoader.loadClass("web_root." + request.getServerName()); servlet = (Servlet)clazz.newInstance(); servlet.init(null); servlet.service(request, response); cache.putIfAbsent(request.getServerName(), servlet); } catch (Exception e) { e.printStackTrace(); System.out.println("服务异常！"); } } }

为了体现servlet的生命周期，增加了init()方法，并且通过ConcurrentHashMap缓存了sevlet实例，为什么用ConcurrentHashMap，主要是考虑线程安全，其分段锁的设计，能够拥有较高的并发写的能力，同时并不会妨碍并发读取，由于读没有进行加锁，不需要等待写完成，所有必然的会造成数据的弱一致性，不过大多数时候都会有取出非空判断逻辑，也造不成什么问题。 servlet代码如下：

public class HelloServlet extends HttpServlet { private static final long serialVersionUID = -2585140950753353037L; private static final Logger logger = Logger.getLogger(HelloServlet.class); public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException { PrintWriter out = response.getWriter(); out.println("hello servlet..."); } @Override public void init() throws ServletException { System.out.println("HelloServlet..初始化开始.."); } }

运行结果：

非阻塞的servlet容器

git checkout step-003 前面的实现，都是非常简单的单线程，万一线程阻塞，那岂不是不能提供服务了，实际的产品肯定不能是这样的。tomcat连接器监听端口，获取创建socket，这个应该是单点，而容易阻塞的地方，应该是具体业务逻辑处理的代码了，为了保证服务的可用，提高系统的吞吐率，可以使用多线程提供多个处理器，让每个请求有单独的线程进行处理，这样性能会大幅度提高，不会以为单个连接出现问题而造成服务不可用。下面我们分析具体的代码。 Bootstrap应用启动，主要功能，初始化连接器：

public final class Bootstrap { public static void main(String[] args) { HttpConnector connector = new HttpConnector("localhost", 8080); try { connector.initialize(); connector.start(); System.in.read(); //连接器线程，让主线程挂起，保证其他后台线程运行 } catch (UnknownHostException e) { e.printStackTrace(); } catch (TomcatException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } }

连接器进行本地端口的监听，实例化并运行处理器：

/** * 初始化连接处理器和处理器 * @throws TomcatException * @throws UnknownHostException * @throws IOException */ public void initialize() throws TomcatException, UnknownHostException, IOException { createServer(); while (curProcessors < minProcessors) { if (curProcessors >= maxProcessors) break; HttpProcessor processor = newProcessor(); recycle(processor); } }

处理器进入wait状态（HttpProcessor中方法），等待被唤醒。

@Override public void run() { try { while(!Thread.interrupted()) { Socket socket = waitingToNewSocket(); process(socket); } } catch (InterruptedException | IOException | ServletException e) { System.out.println("处理器异常。。。"); } } private synchronized Socket waitingToNewSocket() throws InterruptedException { while (!newSocketCome) { wait(); } Socket socket = this.socket; newSocketCome = false; return (socket); }

当有请求到来时，唤醒挂起的处理器，处理 完成，处理器重新入栈，等待下次被使用。

public synchronized void assign(Socket socket) { this.socket = socket; newSocketCome = true; notifyAll(); }

模块化的web容器

git checkout step-004 tomcat作为一个大型的产品，为了开发维护的方便，必然的会把大任务进行分解，进行分层分模块，这也是如今软件设计的思路，模块清晰，层次明了，对于后期的维护，更新都会有极大的便利。 tomcat进行功能的拆分，模拟管道与阀的思想，对于容器的处理组件，都放在阀中，请求会像流水一样流过每个阀，最后得到最终的处理。

而tomcat通过接口来定下标准，Pipeline接口表示管道，Valve表示阀，具体可以看代码。

生命周期监听

git checkout step-005 本节主要增加了生命周期控制组件，接口Lifecycle，定义组件的生命周期，主要增加了事件监听模块，监听tomcat启动状态改变，并作出反应，下图监听的逻辑。 每个实现生命周期接口的组件都能进行监听器的绑定，统一的实现监听器的控制逻辑，使用了LifecycleSupport来代理，实现监听器绑定，解绑，通知。