拦截器和JWT的使用

最新推荐文章于 2024-09-13 22:12:47 发布
最新推荐文章于 2024-09-13 22:12:47 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 拦截器和JWT的使用 文章标签： servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67152642/article/details/125391571
版权

一、我们新建一个Controller文件（编写一段测试代码）

1.2、在设计一个interceptor文件夹，在文件夹下生成一个类TestInterceptor（主要需要继承WebMvcConfigurerAdapter）                                

package com.example.spring_interceptors.interceptor;

import com.example.spring_interceptors.Controller.utils.JwtOperator;
import com.example.spring_interceptors.Controller.utils.RedisHelper;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Configuration
@Slf4j
public class Testinterceptor extends WebMvcConfigurerAdapter {

    @Autowired
    private JwtOperator jwtOperator;
    @Autowired
    private RedisHelper redisHelper;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        HandlerInterceptor handlerInterceptor=new HandlerInterceptor() {
            @Override
            public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
                log.info("preHandle，在请求Controller之前触发，返回值为true代表放行，false代表拦截");

                boolean isOk=false;

                String serVletPath = request.getServletPath();//获取请求的路径
                if (serVletPath.contains("/user/login")){
                    isOk=true;//放行
                }else {
                    try {
                        String token = request.getHeader("Authorization");
                        boolean isExpire = jwtOperator.validateTokenTime(token);
                        if(isExpire){//验证token是否被篡改，是否过期
                            Claims info = jwtOperator.getClaimsFromToken(token);
                            String[] str =info.toString().replace("{","").replace("}","").split(",");
                            String userId=str[0].replace("id=","");

                            //从redis中获取token，通过userId
                            String tokenFromRedis = redisHelper.getValue(userId);
                            if(tokenFromRedis.equals(token)){
                                isOk=true;
                            }
                        }
                    } catch (Exception e) {
                        response.getWriter().write("token is disabled");
                    }
                }
                return isOk;
            }

            @Override
            public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
                log.info("postHandle，在请求Controller之后执行");
            }

            @Override
            public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
                log.info("afterCompletion,在整个Request请求完成后执行");
            }
        };
        registry.addInterceptor(handlerInterceptor);
    }
}

 1.3、然后我们通过访问页面就可以看到打印的日志会输出到控制台上（返回值为true就代表着放行，不需要拦截，false代表拦截）

 二、JWT的使用

2.1、我们使用JWT需要先导入pom.xml文件的依赖（需要导入JWT和Redis的依赖，刷新Maven）

<!--JWT的依赖-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-api</artifactId>
            <version>0.10.7</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-impl</artifactId>
            <version>0.10.7</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-jackson</artifactId>
            <version>0.10.7</version>
            <scope>runtime</scope>
        </dependency>

        <!-- 添加jedis：Begin -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

2.2、设置application.yml的配置条件

spring:
  redis:
    #redis服务器IP
    host: 127.0.0.1
    #redis服务器端口号
    port: 6379
    #redis数据库密码
    password:
    #redis连接池配置
    jedis:
      pool:
        #设置连接池中最大连接数
        max-active: 10000
        #设置连接池中最大空闲连接数
        max-idle: 50
jwt:
  secret: aaaaaaabbbbbbcccccdddddaaaaaaabbbbbbcccccdddddaaaaaaabbbbbbcccccddddd
  # 有效期，单位秒，默认2周
  expire-time-in-second: 1209600

2.3、需要在Controller文件中中新建一个Utils文件夹，并新建两个文件

        2.3.1、第一个文件（JwtOperator）

package com.example.spring_interceptors.Controller.utils;

import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.tomcat.util.codec.binary.Base64;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;


import javax.crypto.SecretKey;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Slf4j
@RequiredArgsConstructor
@SuppressWarnings("WeakerAccess")
@Component
public class JwtOperator {
    /**
     * 秘钥
     * - 默认aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrsssttt
     */
    @Value("${jwt.secret:aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrsssttt}")
    private String secret;
    /**
     * token有效期，单位秒
     * - 默认30分钟
     */
    @Value("${jwt.expire-time-in-second:1209600}")
    private Long expirationTimeInSecond;

    /**
     * 按要求生成token和refresh_token
     *
     * @param claims
     * @return token
     */
    public String generateTokens(Map<String, Object> claims){

        long currentTime = System.currentTimeMillis();
        Date tokenExpirationTime = new Date(currentTime + this.expirationTimeInSecond * 1000);

        String token = generateToken(claims, tokenExpirationTime);//生成token

        return token;
    }

