SpringBoot+Shiro+Redis共享Session入门小栗子

最新推荐文章于 2022-05-30 11:13:34 发布
最新推荐文章于 2022-05-30 11:13:34 发布
阅读量91 收藏
点赞数
文章标签： 数据库 运维 javascript ViewUI
原文链接：http://www.cnblogs.com/LUA123/p/9337963.html
版权

在单机版的Springboot+Shiro的基础上，这次实现共享Session。

这里没有自己写RedisManager、SessionDAO。用的 crazycake 写的开源插件

pom.xml

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-all -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-all</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.crazycake/shiro-redis -->
        <dependency>
            <groupId>org.crazycake</groupId>
            <artifactId>shiro-redis</artifactId>
            <version>3.1.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>
View Code

 redis配置文件

package com.example.demo.conf;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;


@Configuration
@PropertySource("classpath:conf/redis.properties")
public class RedisConfig {

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

    @Value("${shiro.redis.timeout}")
    private int timeout;

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }
}

 

Shiro配置文件

 

package com.example.demo.conf;

import com.example.demo.auth.PermissionRealm;
import com.example.demo.common.entity.User;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.LinkedHashMap;

@Configuration
public class ShiroConfig {

    @Bean
    public RedisConfig redisConfig(){
        return new RedisConfig();
    }

    @Bean
    public RedisManager redisManager(){
        RedisManager redisManager = new RedisManager();     // crazycake 实现
        redisManager.setHost(redisConfig().getHost());
        redisManager.setTimeout(redisConfig().getTimeout());
        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(redisConfig().getTimeout());    // 设置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(){
        PermissionRealm realm = new PermissionRealm();
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        // 指定加密算法
        matcher.setHashAlgorithmName("MD5");
        // 指定加密次数
        matcher.setHashIterations(10);
        // 指定这个就不会报错
        matcher.setStoredCredentialsHexEncoded(true);
        realm.setCredentialsMatcher(matcher);
        return realm;
    }

    /**
     * 4. 配置LifecycleBeanPostProcessor，可以来自动的调用配置在Spring IOC容器中 Shiro Bean 的生命周期方法
     * @return
     */
    @Bean
    public 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("/css/**", "anon");
        map.put("/js/**", "anon");

        // 公共路径
        map.put("/login", "anon");
        map.put("/register", "anon");
        //map.put("/*", "anon");

        // 登出,项目中没有/logout路径,因为shiro是过滤器,而SpringMVC是Servlet,Shiro会先执行
        map.put("/logout", "logout");

        // 授权
        map.put("/user/**", "authc,roles[user]");
        map.put("/admin/**", "authc,roles[admin]");

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

    /**
     * 配置RedisTemplate，充当数据库服务
     * @return
     */
    @Bean
    public RedisTemplate<String,User> redisTemplate(RedisConnectionFactory connectionFactory){
        RedisTemplate<String,User> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<User>(User.class));
        return redisTemplate;
    }

}

 

UserService

package com.example.demo.service;

import com.example.demo.common.entity.User;

import java.util.List;


public interface UserService {

    void addUser(User user);

    User login(User user);

    List<User> getUsers();

}

 

impl

package com.example.demo.service.impl;

import com.example.demo.common.PasswordUtils;
import com.example.demo.common.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private RedisTemplate<String, User> redisTemplate;

    @Override
    public void addUser(User user) {
        user.setPassword(PasswordUtils.saltAndMd5(user.getUsername(),user.getPassword()));  // 加密
        redisTemplate.boundHashOps("users").put(user.getUsername(), user);
    }

    @Override
    public User login(User user) {
        user.setPassword(PasswordUtils.saltAndMd5(user.getUsername(),user.getPassword()));  // 加密
        User u = (User) redisTemplate.boundHashOps("users").get(user.getUsername());
        if (u == null || !check(user, u)){
            return null;
        }
        return u;
    }

    @Override
    public List<User> getUsers() {
        List<Object> list = redisTemplate.boundHashOps("users").values();
        List<User> users = new ArrayList<>();
        list.forEach(u->{
            users.add((User) u);
        });
        return users;
    }

    private boolean check(User a, User b){
        if (a.getUsername().equals(b.getUsername()) && a.getPassword().equals(b.getPassword())){
            return true;
        }
        return false;
    }
}

 

controller

package com.example.demo.controller;

import com.example.demo.common.entity.User;
import com.example.demo.common.response.BaseResponse;
import com.example.demo.service.UserService;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;


@RestController
public class SimpleController {

    @Autowired
    private UserService userService;

    @RequestMapping("/")
    public ModelAndView index(){
        return new ModelAndView("index");
    }

    @RequestMapping("/login")
    public BaseResponse<String> login(@RequestBody User user){
        BaseResponse<String> response = new BaseResponse<>(0,"登陆成功");
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken(
                user.getUsername(), user.getPassword());
        subject.login(token);
        response.setData("/home");
        return response;
    }

    @RequestMapping("/register")
    public BaseResponse register(@RequestBody User user){
        userService.addUser(user);
        return new BaseResponse(0,"注册成功");
    }

    @RequestMapping("/home")
    public ModelAndView home(){
        ModelAndView mv = new ModelAndView("home");
        mv.addObject("users", userService.getUsers());
        return mv;
    }
}

 redis.properties

shiro.redis.host=localhost:6379
shiro.redis.timeout=1800000

 

applicatin.properties

#server.port=8080
server.port=8081
#server.port=8082

spring.redis.host=127.0.0.1
spring.redis.port=6379

 

index.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Index</title>
    <link th:href="@{css/index.css}" rel="stylesheet" type="text/css">
</head>
<body>
    <div class="container">
        <div class="header">
            <h2>初级SpringBoot+Shiro小栗子 Node-One</h2>
            <!--<h2>初级SpringBoot+Shiro小栗子 Node-Two</h2>-->
        </div>
        <div class="main">
            <div class="left">
                <div class="form-group">
                    <input type="text" name="username" placeholder="请输入用户名">
                </div>
                <div class="form-group">
                    <input type="password" name="password" placeholder="请输入密码">
                </div>
                <div class="form-group">
                    <a href="javascript:;" id="login">登录</a>
                </div>
                <div class="form-group">
                    <a href="/home">点我！不登录进不去</a>
                </div>
            </div>
            <div class="right">
                <div class="form-group">
                    <input type="text" name="username" placeholder="请输入用户名">
                </div>
                <div class="form-group">
                    <input type="password" name="password" placeholder="请输入密码">
                </div>
                <div class="form-group">
                    <input type="text" name="show" placeholder="自我介绍">
                </div>
                <div class="form-group">
                    <a href="javascript:;" id="register">注册</a>
                </div>
            </div>
        </div>
    </div>
    <!--<div class="tip-wrap">-->
        <!--<div class="tip">似懂非懂</div>-->
    <!--</div>-->
<script th:src="@{js/jquery-3.3.1.min.js}"></script>
<script th:src="@{js/index.js}"></script>
</body>
</html>

 

home.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Home</title>
    <link th:href="@{css/index.css}" rel="stylesheet" type="text/css">
</head>
<body>
<div class="container">
    <div class="header">
        <h2>初级SpringBoot+Shiro小栗子 Node-One</h2>
        <!--<h2>初级SpringBoot+Shiro小栗子 Node-Two</h2>-->
        <a href="/logout">退出登录</a>
    </div>
    <div class="main">
        <table class="table">
            <thead>
            <tr>
                <th>Username</th>
                <th>Password</th>
                <th>Show</th>
            </tr>
            </thead>
            <tbody>
            <tr th:each="u : ${users}">
                <td>[[${u.username}]]</td>
                <td>[[${u.password}]]</td>
                <td>[[${u.show}]]</td>
            </tr>
            </tbody>
        </table>
    </div>
