spring boot shiro前後端分離自定義filter返回自定義json

自定義校驗工具類(非必須)

import java.util.Collection;
import java.util.Map;
/**
 * 數據校驗工具類
 *
 * @author: chm
 * @create: 2019-08-20
 * @verison: 1.0
 * @description: 數據校驗工具類
 */
public class CheckUtils {

    public static boolean isEmpty(Object o) {
        if (o == null) {
            return true;
        } else {
            if (o instanceof String && o.toString().trim().equals("")) {        //字符串判斷
                return true;
            } else if (o instanceof Iterable && ((Collection) o).size() <= 0) { //判斷set和list
                return true;
            } else if (o instanceof Map && ((Map) o).size() == 0) {             //map判斷
                return true;
            } else if (o instanceof Object[] && ((Object[]) ((Object[]) o)).length == 0) {//object判斷
                return true;
            } else if (isEmptyBasicDataArray(o)) {              //基礎數據類型數組判斷
                return true;
            }
            return false;
        }
    }
    /**
     * 判斷傳入所有可變參數是否有一個爲空
     * @param o
     * @return
     */
    public static boolean isOneEmpty(Object ... o){
        for (Object obj :o ) {
            if(isEmpty(obj)){//有一個爲空，符合條件
                return true;
            }
        }
        return false;
    }

    /**
     * 判斷傳入所有可變參數是否都爲空
     * @param o
     * @return
     */
    public static boolean isAllEmpty(Object ... o){
        for (Object obj :o ) {
            if(!isEmpty(obj)){//有一個不爲空，則不符合條件
                return false;
            }
        }
        return true;
    }

    /**
     * 判斷傳入可變參數是否有一個參數不爲空
     * @param o
     * @return
     */
    public static boolean isOneNotEmpty(Object ... o){
        for (Object obj :o ) {
            if(!isEmpty(obj)){//有一個不爲空，符合條件
                return true;
            }
        }
        return false;
    }

    /**
     * 判斷傳入所有可變參數是否都非空
     * @param o
     * @return
     */
    public static boolean isAllNotEmpty(Object ... o){
        for (Object obj :o ) {
            if(isEmpty(obj)){//有一個爲空，則不符合條件
                return false;
            }
        }
        return true;
    }
    /**
     * 判斷基礎數據類型是否非空
     * @param o
     * @return
     */
    public static boolean isNotEmpty(Object o ){
        return !isEmpty(o);
    }

    /**
     * 校驗基礎數據類型數組是否爲空
     *
     * @param o
     * @return
     */
    public static boolean isEmptyBasicDataArray(Object o) {
        if (o == null) {
            return true;
        } else {
            if (o instanceof int[] && ((int[]) ((int[]) o)).length == 0) {
                return true;
            } else if (o instanceof long[] && ((long[]) ((long[]) o)).length == 0) {
                return true;
            } else if (o instanceof byte[] && ((byte[]) ((byte[]) o)).length == 0) {
                return true;
            } else if (o instanceof char[] && ((char[]) ((char[]) o)).length == 0) {
                return true;
            } else if (o instanceof double[] && ((double[]) ((double[]) o)).length == 0) {
                return true;
            } else if (o instanceof float[] && ((float[]) ((float[]) o)).length == 0) {
                return true;
            } else if (o instanceof short[] && ((short[]) ((short[]) o)).length == 0) {
                return true;
            } else if (o instanceof boolean[] && ((boolean[]) ((boolean[]) o)).length == 0) {
                return true;
            }
        }
        return false;
    }


    /**
     * 判斷基礎數據類型數組是否非空
     * @param o
     * @return
     */
    public static boolean isNotEmptyBasicDataArray(Object o){
        return !isEmptyBasicDataArray(o);
    }

    /**
     * 判斷傳入可變數組是否有一個爲空
     * @param o
     * @return
     */
    public static boolean isOneEmptyBasicDataArray(Object ... o){
        for (Object obj :o ) {
            if(isEmptyBasicDataArray(obj)){//有一個符合條件即可
                return true;
            }
        }
        return false;
    }
    /**
     * 判斷傳入可變數組是否有一個非空
     * @param o
     * @return
     */
    public static boolean isOneNotEmptyBasicDataArray(Object ... o){
        for (Object obj :o ) {
            if(!isEmptyBasicDataArray(obj)){//有一個符合條件即可
                return true;
            }
        }
        return false;
    }

