Spring Boot集成Spring Security

2023-05-16

Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。

简言之，Spring Security底层实现为一条过滤器链，用户请求进来，判断有没有请求的权限，抛出异常，重定向跳转，Spring Security提供了两个核心功能：用户认证与用户授权。

Spring Security用户认证

引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Controller测试

添加一个controller，在不进行其他操作时访问该网址

@Slf4j
@RestController
public class UserController {
    @GetMapping("/test")
    public String test(){
        return "test!!!";
    }
}

在访问http://localhost:8080/test时发现跳转到了http://localhost:8080/login下，并且Spring Security提供了一个默认的登录页面，系统默认的用户名为user，密码在控制台显示输出

输入用户名密码后就能跳转到登录前的页面：

Security 有两种认证方式：

httpbasic
formLogin 默认的，如上边那种方式

同样，Security 也提供两种过滤器类：

UsernamePasswordAuthenticationFilter 表示表单登陆过滤器
BasicAuthenticationFilter 表示 httpbasic 方式登陆过滤器

图中橙色的 FilterSecurityInterceptor 是最终的过滤器，它会决定当前的请求可不可以访问Controller，判断规则放在这个里面。

当不通过时会把异常抛给在这个过滤器的前面的 Exception TranslationFilter 过滤器。

Exception TranslationFilter 接收到异常信息时，将跳转页面引导用户进行认证，如上方所示的用户登陆界面。

自定义认证逻辑

实际开发中是不可能使用 Spring Security 默认的这种方式的，因此需要实现自定义认证逻辑。

以将默认的 form 认证方式改为 httpbasic 方式为例：

首先需要自定义一个配置类，让它继承WebSecurityConfigurerAdapter，然后重写configure方法，这里采用http方式，因此重写http方法

@Configuration
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry registry = http
                .authorizeRequests();
        registry.and()
                .formLogin()
                .permitAll()
                .and()
                .logout()
                .permitAll()
                .and()
                .antMatcher("/**")
                .authorizeRequests()
                .and()
                .authorizeRequests()
                // 任何请求都需要验证
                .anyRequest()
                .authenticated()
                .and()
                // 关闭跨站请求防护
                .csrf().disable()
                // 前后端分离不需要session，将状态设为STATELESS即不需要session
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }
}

自定义认证逻辑分三步：

处理用户信息获取逻辑
处理用户校验逻辑
处理密码加密解密

处理用户信息获取逻辑

Spring Security 中用户信息获取逻辑的获取逻辑是封装在一个接口里的：UserDetailService，代码如下：

public interface UserDetailsService {
    UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
}

这个接口中只有一个方法，loadUserByUsername()，该接收一个 String 类型的username参数，然后返回一个UserDetails的对象，其作用就是通过前台用户输入的用户名，然后去数据库存储中获取对应的用户信息，然后封装在UserDetail实现类里面。

封装到UserDetail 实现类返回以后，Spring Srcurity会拿着用户信息去做校验，如果校验通过了，就会把用户放在 session 里面，否则，抛出UsernameNotFoundException 异常，Spring Security 捕获后做出相应的提示信息。

因此如果要处理用户信息获取逻辑，就需要实现UserDetailsService，从而实现读取数据库中的用户名和密码进行登录

@Slf4j
@Component
public class UserServiceDetailImpl implements UserDetailsService {
    @Autowired
    private UserService userService;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userService.queryByName(username);
        return new SecurityUserDetails(user);
    }
}

这里可以直接返回数据库中查询的user对象，但无法进行进一步操作，因此将user对象进行封装，Secrucity提供的UserDetails 接口专门用于封装：

public class SecurityUserDetails extends User implements UserDetails {

    private static final long serialVersionUID = 1L;

    public SecurityUserDetails(User user) {

        if(user!=null) {
            this.setUsername(user.getUsername());
            this.setPassword(user.getPassword());
        }
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return AuthorityUtils.commaSeparatedStringToAuthorityList("admin");
    }

    /**
     * 账户是否过期
     * @return
     */
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    /**
     * 是否禁用
     * @return
     */
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    /**
     * 密码是否过期
     * @return
     */
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    /**
     * 是否启用
     * @return
     */
    @Override
    public boolean isEnabled() {
        return true;
    }
}

处理用户校验逻辑

关于用户的校验逻辑主要包含两方面：

密码是否匹配【由Sprin Security处理，只需要告诉其密码即可】
密码是否过期、或者账户是否被冻结等

前者，已经通过实现UserDetailsService 的loadUserByname()方法实现了，接下来主要看看后者。

用户密码是否过期、是否被冻结等等需要实现UserDetails接口：

public interface UserDetails extends Serializable {

    Collection<? extends GrantedAuthority> getAuthorities();授权列表；

    String getPassword();从数据库中查询到的密码；

    String getUsername();用户输入的用户名；

    boolean isAccountNonExpired();当前账户是否过期；

    boolean isAccountNonLocked();账户是否被锁定；

