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

最新推荐文章于 2024-07-20 10:08:36 发布
最新推荐文章于 2024-07-20 10:08:36 发布
阅读量4.1k 收藏 3
点赞数
分类专栏： 笔记 文章标签： shiro redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011189939/article/details/79038395
版权

  • 运行效果图
    这里写图片描述
    这里写图片描述

  • 缓存说明（本项目没有使用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>

  • 源码地址

  • http://download.csdn.net/download/u011189939/10201279
五月一
关注
专栏目录
Spring boot + shiro + redis 实现session共享（伪单点登录）
学习编程的shou的博客
06-06 5938
    为实现Web应用的分布式集群部署，要解决登录session的统一。本文利用shiro做权限控制，redis做session存储，结合spring boot快速配置实现session共享。注意本文未解决跨域的问题。不过对于一般的情况能够很好的起到作用，具体已经在不同端口上进行了测试。    我们先从配置说起：1.引入相关依赖引入shiro相关的依赖还有Redis的依赖 ...
SpringSecurity - spring-session-data-redis的简单测试
风吹草动的博客
02-25 1944
SpringSecurity提供了默认了登陆窗口 SpringSession - redis 提供了session情报的redis连携机能， Session 问题 指APserver内信息的保存区域，使用多台AP构成的结构中，每台只保存自己的session情报的话，多台之间不能实现共享，用户的信息没法实现共享 解决方式 StickSession 使AP和Client之间实现1；1的构成，...
shiro+spring+data+session+redis实现单点登录
08-03
shiro+spring+data+session+redis实现单点登录，这是一个不错的案例，学习和参考都是很不错的
Redis+Shiro+Spring-data-redis，共享Session
weixin_34088598的博客
10-25 164
环境：centos7，Java1.8+，一个Nginx，两个Tomcat，一个Redis。 关于共享session的问题大家都应该知道了，传统的部署项目，两个相同的项目部署到不同的服务器上，Nginx负载均衡后会导致用户在A上登陆了，经过负载均衡后，在B上要重新登录，因为A上有相关session信息，而B没有。这种情况也称为“有状态”服务。而“无状态”服务则是：在一个公共的地方存储session...
SpringBoot+Session+redis实现分布式登录
最新发布
weixin_60523038的博客
07-20 729
SpringBoot+Redis+Session实现分布式登录
shiro使用redis缓存，实现session共享，spring-data-redis集群配置
Czijun1990914的博客
04-19 1452
使用mvc环境，spring-data-redis所需jar包版本如下，版本不同会报包冲突：spring4.2.8 spring-data-redis-1.7.4 spring-data-commons-1.12.4 jedis-2.9.0 --依赖commons-lang3-3.3.2通过shiro管理session，将session缓存到redis数据库，可以实现在应用集群下sessio...
在spring应用中使用shiro框架关于session解析
weixin_41490593的博客
05-29 1465
先看shiro过滤器的UML 已经有cookie保存sessionId的请求场景: 1.请求第一次通过shiro的过滤器 OncePerRequestFilter 时,会把request,response包装成ShiroHttpServletRequest和ShiroHttpServletResponse,并且在请求中设置一个属性标识,作用就是当这个请求再次经过过滤器 OncePerReques...
spring boot整合redis实现shiro的分布式session共享的方法
08-28
Spring Boot 整合 Redis 实现 Shiro 的分布式 Session 共享 Shiro 是一个优秀的 Java 安全框架，提供了强大的身份验证、授权和会话管理功能。然而，在分布式架构中，Shiro 的会话管理机制需要进行特殊处理，以便...
springboot +shiro+redis实现session共享（方案二）1
08-08
本文档旨在介绍如何使用 Spring Boot、Shiro 和 Redis 实现分布式 session 共享，以解决 Web 应用程序的登录 session 统一问题。 2. 相关依赖 在实现 session 共享之前，需要在项目中引入相关依赖项，包括： * ...
SpringBoot整合Redis实现Shiro权限控制的集群Session共享
calonmo的专栏
05-21 2206
网上很多介绍springboot+shiro+redis解决session共享的文章，但大部分都是基于springboot1.5版本的，有些接口发生变化。 本篇文章主要记录在SpringBoot2.x的基础上整合Shiro和Redis，实现权限控制与支持集群下的Session共享。 1、项目依赖 项目是基于Maven的，首先在pom.xml添加以下文件： <parent> ...
springboot整合shiro，redis缓存session
02-09
为实现Web应用的分布式集群部署，要解决登录session的统一。本文利用shiro做权限控制，redis做session存储，结合spring boot快速配置实现session共享。
基于spring redis的shiro session共享
05-27
shiro 框架没有用tomcat的session，而是重新实现了一套。所以系统一旦引入shiro后，采用传统的tomcat session共享机制是无效的，必须采用面向shiro 的session共享。 网上针对“shiro session共享”的文章比较多，但是大同小异，基本是基于redis实现的。但是该套实现，代码质量非常差（10几个java文件，都快吓晕），并且redis的连接没有基于spring，而是在java代码中硬编码，这几乎无法容忍。 为此，本人基于spring连接redis，吸取了他们文章的思想，重新写了一套解决方案。代码量已精简到他们的1/3，并且考虑到了他们没有考虑到的问题，绝对是精华！
spring-session-redis/spring整合redis管理session依赖jar包
08-01
commons-pool2-2.3.jar,jedis-2.8.0.jar,spring-data-redis-1.6.0.RELEASE.jar,spring-session-1.1.1.RELEASE.jar,Spring-data-redis(Version 1.6.0.RC1)中文版.pdf
springboot shiro redis缓存和session共享例子
05-17
实现springboot 、shiro 、redis缓存和session共享源码例子
分布式session解决——Spring-data-redis
diaohan1348的博客
02-02 122
1.如果没有集成shiro来管理session，可以直接使用spring-session 2.若集成了shiro，需要Spring-data-redis （或 shiro-redis） 3.nginx设置 　　a.下载nginx 　　b.解压后，在conf目录下修改nginx.conf文件，配置反向代理 upstream tomcat_server{ ...
C#session共享+redis_Shiro Springboot 集群共享Session (Redis)+单用户登录
weixin_39803977的博客
11-20 240
前言 先贴一个项目地址 GitHub-Springboot-shiro-Redis 全文基于Maven进行管理 本文涉及范围 1.shiro在Springboot的共享Session配置 2.Shiro单用户登录的配置 3.Spring-data-jpa的部分不会赘述 个人学习研究，目前未在生产环境使用，有好的意见欢迎评论 共享Session的应用场景应用场景当用户访问系统服务时，会经过负载均...
SpringBoot整合Redis实现Shiro分布式Session共享
m0_67402341的博客
04-08 654
前言： 我们知道shiro有一套自身的session管理机制，默认的session是存储在运行jvm内存中的，在单应用服务器中可共享session，但系统若为分布式架构，则不同应用服务器之间无法共享session，要实现不同应用服务器之间共享session，则需要重写SessionManager中的SessionDao，把session存储在缓存中，这里我们采用redis来存储，引用shiro-redis插件已为我们实现了SessionDao的重写，闲话少说上代码： 1.pom.xml配置依赖包 <!
springboot+redis+shiro+spring-session实现session共享
龙ygl龙的博客
05-09 7348
系统中用了shiro做权限控制和身份认证（其实身份认证可以用jwt的，这在我以后的博客中会写到）。本来是单一系统。但是现在要做成分布式的。所以就只能用到session共享。其实不用spring-session也能实现session共享，只需要将session存入redis即可。但是spring-session作为现成的框架，把许多底层的东西都已经封装了，不用白不用啊。spring-ses...
Spring-data-redis整合：Java入门Redis教程
我们引入了两个主要的依赖：`spring-data-redis`和`spring-core`。`spring-data-redis`版本为1.0.2.RELEASE，它包含了对Redis的支持，而`spring-core`则提供了Spring框架的基础功能。同时，`redis.clients`组库的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值