websocket session共享

单机运行

用户a通过服务器进入房间room,用户b也通过房间进入room，用户之间是通过session来通话的，所以session直接存储在集合中就可以了。

因为session存储在一台服务器的集合中，所以每次发送消息的时候，直接发给房间内的所有人的session就可以了。

多机运行

假如有两台服务器，用户a通过服务器A进入了房间room,用户b通过服务器B也进入了房间room，由于session是用集合存储在各自的服务器中的，所以这种情况下，用户a发的消息只能通过服务器A,但是服务器A中是没有用户b的session的，所以当用户a发送消息的时候,用户b就收不到用户a发送的消息了。

实现共享session

利用redis的订阅发布实现

当用户a通过服务器A进入房间room,然后将用户存入redis的房间room中，用户b通过服务器B进入房间room，也将用户b存入redis的房间room中，并且都订阅房间room.将各自的session还是存储在各自的服务器中，

然后发消息的时候，发布消息到redis的room中，然后监听redis中的room房间，当有消息发送的时候，判断redis的房间中是否存在本地用户，如果存在则反推给当前服务器对应的用户。

在本机用两个tomcat配置不同的端口号模拟启动，访问测试成功，效果如下：

​

RedisConfig  这里没有配置JedisConnectionFactory,因为在application.yml中配置集群（windows集群配置参考这篇博客https://www.cnblogs.com/tommy-huang/p/6240083.html）时会自动注入连接工厂。

配置监听容器RedisMessageListenerContainer，用于监听redis发布的消息。

package com.test;/*

*/

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.serializer.*;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;

import java.util.HashSet;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<?,?> getRedisTemplate(@Autowired RedisConnectionFactory redisConnectionFactory){
      RedisTemplate redisTemplate=  new RedisTemplate<>();
      redisTemplate.setConnectionFactory(redisConnectionFactory);
      redisTemplate.setKeySerializer(new StringRedisSerializer());
      redisTemplate.setValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }

    @Bean
    public RedisMessageListenerContainer initRedisContainer(@Autowired RedisConnectionFactory redisConnectionFactory){

        RedisMessageListenerContainer container=new RedisMessageListenerContainer();
        container.setConnectionFactory(redisConnectionFactory);
        return container;
    }
}

SocketRest

实现MessageListener接口，重写onMessage方法，接收redis消息并发送。
方法container.addMessageListener(socketRest,topic); socketRest为监听者，topic为监听的房间号。

每当第一个用户进入房间后，就为该房间增加一个监听者，用来监听该房间的消息。

package com.test;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.listener.ChannelTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.Topic;
import org.springframework.stereotype.Component;

@ServerEndpoint("/websocket/{roomId}/{username}")
@Component
public class SocketRest implements MessageListener{

    //接收redis中的消息
    @Override
    public void onMessage(Message msgs, byte[] pattern) {
        try {
            //消息内容
            byte[] body=msgs.getBody();
            System.out.println("body: "+body);
            //订阅房间
            String topic=new String(pattern);
            //获取存在的房间中的用户
        String result= new String(body,"utf-8");
            System.out.println("msg: "+result);
            JSONObject js= JSON.parseObject(result);
            String username=js.getString("username");
            String msg=js.getString("msg");
            Set<Object> SessionKeys= UserSessions.keySet();
            HashMap message=new HashMap();
            message.put("msg",msg);
            message.put("username",username);
           broadcast(topic,message,username);
        }catch (Exception e){
            log.info("onMessage exception");
        }
    }

}

application.yml

server:
  port: 8088

logging:
  config: classpath:log4j2.yml
spring:
  profiles:
       active: test
---
spring:
  profiles:  test

  datasource:
        url: jdbc:mysql://localhost:3306/test
        driver-class-name: com.mysql.jdbc.Driver
        data-password: 1234
        data-username: root
  redis:
    cluster:
      nodes: 127.0.0.1:7001,127.0.0.1:7002,127.0.0.1:7003
    database: 0
    host: 127.0.0.1:7001
    port: 6379

  session:
  store-type: redis

WebsocketConfig  打包成war用外置tomcat部署时需要注释，不注释会和tomcat自带的websocket注入bean时冲突。

@Configuration
public class WebsocketConfig {

  @Bean
    public ServerEndpointExporter config(){
      return new ServerEndpointExporter();
  }

}

启动时写入房间

@Component
public class StartupRunner implements CommandLineRunner {

    @Autowired
    private RedisUtil redisUtil;

    @Override
    public void run(String... strings) throws Exception{
        if(!redisUtil.sGet("room111").isEmpty()){
            System.out.println("清空数据");
            redisUtil.del("room111");
        }
        redisUtil.sSet("rooms","room111","room222");
       Set<Object> set=redisUtil.sGet("rooms");
       for (Object o:set){
           System.out.println("------>"+o.toString());
       }

    }
}

ApplicationContextRegister   解决websocket中不能注入bean.

package com.test;/*

*/

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

@Component
public class ApplicationContextRegister implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext=applicationContext;
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }
}

RedisUtil  发布方法

增加订阅发布方法， channel订阅房间号，message发送给该房间的消息。

public  void convertAndSend(String channel ,Object message){
    redisTemplate.convertAndSend(channel,message);
}

启动类Application

package com.test;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;

@EnableAutoConfiguration
@SpringBootApplication
public class Application extends SpringBootServletInitializer {

	@Override
	protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
		return builder.sources(Application.class);
	}

	public static void main(String[] args) {
		 SpringApplication.run(Application.class, args);
	}

}

pom.xml

用tomcat部署时，如果不是默认的8080，则需要添加端口号，在server.xml中配置，增加端口以及设置编码。

<Connector port="8088" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" URIEncoding="UTF-8" />

设置项目启动路径，docBase即项目名称

<Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">
     <Context path="" docBase="whatsup" debug="0" reloadable="true" />
        <!-- SingleSignOn valve, share authentication between web applications
             Documentation at: /docs/config/valve.html -->
        <!--
        <Valve className="org.apache.catalina.authenticator.SingleSignOn" />
        -->

<!-- Access log processes all example.
             Documentation at: /docs/config/valve.html
             Note: The pattern used is equivalent to using pattern="common" -->
        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
               prefix="localhost_access_log" suffix=".txt"
               pattern="%h %l %u %t &quot;%r&quot; %s %b" />

</Host>

log4j.yml

Appenders:
    Console:  #输出到控制台
      name: CONSOLE #Appender命名
      target: SYSTEM_OUT
      PatternLayout:
        pattern: "%d{yyyy-MM-dd HH:mm:ss,SSS}:%4p %t (%F:%L) - %m%n"
    RollingFile: # 输出到文件，超过256MB归档
      - name: ROLLING_FILE
        ignoreExceptions: false
        fileName: springboot.log
        filePattern: "/springboot/logs/$${date:yyyy-MM}/springboot -%d{yyyy-MM-dd}-%i.log.gz"
        PatternLayout:
          pattern: "%d{yyyy-MM-dd HH:mm:ss,SSS}:%4p %t (%F:%L) - %m%n"
        Policies:
          SizeBasedTriggeringPolicy:
            size: "256 MB"
        DefaultRolloverStrategy:
          max: 1000
Loggers:
    Root:
      level: info
      AppenderRef:
        - ref: CONSOLE
    Logger: #单独设置某些包的输出级别
      - name: app.com.kenho.mapper #复数加上-
        additivity: false #去除重复的log
        level: trace
        AppenderRef:
          - ref: CONSOLE #复数加上-
          - ref: ROLLING_FILE #复数加上-