Qt使用QSqlDatabase连接MySQL实现增删改查功能

2025-07-07 17:50
文章标签 实现 mysql 使用 qt 功能 连接 改查 增删 database qsqldatabase

本文主要是介绍Qt使用QSqlDatabase连接MySQL实现增删改查功能，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《Qt使用QSqlDatabase连接MySQL实现增删改查功能》这篇文章主要为大家详细介绍了Qt如何使用QSqlDatabase连接MySQL实现增删改查功能,文中的示例代码讲解详细,感兴趣的小伙伴...

一、创建数据表

数据库名：

我们先创建一个数据库，名字叫 game_db：

CREATE DATABASE IF NOT EXISTS game_db DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
USE game_db;

创建玩家表：players

CREATE TABLE players PnCNA(
    player_id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(32) NOT NULL UNIQUE,
    password_hash VARCHAR(64) NOT NULL,
    nickname VARCHAR(32),
    level INT DEFAULT 1,
    experience INT DEFAULT 0,
    gold INT DEFAULT 0,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

插入 20 条玩家信息 SQL 语句：

INSERT INTO players (username, password_hash, nickname, level, experience, gold) VALUES
('user001', MD5('password1'), 'Knight001', 5, 1200, 500),
('user002', MD5('password2'), 'Mage002', 3, 800, 300),
('user003', MD5('password3'), 'Archer003', 7, 1800, 750),
('user004', MD5('password4'), 'Rogue004', 2, 400, 100),
('user005', MD5('password5'), 'Cleric005', 10, 3200, 1200),
('user006', MD5('password6'), 'Paladin006', 4, 950, 400),
('user007', MD5('password7'), 'Hunter007', 6, 1400, 600),
('user008', MD5('password8'), 'Druid008', 8, 2200, 900),
('user009', MD5('password9'), 'Monk009', 9, 2500, 1000),
('user010', MD5('password10'), 'Barbarian010', 1, 100, 50),
('user011', MD5('password11'), 'Warrior011', 5, 1300, 550),
('user012', MD5('password12'), 'Sorcerer012', 3, 700, 300),
('user013', MD5('password13'), 'Assassin013', 6, 1600, 650),
('user014', MD5('password14'), 'Priest014', 7, 1900, 800),
('user015', MD5('password15'), 'Ranger015', 2, 500, 200),
('user016', MD5('password16'), 'Berserker016', 4, 1100, 450),
('user017', MD5('password17'), 'Necromancer017', 8, 2300, 950),
('user018', MD5('password18'), 'Templar018', 9, 2700, 1100),
('user019', MD5('password19'), 'Shaman019', 10, 3000, 1250),
('user020', MD5('password20'), 'Witch020', 1, 200, 100);

表中结果如下所示：

Qt使用QSqlDatabase连接MySQL实现增删改查功能

二、连接MySQL数据库

database_manager.h

#ifndef DATABASEMANAGER_H
#define DATABASEMANAGER_H

#include <QObject>
#include <QMutex>
#include <QSqlDatabase>
#include <QSqlError>

enum DatabaseType {
    MySQL = 0,
    SQLite,
    PostgreSQL,
    // 可扩展更多类型
};

typedef struct stConnectParams {
    DatabaseType dbType;

    QString strHostName;
    QString strDbName;
    QString strUserName;
    QString strPassword;
    QString strConnectionName;

    int port;
} ConnectParams;

class DatabaseManager : public QObject
{
    Q_OBJECT
public:
    static DatabaseManager& instance();

    void initConnectionParams(const ConnectParams& connectParams);
    void initializeConnection();

private:
    explicit DatabaseManager(QObject *parent = nullptr);
    ~DatabaseManager();
    DatabaseManager(const DatabaseManager&) = delete;
    DatabaseManager& operator =(const DatabaseManager&) = delete;
    DatabaseManager(const DatabaseManager&&) = delete;
    DatabaseManager& operator =(const DatabaseManager&&) = delete;

signals:

private:
    ConnectParams m_connectParams;
};

database_manager.cpp

#include "database_manager.h"

#include <QDebug>

DatabaseManager::DatabaseManager(QObject *parent) : QObject(parent)
{

}


DatabaseManager::~DatabaseManager()
{

}

DapythontabaseManager& DatabaseManager::instance()
{
    static DatabaseManager instance;
    return instance;
}

void DatabaseManager::initConnectionParams(const ConnectParams& connectParams)
{
    m_connectParams.dbType = connectParams.dbType;
    m_connectParams.strHostName = connectParams.strHostName;
    m_connectParams.strDbName = connectParams.strDbName;
    m_connectParams.strUserName = connectParams.strUserName;
    m_connectParams.strPassword = connectParams.strPassword;
    m_connectParams.strConnectionName = connectParams.strConnectionName;
    m_connectParams.port = connectParams.port;
}

void DatabaseManager::initializeConnection()
{
    if (QSqlDatabase::contains(m_connectParams.strConnectionName)) {
        qDebug() << "db:" << m_connectParams.strConnectionName << "already connected";
        return;
    }

    QString strDriver;
    switch (m_connectParams.dbType) {
    case DatabaseType::SQLite:
        strDriver = "QSQLITE";
        break;
    case DatabaseType::MySQL:
        strDriver = "QMYSQL";
        break;
    case DatabaseType::PostgreSQL:
        strDriver = "QPSQL";
        break;
    }

    if (strDriver.isEmpty()) {
        qDebug() << "can't find driver";
        return;
    }

     QSqlDatabase db = QSqlDatabase::addDatabase(strDriver, m_connectParams.strConnectionName);

    if (m_connectParams.dbType == DatabaseType::SQLite) {
        db.setDatabaseName(m_connectParams.PnCNAstrDbName); // SQLite只需数据库文件路径
    } else {
        db.setConnectOptions("MYSQL_OPT_CONNECT_TIMEOUT=5;"
                                "MYSQL_OPT_READ_TIMEOUT=5;"
                                "MYSQL_OPT_WRITE_TIMEOUT=5;");
        db.setHostName(m_connectParams.strHostName);
        db.setPort(m_connectParams.port);
        db.setDatabaseName(m_connectParams.strDbName);
        db.setUserName(m_connectParams.strUserName);
        db.setPassword(m_connectParams.strPassword);
    }

    if (!db.open()) {
        qDebug() << "Database connection failed:" << db.lastError().text();
    } else {
        qDebug() << "Database connected successfully!";
    }
}

三、封装成一个完整的轻量级 ORM 风格类

什么是ORM 模型类的？

ORM（Object-Relational Mapping）模型类的作用，是将数据库中的表与 C++（或其他语言）中的类进行映射和封装，让你能像操作普通对象那样操作数据库数据，避免直接拼接 SQL 字符串，提高代码的可读性、可维护性、安全性和抽象性。

ORM 模型类的作用总结如下：

3.1 表结构 → 类结构

ORM 会把数据库表（如 users）映射成一个类（如 User），表字段对应类成员或字段名：

// 数据库表字段
// id | name | age

// ORM类字段
QVariantMap row;
row["id"] = 1;
row["name"] = "Alice";
row["age"] = 30;

3.2 简化 SQL 操作

让你写这样的代码：

userModel.insert({{"name", "Tom"}, {"age", 25}});

而不需要写繁琐的 SQL：

INSERT INTO users (name, age) VALUES ('Tom', 25);

目标功能：

  • 封装成类 OrmModel 或基类 OrmBase
  • 支持设置数据库连接、表名
  • 支持 select / insert / update / delete 等基础操作
  • 使用 QVariantMap 传入/返回数据
  • ORM风格：调用 model.select(…) 而不是手写 SQL 字符串

类定义：OrmBase

#ifndef DBORMBASE_H
#define DBORMBASE_H

#include <QObject>
#include <QSqlDatabase>
#include <QVariantMap>
#include <QVariantList>

class DbOrmBase : public QObject
{
    Q_OBJECT
public:
    explicit DbOrmBase(const QString &tableName, const QString &connectionName);
    ~DbOrmBase();

    // CRUD
    QVariantList select(const QString &strWhereClause = "", const QStringList &columns = {});
    bool insert(const QVariantMap &values);
    bool update(const QVariantMap &values, const QString &strWhereClause);
    bool remove(const QString &strWhereClause);

private:
    bool isConnected() const;

private:
    QString m_tableName;
    QString m_connectionName;
    QSqlDatabase m_db; // 保存数据库实例
};

#endif // DBORMBASE_H

类实现：OrmBase.cpp

#include "OrmBase.h"
#include <QSqlQuery>
#include <QSqlError>
#include <QSqlRecord>
#include <QDebug>

OrmBase::OrmBase(const QString &tableName, const QString &connectionName)
    : m_tableName(tableName), m_connectionName(connectionName)
{}

QVariantList OrmBase::select(const QString &whereClause, const QStringList &columns)
{
    QVariantList results;
    QSqlDatabase db = QSqlDatabase::database(m_connectionName);
    if (!db.isOpen()) {
        qDebug() << "Database not open";
        return results;
    }

    QString columnStr = columns.isEmpty() ? "*" : columns.join(", ");
    QString sql = QString("SELECT %1 FROM %2").arg(columnStr, m_tableName);
    if (!whereClause.trimmed().isEmpty()) {
        sql += " WHERE " + whereClause;
    }

    QSqlQuery query(db);
    if (!query.exec(sql)) {
        qDebug() << "Select failed:" << query.lastError().text();
        return results;
    }

    while (query.next()) {
        QVariantMap row;
        QSqlRecord rec = query.record();
        for (int i = 0; i < rec.count(); ++i) {
            row[rec.fieldName(i)] = query.value(i);
        }
        results << row;
    }
    return results;
}

bool OrmBase::insert(const QVariantMap &values)
{
    QSqlDatabase db = QSqlDatabase::database(m_connectionName);
    if (!db.isOpen()) return false;

    QStringList columns, placeholders;
    QVariantList bindValues;
    for (auto it = values.begin(); it != values.end(); ++it) {
        columns << it.key();
        placeholders << "?";
        bindValues << it.value();
    }

    QString sql = QString("INSERT INTO %1 (%2) VALUES (%3)")
                      .arg(m_tableName)
                      .arg(columns.join(", "))
                      .arg(placeholders.join(", "));

    QSqlQuery query(db);
    query.prepare(sql);
    for (const QVariant &val : bindValues) {
        query.addBindValue(val);
    }

    if (!query.exec()) {
        qDebug() << "Insert failed:" << query.lastError().text();
        return false;
    }
    return true;
}

bool OrmBase::update(const QVariantMap &values, const QString &whereClause)
{
    QSqlDatabase db = QSqlDatabase::database(m_connectionName);
    if (!db.isOpen()) return false;

    QStringList sets;
    QVariantList bindValues;
    for (auto it = values.begin(); it != values.end(); ++it) {
        sets << QString("%1 = ?").arg(it.key());
        bindValues << it.value();
    }

    QString sql = QString("UPDATE %1 SET %2").arg(m_tableName, sets.join(", "));
    if (!whereClause.trimmed().isEmpty()) {
        sql += " WHERE " + whereClause;
    }

    QSqlQuery query(db);
    query.prepare(sql);
    for (const QVariant &val : bindValues) {
        query.addBindValue(val);
    }

    if (!query.exec()) {
        qDebug() << "Update failed:" << query.lastError().text();
        return false;
    }
    return true;
}

bool OrmBase::remove(const QString &whereClause)
{
    QSqlDatabase db = QSqlDatabase::database(m_connectionName);
    if (!db.isOpen()) return false;

    QString sql = QString("DELETE FROM %1").arg(m_tableName);
    if (!whereClause.trimmed().isEmpty()) {
        sql += " WHERE " + whereClause;
    }

    QSqlQuery query(db);
    if (!query.exec(sql)) {
        qDebug() << "Delete failed:" << query.lastError().text();
        return false;
    }
    return true;
}

使用示例：

#include <QCoreApplication>
#include <QDebug>
#include <QDateTime>

#include "database_manager.h"
#include "db_ormbase.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    ConnectParams connectParams;
    connectParams.dbType = DatabaseType::MySQL;
    connectParams.strHostName = "localhost";
    connectParams.strDbName = "game_db";
    connectParams.strUserName = "root";
    connectParams.strPassword = "root";
    connectParams.strConnectionName = "user_game";
    connectParams.port = 3306;

    DatabaseManager::instance().initConnectionParams(connectParams);
    DatabaseManager::instance().initializeConnection();

    DbOrmBase userModel("players", "user_game");
    QVariantList playerList =  userModel.select("experience > 1000");

    for (const QVariant &playerVar : playerList) {
        QVariantMap playerMap = playerVar.toMap();

        int playerId = playerMap.value("player_id").toInt();
        QString username = playerMap.value("username").toString();
        QString nickname = playerMap.value("nickname").toString();
        int level = playerMap.value("level").toInt();
        int experience = playerMap.value("experience").toInt();
        int gold = playerMap.value("gold").toInt();
        QString passwordHash = playerMap.value("passwChina编程ord_hash").toString();
        QDateTime createdAt = playerMap.value("created_at").toDateTime();

        // 可以进行打印、显示、或保存到类对象中
        qDebug() << "ID:" << playerId
                 << "用户名:" << username
                 << "昵称:" << nickname
                 << "等级:" << level
                 << "经验:" << experience
                 << "金币:" << gold
                 << "密码Hash:" << passwordHash
                 << "创建时间:" << createdAt.toString(Qt::ISODate);
    }

    return a.exec();
}

