简单的Java的token鉴权架构

已于 2022-07-05 14:46:07 修改
阅读量4.1k 收藏 26
点赞数 4
分类专栏： Javaee 文章标签： java 架构
于 2022-07-04 10:42:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23329167/article/details/125595359
版权

简单的Java的token鉴权架构

总体时序图

在这里插入图片描述

1、登录

服务端校验密码，成功后存储token到redis(失效时间为1天)并返回token给客户端

2、访问API

通过自定义拦截器，拦截所有请求，并对需要鉴权的API做token鉴权逻辑处理，存在改token则通过请求，不存在则需要做刷新token或生成token处理

鉴权流程

在这里插入图片描述

1、创建token

用户传入appid和appkey来生成token，服务端通过appid和appkey来到mysql中查找该用户的接口权限，如果满足访问该接口权限则生成token并存储到redis，失效时间为1天，并返回给客户端

2、查询token

用户通过appid和appkey来查询token，服务端通过appid和appkey来到mysql中查找该用户的接口权限，如果满足访问该接口权限则根据appid到redis中获取当前的token，并返回给客户端

3、注销token

用户通过appid和appkey来查询token，服务端通过appid和appkey来到mysql中查找该用户的接口权限，如果满足访问该接口权限则到redis中删除对应的token信息

代码参考

自定义用户鉴权注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author gk
 * @note 加上该注解的类http请求时需要进行token鉴权
 * @date 2021/9/16 10:14
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface AuthToken {
}

创建、查询、注销接口

import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

/**
 * @author gk
 * @note token的controller
 * @date 2021/6/26 11:14
 */
@RestController
@RequestMapping(value = "/usr/token", produces = "application/json; charset=utf-8")
public class TokenChargingController {

    private final TokenService tokenService;
    public TokenChargingController(TokenService tokenService) {
        this.tokenService = tokenService;
    }

    /**
     * 生成我们自己的token
     * @return
     */
    @RequestMapping(value = "/create_token", method = RequestMethod.GET)
    @ApiOperation(value = "生成token", notes = "生成token值")
    public Object createToken(
            HttpServletRequest request,
            @ApiParam(name = "appid", value = "appid", required = true) @RequestHeader(value = "appid") String appid,
            @ApiParam(name = "appkey", value = "appkey", required = true) @RequestHeader(value = "appkey") String appkey) {
        Map<String, Object> resultMap = new HashMap<>();
        CacheService cacheService = = null;
        try {
            cacheService = new JedisPoolUtils();
            // 初始化：URI、URL、addr
            String uri = request.getRequestURI();
            resultMap.put("AppId", appid);
            resultMap.put("AppKey", appkey);

            // 查询用户权限是否有效：appid、appkey、uri
            ApiUserUriMapping apiUserUriMapping = this.tokenService.getApiUserUriMapping(appid, appkey, uri);
            if (apiUserUriMapping == null) {
                resultMap.put("StatusCode", CommonEnum.SIGNATURE_NOT_MATCH.getResultCode());
                resultMap.put("AccessToken", "");
                resultMap.put("TokenAvailableTime", "");
                resultMap.put("Msg", CommonEnum.SIGNATURE_NOT_MATCH.getResultMsg());
            } else {
                // 创建token
                String token = this.tokenService.createToken(cacheService, appid, appkey);
                resultMap.put("StatusCode", CommonEnum.SUCCESS.getResultCode());
                resultMap.put("AccessToken", token);
                resultMap.put("TokenAvailableTime", cacheService.ttl(token, RedisDbConstant.DB_10) + "");
                resultMap.put("Msg", CommonEnum.SUCCESS.getResultMsg());
            }
        } catch (Exception e) {
            resultMap.put("StatusCode", CommonEnum.INTERNAL_SERVER_ERROR.getResultCode());
            resultMap.put("AccessToken", "");
            resultMap.put("TokenAvailableTime", "");
            resultMap.put("Msg", CommonEnum.INTERNAL_SERVER_ERROR.getResultMsg());
        } finally {
            if (Objects.nonNull(cacheService))
                cacheService.destroy();
        }
        return resultMap;
    }

