精华内容
下载资源
问答
  • 本地java代码连接它,就要考虑端口开发的问题。 在云服务器上检测一下开放的端口: firewall-cmd --list-ports 我们再进行端口查询 firewall-cmd --list-ports 发现为空,我们来开放端口 提示防火墙未运行 ...

    第一次接触redis,由于考虑到后续可能项目部署到云服务器上,就直接把redis部署到腾讯云上了。

    本地java代码连接它,就要考虑端口开发的问题。

     

    在云服务器上检测一下开放的端口:

    firewall-cmd --list-ports

    我们再进行端口查询 firewall-cmd --list-ports 发现为空,我们来开放端口

    提示防火墙未运行 FirewallD is not running

    我们开启防火墙 systemctl start firewalld

    注意: 我这里的版本的 centos7,所以开启服务 是用 systemctl

    centos6 应该用chkconfig 命令

     

    查看防火墙状态

    systemctl status firewall

    开放指定端口

     

     

     

     

    firewall-cmd --add-port=6379/tcp --permanent

    --permanent 代表永久开放此端口,如果不加,那么linux重启时失效

    我们再查看一次

     

    然后高兴的测试一下socket连接

    Connection refused

    发现云服务器的安全组还没有开放该端口

    (这里说一下 云服务器的安全组作为一级防御,防火墙作为二级防御)

    来源设置为 0.0.0.0/0 表示任何ip连接访问。

    协议端口设置为 TCP:6379,因为redis默认端口为 6379,你也可以设置为 ALL表示开发所有端口。

    策略设置为运行即可。

     

    注意:记得把你的云服务器实例添加到这个安全组中,如果你有多个安全组的话。

     

    然后再测试一下 还是 报 Connection refused

    想来想去应该是redis的问题了,我查一下监听

    netstat -lntp | grep 6379 (如果端口多过滤一下)

    我是直接 netstat -lnpt

    发现 它只监听127.0.0.1的ip,也就是只监听本机(服务器)

     

    不明白,我记得明明注释了的,

    查了一下redis的配置,才知道配置文件中

    redis.conf 默认是 bind 127.0.0.1的,我看到上面的那行bind就没注意到下面的那行了。。。

    我们把它注释掉

     

    把redis.server带着redis.conf重启

    ./src/redis-server ./redis.conf

    再次查看端口netstat -lntp | grep 6379

    发现允许所有ip访问了

    再进行测试

     

    报异常 Exception in thread "main" redis.clients.jedis.exceptions.JedisDataException: DENIED Redis is running in protected mode because protected mode is enabled, no bind address was specified, no authentication password is requested to clients.

    提示要求 redis无法允许在protect-mode开启,不bind指定地址、不指定具体密码的环境下

    我确实没有指定密码,也没有关闭protect-mode

    在redis.conf中再关一下

     

    上面注释说明了一切: 你应该关闭安全模式,如果你想要其他ip地址的客户端连接本机的redis,即使是不带密码。

    再进行测试

    连接成功!

    注意要添加密码!!我不添加密码,做一些测试Demo时,服务器直接被植入了一个挖矿病毒!!!!!

     

    展开全文
  • 本地开发环境 (windows,IDEA) 可正常运行的springBoot框架代码 准备工作: 腾讯云服务器上安装redis,参考Linux安装和部署Redis 远程连接Redis进行相关配置,配置项如下(均是对redis.config的配置): 1、...

    动手前的条件:

    • 云服务器(我用的是腾讯云服务器)
    • 本地开发环境 (windows,IDEA)
    • 可正常运行的springBoot框架代码

    准备工作:

    • 腾讯云服务器上安装redis,参考Linux安装和部署Redis

    • 远程连接Redis进行相关配置,配置项如下(均是对redis.config的配置):
      1、设置绑定IP(这里允许所有IP端访问,直接注释 bind即可)
      # bind 127.0.0.1 ::1

      2、设置Redis连接密码
      在这里插入图片描述
      3、修改redis的保护模式为no
      在这里插入图片描述
      4、修改redis的守护进程为yes(修改后启动redis时关联redis.config文件,可后台启动redis)
      在这里插入图片描述

    • Centos防火墙设置,开放6379端口,此处略。(我直接把防火墙关闭了,不建议)

    springBoot集成Redis(使用Jedis工具类)

    1、配置pom.xml文件,添加redis依赖

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-redis</artifactId>
        <version>1.4.1.RELEASE</version>
    </dependency>
    

    以下工具下文中会用到,此处提前添加

    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.38</version>
    </dependency>
    

    2、配置文件中添加redis相关信息,备用

    #redis相关配置
    redis:
      database: 0
      host: *.*.*.*
      password: *
      pool:
        max-active: 200
        max-idle: 10
        max-wait: -1
        min-idle: 0
        max-total: 5
      port: 6379
      timeout: 1000
    

    host为redis服务器地址,password为上文中配置的redis连接密码。其他参数含义可自行百度。

    3、编写RedisConf类

    package com.css.dataexchangesystem.config;
    
    import java.lang.reflect.Method;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.cache.interceptor.KeyGenerator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.databind.ObjectMapper;
    @Configuration
    @EnableCaching
    public class RedisConfig extends CachingConfigurerSupport{
        @Value("${redis.host}")
        private String host;
    
        @Value("${redis.port}")
        private int port;
    
        @Value("${redis.timeout}")
        private int timeout;
    
        @Value("${redis.password}")
        private String password;
    
        @Value("${redis.pool.max-active}")
        private int maxActive;
    
        @Value("${redis.pool.max-wait}")
        private int maxWait;
    
        @Value("${redis.pool.max-idle}")
        private int maxIdle;
    
        @Value("${redis.pool.min-idle}")
        private int minIdle;
    
        @Bean
        public KeyGenerator wiselyKeyGenerator(){
            return new KeyGenerator() {
                @Override
                public Object generate(Object target, Method method, Object... params) {
                    StringBuilder sb = new StringBuilder();
                    sb.append(target.getClass().getName());
                    sb.append(method.getName());
                    for (Object obj : params) {
                        sb.append(obj.toString());
                    }
                    return sb.toString();
                }
            };
        }
    
        @Bean
        public JedisConnectionFactory redisConnectionFactory() {
            JedisConnectionFactory factory = new JedisConnectionFactory();
            factory.setHostName(host);
            factory.setPort(port);
            factory.setTimeout(timeout); //设置连接超时时间
            factory.setPassword(password);
            factory.getPoolConfig().setMaxIdle(maxIdle);
            factory.getPoolConfig().setMinIdle(minIdle);
            factory.getPoolConfig().setMaxTotal(maxActive);
            factory.getPoolConfig().setMaxWaitMillis(maxWait);
            return factory;
        }
    
        /*@Bean
        public CacheManager cacheManager(RedisTemplate redisTemplate) {
            RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
            RedisCacheManager cacheManager1 = new RedisCacheManager();
            // Number of seconds before expiration. Defaults to unlimited (0)
            cacheManager.setDefaultExpiration(10); //设置key-value超时时间
            return cacheManager;
        }*/
    
        @Bean
        public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
            StringRedisTemplate template = new StringRedisTemplate(factory);
            setSerializer(template); //设置序列化工具,这样ReportBean不需要实现Serializable接口
            template.afterPropertiesSet();
            return template;
        }
    
        private void setSerializer(StringRedisTemplate template) {
            Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jackson2JsonRedisSerializer.setObjectMapper(om);
            template.setValueSerializer(jackson2JsonRedisSerializer);
        }
    }
    
    

    4、编写RedisUtil类

    package com.css.dataexchangesystem.util;
    
    import java.io.Serializable;
    import java.util.List;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.HashOperations;
    import org.springframework.data.redis.core.ListOperations;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.SetOperations;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.data.redis.core.ZSetOperations;
    import org.springframework.stereotype.Service;
    @Service
    public class RedisUtil {
        @Autowired
        private RedisTemplate redisTemplate;
    
        /**
         * 写入缓存
         *
         * @param key
         * @param value
         * @return
         */
        public boolean set(final String key, Object value) {
            boolean result = false;
            try {
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.set(key, value);
                result = true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        /**
         * 写入缓存设置时效时间
         *
         * @param key
         * @param value
         * @return
         */
        public boolean set(final String key, Object value, Long expireTime, TimeUnit timeUnit) {
            boolean result = false;
            try {
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.set(key, value);
                redisTemplate.expire(key, expireTime, timeUnit);
                result = true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        /**
         * 批量删除对应的value
         *
         * @param keys
         */
        public void remove(final String... keys) {
            for (String key : keys) {
                remove(key);
            }
        }
    
        /**
         * 批量删除key
         *
         * @param pattern
         */
        public void removePattern(final String pattern) {
            Set<Serializable> keys = redisTemplate.keys(pattern);
            if (keys.size() > 0) {
                redisTemplate.delete(keys);
            }
        }
    
        /**
         * 删除对应的value
         *
         * @param key
         */
        public void remove(final String key) {
            if (exists(key)) {
                redisTemplate.delete(key);
            }
        }
    
        /**
         * 判断缓存中是否有对应的value
         *
         * @param key
         * @return
         */
        public boolean exists(final String key) {
            return redisTemplate.hasKey(key);
        }
    
        /**
         * 读取缓存
         *
         * @param key
         * @return
         */
        public Object get(final String key) {
            Object result = null;
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            result = operations.get(key);
            return result;
        }
    
        /**
         * 哈希 添加
         *
         * @param key
         * @param hashKey
         * @param value
         */
        public void hmSet(String key, Object hashKey, Object value) {
            HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
            hash.put(key, hashKey, value);
        }
    
        /**
         * 哈希获取数据
         *
         * @param key
         * @param hashKey
         * @return
         */
        public Object hmGet(String key, Object hashKey) {
            HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
            return hash.get(key, hashKey);
        }
    
        /**
         * 列表添加
         *
         * @param k
         * @param v
         */
        public void lPush(String k, Object v) {
            ListOperations<String, Object> list = redisTemplate.opsForList();
            list.rightPush(k, v);
        }
    
        /**
         * 列表获取
         *
         * @param k
         * @param l
         * @param l1
         * @return
         */
        public List<Object> lRange(String k, long l, long l1) {
            ListOperations<String, Object> list = redisTemplate.opsForList();
            return list.range(k, l, l1);
        }
    
        /**
         * 集合添加
         *
         * @param key
         * @param value
         */
        public void add(String key, Object value) {
            SetOperations<String, Object> set = redisTemplate.opsForSet();
            set.add(key, value);
        }
    
        /**
         * 集合获取
         *
         * @param key
         * @return
         */
        public Set<Object> setMembers(String key) {
            SetOperations<String, Object> set = redisTemplate.opsForSet();
            return set.members(key);
        }
    
        /**
         * 有序集合添加
         *
         * @param key
         * @param value
         * @param scoure
         */
        public void zAdd(String key, Object value, double scoure) {
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            zset.add(key, value, scoure);
        }
    
        /**
         * 有序集合获取
         *
         * @param key
         * @param scoure
         * @param scoure1
         * @return
         */
        public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
            ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
            return zset.rangeByScore(key, scoure, scoure1);
        }
    }
    
    

    5、编写测试用例

    package com.css.dataexchangesystem.controller;
    
    
    import com.css.dataexchangesystem.service.UserService;
    import com.css.dataexchangesystem.util.RedisUtil;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiImplicitParam;
    import io.swagger.annotations.ApiOperation;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.web.bind.annotation.*;
    
    import java.util.List;
    
    /**
    * @Description:
    * @Param:
    * @return:
    * @Author: mxc
    * @Date: 2019/11/13
    * @Version:1.0
    */
    @RestController
    @RequestMapping("/testBoot")
    @Api(value="用户controller",tags={"用户操作接口"})
    public class UserController {
        @Autowired
        RedisUtil redisUtil;
    
        @RequestMapping(value = "testRedis",method = {RequestMethod.GET})
        @ResponseBody
        @ApiOperation(value = "RedisTemplateService测试", notes = "Redis存储对象")
        public void teRedis(){
            redisUtil.set("name2","mxc");
        }
    }
    
    

    以上,完成。
    启动项目后访问 http://localhost:8080/testBoot/testRedis
    可在服务器中查看是否成功:
    在这里插入图片描述

    此处推荐一个开源的redis可视化工具,可远程连接并操作redis中数据,地址
    https://github.com/qishibo/AnotherRedisDesktopManager

    一次学习过程中的记录,RedisConfig、RedisUtil及其他部分内容均参照他人博客,时间仓促未找到其博客地址,如作者发现请及时与我联系,十分感谢

    展开全文
  • Redis 远程连接方法

    千次阅读 2019-07-05 16:13:47
    开发过程中直接连接本地redis服务,结合RedisDesktopManager桌面工具,来方便我们的开发。 但是在线上环境下,我们的业务容器和redis服务有可能不在一台服务器,这时候我们就需要远程连接redis来执行响应的操作。 一...

    在这里插入图片描述

    在平时日常开发中,我们会在自己的开发机安装本地redis服务。开发过程中直接连接本地redis服务,结合RedisDesktopManager桌面工具,来方便我们的开发。

    但是在线上环境下,我们的业务容器和redis服务有可能不在一台服务器,这时候我们就需要远程连接redis来执行响应的操作。

    一.配置文件

    1、修改redis服务器的配置文件

    vi redis.conf
    
    注释以下绑定的主机地址
    
    # bind 127.0.0.1
    

    vim  redis.conf
    
    bind  0.0.0.0
    
    protected-mode   no
    

    2、修改redis服务器的参数配置

    修改redis的守护进程为no,不启用

    127.0.0.1:6379> config  set   daemonize  "no"
    
    OK
    

    修改redis的保护模式为no,不启用

    127.0.0.1:6379> config   set   protected-mode"no"
    
    OK
    

    或者

    config set requirepass 123 ->123是密码
    

    注意:开启 6379端口

    3、远程连接

    命令:[注意空格]
    1.windows
    redis-cli.exe –h [远程ip] –p [端口号] –a [密码]
    2.linux
    redis-cli –h [远程ip] –p [端口号] –a [密码]
    

    3.1.linux

    $ redis-cli -h 138.138.138.138  -p  6379 
    
    redis>ping
    
    PONG
    

    3.2.windows

    首先进入redis的本地安装目录,按图中命令执行

    在这里插入图片描述


    参考文章:
    1.redis 远程连接方法

    展开全文
  • 整整郁闷了半天时间,redis默认设置中,本地开发的,远程访问是不开放的。所以就是一个设置的问题,去redis.conf文件中把daemonize yes改成no,再重启一下redis,ok连接上了,真是草蛋 ...

     

    整整郁闷了半天时间,redis默认设置中,本地是开发的,远程访问是不开放的。所以就是一个设置的问题,去redis.conf文件中把daemonize yes改成no,再重启一下redis,ok连接上了,真是草蛋


    展开全文
  • 近期在测试小程序的过程中,PHP代码需要连接redis服务器,以做记录。1 安装Redis首先,需要一台Redis服务器。具体安装方式见...本地开发环境是windows系统,生产服务器属于linux系统,...
  • 开发中用到Redis的时候,每次还得启动,如果数据量大的话,还影响本地计算机的性能。本文介绍如何在阿里云学生机上安装运行Redis。 1.服务器安装Redis 我使用xshell这个工具远程连接阿里云。 1.下载Redis: wget ...
  • 转做游戏服务器开发之后,基本上都在写游戏逻辑,关于redis的操作也已经有了现成的接口。今天提交了代码有点空闲时间打算学一学redis。 博主是按照网上的教程使用redis-cli去连接redis,但是之前本地redis已经...
  • 本地 mac 系统配置多个 redis 实例

    千次阅读 2018-07-19 09:30:42
    可能我们有时候,需要多个在本地连接多个 redis 服务,因为 redis 不同于 mysql,mysql可以选择连接各种数据表,而且各个表之间的数据文件是独立的,而 redis 虽然有数据库,但多个数据库文件都存储在一起,dump.rdb...
  • redis

    2019-09-19 18:17:34
    今天服务器短暂的连不上,导致redis无法连接,因此在本地又临时搭建启动一个redis程序,在此再记录一下。 redis中文网官网上面提供的直接就是5.0版本的稳定版,但是只有tar.gz,因为开发机器是windows,所以还是找...
  • 本地环境:开发环境:Windows测试环境:CentOS in Virtualbox虚拟机和宿主机之间有网络桥连接,可以互相访问网络。服务器生产环境: Amazon Linux AMI (从CentOS修改而来)。本地环境和生产环境颇有不同,数据库用的...
  • 调试环境python3.6,调试python操作redis数据库,首先要在本地服务器安装redis数据库。安装参考:http://blog.csdn.net/luanpeng825485697/article/details/79363000 在python3.6下我们使用redis库。 pip ...
  • Redis的基础命令

    2019-10-28 11:28:24
    ./redis-server 启动...连接本地Redis 可视化客户端 有很多BUG 不常用 连接之后有16个数据库默认操作第0个库 bug一般出现在 显示不出来存入的值 redis 实际开发中 是在Java程序里面写命令 redis 编程式客户端 ...
  • Redis 开启远程访问

    2018-08-21 16:35:00
    然后通过本地Redis 客户端连接的时候,就挂了,连不上了。 然后继续发扬有问题问度娘的精神,找到了问题的所在 Redis 默认只允许本地访问,不允许远程访问的,如果需要远程访问,就需要修改一下 R...
  • redis连接池在关闭项目的时候,需要收回连接池,不然redis开发的过程中,所有开发人员本地项目连接redis服务器,经常重启项目会累积很多不能释放的连接,   1.碰到因为客户端接入太多,可以通过修改redis.conf...
  • Redis用一段时间之后会报错,经过反复测试和百度、Google之后才发现是redis连接池在关闭项目的时候,需要收回连接池,不然redis开发的过程中,所有开发人员本地项目连接redis服务器,经常重启项目会累积很多不能...
  • 缘起 send of xxx bytes failed with errno=104 Connection reset ...开发服务器上的php项目中近日出现这个错误,昨天抽空看了下,一开始以为是phpredis扩展有bug,然而本地环境中这个扩展没有问题。 连接一下 redis...
  • Redis如何通过公网访问

    千次阅读 2018-07-12 21:12:25
    为了方便开发人员在本地搭建开发或测试环境,提高开发效率,华为云DCS提供了一个新功能,即通过公网连接Redis缓存实例。 这里需要提醒一点:通过公网访问可能会降低访问效率,所以对于生产环境,还是建议将应用与...
  • 背景:代码本地调试通过,能够连接开发服务器redis,存储键值在过期的时候推送,但是在预生产服务器就无法进行推送。 经过调试发现可以将值存储进redis,但是在手动设置过期的时候,程序无法收到推送通知。 ...
  • 由于网络问题,公司开发环境Redis服务器很不稳定,所以我就启用了本地redis服务端,然后修改了项目的redis连接地址,重启项目,控制台竟然异常,报错信息如下: Caused by: redis.clients.jedis.exceptions....
  • redis配置填坑记录

    2020-08-21 11:27:49
    长时间忙于开发,都忘记了运维的事情了,今天在搭建环境的时候,再中间件服务器群中安装redis服务并启动成功,并能在本地访问成功,但是应用服务器死活访问不了提示“拒绝访问”,后经百度查阅发现自己漏了开启远程...
  • 某一天,我写完本地程序,准备部署到云服务器,然而我的xshell始终是连接不上服务器,或者是连接上反应非常慢,我怀疑阿里云对我的服务器动了什么了(实在是对不住,毕竟我也不知道还有这种事情
  • 支持本机Hosts文件重定向本地域名解析; 支持自定义扩展UP功能命令窗口; 支持高级服务清理工具; 支持UPUPW安全防护功能; 支持PHP功能组件开启关闭; 支持主机性能适配功能; 支持生产开发环境选项; 支持...
  • 文章目录基础环境搭建服务器配置免密登录,配置公钥连接更换阿里Yum源添加CentOS 7 EPEL仓库编译环境安装Git安装nginx安装Redis安装MySQL安装php 服务器配置 免密登录,配置公钥连接本地的公钥复制到服务器 $ ...
  • 已采用共享远程数据库,远程Redis(问题:开发中debug锁行;本地连远程数据库非常慢,慢的离谱,一个接口如果没有预热连接,可能要等50s,最长试过1分钟以上) 想法: 把公共的微服务部署到一台公共服务器上(电脑...
  • SAE支持:提供了新浪SAE平台的强力支持,具备“横跨性”和“平滑性”,支持本地开发和调试以及部署切换,让你轻松过渡到SAE开发,打造全新的SAE开发体验。 RESTFul支持:REST模式提供了RESTFul支持,为你打造...
  • 服务器监控:显示服务器内存信息、CPU信息、磁盘信息、JVM信息等性能指标 ○ 在线用户列表:显示在线用户信息 - 常用功能 ○ 邮件发送:集成邮件发送功能,富文本编辑器支持,发送普通文本,HTML文本等 ○ ...
  • RoutingLogic_v2.0-源码

    2021-03-26 22:33:46
    您可以根据需要安装本地Redis服务器 要下载并安装机器人连接器,我们建议使用git 正在安装 一系列循序渐进的示例告诉您如何运行开发环境。 从gitlab或github下载路由逻辑代码。 git clone <<repository>> 下载...
  • 简单的数据库服务连接Redis,Mongo,Elasticsearch,mysql,sqlite ...)。 MVC模板( ) 动作控制器(websocket)中的实时上下文的概念。 动作控制器中同步或异步执行的概念(Promise,Async,Await)。 ...
  • 我这是使用了Xshell6连接了阿里云服务器的linux,有条件就用Xshell6连接服务器的linux,或者的话在本地安装虚拟机中linux也一样的操作,没有安装的可以自行百度下载虚拟机安装linux Tab按键是补全按键 输入命令的前...

空空如也

空空如也

1 2 3 4
收藏数 79
精华内容 31
关键字:

本地开发连接服务器redis

redis 订阅