nginx+redis+springboot实现session共享的服务集群

最新推荐文章于 2024-04-18 04:34:57 发布

御前两把刀刀

最新推荐文章于 2024-04-18 04:34:57 发布

阅读量510

点赞数 1

分类专栏： spring boot 文章标签： nginx redis springboot session共享

本文链接：https://blog.csdn.net/wx5040257/article/details/114264967

版权

spring boot 专栏收录该内容

17 篇文章 1 订阅

订阅专栏

一问题提出

随着我们部署的应用的用户量的增大，单个应用服务器支持并发数有限，而且当单个应用崩溃之后，服务也随之崩溃了，导致系统不够安全。为了解决这样的问题，我们可以同时启动多个应用服务，然后用nginx反向代理的方式，把请求根据情况转发到不同的应用服务器，可以均分的方式转发请求，也可以设置权重。这样就解决了应用的高可用问题，也解决了高并发的问题。但是，每个应用服务生成的session不同，导致了session追踪(会话跟踪)成为一个难题，这时候可以单独用redis存储session，实现session共享来解决这个问题。

二实验环境

jdk1.8，springboot:2.1.12, nginx:1.19.5,redis:4.0.14,centos:7.5.1804

三拓扑图

四环境搭建

1. 请在192.168.68.128服务器上安装nginx ，这里不详述，如何安装请参考我的博文【https://blog.csdn.net/wx5040257/article/details/81274601】

2. 请在192.168.68.129服务器上安装redis, 这里不详述，如何安装请参考我的博文【https://blog.csdn.net/wx5040257/article/details/78347729】

五 springboot项目整合redis并实现session共享关键代码

1. pom文件的关键依赖

        <!-- 添加redis依赖 -->
        <dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>

	    <!--  session 通过redis共享新增的依赖 --> 
        <dependency>
			<groupId>org.springframework.session</groupId>
			<artifactId>spring-session-data-redis</artifactId>
		</dependency>

2. 启动类上添加注解EnableRedisHttpSession,如下:

@ServletComponentScan
@MapperScan({"com.xxx.*.dao","com.xxx.*.*.dao"})
@EnableCaching
//在设置的基础上，源代码里面还自动加了5分钟(300秒)
@EnableRedisHttpSession(maxInactiveIntervalInSeconds= 300)
@SpringBootApplication
public class RedisDemoApplication{
	
	private static final Logger logger = LoggerFactory.getLogger(RedisDemoApplication.class);
	
	
    public static void main(String[] args) throws ParseException {
      SpringApplication.run(RedisDemoApplication.class, args);
      System.out.println("系统启动成功!");
    }
}

通过EnableRedisHttpSession注解实现应用程序session对象存入到了redis服务器 ,接下来的问题就是如何在用到session里面的值的地方取到对应的存在redis里面的session。

3. application.yml中的redis配置

  # redis 配置 
  redis:
    # Redis数据库索引（默认为0）
    database: 0  
    # Redis服务器地址
    host: 192.168.68.129
    # Redis服务器连接端口
    port: 6379  
    # Redis服务器连接密码（默认为空）
    password: '******'
    # 连接超时时间（毫秒）
    timeout: 30000

4. redis服务类接口及redis服务类

RedisObjectService:


import java.util.List;

import javax.servlet.http.HttpServletRequest;


/**
 * Description: redis存取对象的服务类接口,字符串存取直接调用springboot提供的StringRedisTemplate即可
 * Author: wangxiang
 * Version: 1.0
 * Create Date Time: 2020年2月13日 13:26
 * Update Date Time: 2020年2月13日 13:26
*/
public interface RedisObjectService {
	
	<T> boolean set(String key, T value);
	
	<T> T get(String key, Class<T> clazz);
	
	//list对象存
	<T> boolean setList(String key, List<T> value);
			
	//list对象取
    <T> List<T> getList(String key, Class<T> clazz);
    
    /**
     * 获取redis存的session里面的属性值
     * @param request
     * @param sessinAttr
     * @return 共享session里面的属性值
     */
    String getSessionAttr(HttpServletRequest request,String sessinAttr);
}

RedisObjectServiceImpl:


import java.util.*;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

/**
 * Description: redis存取对象的服务类,字符串存取直接调用springboot提供的StringRedisTemplate即可
 * Author: wangxiang
 * Version: 1.0
 * Create Date Time: 2020年2月13日 13:26
 * Update Date Time: 2020年2月13日 13:26
*/
@Service
public class RedisObjectServiceImpl implements RedisObjectService{
	@Autowired
	private StringRedisTemplate stringRedisTemplate;
	
	@Autowired
	private RedisTemplate redisSessionTemplate;

	//bean 对象存
	public <T> boolean set(String key, T value) {
		try {
			// 任意类型转换成String
			String val = beanToString(value);
			if (val == null || val.length() <= 0) {
				return false;
			}
			stringRedisTemplate.opsForValue().set(key, val);
			return true;
		} catch (Exception e) {
			throw new RuntimeException("redis连接失败，请检查服务是否启动,地址、用户名、密码是否正确!");
		}
	}
	
	/**
     * 获取redis存的session里面的属性值
     * @param request
     * @param sessinAttr
     * @return 共享session里面的属性值
     */
	public String getSessionAttr(HttpServletRequest request,String sessinAttr){
		String token=request.getHeader("token");
    	if(token == null || token.equals("undefined") ||token.equals("") || token.split(",")==null){
    		throw new RuntimeException("请重新登录");
    	}
		String[] tokenArr=token.split(",");
		String sessionId=tokenArr[0];
		String sessionKey ="spring:session:sessions:" + sessionId;
		String attr=(String)redisSessionTemplate.opsForHash().get(sessionKey, "sessionAttr:"+sessinAttr);
		return attr;
	}
	
