正文

shiro:hasPermission 标签 ：验证当前用户是否拥有指定权限

IP云
IP云V管理员/6 阅读
11/28
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

1、这些值是存在数据库里的，在哪里找呢？sys_menu 中的permission列。 

<shiro:hasPermission name="cms:article:edit">

他是怎么入库的呢？非菜单项的权限是怎么加入，怎么取出来使用的？

取出来的sql：
SELECT

	a.id ,

	a.parent_id AS "parent.id" ,

	a.parent_ids ,

	a. NAME ,

	a.href ,

	a.target ,

	a.icon ,

	a.sort ,

	a.is_show ,

	a.permission ,

	a.remarks ,

	a.create_by AS "createBy.id" ,

	a.create_date ,

	a.update_by AS "updateBy.id" ,

	a.update_date ,

	a.del_flag ,

	p. NAME AS "parent.name"

FROM

	sys_menu a

LEFT JOIN sys_menu p ON p.id = a.parent_id

WHERE

	a.del_flag = 0

ORDER BY

	a.sort

同一个表里的id与parentid之间的连接；

程序代码是在：com.thinkgem.jeesite.modules.sys.security 这个包里 

/**

	 * 授权查询回调函数, 进行鉴权但缓存中无用户的授权信息时调用

	 */

	@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;

		}

	}


 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);
}
}
}
这一段；
3、那么JSP页面上是什么时候判断的呢？这些数据是什么时候初始化到数据库中的呢？
在使用Shiro标签库前，首先需要在JSP引入shiro标签： 
<%@ taglib prefix="shiro" uri="/WEB-INF/tlds/shiros.tld" %>

当展示一个jsp页面时，页面中如果遇到<shiro:hasPermission name="item:update">，shiro调用realm获取数据库中的权限信息，看item:update是否在权限数据中存在，如果不存在就拒绝访问，如果存在就授权通过。 

package com.thinkgem.jeesite.modules.sys.security;

import java.io.Serializable;

import java.util.Collection;

import java.util.List;

import javax.annotation.PostConstruct;

import org.apache.commons.lang3.StringUtils;

import org.apache.shiro.authc.AuthenticationException;

import org.apache.shiro.authc.AuthenticationInfo;

import org.apache.shiro.authc.AuthenticationToken;

import org.apache.shiro.authc.SimpleAuthenticationInfo;

import org.apache.shiro.authc.credential.HashedCredentialsMatcher;

import org.apache.shiro.authz.AuthorizationInfo;

import org.apache.shiro.authz.Permission;

import org.apache.shiro.authz.SimpleAuthorizationInfo;

import org.apache.shiro.realm.AuthorizingRealm;

import org.apache.shiro.session.Session;

import org.apache.shiro.subject.PrincipalCollection;

import org.apache.shiro.util.ByteSource;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Service;

import com.thinkgem.jeesite.common.config.Global;

import com.thinkgem.jeesite.common.servlet.ValidateCodeServlet;

import com.thinkgem.jeesite.common.utils.Encodes;

import com.thinkgem.jeesite.common.utils.SpringContextHolder;

import com.thinkgem.jeesite.common.web.Servlets;

import com.thinkgem.jeesite.modules.sys.entity.Menu;

import com.thinkgem.jeesite.modules.sys.entity.Role;

import com.thinkgem.jeesite.modules.sys.entity.User;

import com.thinkgem.jeesite.modules.sys.service.SystemService;

import com.thinkgem.jeesite.modules.sys.utils.LogUtils;

import com.thinkgem.jeesite.modules.sys.utils.UserUtils;

import com.thinkgem.jeesite.modules.sys.web.LoginController;

/**

 * 系统安全认证实现类

 * @author ThinkGem

 * @version 2014-7-5

 */

@Service

//@DependsOn({"userDao","roleDao","menuDao"})

public class SystemAuthorizingRealm extends AuthorizingRealm {

	private Logger logger = LoggerFactory.getLogger(getClass());

	private SystemService systemService;

	public SystemAuthorizingRealm() {

		this.setCachingEnabled(false);

	}

	/**

	 * 认证回调函数, 登录时调用

	 */

	@Override

	protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken) {

		UsernamePasswordToken token = (UsernamePasswordToken) authcToken;

		int activeSessionSize = getSystemService().getSessionDao().getActiveSessions(false).size();

		if (logger.isDebugEnabled()){

			logger.debug("login submit, active session size: {}, username: {}", activeSessionSize, token.getUsername());

		}

		// 校验登录验证码

		if (LoginController.isValidateCodeLogin(token.getUsername(), false, false)){

			Session session = UserUtils.getSession();

			String code = (String)session.getAttribute(ValidateCodeServlet.VALIDATE_CODE);

			if (token.getCaptcha() == null || !token.getCaptcha().toUpperCase().equals(code)){

				throw new AuthenticationException("msg:验证码错误, 请重试.");

			}

		}

		// 校验用户名密码

		User user = getSystemService().getUserByLoginName(token.getUsername());

		if (user != null) {

			if (Global.NO.equals(user.getLoginFlag())){

				throw new AuthenticationException("msg:该已帐号禁止登录.");

			}

			byte[] salt = Encodes.decodeHex(user.getPassword().substring(0,16));

			return new SimpleAuthenticationInfo(new Principal(user, token.isMobileLogin()),

					user.getPassword().substring(16), ByteSource.Util.bytes(salt), getName());

		} else {

			return null;

		}

	}

	/**

	 * 获取权限授权信息，如果缓存中存在，则直接从缓存中获取，否则就重新获取， 登录成功后调用

	 */

	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;

		}

	}

	@Override

	protected void checkPermission(Permission permission, AuthorizationInfo info) {

		authorizationValidate(permission);

		super.checkPermission(permission, info);

	}

	@Override

	protected boolean[] isPermitted(List<Permission> permissions, AuthorizationInfo info) {

		if (permissions != null && !permissions.isEmpty()) {

            for (Permission permission : permissions) {

        		authorizationValidate(permission);

            }

        }

		return super.isPermitted(permissions, info);

	}

	@Override

	public boolean isPermitted(PrincipalCollection principals, Permission permission) {

		authorizationValidate(permission);

		return super.isPermitted(principals, permission);

	}

	@Override

	protected boolean isPermittedAll(Collection<Permission> permissions, AuthorizationInfo info) {

		if (permissions != null && !permissions.isEmpty()) {

            for (Permission permission : permissions) {

            	authorizationValidate(permission);

            }

        }

		return super.isPermittedAll(permissions, info);

	}

	/**

	 * 授权验证方法

	 * @param permission

	 */

	private void authorizationValidate(Permission permission){

		// 模块授权预留接口

	}

	/**

	 * 设定密码校验的Hash算法与迭代次数

	 */

	@PostConstruct

	public void initCredentialsMatcher() {

		HashedCredentialsMatcher matcher = new HashedCredentialsMatcher(SystemService.HASH_ALGORITHM);

		matcher.setHashIterations(SystemService.HASH_INTERATIONS);

		setCredentialsMatcher(matcher);

	}

//	/**

//	 * 清空用户关联权限认证，待下次使用时重新加载

//	 */

//	public void clearCachedAuthorizationInfo(Principal principal) {

//		SimplePrincipalCollection principals = new SimplePrincipalCollection(principal, getName());

//		clearCachedAuthorizationInfo(principals);

//	}

	/**

	 * 清空所有关联认证

	 * @Deprecated 不需要清空，授权缓存保存到session中

	 */

	@Deprecated

	public void clearAllCachedAuthorizationInfo() {

//		Cache<Object, AuthorizationInfo> cache = getAuthorizationCache();

//		if (cache != null) {

//			for (Object key : cache.keys()) {

//				cache.remove(key);

//			}

//		}

	}

	/**

	 * 获取系统业务对象

	 */

	public SystemService getSystemService() {

		if (systemService == null){

			systemService = SpringContextHolder.getBean(SystemService.class);

		}

		return systemService;

	}

	/**

	 * 授权用户信息

	 */

	public static class Principal implements Serializable {

		private static final long serialVersionUID = 1L;

		private String id; // 编号

		private String loginName; // 登录名

		private String name; // 姓名

		private boolean mobileLogin; // 是否手机登录

//		private Map<String, Object> cacheMap;

		public Principal(User user, boolean mobileLogin) {

			this.id = user.getId();

			this.loginName = user.getLoginName();

			this.name = user.getName();

			this.mobileLogin = mobileLogin;

		}

		public String getId() {

			return id;

		}

		public String getLoginName() {

			return loginName;

		}

		public String getName() {

			return name;

		}

		public boolean isMobileLogin() {

			return mobileLogin;

		}

//		@JsonIgnore

//		public Map<String, Object> getCacheMap() {

//			if (cacheMap==null){

//				cacheMap = new HashMap<String, Object>();

//			}

//			return cacheMap;

//		}

		/**

		 * 获取SESSIONID

		 */

		public String getSessionid() {

			try{

				return (String) UserUtils.getSession().getId();

			}catch (Exception e) {

				return "";

			}

		}

		@Override

		public String toString() {

			return id;

		}

	}

}

怎么入库的呢？看截图，还是菜单管理中的操作：

4、控制器controller中的权限控制，对应在后台添加菜单时，需要在控制器的方法上添加注解： 
@RequiresPermissions("cms:view")

对应后台添加菜单时：


   

   
 

  
相关阅读
目录[+]