¡La nueva versión de Spring Security es suficientemente elegante para usarla!

Hace poco se publicó Spring Boot 2.7.0 y Spring Security también se actualizó a 5.7.1. Tras la actualización descubrí que el método de configuración de Spring Security que había estado usando quedó obsoleto. No puedo evitar sentir que la tecnología avanza demasiado rápido: ¡apenas se empieza a usar algo y ya se abandona! Hoy le mostraré el uso más reciente de Spring Security para ver si es lo suficientemente elegante.

Proyecto de comercio electrónico mall con SpringBoot para casos reales (50k+star), dirección: github.com/macrozheng/…

Uso básico



Comparemos primero la función básica de autenticación de inicio de sesión que ofrece Spring Security para ver si la nueva versión es mejor.

Versión actualizada


Primero, modifique el archivo pom.xml del proyecto y actualice la versión de Spring Boot a la versión 2.7.0.

org.springframework.boot
spring-boot-starter-parent
2.7.0



Uso anterior


En las versiones anteriores a Spring Boot 2.7.0 era necesario escribir una clase de configuración que heredara de WebSecurityConfigurerAdapter y reescribir los tres métodos del Adapter para configurarlo;
/**
* SpringSecurity configuration
* Created by macro on 2018/4/26.
*/
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class OldSecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private UmsAdminService adminService;

@Override
protected void configure(HttpSecurity httpSecurity) throws Exception {
//Omit the configuration of HttpSecurity
}

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.userDetailsService(userDetailsService())
.passwordEncoder(passwordEncoder());
}

@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}

}

Si lo usa en SpringBoot versión 2.7.0, verá que WebSecurityConfigurerAdapter quedó obsoleto, ¡y parece que Spring Security abandonará definitivamente este uso!

Uso nuevo
El nuevo uso es muy sencillo: no hace falta heredar de WebSecurityConfigurerAdapter, solo se declara la clase de configuración directamente, se configura un método para generar SecurityFilterChainBean y se traslada la configuración original de HttpSecurity a ese método.
/**
* New usage configuration for SpringSecurity 5.4.x and above
* To avoid circular dependencies, only used to configure HttpSecurity
* Created by macro on 2022/5/19.
*/
@Configuration
public class SecurityConfig {

@Bean
SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws Exception {
//Omit the configuration of HttpSecurity
return httpSecurity.build();
}

}

El nuevo uso resulta muy sencillo y directo, y evita la operación de heredar de WebSecurityConfigurerAdapter y reescribir el método. ¡Le recomendamos encarecidamente actualizarlo!

Uso avanzado



Tras actualizar a la versión 2.7.0 de Spring Boot, Spring Security incorporó cambios importantes en el método de configuración. ¿Esto afecta otros usos? En realidad, no. ¡Veamos cómo usar Spring Security para implementar el control dinámico de permisos!

Permisos dinámicos por método



Primero hablemos del control dinámico de permisos por método. Aunque este método es sencillo de implementar, tiene ciertas desventajas.


Use @EnableGlobalMethodSecurity en la clase de configuración para habilitarlo;

/**
* SpringSecurity configuration
* Created by macro on 2018/4/26.
*/
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class OldSecurityConfig extends WebSecurityConfigurerAdapter {

}


Luego use @PreAuthorize en el método para configurar los permisos necesarios para acceder a la interfaz;

/**
* Commodity Management Controller
* Created by macro on 2018/4/26.
*/
@Controller
@Api(tags = "PmsProductController", description = "Product Management")
@RequestMapping("/product")
public class PmsProductController {
@Autowired
private PmsProductService productService;

@ApiOperation("Create an item")
@RequestMapping(value = "/create", method = RequestMethod.POST)
@ResponseBody
@PreAuthorize("hasAuthority('pms:product:create')")
public CommonResult create(@RequestBody PmsProductParam productParam, BindingResult bindingResult) {
int count = productService.create(productParam);
if (count > 0) {
return CommonResult.success(count);
} else {
return CommonResult.failed();
}
}
}


Después consulte en la base de datos el valor del permiso del usuario y asígnelo al objeto UserDetails. Aunque este método es práctico de implementar, escribir el valor del permiso en el método no resulta elegante.

/**
* UmsAdminService implementation class
* Created by macro on 2018/4/26.
*/
@Service
public class UmsAdminServiceImpl implements UmsAdminService {
@Override
public UserDetails loadUserByUsername(String username){
//get user information
UmsAdmin admin = getAdminByUsername(username);
if (admin != null) {
List permissionList = getPermissionList(admin.getId());
return new AdminUserDetails(admin,permissionList);
}
throw new UsernameNotFoundException("Incorrect username or password");
}
}