    /**
     * 判斷傳入可變數組是否全部爲空
     * @param o
     * @return
     */
    public static boolean isAllEmptyBasicDataArray(Object ... o){
        for (Object obj :o ) {
            if(!isEmptyBasicDataArray(obj)){//有一個不爲空，則不符合條件
                return false;
            }
        }
        return true;
    }
    /**
     * 判斷傳入可變數組是否全部爲空
     * @param o
     * @return
     */
    public static boolean isAllNotEmptyBasicDataArray(Object ... o){
        for (Object obj :o ) {
            if(isEmptyBasicDataArray(obj)){//有一個不爲空，則不符合條件
                return false;
            }
        }
        return true;
    }
}

自定義錯誤碼枚舉

/**
 * 錯誤碼枚舉
 *
 * @author: chm
 * @create: 2019-08-20
 * @verison: 1.0
 * @description: 錯誤碼枚舉
 */
public enum ErrorCodeEnum {

    /**
     * 字典
     */
    DICT_EXISTED(400, "字典已經存在"),
    ERROR_CREATE_DICT(500, "創建字典失敗"),
    ERROR_WRAPPER_FIELD(500, "包裝字典屬性失敗"),
    ERROR_CODE_EMPTY(500, "字典類型不能爲空"),

    /**
     * 文件上傳
     */
    FILE_READING_ERROR(400, "FILE_READING_ERROR!"),
    FILE_NOT_FOUND(400, "FILE_NOT_FOUND!"),
    UPLOAD_ERROR(500, "上傳圖片出錯"),

    /**
     * 權限和數據問題
     */
    DB_RESOURCE_NULL(400, "數據庫中沒有該資源"),
    NO_PERMITION_AUTHORITY(403, "無訪問權限"),
    NO_PERMITION(405, "登錄認證異常"),
//    NO_PERMITION(405, "權限異常"),
    REQUEST_INVALIDATE(400, "請求數據格式不正確"),
    INVALID_KAPTCHA(400, "驗證碼不正確"),
    CANT_DELETE_ADMIN(600, "不能刪除超級管理員"),
    CANT_FREEZE_ADMIN(600, "不能凍結超級管理員"),
    CANT_CHANGE_ADMIN(600, "不能修改超級管理員角色"),

    /**
     * 賬戶問題
     */
    NOT_LOGIN(401, "當前用戶未登錄"),
    USER_ALREADY_REG(401, "該用戶已經註冊"),
    NO_THIS_USER(400, "沒有此用戶"),
    USER_NOT_EXISTED(400, "沒有此用戶"),
//    ACCOUNT_FREEZED(401, "賬號被凍結"),
    OLD_PWD_NOT_RIGHT(402, "原密碼不正確"),
    TWO_PWD_NOT_MATCH(405, "兩次輸入密碼不一致"),

    /**
     * 錯誤的請求
     */
    MENU_PCODE_COINCIDENCE(400, "菜單編號和副編號不能一致"),
    EXISTED_THE_MENU(400, "菜單編號重複，不能添加"),
    DICT_MUST_BE_NUMBER(400, "字典的值必須爲數字"),
    REQUEST_NULL(400, "請求有錯誤"),
    SESSION_TIMEOUT(400, "會話超時"),
    SERVER_ERROR(500, "服務器異常"),

    /**
     * token異常
     */
    TOKEN_EXPIRED(700, "token過期"),
    TOKEN_ERROR(700, "token驗證失敗"),

    /**
     * 簽名異常
     */
    SIGN_ERROR(700, "簽名驗證失敗"),

    /**
     * 其他
     */
    AUTH_REQUEST_ERROR(400, "賬號密碼錯誤");

    ErrorCodeEnum(int code, String message) {
        this.code = code;
        this.message = message;
    }

    private Integer code;

    private String message;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

自定義返回類

import lombok.Data;

import java.io.Serializable;
import java.util.HashMap;

/**
 * 響應基類
 * @package: com.yinghu.framework.exception
 * @author: chm
 * @create: 2019-08-15
 * @verison: 1.0
 * @description: 響應基類
 */

@Data
public class ResponseBo extends HashMap implements Serializable {
    private static final long serialVersionUID = -8713837118340960775L;

    private static final boolean SUCCESS = true;
    private static final boolean FAIL = false;

    public static final String MESSAGE_VALUE = "message";   //string
    public static final String DATA_VALUE = "data";      //object

    public static final String CODE_VALUE = "code";         //int
    public static final String SUCCESS_VALUE = "success";  //boolean

    public ResponseBo() {
        this.put(SUCCESS_VALUE,SUCCESS);
    }

