Spring Security 使用总结

Spring Security介绍 文章主要分三部分 1、Spring Security的架构及核心组件:(1)认证;(2)权限拦截;(3)数据库管理;(4)权限缓存;(5)自定义决策; 2、环境搭建与使用,使用当前热门的Spring Boot来搭建环境,结合项目中实际的例子来做几个Case; 3、Spring Security的优缺点总结,结合第二部分中几个Case的实现来总结Spring Security的优点和缺点。 1、Spring Security介绍 ​ 整体介绍,Spring Security为基于J2EE开发的企业应用软件 阅读详情

暑假的时候在学习了 Spring Security 并成功运用到了项目中。 在实践中摸索出了一套结合 json + jwt(json web token) + Spring Boot + Spring Security 技术的权限方案趁着国庆假期记录一下。

以下所有步骤的源码可以从我的 github 上取得。如果要了解,请阅读 readme.md。

各个技术的简要介绍

json : 与前端交互的数据交换格式

个人理解上,它的特点是可以促进 web 前后端解耦,提升团队的工作效率。 同时也是跟安卓端和 iOS 端交互的工具,目前是没想出除了 json 和 XML 之外的交流形式诶(或许等以后有空闲时间会看看)。

它的另一个特点是轻量级,简洁和清晰的层次可以方便我们阅读和编写,并且减少服务器带宽占用。

jwt (json web token)

用人话讲就是将用户的身份信息(账号名字)、其他信息(不固定,根据需要增加)在用户登陆时提取出来,并且通过加密手段加工成一串密文,在用户登陆成功时带在返回结果发送给用户。以后用户每次请求时均带上这串密文,服务器根据解析这段密文判断用户是否有权限访问相关资源,并返回相应结果。

从网上摘录了一些优点,关于 jwt 的更多资料感兴趣的读者可以自行谷歌:

  1. 相比于session,它无需保存在服务器,不占用服务器内存开销。
  2. 无状态、可拓展性强:比如有3台机器(A、B、C)组成服务器集群,若session存在机器A上,session只能保存在其中一台服务器,此时你便不能访问机器B、C,因为B、C上没有存放该Session,而使用token就能够验证用户请求合法性,并且我再加几台机器也没事,所以可拓展性好就是这个意思。
  3. 由 2 知,这样做可就支持了跨域访问。

Spring Boot

Spring Boot 是一个用来简化 Spring 应用的搭建以及开发过程的框架。用完后会让你大呼 : "wocao! 怎么有这么方便的东西! mama 再也不用担心我不会配置 xml 配置文件了!"。

Spring Security

这是 Spring Security 提供的一个安全权限控制框架,可以根据使用者的需要定制相关的角色身份和身份所具有的权限,完成黑名单操作、拦截无权限的操作。配合 Spring Boot 可以快速开发出一套完善的权限系统。

本次技术方案中 Spring Security 执行流程

本次技术方案中 Spring Security 执行流程
本次技术方案中 Spring Security 执行流程

从图中可以看出本次执行流程围绕着的就是 token。

用户通过登陆操作获得我们返回的 token 并保存在本地。在以后每次请求都在请求头中带上 token ,服务器在收到客户端传来的请求时会判断是否有 token ,若有,解析 token 并写入权限到本次会话,若无直接跳过解析 token 的步骤,然后判断本次访问的接口是否需要认证,是否需要相应的权限,并根据本次会话中的认证情况做出反应。

动手实现这个安全框架

步骤一 : 建立项目,配置好数据源

  1. 使用 Itellij Idea 建立一个 Spring Boot 项目
需要的组件
需要的组件

选择 Web 、Security 、 Mybatis 和 JDBC 四个组件。

  1. 在数据库中建立所需的数据库 spring_security
建立数据库
建立数据库
  1. 在 spring boot 配置文件 application.properties 中配置好数据源
配置数据源
配置数据源
  1. 启动项目查看 Spring Boot 是否替我们配置好 Spring Security 了。
启动项目
启动项目

若是正确启动了,可以看到 Spring Security 生成了一段默认密码。

我们访问 localhost:8080 会弹出一个 basic 认证框

输入 用户名 user 密码 前面自动生成的密码 便可得到通过的返回消息(返回 404,因为我们还未建立任何页面)
输入 错误的用户名或者密码会返回 401 ,提示未认证

如果你走到了这一步,意味着你已经配置好了所需要的环境,接下来就跟着进入下一步吧!

步骤二 : 生成我们的 jwt

