# Minicat

**Repository Path**: orangezh/minicat

## Basic Information

- **Project Name**: Minicat
- **Description**: 手写实现简易tomcat，并实现多实例部署
- **Primary Language**: Unknown
- **License**: MulanPSL-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 1
- **Created**: 2020-10-08
- **Last Updated**: 2021-10-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Minicat

#### 介绍
手写实现简易tomcat，并实现多实例部署

#### Tomcat主要目录结构
<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1008/222843_fc108a23_797716.png"  />  <br>tomcat主要目录结构</div>

Bin：主要是用来存放tomcat的命令，启动（startup）/停止（shutdown）脚本等，修改catalina可以设置tomcat的内存

Conf：主要是用来存放tomcat的一些配置文件；

- server.xml可以设置端口号、设置域名或IP、默认加载的项目、请求编码 
- web.xml可以设置tomcat支持的文件类型 
- context.xml可以用来配置数据源之类的 
- tomcat-users.xml用来配置管理tomcat的用户与权限 
- 在Catalina目录下可以设置默认加载的项目

Webapps：用来存放应用程序，当tomcat启动时会去加载webapps目录下的应用程序，可以以文件夹、war包、jar包的形式发布应用；也可以把应用程序放在其他位置，在配置文件中修改路径

Work：用来存放tomcat在运行时的编译后文件，例如JSP编译后的文件，清空work目录，然后重启tomcat，可以达到清除缓存的作用

Lib：主要用来存放tomcat运行需要加载的jar包

Logs：用来存放tomcat在运行过程中产生的日志文件

- 在windows环境中，控制台的输出日志在catalina.xxxx-xx-xx.log文件中 
- 在linux环境中，控制台的输出日志在catalina.out文件中

#### Tomcat总体架构
<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1008/223050_b315dcd2_797716.png"  />  <br>总体架构</div>

使用Container代表容器，Engine、Host、Context、Wrapper都是Container的子容器，Container可以维护子容器。backgroundProcess()方法针对后台处理，并且其基础抽象类(ContainerBase)确保在启动组件的同时，异步启动后台处理
#### Lifecycle生命周期
<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1008/223107_1b0267ca_797716.png"  />  <br>生命周期图</div>

所有的容器中都存在start()、stop()等方法，因此抽象出Lifecycle接口，该接口中定义了相关的生命周期的方法。主要方法如下：
		
- Init()：初始化组件
- Start()：启动组件
- Stop()：停止组件
- Destroy()：销毁组件

<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1008/224121_6c7f8b1b_797716.png"  />  <br>Lifecycle状态流程</div>

#### Tomcat类加载机制

<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1008/224035_ccb99599_797716.png "  />  <br>tomcat类加载机制</div>
	
- 从缓存中加载
- 如果没有，从JVM的Bootstrap类加载器加载
- 如果没有，则从当前类加载器加载（WEB-INF/classes 、WEB-INF/lib的顺序）
- 如果没有，则从父类加载器加载，由于父类加载器采用默认的委派模式，所以加载顺序为System、Common、Shared
- 如果启用Java委派模式(delegate=true)：缓存-Bootstrap-从父类（System、common、shared）-当前类加载器加载

#### Tomcat Coyote与Catalina

- Catalina组件：
- 包含所有的容器组件
- 通过松耦合方式集成Cotoye
- 包含启动入口以及Shell
- 使用Apache Digester解析XML配置文件并创建服务器

<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1008/223203_69f417b4_797716.png "  />  <br>Catalina依赖关系图</div>

Coyote组件：

- Tomcat链接器
- 外部访问接口服务
- 建立链接，发送请求，并接收响应
- 封装底层网络通信协议，为Catalina提供接口，使之与请求协议及I/O方式解耦
- 将Socket输入转换为Request交由Catalina处理
- 提供Response对象将Catalina的处理结果写入输出流
- 此处的Request与Response与Servlet还未关联

<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1008/223608_9a4b4411_797716.png "  />  <br>Coyote与Catalina交互关系</div>

#### Tomcat 服务器核⼼配置详解
> Tomcat作为服务器的配置，主要是 server.xml ⽂件的配置；server.xml中包含了 Servlet容器的相关配置，即 Catalina 的配置；Xml ⽂件的讲解主要是标签的使⽤

**主要标签结构如下：** 

