通过MySQL触发器同步MySQL数据到Redis中

最新推荐文章于 2021-02-05 05:16:34 发布
最新推荐文章于 2021-02-05 05:16:34 发布
阅读量768 收藏 1
点赞数
文章标签： 数据库
原文链接：https://my.oschina.net/u/583029/blog/1808345
版权

DROP FUNCTION IF EXISTS `redis_hset`;
DROP FUNCTION IF EXISTS `redis_hdel`;
DROP FUNCTION IF EXISTS `redis_set_addr`;
CREATE FUNCTION redis_hset RETURNS STRING SONAME 'sync-redis.so';
CREATE FUNCTION redis_hdel RETURNS STRING SONAME 'sync-redis.so';
CREATE FUNCTION redis_set_addr RETURNS STRING SONAME 'sync-redis.so';
select redis_set_addr("192.168.9.98:6379");

 

cpp so文件

#include <stdio.h>
#include <stdlib.h>
#include <syslog.h>

#include <mysql.h>

#include <acl_cpp/acl_cpp_init.hpp>
#include <acl_cpp/redis/redis.hpp>
#include <acl_cpp/redis/redis_client.hpp>
#include <acl_cpp/redis/redis_client_cluster.hpp>

extern char **environ; //导入这个全局变量

acl::redis *g_redis = NULL;
acl::redis_client *g_redisCli = NULL;
acl::redis_client_cluster *g_cluster = NULL;

char *g_redis_addr = NULL;
bool check_redis_conn()
{
    if (g_redis != NULL)
    {
        return true;
    }

    openlog("sync-redis-data", LOG_CONS | LOG_PID, LOG_LOCAL0);

    char *redisAddr = getenv("REDIS_ADDR");
    if (redisAddr == NULL)
    {
        if (g_redis_addr != NULL)
        {
            syslog(LOG_INFO, "mysql cmd line set redis addr: %s", g_redis_addr);
            redisAddr = g_redis_addr;
        }
        else
        {
            redisAddr = "127.0.0.1:6379";
        }

        syslog(LOG_INFO, "redis addr: %s", g_redis_addr);
    }

    const char *redisPasswd = getenv("REDIS_PASSWORD");
    if (redisPasswd == NULL)
    {
        syslog(LOG_INFO, "REDIS_PASSWORD environment variable is not set.");
    }

    int redisCluster = 0;
    //默认不设置则为单机
    const char *isCluster = getenv("REDIS_CLUSTER");
    if (isCluster != NULL)
    {
        redisCluster = atoi(isCluster);
    }

    //初始化redis集群连接
    int connTimeout = 30;
    int rwTimeout = 30;

    acl::acl_cpp_init();
    if (redisCluster == 1)
    {
        g_cluster = new acl::redis_client_cluster();
        // g_cluster->init(NULL, redisAddr, 100, connTimeout, rwTimeout);
        g_cluster->set(redisAddr, 100, connTimeout, rwTimeout);
        g_cluster->set_password("default", redisPasswd);
        g_redis = new acl::redis(g_cluster);
    }
    else
    {
        g_redisCli = new acl::redis_client(redisAddr, connTimeout, rwTimeout);
        g_redisCli->set_slice_request(false);
        g_redisCli->set_password(redisPasswd);
        g_redis = new acl::redis(g_redisCli);
    }

    syslog(LOG_INFO, "init redis conn success.");

    return true;
}

// 调用redis的hset命令
extern "C" char *redis_hset(UDF_INIT *initid, UDF_ARGS *args, char *result, unsigned long *length, char *isNull, char *error)
{
    if (!check_redis_conn())
    {
        *error = 1;
        const char *msg = "connect redis error!";
        *length = strlen(msg) + 1;
        snprintf(result, *length, "%s", msg);
        syslog(LOG_ERR, msg);
        return result;
    }

    if (!(args->args && args->args[0] && args->args[1] && args->args[2]))
    {
        const char *msg = "Param is null.";
        *isNull = 1;
        *length = strlen(msg) + 1;
        snprintf(result, *length, msg);
        return result;
    }

    syslog(LOG_INFO, "hashkey: %s, field: %s, value: %s\n", args->args[0], args->args[1], args->args[2]);

    g_redis->clear();
    if (g_redis->hset(args->args[0], args->args[1], args->args[2]) >= 0)
    {
        *length = 2;
        snprintf(result, 2, "0");
        syslog(LOG_INFO, "update key %s field %s success from redis.", args->args[0], args->args[1]);
        return result;
    }
    else
    {
        *error = 1;
        const char *msg = "redis hset error.";
        *length = strlen(msg) + 1;
        snprintf(result, *length, "%s", msg);
        syslog(LOG_ERR, "hset failed: key:%s,field:%s,value:%s. %s:%s", args->args[0], args->args[1], args->args[2], msg, g_redis->result_error());
        return result;
    }
}

