第一次写简书，打算用来做做开发的笔记本吧，以下是Shiro的使用案例，Shiro在SpringBoot框架下的使用，前端使用的是Vue脚手架，在老项目上测试的权限管理，所以只贴上了部分代码。

首先Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。

三个核心组件：Subject, SecurityManager和 Realms.

Subject：代表了当前用户的安全操作，SecurityManager则管理所有用户的安全操作。
SecurityManager：它是Shiro框架的核心，典型的Facade模式，Shiro通过SecurityManager来管理内部组件实例，并通过它来提供安全管理的各种服务。
Realms： Realm充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，Shiro会从应用配置的Realm中查找用户及其权限信息。

下面是在pom.xml中添加的依赖

        <!-- shiro -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.crazycake</groupId>
            <artifactId>shiro-redis</artifactId>
            <version>2.8.20</version>
        </dependency>

        <!--  redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

使用redis缓存做session和权限cache的保存

一般下，Shiro的授权方式为代码方式和注解方式，

代码方式

Subject subject = SecurityUtils.getSubject();
// 判断用户身份是否为管理员
if (subject.hasRole("admin")){ 
    //有权限do sth.
}else{
    //无权限do sth.
}
 // 判断用户是否拥有"listen:high"权限
// 注意一般权限的表达式为三段式或两段式，以:号隔开 *:*:* 或者 *:* 这种格式
// 此处例子代码匹配所有三段式和二段式的权限
if(subject.isPermitted("listen:high")){
    //有权限do sth.
}else{
    //无权限do sth.
}

注解方式

@RequestMapping(value = "/getUser")
@RequiresRoles(value = {"admin"},logical = Logical.OR)
@RequiresPermissions("listen:high")
public Object getUser() {
  //do sth..
}

两种方式各有优劣，代码方式可以在方法内执行一些复杂的逻辑业务，但是请求已经进入了程序方法中，注解方式的好处是能将用户请求拦截在方法外，请求不进入方法，且使用较为方便，但是处理复杂的逻辑业务不是很灵活，需要自行捕捉抛出的异常类来实现业务逻辑。可按个人爱好选择，该dome使用的注解方式来完成。个人推荐注解方式。

以下是注解解析

@RequiresUser：当前Subject必须是应用的用户，才能访问或调用被该注解标注的类，实例，方法。
@RequiresRoles: 当前Subject必须拥有所有指定的角色时，才能访问被该注解标注的方法。如果当天Subject不同时拥有所有指定角色，则方法不会执行还会抛出AuthorizationException异常。
@RequiresPermissions：当前Subject需要拥有某些特定的权限时，才能执行被该注解标注的方法。如果当前Subject不具有这样的权限，则方法不会被执行。
@RequiresGuest：使用该注解标注的类，实例，方法在访问或调用时，当前Subject可以是“gust”身份，不需要经过认证或者在原先的session中存在记录。
@RequiresAuthentication：使用该注解标注的类，实例，方法在访问或调用时，当前Subject必须在当前session中已经过认证。

该项目主要运用@RequiresRoles和@RequiresPermissions两个注解。
示例

//用户拥有user身份则进入
@RequiresRoles("user")

//用户拥有必须同时属于user和admin身份则进入
@RequiresRoles({"user","admin"})

//用户拥有user或者admin身份之一;修改 logical 为 OR 即可
@RequiresRoles(value={"user","admin"},logical=Logical.OR)

@RequiresPermissions 用法类似不在演示

项目结构为：

1544611423(1)_副本.png

Permission 权限实体
Permission.java

/**
 * @author by. 不笑猫丶
 * @date 2018年12月12日
 */
public class Permission {

    private String name;
    private String permission;
    private String code;

    public Permission(){}

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPermission() {
        return permission;
    }

    public void setPermission(String permission) {
        this.permission = permission;
    }

    public String getCode() {
        return code;
    }

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

Roles 权身份实体
Roles.java

/**
 * @author by. 不笑猫丶
 * @date 2018年12月12日
 */
public class Roles {

    private String role;
    private String code;
    private String permission;

    public Roles() {}

    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }

    public String getCode() {
        return code;
    }

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

    public String getPermission() {
        return permission;
    }

    public void setPermission(String permission) {
        this.permission = permission;
    }
}

ShiroConfig Shiro配置类
ShiroConfig.java

/**
 * @author by. 不笑猫丶
 * @date 2018年12月12日
 * shiro配置类
 */
