spring boot+iview 前后端分离架构之后端鉴权体系的实现（二十四）

「爱情、让人受尽委屈。」 2021-12-14 12:09 167阅读 0赞

### spring boot 与 iview 前后端分离架构之后端鉴权体系的实现（二十四） ###

*  公众号
 *  鉴权体系
 *   *  鉴权体系的规划
     *   *  Auth【用户鉴权】
         *  AuthConfig【用户鉴权的相关配置】
         *  AuthToken【鉴权的相关token】
         *  ReleaseUrl【鉴权的放行方法】
     *  鉴权体系的实现
     *   *  鉴权体系之放行方法的实现
         *   *  系统静态实体类
             *  ReleaseUrl的实现ReleaseUrlProvider
             *  AuthToken的实现AuthTokenProvider
             *  AuthConfig的实现AuthConfigProvider
             *  Auth的实现RedisAuthProvider
             *   *  redis工具类RedisCache
                 *  RedisCache的JSON工具类JsonUtils
                 *  RedisCache的序列化工具类SerializeUtil
                 *  RedisCache的实现
                 *  用户登录dao的实现
                 *  角色dao的实现
                 *  菜单的dao的实现
                 *  RedisAuthProvider的字符串工具类StringUtils
                 *  RedisAuthProvider的实现的代码

# 公众号 #

![在这里插入图片描述][20191218155125364.jpg]  
大家可以直接微信扫描上面的二维码关注我的公众号，然后回复【bg24】 里面就会给到源代码的下载地址同时会附上相应的视频教程，并定期在我的公众号上给大家推送相应的技术文章，欢迎大家关注我的公众号。

# 鉴权体系 #

在前面的开发中我们的前端都是采用mock的形式来实现我们的相关方法的访问，那么到了本章开始我们将真正的和后端开始进行交互了，所有的系统都会涉及到相应的鉴权，那么鉴权主要是通过后端来进行实现的，因此我们首先要构建好我们后端的鉴权体系，后端的鉴权有很多中方式比如security、shiro、oauth2等鉴权方式，如果你理解了整个鉴权体系相信最好的方式还是自己去写一套相应的鉴权体系，因此本章将带大家编写一套基于oauth2标准的用户鉴权体系。

## 鉴权体系的规划 ##

基于oauth2体系的鉴权我们规划了四个接口类，分别是Auth【用户鉴权】、AuthConfig【用户鉴权的相关配置】、AuthToken【鉴权的相关token】、ReleaseUrl【鉴权的放行方法】，因此我们在core目录底下创建以上的四个文件，代码分别如下：

### Auth【用户鉴权】 ###

package com.github.lazyboyl.vcm.web.core.auth;
    
    import com.github.lazyboyl.vcm.web.core.entity.ReturnInfo;
    
    /**
     * @author linzf
     * @since 2019-06-04
     * 类描述：鉴权的接口类
     */
    public interface Auth {
    
        /**
         * 功能描述：实现用户登陆
         * @param loginAccount 用户账号
         * @param loginPassword 用户密码
         * @return 返回登陆结果
         */
        ReturnInfo login(String loginAccount, String loginPassword);
    
        /**
         * 功能描述：实现重新刷新token
         * @param refreshToken token的值
         * @return 返回刷新结果
         */
        ReturnInfo refreshToken(String refreshToken);
    
    }

### AuthConfig【用户鉴权的相关配置】 ###

package com.github.lazyboyl.vcm.web.core.auth;
    
    /**
     * @author linzf
     * @since 2019-06-05
     * 类描述：鉴权的配置接口类
     */
    public interface AuthConfig {
    
        /**
         * 功能描述：获取当前的登陆是否允许单点登陆
         * @return
         */
        boolean isSingleLanding();
    
    }

### AuthToken【鉴权的相关token】 ###

package com.github.lazyboyl.vcm.web.core.auth;
    
    /**
     * 类描述：生成token和refresh token的接口类
     */
    public interface AuthToken {
    
        /**
         * 功能描述：生成authToken的值
         * @return 返回authToken的值
         */
        String authToken();
    
        /**
         * 功能描述：生成refreshToken的值
         * @return 返回refreshToken的值
         */
        String  refreshToken();
    
        /**
         * 功能描述：authToken的过期时间
         * @return 返回过期时间
         */
        int authTokenExpire();
    
        /**
         * 功能描述：refreshToken的过期时间
         * @return 返回过期时间
         */
        int refreshTokenExpire();
    
    }

### ReleaseUrl【鉴权的放行方法】 ###

package com.github.lazyboyl.vcm.web.core.auth;  
/\*\*

*  @author linzf
 *  @since 2019-06-04
 *  类描述：放行的用户权限的地址  
    \*/  
    public interface ReleaseUrl \{
    
    /\*\*
    
     *  功能描述：获取放行的权限的数据
     *  @return 返回放行的权限的数据  
        \*/  
        String getReleaseUrl();

\}  
完成以后的效果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70]

## 鉴权体系的实现 ##

这个环节我们将讲解如何实现我们的鉴权体系

### 鉴权体系之放行方法的实现 ###

基于以上的四个接口的实现类分别是ReleaseUrlProvider【实现ReleaseUrl】、RedisAuthProvider【实现Auth】、AuthTokenProvider【实现AuthToken】、AuthConfigProvider【实现AuthConfig】，因此我们直接在auth目录底下创建一个impl文件夹来存放我们的接口实现类，在这之前我们需要修改下我们的SystemStaticConst.java的系统静态实体类，修改以后的代码如下：

#### 系统静态实体类 ####

