Ejemplo de proyecto de seguridad de Spring utilizando la configuración de Java

Spring Security es un estándar para la seguridad en aplicaciones basadas en Spring, proporciona autenticación y autorización a la aplicación. Spring Security es una poderosa herramienta que proporciona la función de configuración de seguridad personalizada para el usuario. La configuración de seguridad en Spring se puede personalizar de dos maneras, como se indica a continuación: 

1. Configuración basada en XML
2. Configuración Java.

Aquí crearemos un formulario de inicio de sesión utilizando una configuración de seguridad personalizada basada en Java y agregaremos autenticación y autorización a nuestra aplicación.

Prerrequisitos:   Introducción a la primavera , bota de primavera

Pasos para crear un formulario de seguridad basado en Java

Paso 1: Cree un proyecto de arranque de Spring usando spring initializr y proporcione un Grupo y un Id. de artefacto, elija la versión de arranque de Spring, agregue Spring Web, Spring Security y Thymeleaf como dependencias.

Paso 2: extraiga el archivo descargado e impórtelo en Eclipse como proyecto Maven , la estructura del proyecto se vería así:

El proyecto creado debe tener un pom.xml donde se defina la configuración y todas las dependencias. Estamos usando Spring Boot, por lo que no necesitamos definir nada adicional en este momento.

Archivo: pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.gfg</groupId>
    <artifactId>SpringSecurityJavaConfig</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringSecurityJavaConfig</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.thymeleaf.extras</groupId>
            <artifactId>thymeleaf-extras-springsecurity5</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
 
</project>

Esta clase es responsable de compilar todo y ejecutar su aplicación Spring Boot.

// Java program to Illustrate Configuration Java Application
// In Spring Security
 
package com.gfg.SpringSecurityJavaConfig;
 
// Importing required classes
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
// Annotation
@SpringBootApplication
// Class
public class SpringSecurityJavaConfigApplication {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        SpringApplication.run(
            SpringSecurityJavaConfigApplication.class,
            args);
    }
}

Explicación del código: la clase de controlador maneja las requests entrantes redirigiéndolas a la página de vista adecuada, cualquier URL debe definirse en la clase de controlador para enviar una solicitud. La clase LoginController está presente en el paquete com.gfg.SpringSecurityJavaConfig.cotroller y tiene cuatro métodos para asignar cuatro páginas de vista diferentes. Se puede acceder a todas estas páginas de visualización según el rol del usuario. Ahora, veamos cómo definir diferentes roles para diferentes usuarios.

// Java Program to Illustrate LoginController Class
 
package com.gfg.SpringSecurityJavaConfig.cotroller;
 
// Importing required classes
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
 
// Annotation
@Controller
// Class
public class LoginController {
 
    @GetMapping("/welcome") public String welcome()
    {
        return "welcome.html";
    }
 
    @GetMapping("/admin") public String user()
    {
        return "admin.html";
    }
 
    @GetMapping("/basic") public String basic()
    {
        return "basic.html";
    }
 
    @GetMapping("/login") public String login()
    {
        return "login.html";
    }
}

Explicación del código: 

• La clase SpringSecurityConfig en el paquete com.gfg.SpringSecurityJavaConfig.security es donde se define la configuración de Spring Security. Esta clase amplía la clase WebSecurityConfigureAdapter que proporciona métodos como configure para agregar autenticación y autorización personalizadas para el usuario.
• El primer método de configuración tiene el parámetro de AuthenticationManagerBuilder que define la autenticación del usuario. Usaremos una identificación de usuario y una contraseña codificadas para simplificar.
• El passwordEncoder encripta la contraseña usando BCryptPasswordEncoder .
• El segundo método de configuración define la autorización para el usuario, define el mapeo para un usuario con un rol particular, como puede ver, hemos definido que todos los usuarios con roles » BASIC » pueden acceder solo a la página básica y de bienvenida, mientras que el usuario con rol “ ADMIN ” puede acceder a todas las URL. También hemos definido una página de inicio de sesión personalizada que será el punto de redirección de cualquier URL solicitada.

// Java Program to Illustrate Spring Security
 
package com.gfg.SpringSecurityJavaConfig.security;
 
// Importing required classes
import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
 
// Annotation
@EnableWebSecurity
// Class
public class SpringSecurityConfig
    extends WebSecurityConfigurerAdapter {
 
    // Annotation
    @Override
    protected void
    configure(AuthenticationManagerBuilder auth)
        throws Exception
    {
        auth.inMemoryAuthentication()
            .passwordEncoder(passwordEncoder())
            .withUser("gfg")
            .password(passwordEncoder().encode("pass"))
            .roles("ADMIN")
            .and()
            .passwordEncoder(passwordEncoder())
            .withUser("user")
            .password(passwordEncoder().encode("pass"))
            .roles("BASIC");
    }
 
    // Annotation
    @Bean
    // Method
    public PasswordEncoder passwordEncoder()
    {
        return new BCryptPasswordEncoder();
    }
 
    // Annotation
    @Override
    // Method
    protected void configure(HttpSecurity http)
        throws Exception
    {
 
        http.authorizeRequests()
            .antMatchers("/basic")
            .hasAnyRole("BASIC", "ADMIN")
            .antMatchers("/admin")
            .hasRole("ADMIN")
            .antMatchers("/")
            .permitAll()
            .anyRequest()
            .authenticated()
            .and()
            .formLogin()
            .permitAll()
            .loginPage("/login")
            .usernameParameter("username")
            .and()
            .logout()
            .logoutRequestMatcher(
                new AntPathRequestMatcher("/logout"))
            .permitAll();
    }
}

Esta es la página login.html en la carpeta de plantillas, define la página de inicio de sesión para la aplicación.

Archivo: login.html

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <h1>Login page</h1>
    <form th:action="@{/login}" method="post">
        <div><label>Username: </label><input type="text" name="username"></div>
        <div><label>Password: </label><input type="password" name="password"></div>
        <div><button name="submit" type="submit" >Login</button></div>
    </form>
</body>
</html>

Esta es la página welcome.html accesible a todos los usuarios con cualquier rol.

Archivo: bienvenido.html

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <h1>LoggedIn Successful</h1>
    <h2>Welcome Back Click here to <a href="logout">logout</a></h2>
</body>
</html>

Esta es la página basic.html a la que pueden acceder tanto los usuarios «BASIC» como los «ADMIN».

Archivo: basic.html

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>basic page</title>
</head>
<body>
    <h1>Welcome Basic User</h1>
</body>
</html>

Esta es la página admin.html a la que solo pueden acceder los usuarios con el rol «ADMIN».

Archivo: admin.html

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Admin page</title>
</head>
<body>
    <h1>Welcome Admin</h1>
</body>
</html>

Paso 3: después de agregar todas las clases y las páginas de vista, la estructura de nuestro proyecto se ve así:

Paso 4: ahora es el momento de ejecutar su aplicación, después de ejecutar su aplicación, escriba esta URL en cualquiera de los navegadores http://localhost:8080/SpringSecurityJavaConfig/welcome.

Por lo tanto, hemos creado una aplicación web de seguridad Spring utilizando una configuración basada en Java y hemos agregado autenticación y autorización personalizadas a nuestra aplicación.