初探Tomcat的架构设计

// 保存服务的服务集privateService services[] = newService[0];
finalPropertyChangeSupport support = newPropertyChangeSupport(this);
@Overridepublicvoid addService(Service service) {// 相互关联    service.setServer(this);
// 利用同步锁，防止并发访问   来源：https://ytao.topsynchronized(servicesLock) {Service results[] = newService[services.length + 1];// copy 旧的服务到新的数组中System.arraycopy(services, 0, results, 0, services.length);// 添加新的 service        results[services.length] = service;        services = results;
// 如果当前 server 已经启动，那么当前添加的 service 就开始启动if(getState().isAvailable()) {try{                service.start();} catch(LifecycleException e) {// Ignore}}
// 使用观察者模式，当被监听对象属性值发生变化时通知监听器，remove 是也会调用。        support.firePropertyChange("service", null, service);}
}

privateEngine engine = null;
protectedfinalMapperListener mapperListener = newMapperListener(this);
@Overridepublicvoid setContainer(Engine engine) {Engine oldEngine = this.engine;// 判断当前 Service 是否有关联 Engineif(oldEngine != null) {// 如果当前 Service 有关联 Engine，就去掉当前关联的 Engine        oldEngine.setService(null);}// 如果当前新的 Engine 不为空，那么 Engine 关联当前 Service，这里是个双向关联this.engine = engine;if(this.engine != null) {this.engine.setService(this);}// 如果当前 Service 启动了，那么就开始启动当前新的 Engineif(getState().isAvailable()) {if(this.engine != null) {try{this.engine.start();} catch(LifecycleException e) {                log.error(sm.getString("standardService.engine.startFailed"), e);}}// 重启 MapperListener ，获取一个新的 Engine ，一定是当前入参的 Enginetry{            mapperListener.stop();} catch(LifecycleException e) {            log.error(sm.getString("standardService.mapperListener.stopFailed"), e);}try{            mapperListener.start();} catch(LifecycleException e) {            log.error(sm.getString("standardService.mapperListener.startFailed"), e);}
// 如果当前 Service 之前有 Engine 关联，那么停止之前的 Engineif(oldEngine != null) {try{                oldEngine.stop();} catch(LifecycleException e) {                log.error(sm.getString("standardService.engine.stopFailed"), e);}}}
// Report this property change to interested listeners    support.firePropertyChange("container", oldEngine, this.engine);}
/*** 实现方式和 StandardServer#addService 类似，不在细述* 注意，Connector 这里没有像 Engine 一样与 Service 实现双向关联*/@Overridepublicvoid addConnector(Connector connector) {
synchronized(connectorsLock) {        connector.setService(this);Connector results[] = newConnector[connectors.length + 1];System.arraycopy(connectors, 0, results, 0, connectors.length);        results[connectors.length] = connector;        connectors = results;
if(getState().isAvailable()) {try{                connector.start();} catch(LifecycleException e) {                log.error(sm.getString("standardService.connector.startFailed",                        connector), e);}}
// Report this property change to interested listeners        support.firePropertyChange("connector", null, connector);}
}

<Connectorport="8080"protocol="HTTP/1.1"connectionTimeout="20000"redirectPort="8443"/>

publicConnector() {// 无参构造，下面 setProtocol 中默认使用HTTP/1.1this(null);}
publicConnector(String protocol) {// 设置当前连接器协议处理类型    setProtocol(protocol);// 实例化协议处理器，并保存到当前 Connector 中ProtocolHandler p = null;try{Class<?> clazz = Class.forName(protocolHandlerClassName);        p = (ProtocolHandler) clazz.getConstructor().newInstance();} catch(Exception e) {        log.error(sm.getString("coyoteConnector.protocolHandlerInstantiationFailed"), e);} finally{this.protocolHandler = p;}
if(Globals.STRICT_SERVLET_COMPLIANCE) {        uriCharset = StandardCharsets.ISO_8859_1;} else{        uriCharset = StandardCharsets.UTF_8;}}
/*** 这个设置再 tomcat9 中被移除，改为必配项*/publicvoid setProtocol(String protocol) {
boolean aprConnector = AprLifecycleListener.isAprAvailable() &&AprLifecycleListener.getUseAprConnector();
// 这里指定了默认协议和 HTTP/1.1 一样if("HTTP/1.1".equals(protocol) || protocol == null) {if(aprConnector) {            setProtocolHandlerClassName("org.apache.coyote.http11.Http11AprProtocol");} else{            setProtocolHandlerClassName("org.apache.coyote.http11.Http11NioProtocol");}} elseif("AJP/1.3".equals(protocol)) {if(aprConnector) {            setProtocolHandlerClassName("org.apache.coyote.ajp.AjpAprProtocol");} else{            setProtocolHandlerClassName("org.apache.coyote.ajp.AjpNioProtocol");}} else{// 最后如果不是通过指定 HTTP/1.1，AJP/1.3 类型的协议，就通过类名实例化一个协议处理器        setProtocolHandlerClassName(protocol);}}

@Overridepublicvoid addChild(Container child) {// 添加的子容器必须是 Hostif(!(child instanceofHost))thrownewIllegalArgumentException(sm.getString("standardEngine.notHost"));super.addChild(child);}
@Overridepublicvoid setParent(Container container) {
thrownewIllegalArgumentException(sm.getString("standardEngine.notParent"));
}

<!-- 配置默认Host，及jvmRoute --><Enginename="Catalina"defaultHost="localhost"jvmRoute="jvm1">

<!-- name 设置的时虚拟主机域名 --><Hostname="localhost"appBase="webapps"unpackWARs="true"autoDeploy="true">

@Overridepublicvoid addChild(Container child) {
// Global JspServletWrapper oldJspServlet = null;
// 这里添加的子容器只能时 Wrapperif(!(child instanceofWrapper)) {thrownewIllegalArgumentException(sm.getString("standardContext.notWrapper"));}
// 判断子容器 Wrapper 是否为 JspServletboolean isJspServlet = "jsp".equals(child.getName());
// Allow webapp to override JspServlet inherited from global web.xml.if(isJspServlet) {        oldJspServlet = (Wrapper) findChild("jsp");if(oldJspServlet != null) {            removeChild(oldJspServlet);}}
super.addChild(child);
// 将servlet映射添加到Context组件if(isJspServlet && oldJspServlet != null) {/*         * The webapp-specific JspServlet inherits all the mappings         * specified in the global web.xml, and may add additional ones.         */String[] jspMappings = oldJspServlet.findMappings();for(int i=0; jspMappings!=null&& i<jspMappings.length; i++) {            addServletMappingDecoded(jspMappings[i], child.getName());}}}

publicsynchronizedServlet loadServlet() throwsServletException{
// 如果已经实例化或者用实例化池，就直接返回if(!singleThreadModel && (instance != null))return instance;
PrintStream out = System.out;if(swallowOutput) {SystemLogHandler.startCapture();}
Servlet servlet;try{long t1=System.currentTimeMillis();// 如果 servlet 类名为空，直接抛出 Servlet 异常if(servletClass == null) {            unavailable(null);thrownewServletException(sm.getString("standardWrapper.notClass", getName()));}
// 从 Context 中获取 ServletInstanceManager instanceManager = ((StandardContext)getParent()).getInstanceManager();try{            servlet = (Servlet) instanceManager.newInstance(servletClass);} catch(ClassCastException e) {            unavailable(null);// Restore the context ClassLoaderthrownewServletException(sm.getString("standardWrapper.notServlet", servletClass), e);} catch(Throwable e) {            e = ExceptionUtils.unwrapInvocationTargetException(e);ExceptionUtils.handleThrowable(e);            unavailable(null);
// Added extra log statement for Bugzilla 36630:// https://bz.apache.org/bugzilla/show_bug.cgi?id=36630if(log.isDebugEnabled()) {                log.debug(sm.getString("standardWrapper.instantiate", servletClass), e);}
// Restore the context ClassLoaderthrownewServletException(sm.getString("standardWrapper.instantiate", servletClass), e);}
// 加载声明了 MultipartConfig 注解的信息if(multipartConfigElement == null) {MultipartConfig annotation =                    servlet.getClass().getAnnotation(MultipartConfig.class);if(annotation != null) {                multipartConfigElement =newMultipartConfigElement(annotation);}}
// 对 servlet 类型进行检查if(servlet instanceofContainerServlet) {((ContainerServlet) servlet).setWrapper(this);}
        classLoadTime=(int) (System.currentTimeMillis() -t1);
if(servlet instanceofSingleThreadModel) {if(instancePool == null) {                instancePool = newStack<>();}            singleThreadModel = true;}
// 初始化 servlet        initServlet(servlet);
        fireContainerEvent("load", this);
        loadTime=System.currentTimeMillis() -t1;} finally{if(swallowOutput) {String log = SystemLogHandler.stopCapture();if(log != null&& log.length() > 0) {if(getServletContext() != null) {                    getServletContext().log(log);} else{                    out.println(log);}}}}return servlet;
}