Springboot集成Security和JWT

Springboot版本2.3.3

pom依赖

 <!--security+JWT-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-security</artifactId>
 </dependency>
 <dependency>
     <groupId>io.jsonwebtoken</groupId>
     <artifactId>jjwt</artifactId>
     <version>0.9.1</version>
 </dependency>
 <dependency>
     <groupId>javax.xml.bind</groupId>
     <artifactId>jaxb-api</artifactId>
     <version>2.3.1</version>
 </dependency>

Security配置类

/**
 * Security配置类,启用URL过滤,设置PasswordEncoder密码加密类
 * EnableWebSecurity            开启Security
 * EnableGlobalMethodSecurity   保证post之前的注解可以使用
 */
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class Config_Security extends WebSecurityConfigurerAdapter {

    @Resource
    private IUmsMemberService memberService;
    @Resource
    private SecurityAccessDeniedHandler restfulAccessDeniedHandler;
    @Resource
    private SecurityAuthenticationEntryPoint restAuthenticationEntryPoint;


    /**
     * anyRequest          |   匹配所有请求路径
     * access              |   SpringEl表达式结果为true时可以访问
     * anonymous           |   匿名可以访问
     * denyAll             |   用户不能访问
     * fullyAuthenticated  |   用户完全认证可以访问(非remember-me下自动登录)
     * hasAnyAuthority     |   如果有参数,参数表示权限,则其中任何一个权限可以访问
     * hasAnyRole          |   如果有参数,参数表示角色,则其中任何一个角色可以访问
     * hasAuthority        |   如果有参数,参数表示权限,则其权限可以访问
     * hasIpAddress        |   如果有参数,参数表示IP地址,如果用户IP和参数匹配,则可以访问
     * hasRole             |   如果有参数,参数表示角色,则其角色可以访问
     * permitAll           |   用户可以任意访问
     * rememberMe          |   允许通过remember-me登录的用户访问
     * authenticated       |   用户登录后可访问
     */
    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity.csrf()                 //由于使用的是JWT,我们这里不需要csrf
                .disable()
                .sessionManagement()        //基于token,所以不需要session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                .antMatchers(HttpMethod.GET, //允许对于网站静态资源的无授权访问
                        "/",
                        "/*.html",
                        "/favicon.ico",
                        "/**/*.html",
                        "/**/*.css",
                        "/**/*.js",
                        "/swagger.**",
                        "/v3.**",
                        "**_notify_url"
                ).permitAll()
                .antMatchers("/LoginSecurity", "/Register").permitAll()         //对登录注册要允许匿名访问
                .antMatchers(HttpMethod.OPTIONS).permitAll()                    //跨域请求会先进行一次options请求
//                .antMatchers("/**").permitAll()                               //测试时全部运行访问
                .anyRequest()                                                   //除上面外的所有请求全部需要鉴权认证
                .authenticated();
        //禁用缓存
        httpSecurity.headers().cacheControl();
        //添加JWTFilter
        httpSecurity.addFilterBefore(jwtFilter(), UsernamePasswordAuthenticationFilter.class);
        //添加自定义未授权和未登录结果返回
        httpSecurity.exceptionHandling()
                .accessDeniedHandler(restfulAccessDeniedHandler)
                .authenticationEntryPoint(restAuthenticationEntryPoint);
    }


    /**
     * 重写身份认证接口configure
     * 其中userDetailsService为自定义用户认证逻辑接口
     * 其中bCryptPasswordEncoder()为加密接口
     * 使用authenticationManager.authenticate用户验证的时候,该方法会调用我们接口逻辑接口的实现类UserDetailsServiceImpl.loadUserByUsername
     * 就是下面的userDetailsService方法
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService()).passwordEncoder(passwordEncoder());
    }

    /**
     * 认证过程中SpringSecurity会调用这个方法访问数据库进行对用户的搜索,逻辑什么都可以自定义,无论是从数据库中还是从缓存中
     * 我们需要将我们查询出来的用户信息和权限信息组装成一个UserDetails返回。
     * UserDetails也是一个定义了数据形式的接口,用于保存我们从数据库中查出来的数据,其功能主要是验证账号状态和获取权限
     */
    @Bean
    public UserDetailsService userDetailsService() {
        return username -> {
            //获取登录用户信息
            UmsMember u = memberService.GetByNameMember(username);
            if (u == null) {
                throw new UsernameNotFoundException("用户名或密码错误");
            }
            return new SecurityUserDetails(username,u.getPassword(),null);
        };
    }

    /**
     * 自定义加密器Bean
     * 强散列哈希加密实现,在Controller新增用户的时候用此bean生成密码,与及修改密码的时候用到此bean比较新旧密码是否匹配
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    /**
     * JWT过滤器
     */
    @Bean
    public SecurityJwtFilter jwtFilter() {
        return new SecurityJwtFilter();
    }

    /**
     * 定义AuthenticationManager
     * 声明它的作用是用它帮我们进行认证操作,调用这个Bean的authenticate方法会由Spring Security自动帮我们做认证
     */
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