```
<!--Server 根元素，创建⼀个Server实例，⼦标签有 Listener、GlobalNamingResources、Service-->
<Server>
    <!--定义监听器-->
    <Listener/>
    <!--定义服务器的全局JNDI资源 -->
    <GlobalNamingResources/>
    <!--定义⼀个Service服务，⼀个Server标签可以有多个Service服务实例-->
    <Service/>
</Server>
```

**Server 标签：** 

```
<!--port：关闭服务器的监听端口 shutdown：关闭服务器的指令字符串-->
<Server port="8005" shutdown="SHUTDOWN">
	<!-- 以日志形式输出服务器 、操作系统、JVM的版本信息 -->
	<Listener className="org.apache.catalina.startup.VersionLoggerListener" />
	<!-- Security listener. Documentation at /docs/config/listeners.html  <Listener className="org.apache.catalina.security.SecurityListener" /> -->
	<!-- APR library loader. Documentation at /docs/apr.html -->
	<!-- 加载（服务器启动） 和 销毁 （服务器停止） APR。 如果找不到APR库， 则会输出日志， 并不影响 Tomcat启动 -->
	<Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
	<!-- Prevent memory leaks due to use of particular java/javax APIs-->
	<!-- 避免JRE内存泄漏问题 -->
	<Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
	<!-- 加载（服务器启动） 和 销毁（服务器停⽌） 全局命名服务 -->
	<ListenerclassName="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
	<!-- 在Context停⽌时重建 Executor 池中的线程， 以避免ThreadLocal 相关的内存泄漏 -->
	<ListenerclassName="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />

	<!-- Global JNDI resources
		 Documentation at /docs/jndi-resources-howto.html
		 GlobalNamingResources 中定义了全局命名服务
	-->
	<GlobalNamingResources>
	<!-- Editable user database that can also be used by UserDatabaseRealm to authenticate users-->
	<Resource name="UserDatabase" auth="Container" type="org.apache.catalina.UserDatabase" description="User database that can be updated and saved" factory="org.apache.catalina.users.MemoryUserDatabaseFactory" pathname="conf/tomcat-users.xml" />
	</GlobalNamingResources>
	<!-- A "Service" is a collection of one or more "Connectors" that share a single "Container" Note: A "Service" is not itself a "Container", so you may not define subcomponents such as "Valves" at this level. Documentation at /docs/config/service.html -->
	<Service name="Catalina">
	...
	</Service>
</Server>
```

 **Service 标签：** 

```
<!--
 该标签⽤于创建 Service 实例，默认使⽤ org.apache.catalina.core.StandardService。
 默认情况下，Tomcat 仅指定了Service 的名称， 值为 "Catalina"。
 Service ⼦标签为 ： Listener、Executor、Connector、Engine，
 其中：
 Listener ⽤于为Service添加⽣命周期监听器，
 Executor ⽤于配置Service 共享线程池，
 Connector ⽤于配置Service 包含的链接器，
 Engine ⽤于配置Service中链接器对应的Servlet 容器引擎
-->
<Service name="Catalina">
 ...
</Service>
```

 **Executor 标签：** 

```
<!--
	默认情况下，Service 并未添加共享线程池配置。 如果我们想添加一个线程池， 可以在
	<Service> 下添加如下配置：
	name：线程池名称，用于 Connector中指定
	namePrefix：所创建的每个线程的名称前缀，一个单独的线程名称为namePrefix+threadNumber
	maxThreads：池中最大线程数
	minSpareThreads：活跃线程数，也就是核心池线程数，这些线程不会被销毁，会一直存在
	maxIdleTime：线程空闲时间，超过该时间后，空闲线程会被销毁，默认值为6000（1分钟），单位毫秒
	maxQueueSize：在被执行前最大线程排队数量，默认为Int的最大值，也就是无限大。除特殊情况，这个值不需要更改，否则会有请求不会被处理的情况发生
	prestartminSpareThreads：启动线程池时是否启动 minSpareThreads部分线程。默认值为false，即不启动
	threadPriority：线程池中线程优先级，默认值为5，值从1到10
	className：线程池实现类，未指定情况下，默认实现类为
	org.apache.catalina.core.StandardThreadExecutor。如果想使自定义线程池先需要实现org.apache.catalina.Executor接口
-->
<Executor name="commonThreadPool"
 namePrefix="thread-exec-"
 maxThreads="200"
 minSpareThreads="100"
 maxIdleTime="60000"
 maxQueueSize="Integer.MAX_VALUE"
 prestartminSpareThreads="false"
 threadPriority="5"
 className="org.apache.catalina.core.StandardThreadExecutor"/>
```

 **Connector 标签：** 

