webSocket有些乱，整理一下：

webSocket是用来解决B/S模式中长连接的问题，实现浏览器和服务器间的消息推送和接收。浏览器先发送http报文，借用了http协议来完成一部分握手，这个http报文中有这么一段信息"Upgrade:websocket"，这是告诉服务器"你好，我要切换协议"。服务器接收后，回复一个http报文，告诉浏览器"好的，我已经切换到websocket协议了"。从这里以后就不用http报文了，接下来就完全按照websocket协议进行了。

1.实时通讯的方式
1.1 Ajax轮询
异步的方式，是通过ajax+js的方式，每隔一段时间发送一个请求到后端，询问服务器有没有相关的消息或者是数据的更新，如果有就把数据拿到前端进行渲染。但是这种方式是一种死循环，会一直循环下去。ajax是不需要刷新浏览器的，页面上的一些状态更新的操作就需要使用ajax轮询去做。
1.2 Long pull
Long pull的原理和Ajax轮询的方式是差不多的，但是不同的是Long pull是一种阻塞的方式。性能差

这两种方式其实都是向服务器发送请求等待处理，都是被动的。这两种方式的性能都是不怎么好的。
1.3 Websocket
websocket是一种连接协议，是一种长连接，http1.0是一种短连接。服务端和客户端会一直保持着连接。并且服务端会主动的推送消息给客户端。websocket是一种实时化的协议，Http的一个周期是request来界定。也就是说有一个请求发送到服务端，服务端就会做出响应。一个request对应一个response。多个request对应的是多个response。数量是一一对应的。

websocket连接建立之后，服务端就会一直不停的向客户端发送请求。主动的推送消息给客户端。只需要建立一次请求，就会源源不断的推送想要的数据给客户端。除非自己断开连接重新连接。
2.websock连接的过程
首先写一个小demo

（1）先在html界面上构建一个骨架，用于展示发送消息和接收消息的内容。
 <div>发送消息：</div>
 <input type="text" id="msgContent"/>
 <input type="button" value="点击发送" onclick="CHAT.chat()"/>
 <div>接收消息:</div>
 <div id="receiveMsg" style="background-color: gainsboro;"></div>

（2）开始编写建立websocket连接的过程

首先定义一个CHAT对象
window.CHAT = {
	soctet: null,
	init:function() {            //初始化的方法
		//判断当前浏览器是否支持websocket
		if(window.WebSocket) {
			// 进行初始化操作
			CHAT.socket = new WebSocket('ws://localhost:8080/ws');     //创建一个新的WebSocket
			//定义CHAT生命周期函数
			CHAT.socket.onopen = function() {
				console.log('客户端和服务端的连接建立成功');
			}
			CHAT.socket.onmessage = function() {
				 console.log('接收到的消息' + e.data); 
				 var receiveMsg = document.getElementById('receiveMsg');
				 var html = receiveMsg.innerHTML;
				 receiveMsg.innerHTML = html + "<br />" + e.data;
			}
			CHAT.socket.onclose = function() {
				console.log('消息关闭.....');
			}
			CHAT.socket.onerror = function() {
					console.log('消息发生错误');
			}
		}else {
			alert('当前浏览器不支持websocket协议');
		}
	}，
	chat:function() {
		var msg =  document.getElementById("msgContent");
		CHAT.socket.send(msg.value);
	}
}

首先，websocket属于应用层协议，和 http 一样也是基于 TCP/IP 协议。websocket 连接的建立需要借助 http，连接建立完之后就与 http 无关了。

过程

Connection:Connection必须设置为Upgrade，表示客户端希望连接升级

Upgrade:Upgrade必须设置为WebSocket，表示在取得服务器响应之后，使用HTTP升级将HTTP协议转换(升级)为WebSocket协议。

Sec-WebSocket-key:随机字符串，用于验证协议是否为WebSocket协议而非HTTP协议

Sec-WebSocket-Version:表示使用WebSocket的哪一个版本。

Sec-WebSocket-Accept:根据Sec-WebSocket-Accept和特殊字符串计算。验证协议是否为WebSocket协议。

Sec-WebSocket-Location:与Host字段对应，表示请求WebSocket协议的地址。

HTTP/1.1 101 Switching Protocols:101状态码表示升级协议，在返回101状态码后，HTTP协议完成工作，转换为WebSocket协议。此时就可以进行全双工双向通信了。

上一篇讲到 soul 是如何使用 websocket 进行数据同步的，今天来分析下，websocket 连接是什么时候建立的。
上一篇也讲到，启动 soul-admin 时，因为 yml 配置了使用 websocket 进行同步，会加载这三个类，WebsocketCollector 这个类就是开启一个 websocket 服务。

soul-bootstrap 的 pom 文件引入了这个 starter。
<!--soul data sync start use websocket-->
<dependency>
    <groupId>org.dromara</groupId>
    <artifactId>soul-spring-boot-starter-sync-data-websocket</artifactId>
    <version>${project.version}</version>
</dependency>

启动 soul-bootstrap 时，就会去寻找 soul-spring-boot-starter-sync-data-websocket 包 resources/META-INF/spring.factories 文件，然后根据文件中配置去加载指定模块。
//spring.factories 文件内容
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.dromara.soul.spring.boot.starter.sync.data.websocket.WebsocketSyncDataConfiguration