package com.github.bg.admin.core.constant;
    
    /**
     * @author linzf
     * @since 2019/4/25
     * 类描述：系统静态实体类
     */
    public class SystemStaticConst {
    
    
        /**
         * 系统返回的编码的key
         */
        public static final String RESULT = "code";
    
        /**
         * 系统返回的消息的key
         */
        public static final String MSG = "msg";
    
        /**
         * 请求操作成功的标志
         */
        public static final int SUCCESS = 200;
    
        /**
         * 请求操作失败的标志
         */
        public static final int FAIL = 400;
    
        /**
         * 当前TOKEN过期
         */
        public static final int AUTH_TOKEN_EXPIRE = 409;
    
        /**
         * 当前用户没有权限
         */
        public static final int AUTH_FAIL = 403;
    
        /**
         * 当前用户没有登录
         */
        public static final int NOT_LOGIN = 401;
    
        /**
         * 登陆的地址
         */
        public static final String LOGIN_URL = "/user/login";
    
        /**
         * 功能描述：刷新token的地址
         */
        public static final String REFRESH_URL = "/user/refreshToken";
    
        /**
         * 获取用户信息地址
         */
        public static final String USER_INFO_URL = "/user/getUserInfo";
    
    
        /**
         * 请求的方式
         */
        public static final String ACTION_TYPE_OPTIONS = "OPTIONS";
    
    
    }

#### ReleaseUrl的实现ReleaseUrlProvider ####

package com.github.bg.admin.core.auth.impl;
    
    
    import com.github.bg.admin.core.auth.ReleaseUrl;
    import com.github.bg.admin.core.constant.SystemStaticConst;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    /**
     * @author linzf
     * @since 2019-06-04
     * 类描述：放行的用户权限的地址
     */
    @Component
    public class ReleaseUrlProvider implements ReleaseUrl {
    
        @Value("${auth.releaseUrl}")
        private String releaseUrl;
    
        /**
         * 功能描述：获取放行的权限的数据
         * @return 返回放行的权限的数据
         */
        @Override
        public String getReleaseUrl() {
            if(releaseUrl==null){
                releaseUrl = "";
            }
            releaseUrl = releaseUrl + ":" + SystemStaticConst.LOGIN_URL + ":" + SystemStaticConst.USER_INFO_URL  + ":" + SystemStaticConst.REFRESH_URL;
            return releaseUrl;
        }
    }

#### AuthToken的实现AuthTokenProvider ####

在实现该接口的时候我们需要实现一个生成唯一token的工具类，因此我们在core目录底下创建一个UuidUtils.java工具类代码如下：

package com.github.bg.admin.core.util;
    
    import java.util.UUID;
    
    /**
     * @author linzf
     * @since 2019-04-25
     * 类描述：uuid生成工具类
     */
    public class UuidUtils {
    
        /**
         * 获取主键uuid
         * @return uuid
         */
        public static String getUUID() {
            return UUID.randomUUID().toString().replaceAll("-", "");
        }
    
        /**
         * 获取随机的UUID字符串
         * @return uuid
         */
        public static String getRandomUuid() {
            UUID uuid = UUID.randomUUID();
            return uuid.toString().toLowerCase();
        }
    
    }

接着实现我们的AuthToken代码如下：

package com.github.bg.admin.core.auth.impl;
    
    
    import com.github.bg.admin.core.auth.AuthToken;
    import com.github.bg.admin.core.util.UuidUtils;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    /**
     * @author linzf
     * @since 2019-06-04
     * 类描述：实现生成authToken和refreshToken的值
     */
    @Component
    public class AuthTokenProvider implements AuthToken {
    
        /**
         * token过期时间
         */
        @Value("${auth.authTokenExpire}")
        private int authTokenExpire;
    
        /**
         * refreshToken过期时间
         */
        @Value("${auth.refreshTokenExpire}")
        private int refreshTokenExpire;
    
        /**
         * 功能描述：生成authToken的值
         *
         * @return 返回authToken的值
         */
        @Override
        public String authToken() {
            return UuidUtils.getUUID();
        }
    
        /**
         * 功能描述：生成refreshToken的值
         *
         * @return 返回refreshToken的值
         */
        @Override
        public String refreshToken() {
            return UuidUtils.getUUID();
        }
    
        /**
         * 功能描述：authToken的过期时间
         *
         * @return 返回过期时间
         */
        @Override
        public int authTokenExpire() {
            if(authTokenExpire>0){
                return authTokenExpire;
            }else{
                return 3600;
            }
        }
    
        /**
         * 功能描述：refreshToken的过期时间
         *
         * @return 返回过期时间
         */
        @Override
        public int refreshTokenExpire() {
            if(refreshTokenExpire>0){
                return refreshTokenExpire;
            }else{
                return 4800;
            }
        }
    }

#### AuthConfig的实现AuthConfigProvider ####

package com.github.bg.admin.core.auth.impl;
    
    
    import com.github.bg.admin.core.auth.AuthConfig;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    /**
     * @author linzf
     * @since 2019-06-05
     * 类描述：鉴权的配置接口类的实现
     */
    @Component
    public class AuthConfigProvider implements AuthConfig {
    
        @Value("${auth.singleLanding}")
        private boolean singleLanding;
    
        @Override
        public boolean isSingleLanding() {
            return singleLanding;
        }
    }

#### Auth的实现RedisAuthProvider ####

RedisAuthProvider的实现是整个鉴权体系的核心，因为所有的逻辑都在该实现里面进行实现的。

##### redis工具类RedisCache #####

首先该鉴权的实现是基于redis的因此我们在utils底下创建了一个RedisCache的工具类代码,首先我们需要在pom.xml中引入以下的依赖：

<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-redis</artifactId>
    		</dependency>

##### RedisCache的JSON工具类JsonUtils #####

由于RedisCache使用到了json工具类，因此我们需要在此处创建一个操作JSON的工具类JsonUtils代码如下：