@Configuration
public class ShiroConfig {

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

    @Bean
    public ShiroFilterFactoryBean shirFilter(@Qualifier("securityManager") DefaultWebSecurityManager securityManager) {
        System.out.println("ShiroConfiguration.shirFilter()");
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
        //注意过滤器配置顺序不能颠倒
        //配置退出过滤器，修改了默认logou过滤器，清除相应的缓存信息
        filterChainDefinitionMap.put("/easeApi/authc/user/change/Exit", "logout");
        // 配置需要拦截的链接
        filterChainDefinitionMap.put("/easeApi/authc/**", "ShiroAuthFilter");
        Map<String, Filter> filterMap = new LinkedHashMap<>();
        // 自定义的登录过滤器
        filterMap.put("ShiroAuthFilter", new ShiroAuthFilter());
        shiroFilterFactoryBean.setFilters(filterMap);
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }

    /**
     * 凭证匹配器
     * （由于我们的密码校验交给Shiro的SimpleAuthenticationInfo进行处理了）
     * @return
     */
    @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        hashedCredentialsMatcher.setHashAlgorithmName("md5");//散列算法:这里使用MD5算法;
        hashedCredentialsMatcher.setHashIterations(3);//散列的次数，比如散列两次，相当于 md5(md5(md5("")));
        return hashedCredentialsMatcher;
    }

    /**
     * 注入自定义的Realm类
     **/
    @Bean
    public MyShiroRealm myShiroRealm() {
        MyShiroRealm myShiroRealm = new MyShiroRealm();
        myShiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return myShiroRealm;
    }


    @Bean(name = "securityManager")
    public DefaultWebSecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(myShiroRealm());
        // 自定义session管理 使用redis
        securityManager.setSessionManager(sessionManager());
        // 自定义缓存实现 使用redis
        securityManager.setCacheManager(cacheManager());
        securityManager.setRealm(myShiroRealm());

        return securityManager;
    }


    /**
     * 自定义sessionManager，使用redisSessionDAO生成并保存session
     **/
    @Bean(name = "sessionManager")
    public SessionManager sessionManager() {
        MySessionManager mySessionManager = new MySessionManager();
        mySessionManager.setSessionDAO(redisSessionDAO());
        return mySessionManager;
    }


    /**
     * 配置shiro redisManager
     * @return
     */
    @ConfigurationProperties(prefix = "spring.redis")
    public RedisManager redisManager() {
        RedisManager redisManager = new RedisManager();
        redisManager.setDatabase(3);
        return redisManager;
    }

    /**
     * cacheManager 缓存 redis实现
     * @return
     */
    public RedisCacheManager cacheManager() {
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager());
        return redisCacheManager;
    }

    /**
     * 通过redis RedisSessionDAO shiro sessionDao层的实现 
     * 使用shiro-redis插件
     */
    @Bean("redisSessionDAO")
    public RedisSessionDAO redisSessionDAO() {
        RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
        redisSessionDAO.setRedisManager(redisManager());
        return redisSessionDAO;
    }

    /**
     * 开启shiro aop注解支持.
     * 使用代理方式;所以需要开启代码支持;
     * @param securityManager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(@Qualifier("securityManager") DefaultWebSecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

MyShiroRealm类自定义的Realm，用于身份认证和权限获取。

MyShiroRealm.java

/**
 * @author by. 不笑猫丶
 * @date 2018年12月12日
 * 自定义权限匹配
 */
public class MyShiroRealm extends AuthorizingRealm {

    private static final Logger logger = LoggerFactory.getLogger(MyShiroRealm.class);

    @Autowired
    private UserService userService;

    @Autowired
    private UserDao userDao;