    /**
     * 查询token
     * @return
     */
    @RequestMapping(value = "/query_token", method = RequestMethod.GET)
    @ApiOperation(value = "获取token", notes = "获取token值")
    public Object queryToken(
            HttpServletRequest request,
            @ApiParam(name = "appid", value = "appid", required = true) @RequestHeader(value = "appid") String appid,
            @ApiParam(name = "appkey", value = "appkey", required = true) @RequestHeader(value = "appkey") String appkey) {
        Map<String, Object> resultMap = new HashMap<>();
        CacheService cacheService = null;
        try {
            cacheService = new JedisPoolUtils();
            // 初始化：URI、URL、addr
            String uri = request.getRequestURI();
            resultMap.put("AppId", appid);
            resultMap.put("AppKey", appkey);

            // 查询用户权限是否有效：appid、appkey、uri
            ApiUserUriMapping apiUserUriMapping = this.tokenService.getApiUserUriMapping(appid, appkey, uri);
            if (apiUserUriMapping == null) {
                resultMap.put("StatusCode", CommonEnum.SIGNATURE_NOT_MATCH.getResultCode());
                resultMap.put("AccessToken", "");
                resultMap.put("TokenAvailableTime", "");
                resultMap.put("Msg", CommonEnum.SIGNATURE_NOT_MATCH.getResultMsg());
            } else {
                // 查询token
                String token = this.tokenService.queryToken(cacheService, appid);
                resultMap.put("StatusCode", CommonEnum.SUCCESS.getResultCode());
                resultMap.put("AccessToken", token);
                resultMap.put("TokenAvailableTime", cacheService.ttl(token, RedisDbConstant.DB_10) + "");
                resultMap.put("Msg", CommonEnum.SUCCESS.getResultMsg());
            }
        } catch (Exception e) {
            resultMap.put("StatusCode", CommonEnum.INTERNAL_SERVER_ERROR.getResultCode());
            resultMap.put("AccessToken", "");
            resultMap.put("TokenAvailableTime", "");
            resultMap.put("Msg", CommonEnum.INTERNAL_SERVER_ERROR.getResultMsg());
        } finally {
            if (Objects.nonNull(cacheService))
                cacheService.destroy();
        }
        return resultMap;
    }
    
    @RequestMapping(value = "/logout_user", method = RequestMethod.GET)
    @ApiOperation(value = "用户注销", notes = "用户注销")
    public Object logoutUser(
            HttpServletRequest request,
            @ApiParam(name = "appid", value = "appid", required = true) @RequestHeader(value = "appid") String appid,
            @ApiParam(name = "appkey", value = "appkey", required = true) @RequestHeader(value = "appkey") String appkey) {
        Map<String, Object> resultMap = new HashMap<>();
        CacheService cacheService = null;
        try {
            cacheService = new JedisPoolUtils();
            // 初始化：URI、URL、addr
            String uri = request.getRequestURI();
            resultMap.put("AppId", appid);
            resultMap.put("AppKey", appkey);

            // 查询用户权限是否有效：appid、appkey、uri
            ApiUserUriMapping apiUserUriMapping = this.tokenService.getApiUserUriMapping(appid, appkey, uri);
            if (apiUserUriMapping == null) {
                resultMap.put("StatusCode", CommonEnum.SIGNATURE_NOT_MATCH.getResultCode());
                resultMap.put("AccessToken", "");
                resultMap.put("TokenAvailableTime", "");
                resultMap.put("Msg", CommonEnum.SIGNATURE_NOT_MATCH.getResultMsg());
            } else {
                // 创建token
                boolean isSuccess = this.tokenService.logoutUser(cacheService, appid);
                resultMap.put("StatusCode", isSuccess ? CommonEnum.SUCCESS.getResultCode() : CommonEnum.INTERNAL_SERVER_ERROR.getResultCode());
                resultMap.put("AccessToken", "");
                resultMap.put("TokenAvailableTime", "");
                resultMap.put("Msg", isSuccess ? CommonEnum.SUCCESS.getResultMsg() : CommonEnum.INTERNAL_SERVER_ERROR.getResultMsg());
            }
        } catch (Exception e) {
            resultMap.put("StatusCode", CommonEnum.INTERNAL_SERVER_ERROR.getResultCode());
            resultMap.put("AccessToken", "");
            resultMap.put("TokenAvailableTime", "");
            resultMap.put("Msg", CommonEnum.INTERNAL_SERVER_ERROR.getResultMsg());
        } finally {
            if (Objects.nonNull(cacheService))
                cacheService.destroy();
        }
        return resultMap;
    }
}

