Spring Security-Tutorial mit Spring Boot

In unseren früheren Beiträgen haben wir über Spring Security 3.0, Spring Security-Anmeldebeispiel und Wie erhalte ich den aktuellen Benutzernamen in Spring Security geschrieben? Das sind ziemlich alte Beiträge und es gibt viele Änderungen in der neuesten Version von Spring Security. Ein weiterer Grund für diesen Beitrag besteht darin, ein möglichst umfassendes Tutorial zu schreiben Federsicherheit Das würde Entwicklern helfen, die die Interna der Spring-Sicherheit verstehen möchten.

Spring-Sicherheits-Tutorial

Dieses Spring Security-Tutorial konzentriert sich mehr auf das Kernmodul von Spring Security und ein einfaches Beispiel, das die Kernfunktionalität demonstriert. Ich werde Spring Boot zum Packen und Ausführen der Anwendung verwenden. Wenn Sie Probleme mit der Federsicherheit haben, posten Sie Ihre Fragen bitte im Kommentarbereich dieses Tutorials. Ich habe Spring Security 4.0.2 verwendet. für dieses Tutorial.

Hinweis: Obwohl ich Spring Boot zum Ausführen dieser Anwendung verwendet habe, habe ich hauptsächlich Java-Konfigurationen verwendet, um mehr Klarheit über die für diese Anwendung erforderlichen Konfigurationen zu schaffen. Da die meisten Webanwendungen immer noch die traditionellen XML-Konfigurationen und Java-Konfigurationen verwenden.

Spring Boot und Spring Security

Spring Boot und Spring Security

