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

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中设置配置文件的时候，直接使用通配符了：
　　

 
  <context-param>
          <param-name>contextConfigLocationparam-name>
          <param-value>classpath*:/spring-context-*.xmlparam-value>
  context-param>
  
  <listener>
      <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
  listener>

这样就可以扫描到两个配置文件了，又不会扫描到我们的spring-mvc.xml了，

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

 <servlet>
     <servlet-name>springServletservlet-name>
     <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
     <init-param>
         <param-name>contextConfigLocationparam-name>
         <param-value>classpath:springmvc.xmlparam-value>
     init-param>
     <load-on-startup>1load-on-startup>
 servlet>
  <servlet-mapping>
     <servlet-name>springServletservlet-name>
     <url-pattern>/url-pattern>
 servlet-mapping>

3.在web.xml中配置shiroFilter:

     <filter>
        <filter-name>shiroFilterfilter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxyfilter-class>
    filter>
    <filter-mapping>
        <filter-name>shiroFilterfilter-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"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-4.0.xsd"
    default-lazy-init="true">

    <description>Shiro Configurationdescription>

    
    <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}"/>

         <property name="sessionValidationSchedulerEnabled" value="true"/>
         
        <property name="sessionIdCookie" ref="sessionIdCookie"/>
        <property name="sessionIdCookieEnabled" value="true"/>
    bean>
    
    
    <bean id="sessionIdCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
        <constructor-arg name="name" value="jeesite.session.id"/>
    bean>

    




    <bean id="sessionDAO" class="com.yonyou.hotusm.common.security.session.CacheSessionDAO">
        <property name="sessionIdGenerator" ref="idGen" />
        <property name="activeSessionsCacheName" value="activeSessionsCache" />
        <property name="cacheManager" ref="shiroCacheManager" />
    bean>
    
    

    <bean id="shiroCacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
        <property name="cacheManager" ref="cacheManager"/>
    bean>
    
    
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
    
    
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor">
        <property name="proxyTargetClass" value="true" />
    bean>
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    bean>
    
beans>

 

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;

}

    }

 

    @Override

public Date getLastaccessTime(SessionKey key) {

     try{

     return super.getLastAccessTime(key);

     }catch (InvalidSessionException e) {

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

         return null;

}

    }

 

    @Override

public long getTimeout(SessionKey key){

     try{

     return super.getTimeout(key);

     }catch (InvalidSessionException e) {

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

         return 0;

}

    }

 

    @Override

public void setTimeout(SessionKey key, long maxIdleTimeInMillis) {

     try{

     super.setTimeout(key, maxIdleTimeInMillis);

     }catch (InvalidSessionException e) {

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

}

    }

 

    @Override

public void touch(SessionKey key) {

     try{

     super.touch(key);

}catch (InvalidSessionException e) {

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

}

    }

 

    @Override

public String getHost(SessionKey key) {

     try{

     return super.getHost(key);

     }catch (InvalidSessionException e) {

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

         return null;

}

    }

 

    @Override

public Collection