Connector 标签⽤于创建链接器实例

默认情况下，server.xml 配置了两个链接器，⼀个⽀持HTTP协议，⼀个⽀持AJP协议

⼤多数情况下，我们并不需要新增链接器配置，只是根据需要对已有链接器进⾏优化

```
<!--
	port：端口号，Connector 用于创建服务端Socket 并进行监听，以等待客户端请求链接。如果该属性设置为0，Tomcat将会随机选择一个可用的端口号给当前Connector 使用
	protocol：当前Connector 支持的访问协议。 默认为 HTTP/1.1 ，并采用自动切换机制选择一个基于 JAVA NIO 的链接器或者基于本地APR的链接器（根据本地是否含有Tomcat的本地库判定）
	connectionTimeOut:Connector 接收链接后的等待超时时间，单位为毫秒。 -1 表示不超时。
	redirectPort：当前Connector 不支持SSL请求，接收到了一个请求，并且也符合security-constraint 约束需要SSL传输，Catalina 自动将请求重定向到指定的端口。
	executor：指定共享线程池的名称，也可以通过maxThreads、minSpareThreads 等属性配置内部线程池。
	URIEncoding:用于指定编码URI的字符编码，Tomcat8.x版本默认的编码为 UTF-8 , Tomcat7.x版本默认为ISO-8859-1
-->
<!--org.apache.coyote.http11.Http11NioProtocol ， 非阻塞式 Java NIO 链接器-->
<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000"redirectPort="8443" />
<Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
```

可以使⽤共享线程池

```
<Connector port="8080"
 protocol="HTTP/1.1"
 executor="commonThreadPool"
 maxThreads="1000"
 minSpareThreads="100"
 acceptCount="1000"
 maxConnections="1000"
 connectionTimeout="20000"
 compression="on"
 compressionMinSize="2048"
 disableUploadTimeout="true"
 redirectPort="8443"
 URIEncoding="UTF-8" />
```
 **Engine 标签：** 

Engine 表示 Servlet 引擎

```
<!--
    name： ⽤于指定Engine 的名称， 默认为Catalina
    defaultHost：默认使⽤的虚拟主机名称， 当客户端请求指向的主机⽆效时， 将交由默认的虚拟主机处理， 默认为localhost
-->
<Engine name="Catalina" defaultHost="localhost">
 ...
</Engine>
```
 **Host 标签：** 

Host 标签⽤于配置⼀个虚拟主机

```
<Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true">
 ...
</Host> 
```
 **Context 标签：** 

Context 标签⽤于配置⼀个Web应⽤

```
<Host name="www.abc.com" appBase="webapps" unpackWARs="true" autoDeploy="true">
<!--
	docBase：Web应⽤⽬录或者War包的部署路径。可以是绝对路径，也可以是相对于 Host appBase的相对路径。
	path：Web应⽤的Context 路径。如果我们Host名为localhost， 则该web应⽤访问的根路径为：http://localhost:8080/web_demo。
-->
 <Context docBase="/Users/yingdian/web_demo" path="/web3"></Context>
 <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs" prefix="localhost_access_log" suffix=".txt" pattern="%h %l %u %t &quot;%r&quot; %s %b" />
</Host>
```