权限不足处理器

/**
 * 权限不足处理器
 */
@Component
public class SecurityAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException e) throws IOException, ServletException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        ResponseCon<?> responseCon = new ResponseCon<>(401, "没有权限", e.getMessage());
        response.getWriter().println(GsonUtil.getGson().toJson(responseCon));
        response.getWriter().flush();
    }
}

token认证失败处理器

/**
 * 认证失败处理器
 */
@Component
public class SecurityAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        ResponseCon<?> responseCon = new ResponseCon<>(401,"身份认证失败", authException.getMessage());
        response.getWriter().println(GsonUtil.getGson().toJson(responseCon));
        response.getWriter().flush();
    }
}

JWT过滤器


/** 
 * JwtFilter过滤器
 */

@Slf4j
public class SecurityJwtFilter extends OncePerRequestFilter {

    @Resource
    private UserDetailsService userDetailsService;
    @Resource
    private SecurityJwtUtil securityJwtUtil;

    private final String Authorization = "Authorization";
    private final String tokenHead = "Bearer";

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {

        //拿到Authorization请求头内的Header信息
        String authHeader = request.getHeader(Authorization);

        //判断一下内容是否为空且是否为(Bearer)开头
        if (authHeader != null && authHeader.startsWith(tokenHead)) {

            //去掉token前缀(Bearer),拿到真实token
            String authToken = authHeader.substring(tokenHead.length());

            //拿到token里面的username
            String username = securityJwtUtil.getUsername(authToken);

            //然后看看上下文中是否有我们以这个username为标识的主体,没有去new一个
            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                //缓存里查询用户,不存在需要重新登陆
                UserDetails userDetails = userDetailsService.loadUserByUsername(username);

                //拿到用户信息后验证用户信息与token
                if (securityJwtUtil.validateToken(authToken, userDetails)) {

                    //组装authentication对象,构造参数是Principal Credentials与Authorities
                    //后面的拦截器里面会用到grantedAuthorities 方法
                    UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());

                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

                    //将authentication信息放入到上下文对象中, 这样后面的过滤器看到我们上下文对象中有authentication对象,就相当于我们认证过了
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                    log.info("校验token-登录成功, user: {}", username);
                }
            }
        }
        chain.doFilter(request, response);
    }
}

JWT工具类


/**
 * jwtToken工具类
 */
@Slf4j
@Component
public class SecurityJwtUtil {

    //一天过期
    private static final long EXPIRE_TIME = 24 * 60 * 60 * 1000;

    //解密jwt-token的密钥
    private static final String secret = "mySecret";

    /**
     * 生成token
     */
    public static String sign(String username, String loginType) {
        return Jwts.builder()
                .claim("username", username)
                .claim("loginType", loginType)
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE_TIME))
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    /**
     * 根据token解密出用户名
     */
    public String getUsername(String token) {
        try {
            Claims claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
            return (String) claims.get("username");
        } catch (Exception e) {
            log.info("JWT格式验证失败:{}", token);
        }
        return null;
    }

    /**
     * 根据token解密出登录类型
     */
    public String getLoginType(String token) {
        try {
            Claims claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
            return (String) claims.get("loginType");
        } catch (Exception e) {
            log.info("JWT格式验证失败:{}", token);
        }
        return null;
    }
    /**
     * 根据token解密出过期时间
     */
    public Date getExpiredDate(String token) {
        try {
            Claims claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
            return claims.getExpiration();
        } catch (Exception e) {
            log.info("JWT格式验证失败:{}", token);
        }
        return null;
    }



    /**
     * 判断token是否已经过期
     */
    public boolean isTokenExpired(String token) {
        Date expiredDate = getExpiredDate(token);
        return expiredDate.before(new Date());
    }
    /**
     * 判断token是否可以被刷新
     */
    public boolean canRefresh(String token) {
        return !isTokenExpired(token);
    }
    /**
     * 验证token与数据库中token是否一致
     */
    public boolean validateToken(String token, UserDetails userDetails) {
        String username = getUsername(token);
        assert username != null;
        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }

UserDetails

/**
 * SpringSecurity包装的用户信息
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class SecurityUserDetails extends UmsMember implements UserDetails {

    private Collection<? extends GrantedAuthority> authorities;

    //返回当前用户的权限
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return authorities;
    }

    public SecurityUserDetails(String userName, String password, Collection<? extends GrantedAuthority> authorities){
        this.authorities = authorities;
        this.setUsername(userName);
        this.setPassword(new BCryptPasswordEncoder().encode(password));
        this.setAuthorities(authorities);
    }

    /**
     * 账户是否过期
     */
    @Override
    public boolean isAccountNonExpired() {
        return false;
    }
    /**
     * 是否禁用
     */
    @Override
    public boolean isAccountNonLocked() {
        return false;
    }
    /**
     * 密码是否过期
     */
    @Override
    public boolean isCredentialsNonExpired() {
        return false;
    }
    /**
     * 是否启用
     */
    @Override
    public boolean isEnabled() {
        return true;
    }
}

一共6个类

登录注册Controller

 @Resource
 private BCryptPasswordEncoder passwordEncoder;

    //登录:http://localhost:8080/LoginSecurity
    @RequestMapping(value = "/LoginSecurity", method = RequestMethod.POST)
    public ResponseCon<?> LoginSecurity(String username, String password) {
        UmsMember member = memberService.GetByNameMember(username);
        log.info("进入controller-member信息: {}", member);
        if (member != null) {
            if(passwordEncoder.matches(password,member.getPassword())){
                log.info("用户名正确, 密码正确");
                member.setToken(SecurityJwtUtil.sign(username, "user"));
                ...
                return new ResponseCon<>(200, "success", member);
            } else {
                log.info("用户名正确, 密码错误");
            }
        }
        return new ResponseCon<>(401, "error", "用户名或密码错误");
    }

    //注册:http://localhost:8080/Register
    @RequestMapping(value = "/Register", method = RequestMethod.POST)
    public boolean Register_OK(String username, String password, String phone) {
            password = passwordEncoder.encode(password);
            UmsMember mb = new UmsMember();
            mb.setPhone(phone);
            mb.setUsername(username);
            mb.setPassword(password);
            ...
            return true;
    }

    //测试:http://localhost:8080/TestTokenSecurity
    @RequestMapping(value = "/TestTokenSecurity", method = RequestMethod.POST)
    public ResponseCon<?> TestTokenSecurity() {
        return new ResponseCon<>(200, "success", "测试成功!");
    }

前端测试

第一次登录直接进controller验证用户名和密码,返回token
下次请求头都带上token,就会被security拦截去校验…

(不明白为啥非要加Bearer)
在这里插入图片描述
这篇写的很详细想深究去看看

https://blog.csdn.net/he_erduo/article/details/107178856

刷新token下次补全…

  • 2
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Spring Boot可以使用Spring SecurityJWT来实现安全认证和授权。 Spring Security是一个基于Spring框架的安全框架,它提供了一系列的安全功能,包括认证、授权、攻击防护等。在Spring Boot中,可以通过添加spring-boot-starter-security依赖来集成Spring SecurityJWT(JSON Web Token)是一种基于JSON的开放标准,用于在网络上安全地传输信息。它由三部分组成:头部、载荷和签名。在Spring Boot中,可以使用jjwt库来生成和验证JWT。 使用Spring SecurityJWT可以实现以下功能: 1. 用户认证:用户可以使用用户名和密码进行认证,认证成功后可以获取JWT。 2. 授权:使用JWT可以实现无状态的授权,即在每个请求中都携带JWT,服务器可以根据JWT中的信息进行授权。 3. 攻击防护:Spring Security提供了一系列的攻击防护功能,包括CSRF、XSS、SQL注入等。 总之,Spring Boot使用Spring SecurityJWT可以实现安全可靠的Web应用程序。 ### 回答2: Spring Boot是一种非常受欢迎的Java企业应用程序框架,可以帮助开发人员在构建应用程序时更快地完成编程工作。Spring Boot结合Spring Framework和Spring MVC等其他众多技术,并且提供很多特性的支持,比如整合securityjwt,使应用程序的开发和使用变得更加简单和高效。 Security是一种用于身份验证和授权的开放式框架,使得开发人员可以轻松地保护自己的应用程序免受未经授权的访问和攻击。Spring Security提供了很多安全特性,可以在您的应用程序中用来进行身份验证和授权。 通过使用安全组件,可以实现基于角色的访问控制,并且可以配置基于HTTPS的安全通信。Spring Security还可以集成Spring Boot中应用程序授权的功能,并且提供多种身份验证方式。 JWT是一种基于JSON的标准,主要用于在不同的应用程序之间传递安全令牌。它可以使得应用程序在授权用户访问时变得简单和高效,并且可以向其他无需经验证的应用程序发送授权证书,以允许他们访问您的应用程序资源。使用JWT,您可以轻松地传递身份验证数据,并确保这些数据不会被篡改。同时,JWT是通用的、标准化的,并且可以在大多数现代编程语言中使用。 在Spring Boot开发中使用Spring SecurityJWT,可以充分发挥它们的优势,实现更好的开发效率和安全性。Spring Security可以用来保护您的应用程序免受未经授权的访问和攻击,同时可以为授权用户提供访问控制。JWT提供了一种轻量级的安全机制,用于传递身份验证令牌,使得应用程序之间的交互变得更加灵活和安全。 总的来说,Spring Boot和其整合了的Spring SecurityJWT,为开发人员提供了完整的快速开发框架、安全性、实用性和扩展性,是一种非常理想的解决方案,可以支持各种高性能的企业级Java web应用程序。 ### 回答3: SpringBoot是使用Java语言开发的一款方便快捷的应用开发框架。SecurityJWT是其重要的安全保障工具,下面详细介绍它们如何在SpringBoot中使用。 一、Spring Security Spring SecuritySpring官方推出的安全框架,提供了一整套安全性认证和授权工具。包括用户身份认证(Authentication)、访问权限控制(Authorization)、密码加密、用户管理、认证方式等多方面,有效地提高了应用的安全性。 在SpringBoot中,添加Spring Security的依赖后,我们可以通过在配置文件配置好的认证信息和权限信息来管理访问控制。下面是一个简单的配置认证信息的例子: @Configuration @EnableWebSecurity public class WebSecurityConfig extends WebSecurityConfigurerAdapter { @Autowired public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception { auth.inMemoryAuthentication() .withUser("user").password("password").roles("USER") .and() .withUser("admin").password("password").roles("USER", "ADMIN); } } 上面的代码中,我们首先添加了Spring Security的依赖,然后通过@EnableWebSecurity注解来启用Web安全,继承了WebSecurityConfigurerAdapter类后并重写configureGlobal(AuthenticationManagerBuilder auth)方法来配置好需要认证的用户信息。其中,username为user,password为password的用户具有USER角色,username为admin,password为password的用户具有USER和ADMIN的角色。 二、JWT(JSON Web Token) JSON Web Token(JWT)是一种为Web应用程序提供认证及授权的开放标准,专门针对跨域应用场景下的单点登录、API 签名等场景。JWT本身是一个开放标准( RFC 7519),定义了用于在网络应用间传递声明的一种基于JSON的标准。 在SpringBoot中,我们可以通过引入JWT依赖后,结合Spring Security来实现JWT的安全认证功能。下面是一个简单示例: @Configuration @EnableWebSecurity public class WebSecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private JwtTokenProvider jwtTokenProvider; @Override protected void configure(HttpSecurity http) throws Exception { http.csrf().disable().authorizeRequests() .antMatchers("/api/authenticate").permitAll() .anyRequest().authenticated() .and() .apply(new JwtConfigurer(jwtTokenProvider)); } } 上述代码可以实现一个基于Spring SecurityJWT认证功能。我们使用了jwtTokenProvider来生成和验证JWT Token,然后通过configure(HttpSecurity http)方法来设定这个认证服务的安全策略。其中,访问/api/authenticate接口的请求不需要认证,而其他所有请求都需要已认证的访问者才能访问。 总结: Spring SecurityJWTSpringBoot中两种主要的安全保障工具,其中Spring Security提供了传统的用户认证授权等服务,而JWT则更适合跨应用的API认证和授权场景。这两种工具可以结合使用,提高应用在安全性方面的保障。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值