Shiro
Shiro ist ein Open -Source -Projekt unter Apache, wir nennen es Apache Shiro. Es ist ein sehr benutzerfreundlicher Sicherheitsrahmen bei Java-Projekten, das Authentifizierung, Autorisierung, Verschlüsselung und Sitzungsmanagement bereitstellt. Wie bei Frühlingssicherheit handelt es sich um einen Sicherheitsrahmen für die Berechtigung. Im Vergleich zur Frühlingssicherheit verwendet Shiro jedoch eine relativ einfache, leicht verständliche und benutzerfreundliche Autorisierungsmethode. Shiro ist ein leichtes Rahmen. Es ist viel einfacher als Sicherheit und nicht so kompliziert wie die Sicherheit. Für detailliertere Einführungen können Sie grundsätzlich von der offiziellen Website (http://shiro.apache.org/) lernen, dass es hauptsächlich die folgenden Funktionen bietet:
(1) Authentifizierung (Authentifizierung)
(2) Autorisierung (Autorisierung)
(3) Sitzungsmanagement (Sitzungsmanagement)
(4) Kryptographie (Verschlüsselung)
Zunächst können Sie den Authentifizierungsdienst, dh durch sie, die Identitätsauthentifizierung abschließen, sodass sie feststellen kann, ob der Benutzer ein echtes Mitglied ist.
Zweitens ist der autorisierte Service, um ihn unverblümt auszudrücken, "Access Control" -Dienst, dh sie ermöglichen, welche Berechtigungen der Benutzer verfügt. Um es unverblümt auszudrücken, es soll ihm geben, welche Betriebsberechtigungen die Rolle der Benutzer spielen.
Dann gibt es den Sitzungsverwaltungsdienst. Zu diesem Zeitpunkt unterscheidet sich ein unabhängiges Sitzungsmanagement -Framework von der HTTP -Sitzung, mit der wir vertraut sind.
Schließlich bietet sie auch Kryptographie (Verschlüsselung) -Dienste an, die viele kryptografische Algorithmen zusammenfassen.
Heute werde ich nicht alles darüber sagen und mich auf ihre Konversationsmanagementfunktion konzentrieren. In der Tat sollten fast alle Netze beteiligt sein.
Bevor wir über Shiros Sitzungsmanagementdienst sprechen, überprüfen wir, wie wir das vorherige Sitzungsmanagement gemacht haben.
1. Zuerst haben wir den HTTP -Sitzungsmechanismus des Webservers direkt verwendet. Wenn der Benutzer zum ersten Mal hereinkommt, erstellt der Webcontainer eine Sitzung für die Anfrage und speichert die Sitzung. Durch Übergabe der entsprechenden Sitzung als Cookie an den Kunden.
Wenn der Client eine Anfrage erneut an diesen Server sendet, wird die Sitzung automatisch übertragen. Anschließend bestimmt der Webserver, ob sich die Sitzung noch im Speicher basierend auf der vom Client mitgelieferten Sitzung befindet (die Sitzung hat eine Ablaufzeit und kann in der Web.xml -Datei konfiguriert werden). Wenn die entsprechende Sitzung nicht gefunden werden kann, bedeutet dies, dass die Ablaufzeit der Sitzung verabschiedet wurde. Zu diesem Zeitpunkt erstellt der Webserver erneut eine Sitzung dafür und übergibt dann die neue Sitzung wie zuvor an den Client.
Daher können wir diesen Mechanismus verwenden, um die Anmeldesitzung des Benutzers im Programm zu verwalten. Nachdem der erste Anmeldung des Benutzers erfolgreich ist, speichern wir die grundlegenden Informationen des Benutzers in der Sitzung (z. B. session.setAttribute("user", "userInfo") ). Wenn der Benutzer das nächste Mal erneut besucht, erhalten wir die Benutzerinformationen in der aktuellen Sitzung basierend auf den Benutzerinformationen
( session.getAttribute("user") ) Um festzustellen, ob der Benutzer abgelaufen ist. Wenn es nicht erhalten werden kann, wird der Benutzer aufgefordert, sich erneut anzumelden.
2. Die zweite Methode besteht darin, den Ort zu übertragen, an dem Informationen an Medien von Drittanbietern wie Cache, Memecache oder Redis gespeichert sind. Diese Methode wird hauptsächlich aufgrund der Entstehung verteilter Systeme angewendet.
In diesem Fall müssen wir die Sitzung selbst generieren. Im Allgemeinen verwenden wir ein definiertes Präfix ( user:login:token ) und addieren Sie BenutzerID oder Zeitstempel. Anschließend verwenden wir diese SessionID als Cache -Taste und die Informationen des Benutzers als Wert und speichern sie im Cache und setzen die Ungültigheitszeit:
jedisclient.set (tokenkey, jsonutil.tojonstring (userInfo)); jedisclient.expire (tokenkey, token_lose_seconds);
Wir müssen auch den generierten Tokenkey über Cookies: CookieUtils.setCookie(request, response, "TT_TOKEN", tokenKey);
Auf diese Weise können wir, wenn der Benutzer das nächste Mal besucht (einen Interceptor), das entsprechende Tokenkey aus dem Cookie herausnehmen und dann mit diesem Tokenkey zum Cache gehen, um den entsprechenden Wert abzurufen. Wenn es nicht erhalten werden kann, bedeutet dies, dass der Schlüssel abgelaufen ist und der Benutzer aufgefordert wird, sich erneut anzumelden.
Hinweis: Tokenkey ist wichtig, es ist der Hub, der die Cache -Seite und den Client verbindet.
3. Die letzte ist unsere Shiro -Methode, und die Idee ist ähnlich. Der Code ist recht einfach, daher werde ich den Code einfach hochladen:
1) Erstellen Sie eine neue AnwendungContext-shiro.xml-Datei:
<? xmlns: p = "http://www.springframework.org/schema/p" xmlns: aop = "http://www.springframework.org/schema/tx" xmlns: xsi = "http://wwwwwww.ww.ww.ww.ww.ww.ww.ww. XSI: Schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd http://www.springframework.org/schema/util http://www.springframework.g/schema/util/util/util/util/spring-/using- id = "shirofilter"> <Eigenschaft name = "SecurityManager" Ref = "SecurityManager"> </Eigenschaft> <Eigenschaft name = "loginUrl" value = "/loginpage"> </property> <Eigenschaft name = "unauthorizedurl" value = "/pages/unauthorized.jsp"/jspaPaTh/jspaTaTh/JSPACaTh/JspaTaTh/JspaTaThaThaThaThaThaThaThaThaThaThaThaThaThaThaThaThaTa -nam. = anon </value> </property> </bean> <bean> <property name = "staticMethod" value = "org.apache.shiro.securityutils.setSecurityManager"> </Property> <Property name = "Argumente" Ref = "SecurityManager"> </cacheman> </bean> <Dean id = "SecurityManager"> </cachAnch> </bean> <Dean id = " ref = "cachemanager"> </property> <Eigenschaft name = "SessionManager" Ref = "SessionManager"> </property> </bean> <bean id = "sessionManager"> <Property name = "sessiondao" ref = "sessiondao"> </ban> // Diese Klasse muss von selbst implementiert werden.
2) Konfigurieren Sie den entsprechenden Filter in web.xml:
<Filter> <filter-name> shirofilter </filter-name> <filterklasse> org.springframework.web.filter.delegatingFilterProxy </filter-classe> <init-param> <param-name> targetFilterlifecycle </param-param> <param-value> </param-values> </param-valu> </param-values> </param-value> </param-values> </param-valu> </param-valuue> </param-value <Filtermapping> <filter-name> shirofilter </filter-name> <url-pattern>/*</url-puftern> </filter-mapping>
3) Schreiben Sie eine Implementierungsklasse, Inherit contractSessiondao und implementieren Sie die entsprechende Methode.
Paket com.jdd.core.shiro; import com.smart.core.redis.redismanager; import org.apache.shiro.session.session; import org.apache.shiro.session.unneNownSesionException; import org.apache.shiro.Session.mgt.eis.abactactactact. org.springframework.beans.factory.annotation.autowired; import org.springframework.util.Serializationutils; import Java.io. @Override public void update (Sitzung) löst UnbekanntessessionException {RedisManager.set (SerializationUtils.Serialize (Session.getId (). ToString ()), SerializationUtils.serialize (Sitzung)) aus; redismanager.expire (SerializationUtils.Serialize (Session.getID (). ToString ()), 60); } @Override public void delete (Sitzungssitzung) {redisManager.del (SerializationUtils.Serialize (Session.getID (). ToString ())); } @Override public collection <Sesion> getActiveSsions () {NeuarrayList <Sesion> (); } @Override Protected Serializable Docreate (Sitzungssitzung) {// Dies ist, wenn Sie zum ersten Mal zugreifen, serialisierbare SessionID -serialisierbare SID = this.generateSessionID (Sitzung); ordnungssessessions (Sitzung, SID); redismanager.set (SerializationUtils.Serialize (Session.getID (). ToString ()), SerializationUtils.Serialize (Session)); redismanager.expire (SerializationUtils.Serialize (Session.getID (). ToString ()), 60); Rückkehr Sid; } @Override Protected Session doreadSession (serialisierbarer serialisierbar) {// Diese Methode soll die Sitzung über SessionID lesen. Jedes Mal, wenn Sie es lesen, muss die Fehlerzeit Byte [] aa = redismanager.get (SerializationUtils.serialize (serializable.toString ()) zurückgesetzt werden; Session Session = (Sitzung) SerializationUtils.Deserialize (AA); RedisManager.set (SerializationUtils.Serialize (serializable.toString ()), SerializationUtils.Serialize (Sitzung)); redismanager.expire (SerializationUtils.Serialize (serializable.toString ()), 60); Rückgabesitzung; }}4) Der nächste Schritt besteht darin
Paket com.smart.controller; import com.smart.pojo.user; import com.service.userservice; import org.apache.shiro.securityutils; import org.apache.shiro.mgt.securityManager; org.slf4j.loggerfactory; import org.springframework.beans.factory.annotation.autowired; import org.springframework.steretype.Controller; javax.servlet.http.httpServletRequest; importieren javax.servlet.http.httpServletResponse;@Controller@RequestMapping ("/user") öffentliche Klasse UserController {@autowired Private Usserservice; @Autowired Private SecurityManager SM; // SecurityManager private logger logger = loggerfactory.getLogger (userController.class) injizieren; @RequestMapping (value = "/loginPage") public String loginPage () {return "user/userLogin"; } @RequestMapping (value = "/userLogin", method = requestMethod.post) public String userLogin (@RequestParam (value = "name") String -Name, @RequestParam (value = "pwd") String PWD, Modellmodell) {logger.info ("ub UserLogin ..."); User user = userService.getUserbynamandpassword (Name, PWD); if (user == null) {logger.info ("Benutzer ist nicht existiert ..."); model.addattribute ("login_error", "Benutzername oder Kennwortfehler"); zurück "user/userLogin" zurückgeben; } SecurityUtils.setSecurityManager (SM); Betreff CurrentUser = SecurityUtils.getSubject (); currentUser.getSession (). setAttribute ("login_user", Benutzer); return "recirect:/Mitarbeiter/Liste"; }}Holen Sie sich den aktuellen Benutzer in Shiro, es ist das Thema, erhalten Sie dann die entsprechende Sitzung und legen Sie die Benutzerinformationen darin ein. Fühlt es sich ein bisschen wie der Betrieb der HTTP -Sitzung an? Haha.
5) Definieren Sie schließlich einen SpringMVC -Interceptor, um die Benutzerinformationen in der entsprechenden Sitzung im Interceptor zu erhalten. Wenn es nicht erhalten werden kann, springt es zur Anmeldeschnittstelle.
Paket com.smart.core.shiro; import com.smart.pojo.user; import org.apache.shiro.securityutils; import org.apache.shiro.mgt.securityManager; org.slf4j.loggerfactory; import org.springframework.beans.factory.annotation javax.servlet.http.httpServletResponse; public class loginInterceptor implementiert handlerInterceptor {private logger logger = loggerfactory.getLogger (loginInterceptor.class); @Autowired Private SecurityManager SM; @Override public boolean prehandle (httpServletRequest httpServletRequest, httpServletResponse httpServletResponse, Objekt O) Ausnahme aus der Ausnahme {logger.info eingeben ("loginInterceptor ..."); HttpServletRequest request = httpServletRequest; HttpServletResponse response = httpServletResponse; logger.info ("anfordern Uri ===>"+request.getRequesturi ()); // Wenn es sich um eine Anfrage für die Anmeldeseite handelt, wird es nicht abgefangen, andernfalls fällt es in eine tote Schleife, wenn (request.getRequesturi (). Enthält ("loginpage") || request.getRequesturi (). Enthält ("userLogin") {return true; } else {SecurityUtils.setSecurityManager (SM); Betreff CurrentUser = SecurityUtils.getSubject (); Object obj = currentUser.getSession (). GetAtTribute ("login_user"); if (obj == null) {response.sendredirect ("http: // localhost: 8080/user/loginpage"); false zurückgeben; } else {user user = (user) obj; if (user == null || user.getName () == null) {response.sendredirect ("http: // localhost: 8080/user/loginpage"); false zurückgeben; } else {return true; }}}} @Override public void posthandle (httpServletRequest httpServletRequest, httpServletResponse httpServletResponse, Object O, modelandView modelAndview) Ausnahme {} @Override public void httpServletResponse, Objekt O, Ausnahme E) Ausläufe Ausnahme {}}Es ist im Grunde hier. Wenn Sie jetzt direkt auf die Homepage -Informationen zugreifen, wird automatisch zur Anmeldeseite gesprungen.
Zusammenfassen
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass der Inhalt dieses Artikels einen gewissen Referenzwert für das Studium oder die Arbeit eines jeden hat. Wenn Sie Fragen haben, können Sie eine Nachricht zur Kommunikation überlassen. Vielen Dank für Ihre Unterstützung bei Wulin.com.