English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Biblioteca di tag JSP di Spring Security

Spring Security fornisce i propri tag per le pagine JSP. Questi tag vengono utilizzati per accedere alle informazioni di sicurezza in JSP e applicare vincoli di sicurezza.

Le seguenti etichette vengono utilizzate per proteggere la vista dell'applicazione.

Etichetta di autorizzazione Etichetta di autenticazione Tag Accesscontrollist Etichetta Csrfinput Tag CsrfMetaTags

Etichetta di autorizzazione

Questa etichetta viene utilizzata per scopi di autorizzazione. Questa etichetta valuta e verifica se la richiesta è autorizzata.

Utilizza due attributi access e URL Controlla la richiesta di autorizzazione. Possiamo valutare questa etichetta attraverso il ruolo dell'utente.

Il contenuto visualizzato all'interno di questa etichetta verrà visualizzato solo se l'attributo soddisfa i requisiti. Ad esempio.

<sec:authorize access="hasRole('ADMIN')">
Visualizzerà solo se l'utente è amministratore
</sec:authorize>

Etichetta di autenticazione

Questo etichetta viene utilizzata per accedere all'autenticazione memorizzata nel contesto sicuro. Se Authentication è un'istanza dell'oggetto UserDetails, può essere utilizzata per ottenere i dettagli dell'utente corrente. Ad esempio.

<sec:authentication property="principal.username">

Tag Accesscontrollist

Questo tag viene utilizzato insieme al modulo ACL di Spring Security. Controlla la lista di permessi necessari per il dominio specificato. Esegue solo se l'utente attuale possiede tutti i permessi. Esempio.

<sec:accesscontrollist hasPermission="1,2" domainObject="${someObject}">
 if user has all the permissions represented by the values "1" or "2" on the given object.
</sec:accesscontrollist>

Tag CsrfInput

Questo tag viene utilizzato per creare un token CSRF per i moduli HTML. Per usarlo, assicurati di avere abilitata la protezione CSRF. Dovremmo mettere questo tag in   All'interno del tag possiamo creare il token CSRF. Esempio.

<form method="post" action="/some/action">
                <sec:csrfInput />
                Nome:<br />
                <input type="text" name="username" />
                ...
        </form>

Tag CsrfMetaTags

Inserisce un meta tag che contiene il token CSRF, i campi del modulo, il nome dell'intestazione e il valore del token CSRF. Questi valori sono utili per impostare il token CSRF nel JavaScript dell'applicazione.

Il tag dovrebbe essere messo all'interno dei tag HTML.

JAR Spring Security Taglib

Per implementare qualsiasi tag di questi, dobbiamo avere il jar spring security taglib nell'applicazione. Puoi anche aggiungerlo utilizzando la seguente dipendenza Maven.

</dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-taglibs</artifactId>
    <version>5.0.4.RELEASE</version>
</dependency>

Dichiarazione Spring Security Taglib

Nella pagina JSP, possiamo utilizzare la seguente dichiarazione per utilizzare taglib.

<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags" %>

Ora, diamo un'occhiata a un esempio di implementazione di questi tag in un progetto Maven di Spring Security.

Stiamo utilizzando STS (Spring Tool Suite) per creare progetti. Vedi l'esempio.

Crea progetto





Clicca Finito > pulsante, che creerà un progetto Maven come segue:



Configurazione Spring Security

Per configurare Spring Security nel tuo'applicazione Spring MVC, inserisci i seguenti quattro file: in com.w3codeboxcartella.

AppConfig.java

package com.w3codebox;
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.ComponentScan;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.web.servlet.config.annotation.EnableWebMvc;  
import org.springframework.web.servlet.view.InternalResourceViewResolver;  
import org.springframework.web.servlet.view.JstlView;  
  
@EnableWebMvc  
@Configuration  
@ComponentScan({"com.w3codebox.controller.*"})  
public class AppConfig {  
    @Bean  
    public InternalResourceViewResolver viewResolver() {  
        InternalResourceViewResolver viewResolver  
                          = new InternalResourceViewResolver();  
        viewResolver.setViewClass(JstlView.class);  
        viewResolver.setPrefix("/WEB-INF/views/");  
        viewResolver.setSuffix(".jsp");  
        return viewResolver;  
    }  
}

AppConfig utilizzato per impostare l'estensione del percorso della vista dei file di vista.

//MvcWebApplicationInitializer.java

package com.w3codebox;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;  
public class MvcWebApplicationInitializer extends  
        AbstractAnnotationConfigDispatcherServletInitializer {  
    @Override  
    protected Class<?>[] getRootConfigClasses() {  
        return new Class[] { WebSecurityConfig.class };  
    }  
    @Override  
    protected Class<?>[] getServletConfigClasses() {  
        // Todo Auto-generated method stub  
        return null;  
    }  
    @Override  
    protected String[] getServletMappings() {  
        return new String[] { "/" };  
    }  
}

Questa classe viene utilizzata per inizializzare il dispatcher servlet.

//SecurityWebApplicationInitializer.java

package com.w3codebox;
import org.springframework.security.web.context.*;  
public class SecurityWebApplicationInitializer  
    extends AbstractSecurityWebApplicationInitializer {  
  
}

Crea una classe per creare utenti e applicare autenticazione e autorizzazione all'accessibilità degli utenti.

//WebSecurityConfig.java