// 调用redis的hset命令
extern "C" char *redis_hdel(UDF_INIT *initid, UDF_ARGS *args, char *result, unsigned long *length, char *isNull, char *error)
{
    if (!check_redis_conn())
    {
        *error = 1;
        const char *msg = "connect redis error!";
        *length = strlen(msg) + 1;
        snprintf(result, *length, "%s", msg);
        syslog(LOG_ERR, msg);
        return result;
    }

    if (!(args->args && args->args[0] && args->args[1]))
    {
        const char *msg = "Param is null.";
        *isNull = 1;
        *length = strlen(msg) + 1;
        snprintf(result, *length, msg);
        return result;
    }

    syslog(LOG_INFO, "arg0:%s,arg1:%s\n", args->args[0], args->args[1]);

    g_redis->clear();
    if (g_redis->hdel(args->args[0], args->args[1]) >= 0)
    {
        *length = 2;
        snprintf(result, 2, "0");
        syslog(LOG_INFO, "del field %s success from key of redis.", args->args[1], args->args[0]);
        return result;
    }
    else
    {
        *error = 1;
        const char *msg = "redis hset error.";
        *length = strlen(msg) + 1;
        snprintf(result, *length, "%s", msg);
        syslog(LOG_ERR, "hdel failed: key:%s,field:%s. %s:%s", args->args[0], args->args[1], msg, g_redis->result_error());
        return result;
    }
}

// 调用redis的hset命令
extern "C" char *redis_set_addr(UDF_INIT *initid, UDF_ARGS *args, char *result, unsigned long *length, char *isNull, char *error)
{
    if (!(args->args && args->args[0]))
    {
        const char *msg = "Param is null.";
        *isNull = 1;
        *length = strlen(msg) + 1;
        snprintf(result, *length, msg);
        return result;
    }

    syslog(LOG_INFO, "set redis addr is: %s\n", args->args[0]);

    g_redis_addr=new char[50];
    memset(g_redis_addr,0,50);
    strncpy(g_redis_addr, args->args[0], 49);
}

/*资源分配*/
extern "C" my_bool redis_hset_init(UDF_INIT *initid, UDF_ARGS *args, char *message)
{
    if (3 != args->arg_count || args->arg_type[0] != STRING_RESULT || args->arg_type[1] != STRING_RESULT || args->arg_type[2] != STRING_RESULT)
    { // hset(key, field, value) 需要三个参数
        strncpy(message, "please input 3 args and must be string, such as: hset('key', 'feild', 'value');", MYSQL_ERRMSG_SIZE);
        return -1;
    }
    args->arg_type[0] = STRING_RESULT;
    args->arg_type[1] = STRING_RESULT;
    args->arg_type[2] = STRING_RESULT;

    initid->ptr = NULL;
    return 0;
}

/*资源分配*/
extern "C" my_bool redis_hdel_init(UDF_INIT *initid, UDF_ARGS *args, char *message)
{
    if (2 != args->arg_count || args->arg_type[0] != STRING_RESULT || args->arg_type[1] != STRING_RESULT)
    { // hset(key, field, value) 需要三个参数
        strncpy(message, "please input 2 args and must be string, such as: hdel('key', 'feild');", MYSQL_ERRMSG_SIZE);
        return -1;
    }
    args->arg_type[0] = STRING_RESULT;
    args->arg_type[1] = STRING_RESULT;

    initid->ptr = NULL;
    return 0;
}