接口服务及实现类

public interface TokenService {

    /**
     * 权限验证：查询用户的接口访问权限信息
     *
     * @param appid  用户ID
     * @param appkey 用户KEY
     * @param uri    请求路径URI
     * @return ApiUserUriMapping
     */
    ApiUserUriMapping getApiUserUriMapping(
            String appid,
            String appkey,
            String uri);

    /**
     * 创建token
     *
     * @param appid
     * @param appkey
     * @return token
     */
    String createToken(CacheService cacheService, String appid, String appkey) throws Exception;

    /**
     * 查询token
     *
     * @param appid
     * @return token
     */
    String queryToken(CacheService cacheService, String appid) throws Exception;


    /**
     * 查询token
     *
     * @param appid
     * @return token
     */
    boolean logoutUser(CacheService cacheService, String appid) throws Exception;
}

@Service
public class TokenServiceImpl implements TokenService {

    private final VBApiUserUriMappingMapper vbApiUserUriMappingMapper;
    @Autowired
    public ApiUserUriMappingServiceImpl(
            VBApiUserUriMappingMapper vbApiUserUriMappingMapper) {
        this.vbApiUserUriMappingMapper = vbApiUserUriMappingMapper;
    }

    @Override
    public ApiUserUriMapping getApiUserUriMapping(String appid, String appkey, String uri) {
        List<Map> lists = this.getVBApiUserUriMappingByMap(
                new HashMap<String, String>() {
                    {
                        put("appid", appid);
                        put("appkey", appkey);
                        put("uri", uri);
                    }
                }
        );
        return CollectionUtils.isEmpty(lists) ?
                null : JSONObject.parseObject(JSONObject.toJSONString(lists.get(0)), ApiUserUriMapping.class);
    }

    @Override
    public String createToken(CacheService cacheService, String user, String key) throws Exception {
        String token = "";
        Random random = new Random();
        double v = random.nextDouble();
        //获取当前时间时间
        String currentDate = DateUtils.getCurrentDate("yyyy-MM-dd HH:mm:ss");
        String md = user + "+" + key + "#" + currentDate + "%" + v + "@";
        //md5加密
        String mdToken = Md5Util.MD5(md);
        //MD5二次加密
        token = Md5Util.MD5(mdToken);

        //删除老的token
        String oldToken = cacheService.get(TokenConstant.CURRENT_TOKEN_PREFIX + user, RedisDbConstant.DB_10);
        if (StringUtils.isNotBlank(oldToken))
            cacheService.del(oldToken, RedisDbConstant.DB_10);

        //更新redis
        cacheService.hset(token, UserFieldConstant.APP_ID, user, RedisDbConstant.DB_10);
        cacheService.hset(token, UserFieldConstant.APP_KEY, key, RedisDbConstant.DB_10);
        cacheService.hset(token, UserFieldConstant.TOKEN, token, RedisDbConstant.DB_10);
        cacheService.hset(token, UserFieldConstant.UPDATE_TIME, currentDate, RedisDbConstant.DB_10);
        //设置失效时间
        cacheService.expire(token, TokenConstant.ONE_DAY, RedisDbConstant.DB_10);
        //设置当前用户使用的token
        cacheService.set(TokenConstant.ONE_DAY, TokenConstant.CURRENT_TOKEN_PREFIX + user, token, RedisDbConstant.DB_10);
        return token;
    }

    @Override
    public String queryToken(CacheService cacheService, String appid) throws Exception {
        String token = "";
        String redisKey = TokenConstant.CURRENT_TOKEN_PREFIX + appid;
        if (cacheService.exists(redisKey, RedisDbConstant.DB_10))
            token = cacheService.get(redisKey, RedisDbConstant.DB_10);
        return token;
    }

