Ersetzt Redis die Sitzung?

Was ist Redis?

Redis ist eine Open-Source-Protokolltyp-Schlüsselwertdatenbank, die in der ANSI-C-Sprache geschrieben ist, Netzwerke unterstützt, speicherbasiert und persistent sein kann und Folgendes bereitstellt: API in mehreren Sprachen.

1. Vergleich mit anderen Lösungen zum Speichern des Benutzerstatus

Im Allgemeinen verwendet der Benutzerstatus in der Entwicklung Sitzung oder Cookies, beide Methoden haben unterschiedliche Vor- und Nachteile.

Sitzung: Im InProc-Modus geht man leicht verloren und verursacht Parallelitätsprobleme. Wenn Sie SQLServer oder den SQLServer-Modus verwenden und Leistung verbrauchen

Cookies können leicht einige Benutzerinformationen preisgeben, und Verschlüsselung und Entschlüsselung verbrauchen ebenfalls Leistung.

Redis nutzt diese Lösung, um mehrere Probleme zu lösen,

1. Redis hat eine schnelle Zugriffsgeschwindigkeit.

2. Benutzerdaten gehen nicht so leicht verloren.

3. Es ist einfach, Cluster zu unterstützen, wenn es viele Benutzer gibt.

4. Kann Online-Benutzer anzeigen.

5. Benutzer können sich an einem Ort anmelden.

6. Unterstützen Sie die Ausdauer.

2. Implementierungsideen

1 Wir wissen, dass die Sitzung tatsächlich eine Sitzungs-ID in einem Cookie speichert und der Benutzer die Sitzungs-ID jedes Mal an den Server sendet Wenn er besucht, sucht der Server über die ID nach den Statusdaten, die dem Benutzer entsprechen.

Mein Ansatz besteht darin, eine Sitzungs-ID im Cookie zu definieren. Wenn das Programm den Benutzerstatus abrufen muss, wird die Sitzungs-ID als Schlüssel für die Suche in Redis verwendet.

2. Gleichzeitig unterstützt die Sitzung Benutzer dabei, die Sitzung wiederzuverwenden, wenn sie über einen bestimmten Zeitraum nicht darauf zugreifen.

Das Ausleihen der Ablaufzeitfunktion von Keys in Redis unterstützt diese Funktion, aber im Hinblick auf die Erneuerung muss das Programm die Anfrage abfangen und diese Methode selbst aufrufen (die Demo enthält ein Beispiel)

Beschreibung des Startcodes unten

3. Verweisen Sie zunächst auf die ServiceStack-bezogene DLL.
Konfiguration in web.config hinzufügen Diese Konfiguration wird verwendet, um die Redis-Aufrufadresse für jeden Dienst, getrennt durch [,], festzulegen. Der Host wird zuerst geschrieben

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

Initialisierungskonfiguration

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

Einen Delegaten zur Vereinfachung der Steuerung geschrieben

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

Ein Beispiel für das Aufrufen anderer Weitere Informationen finden Sie im Quellcode.

        /// <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. Sitzung implementieren

Schreiben Sie wie oben erwähnt eine Sitzungs-ID in das Cookie

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

Methoden für den Zugriff auf Benutzer

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

Der Standardbenutzer wurde nicht länger als abgemeldet 30 Minuten. Anmeldestatus, daher muss der Benutzer die Abmeldezeit des Benutzers bei jedem Besuch um 30 Minuten verschieben Dies erfordert den Aufruf der Redis-Erneuerungsmethode

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

Nach der Kapselung

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

Hier habe ich den ActionFilter in MVC3 verwendet, um alle Anfragen von Benutzern abzufangen

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

Registrieren Sie es in Global.asax

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

5. Anrufmethode

Um das Anrufen zu vereinfachen, leihen Sie sich das aus Neue Funktion in 4.0 Feature: Fügen Sie dem Controller ein erweitertes Attribut

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

hinzu, um die Methode

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

aufzurufen

Das obige ist der detaillierte Inhalt vonErsetzt Redis die Sitzung?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!