标签 golang 下的文章

2024-08-12

由于原始查询的需求较为宽泛，并未给出具体的技术问题，因此我将提供一个使用Python Flask框架创建简单美食网站的示例。这个示例不会涉及数据库操作，但会展示如何设置一个基本的网站，并提供一个简单的接口来展示美食信息。




from flask import Flask, render_template
 
app = Flask(__name__)
 
# 美食信息列表
foods = [
    {'name': '西红柿炒鸡蛋', 'category': '中西菜', 'description': '清香色香的西红柿，配上鲜嫩的鸡蛋', 'rating': 4.5},
    {'name': '意大利面', 'category': '意菜', 'description': '口感丰富的意大利面', 'rating': 4.2},
    {'name': '红烧肉', 'category': '中国菜', 'description': '口感浓郁的红烧肉', 'rating': 4.0},
    # 更多美食信息...
]
 
@app.route('/')
def index():
    return render_template('index.html', foods=foods)
 
if __name__ == '__main__':
    app.run(debug=True)

在这个例子中，我们创建了一个包含三道美食信息的列表。然后，我们定义了一个路由/，当用户访问网站首页时，它会渲染一个名为index.html的模板，并传递foods列表作为参数。

index.html模板可能如下所示：




<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>美食网站</title>
</head>
<body>
    <h1>欢迎来到美食网站</h1>
    <ul>
        {% for food in foods %}
        <li>
            <h2>{{ food.name }} - {{ food.rating }}星</h2>
            <p>{{ food.description }}</p>
        </li>
        {% endfor %}
    </ul>
</body>
</html>

这个简单的网站不包含数据库操作，因此不适合大量的美食信息存储和复杂的用户交互。如果需要更复杂的功能，你需要引入数据库（如SQLAlchemy），以及其他相关的Flask扩展。

- 阅读更多 -

Django框架之Ajax进阶

System

2024-08-12

所有,ajax

在Django中使用Ajax进行数据的增删改查操作，可以通过编写JavaScript代码来实现前端与后端的异步通信。以下是一个使用jQuery实现的Ajax进阶示例：

假设我们有一个Django视图，用于处理Ajax请求并返回JSON响应：




# views.py
from django.http import JsonResponse
from .models import MyModel
 
def my_model_list(request):
    if request.method == 'GET':
        data = list(MyModel.objects.values())
        return JsonResponse(data, safe=False)

以下是使用jQuery编写的Ajax调用该视图的示例：




<!-- HTML页面 -->
<button id="fetch-data">获取数据</button>
<div id="data-container"></div>
 
<script src="https://code.jquery.com/jquery-3.5.1.min.js"></script>
<script>
$(document).ready(function(){
    $('#fetch-data').click(function(){
        $.ajax({
            url: '/my_model_list/',  // Django视图的URL
            type: 'GET',
            dataType: 'json',
            success: function(data) {
                var html = '';
                $.each(data, function(key, value) {
                    html += '<p>' + value.field_name + '</p>';
                });
                $('#data-container').html(html);
            },
            error: function() {
                alert('有错误发生！');
            }
        });
    });
});
</script>

在这个示例中，我们定义了一个按钮和一个用于显示数据的div容器。当按钮被点击时，通过Ajax请求获取数据，然后遍历数据并将其添加到div容器中。

注意：

确保在Django的urls.py中配置了相应的路由。
确保服务器运行中，并且你的Django应用已经正确地部署了这个视图。
确保你的Django项目允许跨域请求。
这个示例使用了jQuery库，确保在HTML中正确引入了该库。

- 阅读更多 -

利用GoAccess实现中文环境下的实时Web日志分析

System

2024-08-12

所有,golang




package main
 
import (
    "os"
    "os/exec"
    "path/filepath"
    "time"
)
 
// 设置日志文件路径
func setLogFilePath() string {
    return filepath.Join(os.TempDir(), "goaccess.log")
}
 
// 启动GoAccess实时分析
func startGoAccess(logFilePath string) {
    cmd := exec.Command("goaccess", logFilePath, "--log-file", "--real-time-html", "-o", "-", "--date-format=iso")
    cmd.Env = append(os.Environ(), "LANG=zh_CN.UTF-8")
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    _ = cmd.Start()
    go func() {
        _ = cmd.Wait() // 等待命令执行完成
    }()
}
 
