shiro框架整合ssm的简单使用

最新推荐文章于 2019-12-14 10:21:39 发布

zy丶秋水

最新推荐文章于 2019-12-14 10:21:39 发布

阅读量328

点赞数

分类专栏：权限控制文章标签： shiro ssm

本文链接：https://blog.csdn.net/qq_34902684/article/details/80113823

版权

权限控制专栏收录该内容

1 篇文章 0 订阅

订阅专栏

该项目仅作为简单的ssm整合shiro的demo使用，部分代码仅简单实现。

该文只贴出与shiro相关的配置，完整代码可见https://github.com/Zhong-Y/shiro_ssm

部分代码

UserRealm.java

realm在shiro框架中用于认证、授权等操作。为了满足业务的需求，通常在使用时，使用的是继承了AuthorizingRealm的自定义realm.

public class UserRealm extends AuthorizingRealm{
	@Autowired
	TUserMapper userMapper;
	
	@Autowired
	TUserRoleMapper userRolerMapper;
	
	// 设置realm的名称
	@Override
	public void setName(String name) {
		super.setName("userRealm");
	}
	
	//认证
	protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
		System.out.println("====================认证=====================");
		
		//根据username查询用户
		String username = (String) token.getPrincipal();
		TUserExample example = new TUserExample();
		Criteria criteria = example.createCriteria();
		criteria.andUserNameEqualTo(username);
		List<TUser> list = userMapper.selectByExample(example);
		TUser user = null;
		if(list != null && !list.isEmpty()) {
			user = list.get(0);
		}
		
		//如果没有查询到用户返回null
		if(user == null) {
			return null;
		}
		
		String id = user.getUserId();
		String password = user.getUserPassword();
		String salt = user.getUserSalt();
		
		//获取用户角色  ...省略
		String userRoleId =  "1";
		
		//根据身份信息获取权限信息,并将权限添加到在线用户中....省略
		List<String> permissions = new ArrayList<String>();
		permissions.add("user:query");
		
		//设置在线用户属性
		ActiveUser activeUser = new ActiveUser();
		activeUser.setUserRoleId(userRoleId);
		activeUser.setUserName(username);
		activeUser.setUserId(id);
		activeUser.setUserSalt(salt);
		activeUser.setPermissions(permissions);
		
		SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(activeUser, password,
				ByteSource.Util.bytes(salt), this.getName());

		return simpleAuthenticationInfo;
	}
	
	//授权
	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
		System.out.println("===================授权==============================");
		
		//从 principals获取主身份信息
		//将getPrimaryPrincipal方法返回值转为真实身份类型（在上边的doGetAuthenticationInfo认证通过填充到SimpleAuthenticationInfo中身份类型），
		ActiveUser activeUser =  (ActiveUser) principals.getPrimaryPrincipal();
		
		//根据身份信息获取权限信息,并将权限添加到在线用户中
		List<String> permissions  = activeUser.getPermissions();
	
		//查到权限数据，返回授权信息(要包括 上边的permissions)
		SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
		//将上边查询到授权信息填充到simpleAuthorizationInfo对象中
		simpleAuthorizationInfo.addStringPermissions(permissions);
		return simpleAuthorizationInfo;
	}
	
	//清除缓存
	public void clearCached() {
		PrincipalCollection principals = SecurityUtils.getSubject().getPrincipals();
		super.clearCache(principals);
	}
}

MyFormAuthenticationFilter.java

由于shiro自带的FormAuthenticationFilter仅实现了用户的账号密码认证，而我们还需对验证码进行判断，因此，在这里，我们使用的是自定义的FormAuthenticationFilter。我们将重写它的认证方法，使得在进行账号密码认证前对验证码进行校验。

public class MyFormAuthenticationFilter extends FormAuthenticationFilter {
	protected boolean onAccessDenied(ServletRequest request, ServletResponse response, Object mappedValue)
			throws Exception {

		// 校验验证码
		// 从session获取正确的验证码
		HttpSession session = ((HttpServletRequest) request).getSession();
		// 页面输入的验证码
		String randomcode = request.getParameter("randomCode");
		// 从session中取出服务器生成的验证码
		String validateCode = (String) session.getAttribute("randomCode");
		if (randomcode != null && validateCode != null) {
			// 如果验证码错误，则拒绝访问，不再校验账号和密码
			if (!randomcode.equalsIgnoreCase(validateCode)) {
				// 存储错误信息
				request.setAttribute("shiroLoginFailure", "randomCodeError");
				return true;
			}
		}
		//验证码正确，校验账号密码
		return super.onAccessDenied(request, response, mappedValue);
	}

}

web.xml