    //通过用户名查找用户拥有权限
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        //获取SimpleAuthenticationInfo中传来的username
        String username = (String) principals.getPrimaryPrincipal();
        Map<String,Object> map = acquire.getHashMap("username", username);
        //得到用户实体
        UserPrivacy userPrivacy = (UserPrivacy) userService.GetMsgformTable(3, map);
        //得到用户身份的代码
        String role = userPrivacy.getRoleCode();
        //通过身份代码查找对应的权限代码的集合
        List<String> perCodeList = userDao.GetRoles(role);
        //权限代码的集合查找对应的权限表达式 如 "listen:high"
        List<String> permission = userDao.GetPermission(perCodeList);
        //添加用户权限
        authorizationInfo.addStringPermissions(permission);
        //添加用户角色
        authorizationInfo.addRole(role);
        return authorizationInfo;
    }

    //身份认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        logger.info("成功进入ShiroRealm认证器");
        //从token中获取用户名.
        String username = (String) token.getPrincipal();
        SimpleAuthenticationInfo authenticationInfo;
        Map<String,Object> map = acquire.getHashMap("username", username);
        // 获取用户信息
        UserPrivacy userPrivacy = (UserPrivacy) userService.GetMsgformTable(3, map);
        if(userPrivacy != null) {
            // 用户存在，检查用户状态 code = 0 为保护状态
            Result result = userService.findNumcheck(username);
            int CODE = result.getStatus();
            if(CODE == 0){
                throw new LockedAccountException();
            } else {
                // 用户存在，且不为保护状态，对密码进行md5转码并与前端传来的password比对
                String password = EncryUtils.getMD5(userPrivacy.getPassword().getBytes());
                //实际项目中，这里可以根据实际情况做缓存，如果不做，Shiro自己也是有时间间隔机制，2分钟内不会重复执行该方法
                authenticationInfo  = new SimpleAuthenticationInfo(username,password,getName());//getName() realm name
            }
        } else {
            return null;
        }
        return authenticationInfo;
    }


    /**
     * 通过用户名清除缓存
     */
    public void clearCache(String username) {
        System.out.println("调用cache清理操作");
        PrincipalCollection principals = new SimplePrincipalCollection(
                new UserPrivacy(username), getName());
        clearCache(principals);
    }

    @Override
    public void clearCache(PrincipalCollection principals) {
        super.clearCache(principals);
    }

AuthException类异常统一处理，因为项目是前后端分离的项目，异常捕捉后不能重定向，只返回json数组。此处只捕捉了UnauthorizedException异常，其他异常可自行实现。

AuthException.java

/**
* @author by. 不笑猫丶
* @date 2018年12月12日
*/
@ControllerAdvice
public class AuthException {

    private static final Logger logger = LoggerFactory.getLogger(AuthException.class);

    @ExceptionHandler(value = UnauthorizedException.class)//处理访问方法时权限不足问题
    public void AuthcErrorHandler(HttpServletResponse res, Exception e) throws IOException {
        logger.info("抛出UnauthorizedException权限异常");
        res.setHeader("Access-Control-Allow-Credentials", "true");
        res.setContentType("application/json; charset=utf-8");
        res.setStatus(HttpServletResponse.SC_OK);
        PrintWriter writer = res.getWriter();
        Map<String, Object> map= new HashMap<>();
        map.put("status", 3);
        map.put("msg", "权限不足");
        writer.write(JSON.toJSONString(map));
        writer.close();
    }
}

ShiroAuthFilter自定义的 Shiro 登录认证过滤器，继承FormAuthenticationFilter类拦截权限不足的请求，并返回JSON数据

ShiroAuthFilter.java

/**
 * @author by. 不笑猫丶
 * @date 2018年12月12日
 */
public class ShiroAuthFilter extends FormAuthenticationFilter {

    private static final Logger logger = LoggerFactory.getLogger(ShiroAuthFilter.class);


    public ShiroAuthFilter() {
        super();
    }

    @Override
    public boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        //Always return true if the request's method is OPTIONS
        if (request instanceof HttpServletRequest) {
            if (((HttpServletRequest) request).getMethod().toUpperCase().equals("OPTIONS")) {
                return true;
            }
        }
        return super.isAccessAllowed(request, response, mappedValue);
    }

    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        logger.info("SHIROFILTER authc拦截");
        HttpServletResponse res = (HttpServletResponse)response;
        res.setHeader("Access-Control-Allow-Origin", "true");
        res.setContentType("application/json; charset=utf-8");
        res.setStatus(HttpServletResponse.SC_OK);
        PrintWriter writer = res.getWriter();
        Map<String, Object> map= new HashMap<>();
        map.put("status", 3);
        map.put("msg", "未登录");
        writer.write(JSON.toJSONString(map));
        writer.close();
        //return false 拦截， true 放行
        return false;
    }
}

ShiroAutoAuthFilter类，自定义的WebFilter过滤器，该项目中用于基于cookie的自动登录场景，在session过期或者关闭浏览器时，session失效或不存在时，在用户cookie尚存的情况下，再次请求被保护的资源时，重新获取认证，在Vue单页面的情况下无需刷新页面重新获取JSESSIONID，该类在JSESSIONID不存在时会自动生成cookie分配到前端页面中。

