  [conf]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# HTTP模块配置
http {
    upstream backend {
        server 127.0.0.1:3000 weight=5;
    }

    # 定义服务器块
    server {
        listen 8080;
        server_name 127.0.0.1:8080;  # 服务器域名

        # 静态文件的根目录
        root D:\data\nginx4j;  # 静态文件存放的根目录
        index index.html index.htm;  # 默认首页

        # = 精准匹配
        location / {
        }

        # = 精准匹配
        location /p {
            proxy_pass http://backend;
        }
    }

}

配置文件加载

下面的实现主要用来解析 upstream 模块处理。

  [java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
 * @since 0.27.0
 * @author 老马啸西风
 */
public class NginxUserUpstreamConfigLoadFile implements INginxUserUpstreamConfigLoad {

    private final NgxConfig conf;

    private final NgxBlock ngxBlock;

    public NginxUserUpstreamConfigLoadFile(NgxConfig conf, NgxBlock ngxBlock) {
        this.conf = conf;
        this.ngxBlock = ngxBlock;
    }

    @Override
    public NginxUserUpstreamConfig load() {
        NginxUserUpstreamConfig config = new NginxUserUpstreamConfig();
        config.setName(ngxBlock.getName());
        config.setValue(ngxBlock.getValue());
        config.setValues(ngxBlock.getValues());

        // 配置
        String upstreamName = ngxBlock.getValue();
        if(StringUtil.isEmpty(upstreamName)) {
            throw new Nginx4jException("upstream 名称不可为空");
        }

        config.setUpstream(upstreamName);
        Collection<NgxEntry> entryList = ngxBlock.getEntries();
        List<NginxUserUpstreamConfigItem> configItemList = new ArrayList<>();
        if(CollectionUtil.isNotEmpty(entryList)) {
            for(NgxEntry ngxEntry : entryList) {
                if(ngxEntry instanceof NgxParam) {
                    NgxParam ngxParam = (NgxParam) ngxEntry;

                    NginxUserUpstreamConfigItem configItem = new NginxUserUpstreamConfigItem();
                    configItem.setName(ngxParam.getName());
                    configItem.setValue(ngxParam.getValue());
                    configItem.setValues(ngxParam.getValues());

                    configItemList.add(configItem);
                }
            }
        }

        config.setConfigItemList(configItemList);
        return config;
    }

}

配置的预处理

我们在处理配置的时候，需要处理一下上面的配置

整体逻辑

直接处理上述的 NginxUserServerLocationConfig 加载处理，针对 proxy_pass 指令解析处理。

  [java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/**
 * 默认负载均衡配置
 * 
 * @since 0.27.0
 * @author 老马啸西风
 */
public class NginxLoadBalanceDefaultConfig implements INginxLoadBalanceConfig {

    private static final Log log = LogFactory.getLog(NginxLoadBalanceDefaultConfig.class);

    @Override
    public NginxLoadBalanceConfig buildBalanceConfig(NginxRequestDispatchContext dispatchContext) {
        NginxLoadBalanceConfig config = new NginxLoadBalanceConfig();
        config.setNeedProxyPass(false);

        NginxUserServerLocationConfig nginxUserServerLocationConfig = dispatchContext.getCurrentUserServerLocationConfig();
        List<NginxCommonConfigEntry> configEntryList = nginxUserServerLocationConfig.getConfigEntryList();
        if(CollectionUtil.isEmpty(configEntryList)) {
            return config;
        }

        //1. serverList proxy_pass http://my_backend;
        for(NginxCommonConfigEntry entry : configEntryList) {
            if("proxy_pass".equals(entry.getName())) {
                config.setNeedProxyPass(true);

                final String url = entry.getValue();
                config.setProxyPassUrl(url);
                String upstreamName = getUpstreamName(url, dispatchContext);
                config.setUpstreamName(upstreamName);
                // 获取对应的配置信息
                final NginxUserUpstreamConfig upstreamConfig = getUpstreamConfig(upstreamName, url, dispatchContext);

                List<IServer> serverList = buildServerList(upstreamConfig, url, dispatchContext);
                config.setUpstreamServerList(serverList);

                // 设置对应的哈希策略 一般第一行为策略？
                NginxCommonConfigEntry upstreamStrategy = getUpstreamStrategyConfig(upstreamConfig);
                if(upstreamStrategy != null) {
                    config.setUpstreamProxyStrategy(upstreamStrategy.getName());
                    config.setUpstreamProxyStrategyValue(upstreamStrategy.getValue());
                }

                break;
            }
        }

        return config;
    }
}

getUpstreamName 获取 upstreamName

假如配置信息为 proxy_pass http://backend;

那么我们需要解析到 backend 作为 upstreamName。

  [java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 获取对应的 upstream 名称
 * @param target 目标url
 * @param dispatchContext 上下文
 * @return 结果
 */
private String getUpstreamName(String target, NginxRequestDispatchContext dispatchContext) {
    String urlSuffix = getUrlSuffix(target);
    if(StringUtil.isEmpty(urlSuffix)) {
        return urlSuffix;
    }

    // 结果
    return urlSuffix.split(":")[0];
}

getUpstreamConfig 获取配置信息

如果我们得到了 upstreamName，那么如何找到对应的 upstream 配置呢？

根据 upstream 名称，找到对应的配置信息。

  [java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private NginxUserUpstreamConfig getUpstreamConfig(String upstreamName, String url, NginxRequestDispatchContext dispatchContext) {
    if(StringUtil.isEmpty(upstreamName)) {
        return null;
    }
    NginxUserConfig nginxUserConfig =  dispatchContext.getNginxConfig().getNginxUserConfig();
    List<NginxUserUpstreamConfig> upstreamConfigs = nginxUserConfig.getUpstreamConfigs();
    if(CollectionUtil.isEmpty(upstreamConfigs)) {
        log.info("upstreamConfigs is empty, match config is null");
        return null;
    }

    // 遍历
    for(NginxUserUpstreamConfig upstreamConfig : upstreamConfigs) {
        if(upstreamName.equals(upstreamConfig.getUpstream())) {
            return upstreamConfig;
        }
    }
    log.info("upstreamConfigs match config not found!");
    return null;
}

buildServerList 如何构建对应的目标服务器列表？

这里稍微繁琐一点。

默认配置

我们首先可以指定默认的端口：

在 HTTP 和 HTTPS 通信中，默认端口号如下：

HTTP: 默认端口是 80。
HTTPS: 默认端口是 443。

核心实现

核心实现如下：

1) 没找到对应的 upstream

直接根据指定的配置，构建服务器列表。

比如 proxy_pass http://localhost:8080;

2) 找到对应的 upstream 配置

根据对应的服务器列表，构建对应的列表即可。

这里需要注意一下细节，处理一下 host+port+weight

  [java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
    private List<IServer> buildServerList(final NginxUserUpstreamConfig upstreamConfig,
                                          String url,
                                          NginxRequestDispatchContext dispatchContext) {
        List<IServer> list = new ArrayList<>();

        // 协议
        Integer defaultPort = NginxHttpEnum.getDefaultPortByUrl(url);
        String urlSuffix = getUrlSuffix(url);

        if(upstreamConfig == null) {
            // proxy_pass http://backend.example.com:8080;
            String[] urlSuffixSplits = urlSuffix.split(":");
            if(urlSuffixSplits.length > 1) {
                defaultPort = Integer.parseInt(urlSuffixSplits[1]);
            }
            IServer server = Server.newInstance().host(urlSuffixSplits[0]).port(defaultPort).weight(1);
            list.add(server);
        } else {
            //....

            //server backend1.example.com:8080 weight=3;
            for(NginxUserUpstreamConfigItem configItem : configItemList) {
                String name = configItem.getName();
                if(!"server".equals(name)) {
                    continue;
                }

                List<String> values = configItem.getValues();
                String serverValue = values.get(0);
                String[] serverValueSplits = serverValue.split(":");
                int port = defaultPort;
                if(serverValueSplits.length > 1) {
                    port = Integer.parseInt(serverValueSplits[1]);
                }

                int weight = 1;
                if(values.size() > 1) {
                    String weightValue = values.get(1);
                    weight = Integer.parseInt(weightValue.split("=")[1]);
                }

                IServer server = Server.newInstance()
                        .host(serverValueSplits[0])
                        .port(port)
                        .weight(weight);

                list.add(server);
            }
        }

        return list;
    }

小结

到这里开始，我们介绍了如何解析配置文件。

并且介绍了针对 proxy_pass 的指令，如何做好对应的配置解析处理。

下一节，我们一起看一下如何实现 proxy_pass 的反向代理。

参考资料

前言
- 手写 nginx 系列
配置加载
- 配置文件的例子
- 配置文件加载
配置的预处理
小结
参考资料

前言

手写 nginx 系列

配置加载

配置文件的例子