这个文件配置的就是 WebsocketSyncDataConfiguration 类。

看到这个类的代码，我先去查了下 ObjectProvider 相关知识。
在 spring4.3 之前，我们需要在一个类 A 里注入另一个类 B 时，会使用 @Autowired 注解，不加程序会报异常。4.3 后，引入了一个新特性，我们只需要在类 A 加一个构造函数，B 作为构造函数的参数传进来，就可以不加  @Autowired，但 B 必须要在 spring 容器中，否则会出现异常，此时我们就需要 引入 ObjectProvider。
//4.3 之前
@Service
public class A {
    private final B b;
    @Autowired
    public A (B b) {
        this.b = b
    }
}
//4.3 之后，不需要加 @Autowired 注解，但如果 B 不在 spring 容器，会报异常
@Service
public class A {
    private final B b;
    public A (B b) {
        this.b = b
    }
}
//引入 ObjectProvider
@Service
public class A {
    private final B b;
    public A(ObjectProvider<B> bProvider) {
    	//如果不可用或不唯一（没有指定primary）则返回null。否则，返回对象。
        this.b = bProvider.getIfUnique();
    }
}

在下面这个类里，使用的是ObjectProvider 的 getIfAvailable(Supplier<T> defaultSupplier) 方法，这个方法是说 如果对象存在直接返回，对象不存在，就进行回调，回调对象由 defaultSupplier 提供。
@Configuration
@ConditionalOnClass(WebsocketSyncDataService.class)
@ConditionalOnProperty(prefix = "soul.sync.websocket", name = "urls")
@Slf4j
public class WebsocketSyncDataConfiguration {

    /**
     * Websocket sync data service.
     */
    @Bean
    public SyncDataService websocketSyncDataService(final ObjectProvider<WebsocketConfig> websocketConfig, final ObjectProvider<PluginDataSubscriber> pluginSubscriber,
                                           final ObjectProvider<List<MetaDataSubscriber>> metaSubscribers, final ObjectProvider<List<AuthDataSubscriber>> authSubscribers) {
        log.info("you use websocket sync soul data.......");
        return new WebsocketSyncDataService(websocketConfig.getIfAvailable(WebsocketConfig::new), pluginSubscriber.getIfAvailable(),
                metaSubscribers.getIfAvailable(Collections::emptyList), authSubscribers.getIfAvailable(Collections::emptyList));
    }

    /**
     * Config websocket config.
     *
     * @return the websocket config
     */
    @Bean
    @ConfigurationProperties(prefix = "soul.sync.websocket")
    public WebsocketConfig websocketConfig() {
        return new WebsocketConfig();
    }
}

WebsocketSyncDataConfiguration 这个类的加载依赖于  soul.sync.websocket，而我们在 soul-bootstrap 配置如下，所以会加载这个类。

可以看到这个类创建了一个  WebsocketSyncDataService 对象，就是在这个 service，创建了一个 webSocket 客户端，和我们在 soul-admin 创建的 websocket 服务建立了连接，这里还有一个线程池 ScheduledThreadPoolExecutor，如果客户端连接关闭，会定时尝试重新连接。
    public WebsocketSyncDataService(final WebsocketConfig websocketConfig,
                                    final PluginDataSubscriber pluginDataSubscriber,
                                    final List<MetaDataSubscriber> metaDataSubscribers,
                                    final List<AuthDataSubscriber> authDataSubscribers) {
        String[] urls = StringUtils.split(websocketConfig.getUrls(), ",");
        executor = new ScheduledThreadPoolExecutor(urls.length, SoulThreadFactory.create("websocket-connect", true));
        for (String url : urls) {
            try {
                clients.add(new SoulWebsocketClient(new URI(url), Objects.requireNonNull(pluginDataSubscriber), metaDataSubscribers, authDataSubscribers));
            } catch (URISyntaxException e) {
                log.error("websocket url({}) is error", url, e);
            }
        }
        try {
            for (WebSocketClient client : clients) {
                boolean success = client.connectBlocking(3000, TimeUnit.MILLISECONDS);
                if (success) {
                    log.info("websocket connection is successful.....");
                } else {
                    log.error("websocket connection is error.....");
                }
                executor.scheduleAtFixedRate(() -> {
                    try {
                        if (client.isClosed()) {
                            boolean reconnectSuccess = client.reconnectBlocking();
                            if (reconnectSuccess) {
                                log.info("websocket reconnect is successful.....");
                            } else {
                                log.error("websocket reconnection is error.....");
                            }
                        }
                    } catch (InterruptedException e) {
                        log.error("websocket connect is error :{}", e.getMessage());
                    }
                }, 10, 30, TimeUnit.SECONDS);
            }
            /* client.setProxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxyaddress", 80)));*/
        } catch (InterruptedException e) {
            log.info("websocket connection...exception....", e);
        }

    }

因此 soul-admin，soul-bootstrap 项目启动完成，websocket 连接也建立成功了，接下来有数据变动，soul-admin 服务端就会向客户端发送消息，数据就及时的同步到内存中。
参考资料
spring ObjectProvider 源码分析