《Spring Security+JWT实现认证授权》

最新推荐文章于 2024-06-02 20:54:30 发布
最新推荐文章于 2024-06-02 20:54:30 发布
阅读量330 收藏 1
点赞数 1
分类专栏： 从入门到学废
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51945027/article/details/119518071
版权

前面，我们做了Spring Security和JWT的详细介绍，今天，我们就来整合Spring Security 和 JWT……
《Spring Security十万字详解》
《JWT 三万字详解》

话不多说，上代码

安全配置类

package com.uncle.jwt.config;

import com.uncle.jwt.filter.TokenAuthenticationFilter;
import com.uncle.jwt.filter.TokenLoginFilter;
import com.uncle.jwt.handler.UnauthorizedEntryPoint;
import com.uncle.jwt.util.DefaultPasswordEncoder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;

/**
 * @program: spring-security-jwt
 * @description:
 * @author: 步尔斯特
 * @create: 2021-08-08 14:24
 */
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true,securedEnabled=true)
public class TokenWebSecurityConfig extends WebSecurityConfigurerAdapter {
    /**
     * 密码管理工具类
     */
    @Autowired
    private DefaultPasswordEncoder defaultPasswordEncoder;

    /**
     * 用户服务类
     */
    @Autowired
    private UserDetailsService userDetailsService;

    /**
     * 配置设置，设置退出的地址和token
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.exceptionHandling()
                //未授权处理
                .authenticationEntryPoint(new UnauthorizedEntryPoint())
                .and().authorizeRequests()
                .anyRequest().authenticated()
                .and().csrf().disable()
                .logout().logoutUrl("/logout")
                .and()
                .addFilter(new TokenLoginFilter(authenticationManager()))
                .addFilter(new TokenAuthenticationFilter(authenticationManager())).httpBasic();
    }

    /**
     * 密码处理
     */
    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(defaultPasswordEncoder);
    }

    /**
     * 配置哪些请求不拦截
     */
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/api/**");
    }
}

测试接口

package com.uncle.jwt.controller;

import org.springframework.security.access.annotation.Secured;
import org.springframework.security.access.prepost.PostAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @program: spring-security-jwt
 * @description:
 * @author: 步尔斯特
 * @create: 2021-08-08 14:25
 */
@RestController
public class TestController {

    @GetMapping("admin")
    public String admin() {
        return "admin!!!";
    }

    @GetMapping("api/hello")
    public String user() {
        return "hello world";
    }


    /**
     * 方法执行前鉴权
     *
     * @return
     */
    @GetMapping("roleAdmin")
    @Secured("ROLE_ADMIN")
    public String roleAdmin() {
        return "roleAdmin!!!";
    }

    /**
     * 方法执行前鉴权
     *
     * @return
     */
    @GetMapping("preAuthorize")
    @PostAuthorize("hasAnyRole('ROLE_ADMIN')")
    public String preAuthorize() {
        System.out.println("preAuthorize…………方法执行前鉴权");
        return "preAuthorize!!!";
    }

    /**
     * 方法执行完再鉴权
     *
     * @return
     */
    @GetMapping("postAuthorize")
    @PostAuthorize("hasAnyRole('ROLE_USER')")
    public String postAuthorize() {
        System.out.println("postAuthorize…………方法执行完再鉴权");
        return "PostAuthorize!!!";
    }
}

登录过滤器

package com.uncle.jwt.filter;

import com.uncle.jwt.util.JwtTokenUtil;
import com.uncle.jwt.util.ResponseUtil;
import com.uncle.jwt.util.Result;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;

/**
 * @program: spring-security-jwt
 * @description:
 * @author: 步尔斯特
 * @create: 2021-08-08 14:38
 */
public class TokenLoginFilter extends UsernamePasswordAuthenticationFilter {
    private AuthenticationManager authenticationManager;