在这一步我们将学习如何根据我们的需要生成我们定制的 token !

  1. 关闭 Spring Boot 替我们配置好的 Spring Security。(因为默认配置好的 Spring Security 会拦截掉我们定制的登陆接口)

创建 Spring Security 配置类 WebSecurityConfig.java

@Configuration      // 声明为配置类
@EnableWebSecurity      // 启用 Spring Security web 安全的功能
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .anyRequest().permitAll()       // 允许所有请求通过
                .and()
                .csrf()
                .disable()                      // 禁用 Spring Security 自带的跨域处理
                .sessionManagement()                        // 定制我们自己的 session 策略
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS); // 调整为让 Spring Security 不创建和使用 session
    }
}复制代码
  1. 在数据库中建立相应的用户和角色。

创建用户表 user

user 表
user 表

其中各个属性和作用如下:

  • username : 用户名
  • password : 密码
  • role_id : 用户所属角色编号
  • last_password_change : 最后一次密码修改时间
  • enable : 是否启用该账号,可以用来做黑名单

创建角色表 role

role 表
role 表

其中各个属性作用如下:

  • role_id : 角色相应 id
  • role_name : 角色的名称
  • auth : 角色所拥有的权限
  1. 编写相应的登陆密码判断逻辑

因为登陆功能很容易实现,这里就不写出来占地方了哎。

  1. 编写 token 操作类(生成 token 部分)

因为网上有造好的轮子,我们可以直接拿来做些修改就可以使用了。

使用 maven 导入网上造好的 jwt 轮子

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.4</version>
</dependency>复制代码

建立我们自己的 token 操作类 TokenUtils.java

public class TokenUtils {

    private final Logger logger = Logger.getLogger(this.getClass());

    @Value("${token.secret}")
    private String secret;

    @Value("${token.expiration}")
    private Long expiration;

    /**
     * 根据 TokenDetail 生成 Token
     *
     * @param tokenDetail
     * @return
     */
    public String generateToken(TokenDetail tokenDetail) {
        Map<String, Object> claims = new HashMap<String, Object>();
        claims.put("sub", tokenDetail.getUsername());
        claims.put("created", this.generateCurrentDate());
        return this.generateToken(claims);
    }

    /**
     * 根据 claims 生成 Token
     *
     * @param claims
     * @return
     */
    private String generateToken(Map<String, Object> claims) {
        try {
            return Jwts.builder()
                    .setClaims(claims)
                    .setExpiration(this.generateExpirationDate())
                    .signWith(SignatureAlgorithm.HS512, this.secret.getBytes("UTF-8"))
                    .compact();
        } catch (UnsupportedEncodingException ex) {
            //didn't want to have this method throw the exception, would rather log it and sign the token like it was before
            logger.warn(ex.getMessage());
            return Jwts.builder()
                    .setClaims(claims)
                    .setExpiration(this.generateExpirationDate())
                    .signWith(SignatureAlgorithm.HS512, this.secret)
                    .compact();
        }
    }

    /**
     * token 过期时间
     *
     * @return
     */
    private Date generateExpirationDate() {
        return new Date(System.currentTimeMillis() + this.expiration * 1000);
    }

    /**
     * 获得当前时间
     *
     * @return
     */
    private Date generateCurrentDate() {
        return new Date(System.currentTimeMillis());
    }

}复制代码

这个工具类的目前做的事情是 :

  • 把用户名封装进下载的轮子的 token 的主体 claims 中,并在里面封装了当前时间(方便后面判断 token 是否在修改密码之前生成的)
  • 再计算 token 过期的时间写入到 轮子的 token 中
  • 对 轮子的 token 进行撒盐加密,生成一串字符串,即我们定制的 token

生成定制 token 的方法的入参 TokenDetail 的定义如下

public interface TokenDetail {

    //TODO: 这里封装了一层,不直接使用 username 做参数的原因是可以方便未来增加其他要封装到 token 中的信息

    String getUsername();
}

public class TokenDetailImpl implements TokenDetail {

    private final String username;

    public TokenDetailImpl(String username) {
        this.username = username;
    }

    @Override
    public String getUsername() {
        return this.username;
    }
}复制代码

同时这个工具类把加密 token 撒盐的字符串和 token 的过期时间提取到了 application.properties 中

# token 加密密钥
token.secret=secret
# token 过期时间,以秒为单位,604800 是 一星期
token.expiration=604800复制代码
  1. 至此,我们生成 token 的教程已经完成,至于登陆接口,判断账号密码是否正确的操作就留给读者去实现,读者只需在登陆成功时在结果中返回生成好的 token 给用户即可。