#### 自定义Tomcat
[自定义Tomcat Demo](https://gitee.com/orangezh/minicat)

#### Tomcat 源码构建及分析
#### Tomcat 源码构建

 **1、源码下载** 

官网下载源码包

 **2、源码导入前的准备工作**

- 解压 tar.gz 压缩包，得到⽬录 apache-tomcat-8.5.50-src
- 进⼊ apache-tomcat-8.5.50-src ⽬录，创建⼀个pom.xml⽂件，⽂件内容如下 

```
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>org.apache.tomcat</groupId>
 <artifactId>apache-tomcat-8.5.50-src</artifactId>
 <name>Tomcat8.5</name>
 <version>8.5</version>
 <build>
 <!--指定源⽬录-->
 <finalName>Tomcat8.5</finalName>
 <sourceDirectory>java</sourceDirectory>
 <resources>
 <resource>
 <directory>java</directory>
 </resource>
 </resources>
 <plugins>
 <!--引⼊编译插件-->
 <plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-compiler-plugin</artifactId>
 <version>3.1</version>
 <configuration>
 <encoding>UTF-8</encoding>
 <source>11</source>
 <target>11</target>
 </configuration>
 </plugin>
 </plugins>
 </build>
 <!--tomcat 依赖的基础包-->
 <dependencies>
 <dependency>
 <groupId>org.easymock</groupId>
 <artifactId>easymock</artifactId>
 <version>3.4</version>
 </dependency>
 <dependency>
 <groupId>ant</groupId>
 <artifactId>ant</artifactId>
 <version>1.7.0</version>
 </dependency>
 <dependency>
 <groupId>wsdl4j</groupId>
 <artifactId>wsdl4j</artifactId>
 <version>1.6.2</version>
 </dependency>
 <dependency>
 <groupId>javax.xml</groupId>
 <artifactId>jaxrpc</artifactId>
 <version>1.1</version>
 </dependency>
 <dependency>
 <groupId>org.eclipse.jdt.core.compiler</groupId>
 <artifactId>ecj</artifactId>
 <version>4.5.1</version>
 </dependency>
 <dependency>
 <groupId>javax.xml.soap</groupId>
 <artifactId>javax.xml.soap-api</artifactId>
 <version>1.4.0</version>
 </dependency>
 </dependencies>
</project>
```
- 在 apache-tomcat-8.5.50-src ⽬录中创建 source ⽂件夹
- 将 conf、webapps ⽬录移动到刚刚创建的 source ⽂件夹中

 **3、导⼊源码⼯程到IDE并进⾏配置** 

- 将源码⼯程导⼊到 IDEA 中
- 给 tomcat 的源码程序启动类 Bootstrap 配置 VM 参数，因为 tomcat 源码运⾏也需要加载配置⽂件等。

```
-Dcatalina.home=/Users/yingdian/workspace/servers/apache-tomcat-8.5.50-src/source
-Dcatalina.base=/Users/yingdian/workspace/servers/apache-tomcat-8.5.50-src/source
-Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager
-Djava.util.logging.config.file=/Users/yingdian/workspace/servers/apachetomcat-8.5.50-src/source/conf/logging.properties
```
- 运⾏ Bootstrap 类的 main 函数，此时就启动了tomcat，启动时候会去加载所配置的 conf ⽬录下的server.xml等配置⽂件，所以访问8080端⼝即可，但此时我们会遇到的⼀个错误：
> 原因是Jsp引擎Jasper没有被初始化，从⽽⽆法编译JSP，我们需要在tomcat的源码ContextConfig类中的configureStart⽅法中增加⼀⾏代码将 Jsp 引擎初始化

```Java
context.addServletContainerInitializer(new JasperInitializer(), null);
```

- 重启 Tomcat，正常访问即可。⾄此，Tomcat 源码构建完毕。

#### Tomcat 核心源码分析 

Tomcat启动流程和Tomcat请求处理流程

<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1008/223130_de3e0dc3_797716.png"  />  <br>Tomcat的启动流程</div>

<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1008/223140_5090c576_797716.png"  />  <br>Tomcat请求处理流程</div>

<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1111/141439_3a10a962_797716.jpeg"  />  <br>Tomcat请求执行流程</div>


具体代码流程请自行在源码中进行调试

#### Nginx
#### Nginx 概述与安装
 **1、Nginx 到底是什么？** 

Nginx 是⼀个⾼性能的HTTP和反向代理web服务器，核⼼特点是占有内存少，并发能⼒强

 **2、Nginx应用场景** 
- Http服务器（Web服务器）

```
    性能⾮常⾼，⾮常注重效率，能够经受⾼负载的考验。
    ⽀持50000个并发连接数，不仅如此，CPU和内存的占⽤也⾮常的低，10000个没有活动的连接才占⽤2.5M的内存。
```

- 反向代理服务器

```
    浏览器客户端发送请求到反向代理服务器（⽐如Nginx），由反向代理服务器选择原始服务器提供服务获取结果响应，最终再返回给客户端浏览器
```
- 负载均衡服务器

```
负载均衡，当⼀个请求到来的时候，Nginx反向代理服务器根据请求去找到⼀个原始服务器来处理当前请求，那么这叫做反向代理。那么，如果⽬标服务器有多台，找哪⼀个⽬标服务器来处理当前请求呢，这样⼀个寻找确定的过程就叫做负载均衡。
⽣活中也有很多这样的例⼦，⽐如，我们去银⾏，可以处理业务的窗⼝有多个，那么我们会被分配到哪个窗⼝，这样的⼀个过程就叫做负载均衡。
```
- 动静分离

```
动静分离就是讲动态资源和静态资源的请求处理分配到不同的服务器上，⽐较经典的组合就是Nginx+Tomcat架构（Nginx处理静态资源请求，Tomcat处理动态资源请求）
```

 **3、Nginx 的特点** 

- 跨平台：Nginx可以在⼤多数类unix操作系统上编译运⾏，⽽且也有windows版本
- Nginx的上⼿⾮常容易，配置也⽐较简单
- ⾼并发，性能好
- 稳定性也特别好，宕机概率很低

 **4、Nginx的安装** 

- 上传nginx安装包到linux服务器，nginx安装包(.tar⽂件)下载地址：http://nginx.org
- 安装Nginx依赖，pcre、openssl、gcc、zlib（推荐使⽤yum源⾃动安装）
```
    yum -y install gcc zlib zlib-devel pcre-devel openssl openssl-devel
```
- 解包Nginx软件包
```
    tar -xvf nginx-1.17.8.tar
````
- 进⼊解压之后的⽬录 nginx-1.17.8
```
    cd nginx-1.17.8
```
- 命令⾏执⾏./configure
- 命令⾏执⾏ make
- 命令⾏执⾏ make install，完毕之后在/usr/local/下会产⽣⼀个nginx⽬录

```
    进⼊sbin⽬录中，执⾏启动nginx命令
    cd nginx/sbin
    ./nginx
```

 **5、Nginx主要命令** 

- ./nginx 启动nginx
- ./nginx -s stop 终⽌nginx（当然也可以找到nginx进程号，然后使⽤kill -9 杀掉nginx进程）
- ./nginx -s reload (重新加载nginx.conf配置⽂件)

#### Nginx配置解析

Nginx的核⼼配置⽂件conf/nginx.conf包含三块内容：全局块、events块、http块

 **1、全局块** 

从配置⽂件开始到events块之间的内容，此处的配置影响nginx服务器整体的运⾏，⽐如worker进程的数量、错误⽇志的位置等

<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1111/144000_9c933769_797716.jpeg"  />  <br>Nginx 全局块</div>

 **2、events块** 

events块主要影响nginx服务器与⽤户的⽹络连接，⽐如worker_connections 1024，标识每个workderprocess⽀持的最⼤连接数为1024

<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1111/144124_7410691d_797716.jpeg"  />  <br>Nginx events块</div>

 **3、http块** 

http块是配置最频繁的部分，虚拟主机的配置，监听端⼝的配置，请求转发、反向代理、负载均衡等

<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1111/144552_76330e43_797716.jpeg"  />  <br>Nginx http块</div>

#### Nginx 反向代理

主要就是修改location，这⾥的nginx中server/location就好⽐tomcat中的Host/Context

location 语法如下：

```
    location [=|~|~*|^~] /uri/ { … }
```

在nginx配置⽂件中，location主要有这⼏种形式：

```
1）正则匹配 location ~ /lagou { }
2）不区分⼤⼩写的正则匹配 location ~* /lagou { }
3）匹配路径的前缀 location ^~ /lagou { }
4）精确匹配 location = /lagou { }
5）普通路径前缀匹配 location /lagou { }
优先级
4 > 3 > 2 > 1 > 5
```
<div align=center> <img src="https://images.gitee.com/uploads/images/2020/1111/145034_527b53d1_797716.jpeg"  />  <br>Nginx 反向代理配置实例</div>

#### Nginx 负载均衡策略
- 轮询

    默认策略，每个请求按时间顺序逐⼀分配到不同的服务器，如果某⼀个服务器下线，能⾃动剔除

```
upstream lagouServer{
 server 111.229.248.243:8080;
 server 111.229.248.243:8082;
}
location /abc {
 proxy_pass http://lagouServer/;
}
```
- weight

    weight代表权重，默认每⼀个负载的服务器都为1，权重越⾼那么被分配的请求越多（⽤于服务器性能不均衡的场景）

```
upstream lagouServer{
 server 111.229.248.243:8080 weight=1;
 server 111.229.248.243:8082 weight=2;
}
```
- ip_hash

    每个请求按照ip的hash结果分配，每⼀个客户端的请求会固定分配到同⼀个⽬标服务器处理，可以解决session问题

```
upstream lagouServer{
 ip_hash;
 server 111.229.248.243:8080;
 server 111.229.248.243:8082;
}
```