如何在spring项目中使用shiro进行权限管理

最新推荐文章于 2024-10-01 09:29:59 发布
最新推荐文章于 2024-10-01 09:29:59 发布
阅读量1k 收藏 1
点赞数
分类专栏： shiro
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liyunyu2/article/details/48341187
版权

      也不知道是什么原因，或许是经常在网上看到它的好处，不过写个博客确实可以整理下自己学到的知识，方便以后查找。废话不多，越来越有写篇博客的想法下面讲讲我是怎样在项目中加入shiro，然后再项目中怎样使用shiro实现权限管理，以及在使用shiro的过程中遇到的为题以及解决的方法。

     1、怎样在项目中加入shiro

 因为项目是使用osgi+spring+jpa实现，使用maven的方式通过pom文件添加ja包，所以只需要在pom.xml文件中添加下面这些依赖
            <!-- shiro -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-ehcache</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-web</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-quartz</artifactId>
            <version>1.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.2.2</version>
        </dependency>


<build>
		<plugins>
			<plugin>
				<groupId>org.apache.felix</groupId>
				<artifactId>maven-bundle-plugin</artifactId>
				<configuration>
					<instructions>
						<Bundle-SymbolicName>${project.artifactId}</Bundle-SymbolicName>
						<Bundle-Description>${project.description}</Bundle-Description>
						<Embed-Dependency>shiro-core,shiro-ehcache,shiro-web,shiro-quartz,shiro-spring,httpclient</Embed-Dependency>
						<Embed-Transitive>true</Embed-Transitive>
						<Embed-Directory>dependency</Embed-Directory>
						<Import-Package>


Ok,现在已经把shiro相关的jar包加到项目中，下面将在spring的beans.xml文件中配置shiro相关的bean和属性，项目使用Ehcache管理shiro的缓存（为了方便，下面已经把shiro跟spring相关的bean配置全部粘贴下来），期中shiro的realm自己实现，新建一个类继承Realm类即可。


<?xml version="1.0" encoding="GBK"?>
<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor
    license agreements. See the NOTICE file distributed with this work for additional
    information regarding copyright ownership. The ASF licenses this file to
    You under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of
    the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required
    by applicable law or agreed to in writing, software distributed under the
    License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
    OF ANY KIND, either express or implied. See the License for the specific
    language governing permissions and limitations under the License. -->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:osgi="http://www.springframework.org/schema/osgi"
    xmlns:camel="http://camel.apache.org/schema/spring" xmlns:bean="http://servicemix.apache.org/bean/1.0"
    xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://www.springframework.org/schema/osgi  http://www.springframework.org/schema/osgi/spring-osgi.xsd
       http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd">


    <!-- 缓存管理器 使用Ehcache实现 -->
    <bean id="cacheManager"
        class="cn.gzydt.infoshare.security.cache.impl.DefaultCacheManager">
        <property name="cacheManagerConfigFile" value="classpath:ehcache/ehcache.xml" />
    </bean>



    <!-- 会话ID生成器 -->
    <bean id="sessionIdGenerator"
        class="org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator" />
    <!-- 会话DAO -->
    <bean id="sessionDAO"
        class="org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO">
        <property name="activeSessionsCacheName" value="shiro-activeSessionCache" />
        <property name="sessionIdGenerator" ref="sessionIdGenerator" />
    </bean>
    <!-- 会话验证调度器 -->
    <bean id="sessionValidationScheduler"
        class="org.apache.shiro.session.mgt.quartz.QuartzSessionValidationScheduler">
        <property name="sessionValidationInterval" value="1800000" />
        <property name="sessionManager" ref="sessionManager" />
    </bean>
    <!-- 会话管理器 -->
    <bean id="sessionManager"
        class="cn.gzydt.infoshare.security.session.impl.SessionManagerImpl">
        <!-- session -->
        <property name="globalSessionTimeout" value="${security_shiro.globalSessionTimeout}" />
        <property name="deleteInvalidSessions" value="true" />
        <property name="sessionValidationSchedulerEnabled" value="true" />
        <property name="sessionValidationScheduler" ref="sessionValidationScheduler" />
        <property name="sessionDAO" ref="sessionDAO" />
    </bean>


    <!-- Realm实现 -->
    <bean id="userRealm" class="cn.gzydt.infoshare.security.realm.custom.UserRealm">
        <property name="entityServer" ref="entityServer"></property>
        <property name="systemService" ref="systemService"></property>
        <property name="cachingEnabled" value="true" />
        <property name="authenticationCachingEnabled" value="false" />
        <property name="authenticationCacheName" value="authenticationCache" />
        <property name="authorizationCachingEnabled" value="true" />
        <property name="authorizationCacheName" value="authorizationCache" />
    </bean>


    <!-- 安全管理器 -->
    <bean id="securityManager" class="org.apache.shiro.mgt.DefaultSecurityManager">
        <property name="realms">
            <list>
                <ref bean="userRealm" />
            </list>
        </property>
        <property name="sessionManager" ref="sessionManager" />
        <property name="cacheManager" ref="cacheManager" />
    </bean>
    <!-- 相当于调用SecurityUtils.setSecurityManager(securityManager) -->
    <bean
        class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
        <property name="staticMethod"
            value="org.apache.shiro.SecurityUtils.setSecurityManager" />
        <property name="arguments" ref="securityManager" />
    </bean>
    <!-- Shiro生命周期处理器 -->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />


</beans>

至此，已经把shiro交给了spring进行管理，下面也把Ehcache缓存的配置也粘出来（在项目路径下新建一个文件夹Ehcache,然后再新建一个Ehcache.xml文件，把下面的配置复制到Ehcache.xml文件中即可，不懂的地方百度一下，网上很多）


<?xml version="1.0" encoding="UTF-8"?>
<ehcache name="shirocache">

    <diskStore path="java.io.tmpdir"/>

    <cache name="passwordRetryCache"
           maxElementsInMemory="50000"
           eternal="false"
           timeToIdleSeconds="600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>

    <cache name="authorizationCache"
           maxElementsInMemory="50000"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>

    <cache name="authenticationCache"
           maxElementsInMemory="50000"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>

    <cache name="shiro-activeSessionCache"
           maxElementsInMemory="50000"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>
 
   <cache name="SSOCache"
           maxElementsInMemory="50000"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>
    

</ehcache>


import org.apache.shiro.util.Destroyable;
import org.apache.shiro.util.Initializable;

/**
 * 缓存管理
 * @author 
 *
 */
public interface CacheManager extends org.apache.shiro.cache.CacheManager, Initializable, Destroyable{

}


import cn.gzydt.infoshare.security.cache.CacheManager;
import org.apache.shiro.cache.ehcache.EhCacheManager;

/**
 * 
 * @author 
 *
 */
public class DefaultCacheManager extends EhCacheManager implements CacheManager{

}


2、至此，shiro已经完全加到项目中，并且可以使用了，下面说说怎样在项目中使用shiro实现权限管理

        新一个类或接口MyUserRealm继承AuthorizingRealm，Realm，然后覆写   doGetAuthorizationInfo，doGetAuthenticationInfo方法

<span style="font-size:18px;">public interface SecurityRealm extends Realm {

}</span>


public class UserRealm extends AuthorizingRealm implements SecurityRealm {

	private EntityServer entityServer;
	private SystemService systemService;