</div>
</body>
</html>

 

以上两种配置各打包一次（记得留着打包好的jar包）

下载Nginx

 

解压到无中文目录，修改Nginx配置文件

    upstream myapp{
        server 127.0.0.1:8081 weight=1;
        server 127.0.0.1:8082 weight=1;
    }
    
    server{
            listen       80;
            server_name  myapp;
    
            location / {
                proxy_pass http://myapp;
                proxy_set_header   Host             $host;
                proxy_set_header   X-Real-IP        $remote_addr;
                proxy_set_header   X-Forwarded-For  $proxy_add_x_forwarded_for;
            }
    }

 

 

 到此，先启动两个jar包（分别是8081，Node-One；8082，Node-Two）

然后启动Nginx

浏览器访问：http://localhost/

 

刷新看看..

..

随便在一个节点上注册，登录，然后刷新到另外一个节点，发现不用登录就可以访问权限资源

 

..

 

GitHub

转载于:https://www.cnblogs.com/LUA123/p/9337963.html

weixin_34293246
关注
springboot +shiro +redis+jwt
wobenyiwusuoyou的博客
03-13 1109
项目地址：https://gitee.com/ss_1/springboot-shiro-jwt-redis
spring boot集成shiro+redis+jwt
qq_41015193的博客
03-22 1425
spring boot集成shiro+redis+jwt 集成shiro作为权限校验框架 jwt生成token redis缓冲token和用户相关得一些数据 Shiro框架简单介绍 Apache Shiro是Java的一个安全框架，旨在简化身份验证和授权。Shiro在JavaSE和JavaEE项目中都可以使用。它主要用来处理身份认证，授权，企业会话管理和加密等。 添加依赖（数据库和持久层框架根据实际情况添加） <!--redis--> <dependency&g
SpringBoot+Shiro入门小栗子
weixin_34417814的博客
07-18 99
写一个不花里胡哨的纯粹的Springboot+Shiro的入门小栗子 效果如图： 首页：有登录注册 先注册一个，然后登陆 登录，成功自动跳转到home页 home页：通过认证之后才可以进 代码部分： 依赖： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="ht...
springboot+shiro+redis+jwt实现多端登录：PC端和移动端同时在线（不同终端可同时在线）
weixin_43165220的博客
05-08 5307
前言 之前写了篇springboot+shiro+redis多端登录：单点登录+移动端和PC端同时在线的文章，但是token用的不是 jwt 而是 sessionID，虽然已经实现了区分pc端和移动端，但是还是有些问题存在的，比如：自定义的Session管理器中，生成的sessionid无法区分不同终端；还有就是登录用的是 subject.login(token) shiro帮我们自动登录，要实现的是移动端需要保持长期登录； 关于移动端保持长期登录，我想的是，另外建一张存储用户信息和token的表，登录成功
SpringBoot+shiro+redis+jwt .zip
01-03
当我们开发需要简单的鉴权功能时，springboot更快捷、简单的集成JWT，使得项目更加简洁(Compact)、自包含(Self-contained)、安全(security)；鉴权的流程为下。
springboot +shiro+redis实现session共享（方案二）1
08-08
"Spring Boot + Shiro + Redis 实现 Session 共享方案二" 1. 概述 本文档旨在介绍如何使用 Spring Boot、Shiro 和 Redis 实现分布式 session 共享，以解决 Web 应用程序的登录 session 统一问题。 2. 相关依赖 ...
基于springboot+shiro+jwt+vue+redis的后台管理系统源码.zip
01-08
1、基于springboot+shiro+jwt+vue+redis的后台管理系统源码.zip 2、该资源包括项目的全部源码，下载可以直接使用！ 3、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料...
基于springboot+mybatis+shiro+redis+vue构建的前后端分离的企业通用办公管理系统，特别适合个人学习
06-16
基于 springboot+mybatis_+shiro + redis+activiti+quarts+quartz+vue 写的一个前后分离办公企业管理系统 ，通用服务端，用于学习。 使用技术 服务端： springboot(2.2.1) + mybatis-push + shiro(1.4.0) + redis +...
Springboot+Shiro+jwt+Redis+Mybatis 有效期内Token刷新方案.zip
最新发布
02-04
本方案主要涉及Spring Boot、Apache Shiro、JSON Web Token (JWT)、Redis以及Mybatis等技术，它们共同构建了一个高效且灵活的身份验证和令牌刷新机制。下面我们将深入探讨这个方案的各个组件及其作用。 首先，...
springboot+shiro+redis整合
03-12
将SpringBoot、Shiro和Redis整合，主要目的是利用Shiro进行用户认证和授权，而Redis作为Session的共享存储，解决分布式环境下的会话一致性问题。以下是整合步骤： 1. **引入依赖**：在SpringBoot的pom.xml文件中...
SpringBoot集成Shiro、Jwt和Redis
10-24
SpringBoot集成Shiro、Jwt和Redis，使用MyBatisPlus框架实现后台数据库操作。
springboot+redis+shiro单点登录，统一异常处理，统一日志
07-10
springboot+redis+shiro单点登录，统一异常处理，统一日志,缓存
spring+shiro+redis+html后台管理系统(成品)
02-11
spring boot后台管理系统，shiro权限管理,前端html页面，有集成redis
SpringBoot+Shiro+JWT+Jedis+MybatisPlus+前后端分离+基于url通用权限管理系统
01-25
前后端分离（这里只展示后台），基于url拦截的通用权限管理系统，采用jwt+redis的机制取代传统session+cookie的认证授权方式，shiro框架，配置Jedis，以redis作缓存
Shiro + JWT + SpringBoot + MySQL + Redis(Jedis)实现无状态鉴权机制
10-17
Shiro + JWT + SpringBoot + MySQL + Redis(Jedis)实现无状态鉴权机制(Restful风格API)(改为数据库形式(MySQL)) 博客源码 附件
Shiro使用Redis作为缓存(解决Shiro频繁访问Redis)(十一)
Doge的技术小屋
11-10 1753
原文：https://blog.csdn.net/qq_34021712/article/details/80791219 之前写过一篇博客,使用的一个开源项目,实现了redis作为缓存 缓存用户的权限 和 session信息,还有两个功能没有修改,一个是用户并发登录限制,一个是用户密码错误次数.本篇中几个类 也是使用的开源项目中的类,只不过是拿出来了,redis单独做的配置,方便进行优化。 整合过程 1.首先是整合Redis Redis客户端使用的是RedisTemplate,自己写了一个序列化工具继承R
springBoot +nginx+redis 实现session共享
lihongta的博客
11-18 278
springBoot +nginx+redis 实现session共享 ...
springboot+redis+shiro+jwt实现权限管理
weixin_45059879的博客
09-20 1354
系列文章目录 文章目录系列文章目录前言一、设计思路1、用户登录2、Token验证3、资源访问二、shiro配置三、redis配置四、自定义Token五、统一日志打印和异常处理六、Vo七、其他工具类1、StringUtils2、 LocalDateTime3、获取IP4、公共资源总结 前言 一、设计思路 1、用户登录 2、Token验证 3、资源访问 二、shiro配置 三、redis配置 四、自定义Token 五、统一日志打印和异常处理 六、Vo 七、其他工具类 1、StringUtils 2、 Lo
springboot整合shiro+jwt+redis详解
zwjzone的博客
05-30 3585
springboot整合shiro+jwt+redis详解
SpringBoot+Shiro+Redis：分布式集群下session共享实现策略
在SpringBoot项目中，通过整合Shiro进行权限管理和Redis作为会话存储，可以实现跨服务器的分布式应用中的session共享。本文主要探讨的是方案二，着重介绍如何配置和使用这三个技术组件来确保登录状态的一致性。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值