/*资源分配*/
extern "C" my_bool redis_set_addr_init(UDF_INIT *initid, UDF_ARGS *args, char *message)
{
    if (1 != args->arg_count || args->arg_type[0] != STRING_RESULT) // || args->arg_type[1] != STRING_RESULT || args->arg_type[2] != STRING_RESULT)
    {
        strncpy(message, "please input 1 args and must be string, such as: redis_set_addr('redis_addr');", MYSQL_ERRMSG_SIZE);
        return -1;
    }
    args->arg_type[0] = STRING_RESULT;
    // args->arg_type[1] = STRING_RESULT;
    // args->arg_type[2] = STRING_RESULT;

    initid->ptr = NULL;
    return 0;
}

// // 测试
// int main()
// {
//     char isNull;
//     char message[128] = {0};
//     char result[128] = {0};
//     unsigned long length = 0;
//     UDF_ARGS args;
//     UDF_INIT initid;
//     args.arg_count = 3;
//     args.args = new char *[3];
//     args.args[0] = new char[16];
//     args.args[1] = new char[16];
//     args.args[2] = new char[16];
//     args.arg_type = new Item_result[3];
//     strcpy(args.args[0], "mykey");
//     strcpy(args.args[1], "myfeild");
//     strcpy(args.args[2], "myvalue");
//     redis_hset_init(&initid, &args, message);
//     redis_hset(&initid, &args, result, &length, &isNull, message);
//     printf("redis result: %s\n", result);
//     if (args.arg_type)
//         delete args.arg_type;
//     if (args.args)
//         delete args.args;
//     return 0;
// }

 

///

#include <stdio.h>
#include <stdlib.h>
#include <syslog.h>

#include <mysql.h>

#include <acl_cpp/acl_cpp_init.hpp>
#include <acl_cpp/redis/redis.hpp>
#include <acl_cpp/redis/redis_client.hpp>
#include <acl_cpp/redis/redis_client_cluster.hpp>

extern char **environ; //导入这个全局变量

acl::redis *g_redis = NULL;
acl::redis_client *g_redisCli = NULL;
acl::redis_client_cluster *g_cluster = NULL;

bool check_redis_conn()
{
    if (g_redis != NULL)
    {
        return true;
    }

    openlog("sync-redis-data", LOG_CONS | LOG_PID, LOG_LOCAL0);

    char *redisAddr = getenv("REDIS_ADDR");
    if (redisAddr == NULL)
    {
        syslog(LOG_EMERG, "REDIS_HOST environment variable is not set. mysql data is not to sync redis");
        return false;
    }

    char *redisPasswd = getenv("REDIS_PASSWORD");
    if (redisPasswd == NULL)
    {
        syslog(LOG_INFO, "REDIS_PASSWORD environment variable is not set.");
    }

    int redisCluster = 0;
    //默认不设置则为单机
    char *isCluster = getenv("REDIS_CLUSTER");
    if (isCluster != NULL)
    {
        redisCluster = atoi(isCluster);
    }

    //初始化redis集群连接
    int connTimeout = 30;
    int rwTimeout = 30;

    // acl::string redisAddr = "127.0.0.1:6379";

    if (redisCluster == 1)
    {
        g_cluster = new acl::redis_client_cluster();
        // g_cluster->init(NULL, redisAddr, 100, connTimeout, rwTimeout);
        g_cluster->set(redisAddr, 100, connTimeout, rwTimeout);
        g_cluster->set_password("default", redisPasswd);
        g_redis = new acl::redis(g_cluster);
    }
    else
    {
        g_redisCli = new acl::redis_client(redisAddr, connTimeout, rwTimeout);
        g_redisCli->set_slice_request(false);
        char *pwd = NULL;
        g_redisCli->set_password(pwd);
        g_redis = new acl::redis(g_redisCli);
    }

    syslog(LOG_INFO, "init redis conn success.");

    return true;
}