func main() {
    logFilePath := setLogFilePath()
    startGoAccess(logFilePath)
 
    // 模拟日志生成
    for {
        time.Sleep(1 * time.Second)
        _ = os.WriteFile(logFilePath, []byte("GET /some/path\n"), os.ModeAppend)
    }
}

这段代码首先定义了日志文件的路径，然后启动了GoAccess，并设置了环境变量以支持中文显示。之后，代码模拟生成日志文件，并定期写入日志数据。GoAccess运行时会实时分析这些日志数据，并在控制台输出实时报告。

- 阅读更多 -

Django框架之Ajax基础

System

2024-08-12

所有,ajax

在Django中使用Ajax进行前后端分离交互是一种常见的做法。以下是一个简单的示例，展示了如何在Django视图中使用Ajax发送GET请求并接收JSON响应。

首先，在HTML中，我们可以使用JavaScript或者JQuery发送Ajax请求：




<button id="ajaxButton">点击发送Ajax请求</button>
 
<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
<script>
$(document).ready(function(){
    $("#ajaxButton").click(function(){
        $.ajax({
            url: '/your-django-view-url/',  // Django视图的URL
            type: 'GET',
            dataType: 'json',
            success: function(data) {
                console.log(data);  // 这里的data是后端返回的JSON数据
            },
            error: function() {
                console.log('Error occurred');
            }
        });
    });
});
</script>

然后，在Django的views.py中，我们创建一个视图来处理Ajax请求并返回JSON响应：




from django.http import JsonResponse
 
def your_django_view(request):
    # 这里可以根据需要处理请求，例如从数据库获取数据
    response_data = {'key': 'value'}  # 示例数据
    return JsonResponse(response_data)

最后，在urls.py中配置URL：




from django.urls import path
from .views import your_django_view
 
urlpatterns = [
    path('your-django-view-url/', your_django_view, name='your_django_view'),
]

这样就完成了一个简单的Ajax请求示例。当用户点击按钮时，JavaScript会通过Ajax向Django后端发送请求，后端处理后返回JSON格式的响应，然后JavaScript可以在成功回调函数中处理这个响应。

- 阅读更多 -

[go-zero] 简单微服务调用

System

2024-08-12

所有,golang

在go-zero框架中，微服务之间的调用通常使用rpc（远程过程调用）。以下是一个简单的例子，展示了如何在两个服务之间进行rpc调用。

首先，定义rpc接口：




// api/user/user.go
 
type User struct {
    UserId int64 `json:"user_id"`
    Name   string `json:"name"`
}
 
type UserService interface {
    GetUser(userId int64) (*User, error)
}

实现rpc服务端：




// service/user/user.go
 
type UserServiceLogic struct {
    svcCtx *svc.ServiceContext
}
 
func (l *UserServiceLogic) GetUser(req *user.UserReq) (*user.User, error) {
    // 实现获取用户逻辑
    user := &user.User{
        UserId: req.UserId,
        Name:   "John Doe",
    }
    return user, nil
}

注册rpc服务：




// service/user/handler.go
 
func RegisterHandlers(engine *rest.Server, serverCtx *svc.ServiceContext) {
    userHandler := user.NewUserServiceHandler(serverCtx)
    engine.AddRoute(http.MethodGet, "/user/{userId}", userHandler.GetUser)
    // 注册其他handler
}

在rpc客户端调用：




// cmd/caller/main.go
 
func main() {
    client := user.NewUserService("svc.user", client.UseEtcdAsSource("http://localhost:2379"))
    user, err := client.GetUser(context.Background(), &user.UserReq{UserId: 1})
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Received user: %v\n", user)
}

在这个例子中，我们定义了一个简单的UserService，并在UserServiceLogic中实现了GetUser方法。然后我们在rpc服务端注册了这个逻辑处理器，并在客户端使用etcd作为服务发现，调用远程服务获取用户信息。

注意：这只是一个简化的例子，实际的go-zero框架应用可能涉及更多的配置和细节。

- 阅读更多 -

【Python】【进阶篇】10、Django中间件

System

2024-08-12

所有,中间件