步骤三 : 实现验证 token 是否有效,并根据 token 获得账号详细信息(权限,是否处于封号状态)的功能

  1. 分析实现的过程

在步骤二中,我们把用户的的 username 、 token 创建的时间 、 token 过期的时间封装到了加密过后的 token 字符串中,就是为了服务此时我们验证用户权限的目的。

假设我们此时拿到了用户传递过来的一串 token,并且要根据这串 token 获得用户的详情可以这样做:

A. 尝试解析这串 token ,若成功解析出来,进入下一步,否则终止解析过程
B. 根据解析出来的 username 从数据库中查找用户的账号,最后一次密码修改的时间,权限,是否封号等用户详情信息,把这些信息封装到一个实体类中(userDetail类)。若查找不到该用户,终止解析进程
C. 检查 userDetail 中记录的封号状态,若是账号已被封号,返回封号结果,终止请求
D. 根据 userDtail 比较 token 是否处于有效期内,若不处于有效期内,终止解析过程,否则继续
E. 将 userDetail 中记录的用户权限写入本次请求会话中,解析完成。

可参考下图理解:

分析解析 token ,检查权限的过程
分析解析 token ,检查权限的过程

下面开始动手实现

  1. 尝试解析 token 获得 username
/**
     * 从 token 中拿到 username
     *
     * @param token
     * @return
     */
    public String getUsernameFromToken(String token) {
        String username;
        try {
            final Claims claims = this.getClaimsFromToken(token);
            username = claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }

    /**
     * 解析 token 的主体 Claims
     *
     * @param token
     * @return
     */
    private Claims getClaimsFromToken(String token) {
        Claims claims;
        try {
            claims = Jwts.parser()
                    .setSigningKey(this.secret.getBytes("UTF-8"))
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            claims = null;
        }
        return claims;
    }复制代码

在这段代码中,我们先对 token 进行解密,获得 token 中封装好的主体部分 claims (前面第二部引入的 别人造好的轮子),然后尝试获得里面封装的 username 字符串。

  1. 从数据库中获得用户详情 userDetail

这里我们将实现 Spring Security 的一个 UserDetailService 接口,这个接口只有一个方法, loadUserByUsername。流程图如下

获得 UserDetail 的流程图
获得 UserDetail 的流程图

代码如下:

public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;

    /**
     * 获取 userDetail
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        User user = this.userMapper.getUserFromDatabase(username);

        if (user == null) {
            throw new UsernameNotFoundException(String.format("No user found with username '%s'.", username));
        } else {
            return SecurityModelFactory.create(user);
        }
    }
}

public class User implements LoginDetail, TokenDetail {

    private String username;
    private String password;
    private String authorities;
    private Long lastPasswordChange;
    private char enable;

    // 省略构造器和 getter setter 方法
}

public class SecurityModelFactory {

    public static UserDetailImpl create(User user) {
        Collection<? extends GrantedAuthority> authorities;
        try {
            authorities = AuthorityUtils.commaSeparatedStringToAuthorityList(user.getAuthorities());
        } catch (Exception e) {
            authorities = null;
        }

        Date lastPasswordReset = new Date();
        lastPasswordReset.setTime(user.getLastPasswordChange());
        return new UserDetailImpl(
                user.getUsername(),
                user.getUsername(),
                user.getPassword(),
                lastPasswordReset,
                authorities,
                user.enable()
        );
    }

}复制代码

其中获得未处理过的用户详细信息 User 类的 mapper 类定义如下:

public interface UserMapper {


    User getUserFromDatabase(@Param("username") String username);

}复制代码

相应的 xml 文件为 :

<select id="getUserFromDatabase"  resultMap="getUserFromDatabaseMap">
        SELECT
        `user`.username,
        `user`.`password`,
        `user`.role_id,
        `user`.enable,
        `user`.last_password_change,
        `user`.enable,
        role.auth
        FROM
        `user` ,
        role
        WHERE
        `user`.role_id = role.role_id AND
        `user`.username = #{username}
    </select>

    <resultMap id="getUserFromDatabaseMap" type="cn.ssd.wean2016.springsecurity.model.domain.User">
        <id column="username" property="username"/>
        <result column="password" property="password"/>
        <result column="last_password_change" property="lastPasswordChange"/>
        <result column="auth" property="authorities"/>
        <result column="enable" property="enable"/>
    </resultMap>复制代码

至此,我们已经完成获取用户详细信息的的功能了。接下来只要限制接口的访问权限,并要求用户访问接口时带上 token 即可实现对权限的控制。

步骤四 : 定义解析 token 的拦截器

老规矩,上流程图:

解析 token 的拦截器的执行流程
解析 token 的拦截器的执行流程

下面定义这个拦截器

publicclass AuthenticationTokenFilter extends UsernamePasswordAuthenticationFilter {

    /**
     * json web token 在请求头的名字
     */
    @Value("${token.header}")
    private String tokenHeader;

    /**
     * 辅助操作 token 的工具类
     */
    @Autowired
    private TokenUtils tokenUtils;

    /**
     * Spring Security 的核心操作服务类
     * 在当前类中将使用 UserDetailsService 来获取 userDetails 对象
     */
    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 将 ServletRequest 转换为 HttpServletRequest 才能拿到请求头中的 token
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        // 尝试获取请求头的 token
        String authToken = httpRequest.getHeader(this.tokenHeader);
        // 尝试拿 token 中的 username
        // 若是没有 token 或者拿 username 时出现异常,那么 username 为 null
        String username = this.tokenUtils.getUsernameFromToken(authToken);

        // 如果上面解析 token 成功并且拿到了 username 并且本次会话的权限还未被写入
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            // 用 UserDetailsService 从数据库中拿到用户的 UserDetails 类
            // UserDetails 类是 Spring Security 用于保存用户权限的实体类
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
            // 检查用户带来的 token 是否有效
            // 包括 token 和 userDetails 中用户名是否一样, token 是否过期, token 生成时间是否在最后一次密码修改时间之前
            // 若是检查通过
            if (this.tokenUtils.validateToken(authToken, userDetails)) {
                // 生成通过认证
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(httpRequest));
                // 将权限写入本次会话
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
            if (!userDetails.isEnabled()){
                response.setCharacterEncoding("UTF-8");
                response.setContentType("application/json;charset=UTF-8");
                response.getWriter().print("{\"code\":\"452\",\"data\":\"\",\"message\":\"账号处于黑名单\"}");
                return;
            }
        }
        chain.doFilter(request, response);
    }

}复制代码