输出结果：

Qt使用QSqlDatabase连接MySQL实现增删改查功能

四、实现派生具体模型类

为什么要派生？

虽然 OrmBase 已支持通用 CRUD，但派生后的 UserModel 能实现：

  • 指定固定表名（如 players）
  • 添加和 players 表相关的专属函数（如 getAdultUsers()、findByName()）
  • 让调用更具语义：UserModel user; user.insert(…)

创建 UserModel 类

UserModel.h

#ifndef USERMODEL_H
#define USERMODEL_H

#include "OrmBase.h"

class UserModel : public OrmBase
{
public:
    explicit UserModel(const QString &connectionName = "default");

    // 自定义业务函数
    QVariantList getAdultUsers();
    QVariantMap findById(int id);
    QVariantList findByName(const QString &name);
};

#endif // USERMODEL_H

UserModel.cpp

#include "UserModel.h"

UserModel::UserModel(const QString &connectionName)
    : OrmBase("players", connectionName) // 固定表名为 users
{}

// 查询年龄 >= 18 的用户
QVariantList UserModel::getAdultUsers()
{
    return select("experience >= 1000", {"player_id", "username",python "experience"});
}

// 查询某个 ID 的用户（返回一行）
QVariantMap UserModel::findById(int id)
{
    auto results = select(QString("player_id = %1").arg(id));
    return results.isEmpty() ? QVariantMap() : results.first().toMap();
}