ShiroAutoAuthFilter.java

/**
 * @author by. 不笑猫丶
 * @date 2018年12月12日
 * /easeApi/authc/ 为受保护资源的路径
 */
@WebFilter(filterName = "shiroAutoAuthFilter", urlPatterns = {"/easeApi/authc/*"})
public class ShiroAutoAuthFilter implements Filter {

    private static final Logger logger = LoggerFactory.getLogger(ShiroAutoAuthFilter.class);

    @Override
    public void destroy() {

    }

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private UserDao userDao;

    public static final String SESSIONID = "JSESSIONID";

    public static final int MAXAGE = 1800;

    public static final String AUTHORIZATION = "Authorization";

    @SuppressWarnings("deprecation")
    @Override
    public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain arg2) throws IOException, ServletException {
        logger.info("shiroAutoAuthFilter被调用");
        HttpServletRequest request = (HttpServletRequest) arg0;
        HttpServletResponse response = (HttpServletResponse) arg1;
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
        //判断用于自动登录的cookie是否存在
        Cookie UIDcookie = com.music.Tools.CookieTool.getCookieByName(request, "UID");
        //用户给request添加header信息 添加Authorization头，保证此次请求不被拦截，实现不刷新页面自动认证的关键
        MyHttpServletRequestWrapper httpReq = new MyHttpServletRequestWrapper(request);
        if (UIDcookie != null) {
            //获取securityManager管理器
            SecurityManager securityManager = (SecurityManager)SpringUtil.getBean("securityManager");
            SecurityUtils.setSecurityManager(securityManager);
            String enUser = URLDecoder.decode(UIDcookie.getValue());
            //得到username和password
            String[] userArray = com.music.Tools.PBEUtils.decrypt(enUser).split("_");
            String username = userArray[0];
            String password = userArray[1];
            Map<String, Object> map = acquire.getHashMap("username,password",username+","+password);
            //检查帐号密码是否有效
            boolean empty = userDao.QueryforPrivacy(map);
            if (!empty) {
                //拦截返回提示
                authcReq(response);
                return;
            }
            //获取当前JSESSIONID，判断是否存在
            Cookie SUID = CookieTool.getCookieByName(request, SESSIONID);
            if(SUID == null) {
                logger.info("JSESSIONID为空直接执行登录操作");
                //JSESSIONID为空直接执行登录操作,并设置JSESSIONID至前端，实现不刷新自动认证
                ShiroTool.authLogin(httpReq, response, username, password);
                arg2.doFilter(httpReq, response);
                return;
            }
            //判断 JSESSIONID 是否存在redis中 
            boolean bol = redisUtil.hasKey(3, "shiro:session:"+SUID.getValue());
            //redis检测JSESSIONID结果为若为false则调用登录操作
            logger.info("redis检测JSESSIONID结果为  :"+bol);
            if(!bol){
                //不存在执行登录操作
                ShiroTool.authLogin(httpReq, response, username, password);
            } else {
                // 存在，判断是否获得认证
                logger.info("JSESSIONID存在，验证是否已认证");
                boolean auth = ShiroTool.isAuthenticated(SUID.getValue(), request, response);
                if (!auth){
                    // 否，获取认证
                    logger.info("JSESSIONID未认证，执行登录操作");
                  
                    ShiroTool.authLogin(httpReq, response, username, password);
                }else {
                    // 是，打印消息
                    logger.info("JSESSIONID已认证");
                }
            }
        }
        arg2.doFilter(httpReq, response);
    }

    private void authcReq(HttpServletResponse response) throws IOException {
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setStatus(HttpServletResponse.SC_OK);
        response.setContentType("application/json; charset=utf-8");
        PrintWriter writer = response.getWriter();
        Map<String, Object> map= new HashMap<>();
        map.put("status", 4);
        map.put("msg", "未找到用户信息");
        writer.write(JSON.toJSONString(map));
        writer.close();
    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {

    }

ShiroTool类shiro工具类，包括判断是否认证的方法和获取缓存用户信息，和login+设置cookie的操作
ShiroTool.java

/**
 * @author by. 不笑猫丶
 * @date 2018年12月12日
 * Shiro 工具类
 */
public class ShiroTool {

    private static final Logger logger = LoggerFactory.getLogger(ShiroTool.class);

    /**
     * 验证是否登陆
     */
    public static boolean isAuthenticated(String sessionID,HttpServletRequest request,HttpServletResponse response){
        boolean status = false;

        SessionKey key = new WebSessionKey(sessionID,request,response);
        try{
            Session se = SecurityUtils.getSecurityManager().getSession(key);
            Object obj = se.getAttribute(DefaultSubjectContext.AUTHENTICATED_SESSION_KEY);
            if(obj != null){
                status = (Boolean) obj;
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            Session se = null;
            Object obj = null;
        }

        return status;
    }
    /**
     * 获取用户登录信息
     */
    public static UserPrivacy getUserPrivacy(String sessionID, HttpServletRequest request, HttpServletResponse response){
        boolean status = false;
        SessionKey key = new WebSessionKey(sessionID,request,response);
        try{
            Session se = SecurityUtils.getSecurityManager().getSession(key);
            Object obj = se.getAttribute(DefaultSubjectContext.PRINCIPALS_SESSION_KEY);
            SimplePrincipalCollection coll = (SimplePrincipalCollection) obj;
            return (UserPrivacy)coll.getPrimaryPrincipal();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
        }
        return null;
    }

    public static void authLogin(MyHttpServletRequestWrapper request, HttpServletResponse response, String username, String password){
        //JSESSIONID为  :true  执行登录操作
        logger.info("Shiro执行登录操作");
        Subject subject = SecurityUtils.getSubject();
        String sidVal = (String) subject.getSession().getId();
        Cookie SIDCookie = CookieTool.setCookie(ShiroAutoAuthFilter.SESSIONID   , sidVal, ShiroAutoAuthFilter.MAXAGE);
        CookieTool.addCookie(response, SIDCookie, true);
        request.putHeader(ShiroAutoAuthFilter.AUTHORIZATION, sidVal);
        logger.info("subject生成的sessionID   ："+sidVal);
        UsernamePasswordToken token = new UsernamePasswordToken(username, password);
        subject.login(token);
    }

}

MySessionManager类自定义的session获取类

MySessionManager.java

/**
 * @author by. 不笑猫丶
 * @date 2018年12月12日
 * 自定义session获取
 */
public class MySessionManager  extends DefaultWebSessionManager {

    private static final Logger logger = LoggerFactory.getLogger(MySessionManager.class);

    private static final String AUTHORIZATION = "Authorization";

    private static final String REFERENCED_SESSION_ID_SOURCE = "Stateless request";

    public MySessionManager() {
        super();
    }

    @Override
    protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
        String id = WebUtils.toHttp(request).getHeader(AUTHORIZATION);
        //如果请求头中有 Authorization 则其值为sessionId
        if (!StringUtils.isEmpty(id)) {
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, REFERENCED_SESSION_ID_SOURCE);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
            logger.info("Session管理器检测到AUTHORIZATION token 使用此token作为Session");
            return id;
        } else {
            //否则按默认规则从cookie取sessionId
            return super.getSessionId(request, response);
        }
    }
}