	//bean 对象取
	public <T> T get(String key, Class<T> clazz) {
		try {
			String value = stringRedisTemplate.opsForValue().get(key);
			return stringToBean(value, clazz);
		} catch (Exception e) {
			System.out.println(e.getMessage());
			throw new RuntimeException("redis连接失败，请检查服务是否启动,地址、用户名、密码是否正确!");
		}
	}

	//list对象存
	public <T> boolean setList(String key, List<T> value) {
		try {
			stringRedisTemplate.opsForValue().set(key, JSONObject.toJSONString(value));
			return true;
		} catch (Exception e) {
			throw new RuntimeException("redis连接失败，请检查服务是否启动,地址、用户名、密码是否正确!");
		}
	}
		
	//list对象取
	public <T> List<T> getList(String key, Class<T> clazz) {
		try {
			String value = stringRedisTemplate.opsForValue().get(key);
			List<T> theList = JSONArray.parseArray(value, clazz);
			return theList;
		} catch (Exception e) {
			throw new RuntimeException("redis连接失败，请检查服务是否启动,地址、用户名、密码是否正确!");
		}
	}
		
	@SuppressWarnings("unchecked")
	private <T> T stringToBean(String value, Class<T> clazz) {
		if (value == null || value.length() <= 0 || clazz == null) {
			return null;
		}
		if (clazz == int.class || clazz == Integer.class) {
			return (T) Integer.valueOf(value);
		} else if (clazz == long.class || clazz == Long.class) {
			return (T) Long.valueOf(value);
		} else if (clazz == String.class) {
			return (T) value;
		} else {
			return JSON.toJavaObject(JSON.parseObject(value), clazz);
		}
	}

	/**
	 *
	 * @param Every
	 *            T values
	 * @param T
	 *            任意类型
	 * @return String
	 */
	private <T> String beanToString(T value) {

		if (value == null) {
			return null;
		}
		Class<?> clazz = value.getClass();
		if (clazz == int.class || clazz == Integer.class) {
			return "" + value;
		} else if (clazz == long.class || clazz == Long.class) {
			return "" + value;
		} else if (clazz == String.class) {
			return (String) value;
		} else {
			return JSON.toJSONString(value);
		}
	}

	
}

5. 登录与前端约定一个token码，这里用session+时间戳组成

@Log("用户账号登录")
	@RequestMapping("/login.do")
	public ApiResultVO login(HttpServletRequest request, HttpServletResponse response) throws Exception {
		// 登录的时候要把token码返给前台,目前token码是sessionid和时间戳的组合
		String token = session.getId() +","+ new Date().getTime();
        ....
}

把token码返给前端，登录完成后，以后要求前端发起的请求都通过header传递此token码。再就是取session对象中的值

如何在需要的地方获取session中的值，如下：

@RestController
@RequestMapping("/znzr/flow/loosecloth")
@SuppressWarnings("unchecked")
public class LooseClothController {

	private static Logger logger = (Logger) LoggerFactory.getLogger(LooseClothController.class);
	@Autowired
	private HttpServletRequest request;
	
	@Autowired
	private RedisObjectService redisService;
	
	
	
	/**
	 * 机头机尾任务列表查询
	 * @param id 指令编号
	 * @return 返回统一json数据
	 */
	@RequestMapping("/queryLooseTask.do")
	public ApiResultVO queryLooseTask(){
		try {
			String userId=redisService.getSessionAttr(request, "userId");
			
			return  ApiResultVO.putDate(DataVO.success().putValue(resultMap));
		} catch (Exception e) {
			logger.error(e.getMessage(), e);
			return ApiResultVO.putDate(DataVO.fail(e.getMessage()));
		}
	}
}

注意里面的代码 String userId=redisService.getSessionAttr(request, "userId"); 调用的方法在RedisObjectServiceImpl里面有。

这就完成了从redis里面获取session中的值。

六 nginx中的反向代理配置

http {
    include       mime.types;
    default_type  application/octet-stream;

    sendfile        on;

    keepalive_timeout  65;
    underscores_in_headers on;
    #gzip  on;

    #配置服务集群
    upstream wx.com {
      #ip_hash
      server 192.168.68.1:8080 weight=1;
      server 192.168.68.129:8081 weight=1;
    }

    server {
        listen       911;
        server_name  localhost;
        underscores_in_headers on;
        #charset koi8-r;
        
      
        location / {
	   proxy_pass_request_headers on;

	   #指定反向代理的服务集群,注意wx.com是集群名称，要和upstream中的wx.com一致
	   
	   proxy_pass http://wx.com;
	   proxy_set_header Host $host;
	   proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
           proxy_set_header X-Real-IP $remote_addr;
           proxy_set_header Request-Url $request_uri;
	}

        
    }


}

七启动

请分别以端口8080，8081把应用打包部署到192.168.68.1和192.168.68.129 并启动

御前两把刀刀

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
3
评论
nginx+redis+springboot实现session共享的服务集群

一问题提出随着我们部署的应用的用户量的增大，单个应用服务器支持并发数有限，而且当单个应用崩溃之后，服务也随之崩溃了，导致系统不够安全。为了解决这样的问题，我们可以同时启动多个应用服务，然后用nginx反向代理的方式，把请求根据情况转发到不同的应用服务器，可以均分的方式转发请求，也可以设置权重。这样就解决了应用的高可用问题，也解决了高并发的问题。但是，每个应用服务生成的session不同，导致了session追踪(会话跟踪)成为一个难题，这时候可以单独用redis存储session，实现ses...
复制链接

扫一扫