    @Override
    public boolean logoutUser(CacheService cacheService, String appid) throws Exception {
        boolean isLogout = false;
        String redisKey = TokenConstant.CURRENT_TOKEN_PREFIX + appid;
        if (cacheService.exists(redisKey, RedisDbConstant.DB_10))
            cacheService.del(redisKey, RedisDbConstant.DB_10);
        isLogout = true;
        return isLogout ;
    }

    private List<Map> getVBApiUserUriMappingByMap(Map map) {
        return this.vbApiUserUriMappingMapper.getAllByParam(
                ObjectUtils.isEmpty(map.get("id")) ? null : map.get("id").toString(),
                ObjectUtils.isEmpty(map.get("appid")) ? null : map.get("appid").toString(),
                ObjectUtils.isEmpty(map.get("appkey")) ? null : map.get("appkey").toString(),
                ObjectUtils.isEmpty(map.get("userType")) ? null : map.get("userType").toString(),
                ObjectUtils.isEmpty(map.get("userName")) ? null : map.get("userName").toString(),
                ObjectUtils.isEmpty(map.get("userUnit")) ? null : map.get("userUnit").toString(),
                ObjectUtils.isEmpty(map.get("phone")) ? null : map.get("phone").toString(),
                ObjectUtils.isEmpty(map.get("createTime")) ? null : map.get("createTime").toString(),
                ObjectUtils.isEmpty(map.get("updTime")) ? null : map.get("updTime").toString(),
                ObjectUtils.isEmpty(map.get("beginTime")) ? null : map.get("beginTime").toString(),
                ObjectUtils.isEmpty(map.get("endTime")) ? null : map.get("endTime").toString(),
                ObjectUtils.isEmpty(map.get("accessIpList")) ? null : map.get("accessIpList").toString(),
                ObjectUtils.isEmpty(map.get("uri")) ? null : map.get("uri").toString(),
                ObjectUtils.isEmpty(map.get("uriUserConfig")) ? null : map.get("uriUserConfig").toString(),
                ObjectUtils.isEmpty(map.get("formatCls")) ? null : map.get("formatCls").toString(),
                ObjectUtils.isEmpty(map.get("opType")) ? null : map.get("opType").toString());
    }
}

自定义登录拦截器

/**
 * @author gk
 * @note 登陆过滤器
 * @date 2021/09/16 11:14
 */
