91 篇博文 含有标签「后端」

import os
import re

def sanitize_filename(filename):
    """ 使用'-'替换文件名中的特殊字符和空格 """
    return re.sub(r'[^\w.-]', '-', filename)

def rename_files_in_directory(directory):
    """ 遍历目录并重命名文件 """
    for root, dirs, files in os.walk(directory):
        for filename in files:
            # 生成新文件名
            new_filename = sanitize_filename(filename)
            if new_filename != filename:
                # 构建完整的文件路径
                original_file_path = os.path.join(root, filename)
                new_file_path = os.path.join(root, new_filename)
                # 重命名文件
                os.rename(original_file_path, new_file_path)
                print(f"已将文件 {filename} 重命名为 {new_filename}")

def main():
    # 获取当前脚本的目录
    current_directory = os.path.dirname(os.path.abspath(__file__))
    # 开始重命名流程
    rename_files_in_directory(current_directory)
    print("所有文件处理完毕！")

if __name__ == '__main__':
    main()

[
    {
        "Id": "92fe41a6dfd5...",  // 容器的唯一标识符
        "Created": "2024-10-09T08:32:41.659Z",  // 容器创建的时间戳
        "Path": "docker-entrypoint.sh",  // 容器启动时执行的脚本
        "Args": ["--default-authentication-plugin=mysql_native_password"],  // 脚本参数
        "State": {
            "Status": "running",  // 容器当前状态，正在运行
            "Running": true,  // 容器是否在运行
            "Health": {
                "Status": "healthy",  // 容器健康状态为健康
                "FailingStreak": 0,  // 健康检查失败次数
                "Log": []  // 健康检查日志
            }
        },
        "Image": "mysql:8.0.36",  // 使用的MySQL镜像版本
        "Name": "/mysql_server",  // 容器名称
        "RestartCount": 0,  // 重启次数
        "HostConfig": {
            "NetworkMode": "mysql_mysql",  // 网络模式
            "PortBindings": {  // 端口绑定配置
                "3306/tcp": [{ "HostIp": "", "HostPort": "3306" }]  // 映射到主机的3306端口
            },
            "RestartPolicy": {
                "Name": "always"  // 重启策略，始终重启
            }
        },
        "Config": {
            "Env": [  // 环境变量配置
                "MYSQL_DATABASE=demo",  // 数据库名
                "MYSQL_USER=admin",  // 用户名
                "MYSQL_PASSWORD=123456",  // 用户密码
                "MYSQL_ROOT_PASSWORD=123456"  // 根密码
            ],
            "Cmd": ["--default-authentication-plugin=mysql_native_password"],  // 容器启动命令
            "Healthcheck": {  // 健康检查配置
                "Test": ["CMD", "mysqladmin", "ping", "-h", "localhost"],  // 使用mysqladmin ping测试
                "Interval": 30000000000,  // 检查间隔
                "Retries": 3  // 重试次数
            }
        },
        "NetworkSettings": {
            "IPAddress": "172.27.0.2",  // 容器分配的IP地址
            "Networks": {
                "mysql_mysql": {  // 网络配置
                    "IPAddress": "172.27.0.2",  // 网络中的IP地址
                    "Gateway": "172.27.0.1"  // 网关
                }
            }
        }
    }
]

import threading
import requests
​
​
# 下载单个 URL 的函数
def download_url(url):
    try:
        response = requests.get(url, timeout=5)
        print(f"成功下载: {url}, 内容长度: {len(response.content)}")
    except Exception as e:
        print(f"下载失败: {url}, 错误: {e}")
​
​
def main(urls):
    threads = []
    for url in urls:
        thread = threading.Thread(target=download_url, args=(url,))
        threads.append(thread)
        thread.start()
​
    for thread in threads:
        thread.join()  # 等待所有线程完成
​
​
if __name__ == "__main__":
    urls = [f"https://www.example.com/{i}" for i in range(10)]
    main(urls)

import multiprocessing
import requests
​
​
# 下载单个 URL 的函数
def download_url(url):
    try:
        response = requests.get(url, timeout=5)
        print(f"成功下载: {url}, 内容长度: {len(response.content)}")
    except Exception as e:
        print(f"下载失败: {url}, 错误: {e}")
​
​
def main(urls):
    with multiprocessing.Pool(processes=5) as pool:  # 使用进程池
        pool.map(download_url, urls)
​
​
if __name__ == "__main__":
    urls = [f"https://www.example.com/{i}" for i in range(10)]
    main(urls)