package com.github.bg.admin.core.util;
    
    import com.fasterxml.jackson.databind.DeserializationFeature;
    import com.fasterxml.jackson.databind.JavaType;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.type.MapType;
    
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @author linzf
     * @since 2019-04-25
     * 类描述：json转换通用工具类
     */
    public class JsonUtils {
    
        // 定义jackson对象
        private static final ObjectMapper MAPPER = new ObjectMapper();
        private static final MapType MAP = MAPPER.getTypeFactory().constructMapType(HashMap.class, String.class, Object.class);
        private static final MapType STRING_MAP = MAPPER.getTypeFactory().constructMapType(HashMap.class, String.class, String.class);
        private static final JavaType LIST_MAP = MAPPER.getTypeFactory().constructParametricType(ArrayList.class, MAP);
    
        static {
            MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        }
    
        private JsonUtils() {
        }
    
        public static <T> T map2object(Map map,Class<T> beanType) {
            try {
                return MAPPER.readValue( MAPPER.writeValueAsString(map), beanType);
            } catch (Exception e) {
                throw new RuntimeException("Jackson处理出现错误", e);
            }
        }
    
    
        public static String objToJson(Object obj) {
            try {
                return MAPPER.writeValueAsString(obj);
            } catch (IOException e) {
                throw new RuntimeException("Jackson处理出现错误", e);
            }
        }
    
        public static <T> T jsonToPojo(String json, Class<T> beanType) {
            try {
                return MAPPER.readValue(json, beanType);
            } catch (IOException e) {
                throw new RuntimeException("Jackson处理出现错误", e);
            }
        }
    
        public static <T> T objToPojo(Object obj, Class<T> valueType) {
            try {
                return MAPPER.readValue(MAPPER.writeValueAsString(obj), valueType);
            } catch (IOException e) {
                throw new RuntimeException("Jackson处理出现错误", e);
            }
        }
    
        public static <T> ArrayList<T> objToList(Object obj, Class<T> valueType) {
            JavaType listType = MAPPER.getTypeFactory().constructParametricType(ArrayList.class, valueType);
            try {
                return MAPPER.readValue(MAPPER.writeValueAsString(obj), listType);
            } catch (IOException e) {
                throw new RuntimeException("Jackson处理出现错误", e);
            }
        }
    
        public static <T> ArrayList<T> jsonToList(String json, Class<T> valueType) {
            JavaType listType = MAPPER.getTypeFactory().constructParametricType(ArrayList.class, valueType);
            try {
                return MAPPER.readValue(json, listType);
            } catch (IOException e) {
                throw new RuntimeException("Jackson处理出现错误", e);
            }
        }
    
        public static HashMap<String, Object> objToMap(Object obj) {
            try {
                return MAPPER.readValue(MAPPER.writeValueAsString(obj), MAP);
            } catch (IOException e) {
                throw new RuntimeException("Jackson处理出现错误", e);
            }
        }
    
        public static HashMap<String, Object> jsonToMap(String json) {
            try {
                return MAPPER.readValue(json, MAP);
            } catch (IOException e) {
                throw new RuntimeException("Jackson处理出现错误", e);
            }
        }
    
        public static HashMap<String, String> jsonToStringMap(String json) {
            try {
                return MAPPER.readValue(json, STRING_MAP);
            } catch (IOException e) {
                throw new RuntimeException("Jackson处理出现错误", e);
            }
        }
    
        public static ArrayList<HashMap<String, Object>> objToMapList(Object obj) {
            try {
                return MAPPER.readValue(MAPPER.writeValueAsString(obj), LIST_MAP);
            } catch (IOException e) {
                throw new RuntimeException("Jackson处理出现错误", e);
            }
        }
    
        public static ArrayList<HashMap<String, Object>> jsonToMapList(String json) {
            try {
                return MAPPER.readValue(json, LIST_MAP);
            } catch (IOException e) {
                throw new RuntimeException("Jackson处理出现错误", e);
            }
        }
    }

##### RedisCache的序列化工具类SerializeUtil #####

由于RedisCache使用到了序列化，因此我们需要在此处创建一个序列化的工具类SerializeUtil代码如下：

package com.github.bg.admin.core.util;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    /**
    * 类描述：
    * @auther linzf
    * @create 2018/2/2 0002
    */
    public class SerializeUtil {
    
        public static byte[] serialize(Object object) {
            ObjectOutputStream oos = null;
            ByteArrayOutputStream baos = null;
            try {
                // 序列化
                baos = new ByteArrayOutputStream();
                oos = new ObjectOutputStream(baos);
                oos.writeObject(object);
                byte[] bytes = baos.toByteArray();
                return bytes;
            } catch (Exception e) {
                throw new RuntimeException(e.getMessage(), e);
            }
        }
    
        public static Object unserialize(byte[] bytes) {
            ByteArrayInputStream bais = null;
            try {
                // 反序列化
                bais = new ByteArrayInputStream(bytes);
                ObjectInputStream ois = new ObjectInputStream(bais);
                return ois.readObject();
            } catch (Exception e) {
                throw new RuntimeException(e.getMessage(), e);
            }
        }
    
    
    }

##### RedisCache的实现 #####

最后我们编写RedisCache工具类，代码如下：

package com.github.bg.admin.core.util;
    
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.dao.DataAccessException;
    import org.springframework.data.redis.connection.RedisConnection;
    import org.springframework.data.redis.core.RedisCallback;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.RedisSerializer;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 类描述：redis操作类
     *
     * @author linzf
     */
    public class RedisCache {
    
        @Autowired
        private RedisTemplate<String, ?> redisTemplate;
    
        /**
         * 功能描述：获取模糊匹配的数据
         * @param key 模糊匹配的key
         * @return 返回查询的结果
         */
        public List<String> queryKeys(String key){
            List<String> keys = new ArrayList<>();
           Set<String> result = redisTemplate.keys(key + "*");
           for(String s : result){
               keys.add(this.getString(s));
           }
           return keys;
        }
    
        /**
         * 功能描述：删除KEY
         * @param key
         * @return
         */
        public void deleteKey(String key){
            redisTemplate.delete(key);
        }
    
        /**
         * 功能描述：获取key的过期时间
         * @param key
         * @return
         */
        public long getExpire(String key){
            return redisTemplate.getExpire(key);
        }
    
        /**
         * 功能描述：判断key是否存在
         * @param key
         * @return
         */
        public boolean hasKey(String key){
            return redisTemplate.hasKey(key);
        }
    
        public boolean setString(String key, String value) {
            boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
                @Override
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                    connection.set(serializer.serialize(key), serializer.serialize(value));
                    return true;
                }
            });
            return result;
        }
    
        public boolean setString(String key, String value, int time) {
            boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
                @Override
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                    connection.set(serializer.serialize(key), serializer.serialize(value));
                    if (time>0) {
                        connection.expire(serializer.serialize(key),time);
                    }
                    return true;
                }
            });
            return result;
        }
    
        public String getString(String key){
            String result = redisTemplate.execute(new RedisCallback<String>() {
                @Override
                public String doInRedis(RedisConnection connection) throws DataAccessException {
                    RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                    byte[] value =  connection.get(serializer.serialize(key));
                    return serializer.deserialize(value);
                }
            });
            return result;
        }
    
    
        public boolean expire(String key, long expire) {
            return redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
    
    
        public <T> boolean setList(String key, List<T> list) {
            String value = JsonUtils.objToJson(list);
            return setString(key,value);
        }
    
    
        public <T> List<T> getList(final String key, Class<T> clz) {
            String json = getString(key);
            if(json!=null){
                List<T> list = JsonUtils.jsonToList(json, clz);
                return list;
            }
            return null;
        }
    
        /**
         * 功能描述：从redis中获取数据
         * @param key
         * @param elementType
         * @param <T>
         * @return
         */
        public <T> T getObject(final String key,Class<T> elementType){
            return redisTemplate.execute(new RedisCallback<T>() {
                @Override
                public T doInRedis(RedisConnection connection)
                        throws DataAccessException {
                    byte[] keybytes = redisTemplate.getStringSerializer().serialize(key);
                    if (connection.exists(keybytes)) {
                        byte[] valuebytes = connection.get(keybytes);
                        @SuppressWarnings("unchecked")
                        T value = (T) SerializeUtil.unserialize(valuebytes);
                        return value;
                    }
                    return null;
                }
            });
        }
    
        /**
         * 功能描述：设值到redis中
         * @param key
         * @param obj
         */
        public void setObject(String key, Object obj) {
            final byte[] bytes = SerializeUtil.serialize(obj);
            redisTemplate.execute(new RedisCallback<Object>() {
                @Override
                public Object doInRedis(RedisConnection connection)
                        throws DataAccessException {
                    connection.set(redisTemplate.getStringSerializer().serialize(key), bytes);
                    return null;
                }
            });
        }
    
        /**
         * 功能描述：设值到redis中
         * @param key
         * @param obj
         * @param time
         */
        public void setObject(String key, Object obj, int time) {
            final byte[] bytes = SerializeUtil.serialize(obj);
            redisTemplate.execute(new RedisCallback<Object>() {
                @Override
                public Object doInRedis(RedisConnection connection)
                        throws DataAccessException {
                    connection.set(redisTemplate.getStringSerializer().serialize(key), bytes);
                    return null;
                }
            });
            this.expire(key,time);
        }
    
    
    
    
        public long rPush(String key, Object obj) {
            String value = JsonUtils.objToJson(obj);
            long result = redisTemplate.execute(new RedisCallback<Long>() {
                @Override
                public Long doInRedis(RedisConnection connection) throws DataAccessException {
                    RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                    long count = connection.rPush(serializer.serialize(key), serializer.serialize(value));
                    return count;
                }
            });
            return result;
        }
    
    
        public String lPop(String key) {
            String result = redisTemplate.execute(new RedisCallback<String>() {
                @Override
                public String doInRedis(RedisConnection connection) throws DataAccessException {
                    RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                    byte[] res =  connection.lPop(serializer.serialize(key));
                    return serializer.deserialize(res);
                }
            });
            return result;
        }
    }

##### 用户登录dao的实现 #####

打开我们的UserDao添加以下代码，代码如下所示：

/**
         * 功能描述：实现用户的登陆
         * @param loginAccount 用户账号
         * @param loginPassword 用户密码
         * @return 返回登陆结果
         */
        User login(@Param("loginAccount")String loginAccount, @Param("loginPassword")String loginPassword);

接着在UserDao.xml添加以下代码，代码如下所示：

<select id="login" resultMap="BaseResultMap">
            select * from t_user where loginAccount = #{loginAccount} and loginPassword = #{loginPassword}
        </select>

##### 角色dao的实现 #####

打开我们的RoleDao添加以下代码，代码如下所示：

/**
         * 功能描述：根据用户ID来获取该用户的相应的绑定的数据
         * @param userId 用户ID
         * @return 返回角色的集合
         */
        List<Role> getUserRoleListByUserId(@Param("userId") String userId);

接着在RoleDao.xml添加以下代码，代码如下所示：

<select id="getUserRoleListByUserId" resultMap="BaseResultMap">
            select tr.* from t_role tr inner join t_user_role tur on tr.roleId = tur.roleId where tur.userId = #{userId}
      </select>

##### 菜单的dao的实现 #####