@Component
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {

    @Autowired
    private ApiUserUriService apiUserUriService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();

        // 如果打上了AuthToken注解则需要验证token
        if (method.getAnnotation(AuthToken.class) != null || handlerMethod.getBeanType().getAnnotation(AuthToken.class) != null) {

            CacheService cacheService = new JedisPoolUtils();
            try {
                //从header中拿token，并进行解析
                String token = request.getHeader(TokenConstant.TOKEN);

                if (StringUtils.isBlank(token)) {
                    reSetResponse(response, CommonEnum.SIGNATURE_NOT_MATCH);
                    return false;
                }
                if (!cacheService.exists(token, RedisDbConstant.DB_10)) {
                    reSetResponse(response, CommonEnum.NO_USER);
                    return false;
                }
                String uri = request.getRequestURI();

                String appid = cacheService.hget(token, UserFieldConstant.APP_ID, RedisDbConstant.DB_10);
                String appkey = cacheService.hget(token, UserFieldConstant.APP_KEY, RedisDbConstant.DB_10);

                if (StringUtils.isBlank(appid) || StringUtils.isBlank(appkey)) {
                    reSetResponse(response, CommonEnum.NOT_PERMISSION);
                    return false;
                }

                // 查询用户权限是否有效：appid、appkey、uri
                ApiUserUriMapping apiUserUriMapping = this.apiUserUriService.getApiUserUriMapping(appid, appkey, uri);
                if (Objects.isNull(apiUserUriMapping)) {
                    reSetResponse(response, CommonEnum.NOT_PERMISSION);
                    return false;
                }

                //dataRange|appid|appkey
                String dataRange = apiUserUriMapping.getUriUserConfig();
                Map<String, String> key = new HashMap<>();
                key.put("dataRange", dataRange);
                key.put("appid", appid);
                key.put("appkey", appkey);
                key.put("token", token);
                key.put("className", apiUserUriMapping.getFormatCls());
                request.setAttribute(TokenConstant.REQUEST_CURRENT_KEY, key);
            } catch (Exception e) {
                e.printStackTrace();
                reSetResponse(response, CommonEnum.INTERNAL_SERVER_ERROR);
                return false;
            } finally {
                cacheService.destroy();
            }

            return true;
        }

        if (StringUtils.isNotBlank(request.getRequestURI()) && request.getRequestURI().endsWith("/v2/api-docs")) {
            //swagger自带的api-docs
            // 查询用户权限是否有效：appid、appkey、uri
            String appid = request.getHeader("appid");
            String appkey = request.getHeader("appkey");
            if (StringUtils.isBlank(appid) || StringUtils.isBlank(appkey)) {
                reSetResponse(response, CommonEnum.SIGNATURE_NOT_MATCH);
                return false;
            }

            // 查询用户权限是否有效：appid、appkey、uri
            ApiUserUriMapping mapping = this.apiUserUriService.getApiUserUriMapping(appid, appkey, request.getRequestURI());
            if (Objects.isNull(mapping)) {
                reSetResponse(response, CommonEnum.NOT_PERMISSION);
                return false;
            }

        }
        request.setAttribute(TokenConstant.REQUEST_CURRENT_KEY, null);

        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
    }

    /**
     * 登录拦截 重置响应数据
     *
     * @param response
     */
    private void reSetResponse(HttpServletResponse response, CommonEnum commonEnum) {
        PrintWriter pw = null;
        try {
            response.reset();
            response.setContentType("application/json;charset=UTF-8");
            ServiceResult serviceResult = new ServiceResult(commonEnum.getResultCode(), commonEnum.getResultMsg());
            serviceResult.insertResult(null);
            pw = response.getWriter();
            pw.write(JSONObject.toJSONString(serviceResult));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (pw != null) {
                pw.flush();
                pw.close();
            }
        }
    }
}

配置类配置

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

/**
 * @author gk
 * @note 配置类
 * @date 2021/7/20 11:14
 */
@Configuration
public class WebConfigurer implements WebMvcConfigurer {

    @Resource
    private LoginInterceptor loginInterceptor;

    //注册登录拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor).addPathPatterns("/**");//添加所需要拦截的接口，这里我们拦截所有,但是
//                .excludePathPatterns("/**/evcs/v1/query_token/**"); //不拦截登陆和退出请求
    }

    //页面跳转
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
    }

    //配置静态资源
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
    }
}

调用方法

在接口方法上使用@AuthToken该注解

