您的位置:时时app平台注册网站 > 编程知识 > 遍布式中选用Redis完成Session分享时时app平台注册

遍布式中选用Redis完成Session分享时时app平台注册

2019-11-21 02:24

List 类型
Redis列表是接收来链表来积攒的简短字符串列表,依据插入顺序排序。添韩元素日常从链表两端起来。经常信息队列的使用能够一向运用Redis的List数据类型来做管理。获取最新的拾二个顾客的信息,在list链表中只保留最新的13个数据,每一遍进来二个新数据就删除一条旧数据,进而完毕节约多少财富,收缩服务器压力。

二、概念名称含义解释

2.1、什么是Redis?

Redis是三个开源的,使用C语言编写,面向“键/值”对项目数据的分布式NoSQL数据库系统,Redis纯粹为利用而爆发,它是叁个高品质的key-value数据库,特点是高质量,长久存款和储蓄,适应高并发的选择场景,并且提供了二种语言的API。

Redis官网:

多语言客商端驱动下载:

2.2、Redis特点

Redis 是全然开源免费的,信守BSD公约,是一个高质量的key-value数据库。 与另外key - value 缓存成品有以下六脾气状:

● Redis扶植数据的悠久化,能够将内部存款和储蓄器中的数目保存在磁盘中,重启的时候能够再一次加载实行应用。

● Redis不唯有援助轻便的key-value类型的数据,同一时候还提供list,set,zset,hash等数据结构的积存。

● Redis接济数据的备份,即master-slave形式的数据备份。