    public ResponseBo(boolean success){
        this.put(SUCCESS_VALUE,success);
    }

    public static ResponseBo ok(){
        return new ResponseBo();
    }

    public static ResponseBo ok(String message){
        ResponseBo responseBo = new ResponseBo();
        responseBo.put(MESSAGE_VALUE,message);
        return responseBo;
    }
    public static ResponseBo error(){
        return new ResponseBo(FAIL);
    }

    public static ResponseBo error(String message){
        ResponseBo responseBo = new ResponseBo(FAIL);
        responseBo.put(MESSAGE_VALUE,message);
        return responseBo;
    }

    public static ResponseBo error(ErrorCodeEnum e){
        ResponseBo responseBo = new ResponseBo(FAIL);
        responseBo.put(CODE_VALUE,e.getCode());
        responseBo.put(MESSAGE_VALUE,e.getMessage());
        return responseBo;
    }

    public ResponseBo(Integer code, Boolean success, String message, Object data) {
        this.put(CODE_VALUE, code);
        this.put(SUCCESS_VALUE, success);
        this.put(MESSAGE_VALUE, message);
        this.put(DATA_VALUE, data);
    }

    public Integer getCode() {
        return (Integer) get(CODE_VALUE);
    }

    public void setCode(Integer code) {
        this.put(CODE_VALUE, code);
    }

    public Boolean getSuccess() {
        return (boolean) get(SUCCESS_VALUE);
    }

    public void setSuccess(Boolean success) {
        this.put(SUCCESS_VALUE, success);
    }

    public ResponseBo put(String message) {
        this.put(MESSAGE_VALUE, message);
        return this;
    }

    public ResponseBo putData(Object data) {
        this.put(DATA_VALUE, data);
        return this;
    }

    public String getMessage() {
        return (String) this.get(MESSAGE_VALUE);
    }

    /**
     * 獲取字符串
     *
     * @param key
     * @return
     */
    public String getString(String key) {
        Object str = this.get(key);
        return str != null ? (String) str : "";
    }
}

自定義返回數據類

import com.alibaba.fastjson.JSON;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class WebUtilsPro {

    /**
     * 是否是Ajax請求
     *
     * @param request
     * @return
     * @author SHANHY
     * @create 2017年4月4日
     */
    public static boolean isAjaxRequest(HttpServletRequest request) {
        String requestedWith = request.getHeader("x-requested-with");
        if (requestedWith != null && requestedWith.equalsIgnoreCase("XMLHttpRequest")) {
            return true;
        } else {
            return false;
        }
    }

    public static void writer(Object obj , ServletRequest request,ServletResponse response){
        HttpServletRequest req = (HttpServletRequest)request;
        HttpServletResponse resp = (HttpServletResponse) response;

        //前端Ajax請求，則不會重定向
        resp.setHeader("Access-Control-Allow-Origin",  req.getHeader("Origin"));
        resp.setHeader("Access-Control-Allow-Credentials", "true");
        resp.setContentType("application/json;charset=UTF-8");
        try {
            resp.getWriter().write(JSON.toJSONString(obj));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static  void out(HttpServletResponse response, Object obj){
        PrintWriter out = null;
        try {
            response.setCharacterEncoding("UTF-8");
            response.setContentType("application/json; charset=utf-8");
            out = response.getWriter();
            out.write(JSON.toJSONString(obj));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                out.close();
            }
        }
    }
}

定義未登錄filter

import org.apache.shiro.web.filter.authc.FormAuthenticationFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

/**
 * shiro無權限過濾器
 *
 * @package: com.yinghu.platform.filter
 * @author: chm
 * @create: 2019-08-20
 * @verison: 1.0
 * @description: shiro未登錄過濾器
 */
public class SystemUnauthorizedFilter extends FormAuthenticationFilter {

    private static final Logger log = LoggerFactory.getLogger(SystemUnauthorizedFilter.class);
    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
//        return super.onAccessDenied(request, response);
        if (isLoginRequest(request, response)) {
            if (isLoginSubmission(request, response)) {
                if (log.isTraceEnabled()) {
                    log.trace("Login submission detected.  Attempting to execute login.");
                }
                return executeLogin(request, response);
            } else {
                if (log.isTraceEnabled()) {
                    log.trace("Login page view.");
                }
                WebUtilsPro.writer(ResponseBo.error(ErrorCodeEnum.NOT_LOGIN),request,response);
                return false;
            }
        } else {
            WebUtilsPro.writer(ResponseBo.error(ErrorCodeEnum.NO_PERMITION_AUTHORITY),request,response);
            return false;
        }
    }
}

定義無權限filter

import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.StringUtils;
import org.apache.shiro.web.filter.AccessControlFilter;
import org.apache.shiro.web.filter.authz.AuthorizationFilter;
import org.apache.shiro.web.util.WebUtils;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * shiro無權限過濾器
 *
 * @package: com.yinghu.platform.shiro.filter
 * @author: chm
 * @create: 2019-08-20
 * @verison: 1.0
 * @description: shiro無權限過濾器
 */
public class SystemAuthorizationFilter extends AuthorizationFilter {
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object o) throws Exception {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        String url = httpRequest.getRequestURI();
        String reqUrl = httpRequest.getRequestURL().toString();
        System.out.println("請求地址："+reqUrl);
        System.out.println("參數地址："+url);

        String re = "\\/(.*?)\\/";
        Pattern p = Pattern.compile(re);
        Matcher m = p.matcher(url);
        String server="";
        int n=0;
        while(m.find()){
            server=m.group(1);
            if(n==1){
                break;
            }
            n++;
        }

        Subject subject = getSubject(request, response);
        System.out.println("訪問服務名："+server+"；用戶角色是否存在："+subject.hasRole(server));
        if(subject.hasRole(server)){
            //進一步看是否是訪問分類
            String rsearch_cid=request.getParameter("search_cid");
            if(rsearch_cid!=null){
                try{
                    subject.checkPermission(server+"&"+rsearch_cid);
                }catch(Exception e){
                    //拋出異常表示無權限
//                    WebUtilsPro.writer(ResponseBo.error(ErrorCodeEnum.NO_PERMITION_AUTHORITY),request,response);
                    return false;
                }
            }
            return true;
        }

//        WebUtilsPro.writer(ResponseBo.error(ErrorCodeEnum.NO_PERMITION_AUTHORITY),request,response);
        return false;
    }
    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws IOException {
//        WebUtilsPro.writer(ResponseBo.error(ErrorCodeEnum.NO_PERMITION_AUTHORITY),request,response);
        WebUtilsPro.out((HttpServletResponse) response, ResponseBo.error(ErrorCodeEnum.NO_PERMITION_AUTHORITY));//自定義的返回數據
        return Boolean.FALSE;
    }
}

