在线用户

src/main/java/com/bootdo/common/constant/Constants.java

@@ -0,0 +1,22 @@
+package com.bootdo.common.constant;
+
+/**
+ * Created by y on 2017/11/23.
+ * @author y
+ */
+public interface Constants {
+
+
+    /**
+     * 请求中传输TOKEN键
+     */
+    String LOGIN_TOKEN_KEY = "token";
+
+    /**
+     * 统计 redis lock key
+     */
+    String ONLINE_USER = "CIC:ONLINE:USER";
+
+    String SHIRO_REDIS_SESSION = "CIC:SHIRO_REDIS_SESSION:";
+
+}

src/main/java/com/bootdo/common/redis/shiro/RedisCache.java

@@ -11,6 +11,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
+import com.bootdo.common.constant.Constants;
 import org.apache.shiro.cache.Cache;
 import org.apache.shiro.cache.CacheException;
 import org.apache.shiro.util.CollectionUtils;
@@ -30,7 +31,7 @@ public class RedisCache<K, V> implements Cache<K, V> {
     /**
      * The Redis key prefix for the sessions
      */
-    private String keyPrefix = "shiro_redis_session:";
+    private String keyPrefix = Constants.SHIRO_REDIS_SESSION;
 
     /**
      * Returns the Redis session keys

src/main/java/com/bootdo/common/redis/shiro/RedisSessionDAO.java

@@ -1,5 +1,6 @@
 package com.bootdo.common.redis.shiro;
 
+import com.bootdo.common.constant.Constants;
 import org.apache.shiro.session.Session;
 import org.apache.shiro.session.UnknownSessionException;
 import org.apache.shiro.session.mgt.eis.AbstractSessionDAO;
@@ -26,7 +27,7 @@ public class RedisSessionDAO extends AbstractSessionDAO {
     /**
      * The Redis key prefix for the sessions
      */
-    private String keyPrefix = "shiro_redis_session:";
+    private String keyPrefix = Constants.SHIRO_REDIS_SESSION;
 
     @Override
     public void update(Session session) throws UnknownSessionException {

src/main/java/com/bootdo/common/token/TokenUtil.java

@@ -1,11 +1,15 @@
 package com.bootdo.common.token;
 
+import com.bootdo.common.constant.Constants;
 import com.bootdo.common.utils.*;
 import com.bootdo.system.domain.UserDO;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
 
+import javax.annotation.Resource;
+
 
 /**
  * @author 宋显哲
@@ -13,7 +17,35 @@ import org.springframework.util.StringUtils;
  **/
 @Component
 public final class TokenUtil {
+    @Resource
+    private RedisUtil redisUtil;
+    @Value("${server.session-timeout}")
+    private long tomcatTimeout;
 
+    /**
+     * 从缓存中取校验当前用户是否登录,key的格式为：online:{username}
+     *
+     * @param username 账号
+     * @return 返回1，如果返回空则表示该用户不在线
+     * @throws Exception 异常信息
+     */
+    public String getLoginUser(String username) throws Exception {
+        String value = (String)redisUtil.hget(Constants.ONLINE_USER, username);
+        if(ObjectUtils.isEmpty(value)){
+            return null;
+        } else {
+            return value;
+        }
+    }
+
+    /**
+     * @param username 账号
+     * @param token    token
+     * @throws Exception 异常信息
+     */
+    public void saveLoginUser(String username, String token,String ip, long currTime,String sysFlag) throws Exception {
+        redisUtil.hset(Constants.ONLINE_USER, username, token + "_" + ip + "_" + currTime + "_" + sysFlag, tomcatTimeout);
+    }
     /**
      * 从请求中读取Token
      *

src/main/java/com/bootdo/common/utils/RedisUtil.java

@@ -0,0 +1,652 @@
+package com.bootdo.common.utils;
+
+
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.support.atomic.RedisAtomicLong;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * redis工具
+ */
+public class RedisUtil {
+
+    private RedisTemplate<String, Object> redisTemplate;
+
+    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
+        this.redisTemplate = redisTemplate;  
+    }
+
+    //=============================common============================  
+    /** 
+     * 指定缓存失效时间 
+     * @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 获取过期时间 
+     * @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){
+        redisTemplate.delete(key);
+    }  
+
+    //============================String=============================  
+    /** 
+     * 普通缓存获取 
+     * @param key 键 
+     * @return 值 
+     */  
+    public Object get(String key){  
+        return key==null?null:redisTemplate.opsForValue().get(key);  
+    }
+    /**
+     * 普通缓存获取并刷新过期时间
+     * @param key 键
+     * @return 值
+     */
+    public Object getAndRefresh(String key,Long seconds){
+
+        Object object = key==null?null:redisTemplate.opsForValue().get(key);
+        try {
+            redisTemplate.opsForValue().set(key, object,seconds,TimeUnit.SECONDS);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return object;
+    }
+
+    /** 
+     * 普通缓存放入 
+     * @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;  
+        }  
+    }
+
+    /**
+     *     使用Redis生成全局唯一自增ID
+     */
+    public long generate(String key) {
+        RedisAtomicLong redisAtomicLong = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
+        return redisAtomicLong.incrementAndGet();
+    }
+
+    /** 
+     * 递增 
+     * @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);  
+    }
+
+    /**
+     * 获取所有的值
+     * @param key
+     * @return
+     */
+    public List<Object> hgetValues(String key){
+        return redisTemplate.opsForHash().values(key);
+    }
+
+    /** 
+     * 获取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;  
+        }  
+    }
+
+    // ===============lock ==================
+
+    /**
+     * 加锁
+     * @param key
+     * @param time
+     * @return
+     */
+    public Boolean tryLock(String key,long time) {
+        boolean b =  redisTemplate.opsForValue().setIfAbsent(key,"1");
+        if(b){
+            return redisTemplate.expire(key,time,TimeUnit.SECONDS);
+        } else {
+            return b;
+        }
+    }
+
+    /**
+     * 释放锁
+     * @param key
+     * @return
+     */
+    public void releaseLock(String key) {
+        Object currentValue = redisTemplate.opsForValue().get(key);
+        if (currentValue != null) {
+            redisTemplate.delete(key);
+        }
+    }
+
+    /**
+     * 加锁
+     * @param key
+     * @param time
+     * @return
+     */
+    public Boolean tryLock(String key,String requestId,long time) {
+        boolean b =  redisTemplate.opsForValue().setIfAbsent(key,requestId);
+        if(b){
+            return redisTemplate.expire(key,time,TimeUnit.SECONDS);
+        } else {
+            return b;
+        }
+
+    }
+
+    /**
+     * 释放锁
+     * @param key
+     * @return
+     */
+    public void releaseLock(String key,String requestId) {
+        String currentValue = (String)redisTemplate.opsForValue().get(key);
+        if (currentValue != null && requestId.equals(currentValue)) {
+            redisTemplate.delete(key);
+        }
+    }
+
+    public boolean zSetAdd(String key, Object value, long score) {
+        try {
+            boolean re =  redisTemplate.opsForZSet().add(key, value, score);
+            return re;
+         } catch(Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    public Set zSetRangeByScore(String key, double min, double max) {
+        try {
+            Set value = redisTemplate.opsForZSet().rangeByScore(key, min, max);
+            return value;
+        } catch(Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public Long zSetRemoveRangeByScore(String key, double min, double max) {
+        try {
+            Long value = redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
+            return value;
+         } catch(Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+
+    }
+
+}

src/main/java/com/bootdo/system/config/AuthorizationInterceptor.java

@@ -0,0 +1,79 @@
+package com.bootdo.system.config;
+
+
+
+import com.bootdo.common.constant.Constants;
+import com.bootdo.common.token.Token;
+import com.bootdo.common.token.TokenUtil;
+import com.bootdo.common.utils.IPUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.springframework.stereotype.Component;
+import org.springframework.util.ObjectUtils;
+import org.springframework.web.servlet.HandlerInterceptor;
+import org.springframework.web.servlet.ModelAndView;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * 描述:
+ *
+ * @author y
+ * @create 2018-10-18 15:11
+ */
+@Component
+public class AuthorizationInterceptor implements HandlerInterceptor {
+
+    private static final Logger logger = LogManager.getLogger(AuthorizationInterceptor.class);
+    @Resource
+    private TokenUtil tokenUtil;
+    /**
+     * 解析请求
+     */
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+        try {
+            String tokenStr = request.getHeader(Constants.LOGIN_TOKEN_KEY);
+            if(ObjectUtils.isEmpty(tokenStr)){
+                tokenStr = request.getParameter(Constants.LOGIN_TOKEN_KEY);
+            }
+            if(ObjectUtils.isEmpty(tokenStr)){
+                tokenStr = tokenUtil.createCurrTokenString();
+                if(ObjectUtils.isEmpty(tokenStr)){
+                    logger.error("preHandle =====================tokenStr is null=======================");
+                }
+            }
+            if(!ObjectUtils.isEmpty(tokenStr)){
+                Token token = tokenUtil.getToken(tokenStr);
+                if (token == null) {
+                    logger.error("preHandle =====================token is null=======================");
+                } else {
+                    String ip = null;
+                    try {
+                        ip = IPUtils.getIpAddr(request);
+                    } catch (Exception e){
+                        e.printStackTrace();
+                    }
+                    tokenUtil.saveLoginUser(token.getPayload().getUsername(), tokenStr, ip,System.currentTimeMillis(),"1");
+                }
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return true;
+    }
+
+
+    @Override
+    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
+
+    }
+
+    @Override
+    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
+
+    }
+}

src/main/java/com/bootdo/system/config/AuthorizationInterceptorConf.java

@@ -0,0 +1,44 @@
+package com.bootdo.system.config;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+/**
+ * @author stw
+ * @version 1.0.0 创建于 2018/1/18
+ **/
+@Configuration
+public class AuthorizationInterceptorConf implements WebMvcConfigurer {
+
+    @Autowired
+    AuthorizationInterceptor authorizationInterceptor;
+    /**
+     * 不通过拦截器
+     */
+    private static final String[] EXCLUDE_RRI = {
+            //不拦截公共资源
+            "/webjars/**",
+            "/error",
+            "/v2/api-docs",
+            "/swagger-resources/configuration/security",
+            "/swagger-resources/configuration/ui",
+            "/swagger-resources",
+            "/swagger-ui.html",
+            "/static/**",
+            //不拦截接口
+            "/login",
+            "/ssoLogin",
+            "/files/**"
+    };
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        registry.addInterceptor(authorizationInterceptor)
+                .addPathPatterns("/**")
+                .excludePathPatterns(EXCLUDE_RRI);
+    }
+
+
+}

src/main/java/com/bootdo/system/config/RedisConfig.java

@@ -0,0 +1,39 @@
+package com.bootdo.system.config;
+
+
+import com.bootdo.common.utils.RedisUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+@Configuration
+public class RedisConfig {
+
+    @Bean
+    @Autowired
+    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
+
+        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
+        redisTemplate.setConnectionFactory(redisConnectionFactory);
+        redisTemplate.setKeySerializer(new StringRedisSerializer());
+        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
+        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
+        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
+
+
+        return redisTemplate;
+    }
+
+    @Bean(name = "redisUtil")
+    @Autowired
+    public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {
+        RedisUtil redisUtil = new RedisUtil();
+        redisUtil.setRedisTemplate(redisTemplate);
+        return redisUtil;
+    }
+
+}

src/main/java/com/bootdo/system/config/ShiroConfig.java

@@ -135,7 +135,7 @@ public class ShiroConfig {
         filterChainDefinitionMap.put("/druid/**", "anon");
         filterChainDefinitionMap.put("/upload/**", "anon");
         filterChainDefinitionMap.put("/files/**", "anon");
-        filterChainDefinitionMap.put("/logout", "logout");
+        //filterChainDefinitionMap.put("/logout", "logout");
         filterChainDefinitionMap.put("/", "anon");
         filterChainDefinitionMap.put("/blog", "anon");
         filterChainDefinitionMap.put("/blog/open/**", "anon");

src/main/java/com/bootdo/system/controller/LoginController.java

@@ -13,6 +13,7 @@ import com.bootdo.common.token.TokenUtil;
 import com.bootdo.common.utils.*;
 import com.bootdo.system.domain.MenuDO;
 import com.bootdo.system.service.MenuService;
+import com.bootdo.system.service.SessionService;
 import org.apache.shiro.SecurityUtils;
 import org.apache.shiro.authc.UsernamePasswordToken;
 import org.apache.shiro.subject.Subject;
@@ -34,7 +35,6 @@ import java.util.Objects;
 @Controller
 public class LoginController extends BaseController {
     private final Logger logger = LoggerFactory.getLogger(this.getClass());
-
     @Autowired
     MenuService menuService;
     @Autowired
@@ -51,6 +51,9 @@ public class LoginController extends BaseController {
     @Autowired
     private ThirdPartSsoConfig thirdPartSsoConfig;
 
+    @Autowired
+    private SessionService sessionService;
+
 
     @Resource
     private TokenUtil tokenUtil;
@@ -201,7 +204,11 @@ public class LoginController extends BaseController {
 
     @GetMapping("/logout")
     String logout() {
-        ShiroUtils.logout();
+        try {
+            sessionService.logout();
+        } catch (Exception e){
+            e.printStackTrace();
+        }
         return "redirect:/login";
     }
 

src/main/java/com/bootdo/system/service/SessionService.java

@@ -20,6 +20,9 @@ public interface SessionService {
 	List<UserDO> listOnlineUser();
 
 	Collection<Session> sessionList();
-	
+
+	boolean logout() throws Exception;
+
 	boolean forceLogout(String sessionId,HttpServletRequest request) throws Exception;
+
 }

src/main/java/com/bootdo/system/service/impl/SessionServiceImpl.java

@@ -1,6 +1,8 @@
 package com.bootdo.system.service.impl;
 
+import com.bootdo.common.constant.Constants;
 import com.bootdo.common.utils.IPUtils;
+import com.bootdo.common.utils.ShiroUtils;
 import com.bootdo.system.domain.UserDO;
 import com.bootdo.system.domain.UserOnline;
 import com.bootdo.system.service.SessionService;
@@ -14,10 +16,12 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
+import javax.annotation.Resource;
 import javax.servlet.http.HttpServletRequest;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import com.bootdo.common.utils.RedisUtil;
 
 /**
  * 待完善
@@ -31,6 +35,8 @@ public class SessionServiceImpl implements SessionService {
 
     @Value("${api-allow-ip}")
     private String apiAllowIp;
+    @Resource
+    private RedisUtil redisUtil;
 
     @Autowired
     public SessionServiceImpl(SessionDAO sessionDAO) {
@@ -85,6 +91,15 @@ public class SessionServiceImpl implements SessionService {
         return list;
     }
 
+    @Override
+    public boolean logout() throws Exception {
+
+        //删除登录的用户
+        redisUtil.hdel(Constants.ONLINE_USER, ShiroUtils.getUser().getUsername());
+        ShiroUtils.logout();
+        return true;
+    }
+
     @Override
     public Collection<Session> sessionList() {
         return sessionDAO.getActiveSessions();
@@ -97,8 +112,21 @@ public class SessionServiceImpl implements SessionService {
         if (!apiAllowIp.contains(ip)) {
             throw new Exception("不允许访问");
         }
+
         Session session = sessionDAO.readSession(sessionId);
+
+        SimplePrincipalCollection principalCollection = (SimplePrincipalCollection) session
+                .getAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY);
+        UserDO userDO = (UserDO) principalCollection.getPrimaryPrincipal();
+        //删除登录的用户
+        redisUtil.hdel(Constants.ONLINE_USER, userDO.getUsername());
+
         sessionDAO.delete(session);
+
         return true;
     }
+
+
+
+
 }