Does redis replace session?

What is Redis

Redis is an open source log-type, Key-Value database written in ANSI C language, supports the network, can be memory-based and persistent, and provides API in multiple languages.

1. Compared with other user state saving solutions

Generally in development, user state uses session or Cookies, both methods have various pros and cons.

Session: It is easy to lose in InProc mode and cause concurrency problems. If you use SQLServer or SQLServer mode and consume performance

Cookies can easily expose some user information, and encryption and decryption also consume performance.

Redis uses this solution to solve several problems,

1. Redis has fast access speed.

2. User data is not easily lost.

3. It is easy to support clusters when there are many users.

4. Able to view online users.

5. Able to enable users to log in at one place.

6. Support persistence.

2. Implementation ideas

1. We know that session actually saves a sessionid in a cookie, and the user sends the sessionid to the server every time he visits. , the server looks up the status data corresponding to the user through the ID.

My approach here is to define a sessionid in the cookie. When the program needs to obtain the user status, the sessionid is used as the key to search in Redis.

2. At the same time, the session supports users to recycle the session if they do not access it for a certain period of time.

Borrow the expiration time feature of Keys in Redis to support this function, but in terms of renewal, the program needs to intercept the request and call this method by itself (the demo has examples)

Below Start code description

3.Redis calling interface

First reference the ServiceStack related DLL.

Add configuration in web.config. This configuration is used to set the Redis calling address for each service separated by [,]. The host is written in the first place

 <appSettings>
     <!--每台Redis之间用,分割.第一个必须为主机-->
    <add key="SessionRedis" value="127.0.0.1:6384,127.0.0.1:6384"/>
 </appSettings>

Initialization configuration

static Managers()
        {
            string sessionRedis= ConfigurationManager.AppSettings["SessionRedis"];
            string timeOut = ConfigurationManager.AppSettings["SessionRedisTimeOut"];
            if (string.IsNullOrEmpty(sessionRedis))
            {
                throw new Exception("web.config 缺少配置SessionRedis,每台Redis之间用,分割.第一个必须为主机");
            }
            if (string.IsNullOrEmpty(timeOut)==false)
            {
                TimeOut = Convert.ToInt32(timeOut);
            }
            var host = sessionRedis.Split(char.Parse(","));
            var writeHost = new string[] { host[0] };
            var readHosts = host.Skip(1).ToArray();
            ClientManagers = new PooledRedisClientManager(writeHost, readHosts, new RedisClientManagerConfig
            {
                MaxWritePoolSize = writeReadCount,//“写”链接池链接数
                MaxReadPoolSize = writeReadCount,//“读”链接池链接数
                AutoStart = true
            });
        }

Written a delegate for the convenience of control

 /// <summary>
        /// 写入
        /// </summary>
        /// <typeparam name="F"></typeparam>
        /// <param name="doWrite"></param>
        /// <returns></returns>
        public F TryRedisWrite<F>(Func<IRedisClient, F> doWrite)
        {
            PooledRedisClientManager prcm = new Managers().GetClientManagers();
            IRedisClient client = null;
            try
            {
                using (client = prcm.GetClient())
                {
                    return doWrite(client);
                }
            }
            catch (RedisException)
            {
                throw new Exception("Redis写入异常.Host:" + client.Host + ",Port:" + client.Port);
            }
            finally
            {
                if (client != null)
                {
                    client.Dispose();
                }
            }
        }

An example of calling others See the source code for details

        /// <summary>
        /// 以Key/Value的形式存储对象到缓存中
        /// </summary>
        /// <typeparam name="T">对象类别</typeparam>
        /// <param name="value">要写入的集合</param>
        public void KSet(Dictionary<string, T> value)
        {
            Func<IRedisClient, bool> fun = (IRedisClient client) =>
            {
                client.SetAll<T>(value);
                return true;
            };
            TryRedisWrite(fun);
        }

4. Implement Session

Write a sessionid to the cookie as mentioned above

    /// <summary>
    /// 用户状态管理
    /// </summary>
    public class Session
    {
        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="_context"></param>
        public Session(HttpContextBase _context)
        {
            var context = _context;
            var cookie = context.Request.Cookies.Get(SessionName);
            if (cookie == null || string.IsNullOrEmpty(cookie.Value))
            {
                SessionId = NewGuid();
                context.Response.Cookies.Add(new HttpCookie(SessionName, SessionId));
                context.Request.Cookies.Add(new HttpCookie(SessionName, SessionId));
            }
            else
            {
                SessionId = cookie.Value;
            }
        }
    }

Methods of accessing users

        /// <summary>
        /// 获取当前用户信息
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public object Get<T>() where T:class,new()
        {
            return new RedisClient<T>().KGet(SessionId);
        }
        /// <summary>
        /// 用户是否在线
        /// </summary>
        /// <returns></returns>
        public bool IsLogin()
        {
            return new RedisClient<object>().KIsExist(SessionId);
        }
        /// <summary>
        /// 登录
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        public void Login<T>(T obj) where T : class,new()
        {
            new RedisClient<T>().KSet(SessionId, obj, new TimeSpan(0, Managers.TimeOut, 0));
        }

6. Renewal

The default user has not been logged out for more than 30 minutes. Login status, so the user's logout time must be postponed by 30 minutes each time he visits.

This requires calling the Redis renewal method

      /// <summary>
        /// 延期
        /// </summary>
        /// <param name="key"></param>
        /// <param name="expiresTime"></param>
        public void KSetEntryIn(string key, TimeSpan expiresTime)
        {
            Func<IRedisClient, bool> fun = (IRedisClient client) =>
            {
                client.ExpireEntryIn(key, expiresTime);
                return false;
            };
            TryRedisWrite(fun);
        }

After encapsulation

/// <summary>
/// 续期
/// </summary>
public void Postpone()
{
new RedisClient<object>().KSetEntryIn(SessionId, new TimeSpan(0, Managers.TimeOut, 0));
}

Here I used the ActionFilter in MVC3 to intercept all user requests

namespace Test
{
    public class SessionFilterAttribute : ActionFilterAttribute
    {
        /// <summary>
        /// 每次请求都续期
        /// </summary>
        /// <param name="filterContext"></param>
        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            new Session(filterContext.HttpContext).Postpone();
        }
    }
}

You need to register it in Global.asax

public static void RegisterGlobalFilters(GlobalFilterCollection filters)
        {
            filters.Add(new SessionFilterAttribute());
        }
        protected void Application_Start()
        {
            RegisterGlobalFilters(GlobalFilters.Filters);
        }

5. Calling method

In order to facilitate the call, borrow the new features in 4.0 Feature, add an extended attribute to Controller

public static class ExtSessions
{public static Session SessionExt(this Controller controller)
    {
        return new Session(controller.HttpContext);
    }
}

Call method

    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            this.SessionExt().IsLogin();
            return View();
        }
    }

The above is the detailed content of Does redis replace session?. For more information, please follow other related articles on the PHP Chinese website!