配置shiro过滤器：初始化bean的id，及设置filter的匹配规则

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
	xmlns="http://java.sun.com/xml/ns/javaee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <display-name></display-name>
  
  <!-- 加载spring容器 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:spring/applicationContext-*.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	
	<!-- 配置SpringMVC -->
	<servlet>
		<servlet-name>springmvc</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:spring/springmvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>springmvc</servlet-name>
		<!--  出.jsp外的所有访问的地址都由DispatcherServlet进行解析 -->
		<url-pattern>/</url-pattern>
	</servlet-mapping>

	<!-- shiro过滤器，DelegatingFilterProxy通过代理模式将spring容器中的bean和filter关联起来 -->
	<filter>
		<filter-name>shiroFilter</filter-name>
		<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
		<!-- 设置true由servlet容器控制filter的生命周期 -->
		<init-param>
			<param-name>targetFilterLifecycle</param-name>
			<param-value>true</param-value>
		</init-param>
		<!-- 设置spring容器filter的bean id，如果不设置则找与filter-name一致的bean -->
		<init-param>
			<param-name>targetBeanName</param-name>
			<param-value>shiroFilter</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>shiroFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	
  
  
    <!-- post乱码过虑器 -->
	<filter>
		<filter-name>CharacterEncodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>CharacterEncodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
  
</web-app>

applicationContext-shiro.xml

进行shiro的相关配置

