01基础004web开发二

## 1. 跨域
跨域是浏览器基于同源策略的一种安全手段。

同源：
协议相同（protocol）
主机相同（host）
端口相同（port）
当访问不是同源的服务地址时，就会发生跨域问题

![](/media/202501/2025-01-09_135714_2679650.18184288826283057.png)"

### 1.1 go-zero跨域配置
第一种
```
server := rest.MustNewServer(c.RestConf,
		rest.WithCors("http://localhost:5173"))
```
第二种
在有些情况下，我们需要传递一些自定义的header，这时候仍旧会出现跨域问题
所以我们需要自定义跨域的header
```
server := rest.MustNewServer(c.RestConf,
		rest.WithCorsHeaders("xxxx"),
	)
```
第三种
如果我们既想要自定义header，又想要控制跨域的域名
```
server := rest.MustNewServer(c.RestConf,
        //顺序不能颠倒
		rest.WithCors("http://localhost:5173"),
		rest.WithCorsHeaders("xxxx"),
	)
```
第四种
如果想要自定义跨域
```
server := rest.MustNewServer(c.RestConf,
		rest.WithCustomCors(func(header http.Header) {
			var allowOrigin = "Access-Control-Allow-Origin"
			var allOrigins = "http://localhost:5173"
			var allowMethods = "Access-Control-Allow-Methods"
			var allowHeaders = "Access-Control-Allow-Headers"
			var exposeHeaders = "Access-Control-Expose-Headers"
			var methods = "GET, HEAD, POST, PATCH, PUT, DELETE, OPTIONS"
			var allowHeadersVal = "xxxx, Content-Type, Origin, X-CSRF-Token, Authorization, AccessToken, Token, Range"
			var exposeHeadersVal = "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers"
			var maxAgeHeader = "Access-Control-Max-Age"
			var maxAgeHeaderVal = "86400"
			header.Set(allowOrigin, allOrigins)
			header.Set(allowMethods, methods)
			header.Set(allowHeaders, allowHeadersVal)
			header.Set(exposeHeaders, exposeHeadersVal)
			header.Set(maxAgeHeader, maxAgeHeaderVal)
		}, func(w http.ResponseWriter) {

}),
	)
```
## 2. 请求参数
### 2.1 form表单

```
type Request struct {
    Name    string  `form:"name"` // 必填参数
    Age     int     `form:"age,optional"` // optional定义非必填参数
}

var req Request
err := httpx.Parse(r, &req) // 解析参数
#2.2 json
type Request struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

var req Request
err := httpx.Parse(r, &req) // 解析参数
#2.3 path
type Request struct {
    Name string `path:"name"`
}

// Path定义
rest.Route{
    Method:  http.MethodGet,
    Path:    "/user/:name",
    Handler: handle,
}

var req Request
err := httpx.Parse(r, &req) // 解析参数
``
#2.4 header参数
type Request struct {
    Authorization string `header:"authorization"`
}

var req Request
err := httpx.Parse(r, &req) // 解析参数
#2.5 参数默认值
type Request struct {
    Age int `form:"age,default=18"`
}

var req Request
err := httpx.Parse(r, &req) // 解析参数
#2.6 参数枚举值
type Request struct {
    Age int `form:"age,options=18|19"`
}

var req Request
err := httpx.Parse(r, &req) // 解析参数
#2.7 参数区间定义
type Request struct {
    Age int `form:"age,range=[18:35)"`
}

var req Request
err := httpx.Parse(r, &req) // 解析参数
```
## 3. 中间件
### 3.1 内置中间件
鉴权管理中间件 AuthorizeHandler
熔断中间件 BreakerHandler
内容安全中间件 ContentSecurityHandler
解密中间件 CryptionHandler
压缩管理中间件 GunzipHandler
日志中间件 LogHandler
ContentLength 管理中间件 MaxBytesHandler
限流中间件 MaxConnsHandler
指标统计中间件 MetricHandler
普罗米修斯指标中间件 PrometheusHandler
panic 恢复中间件 RecoverHandler
负载监控中间件 SheddingHandler
超时中间件 TimeoutHandler
链路追踪中间件 TraceHandler
```
type MiddlewaresConf struct {
    Trace      bool `json:",default=true"`
    Log        bool `json:",default=true"`
    Prometheus bool `json:",default=true"`
    MaxConns   bool `json:",default=true"`
    Breaker    bool `json:",default=true"`
    Shedding   bool `json:",default=true"`
    Timeout    bool `json:",default=true"`
    Recover    bool `json:",default=true"`
    Metrics    bool `json:",default=true"`
    MaxBytes   bool `json:",default=true"`
    Gunzip     bool `json:",default=true"`
}
```
```
Name: HelloWorld.api
Host: 127.0.0.1
Port: 8080
Middlewares:
  Metrics: false
```
### 3.2 自定义中间件
```
server := rest.MustNewServer(rest.RestConf{})
defer server.Stop()

server.Use(middleware)

// 自定义的中间件
func middleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        w.Header().Add("X-Middleware", "static-middleware")
        next(w, r)
    }
}
```
## 4. redis集成
### 4.1 docker-compose部署配置
version: '3.3'
services:
  redis:
    container_name: zero-redis-node
    image: redis:latest
    restart: always
    ports:
      - "6379:6379"
    volumes:
      - ./volume/redis/dаta:/root/redis
    environment:
      - REDIS_PASSWORD=mszlu
      - REDIS_PORT=6379
      - REDIS_DATABASES=16
  redis-cluster-master:
    image: redis:latest
    container_name: redis-cluster-master
    restart: always
    command: redis-server --port 7000 --requirepass mszlu  --appendonly yes
    ports:
      - 7000:7000
    volumes:
      - ./volume/redis-cluster/data:/data
    networks:
      - redis-cluster
  redis-cluster-slave1:
    image: redis:latest
    container_name: redis-slave-1
    restart: always
    command: redis-server --slaveof redis-cluster-master 7000 --port 7001  --requirepass mszlu --masterauth mszlu  --appendonly yes
    ports:
      - 7001:7001
    depends_on:
      - master
    volumes:
      - ./volume/redis-cluster/data:/data
    networks:
      - redis-cluster