Django中间件是一个轻量级的插件系统，可以介入Django的请求和响应处理过程，修改Django的输入或输出。

要创建一个自定义的Django中间件，你需要定义一个遵守特定结构的类，该类包含以下方法中的一个或多个：

process_request(self, request)
process_view(self, request, view_func, view_args, view_kwargs)
process_template_response(self, request, response)
process_exception(self, request, exception)
process_response(self, request, response)

以下是一个简单的中间件示例，它在每个响应中设置一个自定义的HTTP头：




# my_middleware.py
from django.utils.deprecation import MiddlewareMixin
 
class CustomMiddleware(MiddlewareMixin):
    def process_response(self, request, response):
        response['Custom-Header'] = 'My Custom Value'
        return response

要使用这个中间件，你需要将其添加到你的Django项目的settings.py文件中的MIDDLEWARE配置类列表中：




# settings.py
MIDDLEWARE = [
    # ...
    'path.to.my_middleware.CustomMiddleware',
    # ...
]

这个中间件示例演示了如何在process_response方法中修改响应。每个方法都有其特定的用途，例如process_request可以用于检查请求并决定是否要修改它，或者直接返回HttpResponse以停止进一步处理。

记住，中间件方法应该返回None或HttpResponse对象，以允许请求-响应循环继续。如果返回HttpResponse对象，它也可以返回修改后的HttpResponse对象。

System

2024-08-12

所有,mysql




from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
from apscheduler.executors.pool import ThreadPoolExecutor, ProcessPoolExecutor
from apscheduler.schedulers.background import BackgroundScheduler
 
# 创建Scheduler并设置作业存储和执行器
scheduler = BackgroundScheduler(jobstores={
    'default': SQLAlchemyJobStore(url='sqlite:///jobs.sqlite')
})
scheduler.add_executor('processpool', ProcessPoolExecutor(max_workers=5))
scheduler.add_executor('threadpool', ThreadPoolExecutor(max_workers=10))
scheduler.start()
 
# 添加作业
job = scheduler.add_job(my_job_function, 'interval', minutes=2)
 
# 运行时，确保调用 scheduler.shutdown() 以关闭调度器

这个示例展示了如何在Django中使用重写的SQLAlchemyJobStore来替代默认的作业存储方式。这里使用了SQLite数据库作为例子，但在生产环境中你可能需要使用更健壮的数据库比如PostgreSQL或MySQL。代码首先创建了一个Scheduler实例，并设置了使用SQLAlchemyJobStore作为作业存储方式，同时添加了进程池和线程池执行器。最后，代码添加了一个示例作业并启动了调度器。在实际应用中，你需要替换my_job_function为你自己的作业处理函数，并设置合适的触发条件。

- 阅读更多 -

Go语言的JSON包与数据解析

System

2024-08-12

所有,golang




package main
 
import (
    "encoding/json"
    "fmt"
    "log"
)
 
// 定义一个结构体来映射JSON数据
type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}
 
func main() {
    // 创建一个Person实例
    person := Person{
        Name: "Alice",
        Age:  30,
    }
 
    // 将Person实例编码为JSON
    jsonData, err := json.Marshal(person)
    if err != nil {
        log.Fatalf("JSON marshaling failed: %s", err)
    }
    fmt.Printf("JSON Data: %s\n", jsonData)
 
    // 解码JSON数据到Person结构体实例
    var decodedPerson Person
    if err := json.Unmarshal(jsonData, &decodedPerson); err != nil {
        log.Fatalf("JSON unmarshaling failed: %s", err)
    }
    fmt.Printf("Decoded Person: %+v\n", decodedPerson)
}

这段代码首先定义了一个Person结构体，用来映射JSON数据中的name和age字段。然后创建了一个Person实例，并使用json.Marshal函数将其编码为JSON。接着，它使用json.Unmarshal函数将JSON数据解码回Person结构体实例。这个过程展示了如何在Go语言中处理JSON数据的基本方法。

- 阅读更多 -

go中实现日志级别与切割，日志配置热生效，pprof的技术解析

System

2024-08-12

所有,golang

在Go中实现日志级别和切割的一个常用库是logrus。以下是一个简单的例子，展示如何配置logrus以实现日志级别和滚动文件切割。




package main
 