    public TokenLoginFilter(AuthenticationManager authenticationManager) {
        this.authenticationManager = authenticationManager;
        this.setPostOnly(false);
        this.setRequiresAuthenticationRequestMatcher(new AntPathRequestMatcher("/login", "POST"));
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse res) throws AuthenticationException {
        try {
            String username = req.getParameter("username");
            String password = req.getParameter("password");
            username = username != null ? username.trim() : "";
            password = password != null ? password : "";
            return authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password, new ArrayList<>()));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 登录成功
     */
    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication auth) throws IOException, ServletException {
        User user = (User) auth.getPrincipal();
        String authrorities = user.getAuthorities().size() > 0 ? user.getAuthorities().toString().replaceAll("(?:\\[|null|\\]| +)", "") : user.getAuthorities().toString();

        String token = JwtTokenUtil.createToken(user.getUsername(), authrorities);
        HashMap<Object, Object> map = new HashMap<>();
        map.put("token", token);
        map.put("user", user);
        map.put("loginName", user.getUsername());
        ResponseUtil.out(response, Result.ok(map));
    }

    /**
     * 登录失败
     */
    @Override
    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
        ResponseUtil.out(response, Result.error("登录失败"));
    }
}



package com.uncle.jwt.filter;

import com.uncle.jwt.util.JwtTokenUtil;
import com.uncle.jwt.util.ResponseUtil;
import com.uncle.jwt.util.Result;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
import org.springframework.util.StringUtils;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;

/**
 * @program: spring-security-jwt
 * @description:
 * @author: 步尔斯特
 * @create: 2021-08-08 14:56
 */
public class TokenAuthenticationFilter extends BasicAuthenticationFilter {

    public TokenAuthenticationFilter(AuthenticationManager authManager) {
        super(authManager);
    }

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

        logger.info("=================" + request.getRequestURI());
        //不需要鉴权
        if (request.getRequestURI().indexOf("index") != -1) {
            chain.doFilter(request, response);
        }
        UsernamePasswordAuthenticationToken authentication = null;
        try {
            authentication = getAuthentication(request);
        } catch (Exception e) {
            ResponseUtil.out(response, Result.error(e.getMessage()));
        }
        if (authentication != null) {
            SecurityContextHolder.getContext().setAuthentication(authentication);
        } else {
            ResponseUtil.out(response, Result.error("鉴权失败"));
        }
        chain.doFilter(request, response);
    }

    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
        // 获取Token字符串，token 置于 header 里
        String token = request.getHeader("token");
        if (!StringUtils.hasText(token)) {
            token = request.getParameter("token");
        }
        if (token != null && !"".equals(token.trim())) {
            // 从Token中解密获取用户名
            String userName = JwtTokenUtil.getUserNameFromToken(token);

            if (userName != null) {
                // 从Token中解密获取用户角色
                String role = JwtTokenUtil.getUserRoleFromToken(token);
                // 将ROLE_XXX,ROLE_YYY格式的角色字符串转换为数组
                String[] roles = role.split(",");
                Collection<SimpleGrantedAuthority> authorities = new ArrayList<>();
                for (String s : roles) {
                    authorities.add(new SimpleGrantedAuthority(s));
                }
                return new UsernamePasswordAuthenticationToken(userName, token, authorities);
            }
            return null;
        }
        return null;
    }
}

处理异常类

package com.uncle.jwt.handler;

import com.uncle.jwt.util.ResponseUtil;
import com.uncle.jwt.util.Result;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @program: spring-security-jwt
 * @description:
 * @author: 步尔斯特
 * @create: 2021-08-08 15:19
 */
public class UnauthorizedEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        ResponseUtil.out(response, Result.error("未授权统一处理"));
    }
}

处理用户登录过程的类

package com.uncle.jwt.service;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

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

/**
 * @program: spring-security-jwt
 * @description:
 * @author: 步尔斯特
 * @create: 2021-08-08 15:11
 */