由于我们的鉴权会对每一个响应的方法进行鉴权，因此我们需要在菜单中增加一个powerPath的字段用于存放我们的菜单的权限集合，因此我们在Tree中增加一个powerPath字段，同时改造我们的TreeDao.xml，改造完成以后的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.github.bg.admin.core.dao.TreeDao">
      <resultMap id="BaseResultMap" type="com.github.bg.admin.core.entity.Tree">
        <id column="treeId" jdbcType="INTEGER" property="treeId" />
        <result column="treeName" jdbcType="VARCHAR" property="treeName" />
        <result column="treeCode" jdbcType="VARCHAR" property="treeCode" />
        <result column="treeState" jdbcType="VARCHAR" property="treeState" />
        <result column="treeType" jdbcType="VARCHAR" property="treeType" />
        <result column="parentTreeId" jdbcType="INTEGER" property="parentTreeId" />
        <result column="parentTreeName" jdbcType="VARCHAR" property="parentTreeName" />
        <result column="crtDate" jdbcType="TIMESTAMP" property="crtDate" />
        <result column="fullPath" jdbcType="VARCHAR" property="fullPath" />
        <result column="powerPath" jdbcType="VARCHAR" property="powerPath"/>
      </resultMap>
    
      
      <select id="getLoginUserPowerPath" resultMap="BaseResultMap">
           select tt.* from t_tree tt inner join t_role_tree ttt on tt.treeId = ttt.treeId where ttt.roleId in
           (select tur.roleId from t_user_role tur where tur.userId = #{userId} )
        </select>
    
    </mapper>

接着在我们的TreeDao中添加以下的代码：

/**
         * 功能描述：根据用户登录的ID来获取权限数据的集合
         * @param userId 用户ID
         * @return 返回数据集合
         */
        List<Tree> getLoginUserPowerPath(@Param("userId") String userId);

##### RedisAuthProvider的字符串工具类StringUtils #####

package com.github.bg.admin.core.util;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.Reader;
    import java.io.UnsupportedEncodingException;
    import java.math.BigDecimal;
    import java.sql.Clob;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.Map;
    
    /**
     * @author linzf
     * @since 2019-04-25
     * 类描述：字符串工具类
     */
    public class StringUtils {
    
        /**
         * 功能描述：比较两个字段是否相等
         * @param str1
         * @param str2
         * @return
         */
        public static boolean equals(String str1,String str2){
           if(str1==null){
               str1 = "";
           }
           if(str2==null){
               str2 ="";
           }
           return str1.equals(str2);
        }
    
        /**
         * 合并byte数组
         *
         * @param data1
         * @param data2
         * @return
         */
        public static byte[] copyarray(byte[] data1, byte[] data2) {
            byte[] data3 = new byte[data1.length + data2.length];
            System.arraycopy(data1, 0, data3, 0, data1.length);
            System.arraycopy(data2, 0, data3, data1.length, data2.length);
    
            return data3;
        }
    
        /**
         * 将16进制的字符串转换为字节数组,例如有16进制字符串"12345678"<br/>
         * 转换后的结果为：{18, 52 ,86 ,120 };
         *
         * @param hex 需要转换的16进制字符串
         * @return 以字节数组返回转换后的结果
         */
        public static byte[] hexStringToByte(String hex) {
            int len = (hex.length() / 2);
            byte[] result = new byte[len];
            char[] achar = hex.toCharArray();
            for (int i = 0; i < len; i++) {
                int pos = i * 2;
                result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
            }
            return result;
        }
    
        private static byte toByte(char c) {
            byte b = (byte) "0123456789ABCDEF".indexOf(c);
            if (b < 0) {
                b = (byte) "0123456789abcdef".indexOf(c);
            }
            return b;
        }
    
        /**
         * 把字节数组转换为十六进制字符串，例如有字节数组<br/>
         * byte [] data = new byte[]{18, 52 ,86 ,120 };转换之后的结果为："12 34 56 78"
         *
         * @param bArray 所要进行转换的数组内容
         * @return 返回转换后的结果，内容用空格隔开
         */
        public static final String bytesToHexString(byte[] bArray) {
            StringBuffer sb = new StringBuffer(bArray.length);
            String sTemp;
            //此处定义的j用于控制每行输出的数据个�?
            int j = 0;
            for (int i = 0; i < bArray.length; i++) {
                sTemp = Integer.toHexString(0xFF & bArray[i]);
                if (sTemp.length() < 2)
                    sb.append(0);
                sb.append(sTemp.toUpperCase());
                j++;
            }
            return sb.toString();
        }
    
        /**
         * BCD码转换成阿拉伯数字，例如有数组byte[] data = new byte[]{0x12,0x34,0x56};<br/>
         * 转换为阿拉伯数字字符串后为"123456"
         *
         * @param bytes 所要转换的十进制BCD字节数组
         * @return BCD码表示的阿拉伯数组内容
         */
        public static String bcd2Str(byte[] bytes) {
            StringBuffer temp = new StringBuffer(bytes.length * 2);
    
            for (int i = 0; i < bytes.length; i++) {
                temp.append((byte) ((bytes[i] & 0xf0) >>> 4));
                temp.append((byte) (bytes[i] & 0x0f));
            }
            return temp.toString().substring(0, 1).equalsIgnoreCase("0") ? temp.toString().substring(1) : temp.toString();
        }
    
        /**
         * 10进制字符串转化为BCD压缩码，例如字符串str = "12345678",压缩之后的字节数组内容为{0x12,0x34,0x56,0x78}；
         *
         * @param asc 需要进行压缩的ASCII码表示的字符串
         * @return 以字节数组返回压缩后的内容
         */
        public static byte[] str2Bcd(String asc) {
            int len = asc.length();
            int mod = len % 2;
    
            if (mod != 0) {
                asc = "0" + asc;
                len = asc.length();
            }
    
            byte abt[] = new byte[len];
            if (len >= 2) {
                len = len / 2;
            }
    
            byte bbt[] = new byte[len];
            abt = asc.getBytes();
            int j, k;
    
            for (int p = 0; p < asc.length() / 2; p++) {
                if ((abt[2 * p] >= '0') && (abt[2 * p] <= '9')) {
                    j = abt[2 * p] - '0';
                } else if ((abt[2 * p] >= 'a') && (abt[2 * p] <= 'z')) {
                    j = abt[2 * p] - 'a' + 0x0a;
                } else {
                    j = abt[2 * p] - 'A' + 0x0a;
                }
                if ((abt[2 * p + 1] >= '0') && (abt[2 * p + 1] <= '9')) {
                    k = abt[2 * p + 1] - '0';
                } else if ((abt[2 * p + 1] >= 'a') && (abt[2 * p + 1] <= 'z')) {
                    k = abt[2 * p + 1] - 'a' + 0x0a;
                } else {
                    k = abt[2 * p + 1] - 'A' + 0x0a;
                }
                int a = (j << 4) + k;
                byte b = (byte) a;
                bbt[p] = b;
            }
            return bbt;
        }
    
        /**
         * 将整型数据转化为2字节的16进制bytes
         *
         * @param len
         * @return 2字节byte数组
         */
        public static byte[] intToHexBytes(int len) {
            byte[] buf = new byte[2];
            int pos = 0;
            buf[pos] = (byte) ((len & 0xff00) >> 8);
            pos++;
            buf[pos] = (byte) (len & 0xff);
            return buf;
        }
    
        /**
         * 把2个字节的字节数组转化为int
         *
         * @param lenData 需要进行转换的字节数组
         * @return int
         */
        public static int hexBytesToint(byte lenData[]) {
            if (lenData.length != 2) {
                return -1;
            }
            int outLen = 0;
            for (int i = 0; i < 2; i++) {
                outLen += ((int) lenData[i] & 0xFF) << 8 * (1 - i);
            }
            return outLen;
        }
    
        /**
         * 将obj转换为float
         *
         * @param obj
         * @return
         */
        public static float getObjFloat(Object obj) {
            return Float.parseFloat(obj == null ? "0" : obj + "");
        }
    
        /**
         * 将obj转换为BigDemical
         *
         * @param obj
         * @return
         */
        public static BigDecimal getObjBigDecimal(Object obj) {
            BigDecimal num;
            if (obj != null) {
                num = new BigDecimal(obj + "");
            } else {
                return null;
            }
            return num;
        }
    
        /**
         * 字符串左补空格操作
         *
         * @param str 待补空格的字符串
         * @param len 补空格之后的字符串长度
         * @return 补空格之后的字符串内容
         * @throws UnsupportedEncodingException
         */
        public static String addSpaceLeft(String str, int len) throws UnsupportedEncodingException {
            StringBuffer s = new StringBuffer();
            s.append(str);
            while (s.toString().getBytes("GBK").length < len) {
                s.insert(0, " ");
            }
            return s.toString();
        }
    
        /**
         * 字符串右补空格操作
         *
         * @param str 待补空格的字符串
         * @param len 补空格后字符串的长度
         * @return 补空格后的字符串
         */
        public static String addSpaceRight(String str, int len) throws UnsupportedEncodingException {
            StringBuffer s = new StringBuffer();
            if (str == null) {
                str = "";
            }
            s.append(str);
            while (s.toString().getBytes("GBK").length < len) {
                s.append(" ");
            }
            return s.toString();
        }
    
        /**
         * 去除字符串两端的空格，如果为null，则返回空字符串
         *
         * @param str 要去除空格的字符串
         * @return 去掉两端空格的字符串
         */
        public static String trim(String str) {
            return (str == null ? "" : str.trim());
        }
    
        /**
         * 判断是否为空字符串，空返回true,非空返回false
         *
         * @param str 判断是否为空字符串
         * @return 空返回true, 非空返回false
         */
        public static boolean isEmpty(Object str) {
            return ((str == null || str.toString().trim().equals("")) ? true : false);
        }
    
        /**
         * 判断是否为空字符串，空返回false,非空返回true
         *
         * @param str 判断是否为空字符串
         * @return 空返回false, 非空返回true
         */
        public static boolean isNotEmpty(String str) {
            return ((str == null || "".equals(str.trim())) ? false : true);
        }
    
        /**
         * 去掉输入字符串尾部的空格和制表符的字符串
         *
         * @param s 输入字符串
         * @return 返回去掉串尾部的空格和制表符的字符串
         */
        public static String trimRight(String s) {
            if (s == null)
                return null;
            char[] ch = s.toCharArray();
            int i = ch.length - 1;
            while (0 <= i && (32 == ch[i] || 9 == ch[i]))
                i--;
            return s.substring(0, i + 1);
        }
    
        /**
         * 去掉输入字符串头部的空格和制表符的字符串
         *
         * @param s 输入字符串
         * @return 返回去掉串头部的空格和制表符的字符串
         */
        public static String trimLeft(String s) {
            if (s == null)
                return null;
            char[] ch = s.toCharArray();
            int i = 0;
            while (i <= ch.length - 1 && (32 == ch[i] || 9 == ch[i]))
                i++;
            return s.substring(i);
        }
    
    
        /**
         * 字符串左补0操作
         *
         * @param str 待补空格的字符串
         * @param len 补空格之后的字符串长度
         * @return 补空格之后的字符串内容
         * @throws UnsupportedEncodingException
         */
        public static String addZeroLeft(String str, int len) {
            StringBuffer s = new StringBuffer();
            s.append(str);
            try {
                while (s.toString().getBytes("GBK").length < len) {
                    s.insert(0, "0");
                }
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            return s.toString();
        }
    
        /**
         * 将obj 转换为String
         *
         * @param obj
         * @return
         */
        public static String getObjStr(Object obj) {
            return obj == null ? "" : obj.toString().trim();
        }
    
        /**
         * 将obj转换为Boolean
         *
         * @param obj
         * @return
         */
        public static boolean getobjBoolean(Object obj) {
            return obj == null ? false : (boolean) obj;
        }
    
        /**
         * 将obj转换为double
         *
         * @param obj
         * @return
         */
        public static double getObjDouble(Object obj) {
            return Double.parseDouble(obj == null ? "0" : obj + "");
        }
    
        /**
         * 将obj转换为int
         *
         * @param obj
         * @return
         */
        public static int getObjInt(Object obj) {
            return Integer.parseInt(obj == null ? "0" : obj + "");
        }
    
        /**
         * oracle.sql.Clob类型转换成String类型
         *
         * @param clob
         * @return
         * @throws SQLException
         * @throws IOException
         */
        public static String clobToString(Clob clob) throws SQLException, IOException {
            String reString = "";
            if (clob != null) {
                Reader is = clob.getCharacterStream();// 得到流
                BufferedReader br = new BufferedReader(is);
                String s = br.readLine();
                StringBuffer sb = new StringBuffer();
                while (s != null) {
                    sb.append(s);
                    s = br.readLine();
                }
                reString = sb.toString();
            }
            return reString;
        }
    
        /**
         * 根据指定字符分隔字符串，
         *
         * @param str
         * @param split
         * @param idx
         * @return 并返回指定下标的数据, 下标超出长度则返回第0个
         */
        public static String getSplitData(String str, String split, int idx) {
            if (StringUtils.isEmpty(str)) {
                return "";
            }
            String resStr = "";
            String[] strList = str.split("\\" + split);
            if (idx < 0) {
                return resStr;
            }
            if (strList.length > idx) {
                return strList[idx];
            } else {
                return strList[0];
            }
        }
    
        /**
         * 字符串转16进制字符串
         *
         * @param s
         * @return
         */
        public static String str2Hex(String s) {
            if (s == null || "".equals(s)) {
                return null;
            }
            try {
                StringBuffer res = new StringBuffer();
                byte[] byteArray = s.getBytes("gbk");
                for (byte b : byteArray) {
                    int v = b & 0xFF;
                    String hv = Integer.toHexString(v);
                    if (hv.length() < 2) {
                        res.append(0);
                    }
                    res.append(hv);
                }
                return res.toString();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * Convert byte[] to hex string.
         * 这里我们可以将byte转换成int，然后利用Integer.toHexString(int)来转换成16进制字符串。
         *
         * @param src byte[] data
         * @return hex string
         */
    
        public static String bytesToHexAllString(byte[] src) {
            StringBuilder stringBuilder = new StringBuilder("");
            if (src == null || src.length <= 0) {
                return "";
            }
            for (int i = 0; i < src.length; i++) {
                int v = src[i] & 0xFF;
                String hv = Integer.toHexString(v);
                if (hv.length() < 2) {
                    stringBuilder.append(0);
                }
                stringBuilder.append(hv);
            }
            return stringBuilder.toString();
        }
    
        /**
         * Convert hex string to byte[]
         *
         * @param hexString the hex string
         * @return byte[]
         */
        public static byte[] hexStringToBytes(String hexString) {
            if (hexString == null || hexString.equals("")) {
                return null;
            }
            hexString = hexString.toUpperCase();
            int length = hexString.length() / 2;
            char[] hexChars = hexString.toCharArray();
            byte[] d = new byte[length];
            for (int i = 0; i < length; i++) {
                int pos = i * 2;
                d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
            }
            return d;
        }
    
        /**
         * Convert char to byte
         *
         * @param c char
         * @return byte
         */
        private static byte charToByte(char c) {
            return (byte) "0123456789ABCDEF".indexOf(c);
        }
    
    
        /**
         * 根据传入的长度数据将其转换为Num个字节的参数偏移地址格式
         *
         * @param len 数据长度
         * @return
         */
    
        public static String toParaLen(int len) {
            String a = Integer.toHexString(len);
            //补0后进行高低位调换
            a = StringUtils.addZeroLeft(a, 8);
            a = a.substring(a.length() - 2, a.length()) + a.substring(a.length() - 4, a.length() - 2) + a.substring(a.length() - 6, a.length() - 4) + a.substring(0, 2);
            return a;
        }
    
        /**
         * 转换长度，将中文字符转换*2
         *
         * @param s
         * @return
         */
        public static int getWordCount(String s) {
            int length = 0;
            for (int i = 0; i < s.length(); i++) {
                int ascii = Character.codePointAt(s, i);
                if (ascii >= 0 && ascii <= 255)
                    length++;
                else
                    length += 2;
            }
            return length;
        }
    
        /**
         * 把所有元素按照“key=value”的模式用“&”字符拼接成字符串,并按照参数名ASCII字典序排序
         * @param params 需要参与字符拼接的参数组
         * @return
         */
        public static String createLinkString(Map<String, Object> params) {
            List<String> keys = new ArrayList<String>(params.keySet());
            Collections.sort(keys);//排序
            String prestr = "";
            for (int i = 0; i < keys.size(); i++) {
                String key = keys.get(i);
                if (null == params.get(key) || params.get(key).toString().isEmpty()){
                    continue;
                }
                prestr = prestr + "&" + key + "=" + params.get(key).toString();
            }
            return prestr.substring(1);
        }
    
    }

##### RedisAuthProvider的实现的代码 #####

package com.github.bg.admin.core.auth.impl;
    
    
    import com.github.bg.admin.core.auth.Auth;
    import com.github.bg.admin.core.auth.AuthToken;
    import com.github.bg.admin.core.constant.SystemStaticConst;
    import com.github.bg.admin.core.dao.RoleDao;
    import com.github.bg.admin.core.dao.TreeDao;
    import com.github.bg.admin.core.dao.UserDao;
    import com.github.bg.admin.core.entity.ReturnInfo;
    import com.github.bg.admin.core.entity.Role;
    import com.github.bg.admin.core.entity.Tree;
    import com.github.bg.admin.core.entity.User;
    import com.github.bg.admin.core.util.RedisCache;
    import com.github.bg.admin.core.util.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import java.util.Date;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * @author linzf
     * @since 2019-06-04
     * 类描述：给予redis实现用户的鉴权
     */
    @Component
    public class RedisAuthProvider implements Auth {
    
        /**
         * redis工具类
         */
        @Autowired
        private RedisCache redisCache;
        /**
         * 生成authToken和refreshToken的接口
         */
        @Autowired
        private AuthToken authToken;
        /**
         * 用户的dao
         */
        @Autowired
        private UserDao userDao;
        /**
         * 菜单的dao
         */
        @Autowired
        private TreeDao treeDao;
        /**
         * 角色的dao
         */
        @Autowired
        private RoleDao roleDao;
        /**
         * 鉴权的配置接口类的实现
         */
        @Autowired
        private AuthConfigProvider authConfigProvider;
    
    
        @Override
        public ReturnInfo login(String loginAccount, String loginPassword) {
            User user = userDao.login(loginAccount, loginPassword);
            if (user == null) {
                return new ReturnInfo(SystemStaticConst.FAIL, "账号密码错误");
            }
            List<Role> roleList = roleDao.getUserRoleListByUserId(user.getUserId());
            StringBuilder userRoles = new StringBuilder();
            for (Role role : roleList) {
                userRoles.append(":").append(role.getRoleCode());
            }
            /**
             * 登录成功以后加载用户的权限，同时使用用户的token作为key，使用权限数据作为value来进行数据的保存
             */
            List<Tree> treeList = treeDao.getLoginUserPowerPath(user.getUserId());
            StringBuilder powerPaths = new StringBuilder();
            for (Tree tree : treeList) {
                if (tree.getPowerPath() != null && !"".equals(tree.getPowerPath())) {
                    powerPaths.append(":").append(tree.getPowerPath());
                }
            }
            String authTokenValue = authToken.authToken();
            String refreshTokenValue = authToken.refreshToken();
            /**
             * 更新用户表中的token的值
             */
            user.setToken(authTokenValue);
            user.setLastLoginDate(new Date());
            userDao.updateByPrimaryKey(user);
            return new ReturnInfo(SystemStaticConst.SUCCESS, "登陆成功", setRedisToken("", authTokenValue, refreshTokenValue, powerPaths.toString(), user, userRoles.toString()));
        }
    
        /**
         * 功能描述：实现重新刷新token
         *
         * @param refreshToken token的值
         * @return 返回刷新token的结果
         */
        @Override
        public ReturnInfo refreshToken(String refreshToken) {
            /**
             * 从redis中获取权限的数据
             */
            String powerPaths = StringUtils.getObjStr(redisCache.getString(refreshToken));
            if ("".equals(powerPaths)) {
                return new ReturnInfo(SystemStaticConst.NOT_LOGIN, "无效的refreshToken");
            }
            /**
             * 从redis中获取当前登录的用户
             */
            User user = redisCache.getObject(refreshToken + "_USER", User.class);
            if (user == null) {
                return new ReturnInfo(SystemStaticConst.NOT_LOGIN, "无效的refreshToken");
            }
            /**
             * 从redis中获取当前登录的用户的角色
             */
            String userRoles = StringUtils.getObjStr(redisCache.getString(refreshToken + "_USER_ROLE"));
            if ("".equals(userRoles)) {
                return new ReturnInfo(SystemStaticConst.NOT_LOGIN, "无效的refreshToken");
            }
            redisCache.deleteKey(refreshToken);
            redisCache.deleteKey(refreshToken + "_USER");
            redisCache.deleteKey(refreshToken + "_USER_ROLE");
            String authTokenValue = authToken.authToken();
            String refreshTokenValue = authToken.refreshToken();
            return new ReturnInfo(SystemStaticConst.SUCCESS, "token刷新成功", setRedisToken(refreshToken, authTokenValue, refreshTokenValue, powerPaths, user, userRoles));
        }
    
        /**
         * 功能描述：实现redis中设置权限的相关数据
         *
         * @param oldRefreshTokenValue 旧的刷新的token
         * @param authTokenValue       鉴权的token
         * @param refreshTokenValue    刷新鉴权的token
         * @param powerPaths           权限集合
         * @param userRoles            角色的集合
         * @return 返回相应的值
         */
        private Map<String, Object> setRedisToken(String oldRefreshTokenValue, String authTokenValue, String refreshTokenValue, String powerPaths, User user, String userRoles) {
            String loginToken = "";
            /**
             * 当前系统是单点登录
             */
            if (!authConfigProvider.isSingleLanding()) {
                loginToken = StringUtils.getObjStr(redisCache.getString(user.getLoginAccount()));
                redisCache.setString(user.getLoginAccount(), authTokenValue + ":" + refreshTokenValue, authToken.refreshTokenExpire());
            } else if (!"".equals(oldRefreshTokenValue)) {
                loginToken = StringUtils.getObjStr(redisCache.getString(user.getLoginAccount()) + "_" + oldRefreshTokenValue);
                redisCache.setString(user.getLoginAccount() + "_" + refreshTokenValue, authTokenValue + ":" + refreshTokenValue, authToken.refreshTokenExpire());
            } else {
                redisCache.setString(user.getLoginAccount() + "_" + refreshTokenValue, authTokenValue + ":" + refreshTokenValue, authToken.refreshTokenExpire());
            }
            if (!"".equals(loginToken)) {
                // 删除另外登陆的账号的token信息
                String loginAuthTokenValue = loginToken.split(":")[0];
                redisCache.deleteKey(loginAuthTokenValue);
                redisCache.deleteKey(loginAuthTokenValue + "_USER");
                redisCache.deleteKey(loginAuthTokenValue + "_USER_ROLE");
                String loginRefreshTokenValue = loginToken.split(":")[1];
                redisCache.deleteKey(loginRefreshTokenValue);
                redisCache.deleteKey(loginRefreshTokenValue + "_USER");
                redisCache.deleteKey(loginRefreshTokenValue + "_USER_ROLE");
            }
            /**
             * 将authToken作为key,powerPaths作为值保存到redis中
             */
            redisCache.setString(authTokenValue, powerPaths, authToken.authTokenExpire());
            /**
             * 将authToken作为key,user作为值保存到redis中
             */
            redisCache.setObject(authTokenValue + "_USER", user, authToken.authTokenExpire());
            /**
             * 将authToken作为key,userRoles作为值保存到redis中
             */
            redisCache.setString(authTokenValue + "_USER_ROLE", userRoles, authToken.authTokenExpire());
            /**
             * 将refreshToken作为key,powerPaths作为值保存到redis中
             */
            redisCache.setString(refreshTokenValue, powerPaths, authToken.refreshTokenExpire());
            /**
             * 将refreshToken作为key,user作为值保存到redis中
             */
            redisCache.setObject(refreshTokenValue + "_USER", user, authToken.refreshTokenExpire());
            /**
             * 将refreshToken作为key,userRoles作为值保存到redis中
             */
            redisCache.setString(refreshTokenValue + "_USER_ROLE", userRoles, authToken.refreshTokenExpire());
            /**
             * 刷新token的时候，socket重新设置映射关系
             */
            if (!"".equals(oldRefreshTokenValue)) {
                String socketToken = redisCache.getString(oldRefreshTokenValue + "_SOCKET");
                if (socketToken != null && !"".equals(socketToken)) {
                    redisCache.setString(refreshTokenValue + "_SOCKET", socketToken);
                    redisCache.deleteKey(oldRefreshTokenValue + "_SOCKET");
                }
            }
            Map<String, Object> result = new HashMap<>(1);
            result.put("token", authTokenValue);
            result.put("refreshToken", refreshTokenValue);
            result.put("expiresIn", redisCache.getExpire(authTokenValue));
            return result;
        }
    }

到此处我们就完成了我们的鉴权体系的实现的构建，但是我们若希望和我们的工程结合起来还需要在下一章来编写具体的实现。  
上一篇文章地址：[spring boot+iview 前后端分离架构之首页退出和修改密码的实现（二十三）][spring boot_iview]  
下一篇文章地址：[spring boot+iview 前后端分离架构之登录的实现（二十五）][spring boot_iview 1]

[20191218155125364.jpg]: /images/20211214/7c71b009e8ac49238b635a28fec9d591.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbnpoZWZlbmc4OQ_size_16_color_FFFFFF_t_70]: /images/20211214/33f2c1dc75134165932084ae26ba979f.png
[spring boot_iview]: https://blog.csdn.net/linzhefeng89/article/details/94599345
[spring boot_iview 1]: https://blog.csdn.net/linzhefeng89/article/details/94721890