    /**
     * 判断token是否过期
     *
     * @param token token
     * @return 未过期返回true，否则返回false
     */
    public Boolean validateTokenTime(String token) {
        Date expiration = getExpirationDateFromToken(token);
        return expiration.after(new Date()); //获取时间的毫秒数 > 当前时间的毫秒数 = true
    }

    /**
     * 从token中获取claim
     *
     * @param token token
     * @return claim
     */
    public Claims getClaimsFromToken(String token) {
        try {
            return Jwts.parser()
                    .setSigningKey(this.secret.getBytes())
                    .parseClaimsJws(token)
                    .getBody();
        } catch (ExpiredJwtException | UnsupportedJwtException | MalformedJwtException | IllegalArgumentException e) {
            log.error("token无效");
            throw new IllegalArgumentException("Token invalided.");
        }
    }

    /**
     * 生成token
     *
     * @param claims 用户信息
     * @param expirationTime 过期时间
     * @return token
     */
    private String generateToken(Map<String, Object> claims, Date expirationTime) {
        Date createdTime = new Date();

        byte[] keyBytes = secret.getBytes();
        SecretKey key = Keys.hmacShaKeyFor(keyBytes);

        return Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(createdTime)
                .setExpiration(expirationTime)
                // 你也可以改用你喜欢的算法
                // 支持的算法详见：https://github.com/jwtk/jjwt#features
                .signWith(key, SignatureAlgorithm.HS256)
                .compact();
    }

    /**
     * 获取token的过期时间
     *
     * @param token token
     * @return 过期时间
     */
    private Date getExpirationDateFromToken(String token) {
        return getClaimsFromToken(token).getExpiration();
    }

}

         2.3.2、第二个文件（RedisHelper）

package com.example.spring_interceptors.Controller.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@Slf4j
@Component
public class RedisHelper {

    @Value("${spring.redis.host}")
    private String redisHost;

    @Value("${spring.redis.port}")
    private int redisPort;

    @Value("${spring.redis.password}")
    private String redisPassword;

    @Value("${spring.redis.jedis.pool.max-active}")
    private String redisMaxActive;

    @Value("${spring.redis.jedis.pool.max-idle}")
    private String redisMaxIdle;

    private JedisPool jedisPool; //连接池

    /**
     * 向Redis服务器中添加数据
     *
     * @param key
     * @param value
     * @return
     */
    public String setValue(String key, String value) {
        return getJedis().set(key, value);
    }

    /**
     * 根据Key获取Redis中保存的数据
     *
     * @param key
     * @return
     */
    public String getValue(String key) {
        return getJedis().get(key);
    }

    /**
     * 根据Key删除Redis中保存的数据
     *
     * @param key
     * @return
     */
    public Long removeValue(String key) {
        return getJedis().del(key);
    }

    /**
     * 获得Jedis对象
     *
     * @return
     */
    private Jedis getJedis() {
//		log.info("redisHost:"+redisHost);
//		log.info("redisPort:"+redisPort);
//		log.info("redisPassword:"+redisPassword);
        if(jedisPool == null) {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxTotal(Integer.parseInt(redisMaxActive)); //设置最大连接数
            jedisPoolConfig.setMaxIdle(Integer.parseInt(redisMaxIdle)); //设置最大空闲连接数
            jedisPool = new JedisPool(jedisPoolConfig, redisHost, redisPort); //ip+端口号
        }
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            if(!"".equals(redisPassword)){
                jedis.auth(redisPassword);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(jedis != null) {
                jedis.close(); //关闭jedis连接
            }
            if(jedisPool != null) {
                jedisPool.close(); //关闭jedisPool连接
                jedisPool = null;
            }
        }
        return jedis;
    }
}

三、我们通过测试来实现拦截，新建一个entity的实体类包，新建一个user文件，属性有id,username,password三个参数（使用Data注解来自动生成get和set方法）

 3.2、在设计一个Service文件夹，新建一个UserService文件，然后在Comtroller文件夹中新建一个UserController文件

        3.2.1、UserService

package com.example.spring_interceptors.service;

import com.example.spring_interceptors.Controller.utils.JwtOperator;
import com.example.spring_interceptors.Controller.utils.RedisHelper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
@Slf4j
public class UserService {

