netcore 集成redis集群

本文已参与「新人创作礼」活动.一起开启掘金创作之路。

netcore 集成redis集群

netcore集成redis

services.AddStackExchangeRedisCache(options =>
                {
                    options.Configuration = connectionString;
                    options.InstanceName = instanceName;
                });

1、集成redis集群

//单主机模式
//"Host": "XXXXXXX:6379,password=XXXXX,connectTimeout=3000,connectRetry=3,DefaultDatabase=0 ",
//集群模式  

"Host": "XXXXXXX:6379,XXXXXXX:6379,XXXXXXX:6379,serviceName=mymaster,password=XXXXXXX,connectTimeout=3000,connectRetry=3,KeepAlive=180,DefaultDatabase=0,$CLIENT=,$CLUSTER=,$CONFIG=,$ECHO=,$INFO=,$PING=",

\

2、使用哨兵模式集成redis集群   

//哨兵模式   

 "Host": "XXXXXXX:26379,XXXXXXX:26379,XXXXXXX:26379,serviceName=mymaster,password=XXXXXXX,connectTimeout=3000,connectRetry=3,KeepAlive=180,DefaultDatabase=0,allowAdmin = true"

完整的配置： "Redis": {
    //单主机模式
    //"Host": "XXXXXXX:6379,password=XXXXXXX,connectTimeout=3000,connectRetry=3,DefaultDatabase=0 ",
    //集群模式
    //"Host": "XXXXXXX:6379,XXXXXXX:6379,XXXXXXX:6379,serviceName=mymaster,password=XXXXXXX,connectTimeout=3000,connectRetry=3,KeepAlive=180,DefaultDatabase=0,$CLIENT=,$CLUSTER=,$CONFIG=,$ECHO=,$INFO=,$PING=",
    //哨兵模式
    "Host": "XXXXXXX:26379,XXXXXXX:26379,XXXXXXX:26379,serviceName=mymaster,password=XXXXXXX,connectTimeout=3000,connectRetry=3,KeepAlive=180,DefaultDatabase=0,allowAdmin = true"
  },

如何使用？

using System;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Extensions.Caching.Distributed;
using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json;
using Service.Common.Autofac.Attributes;
using Service.Common.helpers;
using Service.Common.utils;
using Utils.Common.utils;

namespace Service.Common.Services
{
    /// <summary>
    /// 
    /// </summary>
    [Service(lifetime = ServiceLifetime.Singleton)]
    public class RedisService
    {
        private readonly IDistributedCache cache;


        public RedisService(IDistributedCache distributedCache)
        {
            cache = distributedCache;
        }



        ///// <summary>
        ///// 这里的 MergeKey 用来拼接 Key 的前缀，具体不同的业务模块使用不同的前缀。
        ///// </summary>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //private string MergeKey(string key)
        //{
        //    if (String.IsNullOrEmpty(key))
        //    {
        //        return "";
        //    }
        //    return prefix + "_" + key;
        //    //return BaseSystemInfo.SystemCode + key;
        //}

        /// <summary>
        /// 根据key获取缓存对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T Get<T>(string key)
        {
            if (String.IsNullOrWhiteSpace(key))
            {
                return default(T);
            }
            String result = Get(key);
            if (String.IsNullOrEmpty(result))
            {
                return default(T);
            }

            return DeserializeObject<T>(result);


        }

        /// <summary>
        /// 根据key获取缓存对象
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public String Get(string key)
        {
            if (String.IsNullOrWhiteSpace(key))
            {
                return "";
            }
            //key = MergeKey(key);
            string result = "";
            if (!string.IsNullOrEmpty(key))
            {
                byte[] bytes = cache.Get(key);
                if (bytes != null && bytes.Length > 0)
                {
                    result = Encoding.UTF8.GetString(bytes);
                }
            }
            return result;
        }


