项目集成Spring Security

时间  2020-05-06
标签 项目 集成 spring security 栏目 Spring 繁體版
原文   原文链接

前言

以前写的 涂涂影院管理系统 这个 demo 是基于 shiro 来鉴权的，项目先后端分离后，显然集成 Spring Security 更加方便一些，毕竟，都用 Spring 了，权限管理固然 Spring Security.html

花了半天时间整理的笔记，但愿能对你有所帮助。前端

Spring Security 一句话概述：一组 filter 过滤器链组成的权限认证。java

1、加入依赖

环境：项目采用 Spring Initializr 快速构建 Spring Boot ，版本交由 spring-boot-starter-parent 管理。redis

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

在仅仅添加完依赖的状况下，启动项目看看：spring

1.1 控制台打印

控制台打印了一串密码，以下图所示：数据库

访问一下项目中的某个方法：json

http://localhost:7777/tmax/videoCategory/getAll

奇怪，怎么本身跳到 /login 路径下了，并且还让登录？后端

1.2 帐号登陆

在登录 from 表单里输入以下：浏览器

  • 用户名：user
  • 密码：0839a4ba-c8a3-4aee-8a6e-cd19c1d0b0c1（控制台打印的）

点击 Sign in 而后跳转到了目标地址：ruby

添加 Spring Security 依赖后，实际触发了两件事，一时将系统中全部的链接服务都保护起来， 再就是会有默认配置 form 表单认证。

2、基本原理

Spring Security的整个工做流程以下所示：

绿色认证方式能够配置， 橘黄色和蓝色的位置不可更改。

Security 有两种认证方式：

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

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

  • UsernamePasswordAuthenticationFilter 表示表单登录过滤器
  • BasicAuthenticationFilter 表示 httpbaic 方式登录过滤器

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

当不经过时会把异常抛给在这个过滤器的前面的 ExceptionTranslationFilter 过滤器。

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

3、自定义认证逻辑

实际开发中是不可能使用上方 Spring Security 默认的这种方式的，如何去覆盖掉 Spring Security 默认的配置呢？

咱们以：将默认的 form 认证方式改成 httpbasic 方式为例。

建立SpringSecurity自定义配置类：WebSecurityConfig.java

@Slf4j
@Configuration
@EnableGlobalMethodSecurity(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()
            .authorizeRequests()
            任何请求
            .anyRequest()
            须要身份认证
            .authenticated()
            .and()
            关闭跨站请求防御
            .csrf().disable()
            先后端分离采用JWT 不须要session
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
    }
}

从新启动项目，已经看到修改后的 httpbasic 方式认证了。

在这里咱们依然采用的默认提供的用户名 user，以及每次服务器启动自动生成的 password，那么可不能够自定义认证逻辑呢？好比采用数据库中的用户登录？

答案是确定的。

自定义用户认证逻辑须要了解三步：
  1. 处理用户信息获取逻辑
  2. 处理用户校验逻辑
  3. 处理密码加密解密

接下来咱们来看一下这三步，而后实现自定义登录：

3.1 处理用户信息获取逻辑

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

新建 UserDetailsServiceImpl.java

@Slf4j
@Component
public class UserDetailsServiceImpl implements UserDetailsService{

    @Autowired
    private UserService userService;

    /**
     * 从数据库中获取用户信息，返回一个 UserDetails 对象，
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        经过用户名获取用户
        User user = userService.findByUsername(username);
        将 user 对象转化为 UserDetails 对象
        return new SecurityUserDetails(user);
    }
}

SecurityUserDetail.java

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());
            this.setStatus(user.getStatus());
        }
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        理想型返回 admin 权限，可自已处理这块
        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;
    }
}

至此，处理用户信息获取逻辑 部分完成了，主要实现 UserDetailsService 接口的 loadUserByname 方法。

为什么会用到 SecurityUserDetail 类进行转换一下？

其实彻底能够直接返回一个 User 对象，可是须要注意的是，若是直接返回 User 对象的话，返回的是 security 包下的 user。

至于为什么这样处理，若是返回的是 security 包下的 user，这样就失去了使用本地数据库的意义，下方自定义登录逻辑详细说明。

再来登录试一下：

其中 niceyoo、 为数据库用户信息，以下图为成功跳转：

3.2 处理用户校验逻辑

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

  1. 密码是否匹配【由Sprin Security处理，只须要告诉其密码便可】
  2. 密码是否过时、或者帐户是否被冻结等

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

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

public interface UserDetails extends Serializable {

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

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

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

    boolean isAccountNonExpired();当前帐户是否过时；

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

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

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

主要看后四个方法：

一、isAccountNonExpired() 帐户没有过时 返回true 表示没有过时
二、isAccountNonLocked() 帐户没有锁定
三、isCredentialsNonExpired() 密码是否过时
四、isEnabled() 是否被删除

如上四个方法，皆可根据实际状况作响应处理。

3.3 处理密码加密解密

再回到 WebSecurityConfig 自定义配置类。加入：

@Autowired
private UserDetailsServiceImpl userDetailsService;

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

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

补充：UserDetailsServiceImpl 为自定义的 UserDetailsService 实现类。

4、个性化认证流程

一样的在实际的开发中，对于用户的登陆认证，不可能使用 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);
}

在添加 AuthenticationSuccessHandler、AuthenticationFailHandler 后会帮咱们自动导包，可是，既然是个性化认证流程，天然要咱们本身去实现~

那咱们究竟要实现什么效果呢？

自定义登录成功处理：

自定义登录失败处理：

为什么要采用这种返回新式？

用户登陆成功后，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 {

        String username = ((UserDetails)authentication.getPrincipal()).getUsername();
        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 r是 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:

@Slf4j
public class ResponseUtil {

    /**
     *  使用response输出JSON
     * @param response
     * @param 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();
                }
            }
        }
    }
}

其中用到 gson 依赖：

<!-- Gson -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.5</version>
</dependency>

最后

下一篇将集成 jwt 实现用户身份认证。

SpringSecurity 整合 JWT

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程