其中检查 token 是否有效的 tokenUtils.validateToken(authToken, userDetails) 方法定义如下:

/**
     * 检查 token 是否处于有效期内
     * @param token
     * @param userDetails
     * @return
     */
    public Boolean validateToken(String token, UserDetails userDetails) {
        UserDetailImpl user = (UserDetailImpl) userDetails;
        final String username = this.getUsernameFromToken(token);
        final Date created = this.getCreatedDateFromToken(token);
        return (username.equals(user.getUsername()) && !(this.isTokenExpired(token)) && !(this.isCreatedBeforeLastPasswordReset(created, user.getLastPasswordReset())));
    }

    /**
     * 获得我们封装在 token 中的 token 创建时间
     * @param token
     * @return
     */
    public Date getCreatedDateFromToken(String token) {
        Date created;
        try {
            final Claims claims = this.getClaimsFromToken(token);
            created = new Date((Long) claims.get("created"));
        } catch (Exception e) {
            created = null;
        }
        return created;
    }

    /**
     * 获得我们封装在 token 中的 token 过期时间
     * @param token
     * @return
     */
    public Date getExpirationDateFromToken(String token) {
        Date expiration;
        try {
            final Claims claims = this.getClaimsFromToken(token);
            expiration = claims.getExpiration();
        } catch (Exception e) {
            expiration = null;
        }
        return expiration;
    }

    /**
     * 检查当前时间是否在封装在 token 中的过期时间之后,若是,则判定为 token 过期
     * @param token
     * @return
     */
    private Boolean isTokenExpired(String token) {
        final Date expiration = this.getExpirationDateFromToken(token);
        return expiration.before(this.generateCurrentDate());
    }

    /**
     * 检查 token 是否是在最后一次修改密码之前创建的(账号修改密码之后之前生成的 token 即使没过期也判断为无效)
     * @param created
     * @param lastPasswordReset
     * @return
     */
    private Boolean isCreatedBeforeLastPasswordReset(Date created, Date lastPasswordReset) {
        return (lastPasswordReset != null && created.before(lastPasswordReset));
    }复制代码

步骤五 : 注册步骤四的拦截器,使它在 Spring Security 读取本次会话权限前将用户所具有的权限写入本次会话中

在 SpringSecurity 的配置类 WebSecurityConfig.java 中添加如下配置