// 查询某个名字的所有用户
QVariantList UserModel::findByName(const QString &name)
{
    QString clause = QString("username = '%1'").arg(name.replace("'", "''")); // 简单防注入
    return select(clause);
}

五、支持多线程连接池 + ORM + 事务封装

将构建以下组件：

+-------------------------+
| DBConnectionPool       | 线程安全连接池类（单例）
+-------------------------+
| OrmBase                | ORM 基类（封装表操作 + 自动获取线程连接）
+-------------------------+
| OrmManager             | 管理多个模型，支持事务封装
+-------------------------+
| XxxModel : OrmBase     | 表模型（如 UserModel）
+-------------------------+

5.1 线程安全数据库连接池：DBConnectionPool

DBConnectionPool.h

#ifndef DBCONNECTIONPOOL_H
#define DBCONNECTIONPOOL_H

#include <QSqlDatabase>
#include <QMutex>
#include <QMap>
#include <QThreadStorage>

class DBConnectionPool
{
public:
    static DBConnectionPool &instance();

    void init(const QString &driver,
              const QString &host,
              int port,
              const QString &dbName,
              const QString &user,
              const QString &password,
              int maxConn = 10);

    QSqlDatabase getConnection();
    void closeAll();

private:
    DBConnectionPool() = default;
    Q_DISABLE_COPY(DBConnectionPool)

