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

最新推荐文章于 2022-09-26 13:59:43 发布
最新推荐文章于 2022-09-26 13:59:43 发布
阅读量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
关注
专栏目录
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在项目中的应用
m0_67392409的博客
08-27 222
最后我们再看一个controller的save方法的例子，这个比较简单易懂，代码如下。简单来说它是Apache的一个Java安全框架（Apache是一个很牛的团体，除了Shiro，还有Lucene、Elasticsearch、Activiti等等也是Apache的，后续博主可能会讲到），具体这里就不详细赘述了，请大家自行查看百度百科。第三步，编写ShiroConfig类，这个类定义了可以匿名访问的url，其他的代码都是固定套路的，以后开发中基本不用改，我还是直接贴代码，注释写的很详细，大家都能看懂。...
【Java】Shiro权限框架在项目中的应用
weixin_43358075的博客
08-22 611
同样，忙于校招，忙于提升自己，忙于项目。直接把项目中的代码拿来分享给大家。 一、配置ShiroFilter <context-param> <param-name>contextConfigLocation</param-name> <param-value> classpath:spring/spring-*.x...
在前后端分离项目中使用Shiro
qq_42814833的博客
06-21 3041
本文是我在前后端分离项目中使用Shiro遇到的问题和解决方法的汇总总结，包括对各种情况的分析和思考。开始我使用Cookie，发现在http环境的跨域不能携带Cookie，于是我转为使用JWT来进行传输。此次没有出现登录失败的情况，但每次访问接口都需要访问数据库获取权限和其他内容，正确的操作是进行缓存，但重新写一个用户的缓存管理不如使用现成的。所以我结合二者，使用自定义的请求头携带标识，获取Session。.........
Apache Shiro SessionManager
王浩的技术博客
11-28 245
SessionManager是在应用程序中为所有Subject提供Session的管理，包括创建，删除，失效及验证等。同其的核心组件一样，SessionManager也是一个由SecurityManager维护的顶级组件。 在Shiro中默认提供了一个SessionManager的实现DefaultSessionManager。DefaultSessionManager提供一个应用程序所需的所有...
springboot+shiro中自定义session过期时间
ldcaws的专栏
08-12 5234
在springboot工程中，使用shiro作为权限框架，并采用redis来管理session时，如何自定义session过期时间？
详解spring整合shiro权限管理与数据库设计
08-30
Spring整合Shiro权限管理与数据库设计 本文主要介绍了Spring整合Shiro权限管理与数据库设计的相关知识点。Shiro是一个开源的权限管理框架，广泛应用于Java Web开发中，而Spring则是Java企业版的框架，用于构建企业...
spring boot+shiro 权限认证管理案例
12-20
Spring Boot 和 Apache Shiro 的整合是企业级应用中常见的权限认证和安全管理方案。Spring Boot 提供了简化 Java 应用程序开发的框架，而 Shiro 是一个轻量级的安全框架，专注于身份验证、授权、会话管理和加密。...
Spring Boot与Shiro实现权限管理
最新发布
11-12
集成Shiro到Spring Boot项目中，首先需要在pom.xml文件中添加Shiro和相关依赖。然后，创建Shiro的配置类，定义 Realm（领域对象）以处理用户认证和授权。 Realm通常会连接数据库，根据用户名和密码进行用户验证。...
Shiro 设置session超时时间
热门推荐
zsg88的专栏
04-06 5万+
系统默认超时时间是180000毫秒(30分钟)，可以通过下面2中方式设置自定义的超时时间。 一： 配置文件 二：通过api Shiro的Session接口有一个setTimeout()方法，登录后，可以用如下方式取得session SecurityUtils.getSubject().get
在web项目中应用Shiro
02-27
该文档详细地介绍了如何将shiro框架应用到web项目中，对开发很有帮助
Session Timeout需求解決
03-28
NULL 博文链接：https://shmilywzc.iteye.com/blog/1203141
session超时设置
07-01
session设置超时时间，可以不用一直总是登录，在网页上操作更省心
shiro安全框架设置session超时
开发者导航
08-29 1813
系统默认超时时间是180000毫秒(30分钟)longtimeout=SecurityUtils.getSubject().getSession().getTimeout(); System.out.println(timeout+"毫秒");可以通过下面2中方式设置自定义的超时时间。1、配置文件<!--会话管理器--> <beani...
Shiro学习（10）Session管理
m0_67403073的博客
08-24 2792
但是如在web环境中，如果用户不主动退出是不知道会话是否过期的，因此需要定期的检测会话是否过期，Shiro提供了会话验证调度器SessionValidationScheduler来做这件事情。Shiro提供了完整的企业级会话管理功能，不依赖于底层容器（如web容器tomcat），不管JavaSE还是JavaEE环境都可以使用，提供了会话管理、会话事件监听、会话存储/持久化、容器无关的集群、失效/过期支持、对Web的透明支持、SSO单点登录的支持等特性。更新会话最后访问时间及销毁会话；
深入理解MyBatis(四)--缓存
striveb的博客
06-05 356
GitHub：https://github.com/JDawnF 查询缓存的使用，主要是为了提高查询访问速度。将用户对同一数据的重复查询过程简化，不再每次均从数据库查询获取结果数据，从而提高访问速度。 MyBatis 的查询缓存机制，根据缓存区的作用域(生命周期)可划分为两种:一级查询 缓存与二级查询缓存。 一、查询缓存 1.一级查询缓存 MyBatis 一级查询缓存是基...
session管理（15毫秒没有操作就退出）
sharesb的博客
09-26 537
可以粗略的理解为认证信息，是放在session中的，可以手动新建session，设置session的过期时间，这样就实现了用户登录后，多长没有进行操作，就自动退出登录。1.需要自定义session管理器（15毫秒没有操作就退出）2.在securitymanger中绑定这个session。
shiro session过期设置
qq_39508627的博客
02-25 1005
在sessionManager 中设置过期信息。time-server.globalSessionTimeout是从配置文件yml中设置的 @Bean(name = "sessionManager") public DefaultWebSessionManager sessionManager(@Value("${time-server.globalSessionTimeout:3600...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值