springboot shiro 使用redis存储登录信息 实现单点登录sso

最新推荐文章于 2023-09-16 23:01:19 发布
最新推荐文章于 2023-09-16 23:01:19 发布
阅读量7.8k 收藏 41
点赞数 6
分类专栏： springboot shiro
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012954380/article/details/102244194
版权

shiro 默认使用的是session 存储登录信息的，这对于单体应用来讲是没有什么问题的，但是对于分布式应用或者集群应用就行不通了，因为集群或者分布式系统 应用部署在不同的jvm 上，session不能共享。如果使用redis存储登录信息则可以解决这个问题，这里简单使用 shiro-redis框架 来实现这个功能

具体流程如下

首先我们创建一个springboot 父子工程 

父工程pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.9.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.shiroredis</groupId>
    <artifactId>shiro-redis-sso</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>shiro-redis-sso</name>
    <packaging>pom</packaging>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <modules>
        <module>user</module>
        <module>other</module>
    </modules>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.29</version>
        </dependency>

        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-all</artifactId>
            <version>1.3.2</version>
        </dependency>

        <dependency>
            <groupId>org.crazycake</groupId>
            <artifactId>shiro-redis</artifactId>
            <version>3.1.0</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

两个子工程pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.shiroredis</groupId>
        <artifactId>shiro-redis-sso</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>com.shiroredis</groupId>
    <artifactId>user</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>user</name>

</project>

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.shiroredis</groupId>
        <artifactId>shiro-redis-sso</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>com.shiroredis</groupId>
    <artifactId>other</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>other</name>


</project>

创建数据库  

CREATE DATABASE /*!32312 IF NOT EXISTS*/`ease-run` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `ease-run`;

/*Table structure for table `user` */

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) DEFAULT NULL,
  `password` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

/*Data for the table `user` */

insert  into `user`(`id`,`username`,`password`) values (1,'yangzheng','123'),(2,'yangzheng1','123'),(3,'yangzheng3','123'),(5,'yangzheng4','1234');

在user模块创建 实体类  mapper  xml 文件

package com.shiroredis.entity;

import lombok.Data;

import java.io.Serializable;

/**
 * <p>
 * 
 * </p>
 *
 * @author Adam
 * @since 2019-10-04
 */
@Data
public class User implements Serializable{
    private Long id;
    private String username;
    private String password;
}

package com.shiroredis.dao;

import com.shiroredis.entity.User;

public interface UserMapper {
    User selectUserByUsernameAndPassword(String username,String password);
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.shiroredis.dao.UserMapper">
    <select id="selectUserByUsernameAndPassword" resultType="com.shiroredis.entity.User">
      select * from user where username = #{username} and password = #{password}
    </select>

</mapper>

user模块配置文件

server.port=8080

#mysql
spring.datasource.url=jdbc:mysql://localhost:3306/ease-run?serverTimezone=Asia/Chongqing&useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&verifyServerCertificate=false&autoReconnct=true&autoReconnectForPools=true&allowMultiQueries=true
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#mybatis-plus
#Mybatis扫描
mybatis.mapper-locations=classpath*:mapper/*.xml
#起别名。可省略写mybatis的xml中的resultType的全路径
mybatis.type-aliases-package=com.shiroredis.entity

#druid配置

# 初始化大小，最小，最大
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=20
# 配置获取连接等待超时的时间
spring.datasource.maxWait=60000 
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.timeBetweenEvictionRunsMillis=60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.minEvictableIdleTimeMillis=300000
# 校验SQL，Oracle配置 spring.datasource.validationQuery=SELECT 1 FROM DUAL，如果不配validationQuery项，则下面三项配置无用
spring.datasource.validationQuery=SELECT 'x'
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
# 打开PSCache，并且指定每个连接上PSCache的大小
spring.datasource.poolPreparedStatements=true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
spring.datasource.filters=stat,wall,logback
# 通过connectProperties属性来打开mergeSql功能；慢SQL记录
spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
# 合并多个DruidDataSource的监控数据
spring.datasource.useGlobalDataSourceStat=true

spring.redis.host=localhost
spring.redis.port=6379

#log
logging.path=./logs
logging.file=Log   
logging.config=classpath:logback-spring-dev.xml

logback日志配置文件

<?xml version="1.0" encoding="UTF-8"?>
<configuration>    
    <!-- %m输出的信息,%p日志级别,%t线程名,%d日期,%c类的全名,%i索引【从数字0开始递增】,,, -->    
    <!-- appender是configuration的子节点，是负责写日志的组件。 -->
    <!-- ConsoleAppender：把日志输出到控制台 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d %p (%file:%line\)- %m%n</pattern>
            <!-- 控制台也要使用UTF-8，不要使用GBK，否则会中文乱码 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    <!-- RollingFileAppender：滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 -->
    <!-- 以下的大概意思是：1.先按日期存日志，日期变了，将前一天的日志文件名重命名为XXX%日期%索引，新的日志仍然是demo.log -->
    <!--             2.如果日期没有发生变化，但是当前日志的文件大小超过1KB时，对当前日志进行分割 重命名-->
    <appender name="demolog" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!--<File>/log/wanmo-service.log</File>    -->
        <!--&lt;!&ndash; rollingPolicy:当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名。 &ndash;&gt;-->
        <!--&lt;!&ndash; TimeBasedRollingPolicy： 最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动 &ndash;&gt;-->
        <!--<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">    -->
            <!--&lt;!&ndash; 活动文件的名字会根据fileNamePattern的值，每隔一段时间改变一次 &ndash;&gt;-->
            <!--&lt;!&ndash; 文件名：log/demo.2017-12-05.0.log &ndash;&gt;-->
            <!--<fileNamePattern>/log/wanmo-service.%d.%i.log</fileNamePattern> -->
            <!--&lt;!&ndash; 每产生一个日志文件，该日志文件的保存期限为30天 &ndash;&gt; -->
            <!--<maxHistory>30</maxHistory>   -->
            <!--<timeBasedFileNamingAndTriggeringPolicy  class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">    -->
                <!--&lt;!&ndash; maxFileSize:这是活动文件的大小，默认值是10MB，测试时可改成1KB看效果 &ndash;&gt;  -->
                <!--<maxFileSize>10MB</maxFileSize>    -->
            <!--</timeBasedFileNamingAndTriggeringPolicy>    -->
        <!--</rollingPolicy>    -->
        <!--<encoder>    -->
            <!--&lt;!&ndash; pattern节点，用来设置日志的输入格式 &ndash;&gt;-->
            <!--<pattern>    -->
                <!--%d %p (%file:%line\)- %m%n  -->
            <!--</pattern>    -->
            <!--&lt;!&ndash; 记录日志的编码:此处设置字符集 - &ndash;&gt;-->
            <!--<charset>UTF-8</charset>-->
        <!--</encoder>    -->
    </appender>    
    <!-- 控制台输出日志级别 -->
    <root level="info">    
        <appender-ref ref="STDOUT" />    
    </root>    
    <!-- 指定项目中某个包，当有日志操作行为时的日志记录级别 -->
    <!-- com.liyan为根包，也就是只要是发生在这个根包下面的所有日志操作行为的权限都是DEBUG -->
    <!-- 级别依次为【从高到低】：FATAL > ERROR > WARN > INFO > DEBUG > TRACE  -->
    <logger name="com.yangzheng" level="DEBUG">
        <appender-ref ref="demolog" />    
    </logger>    
</configuration>

shiro realm 类

package com.shiroredis.realm;

import com.shiroredis.dao.UserMapper;
import com.shiroredis.entity.User;
import org.apache.shiro.authc.*;
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;

/**
 * 自定义realm
 * @author jianping.lu
 *
 */
public class UserRealm extends AuthorizingRealm{

    @Autowired
    private UserMapper userMapper;

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection arg0) {
        System.out.println("权限配置-->MyShiroRealm.doGetAuthorizationInfo()");
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        return authorizationInfo;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken arg0) throws AuthenticationException {
        // TODO Auto-generated method stub
        System.out.println("认证");
        //shiro判断逻辑
        UsernamePasswordToken user = (UsernamePasswordToken) arg0;
        User newUser = userMapper.selectUserByUsernameAndPassword(user.getUsername(),String.valueOf(user.getPassword()));
        if(newUser == null){
            //用户名错误
            return null;
        }
        return new SimpleAuthenticationInfo(newUser,newUser.getPassword(),"");
    }
}

核心shiroConfig 类

这里将默认的shiro 的 sessionmanager 和cachemanager 换成了  crazycake 基于redis 实现的  sessionmanager 和cachemanager，即可用 redis 管理 登录信息，注意一点是  shiroconfig 如果要使用@Value注解读取配置数据时，需要把

@Bean
public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){
    return new LifecycleBeanPostProcessor();
}

方法改成静态的。

package com.shiroredis.config;

import com.shiroredis.realm.UserRealm;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisManager;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;

import java.util.LinkedHashMap;

@Configuration
public class ShiroConfig {

    @Value("${spring.redis.host}")
    String host;

    @Value("${spring.redis.port}")
    int port;

    @Bean
    public RedisManager redisManager(){
        RedisManager redisManager = new RedisManager();     // crazycake 实现
//        RedisClusterManager redisClusterManager = new RedisClusterManager();
        redisManager.setHost(host);
        redisManager.setPort(port);
        redisManager.setTimeout(180000);
        return redisManager;
    }

    @Bean
    public JavaUuidSessionIdGenerator sessionIdGenerator(){
        return new JavaUuidSessionIdGenerator();
    }

    @Bean
    public RedisSessionDAO sessionDAO(){
        RedisSessionDAO sessionDAO = new RedisSessionDAO(); // crazycake 实现
        sessionDAO.setRedisManager(redisManager());
        sessionDAO.setSessionIdGenerator(sessionIdGenerator()); //  Session ID 生成器
        return sessionDAO;
    }

    @Bean
    public SimpleCookie cookie(){
        SimpleCookie cookie = new SimpleCookie("SHAREJSESSIONID"); //  cookie的name,对应的默认是 JSESSIONID
        cookie.setHttpOnly(true);
        cookie.setPath("/");        //  path为 / 用于多个系统共享JSESSIONID
        return cookie;
    }

    @Bean
    public DefaultWebSessionManager sessionManager(){
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
        sessionManager.setGlobalSessionTimeout(-1000L);    // 设置session超时
        sessionManager.setDeleteInvalidSessions(true);      // 删除无效session
        sessionManager.setSessionIdCookie(cookie());            // 设置JSESSIONID
        sessionManager.setSessionDAO(sessionDAO());         // 设置sessionDAO
        return sessionManager;
    }

    /**
     * 1. 配置SecurityManager
     * @return
     */
    @Bean
    public DefaultWebSecurityManager securityManager(){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(realm());  // 设置realm
        securityManager.setSessionManager(sessionManager());    // 设置sessionManager
        securityManager.setCacheManager(redisCacheManager()); // 配置缓存的话，退出登录的时候crazycake会报错，要求放在session里面的实体类必须有个id标识
        return securityManager;
    }

    /**
     * 2. 配置缓存
     * @return
     */
//    @Bean
//    public CacheManager cacheManager(){
//        EhCacheManager ehCacheManager = new EhCacheManager();
//        ehCacheManager.setCacheManagerConfigFile("classpath:ehcache.xml");
//        return ehCacheManager;
//    }

    @Bean
    public RedisCacheManager redisCacheManager(){
        RedisCacheManager cacheManager = new RedisCacheManager();   // crazycake 实现
        cacheManager.setRedisManager(redisManager());
        return cacheManager;
    }

    /**
     * 3. 配置Realm
     * @return
     */
    @Bean
    public AuthorizingRealm realm(){
        return new UserRealm();
    }

    /**
     * 4. 配置LifecycleBeanPostProcessor，可以来自动的调用配置在Spring IOC容器中 Shiro Bean 的生命周期方法
     * @return
     */
    @Bean
    public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){
        return new LifecycleBeanPostProcessor();
    }

    /**
     * 5. 启用IOC容器中使用Shiro的注解，但是必须配置第四步才可以使用
     * @return
     */
    @Bean
    @DependsOn("lifecycleBeanPostProcessor")
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
        return new DefaultAdvisorAutoProxyCreator();
    }

    /**
     * 6. 配置ShiroFilter
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(){
        LinkedHashMap<String, String> map = new LinkedHashMap<>();

        map.put("/user/login", "anon");
        map.put("/user/logout", "anon");

        // everything else requires authentication:
        map.put("/**", "authc");

        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        // 配置SecurityManager
        factoryBean.setSecurityManager(securityManager());
        // 配置权限路径
        factoryBean.setFilterChainDefinitionMap(map);

        // 配置登录url
        factoryBean.setLoginUrl("/");
        // 配置无权限路径
        factoryBean.setUnauthorizedUrl("/unauthorized");
        return factoryBean;
    }

}

controller 层

package com.shiroredis.controller;

import com.shiroredis.entity.User;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/login")
    public User login(@RequestParam(value = "username") String username,
                      @RequestParam(value = "password") String password){
        Subject subject = SecurityUtils.getSubject();
        subject.login(new UsernamePasswordToken(username, password));
        User user = (User) SecurityUtils.getSubject().getPrincipal();
        return user;
    }

    @RequestMapping("/logout")
    public Boolean logout(){
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        return true;
    }

    @RequestMapping("/get")
    public User get(){
        User user = (User) SecurityUtils.getSubject().getPrincipal();
        return user;
    }

}

user 模块效果

redis  数据

cookie 数据 可以发现和redis的key是一样的

再配置other 模块，这里就比较简单了

@SpringBootApplication 注解换成

@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class, HibernateJpaAutoConfiguration.class})

取消自动注入数据源，因为不需要从数据库读取用户数据了

 

配置文件

server.port=8082
spring.redis.host=localhost
spring.redis.port=6379

 

实体类  直接复制就可以了

package com.shiroredis.entity;

import lombok.Data;

import java.io.Serializable;

/**
 * <p>
 * 
 * </p>
 *
 * @author Adam
 * @since 2019-10-04
 */
@Data
public class User implements Serializable{
    private Long id;
    private String username;
    private String password;
}

realm 要注意删掉  认证方法里面的内容，因为其他模块不需要登录，只要获取登录的用户信息即可

package com.shiroredis.realm;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

/**
 * 自定义realm
 *
 * @author jianping.lu
 */
public class UserRealm extends AuthorizingRealm {

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection arg0) {
        System.out.println("权限配置-->MyShiroRealm.doGetAuthorizationInfo()");
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        return authorizationInfo;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken arg0) throws AuthenticationException {
        return null;
    }
}

shiroconfig 直接复制就可以了

package com.shiroredis.config;

import com.shiroredis.realm.UserRealm;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisManager;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;

import java.util.LinkedHashMap;

@Configuration
public class ShiroConfig {

    @Value("${spring.redis.host}")
    String host;

    @Value("${spring.redis.port}")
    int port;

    @Bean
    public RedisManager redisManager(){
        RedisManager redisManager = new RedisManager();     //  实现
//        RedisClusterManager redisClusterManager = new RedisClusterManager();
        redisManager.setHost(host);
        redisManager.setPort(port);
        redisManager.setTimeout(180000);
        return redisManager;
    }

    @Bean
    public JavaUuidSessionIdGenerator sessionIdGenerator(){
        return new JavaUuidSessionIdGenerator();
    }

    @Bean
    public RedisSessionDAO sessionDAO(){
        RedisSessionDAO sessionDAO = new RedisSessionDAO(); // crazycake 实现
        sessionDAO.setRedisManager(redisManager());
        sessionDAO.setSessionIdGenerator(sessionIdGenerator()); //  Session ID 生成器
        return sessionDAO;
    }

    @Bean
    public SimpleCookie cookie(){
        SimpleCookie cookie = new SimpleCookie("SHAREJSESSIONID"); //  cookie的name,对应的默认是 JSESSIONID
        cookie.setHttpOnly(true);
        cookie.setPath("/");        //  path为 / 用于多个系统共享JSESSIONID
        return cookie;
    }

    @Bean
    public DefaultWebSessionManager sessionManager(){
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
        sessionManager.setGlobalSessionTimeout(-1000L);    // 设置session超时
        sessionManager.setDeleteInvalidSessions(true);      // 删除无效session
        sessionManager.setSessionIdCookie(cookie());            // 设置JSESSIONID
        sessionManager.setSessionDAO(sessionDAO());         // 设置sessionDAO
        return sessionManager;
    }

    /**
     * 1. 配置SecurityManager
     * @return
     */
    @Bean
    public DefaultWebSecurityManager securityManager(){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(realm());  // 设置realm
        securityManager.setSessionManager(sessionManager());    // 设置sessionManager
        securityManager.setCacheManager(redisCacheManager()); // 配置缓存的话，退出登录的时候crazycake会报错，要求放在session里面的实体类必须有个id标识
        return securityManager;
    }

    /**
     * 2. 配置缓存
     * @return
     */
//    @Bean
//    public CacheManager cacheManager(){
//        EhCacheManager ehCacheManager = new EhCacheManager();
//        ehCacheManager.setCacheManagerConfigFile("classpath:ehcache.xml");
//        return ehCacheManager;
//    }

    @Bean
    public RedisCacheManager redisCacheManager(){
        RedisCacheManager cacheManager = new RedisCacheManager();   // crazycake 实现
        cacheManager.setRedisManager(redisManager());
        return cacheManager;
    }

    /**
     * 3. 配置Realm
     * @return
     */
    @Bean
    public AuthorizingRealm realm(){
        return new UserRealm();
    }

    /**
     * 4. 配置LifecycleBeanPostProcessor，可以来自动的调用配置在Spring IOC容器中 Shiro Bean 的生命周期方法
     * @return
     */
    @Bean
    public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){
        return new LifecycleBeanPostProcessor();
    }

    /**
     * 5. 启用IOC容器中使用Shiro的注解，但是必须配置第四步才可以使用
     * @return
     */
    @Bean
    @DependsOn("lifecycleBeanPostProcessor")
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
        return new DefaultAdvisorAutoProxyCreator();
    }

    /**
     * 6. 配置ShiroFilter
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(){
        LinkedHashMap<String, String> map = new LinkedHashMap<>();

        map.put("/user/login", "anon");
        map.put("/user/logout", "anon");

        // everything else requires authentication:
        map.put("/**", "authc");

        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        // 配置SecurityManager
        factoryBean.setSecurityManager(securityManager());
        // 配置权限路径
        factoryBean.setFilterChainDefinitionMap(map);

        // 配置登录url
        factoryBean.setLoginUrl("/");
        // 配置无权限路径
        factoryBean.setUnauthorizedUrl("/unauthorized");
        return factoryBean;
    }

}

controller 就不用提供登录，退出登录方法了

package com.shiroredis.controller;

import com.shiroredis.entity.User;
import org.apache.shiro.SecurityUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/get")
    public User get(){
        User user = (User) SecurityUtils.getSubject().getPrincipal();
        return user;
    }

}

运行效果

有一个地方需要注意，由于shiro-redis使用到了 ThreadLocal,在高并发场景下有可能会造成内存溢出，解决办法是禁用ThreadLocal,shiro-redis版本升级至  3.2.3

<dependency>
     <groupId>org.crazycake</groupId>
     <artifactId>shiro-redis</artifactId>
     <version>3.2.3</version>
</dependency>

shiroConfig  添加   sessionDAO.setSessionInMemoryEnabled(false);  禁用ThreadLocal就可以了

@Bean
public RedisSessionDAO sessionDAO(){
        RedisSessionDAO sessionDAO = new RedisSessionDAO(); // crazycake 实现
        sessionDAO.setSessionInMemoryEnabled(false);
        sessionDAO.setRedisManager(redisManager());
        sessionDAO.setSessionIdGenerator(sessionIdGenerator()); //  Session ID 生成器
        return sessionDAO;
}

最后附上源码  https://github.com/Yanyf765/shiro-redis-sso

yangzheng01
关注
  • 6
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
专栏目录
springboot+shiro+redis多端登录：单点登录+移动端和PC端同时在线
geejkse_seff的博客
03-28 2747
参考文章： 单点登录：https://mp.weixin.qq.com/s/DGFFPl93kZxS5G_DSFTBDA 多端登录：https://blog.csdn.net/zhourenfei17/article/details/88826911 一、前言 最近一个springboot项目要求增加一些app的功能。然后首先要改的就是这个登录的功能。我原本的登录就只是web端登录，实现了单点登录，就是同一个用户只能同时登录一次，如果再次登录的话，会清除上一次的登录信息。（具体实现参考上面的单点登录链接）
一个基于 Spring boot + shiro + redis mybatis 的单点登录starter
编码爱好者
03-09 733
这是我个人参考 https://gitee.com/liselotte/spring-boot-shiro-demo 进行修改，简单的封装一个基于shiro的单点登录starter 我个人不反对你们转发、复制、包括下载以及修改源码等等操作，如果你觉得有用，点个赞，如果你觉得我写的很差，请轻点喷我，毕竟我还是一个菜鸡。。。。 注意事项： 1、支持微服务模块 2、此项目未上传至中央仓库，如有需要，可自...
springboot+shiro+redis+单点登录+异常全局处理+加密(内含sql脚本)
xajh_czbk的博客
03-10 1008
本来是想学习shiro的，不过后来发现竟然一次性能学到。具体能学到哪些呢？哈哈，看标题吧。如果有什么知识点没看懂的，欢迎私信我！ 注明链接，感谢大牛：https://www.cnblogs.com/javazhiyin/p/11398374.html。这里有git地址，也有源码，大家认真翻阅，定会大有收获！ 项目目录结构： 启动类代码： package com.sh.demo; import org.mybatis.spring.annotation.MapperScan; import
springboot redis shiro 实现 单点登录
m0_38053538的博客
05-25 5669
大家好，我是烤鸭：    今天给大家分享简单的单点登录的实现方式。    环境及jar包:    springboot     1.5.10       redis    2.9.0    （可以用tomcat的session，但是无法解决多个tomcat共享session的问题）    shiro    1.4.0        lombok    1.16.10    （可选,编译的时候自动生...
shiro+spring+data+session+redis实现单点登录
08-03
shiro+spring+data+session+redis实现单点登录，这是一个不错的案例，学习和参考都是很不错的
shiro 使用redis存储登录信息 实现单点登录
weixin_42118981的博客
03-19 1080
shiro是一款出色的权限框架，能够实现诸如登录校验、权限校验等功能，默认情况下,shir将session保存到内存中，这在应用分布式部署的情况下会出现session不一致的问题，所以我们要将session保存到第三方，应用始终从第三方获取session，从而保证分布式部署时session始终是一致的，这里我们采用redis保存session。单点登陆的实现逻辑是在用户登陆时，生成token，然后将token以用户登陆账号为key,保存到redis中,再把token放到cookie中，用户在访问的时候，我们
SpringBoot 整合Shiro实现动态权限加载更新+Session共享+单点登录
m0_37471591的博客
07-23 166
一.说明 Shiro是一个安全框架,项目中主要用它做认证,授权,加密,以及用户的会话管理,虽然Shiro没有SpringSecurity功能更丰富,但是它轻量,简单,在项目中通常业务需求Shiro也都能胜任. 二.项目环境 MyBatis-Plus版本: 3.1.0 SpringBoot版本:2.1.5 JDK版本:1.8 Shiro版本:1.4 Shiro-redis插件版本:3.1.0 数据表(SQL文件在项目中):数据库中测试号的密码进行了加密,密
六。shiro集群，将session保存到数据库和redis，使用户保持登录状态
u014203449的博客
07-08 8679
1.目标 1.web端，用户第一次登陆之后，以后不需要再输入用户密码，就可以直接访问。使用cookie 2.shiro集群使用，需要共享session，把session放到数据库或redis就实现了这个目的 2.原理 会话管理器管理着应用中所有 Subject 的会话的创建、维护、删除、失效、验证等工作。是Shiro 的核心组件，顶层组件 SecurityManager 直接继承了 Ses...
这里简单完成一个shiro的单点登陆(用redis)启动两个节点
qq_43077857的博客
06-24 742
首先最开始就是springboot整合shiro 这个网上蛮多的，这里我先不弄 看到网上蛮多资料都是shiro单点登陆整合redis 说白了就是shiro登陆后将登陆信息给session了 可是另外一个节点的shiro没有这个session的信息 于是干脆把第一个登陆的信息保存到session中然后再交给一个公共的redis。另外一个节点的shiro也整合这个redis,所以他们的session...
shiro+ springMVC + Redis+mysql 实现 单点登录
12-06
Shiro安全框架, 实现系统的单点登陆和登出功能, 包含数据库文件
civism-sso:基于springmvc+redis+shiro 实现的分布式单点登录系统
05-14
civism-sso基于springmvc+redis+shiro 实现的分布式单点登录系统,继承了登录验证以及数据接口鉴权， 能很好的帮助其他项目做前后端分析，并且不需要其他子系统关心权限，并且该项目支持跨域请求 功能介绍 * sso登录...
springboot+shiro+cas+redis+mybatis+thymeleaf 集成开发框架
01-30
由于项目需要从网上搜集的相关的集成框架，很多都是部分集成，一直没有找到整个流程全部集成好的，所以将集成好的框架分享出来供...主要实现SSO、后台RBAC角色认证管理。 下载后需要自行修改配置，项目包内带sql脚本
基于springboot、shiro的单点登录系统+源代码+文档说明
最新发布
11-28
# 使用 客户端只需添加starter引用，配置文件中增加相应配置即可。参见web-demo。 ```xml <groupId>com.arnold</groupId> <artifactId>sso-boot-starter <version>0.0.1-SNAPSHOT ``` # 技术 - springboot -...
Shiro实战系列--整合shiro-redis
热门推荐
IT利刃出鞘的博客
10-18 1万+
本文用实例介绍shiro通过引入shiro-redis来缓存权限。使用SpringBoot整合Shiro。
基于SpringbootShiro实现的CAS单点登录
神尐破
09-16 2080
单点登录（Single Sign On,SSO）是一种登录管理机制，主要用于多系统集成，即在多个系统中，用户只需要到一个中央服务器登录一次即可访问这些系统中的任何一个，无须多次登录。常见的例子就是，当我们在淘宝网上登录了之后，如果再访问天猫网的话是不需要再次登录的。
shiro在分布式项目中实现单点登录
qq_28662263的博客
05-11 763
shiro在分布式项目中实现单点登录 Shiro的单点登录 使用shiro需要的依赖 org.crazycake shiro-redis 3.1.0 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifactId> <version>1.3
springboot Shiro 单点登录使用配置教程
m0_67393593的博客
04-25 1173
spring boot整合Shiro实现单点登录
shiro 实现多种方式登录_shiro实现单点登录(一个用户同一时刻只能在一个地方登录)...
weixin_39708636的博客
12-28 999
我这里 shiro 并没有集成 springMVC，直接使用 ini 配置文件。shiro.ini[main]# Objects and their properties are defined here,# Such as the securityManager, Realms and anything# else needed to build the SecurityManagerauthc...
springboot+shiro+redis实现单点登录源码
09-17
Spring Boot是一个用于快速开发Java应用程序的开源框架，Shiro是一个强大且易于使用的Java安全框架，Redis是一个开源的内存数据库。结合使用这些技术可以实现单点登录功能。 在Spring Boot中使用Shiro来处理认证和授权，可以通过配置Shiro的Realm来实现用户的登录认证和权限控制。将用户的信息存储在Redis中，利用Redis的持久化特性来实现用户登录状态的共享和存储。 首先，在Spring Boot项目的配置文件中配置Redis的连接信息，以便连接到Redis数据库。 然后，创建一个自定义的Shiro的Realm，在其中重写认证和授权的方法。在认证方法中，将用户的登录信息存储到Redis中，以便其他服务可以进行验证。在授权方法中，根据用户的角色和权限进行相应的授权操作。 接着，在Spring Boot项目的配置类中配置Shiro的相关设置，包括Realm、Session管理器、Cookie管理器等。 最后，可以在Controller层中使用Shiro的注解来标记需要进行认证和授权的接口，以确保只有登录后且具备相应权限的用户才能访问这些接口。 总的来说，通过使用Spring Boot、Shiro和Redis的组合，可以实现单点登录的功能。用户在登录后，将登录信息存储到Redis中，其他服务可以通过验证Redis中的数据来判断用户的登录状态。同时，Shiro提供了强大的认证和授权功能，可以确保只有具备相应权限的用户才能访问受保护的接口。这些功能的具体实现可以通过深入研究Spring Boot、Shiro和Redis的源码来了解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值