    QString m_driver, m_host, m_dbName, m_user, m_password;
    int m_port = 3306;
    int m_maxConn = 10;

    QMutex m_mutex;
    int m_connIndex = 0;

    QThreadStorage<QString> m_threadConnName;
};

#endif // DBCONNECTIONPOOL_H

DBConnectionPool.cpp

#include "DBConnectionPool.h"
#include <QSqlDatabase>
#include <QSqlError>
#include <QDebug>

DBConnectionPool &DBConnectionPool::instance()
{
    static DBConnectionPool pool;
    return pool;
}

void DBConnectionPool::init(const QString &driver,
                            const QString &host,
                            int port,
                            const QString &dbName,
                            const QString &user,
                            const QString &password,
                            int maxConn)
{
    m_driver = driver;
    m_host = host;
    m_port = port;
    m_dbName = dbName;
    m_user = user;
    m_password = password;
    m_maxConn = maxConn;
}

QSqlDatabase DBConnectionPool::getConnection()
{
    if (!m_threadConnName.hasLocalData()) {
        QMutexLocker locker(&m_mutex);
        QString connName = QString("conn_%1").arg(++m_connIndex);
        m_threadConnName.setLocalData(connName);

        QSqlDatabase db = QSqlDatabase::addDatabase(m_driver, connName);
        db.setHostName(m_host);
        db.setPort(m_port);
        db.setDatabaseName(m_dbName);
        db.setUserName(m_user);
        db.setPassword(m_password);
        db.setConnectOptions("MYSQL_OPT_CONNECT_TIMEOUT=5;"
                             "MYSQL_OPT_RECONNECT=1");

        if (!db.open()) {
            qCritical() << "Failed to open DB:" << db.lastError().text();
        }
    }
    return QSqlDatabase::database(m_threadConnName.localData());
}