以上Shiro的配置和一些基本使用已经全部搭建好，可以开始测试了。

测试之前，说一点Dao层需注意的一点，若要实现动态的修改用户权限范围或者身份，需要更改身份时清除对应的认证缓存，否则身份修改后，缓存还在的情况下，shiro会读取缓存中之前的身份信息，所以可前端请求修改User身份时清除redis中的cache权限缓存信息，则下次用户访问受保护的资源时会再次调用权限获取方法 doGetAuthorizationInfo 从数据库中获取相应权限和身份，此时获取的数据为修改后的数据，可以实现简单的用户权限变更操作。

部分Dao层代码

    /**
     * 根据 T 实体修改与column字段相匹配的数据信息
     * @param userPrivacy 实体类
     * @param column 字段名
     * @param value 字段对应值
     * @return TRUE or FALSE
     */
    @Override
    public boolean UpdateToPrivacy(UserPrivacy userPrivacy, String column, String value){
        Integer result = mapper.getUserPrivacyMapper().update(userPrivacy, new EntityWrapper<UserPrivacy>().eq(column, value));
        if (result > 0){
            if(userPrivacy.getRoleCode() != null){
                RealmSecurityManager securityManager = (RealmSecurityManager) SecurityUtils.getSecurityManager();
                //获取MyShiroRealm 
                MyShiroRealm userRealm = (MyShiroRealm)securityManager.getRealms().iterator().next();
                //执行clearCache方法通过username清除缓存
                userRealm.clearCache(value);
            }
            redisUtil.hset(0, "data_"+value,"update", 3, 604800);
            return true;
        }else {
            return false;
        }
    }