Redis安装配备

    redis是四个key-value存储系统。和Memcached相像,它帮衬存款和储蓄的value类型相对更加多,满含string(字符串)、list(链表)、set(集结)、zset(sorted set --有序会集)和hash(哈希类型卡塔尔国。那个数据类型都扶助push/pop、add/remove及取交集并集和差集及更丰盛的操作,并且这么些操作都以原子性的。在这里功底上,redis扶植各样区别方法的排序。与memcached同样,为了保证功用,数据都是缓存在内部存款和储蓄器中。不相同的是redis会周期性的把改良的数目写入磁盘可能把改良操作写入追加的笔录文件,何况在这里根底上落到实处了master-slave(主从)同步。

  最新版本的redis版本为3.0.3,协助集群效果与利益。笔者那下载的是window版本的,实际境况都以安装在linux系统下的。下载地址:redis-2.8.19.rar 。越来越多下载地址: 

    官网 :  MSOpenTech:  dmajkic:

    下载实现以往解压运营redis-server.exe就开发银行了redis了,运维后会在经过之中见到reids。

时时app平台注册网站 1

  1.读写分离配置

  redis的读写抽离必要改过配置文件,把解压的文书复制了生机勃勃份。两份文件是同生龙活虎的,分别命名称为MasterRedis-2.8.19(主redis服务卡塔 尔(阿拉伯语:قطر‎,SlaveRedis-2.8.19(从redis服务卡塔尔。redis默许绑定的是6379端口,

 大家维持主服务配置不改变,修改从劳动配置。

 时时app平台注册网站 2

  • 修改从服务绑定端口(改善时能够间接寻找port关键字卡塔 尔(英语:State of Qatar)

时时app平台注册网站 3

  • 更改从服务对应的主服务地址(改革时得以直接找寻slaveof关键字卡塔尔国

 时时app平台注册网站 4

  • 布局文件校正产生之后,分别运维主服务和从劳动

  时时app平台注册网站 5时时app平台注册网站 6

    从服务运行以往,主服务会发送一条同步的sync命令,同步从服务器的缓存数据。

hash 是四个键值对聚焦,和C# 的Dictionary 类似。
Redis hash 是三个String 类型的 田野 和 value 的映射表

意气风发、课程介绍

前几日阿笨给大家带给豆蔻梢头堂NOSQL的科目,这期的栋梁是Redis。希望咱们学完这次分享课程后对redis有一个基本的刺探和认得,何况领悟和摆布 Redis在.NET中的使用。本次分享课程满含以下知识点:

1、StackExchange.Redis (简称:SE)驱动在C#中Redis二种数据结构学习和行使。 

2、ServiceStack.Redis ( 简称: SS) 驱动在C#中Redis二种数据结构学习和采纳。

3、Redis主从集群服务器搭建和上学。

4、在ASP.NET中Redis怎样开展Session托管。

5、在C#中什么运用Redis的劳动者/开支者。

6、在C#中如何使用Redis的颁发/订阅功效。

7、在C#中怎样行使Redis的事务、锁。

倘使你相像对本次共享《.NET遍布式缓存Redis从入门到实战》课程感兴趣的话,那么请跟着阿笨一同学学吧。

废话非常的少说,直接上干货,我们不生养干货,大家只是干货的搬运工。

七种数据类型使用

  服务搭建好之后能够使用.net版本redis操作类库ServiceStack.Redis来操作redis,本文少禽用到以下四个dll。

时时app平台注册网站 7

  初始化RedisClient对象

var client = new RedisClient("120.26.197.185", 6379);

 

1.String

    String是最常用的风姿洒脱种数据类型,普通的key/value存款和储蓄都能够归为此类,value其实不唯有是String,也得以是数字:比如想领悟怎么样时候封锁四个IP地址(访谈超越四次)。INCRBY命令让那一个变得超级轻巧,通过原子依次增加保持计数。 

#region "字符串类型"
client.Set<string>("name", "laowang");
string userName = client.Get<string>("name");
Console.WriteLine(userName);

//访问次数
client.Set<int>("IpAccessCount", 0);
//次数递增
client.Incr("IpAccessCount");
Console.WriteLine(client.Get<int>("IpAccessCount"));
#endregion

时时app平台注册网站 8

2.Hash

叁个hashid能够积存多项音讯,每豆蔻年华项消息也会有和煦的key

client.SetEntryInHash("userInfoId", "name", "zhangsan");
client.SetEntryInHash("userInfoId", "name1", "zhangsan1");
client.SetEntryInHash("userInfoId", "name2", "zhangsan2");
client.SetEntryInHash("userInfoId", "name3", "zhangsan3");
client.GetHashKeys("userInfoId").ForEach(e => Console.WriteLine(e));
client.GetHashValues("userInfoId").ForEach(e => Console.WriteLine(e));

时时app平台注册网站 9

3.List

  应用途景:  

  •  Redis list的利用项景十分的多,也是Redis最重大的数据结构之意气风发。 
  •  大家可以轻巧地落到实处最新音信排名等功用。 
  •  Lists的另二个利用就是新闻队列,尚可Lists的PUSH操作,将职分存在Lists中,然后工作线程再用POP操作将职分抽取实行推行。 
 #region "List类型"

client.AddItemToList("userInfoId1", "123");
client.AddItemToList("userInfoId1", "1234");

Console.WriteLine("List数据项条数:"   client.GetListCount("userInfoId1"));
Console.WriteLine("List数据项第一条数据:"   client.GetItemFromList("userInfoId1", 0));
Console.WriteLine("List所有数据");
client.GetAllItemsFromList("userInfoId1").ForEach(e => Console.WriteLine(e));
#endregion

#region "List类型做为队列和栈使用"
Console.WriteLine(client.GetListCount("userInfoId1"));
//队列先进先出
//Console.WriteLine(client.DequeueItemFromList("userInfoId1"));
//Console.WriteLine(client.DequeueItemFromList("userInfoId1"));

//栈后进先出
Console.WriteLine("出栈" client.PopItemFromList("userInfoId1"));
Console.WriteLine("出栈" client.PopItemFromList("userInfoId1"));
#endregion

时时app平台注册网站 10

4.Set

  应用项景: 

  • Redis set对外提供的功能与list相符是叁个列表的作用,特殊之处在于set是足以自行排重的,当您须求仓库储存二个列表数据,又不指望现身重复数据时,set是一个很好的选项,並且set提供了判别某些成员是不是在七个set集结内的最主要接口,那些也是list所不可能提供的。 
  • 举例在新浪应用中,各样人的老铁存在二个汇合(set卡塔尔国中,那样求五个人的同台基友的操作,只怕就只需求用求交集命令就可以。 
  • Redis还为集结提供了求交集、并集、差集等操作,能够拾分有益的实 
client.AddItemToSet("A", "B");
client.AddItemToSet("A", "C");
client.AddItemToSet("A", "D");
client.AddItemToSet("A", "E");
client.AddItemToSet("A", "F");

client.AddItemToSet("B", "C");
client.AddItemToSet("B", "F");

//求差集
Console.WriteLine("A,B集合差集");
client.GetDifferencesFromSet("A", "B").ToList<string>().ForEach(e => Console.Write(e   ","));

//求集合交集
Console.WriteLine("nA,B集合交集");
client.GetIntersectFromSets(new string[] { "A", "B" }).ToList<string>().ForEach(e => Console.Write(e   ","));

//求集合并集
Console.WriteLine("nA,B集合并集");
client.GetUnionFromSets(new string[] { "A", "B" }).ToList<string>().ForEach(e => Console.Write(e   ","));

时时app平台注册网站 11

5.Sort Set(排序)

  应用处景:

  • 以有个别条件为权重,举个例子按顶的次数排序. 
  • ZREVRANGE命令能够用来依据得分来获取前100名的顾客,ZRANK可以用来获取客商排行,特别直接况且操作轻巧。 
  • Redis sorted set的采纳意况与set肖似,不同是set不是自动有序的,而sorted set能够经过客户额外提供三个优先级(score)的参数来为成员排序,何况是插入有序的,即自行排序。 
  • 举例:twitter 的public timeline可以以发布时间作为score来囤积,那样获取时正是自动准时间排好序的。 
  • 例如:全班同学成绩的SortedSets,value能够是同班的学号,而score就能够是其考试得分,这样数据插入集合的,就早就扩充了原始的排序。 
  • 其它还是能用Sorted Sets来做带权重的连串,比方经常信息的score为1,主要音讯的score为2,然后专门的学业线程能够筛选按score的倒序来博取职业职责。让机要的职务优先实行。 
 #region "有序Set操作"
client.AddItemToSortedSet("SA", "B", 2);
client.AddItemToSortedSet("SA", "C", 1);
client.AddItemToSortedSet("SA", "D", 5);
client.AddItemToSortedSet("SA", "E", 3);
client.AddItemToSortedSet("SA", "F", 4);

//有序集合降序排列
Console.WriteLine("n有序集合降序排列");
client.GetAllItemsFromSortedSetDesc("SA").ForEach(e => Console.Write(e   ","));
Console.WriteLine("n有序集合升序序排列");
client.GetAllItemsFromSortedSet("SA").ForEach(e => Console.Write(e   ","));

client.AddItemToSortedSet("SB", "C", 2);
client.AddItemToSortedSet("SB", "F", 1);
client.AddItemToSortedSet("SB", "D", 3);

Console.WriteLine("n获得某个值在有序集合中的排名,按分数的升序排列");
Console.WriteLine(client.GetItemIndexInSortedSet("SB", "D"));

Console.WriteLine("n获得有序集合中某个值得分数");
Console.WriteLine(client.GetItemScoreInSortedSet("SB", "D"));

Console.WriteLine("n获得有序集合中,某个排名范围的所有值");
client.GetRangeFromSortedSet("SA", 0, 3).ForEach(e => Console.Write(e   ","));

#endregion

时时app平台注册网站 12

本身一起首是运用RedisSessionStateProvider来存款和储蓄Session的,其实也依然得以的。可是,后来改成了生龙活虎种艺术,小编平昔调用封装好的StackExchange.Redis类来做Session管理。

四、Redis二种数据结构

1、String( 字符串 )

那是最简便易行的Redis类型。如若只利用那体系型,Redis就好像五个可悠久化的Memcached服务器。

2、List(列表)

Redis的List是基于双向链表完成的,能够支撑反向寻找和遍历。

常用案例:闲谈系统、社交互作用连网中拿到客商最新刊登的帖子、轻易的音信队列、新闻的分页列表、博客的褒贬系统。

3、Hash( 哈希 )

Hash是二个String类型的田野先生和value之间的映射表,请见下图,雷同于.NET中的Hashtable和Dictionary。重要用来积累对象,能够制止连串化的花费和现身改过决定的标题。

4、Set( 集合 )

Set也是叁个列表,不过它的自成一格之处在于它是足以自行排重的:当须求仓库储存四个列表数据,而又不愿意现身重复的时候,Set是八个很好的取舍(举个例子ID的汇合卡塔尔国。並且Set提供了判别有个别成员是还是不是在三个Set集结内的接口,那也是List所未有的。

5、Sorted Set(有序聚焦卡塔尔国

Sorted Set和Set的施用景况相像,区别是Sorted Set会依附提供的score参数来开展活动排序。当你须求一个一直以来的还要不另行的集聚列表,那么就能够选取Sorted Set数据结构。常用案例:游戏中的排行的榜单。

布满式中运用Redis完毕Session分享

  上风姿洒脱篇介绍了怎么行使 Nginx IIS达成负载均衡 铺排一个简便的布满式系统,小说最终留下了多少个难点,在那之中三个是"如何消除多站点下Session分享"。那篇小说将会介绍怎么着运用Redis,下风度翩翩篇在这里根底上完毕Session。

  那Ritter别说圣元(Synutra卡塔尔(Karicare卡塔 尔(阿拉伯语:قطر‎下,其实未有需要选取Redis来化解Session分享。Asp.net提供了StateServer方式来分享Session,这里再度造轮子的目标1:熟习Redis的基本知识和选用2.上学和加强Session的达成原理。3.就学Redis应用处景

阅读目录

  • Redis安装配置
  • 各样数据类型使用
  • 打包拓宽
  • 总结 

对redis的数据类型有丰硕的询问,能够行使到支付的重重景况,譬如消息队列,优先队列,秒杀,最新博客的展示等等。

三、Redis For Windows安装手册

3.1、Redis 在Windows系统上的安装

官方网站只提供linux版本的下载官方网站下载地址:

windows 版本的github下载地址:

引入大家上面多少个学习Redis的网站:

Redis中文网:

能够在线编写Redis指令的网址:  

3.2、Redis服务器主从集群的搭建

 

总结

  1.其实php,java等三种语言都能动用redis,在自身接触的体系中观察使用redis做为音讯队列和缓存组件,当然它的效劳远不独有于此。前边的稿子将详细介绍redis的多少个使用案例。

      2.能够行使redis desktop manager管理工科具查看服务器缓存中的数据

时时app平台注册网站 13

      本篇小说用到的redis_demo能源打包下载地址:

百度网盘下载:

或者

------------------------------------------分割线------------------------------------------

无需付费下载地址在

客商名与密码都是www.bkjia.com

切实下载目录在 /二〇一五年龄资历料/11月/七日/Nginx IIS实现负载均衡/

下载格局见

------------------------------------------分割线------------------------------------------

svn下载地址:

越来越多详细情况见请继续读书下生机勃勃页的精彩内容:

  • 1
  • 2
  • 下一页

上大器晚成篇介绍了什么选择Nginx IIS达成负载均衡 陈设贰个轻易的遍及式系统,小说最终留下了多少个难点,此中...

源码地址:
链接: 密码:jeqi

五、Redis应用处景介绍

卷入拓宽

  最后提供风华正茂份外人写好的Redis操作的帮带类,用到了PooledRedisClientManager连接池来赢得RedisClient,同临时间利用了读写分离的定义,能够直接拿来行使

时时app平台注册网站 14

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ServiceStack.Redis;

namespace Com.Redis
{
    /// <summary>
    /// 来源:http://blog.wx6.org/2013/349.htm
    /// </summary>
    public class RedisBase
    {
        private static string[] ReadWriteHosts = System.Configuration.ConfigurationSettings.AppSettings["readWriteHosts"].Split(new char[] { ';' });
        private static string[] ReadOnlyHosts = System.Configuration.ConfigurationSettings.AppSettings["readOnlyHosts"].Split(new char[] { ';' });

        #region -- 连接信息 --
        public static PooledRedisClientManager prcm = CreateManager(ReadWriteHosts, ReadOnlyHosts);

        private static PooledRedisClientManager CreateManager(string[] readWriteHosts, string[] readOnlyHosts)
        {
            // 支持读写分离,均衡负载  
            return new PooledRedisClientManager(readWriteHosts, readOnlyHosts, new RedisClientManagerConfig
            {
                MaxWritePoolSize = 5, // “写”链接池链接数  
                MaxReadPoolSize = 5, // “读”链接池链接数  
                AutoStart = true,
            });
        }
        #endregion

        #region -- Item --
        /// <summary> 
        /// 设置单体 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="key"></param> 
        /// <param name="t"></param> 
        /// <param name="timeSpan"></param> 
        /// <returns></returns> 
        public static bool Item_Set<T>(string key, T t)
        {
            try
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    return redis.Set<T>(key, t, new TimeSpan(1, 0, 0));
                }
            }
            catch (Exception ex)
            {
                // LogInfo 
            }
            return false;
        }

        /// <summary> 
        /// 获取单体 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="key"></param> 
        /// <returns></returns> 
        public static T Item_Get<T>(string key) where T : class
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                return redis.Get<T>(key);
            }
        }

        /// <summary> 
        /// 移除单体 
        /// </summary> 
        /// <param name="key"></param> 
        public static bool Item_Remove(string key)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                return redis.Remove(key);
            }
        }

        #endregion

        #region -- List --

        public static void List_Add<T>(string key, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var redisTypedClient = redis.GetTypedClient<T>();
                redisTypedClient.AddItemToList(redisTypedClient.Lists[key], t);
            }
        }



        public static bool List_Remove<T>(string key, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var redisTypedClient = redis.GetTypedClient<T>();
                return redisTypedClient.RemoveItemFromList(redisTypedClient.Lists[key], t) > 0;
            }
        }
        public static void List_RemoveAll<T>(string key)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var redisTypedClient = redis.GetTypedClient<T>();
                redisTypedClient.Lists[key].RemoveAll();
            }
        }

        public static int List_Count(string key)
        {
            using (IRedisClient redis = prcm.GetReadOnlyClient())
            {
                return redis.GetListCount(key);
            }
        }

        public static List<T> List_GetRange<T>(string key, int start, int count)
        {
            using (IRedisClient redis = prcm.GetReadOnlyClient())
            {
                var c = redis.GetTypedClient<T>();
                return c.Lists[key].GetRange(start, start   count - 1);
            }
        }


        public static List<T> List_GetList<T>(string key)
        {
            using (IRedisClient redis = prcm.GetReadOnlyClient())
            {
                var c = redis.GetTypedClient<T>();
                return c.Lists[key].GetRange(0, c.Lists[key].Count);
            }
        }

        public static List<T> List_GetList<T>(string key, int pageIndex, int pageSize)
        {
            int start = pageSize * (pageIndex - 1);
            return List_GetRange<T>(key, start, pageSize);
        }

        /// <summary> 
        /// 设置缓存过期 
        /// </summary> 
        /// <param name="key"></param> 
        /// <param name="datetime"></param> 
        public static void List_SetExpire(string key, DateTime datetime)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                redis.ExpireEntryAt(key, datetime);
            }
        }
        #endregion

        #region -- Set --
        public static void Set_Add<T>(string key, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var redisTypedClient = redis.GetTypedClient<T>();
                redisTypedClient.Sets[key].Add(t);
            }
        }
        public static bool Set_Contains<T>(string key, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var redisTypedClient = redis.GetTypedClient<T>();
                return redisTypedClient.Sets[key].Contains(t);
            }
        }
        public static bool Set_Remove<T>(string key, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var redisTypedClient = redis.GetTypedClient<T>();
                return redisTypedClient.Sets[key].Remove(t);
            }
        }
        #endregion

        #region -- Hash --
        /// <summary> 
        /// 判断某个数据是否已经被缓存 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="key"></param> 
        /// <param name="dataKey"></param> 
        /// <returns></returns> 
        public static bool Hash_Exist<T>(string key, string dataKey)
        {
            using (IRedisClient redis = prcm.GetReadOnlyClient())
            {
                return redis.HashContainsEntry(key, dataKey);
            }
        }

        /// <summary> 
        /// 存储数据到hash表 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="key"></param> 
        /// <param name="dataKey"></param> 
        /// <returns></returns> 
        public static bool Hash_Set<T>(string key, string dataKey, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
                return redis.SetEntryInHash(key, dataKey, value);
            }
        }
        /// <summary> 
        /// 移除hash中的某值 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="key"></param> 
        /// <param name="dataKey"></param> 
        /// <returns></returns> 
        public static bool Hash_Remove(string key, string dataKey)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                return redis.RemoveEntryFromHash(key, dataKey);
            }
        }
        /// <summary> 
        /// 移除整个hash 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="key"></param> 
        /// <param name="dataKey"></param> 
        /// <returns></returns> 
        public static bool Hash_Remove(string key)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                return redis.Remove(key);
            }
        }
        /// <summary> 
        /// 从hash表获取数据 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="key"></param> 
        /// <param name="dataKey"></param> 
        /// <returns></returns> 
        public static T Hash_Get<T>(string key, string dataKey)
        {
            using (IRedisClient redis = prcm.GetReadOnlyClient())
            {
                string value = redis.GetValueFromHash(key, dataKey);
                return ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(value);
            }
        }
        /// <summary> 
        /// 获取整个hash的数据 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="key"></param> 
        /// <returns></returns> 
        public static List<T> Hash_GetAll<T>(string key)
        {
            using (IRedisClient redis = prcm.GetReadOnlyClient())
            {
                var list = redis.GetHashValues(key);
                if (list != null && list.Count > 0)
                {
                    List<T> result = new List<T>();
                    foreach (var item in list)
                    {
                        var value = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                        result.Add(value);
                    }
                    return result;
                }
                return null;
            }
        }
        /// <summary> 
        /// 设置缓存过期 
        /// </summary> 
        /// <param name="key"></param> 
        /// <param name="datetime"></param> 
        public static void Hash_SetExpire(string key, DateTime datetime)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                redis.ExpireEntryAt(key, datetime);
            }
        }
        #endregion

        #region -- SortedSet --
        /// <summary> 
        ///  添加数据到 SortedSet 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="key"></param> 
        /// <param name="t"></param> 
        /// <param name="score"></param> 
        public static bool SortedSet_Add<T>(string key, T t, double score)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
                return redis.AddItemToSortedSet(key, value, score);
            }
        }
        /// <summary> 
        /// 移除数据从SortedSet 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="key"></param> 
        /// <param name="t"></param> 
        /// <returns></returns> 
        public static bool SortedSet_Remove<T>(string key, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
                return redis.RemoveItemFromSortedSet(key, value);
            }
        }
        /// <summary> 
        /// 修剪SortedSet 
        /// </summary> 
        /// <param name="key"></param> 
        /// <param name="size">保留的条数</param> 
        /// <returns></returns> 
        public static int SortedSet_Trim(string key, int size)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                return redis.RemoveRangeFromSortedSet(key, size, 9999999);
            }
        }
        /// <summary> 
        /// 获取SortedSet的长度 
        /// </summary> 
        /// <param name="key"></param> 
        /// <returns></returns> 
        public static int SortedSet_Count(string key)
        {
            using (IRedisClient redis = prcm.GetReadOnlyClient())
            {
                return redis.GetSortedSetCount(key);
            }
        }

        /// <summary> 
        /// 获取SortedSet的分页数据 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="key"></param> 
        /// <param name="pageIndex"></param> 
        /// <param name="pageSize"></param> 
        /// <returns></returns> 
        public static List<T> SortedSet_GetList<T>(string key, int pageIndex, int pageSize)
        {
            using (IRedisClient redis = prcm.GetReadOnlyClient())
            {
                var list = redis.GetRangeFromSortedSet(key, (pageIndex - 1) * pageSize, pageIndex * pageSize - 1);
                if (list != null && list.Count > 0)
                {
                    List<T> result = new List<T>();
                    foreach (var item in list)
                    {
                        var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                        result.Add(data);
                    }
                    return result;
                }
            }
            return null;
        }


        /// <summary> 
        /// 获取SortedSet的全部数据 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="key"></param> 
        /// <param name="pageIndex"></param> 
        /// <param name="pageSize"></param> 
        /// <returns></returns> 
        public static List<T> SortedSet_GetListALL<T>(string key)
        {
            using (IRedisClient redis = prcm.GetReadOnlyClient())
            {
                var list = redis.GetRangeFromSortedSet(key, 0, 9999999);
                if (list != null && list.Count > 0)
                {
                    List<T> result = new List<T>();
                    foreach (var item in list)
                    {
                        var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                        result.Add(data);
                    }
                    return result;
                }
            }
            return null;
        }

        /// <summary> 
        /// 设置缓存过期 
        /// </summary> 
        /// <param name="key"></param> 
        /// <param name="datetime"></param> 
        public static void SortedSet_SetExpire(string key, DateTime datetime)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                redis.ExpireEntryAt(key, datetime);
            }
        }
        #endregion
    }
}

  View Code

 使用很简短,几行代码