publicclass WebSecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 注册 token 转换拦截器为 bean
     * 如果客户端传来了 token ,那么通过拦截器解析 token 赋予用户权限
     *
     * @return
     * @throws Exception
     */
    @Bean
    public AuthenticationTokenFilter authenticationTokenFilterBean() throws Exception {
        AuthenticationTokenFilter authenticationTokenFilter = new AuthenticationTokenFilter();
        authenticationTokenFilter.setAuthenticationManager(authenticationManagerBean());
        return authenticationTokenFilter;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .antMatchers("/auth").authenticated()       // 需携带有效 token
                .antMatchers("/admin").hasAuthority("admin")   // 需拥有 admin 这个权限
                .antMatchers("/ADMIN").hasRole("ADMIN")     // 需拥有 ADMIN 这个身份
                .anyRequest().permitAll()       // 允许所有请求通过
                .and()
                .csrf()
                .disable()                      // 禁用 Spring Security 自带的跨域处理
                .sessionManagement()                        // 定制我们自己的 session 策略
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS); // 调整为让 Spring Security 不创建和使用 session


        /**
         * 本次 json web token 权限控制的核心配置部分
         * 在 Spring Security 开始判断本次会话是否有权限时的前一瞬间
         * 通过添加过滤器将 token 解析,将用户所有的权限写入本次 Spring Security 的会话
         */
        http
                .addFilterBefore(authenticationTokenFilterBean(), UsernamePasswordAuthenticationFilter.class);
    }
}复制代码

其中我们将步骤四中定义的拦截器注册到 Spring 中成为一个 bean ,并登记在 Spring Security 开始判断本次会话是否有权限时的前一瞬间通过添加过滤器将 token 解析,将用户所有的权限写入本次会话。

其次,我们添加了三个 ant 风格的地址拦截规则 :

  • /auth : 要求携带有效的 token
  • /admin : 要求携带 token 所对应的账号具有 admin 这个权限
  • /ADMIN : 要求携带 token 对应的张账号具有 ROLE_ADMIN 这个身份

启动程序到 8080 端口,通过 /login 接口登陆 guest 账号,对 /auth 接口尝试访问,结果如下 :

对 auth 的访问结果
对 auth 的访问结果

显然,因为 token 有效,所以成功通过了拦截

接下来尝试访问 /admin 接口,结果如下 :

对 admin 的访问结果
对 admin 的访问结果

显然,因为携带的 token 不具有 admin 这个权限,所以请求被拦截拦截

至此,我们已经完成了一套权限简单的权限规则系统,在下一步中,我们将对无权限访问的返回结果进行优化,并结束这次总结。

步骤六 : 完善 401 和 403 返回结果

定义 401 处理器,实现 AuthenticationEntryPoint 接口

public class EntryPointUnauthorizedHandler implements AuthenticationEntryPoint {

  /**
   * 未登录或无权限时触发的操作
   * 返回  {"code":401,"message":"小弟弟,你没有携带 token 或者 token 无效!","data":""}
   * @param httpServletRequest
   * @param httpServletResponse
   * @param e
   * @throws IOException
   * @throws ServletException
   */
  @Override
  public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
      //返回json形式的错误信息
      httpServletResponse.setCharacterEncoding("UTF-8");
      httpServletResponse.setContentType("application/json");

      httpServletResponse.getWriter().println("{\"code\":401,\"message\":\"小弟弟,你没有携带 token 或者 token 无效!\",\"data\":\"\"}");
      httpServletResponse.getWriter().flush();
  }

}复制代码

定义 403 处理器,实现 AccessDeniedHandler 接口

@Component
public class MyAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
        //返回json形式的错误信息
        httpServletResponse.setCharacterEncoding("UTF-8");
        httpServletResponse.setContentType("application/json");

        httpServletResponse.getWriter().println("{\"code\":403,\"message\":\"小弟弟,你没有权限访问呀!\",\"data\":\"\"}");
        httpServletResponse.getWriter().flush();
    }
}复制代码

将这两个处理器配置到 SpringSecurity 的配置类中 :

publicclass WebSecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 注册 401 处理器
     */
    @Autowired
    private EntryPointUnauthorizedHandler unauthorizedHandler;

    /**
     * 注册 403 处理器
     */
    @Autowired
    private MyAccessDeniedHandler accessDeniedHandler;

    ...

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

                // 配置被拦截时的处理
                .exceptionHandling()
                .authenticationEntryPoint(this.unauthorizedHandler)   // 添加 token 无效或者没有携带 token 时的处理
                .accessDeniedHandler(this.accessDeniedHandler)      //添加无权限时的处理

                ...
    }
}复制代码

尝试以 guest 的身份访问 /admin 接口,结果如下:

