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

Biblioteca de etiquetas JSP do Spring Security

O Spring Security fornece suas próprias etiquetas para páginas JSP. Essas etiquetas são usadas para acessar informações de segurança no JSP e aplicar restrições de segurança.

As seguintes etiquetas são usadas para proteger a camada de visão do aplicativo.

Etiqueta de autorização Etiqueta de autenticação Marcador Accesscontrollist Etiqueta Csrfinput Tag CsrfMetaTags

Etiqueta de autorização

Esta etiqueta é usada para fins de autorização. Esta etiqueta avalia e verifica se a solicitação foi autorizada.

Ele usa duas propriedades acesso e URL Para verificar a autorização da solicitação. Podemos avaliar essa etiqueta com base no papel do usuário.

Apenas o conteúdo dentro dessa etiqueta será exibido se a propriedade atender aos requisitos. Por exemplo.

<sec:authorize access="hasRole('ADMIN')">
Ele só mostrará se o usuário for admin
</sec:authorize>

Etiqueta de autenticação

Esta etiqueta é usada para acessar a autenticação armazenada no contexto de segurança. Se a autenticação for uma instância do objeto UserDetails, pode ser usada para obter os detalhes do usuário atual. Por exemplo.

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

Marcador Accesscontrollist

Este marcador é usado em conjunto com o módulo ACL do Spring Security. Ele verifica a lista de permissões necessárias para o domínio especificado. Ele só será executado quando o usuário atual possuir todas as permissões. Por exemplo.

<sec:accesscontrollist hasPermission="1,2"domínioObject="${someObject}">
 se o usuário tiver todas as permissões representadas pelos valores"1ou2no objeto dado.
</sec:accesscontrollist>

Tag CsrfInput

Essa tag é usada para criar um token CSRF para formulários HTML. Para usá-la, certifique-se de que a proteção CSRF esteja ativada. Devemos colocar essa tag dentro   tags dentro para criar o token CSRF. Por exemplo.

<form method="post" action="/algum/ação">
                <sec:csrfInput />
                Nome:<br />
                <input type="text" name="username" />
                ...
        </form>

Tag CsrfMetaTags

Ele insere uma meta tag que contém o token CSRF, campos de formulário, nome do cabeçalho e valor do token CSRF. Esses valores são úteis para configurar o token CSRF no JavaScript do aplicativo.

Essa tag deve estar dentro da tag HTML.

JAR do Spring Security Taglib

Para implementar qualquer uma dessas tags, devemos ter o jar do spring security taglib no aplicativo. Também podemos adicioná-lo usando a seguinte dependência Maven.

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

Declaração do Spring Security Taglib

No arquivo JSP, podemos usar a seguinte declaração para usar taglib.

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

Agora, vamos ver um exemplo de como implementar essas tags em um projeto Maven do Spring Security.

Estamos usando o STS (Spring Tools Suite) para criar o projeto. Veja o exemplo.

Criar projeto





Clique Concluído >botão, que criará um projeto Maven conforme mostrado a seguir:



Configuração do Spring Security

Para configurar o Spring Security em um aplicativo Spring MVC, coloque os seguintes quatro arquivos dentro com.w3no codeboxpasta.

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 é usado para configurar o sufixo da localização da view do arquivo de visão.

//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[]{"/"};  
    }  
}

该类用于初始化servlet调度程序。

//SecurityWebApplicationInitializer.java

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

再创建一个用于创建用户并在用户可访问性上应用身份验证和授权的类。

//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() {
    // certifique-se de que as senhas sejam codificadas corretamente
     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"));
        
}  
}

Controlador

Agora, crie um controlador para lidar com solicitações e fornecer respostas.

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

Visualização

Crie arquivos de visualização (jsp) para exibir a saída para o usuário. Já criamos três arquivos JSP, consulte a seguir.

//index.jsp

<html>  
<head>  
<title>Página Inicial</title>  
</head>  
<body>  
<a href="user">User</a> <a href="admin">Admin</a> <br> <br>
Bem-vindo(a) à w3codebox!  
</body>  
</html>
 

//user.jsp

<html>  
<head>  
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
<title>Página Inicial</title>  
</head>  
<body>  
Bem-vindo(a) à página do usuário!  
</body>  
</html>
 

//admin.jsp

Na página de administração, usamos a tag authorize, que é avaliada apenas quando a função específica for satisfeita.

<%@ taglib uri="http://www.springframework.org/security/tags" prefix="security" %><html>  
<head>  
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 
<title>Página Inicial</title>  
</head>  
<body>  
Bem-vindo(a) à página administrativa!
<a href="logout">logout</a> <br><br>
<security:authorize access="hasRole('ADMIN')">
Olá ADMIN
</security:authorize>
<security:csrfInput/>
</body>  
</html>
 

Dependências do projeto

Nosso projeto contém os seguintes itens de dependência necessários para a construção da aplicação.

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

Após adicionar todos esses arquivos, nosso projeto ficará assim:


Executar Aplicação

Clique com o botão direito no projeto e selecione  Executando no servidor. Ele exibe a seguinte saída para o navegador.



Ao fornecer em   AppSecurityConfig Credenciais configuradas no arquivo, clique em usuário e faça login.



Após o login bem-sucedido, ele mostrará a seguinte página de administração conforme mostrado. Note que, devido ao usuário que possui o papel USER, o conteúdo dentro do rótulo authorize não é exibido.



Sair, agora faça login com as credenciais de administrador como admin.



Após fazer login como admin, consulte o rótulo authorize dessa vez para avaliação e exiba a seguinte saída.