networks:
  redis-cluster:

#4.2 单节点
go-zero内置配置：

RedisConf struct {
		Host     string
		Type     string `json:",default=node,options=node|cluster"`
		Pass     string `json:",optional"`
		Tls      bool   `json:",optional"`
		NonBlock bool   `json:",default=true"`
		// PingTimeout is the timeout for ping redis.
		PingTimeout time.Duration `json:",default=1s"`
	}
Host：Redis 服务地址 ip:port, 如果是 Redis Cluster 则为 ip1:port1,ip2:port2,ip3:port3
Type：node 单节点 Redis ，cluster Redis 集群
Pass：认证密码
Tls：是否开启tls
NonBlock：是否以非阻塞模式启动
PingTimeout：ping超时时间，用于检测redis是否连接成功
go get github.com/redis/go-redis/v9
RedisConfig:
  Host: "127.0.0.1:6379"
  Pass: "mszlu"
  Type: "node"
  Tls: false
  NonBlock: false
  PingTimeout: 1s
package db

import "github.com/zeromicro/go-zero/core/stores/redis"

func NewRedis(conf redis.RedisConf) *redis.Redis {
	return redis.MustNewRedis(conf)
}

servicecontext中注入：

package svc

import (
	"github.com/zeromicro/go-zero/core/stores/redis"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
	"user-api/internal/config"
	"user-api/internal/db"
)

type ServiceContext struct {
	Config      config.Config
	Conn        sqlx.SqlConn
	RedisClient *redis.Redis
}

func NewServiceContext(c config.Config) *ServiceContext {
	sqlConn := db.NewMysql(c.MysqlConfig)
	redisClient := db.NewRedis(c.RedisConfig)
	return &ServiceContext{
		Config:      c,
		Conn:        sqlConn,
		RedisClient: redisClient,
	}
}

改造登录代码：

func (l *LoginLogic) Login(req *types.LoginReq) (resp *types.LoginResp, err error) {
	// todo: add your logic here and delete this line
	userModel := user.NewUserModel(l.svcCtx.Conn)
	u, err := userModel.FindByUsernameAndPwd(l.ctx, req.Username, req.Password)
	if err != nil {
		l.Logger.Error(err)
		return nil, biz.DBError
	}
	if u == nil {
		return nil, biz.NameOrPwdError
	}
	//登录成功 生成token
	secret := l.svcCtx.Config.Auth.Secret
	expire := l.svcCtx.Config.Auth.Expire
	token, err := biz.GetJwtToken(secret, time.Now().Unix(), expire, u.Id)
	if err != nil {
		l.Logger.Error(err)
		return nil, biz.TokenError
	}
    //把token存入redis
	err = l.svcCtx.RedisClient.SetexCtx(context.Background(), "token:"+token, strconv.FormatInt(u.Id, 10), int(expire))
	if err != nil {
		return nil, biz.RedisError
	}
	resp = &types.LoginResp{
		Token: token,
	}
	return
}
测试

## 4.3 集群
集群方式只需要改配置即可，go-zero对集群和单机做了适配。

go-zero内置redis的缺陷：

不能选择redis数据库
不能配置连接池
对原生go-redis配置项不能自定义
实际开发中，如果对配置项需要精细化控制，建议直接使用go-redis库即可，并且自行对go-redis进行封装