// 调用redis的hset命令
char *redis_hset(char *result, unsigned long *length, char *isNull, char *error)
{
    if (!check_redis_conn())
    {
        *error = 1;
        const char *msg = "connect redis error!";
        *length = strlen(msg) + 1;
        snprintf(result, *length, "%s", msg);
        syslog(LOG_ERR, msg);
        return result;
    }

    int ret = 0;

    g_redis->clear();
    ret = g_redis->hset("testkey", "testfield", "testvalue");
    printf("hset return value: %d\n", ret);

    g_redis->clear();
    ret = g_redis->hset("testkey", "testfield", "testvalue");
    printf("hset return value: %d\n", ret);

    g_redis->clear();
    ret = g_redis->hset("testkey", "testfield", "testvalue");
    printf("hset return value: %d\n", ret);

    g_redis->clear();
    if (g_redis->hset("testkey", "testfield", "testvalue") < 0)
    {
        *error = 1;
        const char *msg = "redis hset error.";
        *length = strlen(msg) + 1;
        snprintf(result, *length, "%s", msg);
        printf("redis hset exec error.%s\n", g_redis->result_error());
        syslog(LOG_ERR, "%s:%s", msg, g_redis->result_error());
        return result;
    }
    else
    {
        *length = 2;
        snprintf(result, 2, "0");
        //syslog(LOG_INFO, "update key %s field %s success from redis.", args->args[0], args->args[1]);
        printf("hset success.\n");
        return result;
    }
}

// 测试
int main()
{
    // acl::acl_cpp_init();

    // openlog("sync-redis-data", LOG_CONS | LOG_PID, LOG_LOCAL0);

    // char *redisAddr = getenv("REDIS_ADDR");
    // if (redisAddr == NULL)
    // {
    //     syslog(LOG_EMERG, "REDIS_HOST environment variable is not set. mysql data is not to sync redis");
    // }

    // char *redisPasswd = getenv("REDIS_PASSWORD");
    // if (redisPasswd == NULL)
    // {
    //     syslog(LOG_INFO, "REDIS_PASSWORD environment variable is not set.");
    // }

    // int redisCluster = 0;
    // //默认不设置则为单机
    // char *isCluster = getenv("REDIS_CLUSTER");
    // if (isCluster != NULL)
    // {
    //     redisCluster = atoi(isCluster);
    // }

    // //初始化redis集群连接
    // int connTimeout = 30;
    // int rwTimeout = 30;

    // redisAddr = "127.0.0.1:6379";

    // if (redisCluster == 1)
    // {
    //     g_cluster = new acl::redis_client_cluster();
    //     g_cluster->init(NULL, redisAddr, 100, connTimeout, rwTimeout);
    //     g_cluster->set_password("default", redisPasswd);
    //     g_redis = new acl::redis(g_cluster);
    // }
    // else
    // {
    //     g_redisCli = new acl::redis_client(redisAddr, connTimeout, rwTimeout);
    //     g_redisCli->set_slice_request(false);
    //     char *pwd = NULL;
    //     g_redisCli->set_password(pwd);
    //     g_redis = new acl::redis(g_redisCli);
    // }

    // if (g_redis->monitor() == false)
    // {
    //     printf("redis monitor error: %s, addr: %s",
    //            g_redis->result_error(), redisAddr);
    //     return false;
    // }
    // syslog(LOG_INFO, "init redis conn success.");

    // int conn_timeout = 10;
    // int rw_timeout = 10;

    // acl::acl_cpp_init();
    // // acl::log::stdout_open(true);

    // acl::string addr("127.0.0.1:6379");
    // acl::redis_client_cluster cluster;
    // cluster.set(addr.c_str(), 100, conn_timeout, rw_timeout);

    // acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
    // client.set_slice_request(false);

    // acl::redis_hash redis;
    // int cluster_mode = 0;
    // if (cluster_mode)
    //     redis.set_cluster(&cluster, 100);
    // else
    //     redis.set_client(&client);

    // g_redis = &redis;

    char isNull;
    char message[128] = {0};
    char result[128] = {0};
    unsigned long length = 0;
    redis_hset(result, &length, &isNull, message);
    printf("redis result: %s\n", result);

    return 0;
}

 

转载于:https://my.oschina.net/u/583029/blog/1808345

