Una API con una ruta pública, rutas para cualquier usuario y una sección solo para administradores, protegida con Spring Security, con contraseñas cifradas que no viven en el código.
También te puede interesar
Lo que necesitas
Spring Web y Spring Security. Al agregar la seguridad, todas las rutas quedan protegidas con un usuario temporal (lo verás en las rarezas). Para una API de verdad hay que decir tres cosas: qué rutas son públicas, quién puede entrar a cada una y de dónde salen los usuarios.
Las reglas
package com.ejemplo.seguridad;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
@Configuration
public class SeguridadConfig {
@Bean
SecurityFilterChain reglas(HttpSecurity http) throws Exception {
http.authorizeHttpRequests(a -> a
.requestMatchers("/publico/**", "/error").permitAll()
.requestMatchers("/admin/**").hasRole("ADMIN")
.anyRequest().authenticated())
.httpBasic(Customizer.withDefaults())
.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.csrf(c -> c.disable()); // API sin sesión ni cookies: CSRF no aplica
return http.build();
}
@Bean
PasswordEncoder codificador() {
return PasswordEncoderFactories.createDelegatingPasswordEncoder();
}
@Bean
UserDetailsService usuarios(PasswordEncoder cod,
@Value("${usuarios.ana.clave}") String claveAna,
@Value("${usuarios.luis.clave}") String claveLuis) {
return new InMemoryUserDetailsManager(
User.withUsername("ana").password(cod.encode(claveAna)).roles("USER").build(),
User.withUsername("luis").password(cod.encode(claveLuis)).roles("USER", "ADMIN").build());
}
}authorizeHttpRequests: las reglas se revisan en orden y gana la primera que coincide./publico/**(y/error, para que los mensajes de error no pidan contraseña) quedan abiertas;/admin/**exige el rolADMIN; todo lo demás, cualquier usuario identificado. Pon siempreanyRequest()al final, para que una ruta nueva nazca protegida.httpBasic: el cliente manda usuario y contraseña en cada petición, en la cabeceraAuthorization. Es lo más sencillo para una API interna; solo es seguro sobre HTTPS, porque la contraseña viaja apenas codificada. Para apps y sitios públicos se usan tokens (OAuth 2 y JWT, conspring-boot-starter-oauth2-resource-server).STATELESSycsrf.disable(): la API no crea sesiones ni usa cookies, así que la protección CSRF, pensada para formularios en el navegador, no aplica. Si tu aplicación usa sesión y cookies, no la apagues.- Las contraseñas se guardan cifradas con bcrypt, nunca en texto.
createDelegatingPasswordEncoderagrega delante el nombre del algoritmo ({bcrypt}$2a$10$…), para poder cambiar de algoritmo en el futuro sin romper las contraseñas viejas.
Las contraseñas no están en el código: llegan por variables de entorno, como en la lección 4. En una aplicación real, los usuarios vendrían de una base de datos (implementando UserDetailsService) o de un proveedor de identidad.
spring.application.name=seguridad
usuarios.ana.clave=${CLAVE_ANA}
usuarios.luis.clave=${CLAVE_LUIS}package com.ejemplo.seguridad;
import java.security.Principal;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TiendaController {
@GetMapping("/publico/horario")
public String horario() {
return "Abrimos de lunes a sábado, de 9 a 20 h";
}
@GetMapping("/pedidos")
public String pedidos(Principal usuario) {
return "Pedidos de " + usuario.getName();
}
@PostMapping("/pedidos")
public String nuevo(Principal usuario) {
return "Pedido creado por " + usuario.getName();
}
@GetMapping("/admin/ventas")
public String ventas() {
return "Ventas del día: $48,210.50";
}
}Principal es el usuario que hizo la petición: Spring Security lo inyecta en cualquier método del controlador.
Probarlo
terminal$ curl -s localhost:8080/publico/horario; echo
Abrimos de lunes a sábado, de 9 a 20 h
$ curl -s -o /dev/null -w "%{http_code}\n" localhost:8080/pedidos
401
$ curl -s -u ana:PanDulce-2026 localhost:8080/pedidos; echo
Pedidos de ana
$ curl -s -u ana:PanDulce-2026 -X POST localhost:8080/pedidos; echo
Pedido creado por ana
$ curl -s -o /dev/null -w "%{http_code}\n" -u ana:PanDulce-2026 localhost:8080/admin/ventas
403
$ curl -s -u luis:Cafe.Con.Leche.9 localhost:8080/admin/ventas; echo
Ventas del día: $48,210.50
$ curl -s -o /dev/null -w "%{http_code}\n" -u ana:otra-clave localhost:8080/pedidos
401La ruta pública responde sin contraseña. Sin credenciales, /pedidos da 401 («¿quién eres?»). Ana entra a sus pedidos y puede crear uno con POST, porque apagamos CSRF. En ventas, Ana recibe 403 («sé quién eres, pero no puedes»), y Luis, que es administrador, sí entra. Con la contraseña equivocada, 401. Esa diferencia entre 401 y 403 es la que debe ver el cliente para saber si tiene que identificarse o pedir permiso.
Cada proyecto de esta página se compiló con Spring Boot 4.2.0, Java 25 (Temurin 25.0.5.1) y Maven 3.10.1 en un contenedor limpio y sin red, se arrancó y se probó con las peticiones de curl que ves; las respuestas y los registros están copiados de esa ejecución.