怎么把全局共享修改为并发的

package main

import (
"context"
"crypto/tls"
"errors"
"fmt"
"github.com/redis/go-redis/v9"
"net"
"net/http"
"net/http/httputil"
"net/url"
"strings"
"sync"
"time"
)

var (
httpAddr = ":80"
httpsAddr = ":443"
redisClient *redis.Client
)

type proxyInfo struct {
mu sync.RWMutex
targetUrl string
requestPath string
requestRawQuery string
requestHeader map[string]string
}

func init() {
redisClient = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379",
Password: "",
DB: 0,
})
}

func main() {
// 创建 httpTCP
tcpConn, err := net.Listen("tcp", httpAddr)
if err != nil {
panic(err)
}
defer tcpConn.Close()

// 创建 httpsTCP
tcpsConn, err := net.Listen("tcp", httpsAddr)
if err != nil {
panic(err)
}
defer tcpsConn.Close()

pi := &proxyInfo{
requestHeader: make(map[string]string),
}

tlsConn := tls.NewListener(tcpsConn, &tls.Config{
GetCertificate: func(clientHello *tls.ClientHelloInfo) (*tls.Certificate, error) {
return pi.getCertificate(clientHello)
},
})

httpServer := &http.Server{
Handler: pi.proxyRequestHandler(),
}

go func() {
if err := httpServer.Serve(tcpConn); err != nil {
fmt.Println("HTTP server error:", err)
}
}()

go func() {
if err := httpServer.Serve(tlsConn); err != nil {
fmt.Println("HTTPS server error:", err)
}
}()

select {}
}

// 反向代理
func (pi *proxyInfo) newProxy() (*httputil.ReverseProxy, error) {
pi.mu.RLock()
defer pi.mu.RUnlock()

targetUrl, err := url.Parse(pi.targetUrl)
if err != nil {
return nil, err
}

targetUrl.Path = pi.requestPath
targetUrl.RawQuery = pi.requestRawQuery

fmt.Println("反代的地址：", targetUrl.String())
proxy := httputil.NewSingleHostReverseProxy(targetUrl)

// 连接配置
proxy.Transport = &http.Transport{
Proxy: http.ProxyFromEnvironment,
DialContext: (&net.Dialer{
Timeout: 60 * time.Second,
KeepAlive: 60 * time.Second,
}).DialContext,
ForceAttemptHTTP2: true,
MaxIdleConns: 100,
IdleConnTimeout: 90 * time.Second,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
MaxIdleConnsPerHost: 20,
}

originalDirector := proxy.Director
proxy.Director = func(req *http.Request) {
originalDirector(req)
req.URL = targetUrl
req.Host = targetUrl.Host
for k, v := range pi.requestHeader {
req.Header.Set(k, v)
}
}

proxy.ModifyRespOnse= pi.modifyResponse()
proxy.ErrorHandler = pi.errorHandler()
return proxy, nil
}

// 根据客户端 ClientHello 查询 redis 里域名信息
func (pi *proxyInfo) getCertificate(clientHello *tls.ClientHelloInfo) (*tls.Certificate, error) {
hostName := clientHello.ServerName

// 判断不符合域名长度的 SSL 请求
if len(hostName) < 4 {
return nil, errors.New(hostName + ",域名长度不符合")
}

// 查询 redis 里的域名 SSL 证书
hostConf, err := pi.getHostConf(hostName)
if err != nil {
return nil, err
}

certPublic := []byte(hostConf["certPublic"])
certPrivate := []byte(hostConf["certPrivate"])

certAndKey, err := tls.X509KeyPair(certPublic, certPrivate)
if err != nil {
return nil, err
}

return &certAndKey, nil
}

// 处理代理请求
func (pi *proxyInfo) proxyRequestHandler() http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// 不是 https 的请求
if r.TLS == nil {
_, err := pi.getHostConf(getHostName(r.Host))
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
}

pi.mu.Lock()
defer pi.mu.Unlock()

pi.requestPath = r.URL.Path
pi.requestRawQuery = r.URL.RawQuery

// 清空并设置请求头
pi.requestHeader = make(map[string]string)
pi.requestHeader["Referer"] = pi.targetUrl
pi.requestHeader["User-Agent"] = r.Header.Get("User-Agent")
pi.requestHeader["Accept"] = r.Header.Get("Accept")

// 反代
proxy, err := pi.newProxy()
if err != nil {
http.Error(w, "Failed to create proxy: "+err.Error(), http.StatusInternalServerError)
return
}

proxy.ServeHTTP(w, r)
}
}

// 修改 http 响应数据
func (pi *proxyInfo) modifyResponse() func(*http.Response) error {
return func(r *http.Response) error {
typeStr := r.Header.Get("Content-Type")
fmt.Println("响应内容类型:", typeStr)
return nil
}
}

// 错误处理器
func (pi *proxyInfo) errorHandler() func( http.ResponseWriter, *http.Request, error) {
return func(w http.ResponseWriter, req *http.Request, err error) {
fmt.Printf("Got error while modifying response: %v \n", err)
http.Error(w, "server error", http.StatusInternalServerError)
return
}
}

// 获取域名的配置信息
func (pi *proxyInfo) getHostConf(hostName string) (map[string]string, error) {
hostConf, err := redisClient.HGetAll(context.Background(), hostName).Result()
if err != nil {
return nil, err
}

// 检查是否存在目标网址
if targetUrl, ok := hostConf["targetUrl"]; ok {
pi.mu.Lock()
pi.targetUrl = targetUrl
pi.mu.Unlock()
} else {
return nil, errors.New("missing targetUrl in configuration")
}

return hostConf, nil
}

// 获取不含端口的 host
func getHostName(rawUrl string) string {
if !strings.HasPrefix(rawUrl, "http://") && !strings.HasPrefix(rawUrl, "https://") {
rawUrl = "http://" + rawUrl
}
u, err := url.Parse(rawUrl)
if err != nil {
reurn ""
}
return u.Hostname()
}

@E520 你这个是加锁的，不清楚是否可以应对一个请求反代花了很长的时间才结束，那么锁没有释放前是否就无法响应新的请求

每次请求创建一次 proxyInfo 副本就好了，可以运行加上-race 参数测试并发问题。

或者把这些参数通过 newProxy 函数传递过去也行。

```go
func proxyRequestHandler() http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
pi := &proxyInfo{}
//不是 https 的请求
if r.TLS == nil {
_, err := pi.getHostConf(getHostName(r.Host))
if err != nil {
w.WriteHeader( http.StatusBadRequest)
w.Write([]byte(err.Error()))
return
}
}

pi.requestPath = r.URL.Path
pi.requestRawQuery = r.URL.RawQuery

requestHeader := make(map[string]string)
requestHeader["Referer"] = pi.targetUrl
requestHeader["User-Agent"] = r.Header.Get("User-Agent")
requestHeader["Accept"] = r.Header.Get("Accept")
pi.requestHeader = requestHeader

//反代
proxy, err := pi.newProxy()
if err != nil {
panic(err)
}

proxy.ServeHTTP(w, r)
}
}
```

@eudore 你的方法我现在就在用的，但唯一的缺点是要查询两次 redis ，一次在 tls 的 GetCertificate 里面查询拿到 SSL 证书建立握手，然后再到后续 http 的 Handler 里面再查询一次。
有没有办法在 GetCertificate 查询后拿到的数据给到 Handler 里面使用。
如果是 http 就没有这个问题直接在 Handler 查询。现在要兼容 http 和 https 两种，希望是在 tls 的 GetCertificate 查了就不要在后面的 Handler 再查一次