https://www.jianshu.com/p/58f05bf13b7d —前后端分离中的无痛刷新token机制
 https://www.cnblogs.com/youzhibing/p/7348337.html —spring-session实现分布式集群session的共享
 https://blog.csdn.net/qq_41717874/article/details/85165401 —JavaWeb的session及其共享技术

分布式session之token解决方案实现
 
基于令牌（Token）方式实现Session解决方案，因为Session本身就是分布式共享连接
 
用token代替session
 
废话不多说，看项目：
 
 
pom.xml
 
<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.toov5.tokenSession</groupId>
  <artifactId>tokenSession</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  <parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.0.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<properties>
		<weixin-java-mp.version>2.8.0</weixin-java-mp.version>
		<maven.compiler.source>1.8</maven.compiler.source>
		<maven.compiler.target>1.8</maven.compiler.target>
		<maven.compiler.encoding>UTF-8</maven.compiler.encoding>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.build.locales>zh_CN</project.build.locales>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
			<!-- <exclusions> <exclusion> <groupId>com.fasterxml.jackson.core</groupId> 
				<artifactId>jackson-databind</artifactId> </exclusion> </exclusions> -->
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.47</version>
		</dependency>
		<!-- Testing Dependencies -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<!--spring session 与redis应用基本环境配置,需要开启redis后才可以使用，不然启动Spring boot会报错 -->
           <dependency>
			<groupId>org.springframework.session</groupId>
			<artifactId>spring-session-data-redis</artifactId>
		</dependency> 
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-pool2</artifactId>
		</dependency>
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
		</dependency>

	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<maimClass>com.meiteedu.WxMpApplication</maimClass>
				</configuration>
				<executions>
					<execution>
						<goals>
							<goal>repackage</goal>
						</goals>
					</execution>
				</executions>

			</plugin>
		</plugins>
	</build>
</project>
 
　yml
 
server:
  port: 8081
spring:
  redis:
    database: 0   
    host:  192.168.91.3
    port:  6379
    password:  123
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0
    timeout: 10000
redis:
  hostname: 192.168.91.3     
  port:  6379
  password:  123
 
　　redis
 
package com.toov5.service;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class RedisService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    //这样该方法支持多种数据类 
    public void set(String key , Object object, Long time){
        if (object instanceof String ) {  //判断下是String类型�?
            String argString =(String)object;  //强转�?
            //存放String类型
            stringRedisTemplate.opsForValue().set(key, argString);
        }
        //如果存放Set类型
        if (object instanceof Set) {
            Set<String> valueSet =(Set<String>)object;
            for(String string:valueSet){
                stringRedisTemplate.opsForSet().add(key, string);  //此处点击下源码看 第二个参数可以放好多
            }
        }
        //设置有效�
        if (time != null) {
            stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
        
    }
    //做个封装
    public void setString(String key, Object object){
        String argString =(String)object;  //强转
        //存放String类型
        stringRedisTemplate.opsForValue().set(key, argString);
    }
    public void setSet(String key, Object object){
        Set<String> valueSet =(Set<String>)object;
        for(String string:valueSet){
            stringRedisTemplate.opsForSet().add(key, string);  //此处点击下源码看 第二个参数可以放好多
        }
    }
    
    public String getString(String key){
     return    stringRedisTemplate.opsForValue().get(key);
    }
    
    
}
 
token的封装
 
package com.toov5.service;

import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import ch.qos.logback.core.subst.Token;

@Service
public class TokenService {
     @Autowired
    private RedisService redisService;
    
    
    // 1 使用token方式替代session功能
    //存入和获取
    public  String put(Object value){
        //判断您是否为空
        if (value == null) {
            return null;
        }
        // 先生成对应的token（token 实际上等于key）
        String token = getToken();
        //存入在redis中
        redisService.setString(token, value);
        //直接返回对应的token
        
        return token;
    }
    
    public String get(String token){
      return redisService.getString(token);        
    }
    

  public String getToken(){
      return UUID.randomUUID().toString();
  }
    
}
 
controller
 
package com.toov5.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.toov5.service.TokenService;

@RestController
public class TestTokenController {

    @Autowired
    private TokenService tokenService;
    
    //使用token方式替代session     sessiong服务器端创session 返回sessionid
    @RequestMapping("/put")
    public String put(String value){
         String string = tokenService.put(value);
         System.out.println(string);
        return string;
    }
    //生成好的token如何存放？ 移动端存放本地文件  浏览器cookie
    
    
    @RequestMapping("/get")
    public String get(String object){
        return tokenService.get(object);
    }
    
    //http如何传递？ 放在请求头里面  最好建议请求头里面
    
    
    
     
}
 