        /// <summary>
        /// 设置缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="expireMinutes"></param>
        public bool Set(string key, object value, int expireMinutes = 1440)
        {
            if (String.IsNullOrWhiteSpace(key))
            {
                return false;
            }
            //String mergeKey = MergeKey(key);
            if (value == null)
            {
                return false;
            }

            expireMinutes = expireMinutes < 1 ? 1440 : expireMinutes;

            DistributedCacheEntryOptions options = new DistributedCacheEntryOptions();
            //设置绝对过期时间 两种写法
            options.AbsoluteExpiration = DateTime.Now.AddMinutes(expireMinutes);
            // options.SetAbsoluteExpiration(DateTime.Now.AddMinutes(30));
            //设置滑动过期时间 两种写法
            //options.SlidingExpiration = TimeSpan.FromSeconds(30);
            //options.SetSlidingExpiration(TimeSpan.FromSeconds(30));
            //添加缓存
            cache.Set(key, SerializeToByte(value), options);
            //刷新缓存
            cache.Refresh(key);
            return true;
        }

        /// <summary>
        /// 设置缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="timeSpan"></param>
        public bool Set(string key, object value, TimeSpan timeSpan)
        {
            if (String.IsNullOrWhiteSpace(key))
            {
                return false;
            }
            //String mergeKey = MergeKey(key);
            if (value == null)
            {
                return false;
            }
            DistributedCacheEntryOptions options = new DistributedCacheEntryOptions();
            //设置绝对过期时间 两种写法
            // options.AbsoluteExpiration = DateTime.Now.AddMinutes(expireMinutes);
            // options.SetAbsoluteExpiration(DateTime.Now.AddMinutes(30));
            //设置滑动过期时间 两种写法
            options.SlidingExpiration = timeSpan;
            //options.SetSlidingExpiration(TimeSpan.FromSeconds(30));
            //添加缓存
            cache.Set(key, SerializeToByte(value), options);
            //刷新缓存
            cache.Refresh(key);

            return true;
        }


        /// <summary>
        /// 判断在缓存中是否存在该key的缓存数据
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Exists(string key)
        {
            if (String.IsNullOrWhiteSpace(key))
            {
                return false;
            }
            //key = MergeKey(key);
            bool returnBool = true;
            byte[] val = cache.Get(key);
            if (val == null || val.Length == 0)
            {
                returnBool = false;
            }
            return returnBool;
        }

        /// <summary>
        /// 移除指定key的缓存
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Remove(string key)
        {
            if (String.IsNullOrWhiteSpace(key))
            {
                return true;
            }
            //key = MergeKey(key);
            bool returnBool = false;
            cache.Remove(key);
            if (Exists(key) == false)
            {
                returnBool = true;
            }
            return returnBool;
        }

        /// <summary>
        /// 异步设置
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public async Task SetAsync(string key, object value)
        {
            if (String.IsNullOrWhiteSpace(key))
            {
                return;
            }
            //key = MergeKey(key);
            await cache.SetAsync(key, SerializeToByte(value));
        }

        /// <summary>
        /// 根据key获取缓存对象
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<object> GetAsync(string key)
        {
            if (String.IsNullOrWhiteSpace(key))
            {
                return Task.FromResult<Object>(null);
            }
            //key = MergeKey(key);
            string returnString = null;
            var value = await cache.GetAsync(key);
            if (value != null)
            {
                returnString = Encoding.UTF8.GetString(value);
            }
            return returnString;
        }



        /// <summary>
        /// 反序列化对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        private T DeserializeObject<T>(String value)
        {

            if (value == null)
            {
                return default(T);
            }

            Type type = typeof(T);
            if (CommonUtils.IsPrimitive(type) || type.IsPrimitive)
            {
                return (T)CommonUtils.ConvertSimpleType(value, type);
            }
            else
            {
                return (T)JsonConvert.DeserializeObject(value, type);
            }

        }

        private byte[] SerializeToByte(Object value)
        {
            string serializeObject = SerializeObject(value);
            if (!String.IsNullOrEmpty(serializeObject))
            {
                return Encoding.UTF8.GetBytes(serializeObject);
            }

            return null;
        }

        private String SerializeObject(Object value)
        {
            if (value == null)
            {
                return "";
            }

            Type type = value.GetType();
            if (CommonUtils.IsPrimitive(type) || type.IsPrimitive)
            {
                return value.ToString();
            }
            else
            {
                return JsonConvert.SerializeObject(value);
            }

        }





    }
}