SpringBoot整合拦截器之接口加密

我就是我 2024-04-17 06:23 83阅读 0赞

Boss：小优呀，你写的springboot接口是不是知道地址就可以访问？

小优：对啊。只要知道地址就能访问。

Boss：小优，你有没有想过，我如果是个黑客，你写的接口数据我是不是都可以拿到。

小优优：拿到拿到呗。

Boss：。。。。 小优，我觉得你想家了，建议你可以回家看看了。

小优：嗯有点吧。两个月没回家了。

真心为为小优的工作担忧。

今天给大家分享一下SpringBoot整合过滤器。

我找了陈年老图：

![file][]

在给大家画一个登录流程图：

![file][file 1]

请求API流程图：

![file][file 2]

很多精华都在图里了。

不多说了，直接上代码吧：

拦截器配置：
    package cn.cnbuilder.face.station.config;
    
    import com.hcr.face.station.interceptor.LoginInterceptor;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.http.converter.HttpMessageConverter;
    import org.springframework.http.converter.StringHttpMessageConverter;
    import org.springframework.web.servlet.config.annotation.EnableWebMvc;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
    
    
    @Configuration
    public class WebConfig extends WebMvcConfigurerAdapter {
    
    
        @Autowired
        private LoginInterceptor loginInterceptor;
    
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            // 需要拦截的路径
            String[] addPathPatterns = {
                    "/user/**"
    
            };
            //不需要拦截的路径
            String[] excludePathPatterns = {
                    "/cnbuilder/**"
    
            };
    
    
            //addPathPatterns()添加拦截路径
            //excludePathPatterns() 添加不拦截的路径
            //添加注册登录拦截器
            registry.addInterceptor(loginInterceptor).addPathPatterns(addPathPatterns).excludePathPatterns(excludePathPatterns);
            // registry.addInterceptor(loginInterceptor).addPathPatterns("").excludePathPatterns("");
            //如果有多个拦截器可以注册多个...
        }
    
    
    }
    
    拦截器逻辑代码：
    package cn.cnbuilder.face.station.interceptor;
    
    import cn.hutool.crypto.SecureUtil;
    import cn.hutool.json.JSONUtil;
    import cn.cnbuilder.face.station.entity.base.BaseResultVo;
    import cn.cnbuilder.face.station.utils.RedisUtil;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.Aware;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    @Component
    public class LoginInterceptor implements HandlerInterceptor {
    
        @Autowired
        private RedisUtil redisUtil;
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    
            //全局请求头取出adminUuid
            String adminUuid = request.getHeader("admin_uuid");
            System.out.println(adminUuid + "已经进入登录拦截器........");
    
            //根据管理员id查询用户token
            Object rToken = redisUtil.get(adminUuid);
            // Object rToken = redisUtil.get(adminUuid);
            if (adminUuid==null||rToken == null) {
                reponseWrite401(response);
                return false;
            }
    
            //加密串 加密进行对比
            String sign = request.getHeader("sign");
            String token = rToken.toString();
            String sSign = SecureUtil.md5(token + "cnbuilder");
            if (sign==null||!sSign.equals(sign)) {
                reponseWrite401(response);
                return false;
            }
            //设置token 为30分钟
            redisUtil.set(adminUuid, token, 18000);
            System.out.println(adminUuid + "退出拦截器.......登录接口.");
            //return false表示不进入controller
            //return true表示进入controller
            return true;
        }
    
        private void reponseWrite401(HttpServletResponse response) throws Exception {
            BaseResultVo resultVo = new BaseResultVo(401, "签名不正确或token失效");
            String res = JSONUtil.toJsonStr(resultVo);
            response.reset();
            response.setContentType("application/json");
            response.setCharacterEncoding("utf-8");
            //解决跨域问题
            response.setHeader("Access-Control-Allow-Origin", "*");
            response.getWriter().print(res);
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    
        }
    }
    
    BaseResultVo实体类：
    
    package cn.cnbuilder.face.station.entity.base;
    
    import java.io.Serializable;
    
    /**
     * @description: 基础vo对象
     * @create_time：2014年10月8日 下午4:08:44
     */
    public class BaseResultVo implements Serializable {
    
        /**
         * 正常
         */
        public static final int RESULT_OK = 200;
        public static final String RESULT_OK_MSG = "请求成功";
    
    
        /**
         * 服务器内部异常
         */
        public static final int SERVER_ERROR = 500;
        public static final String SEVER_ERROE_MSG = "服务器繁忙，请稍后重试！";
    
        /**
         * {变量说明}
         */
        private static final long serialVersionUID = -7978635757653362784L;
    
        // 返回码，200表示成功，非200表示失败
        public int resultCode;
    
        // 返回消息，成功为“success”，失败为具体失败信息
        public String resultMessage;
    
        // 返回数据
        public Object resultData;
    
        public BaseResultVo() {
    
        }
    
        public BaseResultVo(String resultMessage, Object resultData) {
            this.resultCode = 0;
            this.resultMessage = resultMessage;
            this.resultData = resultData;
        }
    
        public BaseResultVo(int resultCode, String resultMessage) {
            this.resultCode = resultCode;
            this.resultMessage = resultMessage;
            this.resultData = "";
        }
    
        public int getResultCode() {
            return resultCode;
        }
    
        public void setResultCode(int resultCode) {
            this.resultCode = resultCode;
        }
    
        public String getResultMessage() {
            return resultMessage;
        }
    
        public void setResultMessage(String resultMessage) {
            this.resultMessage = resultMessage;
        }
    
        public Object getResultData() {
            return resultData;
        }
    
        public void setResultData(Object resultData) {
            this.resultData = resultData;
        }
    
        @Override
        public String toString() {
            return "BaseResultVo [resultCode=" + resultCode + ", resultMessage=" + resultMessage
                    + ", resultData=" + resultData + "]";
        }
    
    }
    redis工具类：（可以查阅博客：SpringBoot整合redis更详细文章）
    package cn.cnbuilder.face.station.utils;
    
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    @Component
    public class RedisUtil {
    
        @Autowired
        private RedisTemplate<Object, Object> redisTemplate;
    
        // =============================common============================
    
        /**
         * 添加字符串KEY
         *
         * @param key      字符串KEY
         * @param value    值 可以为对象
         * @param expire   过期时间
         * @param timeUnit TimeUnit中定义的时间单位
         */
        public void addKey(String key, Object value, long expire, TimeUnit timeUnit) {
            this.redisTemplate.opsForValue().set(key, value, expire, timeUnit);
        }
    
        /**
         * 指定缓存失效时间
         *
         * @param key  键
         * @param time 时间(秒)
         * @return
         */
        public boolean expire(String key, long time) {
            try {
                if (time > 0) {
                    redisTemplate.expire(key, time, TimeUnit.SECONDS);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据KEY获取VALUE
         *
         * @param key
         * @return value
         */
        public Object getValue(String key) {
            return this.redisTemplate.opsForValue().get(key);
        }
    
    
        /**
         * 根据key 获取过期时间
         *
         * @param key 键 不能为null
         * @return 时间(秒) 返回0代表为永久有效
         */
        public long getExpire(String key) {
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
        /**
         * 判断key是否存在
         *
         * @param key 键
         * @return true 存在 false不存在
         */
        public boolean hasKey(String key) {
            try {
                return redisTemplate.hasKey(key);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 删除缓存
         *
         * @param key 可以传一个值 或多个
         */
        @SuppressWarnings("unchecked")
        public void del(String... key) {
            if (key != null && key.length > 0) {
                if (key.length == 1) {
                    redisTemplate.delete(key[0]);
                } else {
                    redisTemplate.delete(CollectionUtils.arrayToList(key));
                }
            }
        }
    
    // ============================String=============================
    
        /**
         * 普通缓存获取
         *
         * @param key 键
         * @return 值
         */
        public Object get(String key) {
            return key == null ? null : redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 普通缓存放入
         *
         * @param key   键
         * @param value 值
         * @return true成功 false失败
         */
        public boolean set(String key, Object value) {
            try {
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
    
        }
    
        /**
         * 普通缓存放入并设置时间
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
         * @return true成功 false 失败
         */
        public boolean set(String key, Object value, long time) {
            try {
                if (time > 0) {
                    redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                } else {
                    set(key, value);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 递增
         *
         * @param key   键
         * @param delta 要增加几(大于0)
         * @return
         */
        public long incr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递增因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, delta);
        }
    
        /**
         * 递减
         *
         * @param key   键
         * @param delta 要减少几(小于0)
         * @return
         */
        public long decr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递减因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, -delta);
        }
    
        // ================================Map=================================
    
        /**
         * HashGet
         *
         * @param key  键 不能为null
         * @param item 项 不能为null
         * @return 值
         */
        public Object hget(String key, String item) {
            return redisTemplate.opsForHash().get(key, item);
        }
    
        /**
         * 获取hashKey对应的所有键值
         *
         * @param key 键
         * @return 对应的多个键值
         */
        public Map<Object, Object> hmget(String key) {
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * HashSet
         *
         * @param key 键
         * @param map 对应多个键值
         * @return true 成功 false 失败
         */
        public boolean hmset(String key, Map<String, Object> map) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * HashSet 并设置时间
         *
         * @param key  键
         * @param map  对应多个键值
         * @param time 时间(秒)
         * @return true成功 false失败
         */
        public boolean hmset(String key, Map<String, Object> map, long time) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                if (time > 0) {
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object value) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object value, long time) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                if (time > 0) {
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 删除hash表中的值
         *
         * @param key  键 不能为null
         * @param item 项 可以使多个 不能为null
         */
        public void hdel(String key, Object... item) {
            redisTemplate.opsForHash().delete(key, item);
        }
    
        /**
         * 判断hash表中是否有该项的值
         *
         * @param key  键 不能为null
         * @param item 项 不能为null
         * @return true 存在 false不存在
         */
        public boolean hHasKey(String key, String item) {
            return redisTemplate.opsForHash().hasKey(key, item);
        }
    
        /**
         * hash递增 如果不存在,就会创建一个 并把新增后的值返回
         *
         * @param key  键
         * @param item 项
         * @param by   要增加几(大于0)
         * @return
         */
        public double hincr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, by);
        }
    
        /**
         * hash递减
         *
         * @param key  键
         * @param item 项
         * @param by   要减少记(小于0)
         * @return
         */
        public double hdecr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, -by);
        }
    
        // ============================set=============================
    
        /**
         * 根据key获取Set中的所有值
         *
         * @param key 键
         * @return
         */
        public Set<Object> sGet(String key) {
            try {
                return redisTemplate.opsForSet().members(key);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 根据value从一个set中查询,是否存在
         *
         * @param key   键
         * @param value 值
         * @return true 存在 false不存在
         */
        public boolean sHasKey(String key, Object value) {
            try {
                return redisTemplate.opsForSet().isMember(key, value);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将数据放入set缓存
         *
         * @param key    键
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSet(String key, Object... values) {
            try {
                return redisTemplate.opsForSet().add(key, values);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 将set数据放入缓存
         *
         * @param key    键
         * @param time   时间(秒)
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSetAndTime(String key, long time, Object... values) {
            try {
                Long count = redisTemplate.opsForSet().add(key, values);
                if (time > 0)
                    expire(key, time);
                return count;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 获取set缓存的长度
         *
         * @param key 键
         * @return
         */
        public long sGetSetSize(String key) {
            try {
                return redisTemplate.opsForSet().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 移除值为value的
         *
         * @param key    键
         * @param values 值 可以是多个
         * @return 移除的个数
         */
        public long setRemove(String key, Object... values) {
            try {
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
        // ===============================list=================================
    
        /**
         * 获取list缓存的内容
         *
         * @param key   键
         * @param start 开始
         * @param end   结束 0 到 -1代表所有值
         * @return
         */
        public List<Object> lGet(String key, long start, long end) {
            try {
                return redisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 获取list缓存的长度
         *
         * @param key 键
         * @return
         */
        public long lGetListSize(String key) {
            try {
                return redisTemplate.opsForList().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 通过索引 获取list中的值
         *
         * @param key   键
         * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
         * @return
         */
        public Object lGetIndex(String key, long index) {
            try {
                return redisTemplate.opsForList().index(key, index);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @return
         */
        public boolean lSet(String key, Object value) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒)
         * @return
         */
        public boolean lSet(String key, Object value, long time) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                if (time > 0)
                    expire(key, time);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @return
         */
        public boolean lSet(String key, List<Object> value) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒)
         * @return
         */
        public boolean lSet(String key, List<Object> value, long time) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                if (time > 0)
                    expire(key, time);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据索引修改list中的某条数据
         *
         * @param key   键
         * @param index 索引
         * @param value 值
         * @return
         */
        public boolean lUpdateIndex(String key, long index, Object value) {
            try {
                redisTemplate.opsForList().set(key, index, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 移除N个值为value
         *
         * @param key   键
         * @param count 移除多少个
         * @param value 值
         * @return 移除的个数
         */
        public long lRemove(String key, long count, Object value) {
            try {
                Long remove = redisTemplate.opsForList().remove(key, count, value);
                return remove;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    }

至此我们springBoot整合拦截器就完事了。

终、、

--------------------

以上就是springBoot整合拦截器接口加密 感觉是不是超简单！ 有什么问题可以联系我哈。

以上有个问题，就是用户A登录获得Token 这个时候同一个账号也登录，会把A用户挤下来。

鼓励作者写出更好的技术文档，就请我喝一瓶哇哈哈哈哈哈哈哈。。你们的赞助决定我更新的速度哦！

微信：

[![format_png][]][format_png 1]

支付宝：

[![format_png 2][]][format_png 2 1]

--------------------

感谢一路支持我的人。。。。。
    
    Love me and hold me
    QQ:69673804（16年老号）
    EMAIL:itw@tom.com
    友链交换
    如果有兴趣和本博客交换友链的话，请按照下面的格式在评论区进行评论，我会尽快添加上你的链接。

--------------------

网站名称：猿码优创
    网站地址：http://blog.cnbuilder.cn
    网站描述：年少是你未醒的梦话，风华是燃烬的彼岸花。
    网站Logo/头像： [头像地址](https://blog.cnbuilder.cn/upload/2018/7/avatar20180720144536200.jpg)

欢迎关注猿码优创（联系小优优进内部群哦，新鲜技术优先更新）：

![file][file 3]

2019-

[file]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9ibG9nLmNuYnVpbGRlci5jbi91cGxvYWQvMjAxOC83LyVFNSVCRSVBRSVFNCVCRiVBMSVFNSU5QiVCRSVFNyU4OSU4N18yMDE4MDgyMjE2MjA0NTIwMTgwODIyMTY0NDE4ODQucG5n?x-oss-process=image/format,png
[file 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWcuY25idWlsZGVyLmNuL2Jsb2cvYTZlZDA4YzQ2OTM5MmVkYzE4OTdiZDg3OTI5MzViNDgucG5n?x-oss-process=image/format,png
[file 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWcuY25idWlsZGVyLmNuL2Jsb2cvMGRkNGIwYWE4MGM3OTk2YzhiNGNjZDM5OWYwODcyOTYucG5n?x-oss-process=image/format,png
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9ibG9nLmNuYnVpbGRlci5jbi91cGxvYWQvMjAxOC83L-W-ruS_oeWbvueJh18yMDE4MDcxODE0Mzc1N19tZWl0dV8yMjAxODA3MTgxNTAwMTg2NjYuanBn?x-oss-process=image/format,png
[format_png 1]: http://blog.cnbuilder.cn/upload/2018/7/%E5%BE%AE%E4%BF%A1%E5%9B%BE%E7%89%87_20180718143757_meitu_220180718150018666.jpg
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9ibG9nLmNuYnVpbGRlci5jbi91cGxvYWQvMjAxOC83L-W-ruS_oeaIquWbvl8yMDE4MDcxODE0MzgxNjIwMTgwNzE4MTQzOTEwNjM1LnBuZw?x-oss-process=image/format,png
[format_png 2 1]: http://blog.cnbuilder.cn/upload/2018/7/%E5%BE%AE%E4%BF%A1%E6%88%AA%E5%9B%BE_2018071814381620180718143910635.png
[file 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWcuY25idWlsZGVyLmNuL2Jsb2cvMzk3ZWQzNjMyZjM3M2IzMjQ0YjhiNjBmM2JjN2U4ZjEucG5n?x-oss-process=image/format,png