¿El núcleo de Tomcat?
Connector和Container：
1、Connector用于处理连接相关的事情，底层是socket通信，将http请求和服务端的响应封装成request和respones;
2、Container用于封装和管理Servlet，以及具体处理Request请求；
一个Tomcat中只有一个Server，一个Server可以包含多个Service，一个Service只有一个Container，但是可以有多个Connector，这是因为一个服务可以有多个连接，如同时提供Http和Https连接，也可以提供向相同协议不同端口的连接。
一个请求发送到Tomcat之后，首先经过Service然后会交给Connector，Connector用于接收请求并将接收的请求封装为Request和Response来具体处理，Request和Response封装完之后再交由Container进行处理，Container处理完请求之后再返回给Connector，最后在由Connector通过Socket将处理的结果返回给客户端，这样整个请求的就处理完了！
Connector最底层使用的是Socket来进行连接的，Request和Response是按照HTTP协议来封装的，所以Connector同时需要实现TCP/IP协议和HTTP协议！
Arquitectura de nivel superior de tomcat:
(1) Solo hay un servidor en Tomcat, un servidor puede tener varios servicios y un servicio puede tener varios conectores y un contenedor;
(2) el servidor está a cargo de la vida o muerte de todo el Tomcat;
(4) el servicio proporciona servicios al mundo exterior;
(5) El conector se usa para aceptar solicitudes y encapsular las solicitudes en Solicitud y Respuesta para un procesamiento específico;
(6) El contenedor se usa para encapsular y administrar Servlet, y específicamente procesar solicitudes de solicitud;
Conector？
Connector usa ProtocolHandler para procesar solicitudes. Diferentes ProtocolHandlers representan diferentes tipos de conexión. Por ejemplo, Http11Protocol usa Socket normal para conectarse y Http11NioProtocol usa NioSocket para conectarse.
ProtocolHandler consta de tres componentes: punto final, procesador y adaptador.
(1) El punto final se usa para procesar la conexión de red del socket subyacente, el procesador se usa para encapsular el socket recibido por el punto final en una solicitud y el adaptador se usa para entregar la solicitud al contenedor para un procesamiento específico.
(2) El punto final se usa para procesar la conexión de red de Socket subyacente, por lo que el punto final se usa para implementar protocolos TCP e IP, y el procesador se usa para implementar protocolos HTTP y el adaptador adapta la solicitud al contenedor de servlet para un procesamiento específico.
(3) La implementación abstracta de Endpoint implementa dos clases internas de Acceptor y AsyncTimeout definidas en AbstractEndpoint y una interfaz Handler. Acceptor se usa para monitorear solicitudes, AsyncTimeout se usa para verificar el tiempo de espera de solicitudes asincrónicas, Handler se usa para procesar el Socket recibido y el Procesador se llama internamente para su procesamiento.
¿Iniciar el proceso?
1，创建Bootstrap启动类实例，并做一些初始化工作，初始化类加载器和创建Catalina实例，然后再启动Catalina线程。Catalina实例执行start方法。load方法解析server.xml配置文件，并加载Server、Service、Connector、Container、Engine、Host、Context、Wrapper一系列的容器。加载完成后，调用getServer().start()来开启一个新的Server。首先利用Digester类解析server.xml文件，得到容器的配置，并创建相应的对象，并关联父子容器。依次创建的是StandardServer、StandardService、StandardEngine、StandardHost。
然后拿到StandardServer实例调用init()方法初始化Tomcat容器的一系列组件。一些容器初始化的的时候，都会调用其子容器的init()方法，初始化它的子容器。顺序是StandardServer、StandardService、StandardEngine、Connector。每个容器都在初始化自身相关设置的同时，将子容器初始化。
在初始化、开启一系列组件、容器的过程中，由tomcat管理的组件和容器，都有一个共同的特点，都实现了Lifecycle接口，由Tomcat管理其生命周期。Lifecycle提供一种统一的管理对象生命周期的接口。通过Lifecycle、LifecycleListener、LifecycleEvent，Catalina实现了对tomcat各种组件、容器统一的启动和停止的方式。
在Tomcat服务开启过程中启动的一些列组件、容器，都继承了LifecycleBase这个抽象类，其中的init()、start() 方法、stop() 方法，为其子类实现了统一的start和stop管理。方法中具体的方法由子类去实现，这里采用的是模板方法模式。
总结Tomcat启动的过程：
在Catalina的load方法里，就已经调用了StandardServer里的init方法，一层一层初始化了globalNamingResources，StandardService--》StandardEngine，executors，MapperListener，Connector--》CoyoteAdapter，protocolHandler。至此就将tomcat的catalina中的组件、容器初始化完成。 接下来就是调用start方法一层一层开启，StandardServer的startInternal方法，按层次start：globalNamingResources，StandardService--》StandardEngine，executors，MapperListener，Connector--》StandardHost，StandardContext，protocolHandler。顺序基本同init过程。StandardEngine在start时，会init子容器，并调用子容器的start方法。子容器依次这样init、start，就开启了StandardHost和StandardContext。
2，Bootstrap的初始化init方法：
1，先初始化类加载器（commonLoader，catalinaLoader，sharedLoader）。
2，给当前线程设置特定的类加载器catalinaLoader。
3，向SecurityClassLoad安全机制的类加载器中添加catalinaLoader类加载器。
4，初始化Catalina启动类，并根据构造函数startupClass.getConstructor().newInstance()创建Catalina启动类。
5，设置启动参数。
Bootstrap的初始化load方法（加载参数）。
3，Bootstrap的demon.start()方法就会调用Catalina的start方法。
¿El modelo de cadena de responsabilidad?
El modo de cadena de responsabilidad es que muchos objetos tienen la referencia de cada objeto y están conectados para formar una cadena, y la solicitud se pasa en esta cadena hasta que un objeto en la cadena procesa la solicitud, o cada objeto puede procesar la solicitud. Y páselo al siguiente hasta que se procesen todos los objetos de la cadena. De esta forma, cualquier nodo de procesamiento se puede agregar a la cadena sin afectar al cliente.
Este modo de diseño se usa casi por completo en tomcat. La configuración de contenedor de tomcat es el modo de cadena de responsabilidad. Desde el motor al host, al contexto y al contenedor, las solicitudes se pasan a través de una cadena.
¿Patrón de método de plantilla?
Tomcat tiene dos métodos principales init () y start () durante el proceso de inicio. Aquí tomamos start () como ejemplo. El método start () en la clase LifecycleBase llamará startInternal (). Este método es un método abstracto. La subclase lo implementa, por lo que la subclase necesita implementar este método de apertura específico. El método de inicio que finalmente se llama es consistente con otros pasos fijos, y también se ejecutará la apertura específica implementada por la subclase.
tomcat mal?
Cuando Tomcat se inicia de forma anormal, la situación general es ir al directorio de registros y comprobar la información de registro cetalina.log para encontrar la anomalía. Si ocurrió una excepción durante la operación, se coloca en localhost.log.
¿Tomcat integrado?
非传统的部署方式，将Tomcat嵌入到主程序中进行运行。
优点：
灵活部署、任意指定位置、通过复杂的条件判断。比如，springboot中内嵌的tomcat。
Tomcat类:Tomcat类是外部调用的入口
1.位置：org.apache.catalina.startup.Tomcat
2.该类是public的。
3.该类有Server、Service、Engine、Connector、Host等属性。
4.该类有init()、start()、stop()、destroy()等方法。
¿Código fuente incrustado de tomcat en springboot?
@EnableAutoConfiguration en @SpringBootApplication, la configuración de tomcat está activada de forma predeterminada y hay una clase interna EmbeddedTomcat en EmbeddedServletContainerAutoConfiguration que es la entrada de inicio de tomcat integrado, que se implementa llamando a la clase Tomcat.
¿Maven integró el análisis de inicio del complemento de Tomcat?
Tomcat7RunnerCli es una clase de arranque, Tomcat7RunnerCli se basa principalmente en Tomcat7Runner, Tomcat7Runner llama a la clase Tomcat.
¿Hay tres modos de funcionamiento para Tomcat?
Bio, nio, apr, la eficiencia operativa de Tomcat en diferentes modos es bastante diferente.
apr (Apache Portable Runtime):
para resolver problemas de E / S asincrónicos desde el nivel del sistema operativo, mejorar en gran medida el rendimiento, se deben instalar apr y native, y apr es compatible cuando se inicia directamente.
¿Tomcat configura el número de subprocesos?
Configure el número máximo de subprocesos, que es un grupo de subprocesos y un período de tiempo de espera de conexión.
optimización de tomcat?
1. Aumente el número de subprocesos en el grupo de subprocesos.
2. Aumente la memoria del montón. Generalmente, puede especificar el 80% de la memoria física. Agregue información de configuración al archivo de configuración.
3. Establezca enableLookups = "false" en el conector para cancelar la verificación de DNS.
4. Establezca la compresión. = "
On " para comprimir 5, establezca useURIValidationHack en "false" para reducir la comprobación innecesaria de algunas URL y reducir la sobrecarga.
¿Cuántas formas de implementar Tomcat?
1. Coloque el proyecto web directamente en webapps, Tomcat lo implementará automáticamente.
2. Configure el nodo en el archivo server.xml, establezca el atributo relevante (doBase)
y luego configúrelo a través de Catalina: ingrese conf \ Catalina En el archivo \ localhost, cree un archivo xml cuyo nombre sea el nombre del sitio.
¿Cómo crea el contenedor Tomcat una instancia de clase de servlet? ¿Qué principio se utilizó? ?
Cuando se inicia el contenedor, lee los archivos web.xml en todas las aplicaciones web en el directorio webapps, luego analiza los archivos xml y lee la información de registro del servlet. Luego, las clases de servlet registradas en cada aplicación se cargan y se instancian por reflexión.
(En ocasiones también se instancia en la primera solicitud) En el registro del servlet, si es un número positivo, se instanciará al principio, si no está escrito o es un número negativo, se instanciará por primera vez.
¿Mecanismo de carga de clases de Tomcat?
El mecanismo de carga de clases de tomcat viola el mecanismo de delegación principal de jdk. Para lograr el aislamiento, cada webappClassLoader carga archivos de clase en su propio directorio y no se pasarán al cargador de clases principal. Las clases que CommonClassLoader puede cargar pueden ser utilizadas por CatalinaClassLoader y SharedClassLoader, realizando así el intercambio de bibliotecas de clases públicas, mientras que las clases que CatalinaClassLoader y Shared ClassLoader pueden cargar están aisladas entre sí. WebAppClassLoader puede usar las clases cargadas en SharedClassLoader, pero cada instancia de WebAppClassLoader está aislada entre sí. Si CommonClassLoader de tomcat quiere cargar las clases en WebAppClassLoader, se puede implementar usando el cargador de clases de contexto de subprocesos. Usando el cargador de contexto de subprocesos, el cargador de clases padre puede solicitar al cargador de clases secundario que complete la acción de carga de clases.