关于ServiceStack.Redis无法读取传输-BasicRedisClientManager和redis无法获取连接的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于.Net使用Re
关于ServiceStack.Redis无法读取传输-BasicRedisClientManager和redis无法获取连接的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于.Net使用Redis详解之ServiceStack.Redis、C# 通过ServiceStack 操作Redis、centos 安装 redis +RedisDesktopManager 连接 redis、com.amazonaws.services.identitymanagement.model.ListAttachedRolePoliciesRequest的实例源码等相关知识的信息别忘了在本站进行查找喔。
本文目录一览：- ServiceStack.Redis无法读取传输-BasicRedisClientManager（redis无法获取连接）
- .Net使用Redis详解之ServiceStack.Redis
- C# 通过ServiceStack 操作Redis
- centos 安装 redis +RedisDesktopManager 连接 redis
- com.amazonaws.services.identitymanagement.model.ListAttachedRolePoliciesRequest的实例源码
ServiceStack.Redis无法读取传输-BasicRedisClientManager（redis无法获取连接）
尝试通过ServiceStack.Redis读取Redis列表时，间歇性出现以下错误：“无法从传输连接读取数据：已建立的连接被主机中的软件中止了”。我想知道我如何使用ServiceStack可靠地连接和池化Redis的整个概念是否是错误的。这是我使用密封类和单例模式进行连接的代码：
public sealed class RedisClientBase{ public BasicRedisClientManager Redis; private static readonly RedisClientBase instance = new RedisClientBase(); private RedisClientBase() { Redis = new BasicRedisClientManager("mypassword@localhost:6379"); } public static RedisClientBase Instance { get { return instance; } }}然后，我实例化另一个使用单例的类：
public class RedisBarSetData{ private static RedisClient Redis; protected IRedisTypedClient<BarSet> redisBarSetClient; protected string instrument_key; public RedisBarSetData() { Redis = (RedisClient)RedisClientBase.Instance.Redis.GetClient(); redisBarSetClient = Redis.As<BarSet>(); } ~RedisBarSetData() { if (Redis != null) Redis.Dispose(); } public List<BarSet> getData(BarSets data) { setKeys(data); // instrument_key is set in here var redisBarSetClientList = redisBarSetClient.Lists[instrument_key]; List<BarSet> barSetData; barSetData = redisBarSetClientList.GetAll(); // <-- exception here (sometimes) return(barSetData); }}这又是从“服务” DTO回调中实例化和调用的：
public class JmaSetsService : Service{ public object Get(JmaSets request) { RedisBarSetData barSetData = new RedisBarSetData(); BarSets barSets = new BarSets(request); barSetList = barSetData.getData(barSets); return barSetList; }}然后，我使用“邮递员”发布到该路线。多数点击“发送”会返回数据。有些例外。例外是尝试从代码中以注释“
<-例外”指示的redis读取内容时。现在，另一点是，我最近通过设置配置文件将Redis配置为使用密码。我提到这一点是因为我之前不记得有这个问题，但这也不可能相关，不知道。
就释放Redis连接而言，我的想法是我的析构函数调用Redis。当RedisBarSetData（）超出范围时处置。这是处理它的可靠方法还是有更好的方法？我看到有人在获得池化客户端时使用“
using”语句，但是我在类中只有一个地方有很多“ using”语句，而不是调用：“ Redis
=（RedisClient）RedisClientBase.Instance.Redis .GetClient（）;”
如果我有很多用于该类的方法，那么我必须在每个方法中重复执行代码吗？
- 当我说“我以前不记得有这个问题”时，我正在将这种模式用于数十个工作的DTO。不确定为什么现在失败了吗？
答案1
小编典典您不应持有RedisClient或IRedisTypedClient<BarSet>封装了非线程安全的Redis
TCP连接的任何单例实例。相反，您可以保留-的单例实例，IRedisClientsManager这是提供线程安全的Redis Client
Factory（如数据库连接池）的目的。
如果您还使用ServiceStack
Services，则在ServiceStack的IOC中注册依赖项会更容易，因此IRedisClientsManager可以像其他任何依赖项一样注入，例如AppHost.Configure()：
container.Register<IRedisClientsManager>(c => new BasicRedisClientManager("mypassword@localhost:6379"));这将允许您base.Redis在ServiceStack Services中使用RedisClient属性，例如：
public class JmaSetsService : Service{ public object Get(JmaSets request) { var redisBarSets = base.Redis.As<BarSet>(); return redisBarSets.Lists[instument_key].GetAll(); }}如果您使用base.Redis，则不必显式处理RedisClient，因为它已经
由Service自动处理，即：
public class Service{ ... public virtual void Dispose() { if (redis != null) redis.Dispose(); ... }}您还可以IRedisClientsManager像其他任何依赖项一样，使用公共属性或Constructor参数将其注入自己的类中，例如：
public class RedisBarSetData{ public virtual IRedisClientsManager RedisManager { get; set; } private IRedisClient redis; public virtual IRedisClient Redis { get { return redis ?? (redis = RedisManager.GetClient()); } } public override void Dispose() { if (redis != null) redis.Dispose(); } public List<BarSet> getData(BarSets data) { setKeys(data); // instrument_key is set in here return Redis.As<BarSet>().Lists[instrument_key].GetAll(); }}然后，您可以使用以下方法在ServiceStack的IOC中进行注册和自动连线：
container.RegisterAutoWired<RedisBarSetData>();然后，您可以将其用作服务中的依赖项：
public class JmaSetsService : Service{ public RedisBarSetData RedisBarSetData { get; set; } public object Get(JmaSets request) { return RedisBarSetData.getData(new BarSets(request)); }}创建您自己的基类的一种替代方法是从预先存在的LogicBase基类继承，该基类已经具有
IRedisClientsManager属性并且位于样板之上。
.Net使用Redis详解之ServiceStack.Redis
序言
本篇从.Net如何接入Reis开始，直至.Net对Redis的各种操作，为了方便学习与做为文档的查看，我做一遍注释展现，其中会对list的阻塞功能和事务的运用做二个案例，进行记录学习。
Redis官方推荐的.NET驱动类库为Service.Stack.Redis。然而网上对这个类库的中文文档不是很全面与合理，这篇文章主要就对这个类库做注释展现。不足遗漏之处还望见谅，海涵。
.Net使用Redis是非常方便与快捷与简单的，下面就让我展示下吧。
这里有必要说一下，如果你对Redis 中的基本对象数据类型还不了解，建议你看下我的前几篇Redis文章，保证要到病除。点击：我的Redis系列文章
项目中安装下载Service.Stack.Redis类库
右击项目->管理NuGet程序包->在联机中输入Reis就能出现这个类库，然后添加引入就行啦。
.Net链接Redis数据库，支持读写分离
1、配置文件
public sealed class RedisConfig : ConfigurationSection
{
public static RedisConfig GetConfig()
{
RedisConfig section = GetConfig("RedisConfig");
return section;
}
public static RedisConfig GetConfig(string sectionName)
{
RedisConfig section = (RedisConfig)ConfigurationManager.GetSection(sectionName);
if (section == null)
throw new ConfigurationErrorsException("Section " + sectionName + " is not found.");
return section;
}
/// <summary>
/// 可写的Redis链接地址
/// </summary>
[ConfigurationProperty("WriteServerConStr", IsRequired = false)]
public string WriteServerConStr
{
get
{
return (string)base["WriteServerConStr"];
}
set
{
base["WriteServerConStr"] = value;
}
}
/// <summary>
/// 可读的Redis链接地址
/// </summary>
[ConfigurationProperty("ReadServerConStr", IsRequired = false)]
public string ReadServerConStr
{
get
{
return (string)base["ReadServerConStr"];
}
set
{
base["ReadServerConStr"] = value;
}
}
/// <summary>
/// 最大写链接数
/// </summary>
[ConfigurationProperty("MaxWritePoolSize", IsRequired = false, DefaultValue = 5)]
public int MaxWritePoolSize
{
get
{
int _maxWritePoolSize = (int)base["MaxWritePoolSize"];
return _maxWritePoolSize > 0 ? _maxWritePoolSize : 5;
}
set
{
base["MaxWritePoolSize"] = value;
}
}
/// <summary>
/// 最大读链接数
/// </summary>
[ConfigurationProperty("MaxReadPoolSize", IsRequired = false, DefaultValue = 5)]
public int MaxReadPoolSize
{
get
{
int _maxReadPoolSize = (int)base["MaxReadPoolSize"];
return _maxReadPoolSize > 0 ? _maxReadPoolSize : 5;
}
set
{
base["MaxReadPoolSize"] = value;
}
}
/// <summary>
/// 自动重启
/// </summary>
[ConfigurationProperty("AutoStart", IsRequired = false, DefaultValue = true)]
public bool AutoStart
{
get
{
return (bool)base["AutoStart"];
}
set
{
base["AutoStart"] = value;
}
}
/// <summary>
/// 本地缓存到期时间，单位:秒
/// </summary>
[ConfigurationProperty("LocalCacheTime", IsRequired = false, DefaultValue = 36000)]
public int LocalCacheTime
{
get
{
return (int)base["LocalCacheTime"];
}
set
{
base["LocalCacheTime"] = value;
}
}
/// <summary>
/// 是否记录日志,该设置仅用于排查redis运行时出现的问题,如redis工作正常,请关闭该项
/// </summary>
[ConfigurationProperty("RecordeLog", IsRequired = false, DefaultValue = false)]
public bool RecordeLog
{
get
{
return (bool)base["RecordeLog"];
}
set
{
base["RecordeLog"] = value;
}
}
}
2、配置Redis链接
public class RedisManager
{
/// <summary>
/// redis配置文件信息
/// </summary>
private static RedisConfig RedisConfig = RedisConfig.GetConfig();
private static PooledRedisClientManager prcm;
/// <summary>
/// 静态构造方法，初始化链接池管理对象
/// </summary>
static RedisManager()
{
CreateManager();
}
/// <summary>
/// 创建链接池管理对象
/// </summary>
private static void CreateManager()
{
string[] WriteServerConStr = SplitString(RedisConfig.WriteServerConStr, ",");
string[] ReadServerConStr = SplitString(RedisConfig.ReadServerConStr, ",");
prcm = new PooledRedisClientManager(ReadServerConStr, WriteServerConStr,
new RedisClientManagerConfig
{
MaxWritePoolSize = RedisConfig.MaxWritePoolSize,
MaxReadPoolSize = RedisConfig.MaxReadPoolSize,
AutoStart = RedisConfig.AutoStart,
});
}
private static string[] SplitString(string strSource, string split)
{
return strSource.Split(split.ToArray());
}
/// <summary>
/// 客户端缓存操作对象
/// </summary>
public static IRedisClient GetClient()
{
if (prcm == null)
CreateManager();
return prcm.GetClient();
}
}
3、IRedisClient为操作Redis的接口，是.Net操作Redis的主要类库，这里我们把它接入
/// <summary>
/// RedisBase类，是redis操作的基类，继承自IDisposable接口，主要用于释放内存
/// </summary>
public abstract class RedisBase : IDisposable
{
public static IRedisClient Core { get; private set; }
private bool _disposed = false;
static RedisBase()
{
Core = RedisManager.GetClient();
}
protected virtual void Dispose(bool disposing)
{
if (!this._disposed)
{
if (disposing)
{
Core.Dispose();
Core = null;
}
}
this._disposed = true;
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
/// <summary>
/// 保存数据DB文件到硬盘
/// </summary>
public void Save()
{
Core.Save();
}
/// <summary>
/// 异步保存数据DB文件到硬盘
/// </summary>
public void SaveAsync()
{
Core.SaveAsync();
}
}
.Net操作Redis数据类型String
public class DoRedisString : DoRedisBase
{
#region 赋值
/// <summary>
/// 设置key的value
/// </summary>
public bool Set(string key, string value)
{
return RedisBase.Core.Set<string>(key, value);
}
/// <summary>
/// 设置key的value并设置过期时间
/// </summary>
public bool Set(string key, string value, DateTime dt)
{
return RedisBase.Core.Set<string>(key, value, dt);
}
/// <summary>
/// 设置key的value并设置过期时间
/// </summary>
public bool Set(string key, string value, TimeSpan sp)
{
return RedisBase.Core.Set<string>(key, value, sp);
}
/// <summary>
/// 设置多个key/value
/// </summary>
public void Set(Dictionary<string, string> dic)
{
RedisBase.Core.SetAll(dic);
}
#endregion
#region 追加
/// <summary>
/// 在原有key的value值之后追加value
/// </summary>
public long Append(string key, string value)
{
return RedisBase.Core.AppendToValue(key, value);
}
#endregion
#region 获取值
/// <summary>
/// 获取key的value值
/// </summary>
public string Get(string key)
{
return RedisBase.Core.GetValue(key);
}
/// <summary>
/// 获取多个key的value值
/// </summary>
public List<string> Get(List<string> keys)
{
return RedisBase.Core.GetValues(keys);
}
/// <summary>
/// 获取多个key的value值
/// </summary>
public List<T> Get<T>(List<string> keys)
{
return RedisBase.Core.GetValues<T>(keys);
}
#endregion
#region 获取旧值赋上新值
/// <summary>
/// 获取旧值赋上新值
/// </summary>
public string GetAndSetValue(string key, string value)
{
return RedisBase.Core.GetAndSetValue(key, value);
}
#endregion
#region 辅助方法
/// <summary>
/// 获取值的长度
/// </summary>
public long GetCount(string key)
{
return RedisBase.Core.GetStringCount(key);
}
/// <summary>
/// 自增1，返回自增后的值
/// </summary>
public long Incr(string key)
{
return RedisBase.Core.IncrementValue(key);
}
/// <summary>
/// 自增count，返回自增后的值
/// </summary>
public double IncrBy(string key, double count)
{
return RedisBase.Core.IncrementValueBy(key, count);
}
/// <summary>
/// 自减1，返回自减后的值
/// </summary>
public long Decr(string key)
{
return RedisBase.Core.DecrementValue(key);
}
/// <summary>
/// 自减count ，返回自减后的值
/// </summary>
/// <param name="key"></param>
/// <param name="count"></param>
/// <returns></returns>
public long DecrBy(string key, int count)
{
return RedisBase.Core.DecrementValueBy(key, count);
}
#endregion
}
.Net操作Redis数据类型List
public class DoRedisList:DoRedisBase
{
#region 赋值
/// <summary>
/// 从左侧向list中添加值
/// </summary>
public void LPush(string key,string value)
{
RedisBase.Core.PushItemToList(key,value);
}
/// <summary>
/// 从左侧向list中添加值，并设置过期时间
/// </summary>
public void LPush(string key, string value,DateTime dt)
{
RedisBase.Core.PushItemToList(key, value);
RedisBase.Core.ExpireEntryAt(key,dt);
}
/// <summary>
/// 从左侧向list中添加值，设置过期时间
/// </summary>
public void LPush(string key, string value, TimeSpan sp)
{
RedisBase.Core.PushItemToList(key, value);
RedisBase.Core.ExpireEntryIn(key, sp);
}
/// <summary>
/// 从左侧向list中添加值
/// </summary>
public void RPush(string key, string value)
{
RedisBase.Core.PrependItemToList(key,value);
}
/// <summary>
/// 从右侧向list中添加值，并设置过期时间
/// </summary>
public void RPush(string key, string value, DateTime dt)
{
RedisBase.Core.PrependItemToList(key, value);
RedisBase.Core.ExpireEntryAt(key, dt);
}
/// <summary>
/// 从右侧向list中添加值，并设置过期时间
/// </summary>
public void RPush(string key, string value, TimeSpan sp)
{
RedisBase.Core.PrependItemToList(key, value);
RedisBase.Core.ExpireEntryIn(key, sp);
}
/// <summary>
/// 添加key/value
/// </summary>
public void Add(string key, string value)
{
RedisBase.Core.AddItemToList(key,value);
}
/// <summary>
/// 添加key/value ,并设置过期时间
/// </summary>
public void Add(string key, string value,DateTime dt)
{
RedisBase.Core.AddItemToList(key, value);
RedisBase.Core.ExpireEntryAt(key,dt);
}
/// <summary>
/// 添加key/value。并添加过期时间
/// </summary>
public void Add(string key, string value,TimeSpan sp)
{
RedisBase.Core.AddItemToList(key, value);
RedisBase.Core.ExpireEntryIn(key,sp);
}
/// <summary>
/// 为key添加多个值
/// </summary>
public void Add(string key, List<string> values)
{
RedisBase.Core.AddRangeToList(key,values);
}
/// <summary>
/// 为key添加多个值，并设置过期时间
/// </summary>
public void Add(string key, List<string> values,DateTime dt)
{
RedisBase.Core.AddRangeToList(key, values);
RedisBase.Core.ExpireEntryAt(key,dt);
}
/// <summary>
/// 为key添加多个值，并设置过期时间
/// </summary>
public void Add(string key, List<string> values,TimeSpan sp)
{
RedisBase.Core.AddRangeToList(key, values);
RedisBase.Core.ExpireEntryIn(key,sp);
}
#endregion
#region 获取值
/// <summary>
/// 获取list中key包含的数据数量
/// </summary>
public long Count(string key)
{
return RedisBase.Core.GetListCount(key);
}
/// <summary>
/// 获取key包含的所有数据集合
/// </summary>
public List<string> Get(string key)
{
return RedisBase.Core.GetAllItemsFromList(key);
}
/// <summary>
/// 获取key中下标为star到end的值集合
/// </summary>
public List<string> Get(string key,int star,int end)
{
return RedisBase.Core.GetRangeFromList(key,star,end);
}
#endregion
#region 阻塞命令
/// <summary>
/// 阻塞命令：从list中keys的尾部移除一个值，并返回移除的值，阻塞时间为sp
/// </summary>
public string BlockingPopItemFromList(string key,TimeSpan? sp)
{
return RedisBase.Core.BlockingDequeueItemFromList(key,sp);
}
/// <summary>
/// 阻塞命令：从list中keys的尾部移除一个值，并返回移除的值，阻塞时间为sp
/// </summary>
public ItemRef BlockingPopItemFromLists(string[] keys, TimeSpan? sp)
{
return RedisBase.Core.BlockingPopItemFromLists(keys, sp);
}
/// <summary>
/// 阻塞命令：从list中keys的尾部移除一个值，并返回移除的值，阻塞时间为sp
/// </summary>
public string BlockingDequeueItemFromList(string key, TimeSpan? sp)
{
return RedisBase.Core.BlockingDequeueItemFromList(key, sp);
}
/// <summary>
/// 阻塞命令：从list中keys的尾部移除一个值，并返回移除的值，阻塞时间为sp
/// </summary>
public ItemRef BlockingDequeueItemFromLists(string[] keys, TimeSpan? sp)
{
return RedisBase.Core.BlockingDequeueItemFromLists(keys, sp);
}
/// <summary>
/// 阻塞命令：从list中key的头部移除一个值，并返回移除的值，阻塞时间为sp
/// </summary>
public string BlockingRemoveStartFromList(string keys, TimeSpan? sp)
{
return RedisBase.Core.BlockingRemoveStartFromList(keys, sp);
}
/// <summary>
/// 阻塞命令：从list中key的头部移除一个值，并返回移除的值，阻塞时间为sp
/// </summary>
public ItemRef BlockingRemoveStartFromLists(string[] keys, TimeSpan? sp)
{
return RedisBase.Core.BlockingRemoveStartFromLists(keys, sp);
}
/// <summary>
/// 阻塞命令：从list中一个fromkey的尾部移除一个值，添加到另外一个tokey的头部，并返回移除的值，阻塞时间为sp
/// </summary>
public string BlockingPopAndPushItemBetweenLists(string fromkey, string tokey, TimeSpan? sp)
{
return RedisBase.Core.BlockingPopAndPushItemBetweenLists(fromkey, tokey, sp);
}
#endregion
#region 删除
/// <summary>
/// 从尾部移除数据，返回移除的数据
/// </summary>
public string PopItemFromList(string key)
{
return RedisBase.Core.PopItemFromList(key);
}
/// <summary>
/// 移除list中，key/value,与参数相同的值，并返回移除的数量
/// </summary>
public long RemoveItemFromList(string key,string value)
{
return RedisBase.Core.RemoveItemFromList(key,value);
}
/// <summary>
/// 从list的尾部移除一个数据，返回移除的数据
/// </summary>
public string RemoveEndFromList(string key)
{
return RedisBase.Core.RemoveEndFromList(key);
}
/// <summary>
/// 从list的头部移除一个数据，返回移除的值
/// </summary>
public string RemoveStartFromList(string key)
{
return RedisBase.Core.RemoveStartFromList(key);
}
#endregion
#region 其它
/// <summary>
/// 从一个list的尾部移除一个数据，添加到另外一个list的头部，并返回移动的值
/// </summary>
public string PopAndPushItemBetweenLists(string fromKey, string toKey)
{
return RedisBase.Core.PopAndPushItemBetweenLists(fromKey,toKey);
}
#endregion
}
展现List的阻塞功能，类似一个简单的消息队列功能
static void Main(string[] args)
{
string key = "zlh";
//清空数据库
DoRedisBase.Core.FlushAll();
//给list赋值
DoRedisBase.Core.PushItemToList(key, "1");
DoRedisBase.Core.PushItemToList(key, "2");
DoRedisBase.Core.AddItemToList(key, "3");
DoRedisBase.Core.PrependItemToList(key, "0");
DoRedisBase.Core.AddRangeToList(key, new List<string>() { "4", "5", "6" });
#region 阻塞
//启用一个线程来处理阻塞的数据集合
new Thread(new ThreadStart(RunBlock)).Start();
#endregion
Console.ReadKey();
}
public static void RunBlock()
{
while (true)
{
//如果key为zlh的list集合中有数据，则读出，如果没有则等待2个小时，2个小时中只要有数据进入这里就可以给打印出来，类似一个简易的消息队列功能。
Console.WriteLine(DoRedisBase.Core.BlockingPopItemFromList("zlh", TimeSpan.FromHours(2)));
}
}
.Net操作Redis数据类型Set
public class DoRedisSet:DoRedisBase
{
#region 添加
/// <summary>
/// key集合中添加value值
/// </summary>
public void Add(string key, string value)
{
RedisBase.Core.AddItemToSet(key,value);
}
/// <summary>
/// key集合中添加list集合
/// </summary>
public void Add(string key, List<string> list)
{
RedisBase.Core.AddRangeToSet(key, list);
}
#endregion
#region 获取
/// <summary>
/// 随机获取key集合中的一个值
/// </summary>
public string GetRandomItemFromSet(string key)
{
return RedisBase.Core.GetRandomItemFromSet(key);
}
/// <summary>
/// 获取key集合值的数量
/// </summary>
public long GetCount(string key)
{
return RedisBase.Core.GetSetCount(key);
}
/// <summary>
/// 获取所有key集合的值
/// </summary>
public HashSet<string> GetAllItemsFromSet(string key)
{
return RedisBase.Core.GetAllItemsFromSet(key);
}
#endregion
#region 删除
/// <summary>
/// 随机删除key集合中的一个值
/// </summary>
public string PopItemFromSet(string key)
{
return RedisBase.Core.PopItemFromSet(key);
}
/// <summary>
/// 删除key集合中的value
/// </summary>
public void RemoveItemFromSet(string key, string value)
{
RedisBase.Core.RemoveItemFromSet(key,value);
}
#endregion
#region 其它
/// <summary>
/// 从fromkey集合中移除值为value的值，并把value添加到tokey集合中
/// </summary>
public void MoveBetweenSets(string fromkey,string tokey,string value)
{
RedisBase.Core.MoveBetweenSets(fromkey,tokey,value);
}
/// <summary>
/// 返回keys多个集合中的并集，返还hashset
/// </summary>
public HashSet<string> GetUnionFromSets(string[] keys)
{
return RedisBase.Core.GetUnionFromSets(keys);
}
/// <summary>
/// keys多个集合中的并集，放入newkey集合中
/// </summary>
public void StoreUnionFromSets(string newkey, string[] keys)
{
RedisBase.Core.StoreUnionFromSets(newkey,keys);
}
/// <summary>
/// 把fromkey集合中的数据与keys集合中的数据对比，fromkey集合中不存在keys集合中，则把这些不存在的数据放入newkey集合中
/// </summary>
public void StoreDifferencesFromSet(string newkey, string fromkey, string[] keys)
{
RedisBase.Core.StoreDifferencesFromSet(newkey,fromkey,keys);
}
#endregion
}
.Net操作Redis数据类型有序集合Zset
public class DoRedisZSet : DoRedisBase
{
#region 添加
/// <summary>
/// 添加key/value，默认分数是从1.多*10的9次方以此递增的,自带自增效果
/// </summary>
public bool AddItemToSortedSet(string key, string value)
{
return RedisBase.Core.AddItemToSortedSet(key, value);
}
/// <summary>
/// 添加key/value,并设置value的分数
/// </summary>
public bool AddItemToSortedSet(string key, string value, double score)
{
return RedisBase.Core.AddItemToSortedSet(key, value, score);
}
/// <summary>
/// 为key添加values集合，values集合中每个value的分数设置为score
/// </summary>
public bool AddRangeToSortedSet(string key,List<string> values,double score)
{
return RedisBase.Core.AddRangeToSortedSet(key, values, score);
}
/// <summary>
/// 为key添加values集合，values集合中每个value的分数设置为score
/// </summary>
public bool AddRangeToSortedSet(string key, List<string> values, long score)
{
return RedisBase.Core.AddRangeToSortedSet(key, values, score);
}
#endregion
#region 获取
/// <summary>
/// 获取key的所有集合
/// </summary>
public List<string> GetAllItemsFromSortedSet(string key)
{
return RedisBase.Core.GetAllItemsFromSortedSet(key);
}
/// <summary>
/// 获取key的所有集合，倒叙输出
/// </summary>
public List<string> GetAllItemsFromSortedSetDesc(string key)
{
return RedisBase.Core.GetAllItemsFromSortedSetDesc(key);
}
/// <summary>
/// 获取可以的说有集合，带分数
/// </summary>
public IDictionary<string, double> GetAllWithScoresFromSortedSet(string key)
{
return RedisBase.Core.GetAllWithScoresFromSortedSet(key);
}
/// <summary>
/// 获取key为value的下标值
/// </summary>
public long GetItemIndexInSortedSet(string key, string value)
{
return RedisBase.Core.GetItemIndexInSortedSet(key, value);
}
/// <summary>
/// 倒叙排列获取key为value的下标值
/// </summary>
public long GetItemIndexInSortedSetDesc(string key, string value)
{
return RedisBase.Core.GetItemIndexInSortedSetDesc(key, value);
}
/// <summary>
/// 获取key为value的分数
/// </summary>
public double GetItemScoreInSortedSet(string key,string value)
{
return RedisBase.Core.GetItemScoreInSortedSet(key,value);
}
/// <summary>
/// 获取key所有集合的数据总数
/// </summary>
public long GetSortedSetCount(string key)
{
return RedisBase.Core.GetSortedSetCount(key);
}
/// <summary>
/// key集合数据从分数为fromscore到分数为toscore的数据总数
/// </summary>
public long GetSortedSetCount(string key,double fromScore,double toScore)
{
return RedisBase.Core.GetSortedSetCount(key,fromScore,toScore);
}
/// <summary>
/// 获取key集合从高分到低分排序数据，分数从fromscore到分数为toscore的数据
/// </summary>
public List<string> GetRangeFromSortedSetByHighestScore(string key, double fromscore, double toscore)
{
return RedisBase.Core.GetRangeFromSortedSetByHighestScore(key, fromscore, toscore);
}
/// <summary>
/// 获取key集合从低分到高分排序数据，分数从fromscore到分数为toscore的数据
/// </summary>
public List<string> GetRangeFromSortedSetByLowestScore(string key, double fromscore, double toscore)
{
return RedisBase.Core.GetRangeFromSortedSetByLowestScore(key, fromscore, toscore);
}
/// <summary>
/// 获取key集合从高分到低分排序数据，分数从fromscore到分数为toscore的数据，带分数
/// </summary>
public IDictionary<string, double> GetRangeWithScoresFromSortedSetByHighestScore(string key, double fromscore, double toscore)
{
return RedisBase.Core.GetRangeWithScoresFromSortedSetByHighestScore(key, fromscore, toscore);
}
/// <summary>
/// 获取key集合从低分到高分排序数据，分数从fromscore到分数为toscore的数据，带分数
/// </summary>
public IDictionary<string, double> GetRangeWithScoresFromSortedSetByLowestScore(string key, double fromscore, double toscore)
{
return RedisBase.Core.GetRangeWithScoresFromSortedSetByLowestScore(key, fromscore, toscore);
}
/// <summary>
/// 获取key集合数据，下标从fromRank到分数为toRank的数据
/// </summary>
public List<string> GetRangeFromSortedSet(string key, int fromRank, int toRank)
{
return RedisBase.Core.GetRangeFromSortedSet(key, fromRank, toRank);
}
/// <summary>
/// 获取key集合倒叙排列数据，下标从fromRank到分数为toRank的数据
/// </summary>
public List<string> GetRangeFromSortedSetDesc(string key, int fromRank, int toRank)
{
return RedisBase.Core.GetRangeFromSortedSetDesc(key, fromRank, toRank);
}
/// <summary>
/// 获取key集合数据，下标从fromRank到分数为toRank的数据，带分数
/// </summary>
public IDictionary<string, double> GetRangeWithScoresFromSortedSet(string key, int fromRank, int toRank)
{
return RedisBase.Core.GetRangeWithScoresFromSortedSet(key, fromRank, toRank);
}
/// <summary>
/// 获取key集合倒叙排列数据，下标从fromRank到分数为toRank的数据，带分数
/// </summary>
public IDictionary<string, double> GetRangeWithScoresFromSortedSetDesc(string key, int fromRank, int toRank)
{
return RedisBase.Core.GetRangeWithScoresFromSortedSetDesc(key, fromRank, toRank);
}
#endregion
#region 删除
/// <summary>
/// 删除key为value的数据
/// </summary>
public bool RemoveItemFromSortedSet(string key,string value)
{
return RedisBase.Core.RemoveItemFromSortedSet(key, value);
}
/// <summary>
/// 删除下标从minRank到maxRank的key集合数据
/// </summary>
public long RemoveRangeFromSortedSet(string key,int minRank,int maxRank)
{
return RedisBase.Core.RemoveRangeFromSortedSet(key,minRank,maxRank);
}
/// <summary>
/// 删除分数从fromscore到toscore的key集合数据
/// </summary>
public long RemoveRangeFromSortedSetByScore(string key, double fromscore, double toscore)
{
return RedisBase.Core.RemoveRangeFromSortedSetByScore(key, fromscore, toscore);
}
/// <summary>
/// 删除key集合中分数最大的数据
/// </summary>
public string PopItemWithHighestScoreFromSortedSet(string key)
{
return RedisBase.Core.PopItemWithHighestScoreFromSortedSet(key);
}
/// <summary>
/// 删除key集合中分数最小的数据
/// </summary>
public string PopItemWithLowestScoreFromSortedSet(string key)
{
return RedisBase.Core.PopItemWithLowestScoreFromSortedSet(key);
}
#endregion
#region 其它
/// <summary>
/// 判断key集合中是否存在value数据
/// </summary>
public bool SortedSetContainsItem(string key, string value)
{
return RedisBase.Core.SortedSetContainsItem(key,value);
}
/// <summary>
/// 为key集合值为value的数据，分数加scoreby，返回相加后的分数
/// </summary>
public double IncrementItemInSortedSet(string key,string value,double scoreBy)
{
return RedisBase.Core.IncrementItemInSortedSet(key,value,scoreBy);
}
/// <summary>
/// 获取keys多个集合的交集，并把交集添加的newkey集合中，返回交集数据的总数
/// </summary>
public long StoreIntersectFromSortedSets(string newkey, string[] keys)
{
return RedisBase.Core.StoreIntersectFromSortedSets(newkey,keys);
}
/// <summary>
/// 获取keys多个集合的并集，并把并集数据添加到newkey集合中，返回并集数据的总数
/// </summary>
public long StoreUnionFromSortedSets(string newkey, string[] keys)
{
return RedisBase.Core.StoreUnionFromSortedSets(newkey, keys);
}
#endregion
}
.Net操作Redis数据类型哈希Hash
public class DoRedisHash :DoRedisBase
{
#region 添加
/// <summary>
/// 向hashid集合中添加key/value
/// </summary>
public bool SetEntryInHash(string hashid, string key, string value)
{
return RedisBase.Core.SetEntryInHash(hashid,key,value);
}
/// <summary>
/// 如果hashid集合中存在key/value则不添加返回false，如果不存在在添加key/value,返回true
/// </summary>
public bool SetEntryInHashIfNotExists(string hashid, string key, string value)
{
return RedisBase.Core.SetEntryInHashIfNotExists(hashid, key, value);
}
/// <summary>
/// 存储对象T t到hash集合中
/// </summary>
public void StoreAsHash<T>(T t)
{
RedisBase.Core.StoreAsHash<T>(t);
}
#endregion
#region 获取
/// <summary>
/// 获取对象T中ID为id的数据。
/// </summary>
public T GetFromHash<T>(object id)
{
return RedisBase.Core.GetFromHash<T>(id);
}
/// <summary>
/// 获取所有hashid数据集的key/value数据集合
/// </summary>
public Dictionary<string, string> GetAllEntriesFromHash(string hashid)
{
return RedisBase.Core.GetAllEntriesFromHash(hashid);
}
/// <summary>
/// 获取hashid数据集中的数据总数
/// </summary>
public long GetHashCount(string hashid)
{
return RedisBase.Core.GetHashCount(hashid);
}
/// <summary>
/// 获取hashid数据集中所有key的集合
/// </summary>
public List<string> GetHashKeys(string hashid)
{
return RedisBase.Core.GetHashKeys(hashid);
}
/// <summary>
/// 获取hashid数据集中的所有value集合
/// </summary>
public List<string> GetHashValues(string hashid)
{
return RedisBase.Core.GetHashValues(hashid);
}
/// <summary>
/// 获取hashid数据集中，key的value数据
/// </summary>
public string GetValueFromHash(string hashid, string key)
{
return RedisBase.Core.GetValueFromHash(hashid, key);
}
/// <summary>
/// 获取hashid数据集中，多个keys的value集合
/// </summary>
public List<string> GetValuesFromHash(string hashid, string[] keys)
{
return RedisBase.Core.GetValuesFromHash(hashid, keys);
}
#endregion
#region 删除
#endregion
/// <summary>
/// 删除hashid数据集中的key数据
/// </summary>
public bool RemoveEntryFromHash(string hashid, string key)
{
return RedisBase.Core.RemoveEntryFromHash(hashid, key);
}
#region 其它
/// <summary>
/// 判断hashid数据集中是否存在key的数据
/// </summary>
public bool HashContainsEntry(string hashid, string key)
{
return RedisBase.Core.HashContainsEntry(hashid,key);
}
/// <summary>
/// 给hashid数据集key的value加countby，返回相加后的数据
/// </summary>
public double IncrementValueInHash(string hashid, string key, double countBy)
{
return RedisBase.Core.IncrementValueInHash(hashid, key, countBy);
}
#endregion
}
.Net操作Redis中的事务与锁
static void Main(string[] args)
{
//清空数据库
DoRedisBase.Core.FlushAll();
//声明事务
using (var tran = RedisManager.GetClient().CreateTransaction())
{
try
{
tran.QueueCommand(p =>
{
//操作redis数据命令
DoRedisBase.Core.Set<int>("name", 30);
long i = DoRedisBase.Core.IncrementValueBy("name", 1);
});
//提交事务
tran.Commit();
}
catch
{
//回滚事务
tran.Rollback();
}
////操作redis数据命令
//RedisManager.GetClient().Set<int>("zlh", 30);
////声明锁，网页程序可获得锁效果
//using (RedisManager.GetClient().AcquireLock("zlh"))
//{
// RedisManager.GetClient().Set<int>("zlh", 31);
// Thread.Sleep(10000);
//}
}
Console.ReadKey();
}
小结
此文是作为我自己的ServiceStack.Redis文档观看
C# 通过ServiceStack 操作Redis
作 者 : 明志德道
1.引用Nuget包 ServiceStack.Redis
我这里就用别人已经封装好的Reids操作类来和大家一起参考了下，看看怎么使用ServiceStack.Redis 操作Redis数据
RedisConfigInfo--redis配置文件信息
/// <summary>
/// redis配置文件信息
/// 也可以放到配置文件去
/// </summary>
public sealed class RedisConfigInfo
{
/// <summary>
/// 可写的Redis链接地址
/// format:ip1,ip2
///
/// 默认6379端口
/// </summary>
public string WriteServerList = "127.0.0.1:6379";
/// <summary>
/// 可读的Redis链接地址
/// format:ip1,ip2
/// </summary>
public string ReadServerList = "127.0.0.1:6379";
/// <summary>
/// 最大写链接数
/// </summary>
public int MaxWritePoolSize = 60;
/// <summary>
/// 最大读链接数
/// </summary>
public int MaxReadPoolSize = 60;
/// <summary>
/// 本地缓存到期时间，单位:秒
/// </summary>
public int LocalCacheTime = 180;
/// <summary>
/// 自动重启
/// </summary>
public bool AutoStart = true;
/// <summary>
/// 是否记录日志,该设置仅用于排查redis运行时出现的问题,
/// 如redis工作正常,请关闭该项
/// </summary>
public bool RecordeLog = false;
}
RedisManager --Redis管理中心 创建Redis链接
/// <summary>
/// Redis管理中心 创建Redis链接
/// </summary>
public class RedisManager
{
/// <summary>
/// redis配置文件信息
/// </summary>
private static RedisConfigInfo RedisConfigInfo = new RedisConfigInfo();
/// <summary>
/// Redis客户端池化管理
/// </summary>
private static PooledRedisClientManager prcManager;
/// <summary>
/// 静态构造方法，初始化链接池管理对象
/// </summary>
static RedisManager()
{
CreateManager();
}
/// <summary>
/// 创建链接池管理对象
/// </summary>
private static void CreateManager()
{
string[] WriteServerConStr = RedisConfigInfo.WriteServerList.Split('','');
string[] ReadServerConStr = RedisConfigInfo.ReadServerList.Split('','');
prcManager = new PooledRedisClientManager(ReadServerConStr, WriteServerConStr,
new RedisClientManagerConfig
{
MaxWritePoolSize = RedisConfigInfo.MaxWritePoolSize,
MaxReadPoolSize = RedisConfigInfo.MaxReadPoolSize,
AutoStart = RedisConfigInfo.AutoStart,
});
}
/// <summary>
/// 客户端缓存操作对象
/// </summary>
public static IRedisClient GetClient()
{
return prcManager.GetClient();
}
}
RedisBase-- 是redis操作的基类，继承自IDisposable接口，主要用于释放内存
/// <summary>
/// RedisBase类，是redis操作的基类，继承自IDisposable接口，主要用于释放内存
/// </summary>
public abstract class RedisBase : IDisposable
{
public IRedisClient iClient { get; private set; }
/// <summary>
/// 构造时完成链接的打开
/// </summary>
public RedisBase()
{
iClient = RedisManager.GetClient();
}
//public static IRedisClient iClient { get; private set; }
//static RedisBase()
//{
// iClient = RedisManager.GetClient();
//}
private bool _disposed = false;
protected virtual void Dispose(bool disposing)
{
if (!this._disposed)
{
if (disposing)
{
iClient.Dispose();
iClient = null;
}
}
this._disposed = true;
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
public void Transcation()
{
using (IRedisTransaction irt = this.iClient.CreateTransaction())
{
try
{
irt.QueueCommand(r => r.Set("key", 20));
irt.QueueCommand(r => r.Increment("key", 1));
irt.Commit(); // 提交事务
}
catch (Exception ex)
{
irt.Rollback();
throw ex;
}
}
}
/// <summary>
/// 清除全部数据 请小心
/// </summary>
public virtual void FlushAll()
{
iClient.FlushAll();
}
/// <summary>
/// 保存数据DB文件到硬盘
/// </summary>
public void Save()
{
iClient.Save();//阻塞式save
}
/// <summary>
/// 异步保存数据DB文件到硬盘
/// </summary>
public void SaveAsync()
{
iClient.SaveAsync();//异步save
}
}
RedisStringService--String类型操作帮助类
/// <summary>
/// key-value 键值对:value可以是序列化的数据
/// </summary>
public class RedisStringService : RedisBase
{
#region 赋值
/// <summary>
/// 设置key的value
/// </summary>
public bool Set<T>(string key, T value)
{
//iClient.Db =2;
return base.iClient.Set<T>(key, value);
}
/// <summary>
/// 设置key的value并设置过期时间
/// </summary>
public bool Set<T>(string key, T value, DateTime dt)
{
//iClient.Db = 2;
return base.iClient.Set<T>(key, value, dt);
}
/// <summary>
/// 设置key的value并设置过期时间
/// </summary>
public bool Set<T>(string key, T value, TimeSpan sp)
{
//iClient.Db = 2;
return base.iClient.Set<T>(key, value, sp);
}
/// <summary>
/// 设置多个key/value 可以一次保存多个key value ---多个key value 不是分多次，是一个独立的命令；
/// </summary>
public void Set(Dictionary<string, string> dic)
{
//iClient.Db = 2;
base.iClient.SetAll(dic);
}
#endregion
#region 追加
/// <summary>
/// 在原有key的value值之后追加value,没有就新增一项
/// </summary>
public long Append(string key, string value)
{
return base.iClient.AppendToValue(key, value);
}
#endregion
#region 获取值
/// <summary>
/// 获取key的value值
/// </summary>
public string Get(string key)
{
return base.iClient.GetValue(key);
}
/// <summary>
/// 获取多个key的value值
/// </summary>
public List<string> Get(List<string> keys)
{
return base.iClient.GetValues(keys);
}
/// <summary>
/// 获取多个key的value值
/// </summary>
public List<T> Get<T>(List<string> keys)
{
return base.iClient.GetValues<T>(keys);
}
#endregion
#region 获取旧值赋上新值
/// <summary>
/// 获取旧值赋上新值
/// </summary>
public string GetAndSetValue(string key, string value)
{
return base.iClient.GetAndSetValue(key, value);
}
#endregion
#region 辅助方法
/// <summary>
/// 获取值的长度
/// </summary>
public long GetLength(string key)
{
return base.iClient.GetStringCount(key);
}
/// <summary>
/// 自增1，返回自增后的值 保存的是10 调用后，+1 返回11
/// </summary>
public long Incr(string key)
{
return base.iClient.IncrementValue(key);
}
/// <summary>
/// 自增count，返回自增后的值 自定义自增的步长值
/// </summary>
public long IncrBy(string key, int count)
{
return base.iClient.IncrementValueBy(key, count);
}
/// <summary>
/// 自减1，返回自减后的值，Redis操作是单线程操作；不会出现超卖的情况
/// </summary>
public long Decr(string key)
{
return base.iClient.DecrementValue(key);
}
/// <summary>
/// 自减count ，返回自减后的值
/// </summary>
/// <param name="key"></param>
/// <param name="count"></param>
/// <returns></returns>
public long DecrBy(string key, int count)
{
return base.iClient.DecrementValueBy(key, count);
}
#endregion
}
nuget包是外国人写的，在国内并没有完整的中文文档，也没有专门的人来翻译、封装它，所以上面的代码方法不是很全，还有很多api方法需要自己去官网找然后自己封装。
在这里，上面的封装我就放一边，还是给大家演示ServiceStack原生的API如何使用
2. string 类型的使用
public static RedisClient client = new RedisClient("127.0.0.1", 6379);
//1.存入键值对
bool a = client.Set("key_name", "value_11");
//2. 根据key获取值
string data1= client.GetValue("key_name");
//3. 在原有的value上进行追加
long data2 = client.AppendToValue("key_name", "value_11");
// 4.获取值的长度
var data3=client.GetStringCount("key_name");
//5. 数值自增/减，返回自增、自减后的值
client.Set("小明分数", 100);
//自增20，可以自增负值
var data4= client.IncrementValueBy("小明分数", 20);
//自减50
var data5 = client.DecrementValueBy("小明分数", 50);
//6. 插入实体和读取实体
UserInfo userInfo = new UserInfo() { Id = 3, Age = 50, Name = "zxl", Pwd = "123456" };
client.Set("UserInfo_Id_3", userInfo);
UserInfo data6 = client.Get<UserInfo>("UserInfo_Id_3");
//7. 一次性添加多个key-value集合
Dictionary<string, string> dic = new Dictionary<string, string>() {
{ "101", Guid.NewGuid().ToString("N")},
{ "102", Guid.NewGuid().ToString("N")},
{ "103", Guid.NewGuid().ToString("N")},
{ "104", Guid.NewGuid().ToString("N")},
{ "105", Guid.NewGuid().ToString("N")},
{ "106", Guid.NewGuid().ToString("N")}
};
client.SetAll(dic);
//8.获取多个key的 value值集合
List<string> keys = new List<string>(){ "101", "103", "105" };
List<string> data8= client.GetValues(keys);
//9. 重命名key
client.Rename("106", "1066");
//10. 设置key的过期时间(30秒后自动销毁)
bool b2= client.Expire("102", 30);
//11. 删除单个key
bool d1 = client.Remove("101");//删除成功，返回true
bool d2 = client.Remove("ffff"); //删除不存在的数据，返回false
//13.清除全部数据 请小心 client.FlushAll();
以上就是C# 通过ServiceStack 操作Redis的详细内容，更多关于C# ServiceStack 操作Redis的资料请关注其它相关文章！
您可能感兴趣的文章:
- C#实现Redis的分布式锁
- c#基于Redis实现轻量级消息组件的步骤
- c#使用csredis操作redis的示例
- C#中如何使用redis
- C# StackExchange.Redis 用法汇总
centos 安装 redis +RedisDesktopManager 连接 redis
1、先到 Redis 官网 (redis.io) 下载 redis 安装包
wget http://download.redis.io/releases/redis-5.0.4.tar.gz
tar xzf redis-5.0.4.tar.gz
cd redis-5.0.4
cd src
make install PREFIX=/usr/local/redis
为了方便管理，将 Redis 文件中的 conf 配置文件和常用命令移动到统一文件中
mkdir -p /usr/local/redis/etc
mv redis.conf /usr/local/redis/etc/
启动 redis
/usr/local/redis/bin/redis-server /usr/local/redis/etc/redis.conf
默认情况，Redis 不是在后台运行，我们需要把 redis 放在后台运行
vi /usr/local/redis/etc/redis.conf
将 daemonize 的值改为 yes
停止 redis 实例
/usr/local/redis/bin/redis-cli shutdown
或者
pkill redis-server
让 redis 开机自启
vim /etc/rc.local
加入
/usr/local/redis/bin/redis-server /usr/local/redis/etc/redis.conf
客户端连接
/usr/local/redis/bin/redis-cli
ps -ef |grep redis 检查后台进程是否正在运行
#检测 6379 端口是否在监听
netstat -lntp | grep 6379
#使用 `redis-cli` 客户端检测连接是否正常
./redis-cli
-------*************************************----------
用 redis desktop manager 可视化工具
开启客户端设置密码
config set requirepass zhangzheng
开启 6379 端口
firewall-cmd --add-port=6379/tcp
firewall-cmd --reload
systemctl restart sshd
systemctl restart firewalld.service
需要修改 redis.conf
1. 修改 bind
原来： bind 127.0.0.1 代表本地回环地址，访问 redis 服务只能通过本机的客户端连接，而无法通过远程连接
修改为：将此行注释或者讲 ip 改成 0.0.0.0 这样就能接受所有来自于可用网络接口的连接
2. 修改 protected mode 保护模式，只允许本地链接
修改为：protected mode no
3. 设置远程登录的密码：取消 requirepass 前面的 #注释，并设置密码 123456
requirepass 123456
补充 redis.conf 中的 daemonize 配置
daemonize yes 代表开启守护进程模式。此时是单进程多线程的模式，redis 将在后台运行，并将 pid 写入 redis.conf--pidfile 文件中，此时 redis 将一直运行，除非手动 kill
daemonize no 当前界面将进入 redis 的命令行界面，exit 强制退出或者关闭连接工具 (xshell 等) 都会导致 redis 进程退出
修改配置文件后需要重启 redis！！！
com.amazonaws.services.identitymanagement.model.ListAttachedRolePoliciesRequest的实例源码
项目：fullstop
文件：PolicyProviderImpl.java
private Set<String> fetchAttachedPolicyNames(String roleName,AmazonIdentityManagementClient iamClient) {
return Optional.of(new ListAttachedRolePoliciesRequest().withRoleName(roleName))
.map(iamClient::listAttachedRolePolicies)
.map(ListAttachedRolePoliciesResult::getAttachedPolicies)
.map(attachedPolicies -> attachedPolicies.stream().map(AttachedPolicy::getPolicyName).collect(toSet()))
.orElseGet(Collections::emptySet);
}
项目：aws-doc-sdk-examples
文件：AttachRolePolicy.java
public static void main(String[] args) {
final String USAGE =
"To run this example,supply a role name\n" +
"Ex: AttachRolePolicy <role-name>\n";
if (args.length != 1) {
System.out.println(USAGE);
System.exit(1);
}
String role_name = args[0];
final AmazonIdentityManagement iam =
AmazonIdentityManagementClientBuilder.defaultClient();
ListAttachedRolePoliciesRequest request =
new ListAttachedRolePoliciesRequest()
.withRoleName(role_name);
List<AttachedPolicy> matching_policies = new ArrayList<>();
boolean done = false;
while(!done) {
ListAttachedRolePoliciesResult response =
iam.listAttachedRolePolicies(request);
matching_policies.addAll(
response.getAttachedPolicies()
.stream()
.filter(p -> p.getPolicyName().equals(role_name))
.collect(Collectors.toList()));
if(!response.getIsTruncated()) {
done = true;
}
request.setMarker(response.getMarker());
}
if (matching_policies.size() > 0) {
System.out.println(role_name +
" policy is already attached to this role.");
return;
}
AttachRolePolicyRequest attach_request =
new AttachRolePolicyRequest()
.withRoleName(role_name)
.withPolicyArn(POLICY_ARN);
iam.attachRolePolicy(attach_request);
System.out.println("Successfully attached policy " + POLICY_ARN +
" to role " + role_name);
}
项目：cloudbreak
文件：AwsSetup.java
private void validateInstanceProfileCreation(AwsCredentialView awsCredentialView) {
GetRoleRequest roleRequest = new GetRoleRequest();
String roleName = awsCredentialView.getRoleArn().split("/")[1];
LOGGER.info("Start validate {} role for S3 access.",roleName);
roleRequest.withRoleName(roleName);
AmazonIdentityManagement client = awsClient.createAmazonIdentityManagement(awsCredentialView);
try {
ListRolePoliciesRequest listRolePoliciesRequest = new ListRolePoliciesRequest();
listRolePoliciesRequest.setRoleName(roleName);
ListRolePoliciesResult listRolePoliciesResult = client.listRolePolicies(listRolePoliciesRequest);
for (String s : listRolePoliciesResult.getPolicyNames()) {
if (checkIamOrS3Statement(roleName,client,s)) {
LOGGER.info("Validation successful for s3 or iam access.");
return;
}
}
ListAttachedRolePoliciesRequest listAttachedRolePoliciesRequest = new ListAttachedRolePoliciesRequest();
listAttachedRolePoliciesRequest.setRoleName(roleName);
ListAttachedRolePoliciesResult listAttachedRolePoliciesResult = client.listAttachedRolePolicies(listAttachedRolePoliciesRequest);
for (AttachedPolicy attachedPolicy : listAttachedRolePoliciesResult.getAttachedPolicies()) {
if (checkIamOrS3Access(client,attachedPolicy)) {
LOGGER.info("Validation successful for s3 or iam access.");
return;
}
}
} catch (AmazonServiceException ase) {
if (ase.getStatusCode() == UNAUTHORIZED) {
String policyMEssage = "Could not get policies on the role because the arn role do not have enough permission: %s";
LOGGER.info(String.format(policyMEssage,ase.getErrorMessage()));
throw new CloudConnectorException(String.format(policyMEssage,ase.getErrorMessage()));
} else {
LOGGER.info(ase.getMessage());
throw new CloudConnectorException(ase.getErrorMessage());
}
} catch (Exception e) {
LOGGER.info(e.getMessage());
throw new CloudConnectorException(e.getMessage());
}
LOGGER.info("Could not get policies on the role because the arn role do not have enough permission.");
throw new CloudConnectorException("Could not get policies on the role because the arn role do not have enough permission.");
}
我们今天的关于ServiceStack.Redis无法读取传输-BasicRedisClientManager和redis无法获取连接的分享已经告一段落，感谢您的关注，如果您想了解更多关于.Net使用Redis详解之ServiceStack.Redis、C# 通过ServiceStack 操作Redis、centos 安装 redis +RedisDesktopManager 连接 redis、com.amazonaws.services.identitymanagement.model.ListAttachedRolePoliciesRequest的实例源码的相关信息，请在本站查询。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