@Service("userDetailsService")
public class CustomUserDetailsService implements UserDetailsService {

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //从数据库获取用户信息
        List<GrantedAuthority> authorities = new ArrayList<>();
        authorities.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
        authorities.add(new SimpleGrantedAuthority("ROLE_USER"));
        //封装用户信息，用于认证与密码校验
        return new User(username, username, authorities);
    }
}

加密处理器

package com.uncle.jwt.util;

import lombok.extern.slf4j.Slf4j;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Component;

/**
 * @program: spring-security-jwt
 * @description:
 * @author: 步尔斯特
 * @create: 2021-08-08 15:37
 */
@Component
@Slf4j
public class DefaultPasswordEncoder extends BCryptPasswordEncoder {

    @Override
    public String encode(CharSequence rawPassword) {
        return rawPassword.toString();
    }

    @Override
    public boolean matches(CharSequence rawPassword, String encodedPassword) {
        if (rawPassword == null) {
            throw new IllegalArgumentException("rawPassword cannot be null");
        }
        if (encodedPassword == null || encodedPassword.length() == 0) {
            log.error("Empty encoded password");
            throw new IllegalArgumentException("encodedPassword is null");
        }
        return encodedPassword.equals(rawPassword);
    }
}

JWT工具类

package com.uncle.jwt.util;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.CompressionCodecs;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;

/**
 * @program: spring-security-jwt
 * @description:
 * @author: 步尔斯特
 * @create: 2021-08-08 16:34
 */
public class JwtTokenUtil {
    private static long tokenExpiration = 24 * 60 * 60 * 1000;
    private static String tokenSignKey = "123456";
    private static String userRoleKey = "userRole";

//    public String createToken(String userName) {
//        String token = Jwts.builder().setSubject(userName)
//                .setExpiration(new Date(System.currentTimeMillis() + tokenExpiration))
//                .signWith(SignatureAlgorithm.HS512, tokenSignKey).compressWith(CompressionCodecs.GZIP).compact();
//        return token;
//    }

    public static String createToken(String userName, String role) {
        String token = Jwts.builder().setSubject(userName)
                .claim(userRoleKey, role)
                .setExpiration(new Date(System.currentTimeMillis() + tokenExpiration))
                .signWith(SignatureAlgorithm.HS512, tokenSignKey).compressWith(CompressionCodecs.GZIP).compact();
        return token;
    }

    public static String getUserNameFromToken(String token) {
        String userName = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token).getBody().getSubject();
        return userName;
    }

    public static String getUserRoleFromToken(String token) {
        Claims claims = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token).getBody();
        return claims.get(userRoleKey).toString();
    }

}

响应有关的类

package com.uncle.jwt.util;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * @program: spring-security-jwt
 * @description:
 * @author: 步尔斯特
 * @create: 2021-08-08 15:56
 */
public class ResponseUtil {
    public static void out(HttpServletResponse response, Result result) {
        ObjectMapper mapper = new ObjectMapper();
        PrintWriter writer = null;
        response.setStatus(HttpStatus.OK.value());
        response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
        try {
            writer = response.getWriter();
            mapper.writeValue(writer, result);
            writer.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (writer != null) {
                writer.flush();
                writer.close();
            }
        }
    }
}


package com.uncle.jwt.util;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Data;

import java.io.Serializable;
import java.util.List;

/**
 * @program: spring-security-jwt
 * @description:
 * @author: 步尔斯特
 * @create: 2021-08-08 16:12
 */
@Data
public class Result implements Serializable {

    /**
     * 定义jackson对象
     */
    private static final ObjectMapper MAPPER = new ObjectMapper();

    /**
     * 响应业务状态
     */
    private long status;

    /**
     * 响应消息
     */
    private String msg;
    /**
     * 响应中的数据
     */
    private Object data;

    public static Result build(Long status, String msg, Object data) {
        return new Result(status, msg, data);
    }

    public static Result ok() {
        return new Result(null);
    }

