Die Frühlingssicherheit ist ein großes Modul, und dieser Artikel beinhaltet nur die Authentifizierung benutzerdefinierter Parameter. Die Standardverifizierungsparameter der Spring Security sind nur Benutzername und Passwort, die im Allgemeinen nicht ausreichen. Denn die Zeit ist zu lange vergangen, einige vergessen und einige von ihnen fehlen möglicherweise. OK, kein Unsinn.
Die Konfigurationen für die Feder- und Federsicherheit verwenden Javaconfig, und die Versionen sind wiederum 4.2.5 und 4.0.4.
Gesamtidee: Anpassen der Einstiegspunkte und fügen Sie benutzerdefinierte Parameter hinzu, um die Authentifizierung und Authentifizierungsprovider zur Überprüfung zu erweitern.
Zuerst den Einstiegspunkt definieren:
import org.springframework.security.core.authenticationException; import org.springframework javax.servlet.http.httpServletResponse; import Java.io.ioException; öffentliche Klasse myauthenticationEntryPoint erweitert loginurlauthenticationEntryPoint {public myAuthenticationEntryPoint (String loginformurl) {super (loginformurl); } @Override public void beginnen (httpServletRequest Request, httpServletResponse -Antwort, Authentifizierungsexception AuthException). }}Als nächstes ist Token, ValidCode ist der Parameter des Verifizierungscodes:
import org.springframework.security.authentication public myusernamePasswordAuthenticationToken (String Principal, String -Anmeldeinformationen, String ValidCode) {Super (Principal, Anmeldeinformationen); this.validcode = validCode; } public String getValidCode () {return validCode; } public void setValidCode (String validCode) {this.validcode = validCode; }}Fortsetzung Processing Filter,
import com.core.shared.validatecodeHandle; import org.springframework.security.core.authentication; org.springframework.security.web.util.matcher.antpathrequestMatcher; import Javax.servlet.servletException; import Javax.servlet.http.httpletRetRequest; Import Javax.Servlet.http.httpletretResponse; javax.servlet.http.httpSession; import Java.io.ioException; öffentliche Klasse myvalidCodeProcessingFilter erweitert die AbstractAuthenticationProcessingFilter {private String usernameParam = "Benutzername"; private String passwayParam = "Passwort"; private Zeichenfolge validCodeParam = "validateCode"; public myvalidCodeProcessingFilter () {Super (neuer AntpathequestMatcher ("/user/login", "post")); } @Override Public Authentication VersuchAuthentication (httpServletRequest Request, httpServletResponse -Antwort) löst die Authentifizierungsexception, IOException, servleTException {String username = request.getParameter (usernameparam) aus; String password = request.getParameter (PassageParam); String validCode = request.getParameter (validCodeParam); valid (validCode, request.getSession ()); MyusernamepasswordAuthenticationToken Token = new MyUnernamePasswordAuthenticationToken (Benutzername, Passwort, validCode); return this.getAuthenticationManager (). Authenticat (Token); } public void valid (String validCode, httpSession Session) {if (validCode == null) {throurne New ValidCodeERRorexception ("validateCode ist leer!"); } if (! validateCodeHandle.matchCode (session.getId (), validCode)) {neue validCodeErRorexception ("validCodeError!"); }}} Definieren Sie drei Parameter getrennt, die verwendet werden, um die Parameter aus dem Anmeldeformular zu empfangen. Die Konstruktionsmethode ergibt die Anmeldem -URL und die erforderliche Postmethode
Als nächstes kommt die Authentifizierung. Bevor der Authentifizierungs -Benutzername und das Passwort angekommen sind, habe ich gerade den Verifizierungscode authentifiziert.
Hier ist eine Tool -Klasse validateCodeHandle und validCodeerrorexception:
import java.util.concurrent public static ConcurrenthashMap getCode () {return validateCode; } public static void Save (String SessionID, String -Code) {validateCode.put (SessionID, Code); } public static String getValidateCode (String SessionID) {Object obj = validateCode.get (SessionID); if (obj! = null) {return string.Valueof (obj); } return null; } public static boolean MatchCode (String SessionID, String InputCode) {String SaveCode = getValidateCode (SessionID); if (SaveCode.equals (inputcode)) {return true; } return false; }}Hier müssen Sie die Authentifizierungsexception erben, um anzuzeigen, dass es sich um einen Sicherheitsauthentifizierungsfehler handelt, damit der nachfolgende Fehlerprozess befolgt wird.
import org.springframework.security.core.authenticationException; public class ValidCodeErRorexception erweitert die Authentifizierungsexception {public ValidCodeErRorexception (String msg) {Super (msg); } public ValidCodeErRorexception (String msg, Throwable T) {Super (msg, t); }}Als nächstes kommt Anbieter:
import org.springframework.security.authentication.badcredentialSexception; import org.springframework.security.authentication.usernamepasswordAuthenticationToken; org.springframework.security.core.authenticationException; import org.springframework.security.core.userDetails.UserDetails; MyAuthenticationProvider erweitert die DaoAuthenticationProvider {@override öffentliche Boolan -Unterstützung (Klasse <> Authentifizierung) {@override) (Klasse <; MyusernamepasswordAuthenticationToken.Class.isScassableFable (Authentifizierung); } @Override Protected void zusätzlichAuthenticationChecks (UserDetails UserDetails, userernamePassWordAuthenticationToken Authentifizierung) löst die Authentifizierung aus. if (getaltSource ()! } if (authentication.getCredentials () == null) {logger.debug ("Authentifizierung fehlgeschlagen: Keine Anmeldeinformationen angegeben"); Neue badcredentialSexception werfen ("Benutzername oder Kennwortfehler!"); } String präsentedPassword = authentifizierung.getCredentials (). ToString (); if (! this.getPasswordEnCoder (). ispasswordValid (userDetails.getPassword (), präsentiertesPassword, Salz)) {logger.debug ("Authentifizierung fehlgeschlagen: Passwort stimmt nicht mit dem gespeicherten Wert überein"); Neue badcredentialSexception werfen ("unter Benutzername oder Passwort!"); }}} Die unterstützende Methode gibt die Verwendung eines benutzerdefinierten Tokens an, und die zusätzliche AuthenticationChecks -Methode entspricht genau der Logik der übergeordneten Klasse. Ich habe gerade die von der Ausnahme zurückgegebenen Informationen geändert.
Als nächstes kommt der Handler, der die erfolgreiche Authentifizierung und die fehlgeschlagene Authentifizierung übernimmt
import org.springframework.security.core.authentication; import org.springframework.security.web.authentication javax.servlet.http.httpServletResponse; import Java.io.ioException; öffentliche Klasse FrontAuthentications -Bildung erweitert SimpleUrlAuthenticationsuccessHandler {public FrontAuthenticationSuccessHandler (String DefaultTargeturl) {super (fausttargeturl); } @Override public void OnAuthentications -nach -nach -uccess (httpServletRequest -Anforderung, HttpServletResponse -Antwort, Authentifizierungsauthentifizierung) löscht IOException, servleTexception {Super.onauthenticationsCess (Anfrage, Antwort, Authentifizierung); }} import org.springframework.security.core.authenticationException; import org.springframework.security.web.authentication javax.servlet.http.httpServletResponse; import Java.io.ioException; öffentliche Klasse FrontAuthenticationFailureHandler erweitert SimpleUrlauthenticationFailReHandler {öffentliche FrontAuthenticationFailureHandler (String DefaultFailureurl) {Super (FallFaultFailReurl); } @Override public void OnAuthenticationFailure (httpServletRequest -Anforderung, httpServletResponse -Antwort, Authentifizierungsexception) löst IOException, ServleTException aus {Super.onauthenticationFailure (Anfrage, Antwort, Ausnahme); }}Schließlich die wichtigste Sicherheitskonfiguration:
Import com.service.user.customerservice; import com.web.filter.sitemeshfilter; import com.web.mysecurity. org.springframework.context.annotation.configuration; import org.springframework.core.annotation.order; import org.springframework.security.authentication.AuthenticationManager; org.springframework.security.authentication.providermanager; import org.springframework.security.config.Annotation org.springframework.security.config.annotation.web.configuration.webecurityConFigurerAdapter; org.springframework.security.web.access.ExceptiontranslationFilter; org. java.util.list;@configuration@enableWebSecurityPublic Class SecurityConfig erweitert AbstractSecurityWebApplicationInitializer {@Bean public kitchEnCoder passwordEncoder () {Neue StandardpasswordEncoder ("MD5"); } @Autowired Private Customerservice Customerservice; @Configuration @Order (1) öffentliche statische Klasse FrontendWebSecurityConfigureadapter erweitert WebSecurityConFigurerAdapter {@autowired private myvalidCodeProcessingfilter myvalidcodeProcessingFilter; @Override Protected void configure (httpecurity http) löst Ausnahme aus. .AddFilterBefore (myvalidCodeProcessingFilter, usernamePasswordAuthenticationFilter.Class) .formlogin () .LoginPage ("/user/login) .and () .logout () .logouturlo ("/user/user/logout "). }} @Bean (name = "frontAuthenticationProvider") public myAuthenticationProvider FrontAuthenticationProvider () {MyAuthenticationProvider myauthenticationProvider = new myAuthenticationProvider (); MyAuthenticationProvider.SetUserDetailsService (Customerservice); myAuthenticationProvider.setPasswordEnCoder (PassageCoder ()); MyauthenticationProvider zurückgeben; } @Bean public AuthenticationManager AuthenticationManager () {list <authenticationProvider> list = new ArrayList <> (); list.add (FrontAuthenticationProvider ()); AuthenticationManager AuthenticationManager = new ProviderManager (Liste); AuthenticationManager zurückgeben; } @Bean public myvalidCodeProcessingFilter myvalidCodeProcessingFilter (AuthentifizierungManager AuthentifizierungManager) {myvalidCodeProcessingFilter filter = new myvalidcodeProcessingFilter (); filter.setAuthenticationManager (AuthenticationManager); filter.setAuthenticationsCessHandler (FrontAuthenticationsCessHandler ()); filter.setAuthenticationFailureHandler (FrontAuthenticationFailureHandler ()); Rückgabefilter; } @Bean public FrontAuthenticationFailureHandler FrontAuthenticationFailureHandler () {Neue FrontAuthenticationFailureHandler zurückgeben ("/user/login"); } @Bean public FrontAuthenticationsCessHandler FrontAuthenticationsCessHandler () {Neue FrontAuthenticationsCessHandler zurückgeben ("/vorne/test"); } @Bean public myAuthenticationEntryPoint myAuthenticationEntryPoint () {Neue MyAuthenticationEntryPoint zurückgeben ("/user/login"); }}Zunächst handelt es sich um eine Bohne der Verschlüsselungsklasse, und Customerservice ist ein einfacher Abfragebenutzer
@Service ("Customerservice") öffentliche Klasse CustomerserviceImpl implementiert Customerservice {@autowired private userDao userDao; @Override public userDetails loadUserByUserName (String -Benutzername) löst ustamenotFoundException {return userDao.findcustomerByUnername (Benutzername) zurück; }} Als nächstes kommt FrontendWebSecurityConfigureadapter. Ich habe die Konfigurationsmethode neu geschrieben, zuerst CSRF deaktivieren, autorizeRequests () aktivieren, wobei "/user/login" und "/user/logout" die Berechtigungsüberprüfung loslassen und andere Anforderungen erfordern, Anmeldeauthentifizierung und dann AddFilterBefore (). Bevor ich meinen benutzerdefinierten myvalidCodeprocessing -filter in die standardmäßige BenutzernamepasswordAuthenticationFilter in Sicherheit hinzufüge, führe ich zuerst meine benutzerdefinierte Parameter -Authentifizierung durch und dann formlogin (), konfigurieren Sie die URL -Login -URL und loggen eine URL an, und login, login -URL und Login -URL.
Als nächstes kommt die Bean Display -Deklaration von AuthenticationProvider, AuthenticationManager, RecantingFilter, AuthenticationFailureHandler, Authentications -CessHandler und EntryPoint.
Unten ist Login.jsp
<body> <div> <Form: Form autoComplete = "false" commandname = "userDto" methode = "post"> <div> <span> <b> $ {Spring_security_last_exception.message} </b> </span> </div> username: <form: Eingabepaths: </b> kassclasse: körpernamen "csSclasse =" csSclasse "csSclasse =" Form: <Forms: </bods: csSclasse = "csSclasse" csSclasse = "Form: <Form: <Form: <Form: <Formular". path = "Passwort" CSSCLASS = "Form-kontroll"/> <br/> validateCode: <Formular: Eingabespath = "validateCode" CSSSCLASS = "Form-Control"/> <label> $ {validate_code} </Label> </Label> <Eingabe type = "precination =" typBox ". value = "subieren"/> </Form: Form> </div> </body>Wenn der Verifizierungscode fehlschlägt, wird die validCodeErRorexception geworfen. Da es die Authentifizierungsexzeption vererbt, wird die AuthentifizierungFailureHandler bei der Authentifizierungspflicht ausgelöst. Die obige Bean erklärt, dass die Authentifizierung fehlgeschlagen ist und zur Anmelde -URL springt. Es gibt also $ {spring_security_last_exception.message} in login.jsp. Die Ausnahmeinformationen werden bei der Authentifizierung geworfen, wodurch das benutzerfreundliche Verfahren aufgefordert wird.
Der gesamte kundenspezifische Sicherheitsüberprüfungsprozess ist abgeschlossen
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.