初始化filter

import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.codec.Base64;
import org.apache.shiro.session.SessionListener;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.CookieRememberMeManager;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisManager;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;

import javax.servlet.Filter;
import java.util.*;

/**
 * Shiro 配置類
 *
 */
@Configuration
public class ShiroConfig {

    @Autowired
    private FebsProperties febsProperties;

    @Autowired
    private ShiroAuthMapper authMapper;

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

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

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

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

    /**
     * shiro 中配置 redis 緩存
     *
     * @return RedisManager
     */
    private RedisManager redisManager() {
        RedisManager redisManager = new RedisManager();
        // 緩存時間，單位爲秒
        //redisManager.setExpire(febsProperties.getShiro().getExpireIn()); // removed from shiro-redis v3.1.0 api
        redisManager.setHost(host);
        redisManager.setPort(port);
        if (CheckUtils.isNotEmpty(password))
            redisManager.setPassword(password);
        redisManager.setTimeout(timeout);
        return redisManager;
    }

    private RedisCacheManager cacheManager() {
        RedisCacheManager redisCacheManager = new RedisCacheManager();
//        redisCacheManager.setExpire(1000*30);//設置過期時間30秒
        redisCacheManager.setRedisManager(redisManager());
        return redisCacheManager;
    }

    /**
     * filter工廠
     * @param securityManager
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        System.out.println("ShiroConfiguration.shirFilter()");
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 設置 securityManager
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        addFilter(shiroFilterFactoryBean);//將自定義 的FormAuthenticationFilter注入shiroFilter中

        LinkedHashMap<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        // 設置免認證 url
        String[] anonUrls = StringUtils.splitByWholeSeparatorPreserveAllTokens(febsProperties.getShiro().getAnonUrl(), ",");
        if(CheckUtils.isNotEmpty(anonUrls)) {
            for (String url : anonUrls) {
                filterChainDefinitionMap.put(url, "anon");
            }
        }

        List<Auth> alist = authMapper.findNeedAuth();
        for (Auth auth:alist) {
            if(StringUtils.isNotBlank(auth.getUrl())&&StringUtils.isNotBlank(auth.getPerms()) ){
                filterChainDefinitionMap.put(auth.getUrl(),"perms["+auth.getPerms()+"]");
            }
        }

        // 配置退出過濾器，其中具體的退出代碼 Shiro已經替我們實現了
        filterChainDefinitionMap.put(febsProperties.getShiro().getLogoutUrl(), "logout");
//        filterChainDefinitionMap.put("/","authc");
        // 除上以外所有 url都必須認證通過纔可以訪問，未通過認證自動訪問 LoginUrl
        filterChainDefinitionMap.put("/**", "user");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);

        return shiroFilterFactoryBean;
    }

    /**
     * 安全管理器
     * @return
     */
    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 配置 rememberMeCookie
        securityManager.setRememberMeManager(rememberMeManager());