void DBConnectionPool::closeAll()
{
    QMutexLocker locker(&m_mutex);
    for (int i = 1; i <= m_connIndex; ++i) {
        QString name = QString("conn_%1").arg(i);
        if (QSqlDatabase::contains(name)) {
            QSqlDatabase::removeDatabase(name);
        }
    }
    m_connIndex = 0;
}

5.2 ORM 基类 OrmBase（使用连接池）

class OrmBase
{
public:
    OrmBase(const QString &tableName);
    virtual ~OrmBase() = default;

    bool insert(const QVariantMap &values);
    QVariantList select(const QString &whereClause = "", const QStringList &columns = {});
    bool update(const QVariantMap &values, const QString &whereClause);
    bool remove(const QString &whereClause);

    QSqlDatabase db() const;

protected:
    QString m_tableName;
};

关键点：OrmBase 中不再保存 QSqlDatabase 实例，而是每次从线程池中获取：

QSqlDatabase OrmBase::db() const
{
    return DBConnectionPool::instance().getConnection();
}

5.3 事务封装类 OrmManager

用于封装如下逻辑：

  • beginTransaction()
  • commit()
  • rollback()
class OrmManager
{
public:
    static bool beginTransaction();
    static bool commit();
    static bool rollback();
};

实现：

bool OrmManager::beginTransaction()
{
    QSqlDatabase db = DBConnectionPool::instance().getConnection();
    return db.transaction();
}

bool OrmManager::commit()
{
    QSqlDatabase db = DBConnectionPool::instance().getConnection();
    return db.commit();
}

bool OrmManager::rollback()
{
    QSqlDatabase db = DBConnectionPool::instance().getConnection();
    return db.rollback();
}

5.4 使用示例：线程内事务 + 多表操作

DBConnectionPool::instance().init("QMYSQL", "127.0.0.1", 3306, "testdb", "root", "123456");

UserModel user;
OrderModel order;

OrmManager::beginTransaction();
bool ok1 = user.insert({{"name", "Tom"}});
bool ok2 = order.insert({{"user_id", 1}, {"amount", 200.0}});
if (ok1 && ok2)
    OrmManager::commit();
else
    OrmManager::rollback();

5.5 线程使用示例（多线程安全）

QtConcurrent::run([](){
    UserModel u;
    u.insert({{"name", "ThreadUser"}});
});

以上就是Qt使用QSqlDatabase连接MySQL实现增删改查功能的详细内容，更多关于QSqlDatabase连接MySQL实现增删改查的资料请关注China编程(www.chinasem.cn)其它相关文章！

这篇关于Qt使用QSqlDatabase连接MySQL实现增删改查功能的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1155317。

相关文章

Java+AI驱动实现PDF文件数据提取与解析

Java+AI驱动实现PDF文件数据提取与解析

《Java+AI驱动实现PDF文件数据提取与解析》本文将和大家分享一套基于AI的体检报告智能评估方案,详细介绍从PDF上传、内容提取到AI分析、数据存储的全流程自动化实现方法,感兴趣的可以了解下... 目录一、核心流程：从上传到评估的完整链路二、第一步：解析 PDF，提取体检报告内容1. 引入依赖2. 封装
阅读更多...
使用Spring Cache本地缓存示例代码