<!-- 自定义formAuthenticationFilter,不配置时将使用默认的过滤器-->
	<!-- usernameParam默认值为username,passwordParam为password -->
	<bean id="formAuthenticationFilter"
		class="com.shiro.MyFormAuthenticationFilter ">
		<!-- 表单中账号的input名称 -->
		<property name="usernameParam" value="username" />
		<!-- 表单中密码的input名称 -->
		<property name="passwordParam" value="password" />
	</bean>
		

	<!-- web.xml中shiro的filter对应的bean -->
	<!-- Shiro 的Web过滤器 -->
	<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
		<property name="filters">
			<map>
				<!-- FormAuthenticationFilter是基于表单认证的过虑器 -->
				<entry key="authc" value-ref="formAuthenticationFilter" />
			</map>
		</property>		
		<property name="securityManager" ref="securityManager" />
		<!-- loginUrl认证提交地址，如果没有认证将会请求此地址进行认证，请求此地址将由formAuthenticationFilter进行表单认证 -->
		<property name="loginUrl" value="/login" />
		<!-- 认证成功统一跳转到first.action，建议不配置，shiro认证成功自动到上一个请求路径 -->
	<!-- 	<property name="successUrl" value="/first.action"/> -->
		<!-- 通过unauthorizedUrl指定没有权限操作时跳转页面-->
		<property name="unauthorizedUrl" value="/refuse.jsp" />
		<!-- 过虑器链定义，从上向下顺序执行，一般将/**放在最下边 -->
		<property name="filterChainDefinitions">
			<value>
				<!-- 对静态资源设置匿名访问 -->
				<!-- /js/** = anon -->
				/randomCode = anon
				
				<!-- 退出拦截，请求logout执行退出操作 -->
				/logout = logout				
				
				<!-- 配置记住我或认证通过可以访问的地址 -->
				/ = user
				/success  = user
				
				<!-- 配置需要访问权限的访问地址 -->
				/test = perms["admin:query"]
				/test3 = perms["user:query"]
				
				<!-- /** = authc 所有url都必须认证通过才可以访问-->
				/** = authc
			
			</value>
		</property>
	</bean>


	<!-- securityManager安全管理器 -->
	<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
		<!-- 注入realm -->
		<property name="realm" ref="userRealm" />
		<!-- 注入缓存管理器 -->
		<property name="cacheManager" ref="cacheManager"/>
		<!-- 注入session管理器 -->
		<property name="sessionManager" ref="sessionManager" />
		<!-- 记住我 -->
		<property name="rememberMeManager" ref="rememberMeManager"/>
	</bean>
	
	<!-- 自定义realm -->
	<bean id="userRealm" class="com.shiro.UserRealm">
		<!-- 将凭证匹配器设置到realm中，realm按照凭证匹配器的要求进行散列 -->
		<property name="credentialsMatcher" ref="credentialsMatcher"/>
	</bean>
	
	<!-- 缓存管理器 -->
	<bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
    	<property name="cacheManagerConfigFile" value="classpath:shiro-ehcache.xml"/>
    </bean>
	

	<!-- 凭证匹配器 -->
	<bean id="credentialsMatcher"
		class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
		<property name="hashAlgorithmName" value="md5" />
		<property name="hashIterations" value="1" />
	</bean>
	
	<!-- 会话管理器 -->
    <bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
        <!-- session的失效时长，单位毫秒 -->
        <property name="globalSessionTimeout" value="600000"/>
        <!-- 删除失效的session -->
        <property name="deleteInvalidSessions" value="true"/>
    </bean>
	
	<!-- rememberMeManager管理器，写cookie，取出cookie生成用户信息 -->
	<bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
		<property name="cookie" ref="rememberMeCookie" />
	</bean>
	<!-- 记住我cookie -->
	<bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
		<!-- rememberMe是cookie的名字 -->
		<constructor-arg value="rememberMe" />
		<!-- 记住我cookie生效时间30天 -->
		<property name="maxAge" value="2592000" />
	</bean>

shiro-ehcache.xml

shiro的缓存策略配置，若项目中没有配置缓存，则在每一次访问时都会进行授权操作。配置后，仅第一次访问需要权限的url时进行授权，之后直接存缓存中取出授权信息。

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
	<!--diskStore：缓存数据持久化的目录 地址  -->
	<diskStore path="F:\develop\ehcache" />
	<defaultCache 
		maxElementsInMemory="1000" 
		maxElementsOnDisk="10000000"
		eternal="false" 
		overflowToDisk="false" 
		diskPersistent="false"
		timeToIdleSeconds="120"
		timeToLiveSeconds="120" 
		diskExpiryThreadIntervalSeconds="120"
		memoryStoreEvictionPolicy="LRU">
	</defaultCache>
</ehcache>

UserController.java

Controller,对shiro相关配置进行测试。

其中，用户的登陆、退出操作都已在shiro的配置文件进行了配置，退出操作无需编写，登陆操作仅需写些登陆失败的相关处理及登陆成功的跳转url即可。

@Controller
public class UserController {
	//注入realm
	@Autowired
	private UserRealm userRealm;

	@RequestMapping(value="/clearShiroCache", produces="application/json; charset=utf-8")
	@ResponseBody
	public String clearShiroCache() {
		// 清除缓存，将来正常开发要在service调用customRealm.clearCached()
		userRealm.clearCached();
		return "shiro授权缓存已清除";
	}
	
	@RequestMapping("/")
	public String defaultIndex() {
		return "success";
	}
	
	// 登陆提交地址，和applicationContext-shiro.xml中配置的loginurl一致
	// 此方法不处理登陆成功（认证成功），shiro认证成功会自动跳转到上一个请求路径
	@RequestMapping("login")
	public String login(HttpServletRequest request) throws Exception {

		// 如果登陆失败从request中获取认证异常信息，shiroLoginFailure就是shiro异常类的全限定名
		String exceptionClassName = (String) request.getAttribute("shiroLoginFailure");
		// 根据shiro返回的异常类判断错误原因
		if (exceptionClassName != null) {
			if (UnknownAccountException.class.getName().equals(exceptionClassName)) {
				System.out.println("=============账号不存在=============");
			} else if (IncorrectCredentialsException.class.getName().equals(exceptionClassName)) {
				System.out.println("=============用户名/密码错误=============");
			} else if ("randomCodeError".equals(exceptionClassName)) {
				System.out.println("=============验证码错误=============");
			} else {
				System.out.println("=============未知错误=============");
			}
		}

		// 登陆失败跳回login.jsp
		return "login";
	}
	
	//没权限时测试
	@ResponseBody
	@RequestMapping(value="/test", produces="application/json; charset=utf-8")
	public String test1() {
		return "这是test1";
	}
	
	//没权限时测试2，通过注解配置权限
	@ResponseBody
	@RequestMapping(value="/test2", produces="application/json; charset=utf-8")
	@RequiresPermissions("admin:query")
	public String test2() {
		return "这是test2";
	}

	//有权限时测试
	@ResponseBody
	@RequestMapping(value="/test3", produces="application/json; charset=utf-8")
	public String test3() {
		return "这是test3";
	}
	
	//有权限时测试2，通过注解配置权限
	@ResponseBody
	@RequestMapping(value="/test4", produces="application/json; charset=utf-8")
	@RequiresPermissions("user:query")
	public String test4() {
		return "这是test4";
	}
	
	//生成验证码
	@RequestMapping("/randomCode")
	public void randomCode(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
    	//设置相应类型,告诉浏览器输出的内容为图片
        response.setContentType("image/jpeg");
        
        //设置响应头信息，告诉浏览器不要缓存此内容
        response.setHeader("pragma", "no-cache");
        response.setHeader("Cache-Control", "no-cache");
        response.setDateHeader("Expire", 0);
        
        RandomValidateCode randomValidateCode = new RandomValidateCode();
        try {
        	//输出图片方法
            randomValidateCode.getRandcode(request, response);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在使用@RequiresPermissions注解添加权限时，需在springmvc.xml中添加对shiro注解的支持

<!-- 开启aop，对类代理 -->
	<aop:config proxy-target-class="true"></aop:config>
	<!-- 开启shiro注解支持 -->
	<bean 
		class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
		<property name="securityManager" ref="securityManager" />
	</bean>