    @Autowired
    private JwtOperator jwtOperator;
    @Autowired
    private RedisHelper redisHelper;
    //校验用户登录
    public String validUser(String username,String password){
        String token=null;
        if("admin".equals(username)&&"123".equals(password)){
            String id="aaaaaaaa";
            //生成token
            Map<String,Object> param=new HashMap<>();
            param.put("id",id);
            token=jwtOperator.generateTokens(param);
            log.info("生成的token是："+token);

            //将token保存到redis中
            redisHelper.setValue(id,token);
        }
        return token;
    }
}

        3.2.2、UserController

 

package com.example.spring_interceptors.Controller;

import com.example.spring_interceptors.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping("/login/{username}/{password}")
    public String login(@PathVariable String username,@PathVariable String password){
        String token = userService.validUser(username,password);
        if(token!=null){
            return "登录成功";
        }else {
            return "登录失败";
        }
    }

    @GetMapping("/list")
    public String[] userList(){
        String[] users={"admin","tom","mike"};
        return users;
    }
}

3.3、我们修改TestInterceptor文件(在当前文件进行判断校验)

package com.example.spring_interceptors.interceptor;

import com.example.spring_interceptors.Controller.utils.JwtOperator;
import com.example.spring_interceptors.Controller.utils.RedisHelper;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Configuration
@Slf4j
public class Testinterceptor extends WebMvcConfigurerAdapter {

    @Autowired
    private JwtOperator jwtOperator;
    @Autowired
    private RedisHelper redisHelper;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        HandlerInterceptor handlerInterceptor=new HandlerInterceptor() {
            @Override
            public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
                log.info("preHandle，在请求Controller之前触发，返回值为true代表放行，false代表拦截");

                boolean isOk=false;

                String serVletPath = request.getServletPath();//获取请求的路径
                if (serVletPath.contains("/user/login")){
                    isOk=true;//放行
                }else {
                    try {
                        String token = request.getHeader("Authorization");
                        boolean isExpire = jwtOperator.validateTokenTime(token);
                        if(isExpire){//验证token是否被篡改，是否过期
                            Claims info = jwtOperator.getClaimsFromToken(token);
                            String[] str =info.toString().replace("{","").replace("}","").split(",");
                            String userId=str[0].replace("id=","");

                            //从redis中获取token，通过userId
                            String tokenFromRedis = redisHelper.getValue(userId);
                            if(tokenFromRedis.equals(token)){
                                isOk=true;
                            }
                        }
                    } catch (Exception e) {
                        response.getWriter().write("token is disabled");
                    }
                }
                return isOk;
            }

            @Override
            public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
                log.info("postHandle，在请求Controller之后执行");
            }

            @Override
            public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
                log.info("afterCompletion,在整个Request请求完成后执行");
            }
        };
        registry.addInterceptor(handlerInterceptor);
    }
}

3.4、我们启动项目来进行测试

        3.4.1、通过页面访问

         3.4.2、访问之后我们就可以获得Token的加密代码，我们将其复制

 

 3.5、修改Http头字段

         3.5.1、使用token密钥进行访问

        3.5.2、拦截器的打印效果展示到控制台，说明拦截器正常运行

 

 

