jwt 订阅
智威汤逊(JWT)一直以“不断自我创新,也不断创造广告事业”著称于世。JWT首开先例的顾客产品调查、第一本杂志指南、第一本农业指南、提供给国际投资人的第一本行销指南、制作第一个电台表演秀、制作第一个商业电视传播、第一个使用电脑策划及媒体购买……。智威汤逊以品牌全行销规划(Thompson Total Branding),结合广告、直效行销、促销、赞助及公关活动,致力于协助客户达成短期业绩成长,并创造长期的品牌价值。 展开全文
智威汤逊(JWT)一直以“不断自我创新,也不断创造广告事业”著称于世。JWT首开先例的顾客产品调查、第一本杂志指南、第一本农业指南、提供给国际投资人的第一本行销指南、制作第一个电台表演秀、制作第一个商业电视传播、第一个使用电脑策划及媒体购买……。智威汤逊以品牌全行销规划(Thompson Total Branding),结合广告、直效行销、促销、赞助及公关活动,致力于协助客户达成短期业绩成长,并创造长期的品牌价值。
信息
JWT
是智威汤逊的英文缩写
全球第一家
广告公司
中文名
JWT
创始于
1864年
JWT简介
自成立以来,时至今日,140周岁的JWT风采依旧,昂首跻身于世界4大顶尖广告公司之列。JWT的大家庭有10,000多名成员,300多个分公司、办事处遍布全球六大洲主要城市,为客户提供全方位的品牌服务。目前智威汤逊隶属于全球最大的传播集团WPP。
收起全文
精华内容
参与话题
问答
  • JWT Token

    2016-03-02 14:05:22
    json web token. http://jwt.io/

    json web token.

    http://jwt.io/

    展开全文
  • JWT token

    2018-04-25 13:43:50
    最近一直在做前后端分离项目,开始想研究如何从实现remember me问题,可以使用JWT token。我的想法是把用户的id或者用户名(最好不要加上password)保存在token令牌中,每次提交时携带上token令牌后台验证是否失效,...

    最近一直在做前后端分离项目,开始想研究如何从实现remember me问题,可以使用JWT token。我的想法是把用户的id或者用户名(最好不要加上password)保存在token令牌中,每次提交时携带上token令牌后台验证是否失效,没有失效的话可以继续后面的操作。失效的话返回登录界面重新登录。

    JWT token的组成

    头部(Header),格式如下: 

    “typ”: “JWT”, 
    “alg”: “HS256” 

    由上可知,该token使用HS256加密算法,将头部使用Base64编码可得到如下个格式的字符串:

    eyJhbGciOiJIUzI1NiJ9
    • 1

    有效载荷(Playload): 

    “iss”: “Online JWT Builder”, 
    “iat”: 1416797419, 
    “exp”: 1448333419, 
    ……. 
    “userid”:10001 

    有效载荷中存放了token的签发者(iss)、签发时间(iat)、过期时间(exp)等以及一些我们需要写进token中的信息。有效载荷也使用Base64编码得到如下格式的字符串:

    eyJ1c2VyaWQiOjB9
    • 1

    签名(Signature): 

    将Header和Playload拼接生成一个字符串str=“eyJhbGciOiJIUzI1NiJ9.eyJ1c2VyaWQiOjB9”,使用HS256算法和我们提供的密钥(secret,服务器自己提供的一个字符串)对str进行加密生成最终的JWT,即我们需要的令牌(token),形如:str.”签名字符串”。

    下面代码是网上粘下来的,因为自己的代码不在这台电脑上>.<.

    private static Logger log = LoggerFactory.getLogger(JavaWebToken.class); //该方法使用HS256算法和Secret:bankgl生成signKey private static Key getKeyInstance() { //We will sign our JavaWebToken with our ApiKey secret SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256; byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary("bankgl"); Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName()); return signingKey; } //使用HS256签名算法和生成的signingKey最终的Token,claims中是有效载荷 public static String createJavaWebToken(Map<String, Object> claims) { return Jwts.builder().setClaims(claims).signWith(SignatureAlgorithm.HS256, getKeyInstance()).compact(); } //解析Token,同时也能验证Token,当验证失败返回null public static Map<String, Object> parserJavaWebToken(String jwt) { try { Map<String, Object> jwtClaims = Jwts.parser().setSigningKey(getKeyInstance()).parseClaimsJws(jwt).getBody(); return jwtClaims; } catch (Exception e) { log.error("json web token verify failed"); return null; }

    后来我想到了安全问题,如果某个人拿到了我的token不就可以登陆我的账号了吗。

    我的几种解决方案:

        1.可以将ip保存在token令牌中,验证ip是否一致,不一致就重新输入。

        2.把token的时效设置的短一点,经常更换(这招可以用来防止爬虫)。

    每次都需要获取token,所以最好在filter中判断一下,就不必在每个controller中在获取判断了。

    这种思想也可以用来作防止表单重复提交。

    展开全文
  • jwt token

    2020-05-26 09:18:41
    package com.example.demo.test.token; import java.util.Date; import java.util.HashMap; import java.util.Map; import com.alibaba.fastjson.JSON; import com.auth0.jwt.JWT; import ...

    package com.example.demo.test.token;

    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;

    import com.alibaba.fastjson.JSON;
    import com.auth0.jwt.JWT;
    import com.auth0.jwt.algorithms.Algorithm;
    import com.auth0.jwt.interfaces.DecodedJWT;
    import com.auth0.jwt.interfaces.JWTVerifier;

    public class JwtToken {

        // 过期时间
        private static final long EXPIRE_TIME = 15 * 60 * 1000; // 15min
        // 私钥
        private static final String TOKEN_SECRET = "privateKey";

    //    public static final String TOKEN_AES_KEY = "xiangli8Token";
    //    public static final String REFREH_TOKEN_AES_KEY = "xiangli8RefreshToken";
    //    public static final String JWT_TYP = "JWT";
    //    public static final String JWT_ALG = "AES";
    //    public static final String JWT_EXP = "30";
    //    public static final String JWT_ISS = "xiangli8";

        public static String createToken(String userId, String pwd) {

    //        String token= JWT.create().withAudience("audience")
    //                   .withIssuedAt(new Date())
    //                   .withSubject("subject")
    //                   .withExpiresAt(new Date()).withJWTId("jtiid")
    //                   .sign(Algorithm.HMAC256("123456"));

            try {
                long nowTime = System.currentTimeMillis();
                // 设置签发时间
                Date nowDate = new Date(nowTime);
                // 设置过期时间
                Date ExpiresDate = new Date(nowTime + EXPIRE_TIME);
                // 私钥和加密算法
                Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
                // 设置头部信息
                Map<String, Object> header = new HashMap<>(2);
                header.put("Type", "Jwt");
                header.put("alg", "HS256");
                // 返回token字符串
                return JWT.create().withHeader(header).withClaim("userId", userId).withClaim("pwd", pwd)
                        .withIssuedAt(nowDate).withExpiresAt(ExpiresDate).sign(algorithm);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }

        }

        /**
         * token解密jwt
         * 
         * @param token
         * @return
         * @throws Exception
         */
        public static DecodedJWT getJWT(String token) {
            try {
                Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
                JWTVerifier verifier = JWT.require(algorithm).build();
                DecodedJWT jwt = verifier.verify(token);
                return jwt;
            } catch (Exception e) {
            }
            return null;
        }

        /**
         * 检验token是否正确
         * 
         * @param **token**
         * @return
         */
        public static boolean verify(String token) {
            DecodedJWT jwt = getJWT(token);
    //            String userId = jwt.getClaim("userId").asString();
            if (null != jwt) {
                return true;
            }
            return false;
        }

    }
     

     

     

    测试

     

        public static void main(String[] args) {
            // TODO Auto-generated method stub

            String token = JwtToken.createToken("zhangsan", "1234qwer");

            System.out.println("token:" + token);
            token="eyJUeXBlIjoiSnd0IiwidHlwIjoiSldUIiwiYWxnIjoiSFMyNTYifQ.eyJwd2QiOiIxMjM0cXdlciIsImV4cCI6MTU5MDQ1ODA4NiwidXNlcklkIjoiemhhbmdoYW8iLCJpYXQiOjE1OTA0NTcxODZ9.cVcq-FTCqhESpIy3_vvJJzPrGy-ZEy4lGKnQxLMjsgY" + 
                    "";
            boolean result = JwtToken.verify(token);

            try {
                DecodedJWT jwt = JwtToken.getJWT(token);

                if(null!=jwt) {
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy‐MM‐dd hh:mm:ss");
                    System.out.println("签发时间:" + sdf.format(jwt.getIssuedAt()));
                    System.out.println("过期时 间:" + sdf.format(jwt.getExpiresAt()));
                    System.out.println("当前时间:" + sdf.format(new Date()));
                }

            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("token is:" + result);

        }

    展开全文
  • GitHub地址:https://github.com/zhang-xiaoxiang/shiro-jwt 说明:由于初衷是解决自己项目的bug的,就找的网上的一面博客瞎搞了一个demo.然后报的错网上难以找到解决办法,后来自己解决了,就记录一下,所以不算教程,我...

    代码略多,粘贴一些关键的代码,完整demo当然必须放在GitHub上面啦,当然带SQL文件的,在项目里面

    GitHub地址:  https://github.com/zhang-xiaoxiang/shiro-jwt

    说明:由于初衷是解决自己项目的bug的,就找的网上的一面博客瞎搞了一个demo.然后报的错网上难以找到解决办法,后来自己解决了,就记录一下,所以不算教程,我看评论大伙说的修改密码后之前的token仍然有效,可以使用redis处理,或者其他业务逻辑代码处理一下,这个仅仅是一个demo,当然很多培训机构的源码也有一些demo,大家可以参考,这里主要是给需要的小伙伴一个思路或者遇到那个bug的解决方案

    关于这个例子介绍:

    1使用的是spring boot2作为环境基础

    2数据库框架是mybatis plus(对mybatis熟悉就行,你顺便看一下mybatis plus逆向生成代码的魅力)

    3包含全局异常的处理(报错getWriter() has already been called for this response),这个BUG是网上的访问量比较高的CSDN的博客案例留下的bug,为了解决这个bug才有我的这篇博客,所以记录一下

    4shiro可以实现除了验证和授权之外的一些功能,这里主要展示验证,验证相当于登录,授权相当于登录后查看是否有权限,就想即使登录了支付宝,但是付款的时候还是需要验证支付宝密码一样,当然前后端未分离可以使用thymeleaf网页引擎,貌似黑马视频有,这里就只做个登录例子

    5jwt这种方式是不太时尚的,正确的方式spring security oauth2实现认证授权,这里仅供参考,欢迎小伙伴提出宝贵意见,我都会尽快回复

    6使用的是mysql8,pom和properties文件你改成现在用得多一点的5.7版本的写法就行了

    7这里根据博友评论确实忘了用户修改密码token的处理,我相信这个大家应该会处理的(更新一下token就行了)

    主要步骤:

    首先是pom引入(主要的依赖,由于代码较大,而且我提供了Git地址,需要的直接从GitHub拉下来就行了,后面不做过多阐述)

                <!--JWT java web token 权限验证-->
            <dependency>
                <groupId>com.auth0</groupId>
                <artifactId>java-jwt</artifactId>
                <version>3.4.0</version>
            </dependency>
                <!--shiro 权限框架-->
            <dependency>
                <groupId>org.apache.shiro</groupId>
                <artifactId>shiro-spring</artifactId>
                <version>1.4.0</version>
            </dependency>

     

    实现shiro的AuthenticationToken接口的类JwtToken
    //package com.example.shirojwt.jwt;
    
    import org.apache.shiro.authc.AuthenticationToken;
    
    /**
     * JwtToken:实现shiro的AuthenticationToken接口的类JwtToken
     *
     * @author zhangxiaoxiang
     * @date: 2019/07/12
     */
    public class JwtToken implements AuthenticationToken{
    
        private String token;
    
        public JwtToken(String token) {
            this.token = token;
        }
    
        @Override
        public Object getPrincipal() {
            return token;
        }
    
        @Override
        public Object getCredentials() {
            return token;
        }
    }
    

     再写一个token的验证工具类

    //package com.example.shirojwt.util;
    
    import com.auth0.jwt.JWT;
    import com.auth0.jwt.JWTVerifier;
    import com.auth0.jwt.algorithms.Algorithm;
    import com.auth0.jwt.exceptions.JWTDecodeException;
    import com.auth0.jwt.interfaces.DecodedJWT;
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.Date;
    
    /**
     * JwtUtil:用来进行签名和效验Token
     *
     * @author zhangxiaoxiang
     * @date: 2019/07/12
     */
    @Slf4j
    public class JwtUtil {
        /**
         * JWT验证过期时间 EXPIRE_TIME 分钟
         */
        private static final long EXPIRE_TIME = 30 * 60 * 1000;
    
        /**
         * 校验token是否正确
         *
         * @param token  密钥
         * @param secret 用户的密码
         * @return 是否正确
         */
        public static boolean verify(String token, String username, String secret) {
            try {
                //根据密码生成JWT效验器
                Algorithm algorithm = Algorithm.HMAC256(secret);
                JWTVerifier verifier = JWT.require(algorithm)
                        .withClaim("username", username)
                        .build();
                //效验TOKEN
                DecodedJWT jwt = verifier.verify(token);
                log.info("登录验证成功!");
                return true;
            } catch (Exception exception) {
                log.error("JwtUtil登录验证失败!");
    
                return false;
            }
        }
    
        /**
         * 获得token中的信息无需secret解密也能获得
         *
         * @return token中包含的用户名
         */
        public static String getUsername(String token) {
            try {
                DecodedJWT jwt = JWT.decode(token);
                return jwt.getClaim("username").asString();
            } catch (JWTDecodeException e) {
                return null;
            }
        }
    
        /**
         * 生成token签名EXPIRE_TIME 分钟后过期
         *
         * @param username 用户名(电话号码)
         * @param secret   用户的密码
         * @return 加密的token
         */
        public static String sign(String username, String secret) {
            Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
            Algorithm algorithm = Algorithm.HMAC256(secret);
            // 附带username信息
            return JWT.create()
                    .withClaim("username", username)
                    .withExpiresAt(date)
                    .sign(algorithm);
    
        }
    
        public static void main(String[] args) {
            /**
             * 测试生成一个token
             */
            String sign = sign("18888888888", "123456");
           log.warn("测试生成一个token\n"+sign);
        }
    }
    

    写一个jwt过滤器来作为shiro的过滤器。

    //package com.example.shirojwt.filter;
    
    import com.alibaba.fastjson.JSONObject;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    import com.example.shirojwt.jwt.JwtToken;
    import com.example.shirojwt.result.ResponseData;
    import com.example.shirojwt.result.ResponseDataUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.shiro.authc.AuthenticationException;
    import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
    import org.springframework.http.HttpStatus;
    import org.springframework.stereotype.Component;
    import org.springframework.web.bind.annotation.RequestMethod;
    
    import javax.servlet.*;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    
    /**
     * JwtFilter:jwt过滤器来作为shiro的过滤器
     *
     * @author zhangxiaoxiang
     * @date: 2019/07/12
     */
    @Slf4j
    @Component//这个注入与否影响不大
    public class JwtFilter extends BasicHttpAuthenticationFilter implements Filter {
        /**
         * 执行登录
         * @param request
         * @param response
         * @return
         * @throws Exception
         */
        @Override
        protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
            HttpServletRequest httpServletRequest = (HttpServletRequest) request;
            String token = httpServletRequest.getHeader("Token");
            JwtToken jwtToken = new JwtToken(token);
            // 提交给realm进行登入,如果错误他会抛出异常并被捕获
            try {
                getSubject(request, response).login(jwtToken);
                // 如果没有抛出异常则代表登入成功,返回true
                return true;
            } catch (AuthenticationException e) {
                ResponseData responseData = ResponseDataUtil.authorizationFailed( "没有访问权限,原因是:" + e.getMessage());
                //SerializerFeature.WriteMapNullValue为了null属性也输出json的键值对
                Object o = JSONObject.toJSONString(responseData, SerializerFeature.WriteMapNullValue);
                response.setCharacterEncoding("utf-8");
                response.getWriter().print(o);
                return false;
            }
    
        }
    
        /**
         * 执行登录认证
         *
         * @param request
         * @param response
         * @param mappedValue
         * @return
         */
        @Override
        protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
            try {
                return executeLogin(request, response);
                // return true;有一篇博客这里直接返回true是不正确的,在这里我特别指出一下
            } catch (Exception e) {
                log.error("JwtFilter过滤验证失败!");
                return false;
            }
        }
    
    
        /**
         * 对跨域提供支持
         * @param request
         * @param response
         * @return
         * @throws Exception
         */
        @Override
        protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
            HttpServletRequest httpServletRequest = (HttpServletRequest) request;
            HttpServletResponse httpServletResponse = (HttpServletResponse) response;
            httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
            httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
            httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
            // 跨域时会首先发送一个option请求,这里我们给option请求直接返回正常状态
            if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
                httpServletResponse.setStatus(HttpStatus.OK.value());
                return false;
            }
            return super.preHandle(request, response);
        }
    }
    

    自定义Realm

    //package com.example.shirojwt.shiro;
    
    import com.example.shirojwt.entity.User;
    import com.example.shirojwt.jwt.JwtToken;
    import com.example.shirojwt.service.UserService;
    import com.example.shirojwt.util.JwtUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.shiro.authc.AuthenticationException;
    import org.apache.shiro.authc.AuthenticationInfo;
    import org.apache.shiro.authc.AuthenticationToken;
    import org.apache.shiro.authc.SimpleAuthenticationInfo;
    import org.apache.shiro.authz.AuthorizationInfo;
    import org.apache.shiro.authz.SimpleAuthorizationInfo;
    import org.apache.shiro.realm.AuthorizingRealm;
    import org.apache.shiro.subject.PrincipalCollection;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    /**
     * MyRealm:自定义一个授权
     *
     * @author zhangxiaoxiang
     * @date: 2019/07/12
     */
    
    @Component
    @Slf4j
    public class MyRealm extends AuthorizingRealm {
    
        @Autowired
        private UserService userService;
    
        /**
         * 必须重写此方法,不然Shiro会报错
         * @param token
         * @return
         */
        @Override
        public boolean supports(AuthenticationToken token) {
            return token instanceof JwtToken;
        }
    
        /**
         * 只有当需要检测用户权限的时候才会调用此方法,例如checkRole,checkPermission之类的
         * @param principals
         * @return
         */
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
            String username = JwtUtil.getUsername(principals.toString());
            User user = userService.findByUserName(username);
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            return simpleAuthorizationInfo;
        }
    
        /**
         * 默认使用此方法进行用户名正确与否验证,错误抛出异常即可。
         * @param auth
         * @return
         * @throws AuthenticationException
         */
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
            String token = (String) auth.getCredentials();
            // 解密获得username,用于和数据库进行对比
            String username = null;
            try {
                //这里工具类没有处理空指针等异常这里处理一下(这里处理科学一些)
                username = JwtUtil.getUsername(token);
            } catch (Exception e) {
                throw new AuthenticationException("heard的token拼写错误或者值为空");
            }
            if (username == null) {
              log.error("token无效(空''或者null都不行!)");
                throw new AuthenticationException("token无效");
            }
            User userBean = userService.findByUserName(username);
            if (userBean == null) {
                log.error("用户不存在!)");
                throw new AuthenticationException("用户不存在!");
            }
            if (!JwtUtil.verify(token, username, userBean.getUserPassword())) {
                log.error("用户名或密码错误(token无效或者与登录者不匹配)!)");
                throw new AuthenticationException("用户名或密码错误(token无效或者与登录者不匹配)!");
            }
            return new SimpleAuthenticationInfo(token, token, "my_realm");
        }
    }
    

     ShiroConfig核心配置

    //package com.example.shirojwt.config;
    
    
    import com.example.shirojwt.filter.JwtFilter;
    import com.example.shirojwt.shiro.MyRealm;
    import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
    import org.apache.shiro.mgt.DefaultSubjectDAO;
    import org.apache.shiro.mgt.SecurityManager;
    import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
    import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import javax.servlet.Filter;
    import java.util.HashMap;
    import java.util.LinkedHashMap;
    import java.util.Map;
    
    /**
     * ShiroConfig:shiro 配置类,配置哪些拦截,哪些不拦截,哪些授权等等各种配置都在这里
     * 
     * 很多都是老套路,按照这个套路配置就行了
     *
     * @author zhangxiaoxiang
     * @date: 2019/07/12
     */
    
    @Configuration
    public class ShiroConfig {
        /**
         * 注入安全过滤器
         * @param securityManager
         * @return
         */
        @Bean("shiroFilter")
        public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
            ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
            shiroFilterFactoryBean.setSecurityManager(securityManager);
            //拦截器
            Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
            // 配置不会被拦截的链接 顺序判断
            filterChainDefinitionMap.put("/login/**", "anon");
            filterChainDefinitionMap.put("/**.js", "anon");
            filterChainDefinitionMap.put("/druid/**", "anon");
            filterChainDefinitionMap.put("/swagger**/**", "anon");
            filterChainDefinitionMap.put("/**/swagger**/**", "anon");
            filterChainDefinitionMap.put("/webjars/**", "anon");
            filterChainDefinitionMap.put("/v2/**", "anon");
            // 添加自己的过滤器并且取名为jwt
            Map<String, Filter> filterMap = new HashMap<String, Filter>(1);
            filterMap.put("jwt", new JwtFilter());
            shiroFilterFactoryBean.setFilters(filterMap);
            //<!-- 过滤链定义,从上向下顺序执行,一般将/**放在最为下边
            filterChainDefinitionMap.put("/**", "jwt");
            //未授权界面;
            shiroFilterFactoryBean.setUnauthorizedUrl("/403");
            shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
            return shiroFilterFactoryBean;
        }
    
        /**
         * 注入安全管理器
         * @param myRealm
         * @return
         */
        @Bean("securityManager")
        public SecurityManager securityManager(MyRealm myRealm) {
            DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
            securityManager.setRealm(myRealm);
    
            /*
             * 关闭shiro自带的session,详情见文档
             * http://shiro.apache.org/session-management.html#SessionManagement-StatelessApplications%28Sessionless%29
             */
            DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
            DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
            defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
            subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
            securityManager.setSubjectDAO(subjectDAO);
            return securityManager;
    
           }
    }
    

     大体核心代码已经完成,项目结构如图(点击图片放大后就清晰了)

     测试示例

    比如模拟登录token(在JwtUtil生成一个)错误,或者token输入成token12,或者账号密码错误等等...

     比如输入使用生成的token(相当于用户登录后返回的token):登录显然不需要token,登录后后台返回token,只是这里为了演示一个需要token的接口,所以把登录接口也设置了需要token,科学的方法是比如查询用户详情这个接口就必须要token,所以postman传入的token模拟的是需要token的接口而存在的,返回的token是给前端带上访问用户订单,地址的那些需要token认证的接口

     

     当然在控制层也可以测试其他被限制访问的接口和放行的接口,以及各种异常的测试,这里不做过多赘述,感兴趣的看GitHub的demo

    展开全文
  • 本文介绍jwt token在laravel中的安装使用,解决token验证的问题 一、查看laravel版本选定适合自己框架的jwt版本,不同版本之间会有意想不到的惊喜(坑) 根据自己laravel版本不同使用jwt-auth版本建议如下: ...
  • jwt token 实现

    2018-07-27 14:30:07
    本例子教你如何在你的项目中搭建jwt token授权登录,代码清晰易懂。
  • JWT Token生成及验证

    热门讨论 2017-11-03 15:07:34
    请参考博客:http://www.cnblogs.com/chenwolong/p/Token.html
  • JWT Token刷新方案

    万次阅读 热门讨论 2019-01-22 20:42:30
    JWT TOKEN刷新方案 环境 Springboot,Redis 需求 由于是前后端分离的项目,需要使用JWT Token来校验用户信息,保证用户信息安全可靠,不会被重放攻击。 问题 JWT Token如不设置有效期,刷新周期,他人一旦拿到Token...
  • String jwtToken = JwtTokenUtil.generateToken(String.valueOf(authentication.getPrincipal()), 300, "_secret"); responseBase.setJwtToken(jwtToken); httpServletResponse.getWriter().write(JSON....
  • 主要介绍了thinkphp框架使用JWTtoken的方法,结合实例形式分析了JWTtoken的功能、原理及thinkPHP使用JWTtoken实现签名验证的相关操作技巧,需要的朋友可以参考下
  • JWTToken超时刷新策略

    千次阅读 2019-10-05 12:21:12
    对于登录的用户签发其对应的jwt,我们在jwt设置他的固定有效期时间,在有效期内用户携带jwt访问没问题,当过有效期后jwt失效,用户需要重新登录获取新的jwt。...这里就涉及到了token的超时刷新问题,解决方案看...
  • 主要介绍了SpringSecurity Jwt Token 自动刷新的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • JWT token加密

    千次阅读 2018-12-20 19:30:13
    使用jhipster生成的微服务,采用其默认的JWT认证方式。代码中获取用户是通过SecurityUtils.getCurrentUserLogin().orElse("admin");方式获取用户信息。 在测试系统中,测试完全没有问题。但是发布到正式...
  • JwtToken原理

    2019-06-21 19:39:12
    JSON Web TokenJWT)是一个开放式标准(RFC 7519),它定义了一种紧凑(Compact)且自包含(Self-contained)的方式,用于在各方之间以JSON对象安全传输信息。 这些信息可以通过数字签名进行验证和信任。 可以使用...
  • thinkphp 使用JWTtoken

    万次阅读 2019-05-16 12:02:43
    一:JWT介绍:全称JSON Web Token,基于JSON的开放标准((RFC 7519),以token的方式代替传统的Cookie-Session模式,用于各服务器、客户端传递信息签名验证。 二:JWT优点: 1:服务端不需要保存传统会话信息,没有...
  • JWT Token认证

    2018-12-15 22:33:13
    JWT是JSON Web Token的缩写,定义了一种简介自暴寒的方法用于通信双方之间以Json对象的形式安全的传递信息。因为特定的数字签名,所以这些通信的信息能够被校验和信任。 JWT可以使用HMAC算法或者RSA的公钥私钥对进行...
  • delphi JWT token

    2018-08-28 15:11:57
    https://blog.csdn.net/ITzhangdaopin/article/details/78360853
  • JWT token令牌

    2017-10-24 00:27:31
    1,JWT token的组成头部(Header),格式如下: { “typ”: “JWT”, “alg”: “HS256” } 由上可知,该token使用HS256加密算法,将头部使用Base64编码可得到如下个格式的字符串: eyJhbGciOiJIUzI1NiJ9 有效...
  • JWT token认证

    2019-02-26 10:05:51
    JWT 是 Json Web Tokens 的缩写,与传统 Web 的 Cookies 或者 Session 方式的认证不同的是,JWT 是无状态的,服务器上不需要对 token 进行存储,也不需要和客户端保持连接。而 JWTtoken 分3个部分,首先是头部 ...
  • JWT token过期自动续期解决方案

    万次阅读 热门讨论 2019-08-29 17:58:15
    JWT全称JSON Web Token,由三部分组成header(头部,用于描述关于该JWT的最基本的信息,例如其类型以及签名所用的算法等)、payload(载荷,就是存放有效信息的地方,在这一部分中存放过期时间)和signature(签证,...
  • JWT token 生成工具

    千次阅读 2019-06-30 11:55:42
    Jwt 是一种生成token,或者解析token 返回对象的工具,现在流行的都是前后端分离项目,用之前的shiro,或者sercurity 去做权限是会遇到无法做前端的权限,所以就采用token 这种方式,服务器返回token 给前端,前端...
  • jwt token定时刷新

    千次阅读 2020-01-22 16:10:35
    因为登录后获得的token是有时间限制的,也即是有效期,刷新token一是可以延续token,二是可以保证安全,即使token被人截获 刷新token后也还是很安全的。 二、大致实现步骤 在前端登录后的主页 的公共模块或公共组件...

空空如也

1 2 3 4 5 ... 20
收藏数 104,093
精华内容 41,637
关键字:

jwt