以 guest 身份访问 admin 接口
以 guest 身份访问 admin 接口

嘻嘻,显然任务完成啦!!!(这个接口也可以用 lamda 表达式配置,这个留给大家去探索啦~~~)

溜了溜了……

来源:https://juejin.cn/post/6844903502003568647
Spring Security 这个类中没有多余的逻辑,都是HttpSecurity内部配置类中重写的方法执行,HttypSecurit的内部配置类就是我们通过HttpSecurity点出来的属性配置,比如:CsrfConfigurer,构建的时候,传入的就是上层配置类的HttpSecurity。,保存了各个SecurtiyConfigure初始化构建的HttpSecurity,httpSecurity经过build后返回的DefaultSecurityFilterChain对象,这个对象中包含的匹配路径,对应的过滤器集合。 阅读详情

相关推荐

spring security详解

1.概要 Spring是非常流行和成功的Java应用开发框架,SpringSecurity正是Spring家族中的成员。SpringSecurity基于Spring框架,提供了一套Web应用安全性的完整解决方案。正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”(或者访问控制),一般来说,Web应用的安全性包括用户认证(Authentication)和用户授权(Authorization)两个部分,这两点也是SpringSecurity重要核心功能。 (1)用户认证指的是:验证某个用户是否为系统

wumingdu1234的博客 7764

如何使用Spring Security控制会话

并发会话控制功能用于维护活动会话列表以及关联的经过身份验证的用户的信息。我们在本文前面配置了 Spring 安全性使用此事件发布来发布会话生命周期中的事件,并且相应地更新了 SessionRegistry。每次登录的客户尝试访问应用程序的安全部分时,都会检查用户的活动会话。以下是安全性中可用的选项,可以帮助我们配置和控制会话创建。会话超时后,如果他们提交具有无效会话 ID 的请求,我们可以将使用重定向到特定页面。在本文中,我们讨论了 Spring 安全会话管理以及如何使用 Spring 安全性控制会话。

allway2的博客 4459

Spring Security 登陆成功后的处理

       Spring Security 完成登陆后一般需要一些自定义的处理,例如,记录登陆日志,初始化用户菜单等等 这里就需要自定义的 登陆成功处理了,Spring  提供了 AuthenticationSuccessHandler 接口,完成这个接口就可以了。 但是,修改到这里处理后,原先系统的自动转向处理就没有了,接口中应该怎么写,才可以保持原来的功能呢?   代码如下:   ...

guanry的博客 5909

舞台直拍全流程详解:从弱光拍摄到后期发布运营

线下演出的现场记录正在成为内容创作的重要类型,而舞台直拍就是其中最具传播价值的形式之一。从Livehouse到小型偶像现场,舞台直拍不仅是粉丝的收藏品,更是衡量演出传播效果的关键媒介。要产出一条高质量的直拍,需要理解弱光环境下的相机参数设置、机位选择、声音采集,以及后期剪辑与调色的完整链路。同时,标题结构、封面设计和数据复盘也决定了一条视频能否被更多观众看到。本文以一条典型直拍标题为样本,拆解拍摄前准备、现场录制、素材整理、剪辑调色、发布传播与长期项目化维护的方法,帮助创作者从零开始建立一套可复制的舞台直拍

weixin_34133829的博客 453

Spring Security配置详细

Spring Security 是一个功能强大且高度可定制的身份验证和访问控制框架,专为基于Spring的应用程序设计。本教程将指导你如何在一个简单的Spring Boot应用程序中集成Spring Security,以实现基本的用户认证和授权功能。

2401_83447580的博客 2537

Spring Boot中集成Spring Security 专题

当然,Spring Security明确的设计可以处理这种常见需求,但是作为替代你应该使用项目的域对象的安全能力来实现这个目标。例如在默认的安全配置中authorizeRequests(),formLogin()、httpBasic()这三个方法返回的分别是ExpressionUrlAuthorizationConfigurer、FormLoginConfigurer、HttpBasicConfigurer,他们都是SecurityConfigurer接口的实现类,分别代表的是不同类型的安全配置器。

2401_86940371的博客 2230

SessionCreationPolicy 枚举常量

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_33877092的博客 4273

Spring Security使用

上面登录认证流程实现了用户会话访问接口,但是SessionId存储在cookie中,这样会导致csrf攻击,所以前端还需要把SessionId存储到其他位置,比如localStorage,在请求时,把它放到Header中,避免csrf攻击,或者直接生成一个新的csrf token,在每次请求时把它放到header或parameter中,在后端服务进行验证。一般来说,filterChain是我们需要重写的,我们的应用是无法直接使用默认filter的配置。数据库查询到的用户对应的密码。请求中的用户名/密码。