	@Override
	@Transactional
	protected AuthorizationInfo doGetAuthorizationInfo(
			PrincipalCollection principals){
		String username = (String) principals.getPrimaryPrincipal();
		SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
		User user = (User) entityServer.findByOneProperty(Entity.USER,
				"userName", username).get(0);
		if (User.isStop(user)) {
			throw new AuthorizationException("用户已经停用，请联系管理员!");
		}
		Set<String> permissions = new HashSet<String>();

		// 获取用户所拥有角色的权限
		for (Role r : user.getRoles()) {
			if (r.getKey().equals("Administrator")) {
				// 如果是管理员
				authorizationInfo.addStringPermission("*");
				return authorizationInfo;
			}
			if (!Role.isStop(r)) {
				//如果当前角色是启用状态
				for (Permission p : r.getPermissions()) {
					if (!Systemz.isStop(systemService.findSystemByPermission(p))) {
						//如果系统是启用状态
						permissions.add(p.getKey());
					}
				}
			}
		}

		// 获取用户所在组的权限
		for (Group g : user.getGroups()) {
			if (!Group.isStop(g)) {
				//如果当前组是启用状态
				for (Permission p : g.getPermissions()) {
					if (!Systemz.isStop(systemService.findSystemByPermission(p))) {
						//如果系统是启用状态
						permissions.add(p.getKey());
					}
				}
			}
		}

		// 获取用户的权限
		if (!User.isStop(user)) {
			//如果当前用户是启用状态
			for (Permission p : user.getPermissions()) {
				if (!Systemz.isStop(systemService.findSystemByPermission(p))) {
					//如果系统是启用状态
					permissions.add(p.getKey());
				}
			}
		}
		
		authorizationInfo.setStringPermissions(permissions);
		return authorizationInfo;
	}

	/**
	 * 登录，帐号密码验证
	 */
	@Override
	@Transactional
	protected AuthenticationInfo doGetAuthenticationInfo(
			AuthenticationToken token) throws AuthenticationException {

		String username = (String) token.getPrincipal();
		String password = new String((char[]) token.getCredentials());

		//System.err.println("****************************************  登录  *****************************************");

		User user = (User) entityServer.findByOneProperty(Entity.USER,
				"userName", username).get(0);

		if (user == null||!user.getUserName().equals(username)) {
			throw new UnknownAccountException("帐号或密码错误");// 没找到帐号
		}

		
		if (!password.equals(user.getPassword())) {
			throw new IncorrectCredentialsException("帐号或密码错误");
		}
		
		SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
				user.getUserName(), // 用户名
				user.getPassword(), // 密码
				getName() // realm name
		);
		return authenticationInfo;
	}

	public void setEntityServer(EntityServer entityServer) {
		this.entityServer = entityServer;
	}


	public void setSystemService(SystemService systemService) {
		this.systemService = systemService;
	}
	
	public void clearCachedAuthorizationInfo(PrincipalCollection principals) {
		super.clearCachedAuthorizationInfo(principals);
	}
	
}

整个代码说得简单些就是验证用户名和密码的时候，先通过username从数据库中查找出用户交给realm,然后让shiro自己判断用户是否合法，认证权限的时候，先把用户的所有权限通过字符串的方式交给shiro，然后认证的时候判断shiro的缓存中是否存在需要认证的字符串，有就通过，没有就报异常，然后通过catch异常的类型返回不同的信息。

try {
			subject = loginService.login(username, password, systemKey);
			sessionId = subject.getSession().getId().toString();
			message = Message.SUCCESS;
			
		} catch (AuthenticationException e) {
			e.printStackTrace();
			HttpSession session = request.getSession();
			session.setMaxInactiveInterval(-1);
			session.setAttribute(Const.SESSION_ID, sessionId);
			message = Message.USERNAME_OR_PASSWORD_ERROR;
			resultJson.put(Const.MESSAGE, message);
			logger.info(username, Message.USER_LOGIN, Message.LOGIN_RESULT_FAILED);
			return buildResult(resultJson);
			
		} catch (AuthorizationException e) {
			e.printStackTrace();
			HttpSession session = request.getSession();
			session.setMaxInactiveInterval(-1);
			session.setAttribute(Const.SESSION_ID, sessionId);
			message = Message.AUTH_FOR_LOGIN_ERROR;
			resultJson.put(Const.MESSAGE, message);
			logger.info(username, Message.USER_LOGIN, Message.LOGIN_RESULT_FAILED);
			return buildResult(resultJson);
			
		} catch (Exception e) {
			e.printStackTrace();
			logger.info(username, Message.USER_LOGIN, Message.LOGIN_RESULT_FAILED);
		}

