Acabamos de ver como usar Java equals y hashcode
El uso de Spring Security JDBC es un clásico. En muchas ocaciones ocasiones necesitamos configurar Spring Security para que almacene los usuarios y los roles en una base de datos . Hoy por hoy esto es bastante sencillo de hacer si nos apoyamos en el manejo de anotaciones y Spring Boot. . Vamos a ver un ejemplo sencillo de como configurar lo básico. El primer paso es crearnos un proyecto de Spring Boot que contenga las siguientes dependencias.
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.arquitecturajava</groupId> <artifactId>security1</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>war</packaging> <name>security1</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.11.BUILD-SNAPSHOT</version> <relativePath /> <!-- lookup parent from repository --> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <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-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> <scope>provided</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> <repositories> <repository> <id>spring-snapshots</id> <name>Spring Snapshots</name> <url>https://repo.spring.io/snapshot</url> <snapshots> <enabled>true</enabled> </snapshots> </repository> <repository> <id>spring-milestones</id> <name>Spring Milestones</name> <url>https://repo.spring.io/milestone</url> <snapshots> <enabled>false</enabled> </snapshots> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>spring-snapshots</id> <name>Spring Snapshots</name> <url>https://repo.spring.io/snapshot</url> <snapshots> <enabled>true</enabled> </snapshots> </pluginRepository> <pluginRepository> <id>spring-milestones</id> <name>Spring Milestones</name> <url>https://repo.spring.io/milestone</url> <snapshots> <enabled>false</enabled> </snapshots> </pluginRepository> </pluginRepositories> </project>
El siguiente paso es configurar el fichero de configuración de Spring con un ViewResolver que nos permite gestionar JSP.
package com.arquitecturajava.security1;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.web.servlet.ViewResolver;
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.arquitecturajava.*")
@Import({ SpringConfiguracionSeguridad.class })
public class SpringConfiguracion {
@Bean
public ViewResolver viewResolver() {
InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
viewResolver.setViewClass(JstlView.class);
viewResolver.setPrefix("/");
viewResolver.setSuffix(".jsp");
return viewResolver;
}
}
A partir de este momento ya podremos gestionar vistas JSP . Al tratarse de un proyecto basado en Spring Boot deberemos modificar el fichero de application.properties para que define la carpeta de vistas y el sufijo de estas.
spring.mvc.view.prefix: / spring.mvc.view.suffix: .jsp
Spring Security JDBC
Es momento de ver el contenido del fichero que se encarga de configurar la seguridad.
package com.arquitecturajava.security1;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
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;
@EnableWebSecurity
public class SpringConfiguracionSeguridad extends WebSecurityConfigurerAdapter {
@Autowired
DataSource dataSource;
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests().antMatchers("/**").hasRole("basico").and().formLogin();
}
@Bean(name = "dataSource")
public DriverManagerDataSource dataSource() {
DriverManagerDataSource driverManagerDataSource = new DriverManagerDataSource();
driverManagerDataSource.setDriverClassName("com.mysql.jdbc.Driver");
driverManagerDataSource.setUrl("jdbc:mysql://localhost:8889/mibasedatos");
driverManagerDataSource.setUsername("cecilio");
driverManagerDataSource.setPassword("cecilio");
return driverManagerDataSource;
}
@Autowired
public void configAuthentication(AuthenticationManagerBuilder auth) throws Exception {
auth.jdbcAuthentication().dataSource(dataSource)
.usersByUsernameQuery("select username,password, enabled from users where username=?")
.authoritiesByUsernameQuery("select username, role from user_roles where username=?");
}
}
Este fichero se encarga de definir la configuración completa de Spring Framework a nivel de seguridad .
- El primer método se encarga de configurar el acceso a los recursos y los roles admitidos. En este caso se admite el acceso a todos los recursos a cualquier usuario que disponga de un rol básico.
- El segundo método se encarga de configurar el tipo de autenticación soportado por Spring Security . En este caso se trata de hacer uso de JDBC , por lo tanto veremos como delega en el uso de un dataSource para conectarse a la base de datos. No solo eso sino que configura ademas cuales son las consultas que se ejecutarán contra unas tablas concretas.
- Por último el método que se encarga de definir el DataSource y como nos conectamos a la base de datos.
Una vez tenemos todo esto configurado el siguiente paso es dar de alta en la base de datos en la tabla users:
Este usuario además dispondrá de una serie de roles por lo tanto también tenemos que insertar información en esa tabla:
Aquí podemos ver la relación entre la tabla de users y la de users_roles . En este caso nuestro usuario solo dispone de un rol muy concreto el básico . Eso si por defecto en Spring Security todos llevan el prefijo de ROLE_. Acabamos de configurar Spring Security para gestionar la seguridad apoyándonos en una base de datos es momento de arrancar la aplicación y ver como nos solicita usuario y clave por pantalla para acceder a los recursos.
Introducimos nuestros datos y accedemos:
Otros artículos relacionados:
- Spring Security Annotation y su configuración
- Spring Security (I) configuracion
- Spring Security Login (II)
Hola Cecilio gracias por sus aportes, te pediria si en algun momento puedes subir un ejemplo de Spring Security con userDetailsService y su configuracion con JPA
me apunto la idea pero ando liado 🙁