import (
    "github.com/sirupsen/logrus"
    "gopkg.in/natefinch/lumberjack.v2"
    "time"
)
 
// 配置日志
func ConfigureLogger() {
    logrus.SetFormatter(&logrus.JSONFormatter{})
    logrus.SetLevel(logrus.InfoLevel) // 设置日志级别
 
    // 配置滚动文件切割
    logFileLoc := "/path/to/log/directory/app.log"
    rotationOpt := &lumberjack.Logger{
        Filename:   logFileLoc,
        MaxSize:    500, // 在切割之前，文件的最大大小（以MB为单位）
        MaxBackups: 3,   // 保留的旧日志文件的最大个数
        MaxAge:     28,  // 保留的最大天数
        Compress:   true, // 是否压缩旧日志文件
    }
 
    logrus.SetOutput(&lumberjack.Logger{
        Filename:   logFileLoc,
        MaxSize:    500, // 在切割之前，文件的最大大小（以MB为单位）
        MaxBackups: 3,   // 保留的旧日志文件的最大个数
        MaxAge:     28,  // 保留的最大天数
        Compress:   true, // 是否压缩旧日志文件
    })
}
 
func main() {
    ConfigureLogger()
 
    logrus.WithFields(logrus.Fields{
        "animal": "walrus",
    }).Info("A walrus appears")
 
    // 模拟时间流逝，以便滚动日志
    time.Sleep(7*24*time.Hour + 1*time.Second) // 等待7天后的1秒
 
    logrus.WithFields(logrus.Fields{
        "animal": "walrus",
    }).Info("Another walrus appears")
}

在这个例子中，logrus被配置为JSON格式输出，并且设置了日志文件滚动的策略。lumberjack.Logger是一个实现了io.Writer接口的结构体，它能够管理日志文件的滚动。通过设置MaxSize、MaxBackups和MaxAge，我们定义了如何以及何时创建新的日志文件。

要实现配置热生效，你可以考虑使用第三方库，如viper，来从配置文件中加载日志配置，并在运行时监控配置文件的变化来动态更新日志配置。

关于pprof的技术解析，它是Go语言的性能分析工具。你可以在你的Go程序中导入net/http/pprof包来启动一个http服务，通过这个服务可以获取程序的运行时间切片、内存分配等信息。以下是一个简单的pprof服务启动示例：




package main
 
import (
    "net/http"
    _ "net/http/pprof"
)
 
func main() {
    go func() {
        http.ListenAndServe("localhost:6060", nil)
    }()
 
    // 你的程序其他代码
}

启动程序后，你可以通过访问http://localhost:6060/debug/pprof/来获取各种性能分析信息。例如，

- 阅读更多 -

【Go】用 Go 原生以及 Gorm 读取 SQLCipher 加密数据库

System

2024-08-12

所有,golang




package main
 
import (
    "database/sql"
    "fmt"
    "log"
 
    _ "github.com/mutecomm/go-sqlcipher"
)
 
func main() {
    // 使用 SQLCipher 驱动打开数据库
    db, err := sql.Open("sqlcipher", "./example.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
 
    // 设置数据库密码
    if _, err := db.Exec("PRAGMA key = 'your-password-here'"); err != nil {
        log.Fatal(err)
    }
 
    // 打开数据库
    if err := db.Ping(); err != nil {
        log.Fatal(err)
    }
 
    // 查询数据库
    rows, err := db.Query("SELECT id, name FROM users")
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()
 
    for rows.Next() {
        var id int
        var name string
        if err := rows.Scan(&id, &name); err != nil {
            log.Fatal(err)
        }
        fmt.Printf("ID: %d, Name: %s\n", id, name)
    }
 
    if err := rows.Err(); err != nil {
        log.Fatal(err)
    }
}

这段代码演示了如何使用 Go 原生的 database/sql 包和 Gorm ORM 来读取一个加密的 SQLCipher 数据库。首先，我们使用 sql.Open 函数以 SQLCipher 驱动打开数据库，然后通过 PRAGMA key 设置密码，并通过 Ping 方法检查数据库是否可以正常访问。接着，我们执行一个简单的查询操作，并遍历结果集，打印出每一行的内容。最后，我们检查并处理可能出现的错误。

- 阅读更多 -