之前讲解过两种升级方式和原理



```go
package ws 
  
 import ( 
         "github.com/gorilla/websocket" 
         "net/http" 
 ) 
  
 var upgrade = websocket.Upgrader{ 
         ReadBufferSize:  1024, 
         WriteBufferSize: 1024, 
         CheckOrigin: func(r *http.Request) bool { 
                 return true 
         }, 
 } 
  
 var ( 
         Websocket *websocket.Conn 
         err       error 
 ) 
  
 func App(w http.ResponseWriter, r *http.Request) (*websocket.Conn, error) { 
         Websocket, err = upgrade.Upgrade(w, r, nil) 
         return Websocket, err 
 }
```

websocket快速升级

用go-redis连接redis



```go
package redis 
  
 import ( 
         "github.com/go-redis/redis" 
         "im-services/internal/config" 
         "log" 
         "time" 
 ) 
  
 var RedisDB *redis.Client 
  
 // InitClient redis 连接 
 func InitClient() { 
         RedisDB = redis.NewClient(&redis.Options{ 
                 Network:      "tcp", 
                 Addr:         config.Conf.Redis.Host + ":" + config.Conf.Redis.Port, 
                 Password:     config.Conf.Redis.Password, 
                 DB:           config.Conf.Redis.DB, 
                 PoolSize:     config.Conf.Redis.Poll, //连接池 默认为4倍cpu数 
                 MinIdleConns: config.Conf.Redis.Conn, //在启动阶段创建指定数量的Idle连接，并长期维持idle状态的连接数不少于指定数量 
                 DialTimeout:  5 * time.Second, 
                 ReadTimeout:  5 * time.Second, 
                 WriteTimeout: 5 * time.Second, 
                 PoolTimeout:  5 * time.Second, 
         }) 
         _, err := RedisDB.Ping().Result() 
  
         if err != nil { 
                 log.Fatalln(err) 
         } 
 }
```

redis连接

利用viper进行配置热加载示例，以后直接复制粘贴即可





```go
package config 
  
 import ( 
         "github.com/fsnotify/fsnotify" 
         "github.com/spf13/viper" 
 ) 
  
 type Config struct { 
         Server ServerConf 
         Mysql  MysqlConf 
         Log    LogConf 
         JWT    JWTConf 
         Redis  RedisConf 
         Mail   MailConf 
         Kafka  KafkaConf 
         Nsq    NsqConf 
         QiNiu  QiNiuConfig 
         Github GithubConfig 
         GoBot  BotConfig 
         Gitee  GiteeConfig 
 } 
  
 type ServerConf struct { 
         Name          string `json:"name"` 
         Listen        string `json:"listen"` 
         Mode          string `json:"mode"` 
         Env           string `json:"env"` 
         Lang          string `json:"lang"` 
         CoroutinePoll int    `json:"coroutinePoll"` 
         Node          string `json:"node"` 
         ServiceOpen   bool   `json:"serviceOpen"` 
         GrpcListen    string `json:"grpcListen"` 
         FilePath      string `json:"filePath"` 
 } 
  
 type JWTConf struct { 
         Secret string `json:"secret"` 
         Ttl    int64  `json:"ttl"` 
 } 
  
 type MysqlConf struct { 
         Host     string `json:"host"` 
         Port     string `json:"port"` 
         Username string `json:"username"` 
         Password string `json:"password"` 
         Database string `json:"database"` 
         Charset  string `json:"charset"` 
 } 
  
 type LogConf struct { 
         Level     string `json:"level"` 
         Type      string `json:"type"` 
         FileName  string `json:"filename"` 
         MaxSize   int    `json:"maxSize"` 
         MaxBackup int    `json:"maxBackup"` 
         MaxAge    int    `json:"maxAge"` 
         Compress  bool   `json:"compress"` 
 } 
  
 type RedisConf struct { 
         Host     string `json:"host"` 
         Port     string `json:"port"` 
         Password string `json:"password"` 
         DB       int    `json:"db"` 
         Poll     int    `json:"poll"` 
         Conn     int    `json:"conn"` 
 } 
  
 type MailConf struct { 
         Driver     string `json:"driver"` 
         Host       string `json:"host"` 
         Name       string `json:"name"` 
         Port       int    `json:"port"` 
         Password   string `json:"password"` 
         Encryption string `json:"encryption"` 
         FromName   string `json:"fromName"` 
 } 
  
 type KafkaConf struct { 
         Host string `json:"host"` 
         Port string `json:"port"` 
 } 
  
 type NsqConf struct { 
         LookupHost string `json:"lookupHost"` 
         NsqHost    string `json:"nsqHost"` 
 } 
  
 type QiNiuConfig struct { 
         AccessKey string `json:"access_key"` 
         SecretKey string `json:"secretKey"` 
         Bucket    string `json:"bucket"` 
         Domain    string `json:"domain"` 
 } 
  
 type GithubConfig struct { 
         ClientId     string `json:"clientId"` 
         ClientSecret string `json:"clientSecret"` 
         RedirectUrl  string `json:"redirectUrl"` 
 } 
  
 type BotConfig struct { 
         Email    string `json:"email"` 
         Password string `json:"password"` 
         Name     string `json:"name"` 
         Avatar   string `json:"avatar"` 
 } 
 type GiteeConfig struct { 
         ClientId     string `json:"clientId"` 
         ClientSecret string `json:"clientSecret"` 
         RedirectUrl  string `json:"redirectUrl"` 
 } 
  
 var Conf = &Config{} 
  
 // InitConfig 初始化配置函数 
 func InitConfig(configPath string) *Config { 
  
         // 设置文件类型 
         viper.SetConfigType("yaml") 
  
         // 读取文件配置 
         viper.SetConfigFile(configPath) 
  
         // 判断是否读取成功 
         err := viper.ReadInConfig() 
         if err != nil { 
                 panic(err) 
         } 
  
         // 将配置解析到Struct 
         err = viper.Unmarshal(&Conf) 
         if err != nil { 
                 panic(err) 
         } 
  
         // 热加载配置信息 
         viper.WatchConfig() 
         viper.OnConfigChange(func(in fsnotify.Event) { 
                 err = viper.Unmarshal(&Conf) 
                 if err != nil { 
                         panic(err) 
                 } 
         }) 
  
         return Conf 
  
 } 
  
 func IsLocal() bool { 
         return Conf.Log.Level == "local" 
 } 
  
 func IsProduction() bool { 
         return Conf.Log.Level == "production" 
 } 
  
 func IsTesting() bool { 
         return Conf.Log.Level == "testing" 
 }
```