    public static Result ok(Object data) {
        return new Result(data);
    }


    public static Result unAuth() {
        return new Result(ResultCode.UNAUTHORIZED.getCode(), ResultCode.UNAUTHORIZED.getMessage(), "");
    }

    public static Result error() {
        return new Result(ResultCode.FAILED.getCode(), ResultCode.FAILED.getMessage(), null);
    }

    public static Result error(Object msg) {
        return new Result(ResultCode.FAILED.getCode(), ResultCode.FAILED.getMessage(), msg);
    }

    public Result() {
    }

    public static Result build(Integer status, String msg) {
        return new Result(ResultCode.UNAUTHORIZED.getCode(), msg, null);
    }

    public Result(Long status, String msg, Object data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }

    public Result(Object data) {
        this.status = ResultCode.SUCCESS.getCode();
        this.msg = ResultCode.SUCCESS.getMessage();
        this.data = data;
    }

    /**
     * 将json结果集转化为Result对象
     *
     * @param jsonData json数据 传的是Result的对象的Json字符串
     * @param clazz    TaotaoResult中的object类型
     * @return
     */
    public static Result formatToPojo(String jsonData, Class<?> clazz) {
        try {
            if (clazz == null) {
                return MAPPER.readValue(jsonData, Result.class);
            }
            JsonNode jsonNode = MAPPER.readTree(jsonData);
            JsonNode data = jsonNode.get("data");
            Object obj = null;
            if (clazz != null) {
                if (data.isObject()) {
                    obj = MAPPER.readValue(data.traverse(), clazz);
                } else if (data.isTextual()) {
                    obj = MAPPER.readValue(data.asText(), clazz);
                }
            }
            return build((long) jsonNode.get("status").intValue(), jsonNode.get("msg").asText(), obj);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 没有object对象的转化
     *
     * @param json
     * @return
     */
    public static Result format(String json) {
        try {
            return MAPPER.readValue(json, Result.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * Object是集合转化
     *
     * @param jsonData 传的是Result的对象的Json字符串
     *                 json数据
     * @param clazz    集合中的类型
     * @return
     */
    public static Result formatToList(String jsonData, Class<?> clazz) {
        try {
            JsonNode jsonNode = MAPPER.readTree(jsonData);
            JsonNode data = jsonNode.get("data");
            Object obj = null;
            if (data.isArray() && data.size() > 0) {
                obj = MAPPER.readValue(data.traverse(),
                        MAPPER.getTypeFactory().constructCollectionType(List.class, clazz));
            }
            return build((long) jsonNode.get("status").intValue(), jsonNode.get("msg").asText(), obj);
        } catch (Exception e) {
            return null;
        }
    }
}



package com.uncle.jwt.util;

/**
 * @program: spring-security-jwt
 * @description:
 * @author: 步尔斯特
 * @create: 2021-08-08 15:33
 */
public enum ResultCode {
    SUCCESS(200, "操作成功"),
    FAILED(500, "操作失败"),
    VALIDATE_FAILED(404, "参数检验失败"),
    UNAUTHORIZED(401, "暂未登录或token已经过期"),
    FORBIDDEN(403, "没有相关权限");
    private long code;
    private String message;

    private ResultCode(long code, String message) {
        this.code = code;
        this.message = message;
    }

    public long getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }
}

启动类

略…

测试

GET http://localhost:8080/postAuthorize
Accept: application/json
token: eyJhbGciOiJIUzUxMiIsInppcCI6IkdaSVAifQ.H4sIAAAAAAAAAKtWKi5NUrJSykstLc5PK1HSUSotTi0Kys9JBQoG-fu4xju6-Hr66YCZocGuQUAVqRUFSlaGZkYWJhYWBhYGtQAtDsvwRAAAAA.6o-vyj5TmIhh8Q8kDmoBOif203HhvvtVKZrVXERa6osP9dp0zSS9HRG1CP6JGz1DC-tJX2hN_ARCWHAW7egroA

###
GET http://localhost:8080/api/hello
Accept: application/json
Cache-Control: no-cache

###
POST http://localhost:8080/login?username=neusoft&password=neusoft
Accept: */*
Cache-Control: no-cache

###
GET http://localhost:8080/admin
Accept: */*
Cache-Control: no-cache
token: eyJhbGciOiJIUzUxMiIsInppcCI6IkdaSVAifQ.H4sIAAAAAAAAAKtWKi5NUrJSykstLc5PK1HSUSotTi0Kys9JBQoG-fu4xju6-Hr66YCZocGuQUAVqRUFSlaGZkYWJhYWBhYGtQAtDsvwRAAAAA.6o-vyj5TmIhh8Q8kDmoBOif203HhvvtVKZrVXERa6osP9dp0zSS9HRG1CP6JGz1DC-tJX2hN_ARCWHAW7egroA

测试结果

POST http://localhost:8080/login?username=neusoft&password=neusoft

HTTP/1.1 200 
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-Frame-Options: DENY
Content-Type: application/json;charset=UTF-8
Content-Length: 521
Date: Sun, 08 Aug 2021 09:58:51 GMT
Keep-Alive: timeout=60
Connection: keep-alive

{
  "status": 200,
  "msg": "操作成功",
  "data": {
    "loginName": "neusoft",
    "user": {
      "password": null,
      "username": "neusoft",
      "authorities": [
        {
          "authority": "ROLE_ADMIN"
        },
        {
          "authority": "ROLE_USER"
        }
      ],
      "accountNonExpired": true,
      "accountNonLocked": true,
      "credentialsNonExpired": true,
      "enabled": true
    },
    "token": "eyJhbGciOiJIUzUxMiIsInppcCI6IkdaSVAifQ.H4sIAAAAAAAAAKtWKi5NUrJSykstLc5PK1HSUSotTi0Kys9JBQoG-fu4xju6-Hr66YCZocGuQUAVqRUFSlaGZkYWpgbGhsYGtQBhPtZ5RAAAAA.G7XsVdsuWpGqI9Elk9-pwDmRhZExixrcmdZfUP-G2lbVekK6pCP8S519OCv5NBlT8nOGoPr37y_ArHqmtJq6Jg"
  }
}

Response code: 200; Time: 355ms; Content length: 513 bytes


GET http://localhost:8080/hello

HTTP/1.1 200 
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-Frame-Options: DENY
Content-Type: application/json;charset=UTF-8
Content-Length: 57
Date: Sun, 08 Aug 2021 10:01:01 GMT
Keep-Alive: timeout=60
Connection: keep-alive

{
  "status": 500,
  "msg": "操作失败",
  "data": "鉴权失败"
}

Response code: 200; Time: 238ms; Content length: 41 bytes


GET http://localhost:8080/admin

HTTP/1.1 200 
Set-Cookie: JSESSIONID=5D0735B1D787417D2443933A934E8AD1; Path=/; HttpOnly
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-Frame-Options: DENY
Content-Type: text/plain;charset=UTF-8
Content-Length: 8
Date: Sun, 08 Aug 2021 10:01:24 GMT
Keep-Alive: timeout=60
Connection: keep-alive

admin!!!

Response code: 200; Time: 328ms; Content length: 8 bytes

Cookies are preserved between requests:
> /Users/uncle/Downloads/spring-security-jwt/.idea/httpRequests/http-client.cookies
「已注销」
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring security+jwt 实现认证授权
IT_cdc的博客
03-10 5053
目录结构 具体代码 config 配置类 DefaultControllerAdvice.java package com.stu.manage.demo.config; import com.stu.manage.demo.result.Result; import com.stu.manage.demo.result.ResultEnum; import com.stu.manage.demo.result.ResultUtil; import org.springframework.w
Spring Security+JWT实现用户验证与授权
ljrgtdxh_777的博客
04-27 361
在我们项目中涉及不同“角色”，包括游客，普通用户和管理员。游客不需要经过任何验证，可以使用部分功能，如查看系统提供的地图钉。另外两种角色则必须使用正确的账号密码登录，且普通用户不能访问部分管理员才能访问的请求。针对这样的需求，后端需要对三种角色（以及未来可能新增的其他角色）进行分类处理。游客与其他角色的区别在于，因此可以借助网站通用手段“token”加以鉴别：用户若登录则获得一个唯一标识的token，并在之后请求中都携带该token用于验证。而针对普通用户和管理员用户，则需要，用于后续判断。
requests模块-cookies参数的使用
鹅不糊涂的博客
08-07 2643
此外，由于Cookie存储在用户的浏览器中，可能会受到黑客的攻击和利用。通过这个Cookie，服务器能够认出你是之前的访问者，并根据你的个人喜好或登录状态来提供个性化的服务，比如显示你之前浏览过的商品、保持你的登录状态等。当你访问一个网站时，服务器会在你的浏览器中创建一个Cookie，其中包含了一些重要的信息，如你在网站上的活动记录、登录状态等。在打印的输出结果中搜索title，html中的标题文本内容如果是你的github账号，则成功利用headers参数携带cookie，获取登陆后才能访问的页面。
初学springSecurity登入登出404各种失败，在配置上理解的坑
qq28117036的博客
05-14 6939
formLogin()的过滤链的配置 关于登入的配置，有以下几种API loginPage("/loginPage") //自定义的 登入页面，如果不指定，springSecurity就会用自带的很丑的login页面 loginProcessingUrl()// 这是登入处理的跳转url(如果配置，相当于在登入请求中，横切入一个跳转url，也就是从一条完整的登入请求url中间，再加入一个) // 情况1： formLogin().defaultSuccessUrl("/success").failure
JWT工具类
最新发布
qq_62880571的博客
06-02 130
【代码】JWT工具类。
关于使SpringSecurity登录参数使用requestBody后引发的一系列问题及解决
c_z_z的博客
06-12 1031
使用SpringSecurity前后端分离，使登录参数支持RequestBody后，单点登录功能失效，最终通过调试源码找到解决办法
前后端分离项目无法得到Spring Security 认证cookie而导致循环登录问题
weixin_59216829的博客
04-12 1333
那是因为内置的登录页面属于前后端不分离的项目，后端在自家人登录，自然信任自家人给了它通行证，**而在前后端分离项目中，我们是一定会出现跨域问题的！值，也就是说，后端没有给前端颁发认证cookie，导致前端没有获取登录用户的对应cookie，这样就会使每次请求都没有携带这个cookie，就无法做到身份认证，从而导致循环登录。那为什么会导致整个问题呢，明明数据已经发送过去了，并且也登录成功了，为什么会被后端认为是没有登录，这个时候就一定是少了什么，我们再次通过Fiddller抓包看看。
毕设准备---Cookie，Session
Ipkiss Studio
09-01 205
面试题 关于cookie的细节 一个Cookie只能保存一个信息 一个web 站点可以给浏览器发送多个Cookie，最多存放20个Cookie Cookie大小有限制，4kb 浏览器上限，300个Cookie 删除Cookie 不设置有效期，关闭浏览器，自动失效 设置有效期为0 Cookie和Session的区别 Cookie是把用户的数据写给用户的浏览器，浏览器保存（可以保存多个） Session把用户的数据写到用户独占的Session...
解析SpringSecurity+JWT认证流程实现
08-18
SpringSecurity+JWT认证流程实现是认证流程中的一种重要方式，它可以帮助我们实现安全的认证和授权。通过使用SpringSecurity+JWT，我们可以实现基于token的认证方式，以便更好地保护我们的系统。 七、参考资料 * ...
springsecurity+oauth2+jwt实现单点登录demo
06-06
该资源是springsecurity+oauth2+jwt实现的单点登录demo，模式为授权码模式，实现自定义登录页面和自定义授权页面。应用数据存在内存中或者存在数据库中（附带数据库表结构），token存储分为数据库或者Redis。demo...
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证
08-26
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证，可根据注解的格式不同，做到角色权限控制，角色加资源权限控制等，粒度比较细化。 @PreAuthorize("hasAnyRole('ADMIN','USER')")：具有admin或...
Springboot+SpringSecurity+JWT实现用户登录和权限认证示例
08-19
主要介绍了Springboot+SpringSecurity+JWT实现用户登录和权限认证示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Springboot整合Spring security+Oauth2+JWT搭建认证服务器，网关，微服务之间权限认证及授权
04-22
本教程将探讨如何使用Spring Boot结合Spring Security、OAuth2和JWT（JSON Web Token）来搭建一个认证服务器、API网关以及微服务之间的权限认证和授权机制。 首先，Spring Security是Spring框架的一个模块，专门...
requests模块 保存cookies和使用cookies
weixin_46770425的博客
12-02 4286
requests模块 保存cookies和使用cookies。 在会话中保留状态，可以使用request.Session() # 获取cookie url = 'http://www.baidu.com' r = requests.get(url) r.cookies # 将CookieJar转为字典： cookie_dict= requests.utils.dict_from_cookiejar(r.cookies) # 将字典转为CookieJar： cookies = requests.utils
Spring Security+JWT简述
热门推荐
姜守威的博客
06-03 2万+
目录一. 什么是Spring Security1. 登陆校验的流程2. SpringSecurity基础案例二. Spring Security原理流程 一. 什么是Spring Security Spring Security是Spring家族的一个安全管理框架, 相比于另一个安全框架Shiro, 它具有更丰富的功能。一般中大型项目都是使用SpringSecurity做安全框架, 而Shiro上手比较简单 spring security 的核心功能: 认证(你是谁): 只有你的用户名或密码正确才能
Spring Security 超详细整合 JWT，能否拿下看你自己！
08-31 6466
文章目录1.JWT 入门1.1 JWT 概念1.2 JWT 应用场景1.3 为何选择 JWT基于 Session 的传统认证基于 JWT 的认证1.4 JWT 的结构标头（Header）载荷（Payload）签名（Signature）1.5 RBAC (Role-Based Access Control)1.6 JWT 基本使用添加依赖生成 Token解析 Token2.Security 整合 JWT2.1 单独抽离 Security 模块添加相关依赖JWT 工具类JWT 相关配置JWT 登录授权过滤器自定
requests保持cookies的问题
weixin_30325071的博客
03-24 842
获取cookie，返回CookieJar对象：url = 'http://www.baidu.com'r = requests.get(url) r.cookies#将CookieJar转为字典： cookies = requests.utils.dict_from_cookiejar(r.cookies) #将字典转为CookieJar： cookies = requests.ut...
JWT工具类及用法
weixin_43920527的博客
04-24 1万+
jwt工具类及用法
Spring Security+JWT实现
08-20
Spring Security JWT实现是指使用JWT（JSON Web Token）作为身份验证和授权机制的Spring Security解决方案。Spring Security为JWT提供了自动化配置，使得使用JWT进行身份验证和授权变得更加简单和高效。通过配置JwtAuthenticationTokenFilter，可以实现对JWT的验证和解析。同时，可以通过RestfulAccessDeniedHandler和RestAuthenticationEntryPoint来处理登录校验和权限校验的逻辑。使用JWT实现的Spring Security解决方案可以提供更加强大和灵活的身份验证和授权功能。 [2 [3<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [厉害，我带的实习生仅用四步就整合好SpringSecurity+JWT实现登录认证](https://blog.csdn.net/qing_gee/article/details/124016059)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *3* [单点登录SSO解决方案之SpringSecurity+JWT实现.docx](https://download.csdn.net/download/njbaige/34581331)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值