精华内容
下载资源
问答
  • Springboot token令牌验证解决方案 在SpringBoot实现基于Token的用户身份验证

    Springboot token令牌验证解决方案 在SpringBoot实现基于Token的用户身份验证

    参考文章:

    (1)Springboot token令牌验证解决方案 在SpringBoot实现基于Token的用户身份验证

    (2)https://www.cnblogs.com/ChromeT/p/10932202.html


    备忘一下。


    展开全文
  • springboot token拦截验证

    2019-09-03 17:06:18
    网上去查了半天,都不完整,所以这里做了... // 不验证URL anon:不验证/authc:受控制的 这里写放过的请求接口 public static final String[] NO_INTERCEPTOR_PATH ={"/yb/register","/yb/validateMobile"}; }

    网上去查了半天,都不完整,所以这里做了一个初级版本。具体参照谁的给忘记了 ,

    1.写下拦截器

    
    
    @Component
    
    public class LoginInterceptor extends HandlerInterceptorAdapter {
        /**
         * 在请求处理之前进行调用(Controller方法调用之前)
         * 基于URL实现的拦截器
         * @param request
         * @param response
         * @param handler
         * @return
         * @throws Exception
         */
         //这个是redis相关的,没用redis的看下思路就可以了。 
        @Autowired
        RedisCacheManagerImpl redisCacheManager;
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            String path = request.getServletPath();
            System.out.println("path---------"+path);
            boolean f= Arrays.asList(AdapterConst.NO_INTERCEPTOR_PATH).contains(path);
            //得到入参
    
            if (f) {
                //不需要的拦截直接过
                return true;
            } else {
                // 获取到token
    
                String token=request.getHeader("token");
                System.out.println("token----------------------"+token);
                UserPO userPO= redisCacheManager.get(token, UserPO.class);
                if(userPO==null){
                //redis中没有用户信息,返回给前台消息,
                    JsonToResponse.objectToResponse("", DateUtil.format(new Date(), Const.TIME_STYLE),
                            new AjaxJson(AjaxJson.FAILED, "999", null, Constants.M_210080001), response, request);
                    return false;
                }
                else{
                    //重置100000S后过期
                   redisCacheManager.set(token,userPO,100000);
                }
            return  true;
            }
        }
    }
    

    2.实现WebMvcConfigurer 不弄这个不生效。

    
    /**
     * 和springmvc的webmvc拦截配置一样
     * @author BIANP
     */
    @Configuration
    public class WebConfigurer implements WebMvcConfigurer {
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            // 拦截所有请求,通过判断是否有 @LoginRequired 注解 决定是否需要登录
            registry.addInterceptor(LoginInterceptor()).addPathPatterns("/**");
        }
    
        @Bean
        public LoginInterceptor LoginInterceptor() {
            return new LoginInterceptor();
        }
    }
    

    3.需要放过的请求

    package com.ccblife.yb.support.bean.cons.adapter;
    
    public class AdapterConst {
    
        public static final String SUCCESS = "SUCCESS";
        public static final String ERROR = "ERROR";
        public static final String FIALL = "FIALL";
        /**********************对象和个体****************************/
        public static final String SESSION_USER = "loginedAgent"; // 用户对象
        public static final String SESSION_LOGINID = "sessionLoginID"; // 登录ID
        public static final String SESSION_USERID = "sessionUserID"; // 当前用户对象ID编号
    
        public static final String SESSION_USERNAME = "sessionUserName"; // 当前用户对象ID编号
        public static final Integer PAGE = 10; // 默认分页数
        public static final String SESSION_URL = "sessionUrl"; // 被记录的url
        public static final String SESSION_SECURITY_CODE = "sessionVerifyCode"; // 登录页验证码
        // 时间 缓存时间
        public static final int TIMEOUT = 1800;// 秒
        // 不验证URL anon:不验证/authc:受控制的  这里写放过的请求接口
        public static final String[] NO_INTERCEPTOR_PATH ={"/yb/register","/yb/validateMobile"};
    
    }
    
    
    展开全文
  • SpringBoot Token 登录验证机制图解

    千次阅读 2018-09-04 12:19:58
    登录验证机制图解

    登录验证机制图解

    展开全文
  • SpringBoot集成token验证

    2019-12-30 22:59:18
    下面我们说一下SpringBoot如何集成token验证 1、向pom文件引入依赖 <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version&g...

    下面我们说一下SpringBoot如何集成token验证

    1、向pom文件引入依赖

     		<dependency>
                <groupId>com.auth0</groupId>
                <artifactId>java-jwt</artifactId>
                <version>3.2.0</version>
            </dependency>
            <dependency>
                <groupId>io.jsonwebtoken</groupId>
                <artifactId>jjwt</artifactId>
                <version>0.9.0</version>
            </dependency>
    

    2、工具类编写

    package com.pro.work.sweet.utils;
    
    
    import com.alibaba.fastjson.JSON;
    import com.pro.work.sweet.entity.TokenInfo;
    import com.pro.work.sweet.entity.User;
    import io.jsonwebtoken.Claims;
    import io.jsonwebtoken.JwtBuilder;
    import io.jsonwebtoken.Jwts;
    import io.jsonwebtoken.SignatureAlgorithm;
    import lombok.SneakyThrows;
    import org.springframework.beans.factory.annotation.Autowired;
    import javax.crypto.spec.SecretKeySpec;
    import javax.xml.bind.DatatypeConverter;
    import java.security.Key;
    import java.util.Date;
    
    public class TokenUtil {
        @Autowired
        private RedisUtil redisUtil ;
        /**
         * 签名秘钥,可以换成 秘钥 注入
         */
        public static final String SECRET = "test";//注意:本参数需要长一点,不然后面剪切的时候很可能长度为0,就会报错
        /**
         * 签发地
         */
        public static final String issuer = "com.pro.work.sweet";
        /**
         * 过期时间
         */
        public static final long ttlMillis = 3600*1000*60;
    
        /**
         * 生成token
         *
         * @return
         */
        public static String createJwtToken(String subject,User user) {
            return createJwtToken( issuer, subject, ttlMillis,user);
        }
        public static String createJwtToken(User user) {
            return createJwtToken( issuer, "", ttlMillis,user);
        }
    
        /**
         * 生成Token
         * @param issuer  该JWT的签发者,是否使用是可选的
         * @param subject  该JWT所面向的用户,是否使用是可选的;
         * @param ttlMillis 签发时间 (有效时间,过期会报错)
         * @return token String
         */
        public static String createJwtToken(String issuer, String subject, long ttlMillis,User user) {
    
            // 签名算法 ,将对token进行签名
            SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
    
            // 生成签发时间
            long nowMillis = System.currentTimeMillis();
            Date now = new Date(nowMillis);
    
            // 通过秘钥签名JWT
            byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(SECRET);
            String str=signatureAlgorithm.getJcaName();
            Key signingKey = new SecretKeySpec(apiKeySecretBytes, str);
    
            // 让我们设置JWT声明
            if(null != user){
                JwtBuilder builder = Jwts.builder().setId(user.getIntId())
                        .setIssuedAt(now)
                        .setSubject(subject)
                        .setIssuer(issuer)
                        .signWith(signatureAlgorithm, signingKey);
                // if it has been specified, let's add the expiration
                if (ttlMillis >= 0) {
                    //过期时间
                    long expMillis = nowMillis + ttlMillis;
                    Date exp = new Date(expMillis);
                    builder.setExpiration(exp);
                }
    
                // 构建JWT并将其序列化为一个紧凑的url安全字符串
                return builder.compact();
            }else{
                return null ;
            }
        }
    
        /**
         * Token解析方法
         * @param jwt Token
         * @return
         */
        public static Claims parseJWT(String jwt) {
            // 如果这行代码不是签名的JWS(如预期),那么它将抛出异常
            Claims claims  = Jwts.parser()
                        .setSigningKey(DatatypeConverter.parseBase64Binary(SECRET))
                        .parseClaimsJws(jwt).getBody();
            return claims;
        }
    
        @SneakyThrows
        public void checkTokenIsLev(String token){
            Claims claims = parseJWT(token) ;
            if(!token.equals(JSON.parseObject(String.valueOf(redisUtil.get(claims.getId())), TokenInfo.class).getToken())){
                throw new Exception("您已离线,请重新登录") ;
            }
        }
    
    }
    

    我的 token工具类主要是契合redis进行登录验证,所以契合了user这个对象进来,大家使用的时候如果不必要的话可以去掉,并不难

    下面是我写的controller验证类,需要的可以看一下,不过我建议还是按自己的逻辑写好一些

    package com.pro.work.sweet.controller;
    
    import com.alibaba.fastjson.JSON;
    import com.pro.work.sweet.entity.TokenInfo;
    import com.pro.work.sweet.entity.User;
    import com.pro.work.sweet.service.UserService;
    import com.pro.work.sweet.utils.RedisUtil;
    import com.pro.work.sweet.utils.ResponseMessage;
    import com.pro.work.sweet.utils.TokenUtil;
    import lombok.SneakyThrows;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.web.bind.annotation.*;
    
    import javax.annotation.Resource;
    
    @RestController
    @RequestMapping("/token")
    public class TokenController {
        @Autowired
        private UserService userService ;
        @Autowired
        private RedisUtil redisUtil ;
        @SneakyThrows
        @PostMapping("/login")
        public ResponseMessage loginAndSetToken(@RequestBody User user){
            User loginUser = userService.login(user) ;
            TokenInfo tokenInfo = new TokenInfo() ;
            try {
                tokenInfo.setToken(TokenUtil.createJwtToken(loginUser));
            }catch (Exception e){
                throw new Exception("生成token失败,请重新登录") ;
            }
            tokenInfo.setUser(loginUser);
            // 向redis中存储用户信息和对应的Token
            redisUtil.set(loginUser.getIntId(),JSON.toJSONString(tokenInfo),3600*1000*60) ;
            return ResponseMessage.success(tokenInfo) ;
        }
    
        @SneakyThrows
        @PostMapping("/checkToken")
        public ResponseMessage checkToken(@RequestBody TokenInfo tokenInfo){
            TokenInfo tokenInfoForRedis = JSON.parseObject(String.valueOf(redisUtil.get(TokenUtil.parseJWT(tokenInfo.getToken()).getId())),TokenInfo.class) ;
            TokenInfo tokens = new TokenInfo() ;
            if(tokenInfoForRedis != null){
                tokens.setUser(tokenInfoForRedis.getUser());
                tokens.setToken(tokenInfo.getToken());
                return ResponseMessage.success(tokens) ;
            }else{
                throw new Exception("您已离线,请重新登录") ;
            }
        }
    }
    
    

    至此,后台的token集成完毕

    展开全文
  • Springboot Websocket token 验证

    千次阅读 热门讨论 2018-08-17 15:11:40
    可以根据拦截器实现 1. 首先写一个WebSocketInterceptor,继承 TextWebSocketHandler 实现 HandshakeInterceptor ... * 在握手之前执行该方法, 继续握手返回...OK,如此这样 token 验证就完成了!(欢迎分享)
  • 现在要做一个功能 登录之后得到一个token 返回给客户端 之后每次请求都要带着这个token 这个token怎么生成和校验的 现在开发用的是springboot 主要就是这个token的生成 token验证 token的存储不知道怎么解决
  • Entity、Dao、Service、Controller、application.yml、pom.xml Entity Dao Service 实现接口Impl package com.guoxinn.demo.Service.ServiceImpl;...import org.springframework.stereotype.Ser
  • 如果对整合 JWT 还不熟悉的朋友,可以先看看我的这篇博客:【SpringBoot】四十四、SpringBoot中整合JWT实现Token验证 自定义注解 1、创建自定义注解 package com.asurplus.common.annotation; import
  • Springboot整合jwt token验证 笔记一下token验证。 1.所需依赖 <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.5.0</...
  • //设置请求拦截器,把token传递到后台 axios.interceptors.request.use(function(config){ // console.log(config.url) //打开进度条 // NProgress.start() config.headers.Authorization=window.sessionStorage....
  • SpringBoot集成JWT实现token验证 参考文章:SpringBoot集成JWT实现token验证
  • @SpringBootApplication // 扫描组件 @ServletComponentScan public class WarningForecastApplication { public static void main(String[] args) { SpringApplication.run(WarningForecastApplication.class, ...
  • SpringBoot 实现token登录验证

    千次阅读 2018-10-11 11:02:29
    2.重写preHandler方法,返回类型为布尔型,true代表放行,false代表不放行,获取Http请求的请求头,验证token是否存在、有效,如果有效则将token放入线程本地变量保管 3.重写afterCompletion方法 清除线程本地变量...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,005
精华内容 402
关键字:

springboottoken验证

spring 订阅