OK,到这里我们已经通过shiro实现了自己的权限策略，下一篇将会说说在使用shiro的过程中遇到的问题。


liyunyu2
关注
专栏目录
在web项目中应用Shiro
02-27
该文档详细地介绍了如何将shiro框架应用到web项目中，对开发很有帮助
Spring Boot 2.0.4 & Shiro1.4.0 权限管理系统
03-08
Spring Boot 2.0.4 & Shiro1.4.0 权限管理系统。 文章地址：https://xttblog.blog.csdn.net/article/details/88353878 FEBS是一个简单高效的后台权限管理系统。项目基础框架采用全新的Java Web开发框架 —— Spring ...
shiro权限项目中的简单应用
Lone-路痴的博客
06-15 4829
SpringMVC+maven项目需要使用shiro，所以自学了几天，仅提供给新手，请根据文档查看…该项目仅是测试项目，并不完善，只实现了需要使用的基本功能，并且只提供了使用shiro模块的代码。楼主新人第一次写，如有问题希望能提出来，由衷的感谢。首先是pom.xml：<dependency> <groupId>org.apache.shiro</groupId> <artifact
如何在Shiro中进行角色和权限的动态管理？
最新发布
alankuo的专栏
10-01 427
在自定义的Realm类中，重写方法来动态获取角色信息。假设使用JDBC来查询数据库获取角色信息：@Override")) {// 处理数据库查询异常// 其他方法，如身份验证相关方法在自定义Realm的方法中同时获取权限信息。@Override// 获取角色")) {// 获取权限)")) {// 处理数据库查询异常// 其他方法，如身份验证相关方法。
使用shiro框架进行权限的管理
qq_36983822的博客
01-03 586
1.shiro框架的角色管理 1.1 在用户验证成功以后，可以在jsp页面中使用shiro的标签进行角色的验证 首先，在jsp页面中需要导入shiro需要的uri &lt;%@taglib prefix="shiro" uri="http://shiro.apache.org/tags"%&gt; 导入该标签以后。就可以使用shiro的标签 &lt;shiro:guest&gt; 亲，请&lt;...
Shiro 权限管理
心猿意码
06-24 4489
一共5个表 用户表 角色表 权限表 用户角色中间表 角色权限中间表 权限验证 通过角色来判断有没有权限。 比如 if 用户有在用户角色中间表中有经理的角色， 就可以查看工资。这中判断比较笼统。适合比如实现不同的角色登录以后看到不同的菜单。 通过权限标识来判断， 这个就需要查出用户拥有的具体权限。 这个权限控制比较细致。 适合细致的，比如部门公司的管理员，只能修改该部门下的员工资料。 Shi...
Shiro实现实时权限管理
qq_43114230的博客
04-09 451
场景描述 系统分为管理端和客户端，管理端具有对客户端某个资源的访问权限的管理功能。 项目主要涉及技术Springboot+Vue+Shiro 原始代码 UserReal.java下的doGetAuthorizationInfo()方法最开始是这样的： // 进入设置了拦截的页面就会触发这个方法 @Override protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection
spring boot+shiro 权限认证管理案例
12-20
Spring Boot 和 Apache Shiro 的整合是企业级应用中常见的权限认证和安全管理方案。Spring Boot 提供了简化 Java 应用程序开发的框架，而 Shiro 是一个轻量级的安全框架，专注于身份验证、授权、会话管理和加密。...
详解spring整合shiro权限管理与数据库设计
08-30
Spring整合Shiro权限管理与数据库设计 本文主要介绍了Spring整合Shiro权限管理与数据库设计的相关知识点。Shiro是一个开源的权限管理框架，广泛应用于Java Web开发中，而Spring则是Java企业版的框架，用于构建企业...
基于Spring、Spring MVC、MiniJdbc和Shiro的权限管理系统LarvaFrame设计源码
04-23
本项目是基于Spring、Spring MVC、MiniJdbc和Shiro开发的权限管理系统LarvaFrame设计源码，包含436个文件，其中包括145个Java源文件，92个JavaScript文件，30个PNG图片，30个CSS样式文件，27个GIF图片，24个XML文件...
Spring Boot与Shiro实现权限管理
11-12
集成Shiro到Spring Boot项目中，首先需要在pom.xml文件中添加Shiro和相关依赖。然后，创建Shiro的配置类，定义 Realm（领域对象）以处理用户认证和授权。 Realm通常会连接数据库，根据用户名和密码进行用户验证。...
Shiro根据用户权限显示不同的菜单.Shiro根据权限显示指定菜单
01-06
Shiro根据用户权限显示不同的菜单.Shiro根据权限显示指定菜单
Shiro 授权（权限）
我的博客----机械鱼人
01-09 1673
一、授权（权限） 1.1 什么是权限 授权，也叫访问控制，即在应用中控制谁能访问哪些资源（如访问页面/编辑数据/页面操作等）。 1.2 权限框架 shiro spring security Apache Shiro是Java的一个安全框架。目前，使用Apache Shiro的人越来越多，因为它相当简单， 对比Spring Security，可能没有Spring Security做的功能强大，但...
Spring-Shiro框架使用说明
C C++ VC
02-10 617
spring-shiro框架集成Webservice
Shiro权限管理框架粗解
arkitocy的博客
09-01 225
Shiro权限管理框架粗解 一.流程 二.权限管理模型 用户（用户id，账号、密码…） 权限（权限id，权限名称，访问地址） 角色（角色id，角色名称） 角色和权限关系（角色id、权限id） 用户和角色关系（用户id、角色id） 三.粗细颗粒度 1.什么是粗颗粒度和细颗粒度 ​ 对资源类型的管理称为粗颗粒度权限管理，即只控制到菜单、按钮、方法，粗粒度的例子比如：用户具有用户管理的权限，具有导出...
【安全框架】浅谈Shiro在项目中的应用
m0_67392409的博客
08-27 234
最后我们再看一个controller的save方法的例子，这个比较简单易懂，代码如下。简单来说它是Apache的一个Java安全框架（Apache是一个很牛的团体，除了Shiro，还有Lucene、Elasticsearch、Activiti等等也是Apache的，后续博主可能会讲到），具体这里就不详细赘述了，请大家自行查看百度百科。第三步，编写ShiroConfig类，这个类定义了可以匿名访问的url，其他的代码都是固定套路的，以后开发中基本不用改，我还是直接贴代码，注释写的很详细，大家都能看懂。...
【Java】Shiro权限框架在项目中的应用
weixin_43358075的博客
08-22 621
同样，忙于校招，忙于提升自己，忙于项目。直接把项目中的代码拿来分享给大家。 一、配置ShiroFilter <context-param> <param-name>contextConfigLocation</param-name> <param-value> classpath:spring/spring-*.x...
在前后端分离项目中使用Shiro
qq_42814833的博客
06-21 3060
本文是我在前后端分离项目中使用Shiro遇到的问题和解决方法的汇总总结，包括对各种情况的分析和思考。开始我使用Cookie，发现在http环境的跨域不能携带Cookie，于是我转为使用JWT来进行传输。此次没有出现登录失败的情况，但每次访问接口都需要访问数据库获取权限和其他内容，正确的操作是进行缓存，但重新写一个用户的缓存管理不如使用现成的。所以我结合二者，使用自定义的请求头携带标识，获取Session。.........
Spring整合Shiro权限管理与数据库设计方案
"本文将深入探讨如何整合Spring与Apache Shiro进行权限管理，并涉及相关的数据库设计。通过这个过程，我们将实现细粒度的权限控制，不仅覆盖到菜单，还涵盖到页面上的具体功能按钮，确保从前端展示到后端逻辑都能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值