Inhaltsverzeichnis

  • Technologie-Stack
  • Überblick über die Spring-Sicherheit
  • Artefakte herunterladen
  • Kernkomponenten
  • Sicherheitskontext
  • SecurityContextHolder
  • Authentifizierung
  • UserDetailsService
  • GrantedAuthority
  • Beispielanwendung für Spring Security
  • Laden Sie den Quellcode herunter
  • Ausnahmen
  • Abschluss
  • Technologie-Stack

    Im Folgenden finden Sie eine Liste der Technologien, die zum Schreiben dieses Tutorials verwendet wurden. Vorkenntnisse zu diesen Frameworks wären hilfreich, um die Konzepte zu verstehen.

    • Java 1.8
    • Maven 3.0
    • Spring Framework 4.2.1
    • Spring Boot 1.2.5
    • Frühlingssicherheit
    • Spring Data JPA
    • Frühlings-MVC
    • HSSQL-Datenbank
    • Tomcat 7.0

    Überblick über die Spring-Sicherheit

    Spring Security ist das hochgradig anpassbare Authentifizierungs- und Zugriffskontroll-Framework. Dies ist das Sicherheitsmodul zur Sicherung von Federanwendungen. Dies kann jedoch auch für nicht auf Federn basierende Anwendungen verwendet werden, wobei nur wenige zusätzliche Konfigurationen erforderlich sind, um die Sicherheitsfunktionen zu aktivieren.

    Der Schwerpunkt von Spring Security liegt auf der Authentifizierung und Autorisierung:

    • Bei der Authentifizierung handelt es sich um den Prozess der Festlegung eines Prinzipals (Benutzers), der vorgibt, dieser zu sein
    • Bei der Autorisierung handelt es sich um den Prozess der Entscheidung, ob der angemeldete Prinzipal (Benutzer) bestimmte Aktionen ausführen darf.

    Wenn es um die Authentifizierung geht, unterstützt Spring Security eine Vielzahl von Authentifizierungsmodellen wie LDAP, OpenID, ESB, JAAS usw., um Ihre Anwendung in der Benutzerdatenbank Ihres Unternehmens zu authentifizieren.

    Spring-Sicherheitsmodule

    Seit Spring Security 3.0 wurde der gesamte Code aufgeteilt und Module eingeführt, um die verschiedenen Funktionalitäten und Drittanbieterabhängigkeiten auf verschiedene Module zu trennen. Im Folgenden finden Sie eine Liste der Module, die derzeit vom Spring Security Framework ausgeliefert werden. Sie werden nicht alle Module für Ihre Bewerbung einbeziehen, dies hängt von Ihren Anforderungen ab.

  • Kern – Dieses Modul enthält die APIs für die grundlegende Authentifizierung und Zugriffskontrollmechanismen. Dies ist für Ameisenfeder-Sicherheitsanwendungen zwingend erforderlich.
  • Fernzugriff – Dieses Modul bietet eine Integration in Spring Remoting. Sie müssen dieses Modul nicht einbinden, es sei denn, Sie schreiben Remote-Client-Anwendungen.
  • Netz – Dieses Modul enthält APIs für Servlet-Filter und alle webbasierten Authentifizierungen wie Zugriffsbeschränkungen für URLs. Jede Webanwendung würde dieses Modul erfordern.
  • Konfig – Sie benötigen es, wenn Sie den Spring Security XML-Namespace für die Konfiguration verwenden. Wenn Sie keine XML-Konfigurationen verwenden, können Sie dieses Modul ignorieren.
  • LDAP – Erforderlich, wenn Sie die LDAP-Authentifizierung verwenden oder LDAP-Benutzereinträge verwalten müssen.
  • ACL – Spezialisierte Domänenobjekt-ACL-Implementierung.
  • CAS – CAS-Client-Integration von Spring Security.
  • OpenID – Unterstützung der OpenID-Webauthentifizierung.
  • Artefakte herunterladen

    Der erste Schritt beim Schreiben Ihrer Spring-Sicherheitsanwendung besteht darin, die erforderlichen Artefakte für die Spring-Sicherheit zu erhalten. Hier sind die Abhängigkeitsanforderungen für Maven- und Gradle-Build-Skripte.

    pom.xml für Maven

    <dependencies>
    <!-- ... other dependency elements ... -->
    <dependency>
    	<groupId>org.springframework.security</groupId>
    	<artifactId>spring-security-web</artifactId>
    	<version>4.0.2.RELEASE</version>
    </dependency>
    <dependency>
    	<groupId>org.springframework.security</groupId>
    	<artifactId>spring-security-config</artifactId>
    	<version>4.0.2.RELEASE</version>
    </dependency>
    </dependencies>
    

    build.gradle für Gradle

    dependencies {
    	compile 'org.springframework.security:spring-security-web:4.0.2.RELEASE'
    	compile 'org.springframework.security:spring-security-config:4.0.2.RELEASE'
    }
    

    Wenn Sie die Authentifizierungsmodelle von Drittanbietern verwenden, müssen Sie diese Abhängigkeiten in Ihre Build-Datei einschließen.

    Kernkomponenten

    In diesem Abschnitt werden die Bausteine ​​der Spring-Sicherheit erläutert und die Kernkomponenten erläutert, die tatsächlich verwendet werden, während sich der Benutzer bei Ihrer Anwendung authentifiziert. Wenn Sie Entwickler sind, würden Sie an diesen Komponenten keine Änderungen vornehmen, es wäre jedoch hilfreich, diese Konzepte zu verstehen.

    Sicherheitskontext

    Wie der Name schon sagt, ist diese Schnittstelle der Grundstein für die Speicherung aller sicherheitsrelevanten Details Ihrer Anwendung. Wenn Sie die Federsicherheit für Ihre Anwendung aktivieren, a SecurityContext wird für jede Anwendung aktiviert und speichert die Details des authentifizierten Benutzers usw. Es verwendet Authentication Objekt zum Speichern der Details im Zusammenhang mit Authentifizierungen.

    SecurityContextHolder

    Diese Klasse ist wichtig für den Zugriff auf beliebige Werte aus der SecurityContext. Sie würden niemals direkt auf den Sicherheitskontext zugreifen, den Sie verwenden müssen SecurityContextHolder um den Kontext zu erhalten und dann auf die Details zuzugreifen. Vereinfacht ausgedrückt handelt es sich um eine Schnittstelle zwischen Client und Kontext. Standardmäßig ist dies der Fall SecurityContextHolder Verwendet ThreadLocal zum Speichern der Details.

    Wenn Sie den aktuell authentifizierten Benutzer wissen möchten, hilft Ihnen das folgende Snippet:

    Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    if (principal instanceof UserDetails) {
        String username = ((UserDetails)principal).getUsername();
    } else {
        String username = principal.toString();
    } 
    

    Authentifizierung

    Schauen wir uns den Prozess der Authentifizierung in der Spring-Sicherheit an:

  • Ein Benutzer wird aufgefordert, sich mit einem Benutzernamen und einem Passwort anzumelden.
  • Das System überprüft, ob das Passwort für den Benutzernamen korrekt ist.
  • Es werden die Kontextinformationen für diesen Benutzer und eine Liste der Rollen abgerufen. usw.
  • Die oben genannten drei Schritte stellen einen erfolgreichen Authentifizierungsprozess dar, und die Spring-Security-Authentifizierung erledigt genau das für Ihre Anwendung.

    Im Folgenden sind die Schritte aufgeführt, um die Authentifizierung zu erhalten:

  • Bei der Authentifizierung handelt es sich um eine Schnittstelle, die über mehrere Implementierungen für unterschiedliche Authentifizierungsmodelle verfügt. Für eine einfache Authentifizierung mit Benutzername und Passwort würde Spring Security verwenden UsernamePasswordAuthenticationToken. Wenn der Benutzer Benutzername und Passwort eingibt, erstellt das System eine neue Instanz von UsernamePasswordAuthenticationToken.
  • Das obige Token wird an weitergegeben AuthenticationManager für die Validierung. Intern was AuthenticationManager Es reicht aus, die Liste der konfigurierten Elemente zu iterieren AuthenticationProvider um die Anfrage zu validieren. Für die gültige Authentifizierung sollte mindestens ein Anbieter konfiguriert werden.
  • Wenn der obige Schritt erfolgreich ist, wird der AuthenticationManager gibt einen gefüllten Wert zurück Authentication Beispiel.
  • Der letzte Schritt besteht darin, durch Aufruf einen Sicherheitskontext einzurichten SecurityContextHolder.getContext().setAuthentication(…​)und übergibt das zurückgegebene Authentifizierungsobjekt.
  • Die oben genannten Schritte sind interne Prozesse des Spring Security Frameworks und der Entwickler muss keinen Code schreiben, um die oben genannten Aktionen auszuführen. Ich habe es nur erklärt, um die Spring-Sicherheitsarchitektur und ihre Implementierungen besser zu verstehen.

    UserDetailsService

    Es handelt sich um eine zentrale Schnittstelle in Spring Security zum Laden benutzerspezifischer Daten. Diese Schnittstelle gilt als Benutzer-DAO und wird von bestimmten DAO-Implementierungen implementiert. Für eine grundlegende In-Memory-Authentifizierung gibt es beispielsweise eine InMemoryUserDetailsManager. Diese Schnittstelle deklariert nur eine Methode loadUserByUsername(String username) Dies vereinfacht die Implementierungsklassen zum Schreiben anderer spezifischer Methoden.

    Mit einfachen Worten: Wenn Sie Ihre vorhandenen DAO-Klassen verwenden möchten, um die Benutzerdetails aus der Datenbank zu laden, implementieren Sie einfach die UserDetailsService und überschreiben Sie die Methode loadUserByUsername(String username). Ein Beispiel für diese Implementierung würde so aussehen:

    @Service
    public class CurrentUserDetailsService implements UserDetailsService {
    
        private final UserService userService;
    
        @Autowired
        public CurrentUserDetailsService(UserService userService) {
            this.userService = userService;
        }
    
        public CurrentUser loadUserByUsername(String username) throws UsernameNotFoundException {
            User user = userService.getUserByUsername(username);
            return new CurrentUser(user);
        }
    }
    

    Im obigen Code das Modell CurrentUser muss vom Typ sein org.springframework.security.userdetails.UserDetails. In der folgenden Beispielanwendung habe ich die erweitert org.springframework.security.userdetails.UserDetails Klasse und schrieb die benutzerdefinierte Benutzerklasse. Dies hat den Vorteil, dass unsere Domänenklasse nicht offengelegt wird.

    GrantedAuthority

    Neben der Authentifizierung gegenüber der Anwendung besteht eine weitere wichtige Komponente darin, die Liste der erteilten Berechtigungen für den angemeldeten Benutzer abzurufen. Dies erfolgt im Rahmen des Autorisierungsprozesses. Dies wird durch den Aufruf von abgerufen getAuthorities() In Authentication Objekt. Dies gibt die Liste von zurück GrantedAuthority was Rollen für die Benutzer bezeichnet.

    Beispielanwendung für Spring Security

    In diesem Abschnitt gehen wir ein einfaches Beispiel für die Federsicherheit durch.

    HelloController.java

    Dies ist die Controller-Klasse, die drei URLs definiert: /hello, /admin und /super.

    @Controller
    public class HelloController {
    
    	@Autowired
    	UserDetailsService userService;
    
    	@RequestMapping(value = { "/", "/hello**" }, method = RequestMethod.GET)
    	public ModelAndView welcomePage() {
    		ModelAndView model = new ModelAndView();
    		model.addObject("title", "Spring Security Example");
    		model.addObject("message", "This is Hello World!");
    		model.setViewName("hello");
    		return model;
    
    	}
    
    	@RequestMapping(value = "/admin**", method = RequestMethod.GET)
    	public ModelAndView adminPage() {
    		UserDetails userDetails = userService.loadUserByUsername("admin");
    		System.out.println(userDetails.getUsername());
    		Authentication auth = SecurityContextHolder.getContext().getAuthentication();
    		String name = auth.getName();
    		ModelAndView model = new ModelAndView();
    		model.addObject("title", "Spring Security Example");
    		model.addObject("message", "Logged In as  " + name + "!");
    		model.setViewName("admin");
    		return model;
    	}
    
    	@RequestMapping(value = "/super**", method = RequestMethod.GET)
    	public ModelAndView dbaPage() {
    		Authentication auth = SecurityContextHolder.getContext().getAuthentication();
    		String name = auth.getName();
    		ModelAndView model = new ModelAndView();
    		model.addObject("title", "Spring Security Example");
    		model.addObject("message", "Logged In as  " + name + "!");
    		model.setViewName("admin");
    		return model;
    	}
    
    }
    

    WebSecurityConfigurerAdapter

    Dies ist die Java-Konfigurationsklasse zum Schreiben der webbasierten Sicherheitskonfigurationen. Sie können die Methoden in dieser Klasse überschreiben, um die folgenden Dinge zu konfigurieren:

    • Erzwingen Sie die Authentifizierung des Benutzers, bevor er auf eine URL in Ihrer Anwendung zugreift
    • Erstellen Sie einen Benutzer mit dem Benutzernamen „user“, dem Passwort „password“ und der Rolle „ROLE_USER“.
    • Aktiviert HTTP-Basis- und formularbasierte Authentifizierung
    • Spring Security stellt automatisch eine Anmeldeseite und eine Erfolgsseite für die Abmeldung für Sie dar

    Eine Grundkonfiguration würde so aussehen:

    @Configuration
    @EnableGlobalMethodSecurity(prePostEnabled = true)
    @Order(SecurityProperties.ACCESS_OVERRIDE_ORDER)
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
    	
    	@Autowired
        private UserDetailsService userDetailsService;
    
    	@Autowired
    	public void configure(AuthenticationManagerBuilder auth) throws Exception {
    		auth
            .userDetailsService(userDetailsService);
    	}	
    	@Override
    	protected void configure(HttpSecurity http) throws Exception {
    
    	  http.authorizeRequests()
    		.antMatchers("/admin/**").access("hasRole('ROLE_ADMIN')")
    		.antMatchers("/super/**").access("hasRole('ROLE_ADMIN') or hasRole('ROLE_SUPER')")
    		.and().formLogin();		
    	}	
    }
    

    Domänenklassen

    CurrentUser.java

    public class CurrentUser extends org.springframework.security.core.userdetails.User {
    	private User user;
    
    	public CurrentUser(User user) {
    		super(user.getUsername(), user.getPassword(), AuthorityUtils.createAuthorityList(user.getRole().toString()));
    		this.user = user;
    	}
    
    	public User getUser() {
    		return user;
    	}
    
    	public Role getRole() {
    		return user.getRole();
    	}
    }
    

    Role.java

    public enum Role {
        ROLE_USER, ROLE_ADMIN,ROLE_SUPER
    }
    

    Benutzer.java

    @Entity
    @Table(name = "users")
    public class User {	
    	
    	@Id
    	@Column(name = "username", nullable = false, unique = true)
    	private String username;
    	@Column(name = "password", nullable = false)
    	@NotNull
    	private String password;
    	@Column(name = "enabled", nullable = false)
        @NotNull
        private Boolean enabled;
    	
    	@Column(name = "role", nullable = false)
        @Enumerated(EnumType.STRING)
        private Role role;
    	//getters and setters
    }
    

    Spring-Daten-Repository

    In diesem Abschnitt werden die Serviceklassen und die Implementierung des Spring Data Repository erläutert.
    CurrentUserDetailsService.java

    @Service
    public class CurrentUserDetailsService implements UserDetailsService {
    
        private final UserService userService;
    
        @Autowired
        public CurrentUserDetailsService(UserService userService) {
            this.userService = userService;
        }
    
        public CurrentUser loadUserByUsername(String username) throws UsernameNotFoundException {
            User user = userService.getUserByUsername(username);
            return new CurrentUser(user);
        }
    }
    

    UserService.java

    public interface UserService {
        User getUserByUsername(String username);  
    }
    

    UserServiceImpl.java

    @Service
    public class UserServiceImpl implements UserService {
        private final UserRepository userRepository;
    
        @Autowired
        public UserServiceImpl(UserRepository userRepository) {
            this.userRepository = userRepository;
        }
        @Override
        public User getUserByUsername(String username) {        
            return (User)userRepository.findByUsername(username);
        }
        
    }
    

    UserRepository.java

    public interface UserRepository extends JpaRepository<User, Long> {
        User findByUsername(String username);
    }
    

    Spring MVC-Konfigurationen

    Dies sind die MVC-Konfigurationen, die zum Ausführen dieser Anwendung erforderlich sind.

    @EnableWebMvc
    @Configuration
    @EnableJpaRepositories
    @Import({ SecurityConfig.class })
    public class AppConfig extends WebMvcConfigurerAdapter{
    
    	@Bean
    	public InternalResourceViewResolver viewResolver() {
    		InternalResourceViewResolver viewResolver 
                              = new InternalResourceViewResolver();
    		viewResolver.setViewClass(JstlView.class);
    		viewResolver.setPrefix("/WEB-INF/JSP/");
    		viewResolver.setSuffix(".jsp");
    		return viewResolver;
    	}
    	
    	@Override
        public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
            configurer.enable();
        }
    }
    

    Ressourcendateien

    Hier sind die Dateien, die im Abschnitt „Ressourcen“ dieses Projekts verwendet werden. Ich habe die Benutzerdetails beim Start der Anwendung geladen, da ich für Demozwecke die In-Memory-Datenbank verwende.
    data.sql

    INSERT INTO users(username,password,role,enabled) VALUES ('admin','pass','ROLE_ADMIN', true);
    INSERT INTO users(username,password,role,enabled) VALUES ('super','pass','ROLE_SUPER', true);
    INSERT INTO users(username,password,role,enabled) VALUES ('krishna','pass','ROLE_USER', true);
    INSERT INTO users(username,password,role,enabled)VALUES ('sanaulla','pass','ROLE_USER', true);
    

    schema.sql

    create table users(
          username varchar_ignorecase(50) not null primary key,
          password varchar_ignorecase(50) not null,
          role varchar_ignorecase(50) not null,
          enabled boolean not null);
    

    application.properties

    spring.jpa.show-sql = true
    logging.level.org.springframework.data=DEBUG
    spring.jpa.hibernate.ddl-auto=
    

    Spring Boot-Anwendung

    Ich verwende Spring Boot, um diese Spring-Security-Beispielanwendung auszuführen. Wenn Sie mehr über die Ausführung erfahren möchten Spring-Boot-AnwendungenBitte beachten Sie unseren vorherigen Artikel zum Thema Spring Boot.
    pom.xml

     <parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>1.2.5.RELEASE</version>
    	</parent>
    	<properties>
    		<java.version>1.8</java.version>
    	</properties>
    	<dependencies>
    		<dependency>
    			<groupId>org.slf4j</groupId>
    			<artifactId>slf4j-api</artifactId>
    			<version>1.7.12</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    			<exclusions>
    				<exclusion>
    					<groupId>org.springframework</groupId>
    					<artifactId>spring-test</artifactId>
    				</exclusion>
    			</exclusions>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-security</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>jstl</groupId>
    			<artifactId>jstl</artifactId>
    			<version>1.2</version>
    		</dependency>
    		<dependency>
    			<groupId>org.apache.tomcat.embed</groupId>
    			<artifactId>tomcat-embed-jasper</artifactId>
    			<scope>provided</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-jpa</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>hsqldb</groupId>
    			<artifactId>hsqldb</artifactId>
    			<version>1.8.0.7</version>
    		</dependency>
    
    	</dependencies>
    	<build>
    		<finalName>spring-boot-security-example</finalName>
    	</build>
    

    Anwendung.java

    @SpringBootApplication
    public class Application {
    	public static void main(String[] args) {
    		SpringApplication.run(Application.class, args);
    	}	
    }
    

    Anwendung ausführen

    Wenn Sie die Anwendung ausführen, ist sie unter http://localhost:8080 zugänglich. Ich habe kein Kontextstammverzeichnis konfiguriert, daher führt Spring Boot die Anwendung im Standardport für Tomcat aus.

    Wenn Sie versuchen, auf die URL http://localhost:8080/admin zuzugreifen, werden Sie nach den Anmeldedaten gefragt.

    Federsicherheitsfederstiefel

    Federsicherheitsfederstiefel

    Wenn Sie sich das obige Beispiel ansehen, leitet Spring Security zur Authentifizierung automatisch zur Seite /login weiter. Wir haben diesen Kontextpfad in unserer Anwendung nicht konfiguriert, der durch die webbasierte Authentifizierung von Spring Security implementiert wird. Wir können diese Konfiguration überschreiben. Das werde ich in meinen nächsten Tutorials zeigen.

    Beispielanwendung für Spring Security Spring Boot

    Wenn Sie die falschen Anmeldeinformationen eingeben, wird die folgende Fehlerseite angezeigt.

    Spring Security-Anmeldefehler

    Dies ist das grundlegende Beispiel für die Konfiguration Ihrer Spring-Sicherheitsanwendungen.

    Laden Sie den Quellcode herunter

    Sie können das funktionierende Codebeispiel über den folgenden Link herunterladen:

    Symbol

    Beispiel für Spring Security + Spring JPA + Spring Boot

    1 Datei(en) 11,69 KB Download

    Ausnahmen

    Wenn Sie mit rein Java-basierten Konfigurationen und Spring Boot arbeiten, besteht die Möglichkeit, dass eine Ausnahme auftritt und es eine Weile dauern kann, bis die Grundursache ermittelt ist. Ich habe einige Probleme erfasst, die möglicherweise auftauchen, und werde in diesem Abschnitt aufgelistet. Es kann Ihnen Zeit sparen, wenn Sie neu auf dieser Welt sind :).

    Keine Zuordnung für HTTP-Anfrage gefunden mit: Wenn diese Ausnahme häufig auftritt, bedeutet dies, dass Sie die Zuordnung zu Ihren Ansichten nicht durchgeführt haben. Wenn Sie jedoch der Meinung sind, dass Sie alles perfekt konfiguriert haben, prüfen Sie, ob diese Konfigurationen zu Ihrer Spring MVC-Konfigurationsdatei hinzugefügt wurden:

    @Override
        public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
            configurer.enable();
        }
    

    Die obige Konfiguration kann Ihre Probleme mit der Anforderungszuordnung lösen.

    JSPs werden nicht gerendert: Wenn JSPs nicht als solche gerendert werden und stattdessen den Inhalt ausdrucken, müssen Sie die Jasper-Parser-Abhängigkeit wie folgt in Ihre pom.xml einfügen:

    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-jasper</artifactId>
        <scope>provided</scope>
    </dependency>
    

    Ich hoffe, dass dies Ihr Problem lösen kann.

    Abschluss

    Ich hoffe, dieses Tutorial hat Ihnen geholfen, die Konfiguration und die Ausführung einer einfachen Spring-Sicherheitsanwendung zu verstehen. Ich habe mich mehr auf die Erläuterung der Kernkonzepte wie Spring Security Context Holder, UserDetailsServices, SpringContext, Authentication und viele andere Kernklassen konzentriert, die für die Durchführung der Authentifizierung und Autorisierung hinter den Kulissen verwendet werden.

    In meinen nächsten Tutorials werde ich tatsächlich viele verschiedene Konfigurationen zeigen, die in Ihren produktionstauglichen Anwendungen verwendet werden.

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen