Springboot+SpringSecurity结合JWT实现认证和鉴权

最新推荐文章于 2024-08-28 09:02:59 发布
最新推荐文章于 2024-08-28 09:02:59 发布
阅读量2.1k 收藏 7
点赞数 4
分类专栏： Java笔记 文章标签： spring jwt spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oypebook/article/details/107596052
版权

概述

Spring Security 是 Spring 社区的一个顶级项目，也是 Spring Boot 官方推荐使用的安全框架。Spring Security和Shiro也是当前广大应用使用比较广泛的两个安全框架。

Spring Security 应用级别的安全主要包含两个主要部分，即登录认证（Authentication）和访问授权（Authorization），首先用户登录的时候传入登录信息，登录验证器完成登录认证并将登录认证好的信息存储到请求上下文，然后再进行其他操作，如在进行接口访问、方法调用时，权限认证器从上下文中获取登录认证信息，然后根据认证信息获取权限信息，通过权限信息和特定的授权策略决定是否授权。

项目搭建

在IDEA中创建Springboot项目，引入以下内容

在这里插入图片描述

其中Springboot DevTools、Lombok不是必须件

引入依赖

项目搭建好后，引入JWT依赖。为了方便调试，本例中还将引入Swagger项目。由于引入了Swagger，所以在之后的权限拦截中要额外配置Swagger资源跳过验证，具体后文会说。

JWT

<!-- https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

Swagger

我并没有使用Swagger-ui，而是使用了Layui来作为Swagger的展示，所以没有引用到swagger-ui的依赖。swagger-ui-layer只支持RestController的接口，请根据自己项目实际情况选择Swagger的UI框架。

<!-- swagger2  -->
<!--swagger本身不支持spring mvc的，springfox把swagger包装了一下，让他可以支持springmvc-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.6.1</version>
</dependency>
<dependency>
    <groupId>com.github.ohcomeyes</groupId>
    <artifactId>swagger-ui-layer</artifactId>
    <version>1.2</version>
</dependency>

配置Swagger（没有用到Swagger的直接跳过）

添加一个Swagger配置类，除了常规配置外，还需要增加一个令牌属性，使其可以在接口调用的时候传递令牌。

package com.vansen.zuanyunfei_backend.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.ParameterBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.schema.ModelRef;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.service.Parameter;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

import java.util.ArrayList;
import java.util.List;

/**
 * Swagger config class
 *
 * @author Nicemorning
 * @date Create in 1:58 2020/7/24 0024
 */
@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket createRestApi() {
        // Construct request parameters,put token into request header
        ParameterBuilder parameterBuilder = new ParameterBuilder();
        List<Parameter> parameters = new ArrayList<>();
        parameterBuilder.name("Authorization")
                .description("AuthorizationToken")
                .modelRef(new ModelRef("string"))
                .parameterType("header")
                .required(false)
                .build();
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build()
                .globalOperationParameters(parameters);
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("title")
                .description("description")
                .version("1.0")
                .contact(new Contact("name", "url", "email"))
                .build();
    }
}

启动项目后，在浏览器中打开http://localhost:8080/api-docs.html即可查看Swagger的UI展示。

由于引入了SpringSecurity，但是没有对其进行配置。所以不出意外的话会进入SpringSecurity默认的登录页面。

在这里插入图片描述

编写SpringSecurity配置类

编写一个自定义的SpringSecurity配置了，继承WebSecurityConfigurerAdapter抽象类，该抽象类定义了一些默认的configure()方法，我们需要重写这些方法来实现自定义的安全逻辑。

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        super.configure(auth);
    }

    @Override
    public void configure(WebSecurity web) throws Exception {
        super.configure(web);
    }

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

其中常用的是configure(AuthenticationManagerBuilder auth)和configure(HttpSecurity http)，可以简单的理解为其分别针对的逻辑为认证和授权。其中configure(WebSecurity web)主要用于对web请求做一些过滤操作。

配置不需要鉴权的路径

通常而言，静态资源、登录注册以及Swagger-ui是不需要鉴权的，可以让任何用户随意访问，我们只需要在configure(WebSecurity web)方法中添加ignore()配置即可。

@Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring()
                // static resources
                .antMatchers("/favicon.ico")
                .antMatchers("/hello")
                .antMatchers("/static/**")
                .antMatchers("**.js", "**.html", "**.css")
                // swagger
                .antMatchers("/v2/api-docs",
                        "/configuration/ui",
                        "/swagger-resources",
                        "/configuration/security",
                        "/swagger-ui.html",
                        "/webjars/**",
                        "/swagger-resources/configuration/ui",
                        "/swagger-ui.html").
                antMatchers("/api-docs.html");
    }

也可以直接在configure(HttpSecurity http)中使用permitAll()来实现。

antMatchers(HttpMethod.POST, "/**").permitAll()

配置鉴权逻辑

直接上代码。

@Override
protected void configure(HttpSecurity http) throws Exception {
    // 由于使用的是JWT，所以需要禁用掉CSRF
    http.cors().and().csrf().disable()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .httpBasic().authenticationEntryPoint(new CusAuthenticationEntryPoint())
            .and()
            .authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .addFilter(new AuthenticationTokenFilter(authenticationManager()));
    http.headers().cacheControl();
}

其中cors()和csrf()是CSRF(跨站请求伪造)和CORS(跨域资源共享)的意思，将其禁用掉可以开启跨域功能。sessionManagement是配置SpringSecurity的Session策略，由于使用无状态的JWT来做Token，所以这里将Session创建策略通过sessionCreationPolicy方法定义为STATELESS，即Spring Security不创建和使用Session。

关于Session创建策略的选项区别，可以直接查看源码注释。

/**
 * Specifies the various session creation policies for Spring Security.
 *
 * @author Luke Taylor
 * @since 3.1
 */
public enum SessionCreationPolicy {
	/** Always create an {@link HttpSession} */
	ALWAYS,
	/**
	 * Spring Security will never create an {@link HttpSession}, but will use the
	 * {@link HttpSession} if it already exists
	 */
	NEVER,
	/** Spring Security will only create an {@link HttpSession} if required */
	IF_REQUIRED,
	/**
	 * Spring Security will never create an {@link HttpSession} and it will never use it
	 * to obtain the {@link SecurityContext}
	 */
	STATELESS
}

回到刚才的配置中，authenticationEntryPoint配置的是一个自定义的CusAuthenticationEntryPoint处理类，还有一个是accessDeniedHandler。他们的作用分别为：

  1. AuthenticationEntryPoint 用来解决匿名用户访问无权限资源时的异常
  2. AccessDeineHandler 用来解决认证过的用户访问无权限资源时的异常

如果需要增加AccessDeineHandler的话，只需要将上面的语句改成：

// .httpBasic().authenticationEntryPoint(new CusAuthenticationEntryPoint())
// 注释掉原来的EntryPoint配置，使用下面的语句进行配置
.exceptionHandling().authenticationEntryPoint(new CusAuthenticationEntryPoint()).accessDeniedHandler(new CusAccessDeiedHandler())

往下继续读配置，会出现authorizeRequests方法，这个方法需要和anyRequest或antMatchers配合使用，是用于指定路径是否需要鉴权的设置。鉴权的设置常用的有以下几种方法：

  1. permitAll() 允许无条件访问
  2. anonymous() 允许匿名访问
  3. hasRole() 只允许有特定权限的用户访问
  4. authenticated() 需要进行认证

最后一句addFilter方法可以添加自定义的认证过滤器，上方配置的authenticated会流转到这里所配置的过滤器中进行认证。

至此，需要留意几个关键点：

  1. 配置需要鉴权或不需要认证的URL路径
  2. 根据需要决定是否关闭跨域限制
  3. 添加自定义的异常处理（详见下文）
  4. 添加自定义的认证过滤器（详见下文）

暂时先把上方的配置注释掉，重启一下项目，再次进入http://localhost:8080/api-docs.html。此时可以看到已经能够正常进入页面，而不会被SpringSecurity所拦截了。

在这里插入图片描述

编写自定义异常处理类

上文有提到，异常处理类有两个，分别是：

  1. AuthenticationEntryPoint 用来解决匿名用户访问无权限资源时的异常
  2. AccessDeineHandler 用来解决认证过的用户访问无权限资源时的异常

接下来我们将对以上两个类进行自定义业务逻辑

AuthenticationEntryPoint

自定义一个CusAuthenticationEntryPoint类，需要实现AuthenticationEntryPoint接口，并添加@Component注解，将该类交给Spring进行管理。

@Component
@Slf4j
public class CusAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public void commence(HttpServletRequest request,
                         HttpServletResponse response,
                         AuthenticationException e) throws IOException {
        log.error("未授权访问 路径:{} - {}", request.getRequestURI(), e.getMessage());
        ResMsg<Object> forbidden = ResMsg.errorMsg(request.getHeader("Authorization") == null ?
                AuthExceptionGroup.FORBIDEN.getMessage() :
                AuthExceptionGroup.BEARER_TOKEN_ERROR.getMessage());
        String s = objectMapper.writeValueAsString(forbidden);
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        response.getWriter().write(s);
        response.flushBuffer();
    }
}

这是我的配置示例，请根据项目实际需求自行改动。

AccessDeineHandler

自定义一个CusAccessDeniedHandler类，需要实现AccessDeniedHandler接口，该类同样需要交给Spring进行管理。

@Component
public class CusAccessDeniedHandler implements AccessDeniedHandler {

    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response,
                       AccessDeniedException accessDeniedException) throws IOException {
        if (!response.isCommitted()) {
            ResMsg<Object> forbidden = ResMsg.errorMsg(AuthExceptionGroup.FORBIDEN.getMessage());
            String s = objectMapper.writeValueAsString(forbidden);
            response.getWriter().write(s);
            response.flushBuffer();
        }
    }
}

编写完成后，将这两个自定义的异常处理类添加到配置中，此时配置内容为：

http.cors().and().csrf().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
//                .httpBasic().authenticationEntryPoint(new CusAuthenticationEntryPoint())
                .exceptionHandling()
                .authenticationEntryPoint(new CusAuthenticationEntryPoint())
                .accessDeniedHandler(new CusAccessDeniedHandler())
                .and()
                .authorizeRequests()
                .anyRequest().authenticated()
                .and()
                .addFilter(new AuthenticationTokenFilter(authenticationManager()));
        http.headers().cacheControl();

编写自定义的认证过滤器

编写一个AuthenticationTokenFilter类，需要继承BasicAuthenticationFilter，该类不需要交给Spring管理。

BasicAuthenticationFilter中定义了默认的doFilterInternal过滤逻辑，我们可以重写它来实现自定义的业务逻辑。

public class AuthenticationTokenFilter extends BasicAuthenticationFilter {

    public AuthenticationTokenFilter(AuthenticationManager authenticationManager) {
        super(authenticationManager);
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        String tokenHeader = request.getHeader(ConstantParams.TOKEN_HEADER);
        // 如果请求头中没有Authorization信息则直接放行了
        if (tokenHeader == null || !tokenHeader.startsWith(ConstantParams.TOKEN_PREFIX)) {
            chain.doFilter(request, response);
            return;
        }
        // 如果请求头中有token，则进行解析，并且设置认证信息
        SecurityContextHolder.getContext().setAuthentication(getAuthentication(tokenHeader));
        super.doFilterInternal(request, response, chain);
    }

    private UsernamePasswordAuthenticationToken getAuthentication(String tokenHeader) {
        String token = tokenHeader.replace(ConstantParams.TOKEN_PREFIX, "").trim();
        String username = JwtUtil.getUsername(token);
        List<String> roles = JwtUtil.getUserRole(token);
        Collection<GrantedAuthority> authorities = new HashSet<>();
        if (username == null) {
            return null;
        }
        if (roles != null) {
            for (String role : roles) {
                authorities.add(new SimpleGrantedAuthority(role));
            }
        }
        return new UsernamePasswordAuthenticationToken(
                CurrentUser.ofId(1)
                        .setUsername(ConstantParams.USERNAME)
                        .setPassword(ConstantParams.PASSWORD)
                        .setAuthorities(authorities),
                null,
                authorities);
    }
}

其中UsernamePasswordAuthenticationToken是SpringSecurity默认的用户信息实体逻辑，整个自定义的认证逻辑可以根据自身业务需要进行改动。核心的流程其实就是doFilterInternal方法中所定义的内容。

本示例中，用户的请求如果需要进行认证的，将会进入到doFilterInternal方法中，在方法中取得请求的头部信息，如果没有Token的，直接放行。如果有头部的，则调用getAuthentication方法进行Token信息解析，用以取得当前访问的用户身份和权限范围。

在doFilterInternal方法中，对于没有Token的将直接return，这一步的return会直接结束当前方法，继续执行调用者的逻辑。我们可以通过断点逐步调试的方式跟踪步骤，但是这里直接给出结论，return后会执行到刚才所自定义的CusAuthenticationEntryPoint中，也就是说其出发了匿名用户访问无权限资源时的异常。

上面的代码中，有一段

CurrentUser.ofId(1)
    .setUsername(ConstantParams.USERNAME)
    .setPassword(ConstantParams.PASSWORD)
    .setAuthorities(authorities)

用户的权限信息正常来说是通过数据库获得的，但是在此示例项目中，我直接将用户名和密码写在了ConstantParams类中，只用于做示范。

上方代码中涉及到了JwtUtil工具类，JWT的工具类百度上有一大堆。在本文的最后也会附上我所使用的JWT工具类源码，这里暂时跳过不讨论。

至此我们已经完成了拦截配置、认证逻辑自定义、异常处理自定义。还缺最后一步，即授权。

配置自定义授权逻辑

在SpringSecurity配置类中的configure(AuthenticationManagerBuilder auth)方法内，添加自定义的授权业务类。

@Autowired
private CusUserDetailsService userDetailsService;

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

编写自定义授权逻辑类

SpringSecurity默认使用的是UserDetailsService授权业务类，如果没有什么特别高级的定制需求，只需要继承这个类重写一下接口即可。

自定义CusUserDetailsService接口，继承UserDetailsService

public interface CusUserDetailsService extends UserDetailsService {
}

自定义CusUserDetailsServiceImpl实现CusUserDetailsService，实现loadUserByUsername方法完成授权的业务自定义。通常情况下授权需要比对用户名密码等信息，是通过数据库获得的，在此我直接将用户名和密码写在了ConstantParams类中。

@Service
@Slf4j
public class CusUserDetailsServiceImpl implements CusUserDetailsService
{
    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        UserDetails userDetails = null;
        try {
            if (s.equals(ConstantParams.USERNAME)) {
                Set<GrantedAuthority> authorities = new HashSet<>();
                authorities.add(new SimpleGrantedAuthority("ALL"));
                userDetails = new User(ConstantParams.USERNAME, ConstantParams.PASSWORD, authorities);
            } else {
                String message = "Username not corrected";
                log.error(message);
                throw new UsernameNotFoundException(message);
            }
        } catch (Exception e) {
            log.error(e.getMessage());
        }
        return userDetails;
    }
}

其中的UserDetails是SpringSecurity自带的用户信息类，默认实现是User，其中包含以下信息，如果没有什么特别要求的话，直接使用就足够了。

public User(String username, String password, Collection<? extends GrantedAuthority> authorities) {
        this(username, password, true, true, true, true, authorities);
    }

public User(String username, String password, boolean enabled, boolean accountNonExpired, boolean credentialsNonExpired, boolean accountNonLocked, Collection<? extends GrantedAuthority> authorities) {
    if (username != null && !"".equals(username) && password != null) {
        this.username = username;
        this.password = password;
        this.enabled = enabled;
        this.accountNonExpired = accountNonExpired;
        this.credentialsNonExpired = credentialsNonExpired;
        this.accountNonLocked = accountNonLocked;
        this.authorities = Collections.unmodifiableSet(sortAuthorities(authorities));
    } else {
        throw new IllegalArgumentException("Cannot pass null or empty values to constructor");
    }
}

需要注意的是，loadUserByUsername(String s)中传入的s为用户登录或其他业务操作传入的用户名，我们可以通过用户名去数据库中查询该用户的密码，进行比对来决定接下来的业务如何处理。

Set<GrantedAuthority> authorities = new HashSet<>();
authorities.add(new SimpleGrantedAuthority("ALL"));

这一段代码则是将权限范围添加到该用户的UserDetails信息中，之后的认证也是从UserDetails获取该List来判断用户是否具有某项操作的权限。

至此，整个SpringSecurity的配置、认证、授权、异常处理都已经实现完成，一般情况下这些内容已经足够实现项目丰富的权限管控要求了，如果还不够用的话，我们还可以通过实现AuthenticationProvider来自定义更多的认证模式，通过配置好的认证请求链中的顺序来进行更复杂的验证。本文未涉及到多认证模式的内容，需要的可以自行百度相关资料。

AuthenticationProvider和AuthenticationFilter方式的区别

AuthenticationProvider的默认实现是DaoAuthenticationProvider，
AuthenticationProvider作为授权方式提供者，用于判断授权有效性，用户有效性，在判断用户是否有效性时，它依赖于UserDetailsService实例，开发人员可以自定义UserDetailsService的实现。

  1. additionalAuthenticationChecks 方法校验密码有效性
  2. retrieveUser 方法根据用户名获取用户
  3. createSuccessAuthentication 完成授权持久化

AuthenticationFilter的默认实现是UsernamePasswordAuthenticationFilter，
AuthenticationFilter作为授权过滤器，开发人员可以自定义它的业务逻辑，并把它添加到默认过滤器前或者后去执行，主要用来到授权的持久化，它可以从请求上下文中获取你的username,password等信息，然后去判断它是否符合规则，最后通过authenticate方法去授权。默认的UsernamePasswordAuthenticationFilter过滤器，主要判断请求方式是否为post，并且对username和password进行了默认值的处理，总之，在这个过滤器里不会涉及到具体业务。

启动项目，检查是否正常运行

写完上面所提到的所有配置后，我们可以启动一下项目，检查一下是否能够正常启动。

在这里插入图片描述

通过上面的配置，项目正常启动。接下来我们需要写几个测试接口，看看具体的配置是否起到了作用。

编写测试接口

编写测试Controller

/**
 * @author Nicemorning
 * @date Create in 16:40 2020/7/26 0026
 */
@Api(tags = "Demo apis")
@RestController
@RequestMapping("demo")
public class DemoController {
    @ApiOperation("Login get token")
    @PostMapping("login")
    public String login() {
        // 需要生成Authentication对象，并将 Authentication 绑定到 SecurityContext，示例项目中没有编写这一部分
        List<String> roles = new ArrayList<>();
        roles.add(ConstantParams.ROLE_CLAIMS);
        return JwtUtil.createToken(ConstantParams.USERNAME, roles);
    }

    @ApiOperation("auth")
    @GetMapping("auth")
    public String auth(Integer id) {
        return "Auth id: " + id;
    }
}

其中包含了两个接口：登录接口（不需要权限）和鉴权接口（需要携带Token）

编写WebSecurity配置

将登录接口配置为不需要鉴权。

.antMatchers("/demo/login")

启动后浏览器打开http://localhost:8080/api-docs.html尝试。

在这里插入图片描述

不登录的情况下请求鉴权接口


无法访问，被拦截。

请求登录接口获得Token

在这里插入图片描述
可以访问，并且获得Token

携带Token请求鉴权接口

在头部中添加Token重新尝试鉴权接口

在这里插入图片描述

响应正常。

至此SpringBoot结合SpringSecurity使用JWT实现鉴权和认证已经全部完成，当前项目结构如图所示：

在这里插入图片描述

Swagger 跨域问题解决

我在本地调试时没有遇到，但是部署到服务器后出现了跨域的问题，解决办法如下：

定义一个CORS配置类，该类标记为配置类并实现WebMvcConfigurer接口。即可解决

@Configuration
public class CorsFilterConfig implements WebMvcConfigurer {
    @Bean
    public CorsFilter corsFilter() {
        final UrlBasedCorsConfigurationSource urlBasedCorsConfigurationSource = new UrlBasedCorsConfigurationSource();
        final CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.setAllowCredentials(true);
        corsConfiguration.addAllowedOrigin("*");
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
        urlBasedCorsConfigurationSource.registerCorsConfiguration("/**", corsConfiguration);
        return new CorsFilter(urlBasedCorsConfigurationSource);
    }
}

JWT工具类

public class JwtUtil implements Serializable {
    private static final long serialVersionUID = -649173465054267244L;

    private static final long EXPIRE_TIME = 24 * 60 * 60 * 1000;

    /**
     * description: 创建Token
     *
     * @param username 用户名
     * @return java.lang.String
     */
    public static String createToken(String username, List<String> roles) {
        HashMap<String, Object> map = new HashMap<>();
        map.put(ConstantParams.ROLE_CLAIMS, roles);
        return Jwts.builder()
                .signWith(SignatureAlgorithm.HS512, ConstantParams.SECRET)
                .setClaims(map)
                .setIssuer(ConstantParams.ISS)
                .setId(String.valueOf("1"))
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRE_TIME))
                .compact();
    }

    public static String getIdentify(String token) {
        return getTokenBody(token).getSubject();
    }

    public static String getUsername(String token) {
        return getTokenBody(token).getSubject();
    }

    public static Integer getId(String token) {
        return Integer.parseInt(getTokenBody(token).getId());
    }

    /**
     * 获取用户角色
     *
     * @param token token
     * @return 用户角色
     */
    @SuppressWarnings("unchecked")
    public static List<String> getUserRole(String token) {
        return (List<String>) getTokenBody(token).get(ConstantParams.ROLE_CLAIMS);
    }

    /**
     * 判断Token是否过期
     *
     * @param token token
     * @return boolean
     */
    public static boolean isExpiration(String token) {
        return getTokenBody(token).getExpiration().before(new Date());
    }

    /**
     * 解析TOKEN
     *
     * @param token token
     * @return io.jsonwebtoken.Claims
     */
    private static Claims getTokenBody(String token) {
        return Jwts.parser()
                .setSigningKey(ConstantParams.SECRET)
                .parseClaimsJws(token)
                .getBody();
    }
}
nicemorning
关注
专栏目录
SpringBoot整合SpringSecurity实现JWT认证
我的博客
03-30 3万+
前言 微服务架构，前后端分离目前已成为互联网项目开发的业界标准，其核心思想就是前端（APP、小程序、H5页面等）通过调用后端的API接口，提交及返回JSON数据进行交互。 在前后端分离项目中，首先要解决的就是登录及授权的问题。微服务架构下，传统的session认证限制了应用的扩展能力，无状态的JWT认证方法应运而生，该认证机制特别适用于分布式站点的单点登录（SSO）场景 目录 该文会通过创建...
SpringSecurity和JWT实现认证和授权
架构师老狼
02-10 515
SpringSecurity SpringSecurity是一个强大的可高度定制的认证和授权框架，对于Spring应用来说它是一套Web安全标准。SpringSecurity注重于为Java应用提供认证和授权功能，像所有的Spring项目一样，它对自定义需求具有强大的扩展性。 JWT JWT是JSON WEB TOKEN的缩写，它是基于 RFC 7519 标准定义的一种可以安全传输的的JSON对象，由于使用了数字签名，所以是可信任和安全的。 JWT的组成 WT token的格式：header.pa
SpringBoot整合SpringSecurity + JWT
最新发布
zznnniuu的博客
08-28 638
Token 也是一种用于用户身份鉴权的手段。他其实是一种代表用户身份验证和授权的令牌。在 Web 应用程序中，常用的身份验证方案是基于令牌的身份验证 (Token-based Authentication)。当用户成功登录时，服务器会生成一个 Token 并将其返回给客户端。客户端在后续的请求中将 Token 包含在请求头或请求参数中发送给服务器。服务器接收到 Token 后，会进行验证和解析，以确定用户的身份和权限。Token 通常是基于某种加密算法生成的，因此具有一定的安全性。
Springboot+SpringSecurity+JWT实现登录认证及鉴权
tony_stark的博客
08-18 4584
因为现在项目重构，在网上找了很多这方面的案例，常用的登录认证和前端鉴权就是SpringSecurity+JWT来实现。所以在网上搜了一些案例，集成到自己的项目中，做了适应项目的修改及调整，分享demo出来给有需要的码友。 备注：其实在项目中一般都只会用到登录认证，至于鉴权，Security实际上就是将所有权限的角色遍历，和当前登录用户的角色匹配是否具有权限，每次请求都会遍历，过于繁琐，在实际项目中一般很少使用。 1.首先引入pom.xml依赖： <dependency> <grou
Spring Security + JWT 实现认证和授权
修理男爵的博客
11-10 1984
数据库表 Spring Security JWT JwtToken @Data public class JwtToken { private String token; private String username; private Long expireTime; } JwtTokenProvider @Slf4j @Component public class JwtTokenProvider { public JwtToken cre..
使用springSecurity+JWT实现认证和授权
人间剧场的博客
05-16 445
SpringSecurity是一个强大的可高度定制的认证和授权框架，对于Spring应用来说它是一套Web安全标准。SpringSecurity注重于为Java应用提供认证和授权功能，像所有的Spring项目一样，它对自定义需求具有强大的扩展性。
springboot+security+mybatis+redis+jwt，鉴权框架搭建
06-22
本项目集成了springboot+security+mybatis+redis+jwt用于学习security鉴权功能，其中有集成了redis，mybatis，jasypt，jwt，thymeleaf，knife4j，mybatis-plus 项目搭建已经比较成熟，能够直接进行使用，通过代码...
基于springBoot+springSecurity+jwt实现前后端分离用户权限认证
12-09
springSecurity也有很多种权限认证方式，本项目主要实现基于接口授权，也就是说通过注解给controller赋予权限，用户只有拥有某个接口的权限才能成功访问这个接口，从而实现不同用户拥有不同访问权限;
基于springboot+oauth2.0+jwtToken鉴权认证开发的后台接口，整套架构采用restful风格，车牌识别，阿里云消息推送，短信接口等
04-04
内容只为接口开发，配合前端和移动app调用使用，不包含html页面，基于springboot+oauth2.0+jwttoken鉴权（内有怎么使用redistoken和数据库token注释）+restful风格+阿里短信+阿里消息推送+车牌识别等。该项目为工作...
SpringBoot+Spring Security+JWT（三更草堂）
Roc的博客
09-12 7922
Springsecurity是Spring家族中的一个安全管理框架。相比与另外一个安全框架shiro，它提供了更丰富的功能，社区资源也比Shiro丰富。一般来说中大型的项目都是使用来做安全框架。小项目有Shiro的比较多，因为相比与SpringSecurity，Shiro的上手更加的简单。—般Web应用的需要进行认证和授权。认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户授权：经过认证后判断当前用户是否有权限进行某个操作而认证和授权也是SpringSecurity作为安全框架的核心功能。
Springboot+Spring-Security+JWT 实现用户登录和权限认证
热门推荐
congge
06-08 27万+
如今，互联网项目对于安全的要求越来越严格，这就是对后端开发提出了更多的要求，目前比较成熟的几种大家比较熟悉的模式，像RBAC 基于角色权限的验证，shiro框架专门用于处理权限方面的，另一个比较流行的后端框架是Spring-Security，该框架提供了一整套比较成熟，也很完整的机制用于处理各类场景下的可以基于权限，资源路径，以及授权方面的解决方案，部分模块支持定制化，而且在和oauth2.0进...
spring boot + spring security + Jwt
qq_36722687的博客
06-30 735
spring boot + spring security + Jwt主要依赖标题新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 主要依赖 <dependency> <grou
2021-01-24 SpringBoot + Spring Security + JWT 实现认证鉴权
bb
02-24 480
前言 1、会基本的Spring Security配置 2、大概了解Spring Security原理(一条过滤器链) 简单理解 Spring Security就是一条过滤器链，如果你登录了，那么会有过滤器将你的认证信息解析出来并放到Security的上下文中，这样其他过滤器就通过这个认证信息来鉴权 JWT配置 简单描述 之前由Security的过滤器来解析认证信息，现在我们自己定义一个过滤器，将携带的token解析为认证信息即可 登录：登录成功后生成token // cn.mb
详细！SpringBoot整合SpringSecurity实现JWT认证
MarkerHub的博客
01-02 1171
小Hub领读：最近做了个security项目，参考了一下这个例子，还可以作者：智慧zhuhuixhttps://blog.csdn.net/jpgzhu/article/details/...
Spring boot Security Jwt
何xiao树
05-31 1543
Spring Security 整合开发 引入 security 启动器，默认拦截所有资源，启动项目会生成一个默认密码，账号 user <!-- 引入Spring Security --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-.
SpringBoot+SpringSecurity+JWT+Redis实现认证授权 整体思路： 基于汇客CRM项目
isiywang的博客
08-01 1298
前端提交用户名和密码到后端接口方法中，被springsecurity拦截，需要进行用户认证，首先将用户名和密码通过AuthenticationManager接口中的authenticate方法封装成一个Authentication对象但是Authentication是一个接口，要用Authentication的实现类UsernamePasswordAuthenticationToken传入用户名和密码参数封装成Authentication对象。............
SpringSecurity+JWT实现认证及授权详细步骤
sunao1106的博客
08-03 1174
1. 实现**UserDetailsService**对象中的`loadUserByUsername`方法，根据用户名查询用户信息以及权限信息； 2. 自定义controller登录接口； 3. 自定义service层登录逻辑，调用`loadUserByUsername`获取用户信息并且校验密码，如果认证成功则生成一个jwt返回，将用户信息存入**SecurityContextHolder**上下文； 4. 自定义**JwtAuthenticationTokenFilter**过滤器，获取请........
SpringBoot使用Jwt来进行安全验证机制
A169388842的博客
06-19 705
一. HTTP Basic Auth HTTP Basic Auth简单点说明就是每次请求API时都提供用户的username和password，简言之，Basic Auth是配合RESTful API 使用的最简单的认证方式，只需提供用户名密码即可，但由于有把用户名密码暴露给第三方客户端的风险，在生产环境下被使用的越来越少。因此，在开发对外开放的RESTful API时，尽量避免采用HTTP Basic Auth 二.OAuth OAuth（开放授权）是一个开放的授权标准，允许用户让第三方应用访问该用户在
spring boot整合spring security和jwt实现分布式认证和权限处理
技术成就梦想
11-19 1229
spring security是spring官方比较推荐的用于认证和权限的解决方案，市面上做认证和权限的开发框架还有shiro，spring boot也提供了shiro的解决方案，本人在之前的开发中大多使用了shiro,但是spring security也是值得一学的，除了官方推荐的原因像spring oauth2.0也会用到它，所以学习一下还是很有必要的，本次将围绕spring security的认证授权、jwt进行学习分享 1 依赖的引入 <!-- springsecurity的依赖 --&
SpringBoot+Spring Security整合JWT实现登录鉴权教程
"本文主要探讨了如何在SpringBoot项目中集成Spring Security，并利用JWT（Json Web Token）实现用户的登录和鉴权功能。文中通过具体的代码示例，详细讲解了JWT的工作原理以及实现场景，旨在帮助开发者理解并掌握这一...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值