//会往主服务里面写入
RedisBase.Hash_Set<string>("PooledRedisClientManager", "one", "123");

//从服务里面读取信息
RedisBase.Hash_Get<string>("PooledRedisClientManager", "one");

  连接池的开端化

        private static string[] ReadWriteHosts = System.Configuration.ConfigurationSettings.AppSettings["readWriteHosts"].Split(new char[] { ';' });
        private static string[] ReadOnlyHosts = System.Configuration.ConfigurationSettings.AppSettings["readOnlyHosts"].Split(new char[] { ';' });

        #region -- 连接信息 --
        public static PooledRedisClientManager prcm = CreateManager(ReadWriteHosts, ReadOnlyHosts);

        private static PooledRedisClientManager CreateManager(string[] readWriteHosts, string[] readOnlyHosts)
        {
            // 支持读写分离,均衡负载  
            return new PooledRedisClientManager(readWriteHosts, readOnlyHosts, new RedisClientManagerConfig
            {
                MaxWritePoolSize = 5, // “写”链接池链接数  
                MaxReadPoolSize = 5, // “读”链接池链接数  
                AutoStart = true,
            });
        } 

  配置文件

时时app平台注册网站 15

【新手总括】在.Net项目中使用Redis作为缓存服务
Session布满式分享 = Session Redis Nginx

