How to use redis to implement session function

Let’s briefly introduce redis.

Redis (Remote Dictionary Server), the remote dictionary service, is an open source log-type, Key-Value database written in ANSI C language, supports the network, can be based on memory and can be persisted, and provides multiple language API. Since March 15, 2010, the development of Redis has been hosted by VMware. Since May 2013, the development of Redis has been sponsored by Pivotal.

1. Comparison with other user state preservation solutions

Generally, session or cookie is used for user state in development. Both methods have 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. (Achieved through code, introduced later)

6. Support persistence. (Of course it may be useless)

2. Implementation ideas

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

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)

Start the code description below

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 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();
                }
            }
        }

For an example of calling, please 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;
            }
        }

    }

How to access the user

/// <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

By default, the user logs out of the user after not visiting for more than 30 minutes, so each time the user visits, the user's logout time must be postponed by 30 minutes

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 the user's requests

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

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 calling and borrowing the new features in 4.0, add an extended attribute to the Controller

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

Calling method:

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

6. Code Download

Click to download

7. Follow-up

SessionManager includes obtaining the number of user lists, logging out of a user, obtaining user information based on user ID, online User object list, online user SessionId list and other methods

The user login function will be implemented in one place in the future

Related recommendations:redis database tutorial

The above is the detailed content of How to use redis to implement session function. For more information, please follow other related articles on the PHP Chinese website!