CASER_HDMI的博客 1156

Spring Security(一)初涉Security

Spring Security 中文文档:https://www.docs4dev.com/docs/zh/spring-security/5.1.2.RELEASE/reference 官方文档:https://spring.io/projects/spring-security 一、Spring Security 介绍 Spring Security 应该属于 Spring 全家桶中学习曲线比较陡峭的几个模块之一,下面我将从起源和定义这两个方面来简单介绍一下它。 起源:Spring Securi.

lqycwy的博客 365

【Spring Security系列】Spring Security 简介

Spring Security简介 官网:https://spring.io/projects/spring-security 中文文档:https://www.springcloud.cc/spring-security.html Spring Security 的前身是 Acegi Security,在被收纳为Spring子项目后正式更名为Spring Security。 在笔者成书时,Spring Security已经升级到5.1.3.RELEASE版...

qq_28248897的博客 1845

Spring Security 4 原理详解

场景: 用户通过提交username和password请求登陆 服务器验证身份信息是否正确 获取用户信息(包括角色集合) 利用3中的信息构建Security Context 在此之后,该用户的所有请求,Spring Security的访问控制机制将根据Security Context中的信息判断用户是否具有权限 以上,前3点即为认证,构建Security Context,为之后5的授权(访

lbqssss的博客 8455

SpringSecurity Session管理

目录Session管理Session超时设置Session并发控制 Session管理 Session超时设置 Session超时时间也就是用户登录的有效时间。要设置Session超时时间很简单,只需要在配置文件中添加: server: servlet: session: timeout: 60 #1分钟 Session的最小有效期为60秒,也就是说即使你设置为小于60秒的值,其有效期还是为60秒 在Spring Security中配置Session管理器,并配置Session失效

Curtisjia的博客 482

Spring Security学习——基于Java注解的Spring Security配置

基于Java注解的Spring Security配置           Spring在早期版本的时候,全是基于xml配置文件,导致配置极其繁杂。后期的版本中,Spring提供了对基于Java注解的支持。Java注解的Spring使每个Bean类有了自配置的特性,通过在每个类中添加相应的Java注解,就可以标注这些类在系统中的功能,可以大大减少配置文件的管理。当然,Java注解的Spring也

Benson的博客 1410

Spring Security 详解

​ Spring Security 是 Spring家族中的一个安全管理框架。相比与另外一个安全框架Shiro,它提供了更丰富的功能,社区资源也比Shiro丰富。一般来说中大型的项目都是使用SpringSecurity来做安全框架。小项目有Shiro的比较多,因为相比与SpringSecurity,Shiro的上手更加的简单。​ 一般Web应用的需要进行认证和授权。​ 而认证和授权也是SpringSecurity作为安全框架的核心功能。视频地址:​ 我们先要搭建一个简单的SpringBoot工程① 设置父工

qq_22075913的博客 12万+

家庭路由器从入门到精通:连接设置、优化排障全指南

路由器作为家庭网络的核心枢纽,其工作原理基于NAT(网络地址转换)和DHCP(动态主机配置协议)两大关键技术。NAT负责将公网IP转换为多个内网IP,实现多设备共享上网;DHCP则自动为接入设备分配IP地址,简化网络配置。这些技术共同构建了稳定、安全的局域网环境,其价值在于为智能家居、在线办公、高清影音和游戏娱乐等场景提供可靠的网络基础。理解路由器的物理连接、后台设置与故障排查逻辑,是优化Wi-Fi信号覆盖、提升网络性能、保障家庭网络安全的关键。本文以路由器配置与排障为核心,详细解析从WAN/LAN口区分、

weixin_33393017的博客 406

Linux单独编译设备树,开发者分享 | Petalinux 工程中设备树的介绍

本文来自XILINX嵌入式产品应用工程师 Terry Ni设备树是 Petalinux kernel 的关键组件,接下来以 2020.1 版本为例,为大家介绍一下在Xilinx Petalinux 工程中的设备树是如何产生,配置以及修改的。Petalinux 工程中设备树的位置当我们创建了一个 petalinux 工程后(以zcu102为例),在编译的时候,会自动生成对应的设备树文件。这些设备树的...

weixin_28877107的博客 2619

Spring Security团队正式宣布Spring Security OAuth终止维护

Spring Security团队正式宣布Spring Security OAuth终止维护。spring 官宣终止维护spring security oauth目前官网的主页已经高亮提醒大家彻底停止维护。官网已经通知EOL旧的Spring Security OAuth项目终止到2.5.2.RELEASE版本,该项目将不会再进行任何的迭代,包括Bug修复,之前胖哥已经提醒该项目即将停止维护,有心的同学已经进行了迁移。2020年就已经宣布了EOL时间表项目文档和代码仓库被移除目前该项目的官方文档已经正式从sp

资料免费分享,点击名片 1594

手把手教你用Verilog实现AT24C64的I2C读写(附完整仿真流程)

本文详细介绍了如何使用Verilog HDL设计AT24C64 EEPROM的I2C控制器,并配合ModelSim完成完整的仿真验证流程。内容涵盖I2C协议解析、Verilog状态机设计、AT24C64读写操作实现,以及仿真波形分析和调试技巧,为FPGA开发者提供了一套完整的EEPROM控制解决方案。

3c4x5z6v7b的博客 847

Spring Security的基本使用

本文详细介绍了Spring Security在基于JWT(JSON Web Token)的认证和授权中的基本使用方法,结合Mybatis、Redis等技术实现了一个完整的用户认证和授权流程。通过自定义用户详情类、全局异常处理、JWT工具类以及安全配置类,实现了用户登录、登出、权限校验等功能,并提供了跨域问题的解决方案

2302_79603114的博客 1883

RISC-V IP中的ITCM/DTCM与Slave-AHB接口设计解析

本文深入解析RISC-V IP中ITCM/DTCM与Slave-AHB接口的设计要点,涵盖TCM架构原理、总线协议实现及性能优化策略。通过实际案例展示如何实现单周期访问延迟,解决跨时钟域同步等关键问题,为嵌入式系统提供确定性内存访问方案。特别探讨了AHB总线仲裁机制和RTL实现技巧,助力开发者构建高效可靠的RISC-V处理器子系统。

weixin_28419039的博客 531

IIS - 会话cookie中缺少HttpOnly属性

不啰嗦,我们直接开始! 先进行常规设置 打开配置编辑器 选中图中节点,将httpOnlyCookies设置为true 然后。。。不起作用。。。 换种方式 通过配置出站规则getcookie添加HttpOnly 在Web.config中添加如下出站规则 <rewrite> <outboundRules> <rule name="Add HttpOnly"> <match serverVa.

。 21万+

Spring Security快速入门

目录1 Spring Security介绍2 创建工程2.1 创建maven工程2.2 Spring容器配置2.3 Servlet Context配置2.4 加载 Spring容器3 认证3.1 认证页面3.2.安全配置3.2.Spring Security初始化2.3.默认根路径请求2.4.认证成功页面2.5 测试4 授权5 小结 1 Spring Security介绍 Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。由于它是Sprin

赵广陆 1万+

圆极化天线特性测试

3、将测试数据代入方向图计算程序,得到圆极化天线的H面的左旋圆极化分量的方向图和右旋圆极化分量的方向图,其中幅度较大的是主极化。1、固定好待测圆极化天线,打开方向图LABVIEW测试程序,设定测试起始频率,测量待测天线的S21的幅度P1。% title('左旋圆极化方向图','FontSize',15,'Color','b');% title('右旋圆极化方向图','FontSize',15,'Color','b');title('天线的轴比','FontSize',15,'Color','b');

Symean的博客 3364

Spring Security 基本使用

一、Spring Security是什么? Spring Security is a powerful and highly customizable authentication and access-control framework. It is the de-facto standard for securing Spring-based applications. Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架。它是用于保护基于Spring的应用程序的实际标准。

qq_36700462的博客 2809

YOLOv11改进策略【损失函数篇】| 引入Soft-NMS,提升密集遮挡场景检测精度,包括GIoU-NMS、DIoU-NMS、CIoU-NMS、SIoU-NMS、 EIou-NMS

传统的非极大值抑制(NMS)算法在目标检测中存在一个问题,即当一个物体的检测框与具有最高得分的检测框M有重叠(在预定义的重叠阈值内)时,会将该检测框的得分设置为零,从而导致该物体可能被遗漏,降低了平均精度。为了解决这个问题,作者提出了Soft-NMS算法。本文将YOLOv11默认的NMS修改成GIoU-NMSDIoU-NMSCIoU-NMSSIoU-NMSEIou-NMS。

Limiiiing的博客 4320

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

上一篇: 彻底弄清SpringSecurity登录原理及开发步骤
下一篇: SpringSecurity+JWT认证流程解析
码趣资源网
博客等级 码龄4年 269粉丝 518原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值