六、Redis在.NET中的使用

这段时光一贯在研商学习Redis的有关知识,以后概略做下总结吧
首先,Redis的功底方面,不说配置,就只有说下Redis数据类型:
Redis 中国共产党第五次全国代表大会数据类型有String 类型,Hash 类型,List 类型,Set 类型,Zset(Sortedset卡塔尔国类型。个中常用的是前四个。
String 是 redis 最大旨的花色,二个key对应贰个value。

六、Redis实战练习分享

1、StackExchange.Redis (SE)驱动在C#中Redis三种数据结构学习和利用。 

2、ServiceStack.Redis (SS) 驱动在C#中Redis二种数据结构学习和行使。

3、 Redis主从集群服务器搭建和学习。

4、在ASP.NET中Redis怎么着开展Session托管。

5、在C#中怎样利用Redis的生产者/开支者。

6、在C#中哪些选用Redis的发表/订阅作用。

7、在C#中什么运用Redis的作业、锁。

Zset 类型
Redis的zset(sortedset卡塔 尔(阿拉伯语:قطر‎和set同样也是string类型成分的聚众,且不容许有重复的积极分子。由于是已序群集,能够利用到紧俏帖子的景象,排序好之后,重回最新的最热的前11个帖子。

七、源码在线学习和演示

Set 类型
Redis 的 Set 是String类型的冬辰聚焦。它是由此HashTable完结完结的,用法和 List类型很相似。因为大家得以借助集结类型来做一些拍卖比如交并补集,具体应用途景:QQ亲密的朋友的推荐介绍

.NET对Redis的扶助依旧很好的。日常大家用Redis来积累Session数据,微软给大家提供了二个第三方组件:RedisSessionStateProvider。微软官方还给大家提供了三个基于redis的内部存款和储蓄器输出缓存的组件:RedisOutputCacheProvider。所以的第三方redis组件通常都以依赖Redis顾客端完毕的,平常是StackExchange.Redis或是其他的顾客端。英特网有成都百货上千人卷入好了根据各类顾客端的类,大家得以友善去询问。

参考资料:
用redis来落到实处Session保存的二个轻松易行德姆o
Redis 飞快入门

本文由时时app平台注册网站发布于编程知识,转载请注明出处:遍布式中选用Redis完成Session分享时时app平台注册

关键词: