spring+shiro 整合之自己注册会话和自写realm

喜欢ヅ旅行 2023-06-29 01:58 7阅读 0赞

Apache Shiro是java的一个安全框架。目前，使用Apache Shiro的人越来越多，因为它相当简单，对比SPRing Security，可能没有Spring Security做的功能强大，但是在实际工作时可能并不需要那么复杂的东西，所以使用小而简单的Shiro就足够了。

因为我总结的是使用SpringMVC和Apache Shiro整合，注重的是整合和使用，至于基础，我这里就不细说了.按照惯例，既然是需要创建项目，那么我们首先需要JAR包，Apache shiro的架包除了除了基本的以外，我们还需要shiro-web和shiro-spring的的架包，下面是所需要的所有shiro架包，至于其他的架包，像缓存的架包，Spring和SpringMVC的架包还是和我们以前使用的架包一样的。

org.apache.shiro shiro-core 1.2.3 org.apache.shiro shiro-ehcache 1.2.3 org.apache.shiro shiro-web 1.2.3 org.apache.shiro shiro-spring 1.2.3 　　所有的架包都搞清楚了以后，我们就可以开始正式搭建了，在myeclise中创建一个maven项目，将需要的架包信息依赖全部放入。下面就分步骤来创建 　　1.首先创建spring的配置文件，位置都在在resource中，配置文件是spring-context.xml，创建Apache Shiro的配置文件，名字是spring-context-shiro.xml，还有一个配置文件是springmvc的，配置文件是spring-mvc,这样起名是有原因的，因为这样我们就可以在web.xml中设置配置文件的时候，直接使用通配符了： 　　 contextConfigLocation classpath\*:/spring-context-\*.xml org.springframework.web.context.ContextLoaderListener 这样就可以扫描到两个配置文件了，又不会扫描到我们的spring-mvc.xml了，

2除了在web.xml中设置这个以外，我们还需要设置spring-mvc的位置：

springServlet org.springframework.web.servlet.DispatcherServlet contextConfigLocation classpath:springmvc.xml 1 springServlet / 3.在web.xml中配置shiroFilter:

<filter>
        <filter-name>shiroFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>shiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

注意，这个shiroFilter名称，后面的配置还需要使用到，所以要注意咯。  
4，因为shiro的session是自己实现的，所以我们还需要一个缓存框架，所以在spring的配置文件一定要注意配置哦，

<bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
        <property name="configLocation" value="classpath:${ehcache.file}"></property>
    </bean>

spring的其他的配置，该怎样还是这样，我们的重点是配置spring-context-shiro.xml：先把配置的贴出来，然后讲一下这几个配置的意义：

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

<description>Shiro Configuration</description>
    
    
    <context:property-placeholder ignore-unresolvable="true" location="classpath:yonyou.properties" />
    
    
    <bean name="shiroFilterChainDefinitions" class="java.lang.String">
        <constructor-arg>
            <value>
                /static/** = anon
                /userfiles/** = anon
                ${adminPath}/cas = cas
                ${adminPath}/login = authc
                ${adminPath}/logout = logout
                ${adminPath}/** = user
            </value>
        </constructor-arg>
    </bean>
    
    
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager" />
        <property name="loginUrl" value="${adminPath}/login" />
        <property name="successUrl" value="${adminPath}?login" />
        <property name="filters">
            <map>
                <entry key="cas" value-ref="casFilter"/>
                <entry key="authc" value-ref="formAuthenticationFilter"/>
            </map>
        </property>
        <property name="filterChainDefinitions">
            <ref bean="shiroFilterChainDefinitions"/>
        </property>
    </bean>
    
      
    <bean id="casFilter" class="org.apache.shiro.cas.CasFilter">  
        <property name="failureUrl" value="${adminPath}/login"/>
    </bean>
    
    
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="systemAuthorizingRealm" />
        <property name="sessionManager" ref="sessionManager" />
        <property name="cacheManager" ref="shiroCacheManager" />
    </bean>
    
    
    <bean id="sessionManager" class="com.yonyou.hotusm.common.security.session.SessionManager"> 
        <property name="sessionDAO" ref="sessionDAO"/>
        
        
        <property name="globalSessionTimeout" value="${session.sessionTimeout}"/>
        
        
        <property name="sessionValidationInterval" value="${session.sessionTimeoutClean}"/>

ecurityManager:是shiro最重要的一个对象，授权和验证都是由它来做的，下面就一一的来讲他的依赖类，

一：realm：域，Shiro从从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。下对于源代码，我就不细细的研究了，下面是我重写的realm，：

package com.yonyou.hotusm.module.sys.security;

import java.io.Serializable;

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.UsernamePassWordToken;

import org.apache.shiro.authz.AuthorizationInfo;

import org.apache.shiro.authz.SimpleAuthorizationInfo;

import org.apache.shiro.authz.UnauthenticatedException;

import org.apache.shiro.realm.AuthorizingRealm;

import org.apache.shiro.subject.PrincipalCollection;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import com.yonyou.hotusm.module.sys.dao.UserDao;

import com.yonyou.hotusm.module.sys.entity.User;

import com.yonyou.hotusm.module.sys.util.UserUtils;

@Service

public class SystemAuthorizingRealm extends AuthorizingRealm\{

@Autowired

private UserDao userDao;

@Override

protected AuthorizationInfo doGetAuthorizationInfo(

PrincipalCollection principals) \{

SimpleAuthorizationInfo info=new SimpleAuthorizationInfo();

info.addStringPermission(“sys:manager”);

info.addStringPermission(“user”);

System.out.println(“开始授权”);

return info;

@Override

protected AuthenticationInfo doGetAuthenticationInfo(

AuthenticationToken token) throws AuthenticationException \{

UsernamePasswordToken upToken=(UsernamePasswordToken) token;

String username=upToken.getUsername();

String password=new String(upToken.getPassword());

User user=new User();

user.setLoginName(username);

user=userDao.get(user);

System.out.println("===========");

if(user!=null)\{

if(user.getPassword().equals(password))\{

return new SimpleAuthenticationInfo(username,password,getName());

throw new UnauthenticatedException();

public static class Principal implements Serializable \{

private static final long serialVersionUID = 1L;

private String id; // 编号

private String loginName; // 登录名

private String name; // 姓名

public Principal(User user) \{

this.id = user.getId();

this.loginName = user.getLoginName();

this.name = user.getName();

public String getId() \{

return id;

public String getLoginName() \{

return loginName;

public String getName() \{

return name;

/\*\*

*  获取SESSIONID

\*/

public String getSessionid() \{

try\{

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

\}catch (Exception e) \{

return “”;

@Override

public String toString() \{

return id;

看的出来，其中最重要的是doGetAuthorizationInfo和doGetAuthenticationInfo，这两个方法，doGetAuthorizationInfo是对当前的用户进行授权的，至于授权的时期，就是当用户需要验证的时候，我这里只是简单的写死了，但是在实际项目开发中，我们一般会将权限存放在数据表中，所以真实情况是先到数据库中查出一个集合，然后迭代授权，

doGetAuthenticationInfo对于的是对用户验证，这里我们就需要从数据库中根据用户查出用户，根据用户情况，抛出不用的异常。

下面就是讲解sessionManager，因为Shiro有自己的一套session体系，有sessionManager就不奇怪了，sessionManager主要职责是管理session的创建和删除，特别提一下，sessionManager对session的操作，其实只是调用了sessionDAO，然再加上自己的一些操作，所以，我们可以看到sessionManager的bean还依赖sessionDAO，下面是自己实现的sessionManager：

package com.yonyou.hotsum.common.security.shiro.session;

import java.io.Serializable;

import java.util.Collection;

import java.util.Date;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.shiro.session.InvalidSessionException;

import org.apache.shiro.session.Session;

import org.apache.shiro.session.UnknownSessionException;

import org.apache.shiro.session.mgt.SessionContext;

import org.apache.shiro.session.mgt.SessionKey;

import org.apache.shiro.session.mgt.SimpleSession;

import org.apache.shiro.web.servlet.Cookie;

import org.apache.shiro.web.servlet.ShiroHttpServletRequest;

import org.apache.shiro.web.servlet.SimpleCookie;

import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;

import org.apache.shiro.web.util.WebUtils;

/\*\*

*  自定义WEB会话管理类
 *  @author hotusm
 *

\*/

public class SessionManager extends DefaultWebSessionManager \{

public SessionManager() \{

super();

@Override

protected Serializable getSessionId(ServletRequest request, ServletResponse response) \{

// 如果参数中包含“\_\_sid”参数，则使用此sid会话。 例如：http://localhost/project?\_\_sid=xxx&\_\_cookie=true

String sid = request.getParameter("\_\_sid");

if (org.apache.commons.lang3.StringUtils.isNotBlank(sid)) \{

// 是否将sid保存到cookie，浏览器模式下使用此参数。

if (WebUtils.isTrue(request, “\_\_cookie”))\{

HttpServletRequest rq = (HttpServletRequest)request;
    
        HttpServletResponse rs = (HttpServletResponse)response;

Cookie template = getSessionIdCookie();

Cookie cookie = new SimpleCookie(template);

cookie.setValue(sid); cookie.saveTo(rq, rs);

// 设置当前session状态

request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE,
    
                    ShiroHttpServletRequest.URL_SESSION_ID_SOURCE); // session来源与url
    
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, sid);
    
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
    
         return sid;

\}else\{

return super.getSessionId(request, response);

@Override

public void validateSessions() \{

super.validateSessions();

@Override

protected Session retrieveSession(SessionKey sessionKey) \{

try\{

return super.retrieveSession(sessionKey);

\}catch (UnknownSessionException e) \{

// 获取不到SESSION不抛出异常

return null;

@Override

public Date getStartTimestamp(SessionKey key) \{

try{
    
     return super.getStartTimestamp(key);
    
     }catch (InvalidSessionException e) {
    
     // 获取不到SESSION不抛出异常
    
         return null;