使用Spring Cache本地缓存示例代码

《使用SpringCache本地缓存示例代码》缓存是提高应用程序性能的重要手段,通过将频繁访问的数据存储在内存中,可以减少数据库访问次数,从而加速数据读取,：本文主要介绍使用SpringCac... 目录一、Spring Cache简介核心特点：二、基础配置1. 添加依赖2. 启用缓存3. 缓存配置方案方案
阅读更多...
Java实现复杂查询优化的7个技巧小结

Java实现复杂查询优化的7个技巧小结

《Java实现复杂查询优化的7个技巧小结》在Java项目中,复杂查询是开发者面临的“硬骨头”,本文将通过7个实战技巧,结合代码示例和性能对比,手把手教你如何让复杂查询变得优雅,大家可以根据需求进行选择... 目录一、复杂查询的痛点：为何你的代码“又臭又长”1.1冗余变量与中间状态1.2重复查询与性能陷阱1.
阅读更多...
使用Python的requests库来发送HTTP请求的操作指南

使用Python的requests库来发送HTTP请求的操作指南

《使用Python的requests库来发送HTTP请求的操作指南》使用Python的requests库发送HTTP请求是非常简单和直观的,requests库提供了丰富的API,可以发送各种类型的HT... 目录前言1. 安装 requests 库2. 发送 GET 请求3. 发送 POST 请求4. 发送
阅读更多...
MySQL 表空却 ibd 文件过大的问题及解决方法

MySQL 表空却 ibd 文件过大的问题及解决方法

《MySQL表空却ibd文件过大的问题及解决方法》本文给大家介绍MySQL表空却ibd文件过大的问题及解决方法,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考... 目录一、问题背景：表空却 “吃满” 磁盘的怪事二、问题复现：一步步编程还原异常场景1. 准备测试源表与数据
阅读更多...
python 线程池顺序执行的方法实现

python 线程池顺序执行的方法实现

《python线程池顺序执行的方法实现》在Python中,线程池默认是并发执行任务的,但若需要实现任务的顺序执行,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋... 目录方案一：强制单线程（伪顺序执行）方案二：按提交顺序获取结果方案三：任务间依赖控制方案四：队列顺序消
阅读更多...
Mac电脑如何通过 IntelliJ IDEA 远程连接 MySQL

Mac电脑如何通过 IntelliJ IDEA 远程连接 MySQL

《Mac电脑如何通过IntelliJIDEA远程连接MySQL》本文详解Mac通过IntelliJIDEA远程连接MySQL的步骤,本文通过图文并茂的形式给大家介绍的非常详细,感兴趣的朋友跟... 目录MAC电脑通过 IntelliJ IDEA 远程连接 mysql 的详细教程一、前缀条件确认二、打开 ID
阅读更多...
Nginx中配置使用非默认80端口进行服务的完整指南

Nginx中配置使用非默认80端口进行服务的完整指南

《Nginx中配置使用非默认80端口进行服务的完整指南》在实际生产环境中,我们经常需要将Nginx配置在其他端口上运行,本文将详细介绍如何在Nginx中配置使用非默认端口进行服务,希望对大家有所帮助... 目录一、为什么需要使用非默认端口二、配置Nginx使用非默认端口的基本方法2.1 修改listen指令
阅读更多...
Redis实现分布式锁全过程

Redis实现分布式锁全过程

《Redis实现分布式锁全过程》文章介绍Redis实现分布式锁的方法,包括使用SETNX和EXPIRE命令确保互斥性与防死锁,Redisson客户端提供的便捷接口,以及Redlock算法通过多节点共识... 目录Redis实现分布式锁1. 分布式锁的基本原理2. 使用 Redis 实现分布式锁2.1 获取锁
阅读更多...
Python WebSockets 库从基础到实战使用举例

Python WebSockets 库从基础到实战使用举例

《PythonWebSockets库从基础到实战使用举例》WebSocket是一种全双工、持久化的网络通信协议,适用于需要低延迟的应用,如实时聊天、股票行情推送、在线协作、多人游戏等,本文给大家介... 目录1. 引言2. 为什么使用 WebSocket？3. 安装 WebSockets 库4. 使用 We
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2