无果i
关注
专栏目录
【SpringBoot】46、SpringBoot中整合JWT实现Token验证（拦截器篇）
Asurplus
02-28 21万+
前言 上篇文章我们已经实现了使用自定义注解验证 token 信息，这样我们就会发现，当我们需要验证的接口较多时，我们需要每个方法上面都加上 @JwtToken 这个注解，也是非常麻烦， 本片文章，我们继续使用拦截器来实现 token 信息的验证 如果对整合 JWT 还不熟悉的朋友，可以先看看我的这篇博客：【SpringBoot】四十四、SpringBoot中整合JWT实现Token验证（整合篇） 如果对自定义注解验证 token 信息感兴趣的朋友，可以看看我的这篇博客：【SpringBoot】四十五、Spr
spring boot jwt Interceptor 例子
12-11
spring boot jwt 和 interceptor的例子。 其中jwt的例子网上有很多，但是都是要数据库支持，这个只是用假数据模拟，不需要数据库支持。另外还有一个拦截器的简单例子。已经在sts 4 测试通过。
SpringBoot配置JWT拦截器
Kristabo的博客
03-24 1430
JWT在之前文章提到过，JWT（JSON Web Token）是一种用于身份验证和授权的开放标准（RFC 7519），它允许在网络中安全地传输声明（claims）作为 JSON 对象。JWT 可以通过数字签名或加密来验证数据的完整性和真实性，从而保证数据在传输过程中不被篡改。工作流程用户通过用户名和密码等方式进行身份验证。服务器验证用户身份，并生成一个 JWT。服务器将 JWT 发送给客户端。客户端将 JWT 存储起来，通常是在本地存储或者内存中。
【Spring Security系列】Spring Security整合JWT：构建安全的Web应用_springsecurity jwt
最新发布
heike_Ch的博客
09-13 529
在企业级开发或者我们自己的课程设计中，确保用户数据的安全性和访问控制非常重要。而Spring Security和JWT是都两个强大的工具，它俩结合可以帮助我们实现这一目标。Spring Security提供了全面的安全功能，而JWT则是一种用于身份验证的令牌机制。前面两个章节介绍过了Spring Security，这里就不再赘述了！！！JWT是一种轻量级的身份验证和授权机制，通过发送包含用户信息的加密令牌来实现身份验证。这个工具我们在前面的文章中也提起过。
JWT实现拦截器和token认证
AsFarmer的博客
07-28 3796
Jwt实现拦截器
JWT的介绍与Spring拦截器的配合使用
做点有意思的事情
10-10 271
JWT的介绍与Spring拦截器的配合使用
Jwt + SpringBoot 拦截器+权限认证
ringBey的博客
06-30 760
Jwt + SpringBoot 拦截器+权限认证
拦截器+JWT的使用
m0_73777375的博客
07-19 172
第三步：创建一个拦截器类并且继承HandlerInterceptor接口且重写里面的preHandle放大（快捷键ctrl + O）。第四步：创建一个配置类继承WebMvcConfigurer接口并重写里面的addInterceptors方法。第二步：创建一个JWT令牌的工具类。完结：有用请给个赞吧！第一步：导入JWT令牌的坐标。
JWT令牌&&拦截器
weixin_64308540的博客
07-31 854
JWT令牌&&拦截器
用户登录实现(拦截器,JWT令牌)
05-28
用户登录实现(拦截器,JWT令牌)
分布式环境认证和授权-基于springboot+JWT+拦截器实现-实操+源码下载
雾林小妖的博客
12-12 1680
基于springbootboot工程+jwt+拦截器实现登录验证和授权
SpringBoot集成JWT实现拦截器
qq_50954744的博客
09-12 2611
SpringBoot集成JWT实现拦截器
JWT拦截器鉴权
taiguolaotu的博客
12-15 1040
jwt_拦截器_校验token
asdfgh
08-13 359
现在 是springboot, 没有 配置文件了。1, 拦截器, 需要交给 spring管理。现在需要 基于 Java配置。
JWT拦截器
weixin_47119456的博客
02-09 204
JWT拦截器
基于jwt的用户鉴权：拦截器概述
Leon_Jinhai_Sun的博客
01-01 453
基于拦截器的token与鉴权 如果我们每个方法都去写一段代码，冗余度太高，不利于维护，那如何做使我们的代码看起来更清爽呢？我们可以将这段代码放入拦截器去实现 Spring中的拦截器 Spring为我们提供了org.springframework.web.servlet.handler.HandlerInterceptorAdapter这个适配器，继承此类，可以非常方便的实现自己的拦截器。他有...
使用JWT验证登陆(拦截器实现)
weixin_72979483的博客
06-12 1027
本文主要是使用jwt进行登陆验证的代码。JSON Web Token (JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的
JWT令牌、过滤器Filter、拦截器Interceptor
m0_46702681的博客
06-16 1647
全称:JSON Web Token(https://iwt.io/)定义了一种简洁的、自包含的格式，用于在通信双方以json数据格式安全的传输信息。由于数字签名的存在，这些信息是可靠的。组成:第一部分:Header(头)，记录令牌类型、签名算法等。例如:{"alg":"HS256","type":"JWT"}第二部分:Payload(有效载荷)，携带一些自定义信息、默认信息等。例如 {"id":"1"，"username":"Tom"}
jwt设置token登录拦截器
m0_58467275的博客
03-08 2036
springboot项目，搭配jwt设置判断token放行工具，控制页面登录之后才可以访问的页面
自定义拦截器+ jwt 登录登出
05-26
下面是使用自定义拦截器和 JWT 实现登录和登出的步骤： 1. 创建一个 JWT 工具类，用于生成和验证 JWT。该类应包含以下方法： - 生成 JWT：将用户信息（如用户名、角色等）加密，并将其存储在 JWT 中。 - 验证 JWT...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值