spring整合spring-data-redis和spring-session-data-redis通过shiro实现单点登录

大家好，又见面了，我是你们的朋友全栈君。

运行效果图
缓存说明（本项目没有使用shiro的缓存管理器和session管理器）
shiro_user_cache:permission：权限缓存，当前只有test用户
shiro_user_cache:role：角色缓存，当前只有test用户
shiro_user_kickout：保存被踢出的用户
shiro_user_online：保存登录了的用户
sprting：spring-session管理的缓存

上面缓存的创建过程
shiro_user_cache：登录时UserRealm会触发Spring的查询缓存保存用户的角色权限，清除缓存也是利用Spring的注解，如下

<!-- 启用缓存注解功能，在这里起到关键作用 -->
<cache:annotation-driven cache-manager="redisCacheManager" />

package com.shiro;

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.UnknownAccountException;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;

import com.entity.User;
import com.service.UserService;

public class UserRealm extends AuthorizingRealm { 
     

    @Autowired
    private UserService userService;

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        String username = (String)principals.getPrimaryPrincipal();       
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        authorizationInfo.setRoles(userService.findRolesByUsername(username));
        authorizationInfo.setStringPermissions(userService.findPermissionsByUsername(username));
        return authorizationInfo;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        String username = (String)token.getPrincipal();
        User user = userService.findByUsername(username);
        if(user == null) {
            throw new UnknownAccountException();//没找到帐号
        }

        SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
                user.getUsername(),
                user.getPassword(),
                getName()  //realm name
        );
        return authenticationInfo;
    }

    /** * 根据用户名，清除角色和权限缓存 * @param uername */
    public void clearUserCache(String uername) {
        userService.clearUserCache(uername);
    }

    /** * 清除所有用户的角色和权限缓存 */
    public void clearUserCache() {
        userService.clearUserCache();
    }

}

package com.service.impl;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import com.dao.DictDao;
import com.dao.RoleDao;
import com.dao.UserDao;
import com.entity.RolePermission;
import com.entity.User;
import com.entity.UserRole;
import com.service.UserService;

import core.service.BaseServiceImpl;

@Service
public class UserServiceImpl extends BaseServiceImpl<User, Integer> implements UserService {

    @Autowired
    UserDao userDao;

    @Autowired
    RoleDao roleDao;

    @Autowired
    DictDao daoDao;

    @Override
    public User findByUsername(String username) {
        return userDao.findByUsername(username);
    }

    @Cacheable(value="shiro_user_cache:role", key="#username")
    @Override
    public Set<String> findRolesByUsername(String username) {
        Set<String> roles = new HashSet<String>();
        User user = this.findByUsername(username);
        if(user==null) {
            return roles;
        }
        List<UserRole> userRoles = user.getUserRoleList();
        for(UserRole userRole:userRoles) {
            roles.add(userRole.getRole().getName());
        }
        return roles;
    }

    @Cacheable(value="shiro_user_cache:permission", key="#username")
    @Override
    public Set<String> findPermissionsByUsername(String username) {
        Set<String> permissions = new HashSet<String>();
        User user = this.findByUsername(username);
        if(user==null) {
            return permissions;
        }
        List<UserRole> userRoles = user.getUserRoleList();
        for(UserRole userRole:userRoles) {
            List<RolePermission> rolePermissions= userRole.getRole().getRolePermissionList();
            for(RolePermission rolePermission:rolePermissions) {
                permissions.add(rolePermission.getPermission().getName());
            }
        }       
        return permissions;
    }

    @CacheEvict(value={
    
    "shiro_user_cache:role","shiro_user_cache:permission"}, key="#username")
    public void clearUserCache(String username) {

    }

    @CacheEvict(value={
    
    "shiro_user_cache:role","shiro_user_cache:permission"}, allEntries=true)
    public void clearUserCache() {

    }

}

shiro_user_kickout和shiro_user_online，跟上面一样通过下面这个缓存管理器创建，通过他们实现单点登录或限定其他登录数.


<bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager"
        factory-method="create" c:connection-factory-ref="jedisConnectionFactory" />

package com.shiro;
import java.io.Serializable;
import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.AccessControlFilter;
import org.apache.shiro.web.util.WebUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import com.contant.SystemContant;
public class KickoutFilter extends AccessControlFilter { 

/** * 踢出前一个登陆或后一个登陆的同一用户 */
private boolean kickoutBefore = true;
/** * 同一个用户的最大同时登陆数 */
private int maxUserCount = 1;
/** * 保存同一用户登录数<用户名，sessionId队列> */
private Cache onliceCache;
/** * 被踢出的登录<用户名，sessionId队列> */
private Cache kickoutCache;
@Autowired
@Qualifier("redisCacheManager")
public void setCacheManager(CacheManager cacheManager) {
this.onliceCache = cacheManager.getCache("shiro_user_online");
this.kickoutCache = cacheManager.getCache("shiro_user_kickout");
}
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue)
throws Exception {
return false;
}
@Override
protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
Subject subject = getSubject(request, response);
Session session = subject.getSession();
String username = (String) subject.getPrincipal();
Serializable sessionId = session.getId();
//如果没有登录，直接进行之后的流程
if (!subject.isAuthenticated() && !subject.isRemembered()) {            
return true;
}
//先判断当前用户是否被踢出
Deque<Serializable> kickoutDeque = getKickoutDeque(username);
for (Serializable id : kickoutDeque) {
if (sessionId.equals(id)) {             
subject.logout();
//踢出后在kickoutDeque中删除当前sessionId
System.out.println("踢出sessionId：" + id);
kickoutDeque.remove(id);
kickoutCache.put(username, kickoutDeque);
//跳转到登录页
Map<String, String> params = new HashMap<String, String>();
params.put(SystemContant.KICKOUT_MSG, "kick out login");
WebUtils.issueRedirect(request, response, "/login", params);
return false;
}
}
//如果队列里没有此sessionId，放入队列
Deque<Serializable> onlineDeque = getOnlineDeque(username);
if (!onlineDeque.contains(sessionId)) {
onlineDeque.push(sessionId);
}
//判断当前用户在线数目是否超出maxUserCount，然后把超出的用户从onlineDeque移到kickoutDeque
while (onlineDeque.size() > maxUserCount) {
Serializable kickoutSessionId = null;
if (kickoutBefore) {
kickoutSessionId = onlineDeque.removeLast();
kickoutDeque.push(kickoutSessionId);
} else {
kickoutSessionId = onlineDeque.removeFirst();
kickoutDeque.push(kickoutSessionId);
}
}
onliceCache.put(username, onlineDeque);
kickoutCache.put(username, kickoutDeque);
return true;
}
/** * 获取在线用户 * * @param username * @return */
@SuppressWarnings("unchecked")
private Deque<Serializable> getOnlineDeque(String username) {
Deque<Serializable> onlineDeque;
if (onliceCache.get(username) == null) {
onlineDeque = new LinkedList<Serializable>();
} else {
onlineDeque = (Deque<Serializable>) onliceCache.get(username).get();
}
return onlineDeque;
}
/** * 获取被踢出的用户 * * @param username * @return */
@SuppressWarnings("unchecked")
private Deque<Serializable> getKickoutDeque(String username) {
Deque<Serializable> kickoutDeque;
if (kickoutCache.get(username) == null) {
kickoutDeque = new LinkedList<Serializable>();
} else {
kickoutDeque = (Deque<Serializable>) kickoutCache.get(username).get();
}
return kickoutDeque;
}
}

配置文件

applicationContext-redis.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:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<constructor-arg>
<bean class="org.springframework.data.redis.connection.RedisStandaloneConfiguration" c:host-name="${redis.host}" c:port="${redis.port}" />
</constructor-arg>      
</bean>
<bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager" factory-method="create" c:connection-factory-ref="jedisConnectionFactory" />
</beans>

applicationContext-session.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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration">
<property name="maxInactiveIntervalInSeconds" value="1800" />
</bean>
</beans>


applicationContext-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:util="http://www.springframework.org/schema/util" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
<!-- 安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<property name="realm">
<bean class="com.shiro.UserRealm"/>
</property>     
</bean>
<!-- Shiro Filter -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<property name="securityManager" ref="securityManager" />
<property name="loginUrl" value="/login" />
<property name="unauthorizedUrl" value="/login" />
<property name="filters">
<util:map>
<!-- Shiro的单点登录-->
<entry key="kickout">
<bean class="com.shiro.KickoutFilter" />
</entry>
</util:map>
</property>
<property name="filterChainDefinitions">
<value>
/login/** = anon
/common/taglibs.jspf = anon
/static/** = anon
/** = kickout,authc
</value>
</property>
</bean>
<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />
</beans>

applicationContext.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:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xmlns:cache="http://www.springframework.org/schema/cache" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:jpa="http://www.springframework.org/schema/data/jpa" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd" default-autowire="byName">
<context:annotation-config />
<context:component-scan base-package="com.service,core" />
<!-- 配置文件获取 -->
<bean id="propertyConfig" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location">
<value>classpath:application.properties</value>
</property>
<property name="fileEncoding">
<value>UTF-8</value>
</property>
</bean>
<!-- 数据源配置 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
<property name="driverClassName" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<!-- 设置连接池初始值 -->
<property name="initialSize" value="1" />
<!-- 设置连接池最大值 -->
<property name="maxActive" value="100" />
<!-- 设置连接池最小空闲值 -->
<property name="minIdle" value="10" />
<!-- 获取连接最大等待时间 -->
<property name="maxWait" value="60000" />
<!-- 配置间隔10分钟，检测空闲了5分钟的连接是否需要关闭，单位是毫秒 -->
<property name="timeBetweenEvictionRunsMillis" value="600000" />
<property name="minEvictableIdleTimeMillis" value="300000" />
<property name="validationQuery" value="SELECT 1 FROM DUAL " />
<property name="testOnBorrow" value="false" />
<property name="testOnReturn" value="false" />
<property name="testWhileIdle" value="true" />
<property name="filters" value="stat" />
</bean>
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<!-- 适配器 -->
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
</property>
<property name="packagesToScan" value="com.entity"></property>
<property name="jpaProperties">
<props>
<!-- 生成的数据表的列的映射策略 -->
<prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.use_sql_comments">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
<!-- 使用JDK代理方式配置AOP，暴露代理到Threadload，解决内部调用存在事务再另起事务失效问题 -->
<aop:aspectj-autoproxy expose-proxy="true" proxy-target-class="false" />
<!-- 使用注解方式定义事务 -->
<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="false" />
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"></property>    
</bean>
<!-- Spring Data Jpa配置 -->
<jpa:repositories base-package="com.dao" repository-impl-postfix="Impl" entity-manager-factory-ref="entityManagerFactory" transaction-manager-ref="transactionManager"/>
<!-- 启用缓存注解功能 -->
<cache:annotation-driven cache-manager="redisCacheManager" />
<bean id="redisUtil" class="core.util.RedisUtil" />
</beans>

springServletContext.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" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<mvc:annotation-driven />
<mvc:view-controller path="/" view-name="redirect:/login"/>
<context:component-scan base-package="com.controller">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" />
</context:component-scan>
<!-- Enable Shiro Annotations for Spring-configured beans. Only run after -->
<!-- the lifecycleBeanProcessor has run: -->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor"/>
<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
<property name="securityManager" ref="securityManager"/>
</bean>
<bean id="JstlView" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="order" value="1" />
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
<property name="prefix" value="/WEB-INF/jsp/" />
<property name="suffix" value=".jsp" />
</bean>
</beans>