Demon_gu
关注
  • 4
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于springboot+oauth2.0+jwtToken鉴权认证开发的后台接口，整套架构采用restful风格，车牌识别，阿里云消息推送，短信接口等
04-04
内容只为接口开发，配合前端和移动app调用使用，不包含html页面，基于springboot+oauth2.0+jwttoken鉴权（内有怎么使用redistoken和数据库token注释）+restful风格+阿里短信+阿里消息推送+车牌识别等。该项目为工作...
API市场网关鉴权java
11-16
6. **API Key鉴权**：API Key是最简单的鉴权方式，每个客户端拥有唯一的API Key，每次请求都需携带此Key，网关通过验证Key的合法性决定是否放行。 7. **高并发处理**：在Java高并发环境下，API网关需要设计合理的...
java 对外第三方接口鉴权
迷迷糊糊，懵懵懂懂
12-28 1179
在Java中，对外提供第三方接口鉴权通常涉及使用令牌（Token）或API密钥（API Key）等方式来确保请求的合法性。以下是一个简单的基于令牌的鉴权示例，你可以根据实际情况进行修改和扩展。
学习笔记（二）：Token鉴权实现
qq_49111986的博客
03-31 1467
上次总结了有关Token鉴权的理论知识，本次内容学习了将jwt、shiro、redis整合，实现token的自动刷新和可控性。
Java中的Token
最新发布
m0_65732083的博客
06-12 951
Token是服务端生成的一串字符串，以作客户端进行请求的一个令牌，当第一次登录后，服务器生成一个Token便将此Token返回给客户端，以后客户端只需带上这个Token前来请求数据即可，无需再次带上用户名和密码。基于 Token 的身份验证使用基于 Token 的身份验证方法，在服务端不需要存储用户的登录记录。流程是这样的：客户端使用用户名跟密码请求登录服务端收到请求，去验证用户名与密码验证成功后，服务端会签发一个 Token，再把这个 Token 发送给客户端。
接口测试中的Token鉴权（Postman中Token的获取和引用）
热门推荐
weixin_44901808的博客
08-25 1万+
Token的获取和引用
Java应用程序 身份认证与授权机制(三)
xhh198781的专栏
10-09 2125
授权概述 了解 Java 平台如何实现授权的访问控制对于了解我们将在本章中讨论的概念很重要。Java 平台使用访问控制环境（access control context）的概念来确定当前执行线程的权限。从概念上讲，可以将它视作与每个执行线程连接的令牌。在 JAAS 之前
http（三）接口动态鉴权
w_t_y_y的博客
05-26 7359
一、问题说明：接口如果是被同一个项目的前端项目调用，一般都是加了各种鉴权的，比如springsercurity+token安全机制，shiro 等框架都可以控制接口访问权限。但是如果接口是提供给外部调用，肯定是不需要登录的，所以需要在自身的权限控制中放开 该接口的token校验，这样就会造成安全问题，我们一般采取拦截器的方式，和第三方做个鉴权； 二、鉴权方法： 鉴权采用固定参数同样存在安全问题，容易被抓包获取到。所以一般带入动态的时间戳来鉴权，常用的鉴权逻辑是：...
Java语言搭建接口自动化框架学习八（鉴权）
Keep_Learn2020的博客
12-01 585
鉴权3种常见的鉴权方式HttpUtils类修改抽取请求头和返回响应body新建EnvUtils类用来保存环境变量case类修改 3种常见的鉴权方式 1、cookie 2、session 3、token 3者的原理和区别需要查询网络资料好好理解下 HttpUtils类修改抽取请求头和返回响应body 前面的注册和登录接口都是不需要有鉴权信息就可以完成的接口测试，但是想充值、投资等需要有对应用户登录成功前提下才能测试的接口，就需要考虑鉴权的处理。 示例背景以token为例子，token生成在登录响应报文中，以及
Java基础11-访问权限和静态的总结
weixin_44224089的博客
01-15 461
1.Java中访问权限分为四种，控制范围不同，即： public （公共的）、protected（受保护的）、 default（默认的）（一般默认，使用的不多，写的也不多）、 private（私有的）。 使用权限能够更好的管理数据， 或者这样理解 可以这样理解数据，public是朋友圈的红包，各个朋友圈（不同包）都可以用；protected是家庭基金，只能家里面用（同包）； ...
Sa-Token:这可能是史上功能最全的Java权限认证框架！目前已集成——登录认证、权限认证、分布式Session会话、微服务网关鉴权、单点登录、OAuth2.0、踢人下线、Redis集成、前后台分离、记住我模式、模拟他人账号、临时身份切换、账号封禁、多账号认证体系、注解式鉴权、路由拦截式鉴权、花式token生成、自动续签、同端互斥登录、会话治理、密码加密、jwt集成、Spring集成、WebFlux集成..
07-23
在线资料Sa-Token 介绍Sa-Token是一个轻量级Java权限认证框架，主要解决：登录认证、权限认证、Session会话、单点登录、OAuth2.0、微服务网关鉴权 等一系列权限相关问题框架集成简单、开箱即用、API设计清爽，通过Sa...
跨域实现用户鉴权
06-13
(需要BASS和console)
Sa-Token v1.36.0一个轻量级 Java 权限认证框架，让鉴权变得简单、优雅！
10-14
Sa-Token是一个针对Java平台设计的轻量级权限认证框架，它的主要目标是简化应用中的鉴权流程，使其更加简洁、优雅。框架提供了丰富的功能，适用于各种类型的Web应用开发，包括传统的MVC模式、RESTful API接口以及...
sa-token-dev.zip
05-27
综上，"sa-token-dev.zip" 是一个为 Java 开发者提供的强大鉴权框架，涵盖了登录认证、权限控制、分布式会话管理等多个核心功能，特别适用于微服务架构和大型分布式系统的安全建设。通过深入研究和使用，开发者可以...
接口鉴权实践
hxj413977035的博客
12-03 6173
我们知道，做为一个web系统，少不了要调用别的系统的接口或者是提供接口供别的系统调用。从接口的使用范围也可以分为对内和对外两种，对内的接口主要限于一些我们内部系统的调用，多是通过内网进行调用，往往不用考虑太复杂的鉴权操作。但是，对于对外的接口，我们就不得不重视这个问题，外部接口没有做鉴权的操作就直接发布到互联网无疑是 而这不仅有暴露数据的风险，同时还有数据被篡改的分享，严重的甚至是影响到系统的正常运转！ 接下来，我将结合实际代码，分享一套接口鉴权实践方法。 方案一 appId和secret 接口鉴权？那还
字节API鉴权方法
栗少的博客
08-03 1020
https://www.volcengine.com/docs/6561/107789
是一个轻量级 Java 权限认证框架
zollty的专栏
12-31 260
浪费凯迪拉克发的健康是福会计法对方离开打过来了。发快递带过来大概恐龙快打过啦。司法局开卷考试附加费手机卡。当升科技附属金卡就开始放。反馈李老师发来看看理发。额外婆哦瓶装水理发卡。代付款伶仃孤苦老大哥，东莞科罗拉多管理多个。放得开劳动工具都感觉。首付款浪费时间开始。带过来刚看到连连看，
JAVA认证鉴权安全框架【JustAuthPlus】（一篇足已）
王大师企业官方博客
06-24 976
学习目标（附超链接传送门） 1、掌握 JAVA入门到进阶知识(持续写作中……） 2、学会Oracle数据库用法(创作中……） 3、手把手教你vbs脚本制作(完善中……） 4、牛逼哄哄的 IDEA编程利器(编写中……） 5、吐血整理的 面试技巧(更新中……） 面试题[技巧]  第一章：日常_JAVA_面试题集1（含答案）  第二章：日常_JAVA_面试题集2（含答案）  第三章：日常_JAVA_面试题集3（含答案）  第四章：日常_JAVA_面试题集4（含答案） 前言 世上无难事！冲冲冲！！！2021
这可能是史上功能最全的 Java 权限认证框架！
code小生
07-14 392
微信搜索逆锋起笔关注后回复编程pdf领取编程大佬们所推荐的 23 种编程资料！ 大家好，今天给大家推荐的这个开源项目超级棒，可能是史上功能最全的 Java 权限认证框架！这个开源项目就是...
1. token鉴权和session鉴权区别
06-11
Token鉴权和Session鉴权是两种常用的身份验证方式。 Token鉴权是一种轻量级的身份验证方式，通常用于Web API的身份验证，其工作方式为：客户端在登录后，服务器返回一个包含用户身份信息的token。客户端在后续请求中将该token附加在请求头或请求体中，服务器接收到请求后，通过对token的解析验证用户身份。该方式的优点是减轻了服务器的负担，可以跨域使用，但缺点是token一旦泄露，攻击者可以使用该token来模拟合法用户进行操作。 Session鉴权是一种传统的身份验证方式，通常用于Web应用程序的身份验证，其工作方式为：用户在登录后，服务器在后端创建一个session并返回一个sessionid给客户端，客户端在后续请求中将该sessionid附加在请求头或请求体中，服务器通过对sessionid的验证判断用户身份。该方式的优点是安全性较高，用户的状态信息可以保存在session中，但缺点是需要在服务器端存储session信息，会增加服务器的负担，并且无法跨域使用。 因此，Token鉴权和Session鉴权各有优缺点，根据实际应用场景和需求选择适当的身份验证方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值