private void CreateRedisClient()
{
string writeServerList = AppRuntime.Instance.CurrentApplication.ConfigSource.Config.Redis.WriteHosts;
string readOnlyServerList = AppRuntime.Instance.CurrentApplication.ConfigSource.Config.Redis.ReadOnlyHosts;
string[] writeHosts = writeServerList.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
string[] readOnlyHosts = readOnlyServerList.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
RedisClientManagerConfig config = new RedisClientManagerConfig();
config.MaxWritePoolSize = AppRuntime.Instance.CurrentApplication.ConfigSource.Config.Redis.MaxWritePoolSize;
config.MaxReadPoolSize = AppRuntime.Instance.CurrentApplication.ConfigSource.Config.Redis.MaxReadPoolSize;
config.AutoStart = AppRuntime.Instance.CurrentApplication.ConfigSource.Config.Redis.AutoStart;
this.redisClientManager = new PooledRedisClientManager(writeHosts, readOnlyHosts, config);
this.redisClient = (RedisClient)redisClientManager.GetClient();
this.redistTypedClient = this.redisClient.As <TMessage>();
this.redisDistributedLock = new DistributedLock();
this.redisDistributedLock.Lock(lockName, 0, 0, out this.lockExpire, this.redisClient);
this.redisTypedTransaction = this.redistTypedClient.CreateTransaction();
}
public void Does_throw_TimeoutException_when_PoolTimeout_exceeded()
{
var config = new RedisClientManagerConfig {
MaxWritePoolSize = 4,
MaxReadPoolSize = 4,
AutoStart = false
};
using (var manager = new PooledRedisClientManager(this._testReadWriteHosts, this._testReadOnlyHosts, config)) {
manager.PoolTimeout = 100;
manager.Start();
var masters = Enumerable.Range(0, 4).Select(i => manager.GetClient()).ToList();
Console.WriteLine(masters.Count);
try {
manager.GetClient();
Assert.Fail("Should throw TimeoutException");
} catch (TimeoutException ex) {
Assert.That(ex.Message, Does.StartWith("Redis Timeout expired."));
}
var slaves = Enumerable.Range(0, 4).Select(i => manager.GetReadOnlyClient()).ToList();
Console.WriteLine(slaves.Count);
try {
manager.GetReadOnlyClient();
Assert.Fail("Should throw TimeoutException");
} catch (TimeoutException ex) {
Assert.That(ex.Message, Does.StartWith("Redis Timeout expired."));
}
}
}
private RedisManager(string[] readWriteHosts, RedisConfig cfg)
{
if (redisClientManager == null)
{
this.readWriteHosts = readWriteHosts;
var confg = new RedisClientManagerConfig()
{
MaxReadPoolSize = cfg.MaxReadPoolSize,
MaxWritePoolSize = cfg.MaxWritePoolSize,
AutoStart = true,
};
if (cfg.DefaultDB != 0)
{
confg.DefaultDb = cfg.DefaultDB;
}
redisClientManager = new PooledRedisClientManager(readWriteHosts, readWriteHosts,
confg
);
redisClientManager.SocketReceiveTimeout = 60000;
redisClientManager.SocketSendTimeout = 60000;
}
}
private void linkLabel37_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
//int slot = CRC16.GetSlot("template");
//using (var channel = RedisClientManager.GetClient())
//{
// var data= channel.RawCommand(Encoding.UTF8.GetBytes("CLUSTER"), Encoding.UTF8.GetBytes("NODES"));
// string liunes = Encoding.UTF8.GetString(data.Data);
//}
// redis配置文件信息 password@ip:port
RedisConfig setting = RedisConfig.GetConfig();
RedisClientManagerConfig config = new RedisClientManagerConfig();
config.MaxWritePoolSize = setting.MaxWritePoolSize;
config.MaxReadPoolSize = setting.MaxReadPoolSize;
config.AutoStart = setting.AutoStart;
config.DefaultDb = setting.DefaultDb;
var node = new ClusterNode("127.0.0.1", 7001);
var c = RedisClusterFactory.Configure(node, config);
int taskQty = 1;
for (int index = 1; index <= taskQty; index++)
{
Task.Factory.StartNew(() => ExecuteCluster(c));
}
//var keys = c.Keys("*");
//c.FlushAll();
}
/// <summary>
/// 配置 REDIS 集群
/// </summary>
/// <param name="nodes">集群节点</param>
/// <param name="config"><see cref="RedisClientManagerConfig"/> 客户端缓冲池配置</param>
/// <returns></returns>
public static RedisCluster Configure(IEnumerable <ClusterNode> nodes, RedisClientManagerConfig config)
{
if (nodes == null)
{
throw new ArgumentNullException("nodes");
}
if (nodes == null || nodes.Count() == 0)
{
throw new ArgumentException("There is no nodes to configure cluster.");
}
if (_cluster == null)
{
lock (_factory)
{
if (_cluster == null)
{
RedisCluster c = new RedisCluster(nodes, config);
_cluster = c;
}
}
}
return(_cluster);
}
static RedisFactory()
{
CacheSetting cacheSetting = CacheSetting.GetInstance();
if (cacheSetting != null)
{
var connectionPools = new CustomShardedConnectionPool[cacheSetting.Pools.Count];
int index = 0;
foreach (CacheSetting.PoolConfig poolConfig in cacheSetting.Pools)
{
long initalDb = poolConfig.Db ?? 0L;
RedisClientManagerConfig config = poolConfig.MaxReadPoolSize.HasValue || poolConfig.MaxWritePoolSize.HasValue?new RedisClientManagerConfig():null;
if (config != null)
{
config.MaxReadPoolSize = poolConfig.MaxReadPoolSize.HasValue
? poolConfig.MaxReadPoolSize.Value
: 50;
config.MaxWritePoolSize = poolConfig.MaxWritePoolSize.HasValue
? poolConfig.MaxWritePoolSize.Value
: 50;
}
var pool = new CustomShardedConnectionPool(poolConfig.Name, poolConfig.Weight, config, initalDb,
poolConfig.Hosts);
pool.PoolTimeout = poolConfig.PoolTimeout ?? 1000;
pool.ConnectTimeout = poolConfig.ConnectTimeout;
pool.SocketSendTimeout = poolConfig.SocketSendTimeout;
pool.SocketReceiveTimeout = poolConfig.SocketReceiveTimeout;
connectionPools[index] = pool;
index++;
}
RedisClientManager = new AutoDetectShardedRedisClientManager(connectionPools);
}
}
public Redis(int maxWritePoolSize, int maxReadPoolSize, string[] readWriteHosts, string[] readOnlyHosts, long initalDb, TimeSpan defaultExpirationTime)
{
try
{
try
{
var config = new RedisClientManagerConfig
{
MaxWritePoolSize = maxWritePoolSize, //“写”链接池链接数
MaxReadPoolSize = maxReadPoolSize, //“读”链接池链接数
AutoStart = true,
};
PooledRedisClientManager.Add(initalDb, new PooledRedisClientManager(readWriteHosts, readOnlyHosts, config, initalDb, null, null));
}
catch (Exception e)
{
//LFFK.LogManager.Error(CacheConstants.Error_Init, e);
}
DefaultExpirationTime = defaultExpirationTime;
InitalDb = initalDb;
ReadWriteHost = readWriteHosts[0];
MaxWritePoolSize = maxWritePoolSize;
MaxReadPoolSize = maxReadPoolSize;
ReadWriteHosts = readWriteHosts;
ReadOnlyHosts = readWriteHosts;
PersistentClient.Add(initalDb, new RedisClient(ReadWriteHost.Split(':')[0], Convert.ToInt32(ReadWriteHost.Split(':')[1]), db: initalDb));
}
catch (Exception ex)
{
throw new Exception(Constants.Error_Data_InitConfigFailed, ex);
}
}
/// <summary>
/// 创建链接池管理对象
/// </summary>
private static void CreateManager()
{
var settings = RedisCacheSection.GetRedisCacheSettings();
if (settings == null || !settings.Any())
{
return;
}
RedisCacheSetting redisCacheSetting = settings.FirstOrDefault((RedisCacheSetting c) => c.Key == "BTPCache");
if (redisCacheSetting == null)
{
return;
}
string[] writeList = new[] { redisCacheSetting.Host };
string[] readList = new[] { redisCacheSetting.Host };
int num = string.IsNullOrEmpty(ConfigurationManager.AppSettings["RedisPoolSize"]) ? 60 : System.Convert.ToInt32(ConfigurationManager.AppSettings["RedisPoolSize"]);
int value = string.IsNullOrEmpty(ConfigurationManager.AppSettings["PoolTimeOutSecond"]) ? 20 : System.Convert.ToInt32(ConfigurationManager.AppSettings["PoolTimeOutSecond"]);
RedisClientManagerConfig redisClientManagerConfig = new RedisClientManagerConfig();
redisClientManagerConfig.MaxWritePoolSize = num;
redisClientManagerConfig.MaxReadPoolSize = num;
redisClientManagerConfig.AutoStart = true;
//redis = new BasicRedisClientManager(readList, writeList);
redis = new PooledRedisClientManager(readList, writeList, redisClientManagerConfig)
{
PoolTimeout = 2000,
ConnectTimeout = 500
};
}
public PooledRedisClientManager GetPooledRedisClient(long db)
{
try
{
PooledRedisClientManager pooledRedisClientManager = null;
if (PooledRedisClientManager.TryGetValue(db, out pooledRedisClientManager))
{
return(pooledRedisClientManager);
}
else
{
var config = new RedisClientManagerConfig
{
MaxWritePoolSize = MaxWritePoolSize, //“写”链接池链接数
MaxReadPoolSize = MaxReadPoolSize, //“读”链接池链接数
AutoStart = true,
};
pooledRedisClientManager = new PooledRedisClientManager(ReadWriteHosts, ReadOnlyHosts, config, db, null, null);
PooledRedisClientManager.Add(db, pooledRedisClientManager);
return(pooledRedisClientManager);
}
}
catch (Exception ex)
{
return(null);
}
}
public RedisConnectionPool(string redisConnectionString, long database, RedisLuaScriptManager luaScriptManager)
{
// Init the pooledRedisClient Manager
RedisClientManagerConfig config = new RedisClientManagerConfig();
config.DefaultDb = database;
config.MaxReadPoolSize = RedisConnectionPool.DEFAULT_MAX_READ_POOL_SIZE;
config.MaxWritePoolSize = RedisConnectionPool.DEFAULT_MAX_WRITE_POOL_SIZE;
this.redisManagerPool =
new PooledRedisClientManager(
new string[] { redisConnectionString },
new string[] { redisConnectionString },
config);
this.RequestBatchSize = RedisConnectionPool.DEFAULT_BATCH_SIZE;
this.WindowMicroSec = RedisConnectionPool.DEFAULT_WINDOW_MICRO_SEC;
this.Active = true;
this.redisRequestQueue = new Queue <RedisRequest>(this.RequestBatchSize);
this.redisResponseVisitor = new RedisResponseVisitor();
this.txEntryVisitor = new RedisTxEntryRequestVisitor(luaScriptManager);
this.versionEntryVisitor = new RedisVersionEntryRequestVisitor(luaScriptManager);
this.spinLock = new SpinLock();
lastFlushTime = DateTime.Now.Ticks / 10;
}
static PooledRedisClientManager ParseConnectionString(string connName)
{
var conn = ConfigurationManager.ConnectionStrings[connName];
if (conn == null)
{
throw new ConfigurationErrorsException(String.Format("缺少命名为“{0}”的连接字符串", connName));
}
List <string> readWriteHosts = new List <string>();
List <string> readOnlyHosts = new List <string>();
RedisClientManagerConfig config = new RedisClientManagerConfig();
string[] items = conn.ConnectionString.Split(';');
foreach (var kv in items)
{
if (String.IsNullOrWhiteSpace(kv))
{
continue;
}
var vs = kv.Split('=');
if (vs.Length != 2)
{
throw new ArgumentException("Redis 的连接串在 " + kv + " 处存在错误");
}
var key = vs[0].Trim().Replace(" ", "").ToLower();
var value = vs[1].Trim();
switch (key)
{
case "readwriteserver":
readWriteHosts.Add(value);
break;
case "readserver":
readOnlyHosts.Add(value);
break;
case "maxreadpoolsize":
config.MaxReadPoolSize = Int32.Parse(value);
break;
case "maxwritepoolsize":
config.MaxWritePoolSize = Int32.Parse(value);
break;
case "autostart":
config.AutoStart = Boolean.Parse(value);
break;
case "defaultdb":
config.DefaultDb = Int32.Parse(value);
break;
default:
throw new ArgumentException("无法识别的 Redis 连接串属性，发生在 " + kv);
}
}
return(new PooledRedisClientManager(readWriteHosts, readOnlyHosts, config));
}
/// <summary>
/// Redis建立连接池
/// </summary>
private void CreateManagerByRedis()
{
// 读取Redis主机IP配置信息
// 有密码的格式：redis:[email protected]:6379
// 无密码的格式：127.0.0.1:6379
string[] redisMasterHosts = readWriteHosts.Split(',');
// 如果Redis服务器是主从配置，则还需要读取Redis Slave机的IP配置信息
string[] redisSlaveHosts = null;
if (!string.IsNullOrWhiteSpace(readOnlyHosts))
{
redisSlaveHosts = readOnlyHosts.Split(',');
}
var redisClientManagerConfig = new RedisClientManagerConfig
{
MaxWritePoolSize = maxWritePoolSize,
DefaultDb = defaultDb,
AutoStart = true
};
Manager = new PooledRedisClientManager(redisMasterHosts, redisSlaveHosts, redisClientManagerConfig)
{
PoolTimeout = 2000,
ConnectTimeout = 1000
};
}
private IRedisClientsManager GetInstance(bool masterOnly = false)
{
var redisClientManager = default(IRedisClientsManager);
var redisConfig = new RedisClientManagerConfig
{
MaxWritePoolSize = AppConfigKeys.MAX_WRITE_POOL_SIZE.ConfigValue().ToInt32(),
MaxReadPoolSize = AppConfigKeys.MAX_READ_POOL_SIZE.ConfigValue().ToInt32(),
AutoStart = true
};
string[] readWriteHosts = AppConfigKeys.REDIS_READ_WRITE_SERVERS.ConfigValue().Split(';');
string[] readOnlyHosts = AppConfigKeys.REDIS_READONLY_SERVERS.ConfigValue().Split(';');
if (masterOnly)
{
redisClientManager = new PooledRedisClientManager(readWriteHosts, readWriteHosts, redisConfig);
}
else
{
redisClientManager = new PooledRedisClientManager(readWriteHosts, readOnlyHosts, redisConfig);
}
return(redisClientManager);
}
static RedisManager()
{
RedisClientManagerConfig redisConfig = new RedisClientManagerConfig();
redisConfig.MaxWritePoolSize = 128;
redisConfig.MaxReadPoolSize = 128;
ClientManager = new PooledRedisClientManager(new string[] { "127.0.0.1" }, new string[] { "127.0.0.1" }, redisConfig);
}
private IRedisClientsManager GetInstance(RedisClientManagerType type)
{
var manager = default(IRedisClientsManager);
switch (type)
{
case RedisClientManagerType.News:
var newsConfig = new RedisClientManagerConfig
{
MaxWritePoolSize = ConfigKeys.NEWS_MAX_WRITE_POOL_SIZE.ConfigValue().ToInt32(),
MaxReadPoolSize = ConfigKeys.NEWS_MAX_READ_POOL_SIZE.ConfigValue().ToInt32(),
AutoStart = true
};
string[] newsReadWriteHosts = ConfigKeys.NEWS_REDIS_READ_WRITE_SERVERS.ConfigValue().Split(ASCII.SEMICOLON_CHAR);
string[] newsReadOnlyHosts = ConfigKeys.NEWS_REDIS_READONLY_SERVERS.ConfigValue().Split(ASCII.SEMICOLON_CHAR);
manager = new PooledRedisClientManager(newsReadWriteHosts, newsReadWriteHosts, newsConfig);
break;
case RedisClientManagerType.Theme:
var themeConfig = new RedisClientManagerConfig
{
MaxWritePoolSize = ConfigKeys.THEME_MAX_WRITE_POOL_SIZE.ConfigValue().ToInt32(),
MaxReadPoolSize = ConfigKeys.THEME_MAX_READ_POOL_SIZE.ConfigValue().ToInt32(),
AutoStart = true
};
string[] themeReadWriteHosts = ConfigKeys.THEME_REDIS_READ_WRITE_SERVERS.ConfigValue().Split(ASCII.SEMICOLON_CHAR);
string[] themeRadOnlyHosts = ConfigKeys.THEME_REDIS_READONLY_SERVERS.ConfigValue().Split(ASCII.SEMICOLON_CHAR);
manager = new PooledRedisClientManager(themeReadWriteHosts, themeReadWriteHosts, themeConfig);
break;
case RedisClientManagerType.Mixed:
var mixedConfig = new RedisClientManagerConfig
{
MaxWritePoolSize = AppConfigKeys.MAX_WRITE_POOL_SIZE.ConfigValue().ToInt32(),
MaxReadPoolSize = AppConfigKeys.MAX_READ_POOL_SIZE.ConfigValue().ToInt32(),
AutoStart = true
};
string[] readWriteHostsMixed = AppConfigKeys.REDIS_READ_WRITE_SERVERS.ConfigValue().Split(ASCII.SEMICOLON_CHAR);
string[] readOnlyHostsMixed = AppConfigKeys.REDIS_READONLY_SERVERS.ConfigValue().Split(ASCII.SEMICOLON_CHAR);
manager = new PooledRedisClientManager(readWriteHostsMixed, readOnlyHostsMixed, mixedConfig);
break;
default:
break;
}
return(manager);
}
private static PooledRedisClientManager CreateManager(string[] readWriteHosts, string[] readOnlyHosts)
{
RedisClientManagerConfig redisClientManagerConfig = new RedisClientManagerConfig();
redisClientManagerConfig.AutoStart = true;
redisClientManagerConfig.MaxReadPoolSize = 5;
redisClientManagerConfig.MaxWritePoolSize = 5;
return(new PooledRedisClientManager(readWriteHosts, readOnlyHosts, redisClientManagerConfig));
}
private static void CreateManager()
{
RedisClientManagerConfig redisClientManagerConfig = new RedisClientManagerConfig
{
MaxWritePoolSize = CacheConfig.MaxWritePoolSize,
MaxReadPoolSize = CacheConfig.MaxReadPoolSize
};
string[] WriteServerConStr = SplitString(CacheConfig.GetRedisWriteConnectionString(), ",");
string[] ReadServerConStr = SplitString(CacheConfig.GetRedisReadConnectionString(), ",");
clientManager = new PooledRedisClientManager(WriteServerConStr, ReadServerConStr, redisClientManagerConfig);
}
private static PooledRedisClientManager CreateManager(string[] readWriteHosts, string[] readOnlyHosts)
{
var redisClientManagerConfig = new RedisClientManagerConfig
{
MaxWritePoolSize = 5, // “写”链接池链接数
MaxReadPoolSize = 5, // “读”链接池链接数
AutoStart = true
};
// 支持读写分离，均衡负载
return(new PooledRedisClientManager(readWriteHosts, readOnlyHosts, redisClientManagerConfig));
}
static RedisManager()
{
RedisClientManagerConfig redisConfig = new RedisClientManagerConfig();
redisConfig.MaxWritePoolSize = 128;
redisConfig.MaxReadPoolSize = 128;
//读写分离，多台Redis组成集群，一台Redis服务器瘫痪了，它会自动切换到另外一台服务器。
//读写分离，几台服务器是用来读取数据的，另外几台服务器是用来写数据的。
//（new string[] {"127.0.0.1","192.168.1.6"}）数组，可以写多个ip地址，就是多台服务器的意思。
ClientManager = new PooledRedisClientManager(new string[] { "127.0.0.1" },
new string[] { "127.0.0.1" }, redisConfig);
}
/// <summary>
/// 获取redis连接池客户端
/// </summary>
/// <returns></returns>
public static IRedisClient GetRedisPoolClient()
{
RedisClientManagerConfig config = new RedisClientManagerConfig();
config.DefaultDb = ConfigHelper.DistributedLockDefaultDb;
config.AutoStart = true;
config.MaxReadPoolSize = DistributedLockConfig.DistributedLockRedisServersMaxPoolClient;
config.MaxWritePoolSize = DistributedLockConfig.DistributedLockRedisServersMaxPoolClient;
List <string> servers = GetDistributedLockRedisServerList();
PooledRedisClientManager pool = new PooledRedisClientManager(servers, servers, config);
return(pool.GetClient());
}
static RedisManage()
{
RedisClientManagerConfig redisConfig = new RedisClientManagerConfig();
redisConfig.MaxWritePoolSize = 128;
redisConfig.MaxReadPoolSize = 128;
//可以读写分离，指定一台服务器读，一台写。
// new PooledRedisClientManage(读写的服务器地址，只读的服务器地址
ClientManager = new PooledRedisClientManager(
new string[] { "[email protected]:6379" },
new string[] { "[email protected]:6379" }, redisConfig);
}
private PooledRedisClientManager CreateManager(
string[] readWriteHosts, string[] readOnlyHosts, long defaultDb = 0)
{
RedisClientManagerConfig _redisConfig = new RedisClientManagerConfig();
_redisConfig.AutoStart = true;
_redisConfig.MaxReadPoolSize = readOnlyHosts.Length * 20;
_redisConfig.MaxWritePoolSize = readWriteHosts.Length * 20;
_redisConfig.DefaultDb = defaultDb;
PooledRedisClientManager _prm = new PooledRedisClientManager(readWriteHosts, readOnlyHosts, _redisConfig);
return(_prm);
}
static RedisCache()
{
var readPoolSize = AppConfig.GetValue <int>("RedisReadPoolSize");
var writePoolSize = AppConfig.GetValue <int>("RedisWritePoolSize");
var serverList = AppConfig.GetValue("RedisServer").Split(',');
var config = new RedisClientManagerConfig
{
AutoStart = true,
MaxReadPoolSize = readPoolSize > 0 ? readPoolSize : 20,
MaxWritePoolSize = writePoolSize > 0 ? writePoolSize : 20,
};
manager = new PooledRedisClientManager(serverList, null, config);
}
/// <summary>
/// 创建链接池管理对象
/// </summary>
private static void CreateManager()
{
string[] WriteServerConStr = RedisConfigInfo.WriteServerList.Split(',');
string[] ReadServerConStr = RedisConfigInfo.ReadServerList.Split(',');
RedisClientManagerConfig redisClientManagerConfig = new RedisClientManagerConfig();
{
redisClientManagerConfig.MaxWritePoolSize = RedisConfigInfo.MaxWritePoolSize;
redisClientManagerConfig.MaxReadPoolSize = RedisConfigInfo.MaxReadPoolSize;
redisClientManagerConfig.AutoStart = RedisConfigInfo.AutoStart;
}
prcManager = new PooledRedisClientManager(ReadServerConStr, WriteServerConStr, redisClientManagerConfig);
}
/// <summary>
/// 静态构造方法，初始化链接池管理对象
/// </summary>
static RedisClientManager()
{
string[] writeHosts = _config.WriteServerConnString.Split(',');
string[] readHosts = _config.ReadServerConnString.Split(',');
RedisClientManagerConfig config = new RedisClientManagerConfig();
config.MaxWritePoolSize = _config.MaxWritePoolSize;
config.MaxReadPoolSize = _config.MaxReadPoolSize;
config.AutoStart = _config.AutoStart;
config.DefaultDb = _config.DefaultDb;
_pool = new PooledRedisClientManager(writeHosts, readHosts, config);
}
/**
* @ 构造函数
* @ writeHost 写入数据主机列表
* @ readHost 读取数据主机列表
* @ config 连接池的配置
* @ initalDb 默认连接的数据库，如果config没有指定defaultDb，initalDb 默认为 0，有可能连接不上
* @ poolSizeMultiplier pool大小的跨度 ，计算公式：db * multiplier，如10个数据库，mutiplier为2，则最终pool的大小为：10*2
* @ poolTimeOutSeconds pool超时时间 ，秒
* */
public RedisCacheExpiration(IEnumerable <string> writeHost, IEnumerable <string> readHost, RedisClientManagerConfig config = null, int initalDb = 0, int?poolSizeMultiplier = 10, int?poolTimeOutSeconds = 2)
{
if (writeHost.IsNullOrEmpty() || readHost.IsNullOrEmpty())
{
throw new ArgumentNullException("必须指定参数：writeHost和readHost的值");
}
if (config == null)
{
config = new RedisClientManagerConfig();
}
redisPool = new PooledRedisClientManager(writeHost, readHost, config, initalDb, poolSizeMultiplier, poolTimeOutSeconds);
if (!config.AutoStart)
{
redisPool.Start();
}
}
private RedisManager()
{
var config = new RedisClientManagerConfig
{
MaxWritePoolSize = 5,
MaxReadPoolSize = 5,
AutoStart = true
};
_manager = new PooledRedisClientManager(
new[] { "deyi@[email protected]:6379" },
new[] { "deyi@[email protected]:6380", "deyi@[email protected]:6381" }, config);
// _manager = new PooledRedisClientManager(
// new[] { "[email protected]:6379" },
// new[] { "[email protected]:6380", "[email protected]:6381" }, config);
}
public void SetServerInfo(string host, int maxPoolSize)
{
this.host = host;
string[] writeHost = new string[]
{
host
};
string[] readHosts = writeHost;
System.Collections.Generic.IEnumerable <string> arg_35_0 = writeHost;
System.Collections.Generic.IEnumerable <string> arg_35_1 = readHosts;
RedisClientManagerConfig redisClientManagerConfig = new RedisClientManagerConfig();
redisClientManagerConfig.MaxWritePoolSize = maxPoolSize;
redisClientManagerConfig.MaxReadPoolSize = maxPoolSize;
redisClientManagerConfig.AutoStart = true;
this._pooledRedisClientManager = new PooledRedisClientManager(arg_35_0, arg_35_1, redisClientManagerConfig);
}
/// <summary>
/// 建立连接池
/// </summary>
private void CreateManager()
{
// 读取Redis主机IP配置信息
// 有密码的格式：redis:[email protected]:6379
// 无密码的格式：127.0.0.1:6379
var pools = zkhelper.pools;
string[] redisMasterHosts = pools.Select(m => m.Addr).ToArray();
// 如果Redis服务器是主从配置，则还需要读取Redis Slave机的IP配置信息
string[] redisSlaveHosts = null;
//string slaveConnection = null;
//if (!string.IsNullOrWhiteSpace(slaveConnection))
//{
// redisSlaveHosts = slaveConnection.Split(',');
//}
var redisClientManagerConfig = new RedisClientManagerConfig
{
MaxWritePoolSize = maxWritePoolSize,
DefaultDb = defaultDb,
AutoStart = true
};
// 创建Redis连接池
if (Manager != null)
{
Manager.Dispose();
log.InfoFormat("销毁Redis连接池完成");
}
#region 只为打日志
string redisMasterHostsStr = "";
foreach (var itemHost in redisMasterHosts)
{
redisMasterHostsStr += itemHost + ",";
}
log.InfoFormat("创建Redis连接池，RedisMasterHosts：{0}", redisMasterHostsStr.TrimEnd(','));
#endregion 只为打日志
Manager = new PooledRedisClientManager(redisMasterHosts, redisSlaveHosts, redisClientManagerConfig)
{
PoolTimeout = 2000,
ConnectTimeout = 1000
};
}
private static void CreateRedisClient()
{
string writeServerList = AppRuntime.Instance.CurrentApp.ConfigSource.Config.Redis.WriteHosts;
string readOnlyServerList = AppRuntime.Instance.CurrentApp.ConfigSource.Config.Redis.ReadOnlyHosts;
string[] writeHosts = writeServerList.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
string[] readOnlyHosts = readOnlyServerList.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
RedisClientManagerConfig config = new RedisClientManagerConfig();
config.MaxWritePoolSize = AppRuntime.Instance.CurrentApp.ConfigSource.Config.Redis.MaxWritePoolSize;
config.MaxReadPoolSize = AppRuntime.Instance.CurrentApp.ConfigSource.Config.Redis.MaxReadPoolSize;
config.AutoStart = AppRuntime.Instance.CurrentApp.ConfigSource.Config.Redis.AutoStart;
redisClientManager = new PooledRedisClientManager(writeHosts, readOnlyHosts, config);
redisClient = (RedisClient)redisClientManager.GetClient();
}