Permisos dinámicos por ruta



De hecho, la ruta correspondiente a cada interfaz es única, y resulta más elegante controlar los permisos de la interfaz mediante la ruta.


Primero es necesario crear un filtro para los permisos dinámicos. Preste atención al método doFilter, que se usa para configurar y dejar pasar las solicitudes OPTIONS y las de la lista blanca. Este invoca al método super.beforeInvocation(fi), que a su vez llama al método decide de AccessDecisionManager para la operación de autenticación;

/**
* Dynamic permission filter for path-based dynamic permission filtering
* Created by macro on 2020/2/7.
*/
public class DynamicSecurityFilter extends AbstractSecurityInterceptor implements Filter {

@Autowired
private DynamicSecurityMetadataSource dynamicSecurityMetadataSource;
@Autowired
private IgnoreUrlsConfig ignoreUrlsConfig;

@Autowired
public void setMyAccessDecisionManager(DynamicAccessDecisionManager dynamicAccessDecisionManager) {
super.setAccessDecisionManager(dynamicAccessDecisionManager);
}

@Override
public void init(FilterConfig filterConfig) throws ServletException {
}

@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) servletRequest;
FilterInvocation fi = new FilterInvocation(servletRequest, servletResponse, filterChain);
//OPTIONS request is released directly
if(request.getMethod().equals(HttpMethod.OPTIONS.toString())){
fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
return;
}
//The whitelist request is released directly
PathMatcher pathMatcher = new AntPathMatcher();
for (String path : ignoreUrlsConfig.getUrls()) {
if(pathMatcher.match(path,request.getRequestURI())){
fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
return;
}
}
//Here will call the decide method in AccessDecisionManager for authentication operation
InterceptorStatusToken token = super.beforeInvocation(fi);
try {
fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
} finally {
super.afterInvocation(token, null);
}
}

@Override
public void destroy() {
}

@Override
public Class getSecureObjectClass() {
return FilterInvocation.class;
}

@Override
public SecurityMetadataSource obtainSecurityMetadataSource() {
return dynamicSecurityMetadataSource;
}

}


A continuación es necesario crear una clase que herede de AccessDecisionManager y usar el método decide para comparar los permisos que requiere la interfaz a la que se accede con los permisos que tiene el usuario; si coinciden, se deja pasar la solicitud;

/**
* Dynamic permission decision manager, used to determine whether the user has access rights
* Created by macro on 2020/2/7.
*/
public class DynamicAccessDecisionManager implements AccessDecisionManager {

@Override
public void decide(Authentication authentication, Object object,
Collection configAttributes) throws AccessDeniedException, InsufficientAuthenticationException {
// Release directly when the interface is not configured with resources
if (CollUtil.isEmpty(configAttributes)) {
return;
}
Iterator iterator = configAttributes.iterator();
while (iterator.hasNext()) {
ConfigAttribute configAttribute = iterator.next();
// Compare access to required resources or user-owned resources
String needAuthority = configAttribute.getAttribute();
for (GrantedAuthority grantedAuthority : authentication.getAuthorities()) {
if (needAuthority.trim().equals(grantedAuthority.getAuthority())) {
return;
}
}
}
throw new AccessDeniedException("Sorry, you don't have access rights");
}

@Override
public boolean supports(ConfigAttribute configAttribute) {
return true;
}

@Override
public boolean supports(Class aClass) {
return true;
}

}


Como el atributo configAttributes del método decide anterior se obtiene del método getAttributes de FilterInvocationSecurityMetadataSource, también es necesario crear una clase que lo herede; el método getAttributes permite obtener el valor del permiso necesario para acceder a la ruta actual;

/**
* Dynamic permission data source for obtaining dynamic permission rules
* Created by macro on 2020/2/7.
*/
public class DynamicSecurityMetadataSource implements FilterInvocationSecurityMetadataSource {

private static Map configAttributeMap = null;
@Autowired
private DynamicSecurityService dynamicSecurityService;

@PostConstruct
public void loadDataSource() {
configAttributeMap = dynamicSecurityService.loadDataSource();
}

public void clearDataSource() {
configAttributeMap.clear();
configAttributeMap = null;
}

@Override
public Collection getAttributes(Object o) throws IllegalArgumentException {
if (configAttributeMap == null) this.loadDataSource();
List configAttributes = new ArrayList<>();
//Get the currently accessed path
String url = ((FilterInvocation) o).getRequestUrl();
String path = URLUtil.getPath(url);
PathMatcher pathMatcher = new AntPathMatcher();
Iterator iterator = configAttributeMap.keySet().iterator();
//Get the resources needed to access the path
while (iterator.hasNext()) {
String pattern = iterator.next();
if (pathMatcher.match(pattern, path)) {
configAttributes.add(configAttributeMap.get(pattern));
}
}
// The operation request permission is not set, return an empty collection
return configAttributes;
}

@Override
public Collection getAllConfigAttributes() {
return null;
}

@Override
public boolean supports(Class aClass) {
return true;
}

}