    boolean isCredentialsNonExpired();账户的认证时间是否过期；

    boolean isEnabled();是账户是否有效。
}

主要看后四个方法：

1、isAccountNonExpired() 账户是否过期返回true 表示没有过期
2、isAccountNonLocked() 账户是否锁定
3、isCredentialsNonExpired() 密码是否过期
4、isEnabled() 是否被删除

每个方法可以根据实际需求进行重写

处理密码加密解密

在 WebSecurityConfig 自定义配置类重写configure方法，形参为AuthenticationManagerBuilder

@Autowired
private UserDetailsServiceImpl userDetailsService;

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth.userDetailsService(userDetailsService).passwordEncoder(new BCryptPasswordEncoder());//加密
}

配置了这个 configure 方法以后，从前端传递过来的密码就会被加密，所以从数据库查询到的密码必须是经过加密的，而这个过程都是在用户注册的时候进行加密的。

自定义响应结果

在实际的开发中，对于用户的登录认证，不可能使用 Spring Security 自带的方式或者页面，需要自己定制适用于项目的登录流程。

Spring Security 支持用户在配置文件中配置自己的登录页面，如果用户配置了，则采用用户的页面，否则采用模块内置的登录页面。

实现起来只需要在WebSecurityConfig 配置类中增加成功、失败的过滤器即可

@Autowired
private AuthenticationSuccessHandler successHandler;

@Autowired
private AuthenticationFailHandler failHandler;

@Override
protected void configure(HttpSecurity http) throws Exception {

    ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry registry = http
            .authorizeRequests();

    registry.and()
        表单登录方式
        .formLogin()
        .permitAll()
        成功处理类
        .successHandler(successHandler)
        失败
        .failureHandler(failHandler)
        .and()
        .logout()
        .permitAll()
        .and()
        .authorizeRequests()
        任何请求
        .anyRequest()
        需要身份认证
        .authenticated()
        .and()
        关闭跨站请求防护
        .csrf().disable()
        前后端分离采用JWT 不需要session
        .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
}

用户登录成功后，Spring Security 的默认处理方式是跳转到原来的链接上，这也是企业级开发的常见方式，但是有时候采用的是 Ajax 方式发送的请求，往往需要返回 Json 数据，如图中：登陆成功后，会把 token 返回给前台，失败时则返回失败信息。

AuthenticationSuccessHandler：

@Slf4j
@Component
public class AuthenticationSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler {

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {

        List<GrantedAuthority> authorities = (List<GrantedAuthority>) ((UserDetails)authentication.getPrincipal()).getAuthorities();
        List<String> list = new ArrayList<>();
        for(GrantedAuthority g : authorities){
            list.add(g.getAuthority());
        }
        登陆成功生成token
        String  token = UUID.randomUUID().toString().replace("-", "");
    token 需要保存至服务器一份，实现方式：redis or jwt
        输出到浏览器
        ResponseUtil.out(response, ResponseUtil.resultMap(true,200,"登录成功", token));
    }
}

SavedRequestAwareAuthenticationSuccessHandle是 Spring Security 默认的成功处理器，默认方式是跳转。这里将认证信息作为Json数据进行了返回，也可以返回其他数据，这个是根据业务需求来定的，比如，上方代码在用户登陆成功后返回来 token，需要注意的是，此 token 需要在服务器备份一份，毕竟要用做下次的身份认证嘛~

AuthenticationFailHandler：

@Component
public class AuthenticationFailHandler extends SimpleUrlAuthenticationFailureHandler {

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {

        ## 默认情况下，不管你是用户名不存在，密码错误，SS 都会报出 Bad credentials 异常信息
        if (e instanceof UsernameNotFoundException || e instanceof BadCredentialsException) {
            ResponseUtil.out(response, ResponseUtil.resultMap(false,500,"用户名或密码错误"));
        } else if (e instanceof DisabledException) {
            ResponseUtil.out(response, ResponseUtil.resultMap(false,500,"账户被禁用，请联系管理员"));
        } else {
            ResponseUtil.out(response, ResponseUtil.resultMap(false,500,"登录失败，其他内部错误"));
        }
    }

}

通过ResponseUtil工具包进行结果集合的封装

package com.example.authdemo.config;

import com.google.gson.Gson;
import lombok.extern.slf4j.Slf4j;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

/**
 * Description :
 * Created by WanBo
 * Date :2022/5/5
 */
@Slf4j
public class ResponseUtil {

    /**
     *  使用response输出JSON
     * @param response
     * @param resultMap
     */
    Map<String, Object> resultMap;
    public static void out(HttpServletResponse response, Map<String, Object> resultMap){

        ServletOutputStream out = null;
        try {
            response.setCharacterEncoding("UTF-8");
            response.setContentType("application/json;charset=UTF-8");
            out = response.getOutputStream();
            out.write(new Gson().toJson(resultMap).getBytes());
        } catch (Exception e) {
            log.error(e + "输出JSON出错");
        } finally{
            if(out!=null){
                try {
                    out.flush();
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)