viper进行配置文件热加载

Webhook 是一种用于实时通信和数据传递的技术。它允许应用程序通过 HTTP 协议将数据发送到另一个应用程序。Webhook 的基本工作原理如下：



1. 应用程序 A 注册一个 Webhook，提供一个 URL 给应用程序 B。
2. 应用程序 B 在某个事件发生时，将相关数据 POST 到应用程序 A 提供的 URL。
3. 应用程序 A 接收到 POST 请求后，可以对数据进行处理，执行相应的操作。

Webhook 可以用于实现许多不同的功能和应用场景，例如：

- 实时通知：应用程序 A 可以注册 Webhook 接收来自应用程序 B 的实时通知，如新消息、新订单、系统事件等。
- 数据同步：当应用程序 B 中的数据发生变化时，可以通过 Webhook 将更新的数据发送给应用程序 A，以保持数据的同步。
- 自动化操作：应用程序 A 可以根据接收到的 Webhook 数据执行自动化操作，如发送电子邮件、生成报告、更新数据库等。

Webhook 提供了一种简单而有效的方式，让应用程序之间能够实时交互和共享数据，而无需轮询或手动检查更新。它在许多 Web 应用程序、消息平台和开发工具中被广泛使用。

webhook

前端背景图片全屏



```
.back-image {
        background-image: url("./mbvwwo0zubz.jpg");
        background-size: cover;
        background-repeat: no-repeat;
        background-position: center center;
    }
```

在 CSS 文件中，我们使用 background-image 属性设置背景图像的路径，并使用 background-size: cover; 来让图像充满整个容器。background-repeat: no-repeat; 防止图像重复，而 background-position: center center; 将图像居中显示。

在 CSS 中，使用本地文件路径作为背景图像的 URL 是不可行的。浏览器无法直接访问本地文件系统中的图像，因此无法显示图像。

为了在网页中显示背景图像，你应该将图像文件放在 Web 服务器上，并使用服务器上的相对路径或绝对 URL 来引用图像。

假设你将图像文件 `mbvwwo0zubz.jpg` 放在 Flask 应用的静态文件夹中，你可以使用相对路径来引用它。例如，如果图像文件位于 `static/image/mbvwwo0zubz.jpg`，你可以按照以下方式修改 CSS：

```css
body {
    font-family: 'Arial', sans-serif;
    background-color: #f5f5f5;
    margin: 0;
    display: flex;
    align-items: center;
    justify-content: center;
    height: 100vh;
    background-image: url('../static/image/mbvwwo0zubz.jpg');
    background-repeat: no-repeat;
    background-size: cover;
}
```