运行访问
 
 
怎么刷新都能获取到哦
 
 
 
 
redis 在服务器集群的时候 分布式缓存可以共享
 
 

 
移动互联网的繁荣，出现很多客户端，不同于以往的浏览器，有的终端是不支持cookie的，传统浏览器cookie的模式不太适用。
 
用户数量的增多，传统的服务端存储session的方式，面对负载均衡多服务器的部署方式，不好解决用户登录的问题。
 
面对这两个问题，出现了token的验证方式，下面均益数一下三者的区别和问题，以及解决方案。
 
cookie:
 
cookie是存在浏览器的标识用户的方式，由服务端为每一个用户签发不同session id发给浏览器存储在cookie，下次访问会带上这个session id，服务端就知道这个访问是哪个用户了。
 
cookie面临的问题：
 
CSRF(跨站请求伪造)攻击，这个也好解决，很多框架都屏蔽这个问题
 
有的客户端不支持cookie，需要手动设置，比如小程序
 
浏览器对cookie有限制，不能手动设置cookie，对于混合嵌套的开发有问题，比如小程序跳转H5页面，不能携带cookie
 
浏览器对单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie
 
sesssion
 
session(会话)，是存储在服务端标识用户的方式，服务端为每个用户生成不同的session id，还有与之相对应的信息，比如用户id和登录时间等。在php中，就是存储在超全局变量$_SESSION。通过服务端的session和浏览器的cookie一一对应，来区分这个用户是谁。
 
session面临的问题：
 
负载均衡多服务器的情况，不好确认当前用户是否登录，因为多服务器不共享seesion。这个问题也可以将session存在一个服务器中来解决，但是就不能完全达到负载均衡的效果。
 
每个客户端只需存储自己的session id，但是服务端却需要存储所有用户session id，对服务器也是一个压力
 
token
 
token的意思是“令牌”，是用户身份的验证方式，最简单的token组成：sign(签名，经过加密后的数据)，相当于上文提到的session id。token可以放在header、url中，在每次网络访问都携带，一般是写请求头header中。相比于cookie，你可以认为只是存储的地方参数不同而已。token相比于cookie就是有cookie的功能，没有cookie的限制。比如其他客户端不会限制header的cookie。token是cookie很好替代品。
 
解决方案
 
针对上面提到问题，人们想到的办法是用token代替cookie和seesion。一个token怎么替代两个的呢？
 
服务端把用户信息加密(token)传给客户端，客户端每次访问都返回token，服务端解密token，就知道这个用户是谁了。通过cpu加解密，服务端就不需要存储session id占用存储空间，就很好的解决负载均衡多服务器的问题了。这个方法叫jwt(json web token的缩写)，各个语言的实现方式在这个网站上有https://jwt.io/
 
使用jwt有一个问题，就是不像cookie和session有自动过期的设置，这个token的状态和过期时间需要自己手动设置。比如说，token中存储用户登录的时间，服务端每次验证这个时间是否过期就可以了。

 
 
 
  一、session的状态保持及弊端 
 

二、token认证机制
 

一、session的状态保持及弊端
 
当用户第一次通过浏览器使用用户名和密码访问服务器时，服务器会验证用户数据，验证成功后在服务器端写入session数据，向客户端浏览器返回sessionid，浏览器将sessionid保存在cookie中，当用户再次访问服务器时，会携带sessionid，服务器会拿着sessionid从数据库获取session数据，然后进行用户信息查询，查询到，就会将查询到的用户信息返回，从而实现状态保持。
 
 
弊端：
 
1、服务器压力增大
 
通常session是存储在内存中的，每个用户通过认证之后都会将session数据保存在服务器的内存中，而当用户量增大时，服务器的压力增大。
 
2、CSRF跨站伪造请求攻击
 
session是基于cookie进行用户识别的, cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。
 
3、扩展性不强
 
如果将来搭建了多个服务器，虽然每个服务器都执行的是同样的业务逻辑，但是session数据是保存在内存中的（不是共享的），用户第一次访问的是服务器1，当用户再次请求时可能访问的是另外一台服务器2，服务器2获取不到session信息，就判定用户没有登陆过。
 
二、token认证机制
 
token与session的不同主要在①认证成功后，会对当前用户数据进行加密，生成一个加密字符串token，返还给客户端（服务器端并不进行保存）
 
②浏览器会将接收到的token值存储在Local Storage中，（通过js代码写入Local Storage，通过js获取，并不会像cookie一样自动携带）
 
③再次访问时服务器端对token值的处理：服务器对浏览器传来的token值进行解密，解密完成后进行用户数据的查询，如果查询成功，则通过认证，实现状态保持，所以，即时有了多台服务器，服务器也只是做了token的解密和用户数据的查询，它不需要在服务端去保留用户的认证信息或者会话信息，这就意味着基于token认证机制的应用不需要去考虑用户在哪一台服务器登录了，这就为应用的扩展提供了便利，解决了session扩展性的弊端。