shiro框架学习（三）

在使用shiro框架时，可以通过继承AuthorizingRealm类中，并重写

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken)和

protected AuthorizationInfo getAuthorizationInfo(PrincipalCollection principals)这两个方法来实现登录验证和权限获取。

@Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken) {
        
        UsernamePasswordToken token = (UsernamePasswordToken) authcToken;
        String username = token.getUsername();
        Session session = UserUtils.getSession();
        session.setAttribute("loginFailType", null);
        session.setAttribute("loginFailMessage", null);
        int activeSessionSize = getSystemService().getSessionDao().getActiveSessions(false).size();
                User user = UserUtils.getByLoginName2(username);
        if (user == null) {
            session.setAttribute("loginFailType", "UserNotExist");
            session.setAttribute("loginFailMessage", "用户名不存在，请输入正确的用户名.");
            throw new AuthenticationException("msg:用户名不存在，请输入正确的用户名.");
        }    
        String sessionid = user.getSessionid();
                if (!Global.TRUE.equals(Global.getConfig("sameAccountLogin")) && !"1".equals(user.getId())){
            Collection<Session> sessions = getSystemService().getSessionDao().getActiveSessions(true, null, session);
            if (sessions != null && sessions.size() > 0){
                for (Session sessioni : sessions){
                    Object siid = sessioni.getId();
                    if(siid.equals(sessionid)){
                                                getSystemService().getSessionDao().delete(sessioni);
                    }
                                    }                
            }
        }
                int    maxSessionSize = Integer.valueOf(Global.getConfig("maxSessionSize"));         
        if(activeSessionSize > maxSessionSize){
            session.setAttribute("loginFailType", "usersOverload");
            session.setAttribute("loginFailMessage", "登陆人数过多,服务器繁忙，请稍后重试.");
            throw new AuthenticationException("msg:登陆人数过多,服务器繁忙，请稍后重试.");
        }
        if (logger.isDebugEnabled()){
            logger.debug("login submit, active session size: {}, username: {}", activeSessionSize, username);
        }            
                if (Global.TRUE.equals(Global.getConfig("validateCodeLogin")) && LoginController.isValidateCodeLogin(username, false, false)){
            String code = (String)session.getAttribute(ValidateCodeServlet.VALIDATE_CODE);
            if (token.getCaptcha() == null || !token.getCaptcha().toUpperCase().equals(code)){
                session.setAttribute("loginFailType", "verificationCodeError");
                session.setAttribute("loginFailMessage", "验证码错误, 请重试.");
                throw new AuthenticationException("msg:验证码错误, 请重试.");
            }
        }
        
                String message = UserUtils.isForbidLogin(username);
        if (StringUtils.isNoneBlank(message)){
                session.setAttribute("loginFailType", "forbidLogin");
                session.setAttribute("loginFailMessage", message);
                throw new AuthenticationException("msg:"+message,new Throwable());
        }
                return new SimpleAuthenticationInfo(new Principal(user, token.isMobileLogin()),
                user.getPassword().toLowerCase(), getName());

    }
    }

/**
     * 获取权限授权信息，如果缓存中存在，则直接从缓存中获取，否则就重新获取， 登录成功后调用
     */
    protected AuthorizationInfo getAuthorizationInfo(PrincipalCollection principals) {
        if (principals == null) {
            return null;
        }
        
        AuthorizationInfo info = null;

        info = (AuthorizationInfo)UserUtils.getCache(UserUtils.CACHE_AUTH_INFO);

        if (info == null) {
            info = doGetAuthorizationInfo(principals);
            if (info != null) {
                UserUtils.putCache(UserUtils.CACHE_AUTH_INFO, info);
            }
        }

        return info;
    }

    /**
     * 授权查询回调函数, 进行鉴权但缓存中无用户的授权信息时调用
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        Principal principal = (Principal) getAvailablePrincipal(principals);
        // 获取当前已登录的用户
        if (!Global.TRUE.equals(Global.getConfig("user.multiAccountLogin"))){
            Collection<Session> sessions = getSystemService().getSessionDao().getActiveSessions(true, principal, UserUtils.getSession());
            if (sessions.size() > 0){
                // 如果是登录进来的，则踢出已在线用户
                if (UserUtils.getSubject().isAuthenticated()){
                    for (Session session : sessions){
                        getSystemService().getSessionDao().delete(session);
                    }
                }
                // 记住我进来的，并且当前用户已登录，则退出当前用户提示信息。
                else{
                    UserUtils.getSubject().logout();
                    throw new AuthenticationException("msg:账号已在其它地方登录，请重新登录。");
                }
            }
        }
        User user = getSystemService().getUserByLoginName(principal.getLoginName());
        if (user != null) {
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
            List<Menu> list = UserUtils.getMenuList();
            for (Menu menu : list){
                if (StringUtils.isNotBlank(menu.getPermission())){
                    // 添加基于Permission的权限信息
                    for (String permission : StringUtils.split(menu.getPermission(),",")){
                        info.addStringPermission(permission);
                    }
                }
            }
            // 添加用户权限
            info.addStringPermission("user");
            // 添加用户角色信息
            for (Role role : user.getRoleList()){
                info.addRole(role.getEnname());
            }
            // 更新登录IP和时间
            getSystemService().updateUserLoginInfo(user);
            // 记录登录日志
            LogUtils.saveLog(Servlets.getRequest(), "系统登录");
            return info;
        } else {
            return null;
        }
    }