前言
大家好，我是老马。很高兴遇到你。
我们为 java 开发者实现了 java 版本的 nginx
https://github.com/houbb/nginx4j
如果你想知道 servlet 如何处理的，可以参考我的另一个项目：
手写从零实现简易版 tomcat minicat
手写 nginx 系列
如果你对 nginx 原理感兴趣，可以阅读：
[从零手写实现 nginx-01-为什么不能有 java 版本的 nginx?]
[从零手写实现 nginx-02-nginx 的核心能力]
[从零手写实现 nginx-03-nginx 基于 Netty 实现]
[从零手写实现 nginx-04-基于 netty http 出入参优化处理]
[从零手写实现 nginx-05-MIME类型（Multipurpose Internet Mail Extensions，多用途互联网邮件扩展类型）]
[从零手写实现 nginx-06-文件夹自动索引]
[从零手写实现 nginx-07-大文件下载]
[从零手写实现 nginx-08-范围查询]
[从零手写实现 nginx-09-文件压缩]
[从零手写实现 nginx-10-sendfile 零拷贝]
[从零手写实现 nginx-11-file+range 合并]
[从零手写实现 nginx-12-keep-alive 连接复用]
[从零手写实现 nginx-13-nginx.conf 配置文件介绍]
[从零手写实现 nginx-14-nginx.conf 和 hocon 格式有关系吗？]
[从零手写实现 nginx-15-nginx.conf 如何通过 java 解析处理？]
[从零手写实现 nginx-16-nginx 支持配置多个 server]
[从零手写实现 nginx-17-nginx 默认配置优化]
[从零手写实现 nginx-18-nginx 请求头+响应头操作]
[从零手写实现 nginx-19-nginx cors]
[从零手写实现 nginx-20-nginx 占位符 placeholder]
目标
这一节我们带着这几个问题来学习：
1）nginx.conf 配置的时候支持配置多个 server 模块吗？为什么要支持？
2）不同的 server 模块，监听端口必须相同吗？如果不同，nginx 又如何匹配区分呢？
-
不同的 server 模块，代码启动要如何调整?
-
实现的核心思路+代码是什么样的
nginx.conf 配置的时候支持配置多个 server 模块吗？为什么要支持？
在 Nginx 配置文件 (nginx.conf) 中，确实支持配置多个 server 模块。
这种支持是为了满足以下几个需求：
1. 多域名支持
多个 server 模块允许 Nginx 处理多个域名或子域名。
例如，你可以为 example.com 和 sub.example.com 分别配置不同的服务器块：
http {
server {
listen 80;
server_name example.com;
location / {
root /var/www/example.com;
}
}
server {
listen 80;
server_name sub.example.com;
location / {
root /var/www/sub.example.com;
}
}
}
2. 不同端口支持
你可以为不同的服务配置不同的端口。
例如，一个站点可以运行在端口 80（HTTP），另一个站点可以运行在端口 443（HTTPS）：
http {
server {
listen 80;
server_name example.com;
location / {
root /var/www/example.com;
}
}
server {
listen 443 ssl;
server_name example.com;
ssl_certificate /etc/nginx/ssl/example.com.crt;
ssl_certificate_key /etc/nginx/ssl/example.com.key;
location / {
root /var/www/example.com;
}
}
}
3. 不同配置需求
每个 server 模块可以有自己的配置，例如不同的日志文件、错误页、访问控制策略等：
http {
server {
listen 80;
server_name example1.com;
access_log /var/log/nginx/example1_access.log;
error_log /var/log/nginx/example1_error.log;
location / {
root /var/www/example1.com;
}
}
server {
listen 80;
server_name example2.com;
access_log /var/log/nginx/example2_access.log;
error_log /var/log/nginx/example2_error.log;
location / {
root /var/www/example2.com;
}
}
}
4. 反向代理和负载均衡
Nginx 常用作反向代理服务器，可以将请求转发到不同的后端服务器。
每个 server 模块可以有不同的反向代理配置：
http {
upstream backend1 {
server 127.0.0.1:8080;
server 127.0.0.1:8081;
}
upstream backend2 {
server 127.0.0.1:9090;
server 127.0.0.1:9091;
}
server {
listen 80;
server_name api.example.com;
location / {
proxy_pass http://backend1;
}
}
server {
listen 80;
server_name web.example.com;
location / {
proxy_pass http://backend2;
}
}
}
为什么要支持多个 server 模块？
- 灵活性：不同的站点或服务可以有不同的配置，满足不同的需求。
- 扩展性：可以轻松地添加或修改配置而不影响其他站点或服务。
- 维护性：分离配置使得每个站点的配置文件更加简洁和易于维护。
- 安全性：不同站点可以有不同的安全配置，降低风险。
综上所述，Nginx 支持多个 server 模块，使其能够灵活地管理和配置多个站点和服务，满足各种不同的需求。
不同的 server 模块，监听端口必须相同吗？如果端口相同，nginx 又如何匹配区分呢？
监听端口不同
不同的 server 模块并不需要监听相同的端口。
实际上，配置不同的 server 模块监听不同的端口是一个常见的需求。
例如，一个站点可以运行在端口 80（HTTP），另一个站点可以运行在端口 443（HTTPS），或者其他自定义端口。
以下是一个简单的示例：
http {
server {
listen 80;
server_name example.com;
location / {
root /var/www/example.com;
}
}
server {
listen 8080;
server_name example.com;
location / {
root /var/www/example.com;
}
}
}
在这个示例中，example.com 同时监听了端口 80 和 8080。
如果端口相同，Nginx 如何匹配和区分？
当多个 server 模块监听相同的端口时，Nginx 使用 server_name 和 location 来匹配和区分请求。
匹配流程如下：
-
根据
server_name进行匹配：当一个请求到达 Nginx 时，Nginx 首先根据请求头中的Host字段与配置中的server_name进行匹配。server_name可以是具体的域名、通配符（例如*.example.com）、正则表达式等。 -
默认服务器：如果没有匹配到
server_name，Nginx 会选择一个默认的server模块处理请求。默认服务器是第一个定义的server模块，或者在listen指令中显式指定default_server。
例如：
http {
server {
listen 80 default_server;
server_name default.example.com;
location / {
root /var/www/default;
}
}
server {
listen 80;
server_name example.com;
location / {
root /var/www/example;
}
}
server {
listen 80;
server_name another.example.com;
location / {
root /var/www/another;
}
}
}
在这个配置中：
- 请求
example.com会匹配第二个server模块。 - 请求
another.example.com会匹配第三个server模块。 - 任何其他没有明确匹配到的请求将会被第一个
server模块（默认服务器）处理。
更详细的匹配机制
当多个 server 模块的 server_name 都能匹配到一个请求时，Nginx 会选择最具体的匹配。
例如：
http {
server {
listen 80;
server_name *.example.com;
location / {
root /var/www/wildcard;
}
}
server {
listen 80;
server_name www.example.com;
location / {
root /var/www/www;
}
}
}
对于请求 www.example.com，Nginx 会选择第二个 server 模块，因为它比通配符匹配更具体。
正则表达式匹配
Nginx 还支持使用正则表达式进行 server_name 匹配，这种匹配方式的优先级最低，只在前面的精确匹配和通配符匹配失败后才会被使用：
http {
server {
listen 80;
server_name ~^www\d+\.example\.com$;
location / {
root /var/www/regex;
}
}
}
在这个例子中，www1.example.com 和 www2.example.com 都会匹配到这个 server 模块。
综上所述，当多个 server 模块监听相同端口时，Nginx 会通过 server_name 和匹配规则来区分不同的请求，从而将请求路由到正确的 server 模块。
多个 server 端口启动的方式调整
单个 server 启动
因为单个 server 我们只需要监听一个端口，启动的核心代码如下：
// @author: 老马啸西风
// 服务器监听的端口号
String host = InnerNetUtil.getHost();
EventLoopGroup bossGroup = new NioEventLoopGroup();
//worker 线程池的数量默认为 CPU 核心数的两倍
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
final String httpServerPrefix = String.format("http://%s:%s/", host, port);
nginxConfig.setHttpServerPrefix(httpServerPrefix);
ServerBootstrap serverBootstrap = new ServerBootstrap();
serverBootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
// 配置
}
})
.option(ChannelOption.SO_BACKLOG, 128)
.childOption(ChannelOption.SO_KEEPALIVE, true);
// Bind and start to accept incoming connections.
ChannelFuture future = serverBootstrap.bind(port).sync();
log.info("[Nginx4j] listen on {}", httpServerPrefix);
// Wait until the server socket is closed.
future.channel().closeFuture().sync();
} catch (InterruptedException e) {
log.error("[Nginx4j] start meet ex", e);
throw new Nginx4jException(e);
} finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
log.info("[Nginx4j] shutdownGracefully", host, port);
}
多个 server port 启动时
如果有不同的监听端口，那么就要调整为：
Set<Integer> httpServerPortSet = nginxConfig.getNginxUserConfig().getServerPortSet();
// 需要验证这里是否支持多个？
for(Integer port : httpServerPortSet) {
// 单个启动
}
但是这段代码实际上会卡主，因为 Netty 只会启动并阻塞在第一个端口上，因为 future.channel().closeFuture().sync() 会阻塞当前线程，直到通道关闭。
这意味着在第一个端口启动并阻塞后，后续的端口启动代码将永远不会执行。
引入线程池
为了让多个 port 服务正常启动，我们引入线程池。
//@author: 老马啸西风
@Override
public void start() {
Set<Integer> httpServerPortSet = nginxConfig.getNginxUserConfig().getServerPortSet();
ExecutorService executorService = Executors.newFixedThreadPool(httpServerPortSet.size());
// 需要验证这里是否支持多个？
for (final Integer port : httpServerPortSet) {
executorService.submit(new Runnable() {
@Override
public void run() {
log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> START port={}", port);
singleStart(port);
log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> END port={}", port);
}
});
}
}
配置的过滤
因为配置的时候，可以按照不同的 port
比如下面这样：
# nginx.conf
# 定义运行Nginx的用户和组
user nginx;
# 主进程的PID文件存放位置
pid /var/run/nginx.pid;
# 事件模块配置
events {
worker_connections 1024; # 每个工作进程的最大连接数
}
# HTTP模块配置
http {
include /etc/nginx/mime.types; # MIME类型配置文件
default_type application/octet-stream; # 默认的MIME类型
# 文件传输设置
sendfile on; # 开启高效文件传输
# Keepalive超时设置
keepalive_timeout 65;
# 定义服务器块
server {
listen 8080;
server_name 192.168.1.12:8080; # 服务器域名
# 单独为这个 server 启用 sendfile
sendfile on;
# 静态文件的根目录
root D:\data\nginx4j; # 静态文件存放的根目录
index index.html index.htm; # 默认首页
# 如果需要为这个 server 单独配置 gzip，可以覆盖全局配置
gzip on;
gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;
# 定义location块，处理对根目录的请求
location / {
try_files $uri $uri/ =404; # 尝试提供请求的文件，如果不存在则404
}
}
# 定义服务器块2
server {
listen 8081;
server_name 192.168.1.12:8081; # 服务器域名
# 单独为这个 server 启用 sendfile
sendfile on;
# 静态文件的根目录
root D:\data\nginx4j; # 静态文件存放的根目录
index index.txt; # 默认首页
}
}
我们在初始化的时候，按照 port 过滤分组
protected NginxConfig buildCurrentNginxConfig(NginxConfig nginxConfig,
final int port,
final String httpServerPrefix) {
NginxConfig currentNginxConfig = new NginxConfig();
// 省略基础属性
// 按照端口号过滤
List<NginxUserServerConfig> userServerConfigs = nginxConfig.getNginxUserConfig().getServerConfigList();
// 过滤出 port 的列表并按 hostName 分组
Map<String, List<NginxUserServerConfig>> groupedByHostName = new HashMap<>();
if (CollectionUtil.isNotEmpty(userServerConfigs)) {
groupedByHostName = userServerConfigs.stream()
.filter(userConfig -> userConfig.getHttpServerListen() == port)
.collect(Collectors.groupingBy(NginxUserServerConfig::getHttpServerName));
}
currentUserConfig.setCurrentServerConfigMap(groupedByHostName);
currentNginxConfig.setNginxUserConfig(currentUserConfig);
log.info("[Netty] Server start port={}, groupedByHostName={}", port, groupedByHostName);
return currentNginxConfig;
}
使用
我们启动后设置了对应的配置，在请求过来时，可以根据请求信息直接匹配
/**
* 按照 hostName 匹配
*
* TODO: 这个匹配策略可以单独独立出来，后续可以拓展。
* 比如最佳的 URL 匹配等等。
*
* @param hostName hostName
* @return 结果
*/
public NginxUserServerConfig getNginxUserServerConfig(String hostName) {
final Map<String, List<NginxUserServerConfig>> serverConfigMap = nginxConfig.getNginxUserConfig().getCurrentServerConfigMap();
List<NginxUserServerConfig> serverConfigList = serverConfigMap.get(hostName);
// 返回自定义
if(CollectionUtil.isNotEmpty(serverConfigList)) {
return serverConfigList.get(0);
}
// 默认的配置
List<NginxUserServerConfig> currentDefineserverConfigList = serverConfigMap.get(NginxConst.DEFAULT_SERVER);
if(CollectionUtil.isNotEmpty(currentDefineserverConfigList)) {
return currentDefineserverConfigList.get(0);
}
// 全局默认
return nginxConfig.getNginxUserConfig().getDefaultUserServerConfig();
}
当然，这里的实现比较简陋。
后续可以对这里进行拓展。
小结
我们可以发现 nginx 设计的非常灵活+强大。
值得我们深入学习其背后的思想+理念。