import requests
from concurrent.futures import ThreadPoolExecutor
​
​
# 下载单个 URL 的函数
def download_url(url):
    try:
        response = requests.get(url, timeout=5)
        print(f"成功下载: {url}, 内容长度: {len(response.content)}")
    except Exception as e:
        print(f"下载失败: {url}, 错误: {e}")
​
​
def main(urls):
    with ThreadPoolExecutor(max_workers=5) as executor:
        executor.map(download_url, urls)
​
​
if __name__ == "__main__":
    urls = [f"https://www.example.com/{i}" for i in range(10)]
    main(urls)

import asyncio
import aiohttp
​
​
# 异步下载单个 URL 的函数
async def download_url(session, url):
    try:
        async with session.get(url, timeout=5) as response:
            content = await response.read()
            print(f"成功下载: {url}, 内容长度: {len(content)}")
    except Exception as e:
        print(f"下载失败: {url}, 错误: {e}")
​
​
async def main(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [download_url(session, url) for url in urls]
        await asyncio.gather(*tasks)
​
​
if __name__ == "__main__":
    urls = [f"https://www.example.com/{i}" for i in range(10)]
    asyncio.run(main(urls))

server {
    listen 443 ssl;
    server_name example.com;
​
    ssl_certificate /path/to/root.crt;
    ssl_certificate_key /path/to/root.key;
​
    location / {
        root /usr/share/nginx/html;
        index index.html index.htm;
    }
}

curl -k https://example.com

#!/bin/bash

# 配置变量
KEY_FILE="root.key"         # 私钥文件名
CRT_FILE="root.crt"         # 证书文件名
CSR_FILE="root.csr"         # CSR 文件名
DAYS_VALID=365               # 证书有效天数
COUNTRY="CN"                 # 国家
STATE="Beijing"              # 省份
LOCALITY="Beijing"           # 城市
ORG="Example Corp"           # 组织
ORG_UNIT="IT Department"     # 组织单位
COMMON_NAME="harbor.com"     # 公共名称

# 生成私钥
if openssl genrsa -out "$KEY_FILE" 2048; then
    echo "私钥生成成功：$KEY_FILE"
else
    echo "私钥生成失败" >&2
    exit 1
fi

# 创建证书签名请求 (CSR)
if openssl req -new -key "$KEY_FILE" -out "$CSR_FILE" -subj "/C=$COUNTRY/ST=$STATE/L=$LOCALITY/O=$ORG/OU=$ORG_UNIT/CN=$COMMON_NAME"; then
    echo "证书签名请求生成成功：$CSR_FILE"
else
    echo "CSR 生成失败" >&2
    exit 1
fi

# 自签名证书
if openssl x509 -req -days "$DAYS_VALID" -in "$CSR_FILE" -signkey "$KEY_FILE" -out "$CRT_FILE"; then
    echo "自签名证书生成成功：$CRT_FILE"
else
    echo "证书生成失败" >&2
    exit 1
fi

echo "证书生成完毕："
echo "私钥文件：$KEY_FILE"
echo "证书文件：$CRT_FILE"

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

type User struct {
    ID          int
    PhoneNumber sql.NullString  // 使用 sql.NullString 来处理可能为 NULL 的手机号
    Email       sql.NullString  // 使用 sql.NullString 来处理可能为 NULL 的邮箱
}

func main() {
    // 假设这是数据库连接字符串
    db, err := sql.Open("mysql", "user:password@/dbname")
    if err != nil {
        panic(err)
    }
    defer db.Close()

    // 查询数据库
    rows, err := db.Query("SELECT id, phone_number, email FROM users")
    if err != nil {
        panic(err)
    }
    defer rows.Close()

    for rows.Next() {
        var user User
        // 使用 Scan 时，确保对应的字段可以接收 sql.NullString
        if err := rows.Scan(&user.ID, &user.PhoneNumber, &user.Email); err != nil {
            panic(err)
        }

        // 打印结果，如果字段为NULL，则显示为 "NULL"
        fmt.Printf("ID: %d, Phone: %s, Email: %s\n",
            user.ID,
            if user.PhoneNumber.Valid { user.PhoneNumber.String } else { "NULL" },
            if user.Email.Valid { user.Email.String } else { "NULL" },
        )
    }
}

package main

import (
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

type User struct {
    ID          uint
    PhoneNumber *string  // 使用指针允许手机号为 NULL
    Email       *string  // 使用指针允许邮箱为 NULL
}

func main() {
    // 假设这是连接数据库的DSN（数据源名）
    dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }

    // 查询所有用户
    var users []User
    result := db.Find(&users)
    if result.Error != nil {
        panic(result.Error)
    }

    // 打印用户信息
    for _, user := range users {
        fmt.Printf("ID: %d, Phone: %v, Email: %v\n", user.ID, user.PhoneNumber, user.Email)
    }
}

go build -o xApp-windows.exe

go build -o xApp-macos

GOARCH=amd64 go build -o xApp-linux-x86

GOARCH=arm64 go build -o xApp-linux-arm

SET GOARCH=386&& go build -o xApp-windows-32bit.exe

GOOS=darwin GOARCH=arm64 go build -o xApp-macos-arm

go build -ldflags "-linkmode external -extldflags -static" -o xApp

package main

import (
    "fmt"
    "golang.org/x/crypto/bcrypt"
)

func main() {
    // 原始密码
    password := "MyPassword123"

    // 加密密码
    hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
    if err != nil {
        fmt.Println("加密错误:", err)
        return
    }
    fmt.Println("加密后的密码:", string(hashedPassword))

    // 验证密码
    err = bcrypt.CompareHashAndPassword(hashedPassword, []byte(password))
    if err != nil {
        fmt.Println("密码不匹配")
    } else {
        fmt.Println("密码匹配")
    }
}

func ShrinkSlice(original []int, newLength int) []int {
    if newLength > len(original) {
        newLength = len(original)
    }
    newSlice := make([]int, newLength, newLength) // 设置新切片的长度和容量
    copy(newSlice, original[:newLength])
    return newSlice
}

func ShrinkSliceUsingAppend(original []int, newLength int) []int {
    if newLength > len(original) {
        newLength = len(original)
    }
    newSlice := make([]int, 0, newLength) // 创建一个容量为newLength的空切片
    newSlice = append(newSlice, original[:newLength]...)
    return newSlice
}

func ShrinkSliceInPlace(original []int, newLength int) []int {
    if newLength > len(original) {
        newLength = len(original)
    }
    return original[:newLength:newLength] // 设置新切片的长度和容量相同
}

func calCapacity(c, l int) (int, bool) { // usage = Deng Ming
    // 容量 <=64 缩不缩都无所谓, 因为浪费内存也浪费不了多少
    // 你可以考虑调大这个阈值, 或者调小这个阈值
    if c <= 64 {
        return c, false
    }
    // 如果容量大于 2048, 但是元素不足一半,
    // 降低为 0.625, 也就是 5/8
    // 也就是比一半多一点, 和正向扩容的 1.25 倍相呼应
    if c > 2048 && (c/l >= 2) {
        factor := 0.625
        return int(float32(c) * float32(factor)), true
    }
    // 如果在 2048 以内, 并且元素不足 1/4, 那么直接缩减为一半
    if c <= 2048 && (c/l >= 4) {
        return c / 2, true
    }
    return c, false
}

package main
​
import (
    "fmt"
    "strconv"
)
​
func main() {
    // 字符串转整数
    s := "1024"
    num, err := strconv.Atoi(s)
    if err != nil {
        fmt.Println("转换错误:", err)
    } else {
        fmt.Println("转换结果:", num)
    }
​
    // 整数转字符串
    numStr := strconv.Itoa(num)
    fmt.Println("整数转字符串:", numStr)
​
    // 使用 ParseInt 解析十六进制字符串
    hexNum, _ := strconv.ParseInt("1f4", 16, 32)
    fmt.Println("十六进制 '1f4' 转为十进制:", hexNum)
​
    // 使用 FormatInt 将数字转换为二进制表示的字符串
    binStr := strconv.FormatInt(int64(hexNum), 2)
    fmt.Println("数字转二进制字符串:", binStr)
}

package main
​
import (
    "fmt"
    "strconv"
)
​
func main() {
    // 字符串转浮点数
    floatStr := "3.14159"
    f, err := strconv.ParseFloat(floatStr, 64)
    if err != nil {
        fmt.Println("转换错误:", err)
    } else {
        fmt.Println("转换结果:", f)
    }
​
    // 浮点数转字符串
    formattedFloat := strconv.FormatFloat(f, 'f', 3, 64)
    fmt.Println("浮点数格式化:", formattedFloat)
}

package main
​
import (
    "fmt"
    "strconv"
)
​
func main() {
    // 字符串转布尔值
    boolStr := "true"
    b, err := strconv.ParseBool(boolStr)
    if err != nil {
        fmt.Println("转换错误:", err)
    } else {
        fmt.Println("转换结果:", b)
    }
​
    // 布尔值转字符串
    bStr := strconv.FormatBool(b)
    fmt.Println("布尔值转字符串:", bStr)
}