Cabe señalar que los datos de los valores de permiso correspondientes a todas las rutas provienen del DynamicSecurityService personalizado;

/**
* Dynamic permission related business class
* Created by macro on 2020/2/7.
*/
public interface DynamicSecurityService {
/**
* Load resource ANT wildcard and resource corresponding MAP
*/
Map loadDataSource();
}


Ya está todo listo: agregue el filtro de permisos dinámicos antes de FilterSecurityInterceptor;

/**
* New usage configuration for SpringSecurity 5.4.x and above
* To avoid circular dependencies, only used to configure HttpSecurity
* Created by macro on 2022/5/19.
*/
@Configuration
public class SecurityConfig {

@Autowired
private DynamicSecurityService dynamicSecurityService;
@Autowired
private DynamicSecurityFilter dynamicSecurityFilter;

@Bean
SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws Exception {
//Omit some configuration...
//Add dynamic permission verification filter when there is dynamic permission configuration
if(dynamicSecurityService!=null){
registry.and().addFilterBefore(dynamicSecurityFilter, FilterSecurityInterceptor.class);
}
return httpSecurity.build();
}

}


Si leyó este artículo, ¡integrar SpringSecurity+JWT para lograr la autenticación de inicio de sesión requiere solo cuatro pasos! Entonces ya sabe que debe configurar estos dos beans: uno se encarga de obtener la información del usuario que inicia sesión y el otro de obtener las reglas de permisos dinámicos almacenadas. Para adaptarnos al nuevo uso de Spring Security, ya no heredamos SecurityConfig, ¡lo cual es mucho más sencillo!

/**
* mall-security module related configuration
* Custom configuration to configure how to obtain user information and dynamic permissions
* Created by macro on 2022/5/20.
*/
@Configuration
public class MallSecurityConfig {

@Autowired
private UmsAdminService adminService;

@Bean
public UserDetailsService userDetailsService() {
//Get the login user information
return username -> {
AdminUserDetails admin = adminService.getAdminByUsername(username);
if (admin != null) {
return admin;
}
throw new UsernameNotFoundException("Incorrect username or password");
};
}

@Bean
public DynamicSecurityService dynamicSecurityService() {
return new DynamicSecurityService() {
@Override
public Map loadDataSource() {
Map map = new ConcurrentHashMap<>();
List resourceList = adminService.getResourceList();
for (UmsResource resource : resourceList) {
map.put(resource.getUrl(), new org.springframework.security.access.SecurityConfig(resource.getId() + ":" + resource.getName()));
}
return map;
}
};
}

}

Prueba de funcionamiento

A continuación, inicie nuestro proyecto de ejemplo mall-tiny-security e inicie sesión con la siguiente cuenta y contraseña; esta cuenta solo está configurada para acceder a /brand/listAll, y la dirección de acceso es: http://localhost:8088/swagger-ui/



Después coloque el token devuelto en la cabecera de autenticación de Swagger;



Cuando accedemos a la interfaz autorizada, los datos se obtienen con normalidad;



Cuando accedemos a la interfaz sin permiso, esta devuelve un mensaje que indica que no hay permiso de acceso.


Resumen


El uso actualizado de Spring Security es, en efecto, ¡lo suficientemente elegante, lo suficientemente sencillo y más compatible con el uso anterior! Personalmente, considero que un framework maduro no cambia mucho su forma de uso durante el proceso de actualización; aun cuando lo haga, mantiene la compatibilidad con el uso anterior. Así que, en la mayoría de los frameworks, ¡la versión anterior seguirá funcionando y la nueva también!

Artículos relacionados

Ver más ofertas especiales

  1. Short Message Service (SMS) y servicio de correo

    Paquete de 50,000 correos electrónicos desde USD $1.99, 120 mensajes SMS desde solo USD $1.00

phone Contactar con nosotros
Hi, I'm Alibaba Cloud AI Assistant!
I can help with questions and solutions.