package com.w3codebox;
import org.springframework.context.annotation.*;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;  
import org.springframework.security.config.annotation.web.configuration.*;  
import org.springframework.security.core.userdetails.*;
import org.springframework.security.core.userdetails.User.UserBuilder;  
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
@EnableWebSecurity  
@ComponentScan("com.w3codebox")  
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {  
  
@Bean  
public UserDetailsService userDetailsService() {
    // ensure the passwords are encoded properly
     UserBuilder users = User.withDefaultPasswordEncoder();
     InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
     manager.createUser(users.username("mohan").password("1mohan23").roles("USER").build());
     manager.createUser(users.username("admin").password("admin123").roles("ADMIN").build());
     return manager;
    } 
  
@Override  
protected void configure(HttpSecurity http) throws Exception {  
      
      http.authorizeRequests().
      antMatchers("/index","/").permitAll()
      .antMatchers("/admin","/user").authenticated()
      .and();
      .formLogin();
      .and();
      .logout();
      .logoutRequestMatcher(new AntPathRequestMatcher("/logout"));
        
}  
}

Controller

Ora, crea un controller per gestire le richieste e fornire risposte.

//HomeController.java

package com.w3codebox.controller;
import org.springframework.stereotype.Controller;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RequestMethod;
@Controller  
public class HomeController {  
    @RequestMapping(value="/", method=RequestMethod.GET)  
    public String index() {  
        return "index";  
    }  
    @RequestMapping(value="/user", method=RequestMethod.GET)  
    public String user() {  
       return "admin";
    }  
    @RequestMapping(value="/admin", method=RequestMethod.GET)  
    public String admin() {  
          
        return "admin";  
    }
}
 

Vista

Crea un file di vista (jsp) per mostrare l'output agli utenti. Abbiamo creato tre file JSP, vedi di seguito.

//index.jsp

<html>  
<head>  
<title>Pagina Home</title>  
</head>  
<body>  
<a href="user">Utente</a> <a href="admin">Admin</a> <br> <br>
Benvenuti su w3codebox!  
</body>  
</html>
 

//user.jsp

<html>  
<head>  
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
<title>Pagina Home</title>  
</head>  
<body>  
Benvenuti nella pagina utente!  
</body>  
</html>
 

//admin.jsp

Nella pagina di gestione, abbiamo utilizzato il tag authorize, che viene valutato solo quando soddisfano il ruolo specificato.

<%@ taglib uri="http://www.springframework.org/security/tags" prefix="security" %><html>  
<head>  
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 
<title>Pagina Home</title>  
</head>  
<body>  
Benvenuto nella pagina amministrativa!
<a href="logout">logout</a> <br><br>
<security:authorize access="hasRole('ADMIN')">
Ciao, ADMIN
</security:authorize>
<security:csrfInput/>
</body>  
</html>
 

Dipendenze del progetto

Il nostro progetto contiene le dipendenze necessarie per costruire l'applicazione.

//pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.w3codebox</groupId>
  <artifactId>springtaglibrary</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <properties>  
    <maven.compiler.target>1.8</maven.compiler.target>  
    <maven.compiler.source>1.8</maven.compiler.source>  
</properties>  
<dependencies>  
  </dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-webmvc</artifactId>  
            <version>5.0.2.RELEASE</version>  
        </dependency>  
        </dependency>  
        <groupId>org.springframework.security</groupId>  
        <artifactId>spring-security-web</artifactId>  
        <version>5.0.0.RELEASE</version>  
    </dependency>  
</dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-core</artifactId>
    <version>5.0.4.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.security/spring-security-taglibs -->
</dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-taglibs</artifactId>
    <version>5.0.4.RELEASE</version>
</dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework.security/spring-security-config -->
</dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-config</artifactId>
    <version>5.0.4.RELEASE</version>
</dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->  
</dependency>  
    <groupId>javax.servlet</groupId>  
    <artifactId>javax.servlet-api</artifactId>  
    <version>3.1.0</version>  
    <scope>provided</scope>  
</dependency>  
</dependency>  
    <groupId>javax.servlet</groupId>  
    <artifactId>jstl</artifactId>  
    <version>1.2</version>  
</dependency>  
<!-- https://mvnrepository.com/artifact/org.springframework/spring-framework-bom -->
</dependencies>  
  <build>  
    <plugins>  
        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-war-plugin</artifactId>  
            <version>2.6</version>  
            <configuration>  
                <failOnMissingWebXml>false</failOnMissingWebXml>  
            </configuration>  
        </plugin>  
    </plugins>  
</build>  
</project>
 

Dopo aver aggiunto tutti questi file, il nostro progetto appare come segue:


Esegui l'applicazione

Fare clic con il pulsante destro del mouse sul progetto e selezionare  Esegui sul server. Visualizza il seguente output nel browser.



Fornendo in   AppSecurityConfig Credenziali impostate nel file, clicca su utente e accedi.



Dopo aver effettuato il login con successo, verrà visualizzata la pagina di gestione come indicato di seguito. Nota che, poiché l'utente di login ha il ruolo USER, il contenuto all'interno del tag authorize non viene visualizzato.



Disconnettiti, ora accedi come admin fornendo le credenziali dell'amministratore.



Dopo aver effettuato il login come admin, consulta il tag authorize di questa volta per l'evaluazione e visualizza l'output seguente.