        // 配置 緩存管理類 cacheManager
        securityManager.setCacheManager(cacheManager());


        securityManager.setSessionManager(sessionManager());

        // 配置 SecurityManager，並注入 shiroRealm
        securityManager.setRealm(shiroRealm());
        return securityManager;
    }



    @Bean(name = "lifecycleBeanPostProcessor")
    public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        // shiro 生命週期處理器
        return new LifecycleBeanPostProcessor();
    }

    @Bean
    public ShiroRealm shiroRealm() {

        return new ShiroRealm();
    }
    private void addFilter(ShiroFilterFactoryBean shiroFilterFactoryBean){
        Map<String, Filter> filters = shiroFilterFactoryBean.getFilters();//獲取filters
        filters.put("perms", authorizationFilter());//將自定義 的FormAuthenticationFilter注入shiroFilter中
        filters.put("loginF", unauthorizedFilter());//將自定義 的FormAuthenticationFilter注入shiroFilter中
        shiroFilterFactoryBean.setFilters(filters);
    }

    @Bean("authorizationFilter")
    public SystemAuthorizationFilter authorizationFilter() {
        return new SystemAuthorizationFilter();
    }

    @Bean("unauthorizedFilter")
    public SystemUnauthorizedFilter unauthorizedFilter(){
        return new SystemUnauthorizedFilter();
    }


    /**
     * rememberMe cookie 效果是重開瀏覽器後無需重新登錄
     *
     * @return SimpleCookie
     */
    private SimpleCookie rememberMeCookie() {
        // 設置 cookie 名稱，對應 login.html 頁面的 <input type="checkbox" name="rememberMe"/>
        SimpleCookie cookie = new SimpleCookie("rememberMe");
        // 設置 cookie 的過期時間，單位爲秒，這裏爲一天
        cookie.setMaxAge(febsProperties.getShiro().getCookieTimeout());
        return cookie;
    }

    /**
     * cookie管理對象
     *
     * @return CookieRememberMeManager
     */
    private CookieRememberMeManager rememberMeManager() {
        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        cookieRememberMeManager.setCookie(rememberMeCookie());
        // rememberMe cookie 加密的密鑰
        cookieRememberMeManager.setCipherKey(Base64.decode("4AvVhmFLUs0KTA3Kprsdag=="));
        return cookieRememberMeManager;
    }

    /**
     * DefaultAdvisorAutoProxyCreator 和 AuthorizationAttributeSourceAdvisor 用於開啓 shiro 註解的使用
     * 如 @RequiresAuthentication， @RequiresUser， @RequiresPermissions 等
     *
     * @return DefaultAdvisorAutoProxyCreator
     */
    @Bean
    @DependsOn({"lifecycleBeanPostProcessor"})
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
        System.out.println("lifecycleBeanPostProcessor");
        System.out.println(febsProperties.getClass());
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }



    @Bean
    public RedisSessionDAO redisSessionDAO() {
        RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
        redisSessionDAO.setRedisManager(redisManager());
        return redisSessionDAO;
    }

    /**
     * session 管理對象
     *
     * @return DefaultWebSessionManager
     */
    @Bean
    public DefaultWebSessionManager sessionManager() {
//        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
        DefaultWebSessionManager sessionManager = new StatelessSessionManager();
        Collection<SessionListener> listeners = new ArrayList<>();
        listeners.add(new ShiroSessionListener());
        // 設置session超時時間，單位爲毫秒
        sessionManager.setGlobalSessionTimeout(febsProperties.getShiro().getSessionTimeout());
        sessionManager.setSessionListeners(listeners);
        sessionManager.setSessionDAO(redisSessionDAO());
        sessionManager.setSessionIdUrlRewritingEnabled(false);
        return sessionManager;
    }
}