chengzhou2075
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
canal应用二：mysql数据实时同步到redis
qq_28834355的博客
06-18 1228
前言 在项目开发中，通常使用redis作为数据的缓存，那么经常遇到一个问题，修改MySQL的数据要怎么同步到Redis呢？ 方式一：在系统的保存、删除接口同时对redis进行操作，但是存在一个缺点，就是如果直接修改数据库的情况下无法同步数据； 方式二：使用canal拉取mysql binlog，获取mysql变化的数据日志，然后同步操作redis。 这里我们采用方式二，基本设计思路如下图所示 准备工作 安装canal-server、canal-admin：canal安装和基本使用 安装mysql、r
Redis与MySql的数据同步方案
最新发布
wjianwei666的专栏
07-08 137
使用阿里的MySql数据库同步工具canal，基于最终一致性，canal的实现方式是模拟mysql的slave和master同步机制，监听mysql中binlog日志的更新来触发Redis缓存的更新。当数据库中的数据更新时，不立即更新缓存，而是将更新操作记录发送到消息队列中，然后异步处理队列中的消息来完成Redis的更新。实时同步：适用于对「强一致性」有严格要求的场景，可以提供实时的数据同步，但对数据库的负载较高，同步并发时的性能不可控。：写关系数据库MySql，写成功后，删除缓存Redis中的值。
通过Gearman实现MySQL到Redis的数据同步
CloudCraft的专栏
08-25 4256
对于变化频率非常快的数据来说，如果还选择传统的静态缓存方式（Memocached、File System等）展示数据，可能在缓存的存取上会有很大的开销，并不能很好的满足需要，而Redis这样基于内存的NoSQL数据库，就非常适合担任实时数据的容器。 但是往往我们又有数据可靠性的需求，采用MySQL作为数据存储，不会因为内存问题而引起数据丢失，同时也可以利用关系数据库的特性实现很多功能。
后台服务优化-通过MySQL触发器将数据缓存到Redis
halo0623的博客
04-02 498
开发网站过程中，每当修改海报时，通过触发器自动将新的海报缓存到Redis，运用mysql2redis(一个可以在mysql中操作redis的插件) 1、建立存储过程cache_poster_to_redis()，将所需字段拼接成json字符串保存到Redis中。 BEGIN DECLARE v_json VARCHAR(4000); DECLARE v_redis_ret INT; SEL...
通过UDF使mysql主动刷新redis缓存
热门推荐
liberalman的专栏
08-23 1万+
UDF是mysql的一个拓展接口，UDF（Userdefined function）用户自定义函数。在什么地方使用这个功能呢，试想有如下场景：你的网站使用mysql作为最终数据落地的存储引擎，而redis作为缓存以减小查询请求穿透到mysql的数量，可以极大的降低数据库性能瓶颈带来的整个网站对外服务的卡顿、不可用等情况。这种方式的架构，当有查询请求的时候，我们可以在业务逻辑层控制，先从缓存中查询，无
mysql-触发器
xgs736214763的博客
10-20 245
文章地址https://xgs888.top/post/view?id=54 mysql 增删改触发器的创建 insert 触发器 CREATE DEFINER=`root`@`localhost` TRIGGER `chilrd`.`insert`   BEFORE INSERT ON `chilrd`.`dd`   FOR EACH ROW BEGIN   #
mysql-redis在MySQL中操作Redis.zip
09-13
通过连接器，可以在MySQL查询后无缝地将结果保存到Redis，或者在Redis中检索数据并插入MySQL。 3. 数据库设计：合理设计数据库结构，明确哪些数据适合缓存，哪些需要实时更新。例如，经常访问但不频繁更改的数据...
在SQL中操作Redis或者Redis集群，达到Redis与MySQL的数据一致性.zip
07-27
每当MySQL中的数据发生变化时，通过触发器、中间件或专门的工具将变更同步到Redis。例如，可以使用`Redisson`库来监听MySQL Binlog事件，实现实时更新。 2. 双向同步：在某些场景下，可能需要双向同步，确保Redis和...
使Redis与MySQL的数据保持一致性的源代码.zip
09-10
在某些场景下，我们可能需要将Redis中的数据实时或近实时地同步到MySQL，或者反之，以满足高性能读写需求、高可用性或持久化存储等目的。 实现Redis与MySQL的数据一致性有多种策略，其中常见的包括： 1. **触发器...
基于 Canal 的 MySql RabbitMQ Redis/memcached/mongodb
08-16
5.数据写入/修改到nosql （redis的主从/hash分片） 6.保证对应关系的简单性：一个mysql表对应一个 redis实例（redis单线程，多实例保证分流不阻塞），关联关系数据交给接口业务 数据：mysql->binlog->MQ->redis(不...
MySQL&Redis安装使用规范
12-08
由于Redis主要用于提高访问速度，建议关键数据同时在MySQL中存储一份，以备不时之需。 6. **Redis的数据持久化**：Redis Cluster提供了RDB和AOF两种持久化方式，但在业务初期，可以考虑根据流量预估选择合适的节点...
java，mysql触发器，redis生成流水号（yyyyMM000）
weixin_30256505的博客
06-12 456
最近又遇到需要根据日期生成流水号的业务，然后记录了几种生成方法，一个是通过java代码，一个是数据库的触发器，还有是通过redis。下面是代码： 通过java生成简易流水： /** * 通过日期和生成的流水号拼接 * @param maxCount 已经生成的个数 * @return */ public static String recou...
修改mysql触发redis_实现mysql和redis之间的触发数据同步——mysql 触发器+gearman+php.worker...
weixin_39669638的博客
02-05 302
上回一次我们已经实现了 redis 作为 mysql 的缓存服务器,但是如果更新了 mysql,redis中仍然会有对应的 KEY,数据就不会更新,此时就会出现 mysql 和 redis 数据不一致的情况。详情请见基于redis缓存数据库实现lnmp架构高速访问所以接下来就要通过 mysql 触发器将改变的数据同步到 redis 中。因为mysql和redis数据格式不同,不能实现直接同步,所以...
redis作为mysql的缓存服务器(读写分离) （转）
u010681191的博客
03-29 800
一、redis简介Redis是一个key-value存储系统。和Memcached类似，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。在部分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++(hiredis)，C#，PHP，JavaScript，Per...
实现mysql和redis之间的触发数据同步——mysql 触发器+gearman+worker.php
weixin_45649763的博客
03-13 955
文章目录原理Gearman的运行过程操作步骤 在上一篇博客中，我们实现了redis作为mysql的缓存数据库，当访问数据时，首先在redis中查找，redis没有时，才会在mysql中查找，那么如何实现当mysql的数据更新时，redis的数据保持同步更新呢？ 默认情况下，它是不会自动更新的。 当手动更新mysql时， 访问页面时，发现redis的数据并没有改变 那么如何实现redis的自动同步更...
实现mysql和redis之间的触发数据同步——mysql 触发器+gearman+php.worker
weixin_33922670的博客
04-07 283
上回一次我们已经实现了 redis 作为 mysql 的缓存服务器,但是如果更新了 mysql,redis中仍然会有对应的 KEY,数据就不会更新,此时就会出现 mysql 和 redis 数据不一致的情况。详情请见基于redis缓存数据库实现lnmp架构高速访问所以接下来就要通过 mysql 触发器将改变的数据同步到 redis 中。因为mysql和redi...
修改mysql触发redis_mysql触发器调用udf同步redis使用实例
weixin_42439576的博客
01-18 204
BEGIN#检测是否有sql异常declare _row,_err,_count int default 0;DECLARE CONTINUE HANDLER FOR SQLEXCEPTION,SQLWARNING,NOT FOUND set _err=1;#new.user_token!=old.user_token|| 去掉改行，登陆修改token时，不调用触发器，当登陆后再调用注册设备时...
Redis 触发器
liyongbing1122的博客
07-02 5547
Redis 触发器 监听 Redis 中Key超时失效的事件 Redis中的key可以设置生存时间，当该key超时失效时会触发一个事件 “过期事件通过Redis的订阅与发布功能（pub/sub）来进行分发。” 首先需要修改Redis 的配置文件，将notify-keyspace-events 的值改为 Ex 1.监听程序 import redis.clients.j...
Redis发布订阅
涛涛之海
08-29 168
Redis发布订阅 Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接受消息。微信、微博关注系统！ Redis 客户端可以订阅任意数量的频道。 订阅/发布消息图 下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系： 当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端： Redis 发布订阅命令 下表列出
如何在 MySQL 中使用触发器，在数据更新时同步更新 Redis
05-16
您可以使用AFTER UPDATE触发器，在MySQL中更新数据时通过发送适当的指令到Redis中达到同步更新的目的。我们可以在触发器中编写适当的代码，以便在MySQL中更新数据时同时更新Redis。 但是，当您在Redis中执行数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值