Controller层

/**
* @author by. 不笑猫丶
* @date 2018年12月12日
*/          
@RestController
@RequestMapping("/easeApi")
public class controllerTest {

   /**
    * 用户登录
    * @param request
    * @param username
    * @return
    */    
    @RequestMapping("/auth/login")
    public Object login() {
        JSONObject jsonObject = new JSONObject();
        Subject subject = SecurityUtils.getSubject();
        subject.getSession().getId();
        String username = "123456";
        String password = "123456";
        UsernamePasswordToken token = new UsernamePasswordToken(username, password);
        try {
            subject.login(token);
            jsonObject.put("token", subject.getSession().getId());
            jsonObject.put("msg", "登录成功");
        } catch (IncorrectCredentialsException e) {
            jsonObject.put("msg", "密码错误");
        } catch (LockedAccountException e) {
            jsonObject.put("msg", "登录失败，该用户已被冻结");
        } catch (AuthenticationException e) {
            jsonObject.put("msg", "该用户不存在");
        } catch (Exception e) {
            e.printStackTrace();
        }

        return jsonObject;
    }


    @RequestMapping(value = "/authc/getUser")
    //此处为了方便用1,2,3来代表用户身份
    @RequiresRoles(value = {"2"},logical = Logical.OR)
    @RequiresPermissions("listen:high")
    public Object getUser(){
        return "Success";
    }

    @RequestMapping(value = "/authc/changeData")
    @RequiresRoles(value = "1")
    public Object changeData(){
        UserPrivacy userPrivacy = new UserPrivacy();
        userPrivacy.setRoleCode("2"); //修改用户身份
        String username = "123456";
        boolean bol = userDao.UpdateToPrivacy(userPrivacy, "username", username);
        return bol;
    }
}

使用postMan测试
首先测试请求url 127.0.0.1:8080/easeApi/authc/changeData,得到以下结果

{
    "msg": "未登录",
    "status": 3
}

因为在上面changeData()方法中设置了@RequiresRoles(value = "1")，而一开始用户并没有登录所以拒绝访问被保护的资源

然后我们再来测试登录操作,
请求url 127.0.0.1:8080/easeApi/auth/login,得到以下结果:

{
    "msg": "登录成功",
    "token": "b4c00d4f-8724-4ff3-88f6-ba216a06e269"
}

用户登录后测试getUser(),由于初始登录的用户只拥有 "1" 这个身份，用户以 "1" 的身份访问getUser()方法结果如下：

{
    "msg": "权限不足",
    "status": 3
}

结果显示权限不足，因为用户当前的拥有的身份为 "1" ，而请求此方法所需要的权限为 "2" 以上，所以请求被拦截。

此时在执行changeData()身份修改方法讲用户身份修改为"2"成功则返回true，得到结果如下

true

true既修改成功。此时用户拥有了 "2" ，这里再强调一下，在执行changeData()方法的时候Dao层中会执行这串代码，清除对应的username缓存信息。

   if(userPrivacy.getRoleCode() != null){
      RealmSecurityManager securityManager = (RealmSecurityManager) SecurityUtils.getSecurityManager();
      MyShiroRealm userRealm = (MyShiroRealm)securityManager.getRealms().iterator().next();
      userRealm.clearCache(username);
   }

因为缓存清除了，shiro会再次执行doGetAuthorizationInfo权限获取方法从数据库中获取用户权限信息，此时的数据为更新后的数据，从而实现用户身份和权限范围变更。
再次调用getUser()，得到以下结果

Success

大功告成！
文章没有贴出前端Vue的代码，可以使用axios发送AJAX请求即可完成同样的操作，注意做好Vue的跨域操作
在index.js中添加一下代码即可

proxyTable: {
      '/root': {
            // 测试环境
            target: 'http://127.0.0.1:8080/',  // 接口域名
            changeOrigin: true,  //是否跨域
            pathRewrite: {
                '^/root': ''   //需要rewrite重写的,
            }
        },
    },

以上就是SpringBoot+Shiro+Vue前后端分离开发的全部项目实现。本人小白难免出错，请谅解。

我是不笑猫丶
一只爱编程的猫。