精华内容
下载资源
问答
  • 服务端通知客户端缓存静态页面资源,这样加快页面的加载。 .没加缓解前效果: 在application.properties配置,让服务器告诉客服端静态页面资源要缓存 其中,resources.cache-period是缓存时间,3600秒。 ...

    服务端通知客户端缓存静态页面资源,这样加快页面的加载。

    .没加缓解前效果:

     

     

    在application.properties配置,让服务器告诉客服端静态页面资源要缓存

    其中,resources.cache-period是缓存时间,3600秒。

    spring.resources.add-mappings=true
    spring.resources.cache-period= 3600
    spring.resources.chain.cache=true
    spring.resources.chain.enabled=true
    spring.resources.chain.gzipped=true
    spring.resources.chain.html-application-cache=true
    spring.resources.static-locations=classpath:/static/

     

     

     

    只火狐浏览器可见,“已缓存”效果。

    展开全文
  • springboot+websocket实现服务端客户端

    万次阅读 多人点赞 2019-01-12 12:54:43
    一、引言 小编最近一直在使用springboot框架...websocket主要功能就是实现网络通讯,比如说最经典的客服聊天窗口、您有新的消息通知,或者是项目与项目之间的通讯,都可以采用websocket来实现。 二、websocket介...

     

    一、引言

    小编最近一直在使用springboot框架开发项目,毕竟现在很多公司都在采用此框架,之后小编也会陆续写关于springboot开发常用功能的文章。 

    什么场景下会要使用到websocket的呢?

    websocket主要功能就是实现网络通讯,比如说最经典的客服聊天窗口、您有新的消息通知,或者是项目与项目之间的通讯,都可以采用websocket来实现。

    二、websocket介绍

    百度百科介绍:WebSokcet

    在公司实际使用websocket开发,一般来都是这样的架构,首先websocket服务端是一个单独的项目,其他需要通讯的项目都是以客户端来连接,由服务端控制消息的发送方式(群发、指定发送)。 但是也会有服务端、客户端在同一个项目当中,具体看项目怎么使用。

    本文呢,采用的是服务端与客户端分离来实现,包括使用springboot搭建websokcet服务端、html5客户端、springboot后台客户端, 具体看下面代码。

    三、服务端实现

    步骤一: springboot底层帮我们自动配置了websokcet,引入maven依赖

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
    </dependency>

    步骤二:如果是你采用springboot内置容器启动项目的,则需要配置一个Bean。如果是采用外部的容器,则可以不需要配置。

    /**
     * @Auther: liaoshiyao
     * @Date: 2019/1/11 11:49
     * @Description: 配置类
     */
    @Component
    public class WebSocketConfig {
    
        /**
         * ServerEndpointExporter 作用
         *
         * 这个Bean会自动注册使用@ServerEndpoint注解声明的websocket endpoint
         *
         * @return
         */
        @Bean
        public ServerEndpointExporter serverEndpointExporter() {
            return new ServerEndpointExporter();
        }
    }
    

    步骤三:最后一步当然是编写服务端核心代码了,其实小编不是特别想贴代码出来,贴很多代码影响文章可读性。

    package com.example.socket.code;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Component;
    
    import javax.websocket.OnClose;
    import javax.websocket.OnMessage;
    import javax.websocket.OnOpen;
    import javax.websocket.Session;
    import javax.websocket.server.PathParam;
    import javax.websocket.server.ServerEndpoint;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * @Auther: liaoshiyao
     * @Date: 2019/1/11 11:48
     * @Description: websocket 服务类
     */
    
    /**
     *
     * @ServerEndpoint 这个注解有什么作用?
     *
     * 这个注解用于标识作用在类上,它的主要功能是把当前类标识成一个WebSocket的服务端
     * 注解的值用户客户端连接访问的URL地址
     *
     */
    
    @Slf4j
    @Component
    @ServerEndpoint("/websocket/{name}")
    public class WebSocket {
    
        /**
         *  与某个客户端的连接对话,需要通过它来给客户端发送消息
         */
        private Session session;
    
         /**
         * 标识当前连接客户端的用户名
         */
        private String name;
    
        /**
         *  用于存所有的连接服务的客户端,这个对象存储是安全的
         */
        private static ConcurrentHashMap<String,WebSocket> webSocketSet = new ConcurrentHashMap<>();
    
    
        @OnOpen
        public void OnOpen(Session session, @PathParam(value = "name") String name){
            this.session = session;
            this.name = name;
            // name是用来表示唯一客户端,如果需要指定发送,需要指定发送通过name来区分
            webSocketSet.put(name,this);
            log.info("[WebSocket] 连接成功,当前连接人数为:={}",webSocketSet.size());
        }
    
    
        @OnClose
        public void OnClose(){
            webSocketSet.remove(this.name);
            log.info("[WebSocket] 退出成功,当前连接人数为:={}",webSocketSet.size());
        }
    
        @OnMessage
        public void OnMessage(String message){
            log.info("[WebSocket] 收到消息:{}",message);
            //判断是否需要指定发送,具体规则自定义
            if(message.indexOf("TOUSER") == 0){
                String name = message.substring(message.indexOf("TOUSER")+6,message.indexOf(";"));
                AppointSending(name,message.substring(message.indexOf(";")+1,message.length()));
            }else{
                GroupSending(message);
            }
    
        }
    
        /**
         * 群发
         * @param message
         */
        public void GroupSending(String message){
            for (String name : webSocketSet.keySet()){
                try {
                    webSocketSet.get(name).session.getBasicRemote().sendText(message);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 指定发送
         * @param name
         * @param message
         */
        public void AppointSending(String name,String message){
            try {
                webSocketSet.get(name).session.getBasicRemote().sendText(message);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    

    四、客户端实现

    HTML5实现:以下就是核心代码了,其实其他博客有很多,小编就不多说了。

     var websocket = null;
        if('WebSocket' in window){
            websocket = new WebSocket("ws://192.168.2.107:8085/websocket/testname");
        }
    
        websocket.onopen = function(){
            console.log("连接成功");
        }
    
        websocket.onclose = function(){
            console.log("退出连接");
        }
    
        websocket.onmessage = function (event){
            console.log("收到消息"+event.data);
        }
    
        websocket.onerror = function(){
            console.log("连接出错");
        }
    
        window.onbeforeunload = function () {
            websocket.close(num);
        }
        

    SpringBoot后台实现:小编发现多数博客都是采用js来实现客户端,很少有用后台来实现,所以小编也就写了写,大神请勿喷?。很多时候,项目与项目之间通讯也需要后台作为客户端来连接。

    步骤一:首先我们要导入后台连接websocket的客户端依赖

    <!--websocket作为客户端-->
    <dependency>
        <groupId>org.java-websocket</groupId>
        <artifactId>Java-WebSocket</artifactId>
        <version>1.3.5</version>
    </dependency>

    步骤二:把客户端需要配置到springboot容器里面去,以便程序调用。

    package com.example.socket.config;
    
    import lombok.extern.slf4j.Slf4j;
    import org.java_websocket.client.WebSocketClient;
    import org.java_websocket.drafts.Draft_6455;
    import org.java_websocket.handshake.ServerHandshake;
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Component;
    
    import java.net.URI;
    
    /**
     * @Auther: liaoshiyao
     * @Date: 2019/1/11 17:38
     * @Description: 配置websocket后台客户端
     */
    @Slf4j
    @Component
    public class WebSocketConfig {
    
        @Bean
        public WebSocketClient webSocketClient() {
            try {
                WebSocketClient webSocketClient = new WebSocketClient(new URI("ws://localhost:8085/websocket/test"),new Draft_6455()) {
                    @Override
                    public void onOpen(ServerHandshake handshakedata) {
                        log.info("[websocket] 连接成功");
                    }
    
                    @Override
                    public void onMessage(String message) {
                        log.info("[websocket] 收到消息={}",message);
    
                    }
    
                    @Override
                    public void onClose(int code, String reason, boolean remote) {
                        log.info("[websocket] 退出连接");
                    }
    
                    @Override
                    public void onError(Exception ex) {
                        log.info("[websocket] 连接错误={}",ex.getMessage());
                    }
                };
                webSocketClient.connect();
                return webSocketClient;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
    }
    

    步骤三:使用后台客户端发送消息

    1、首先小编写了一个接口,里面有指定发送和群发消息两个方法。

    2、实现发送的接口,区分指定发送和群发由服务端来决定(小编在服务端写了,如果带有TOUSER标识的,则代表需要指定发送给某个websocket客户端)

    3、最后采用get方式用浏览器请求,也能正常发送消息

    package com.example.socket.code;
    
    /**
     * @Auther: liaoshiyao
     * @Date: 2019/1/12 10:57
     * @Description: websocket 接口
     */
    public interface WebSocketService {
    
        /**
         * 群发
         * @param message
         */
         void groupSending(String message);
    
        /**
         * 指定发送
         * @param name
         * @param message
         */
         void appointSending(String name,String message);
    }
    
    package com.example.socket.code;
    
    import org.java_websocket.client.WebSocketClient;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    /**
     * @Auther: liaoshiyao
     * @Date: 2019/1/12 10:56
     * @Description: websocket接口实现类
     */
    @Component
    public class ScoketClient implements WebSocketService{
    
        @Autowired
        private WebSocketClient webSocketClient;
    
        @Override
        public void groupSending(String message) {
            // 这里我加了6666-- 是因为我在index.html页面中,要拆分用户编号和消息的标识,只是一个例子而已
            // 在index.html会随机生成用户编号,这里相当于模拟页面发送消息
            // 实际这样写就行了 webSocketClient.send(message)
            webSocketClient.send(message+"---6666");
        }
    
        @Override
        public void appointSending(String name, String message) {
            // 这里指定发送的规则由服务端决定参数格式
            webSocketClient.send("TOUSER"+name+";"+message);
        }
    }
    
    package com.example.socket.chat;
    
    import com.example.socket.code.ScoketClient;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @Auther: liaoshiyao
     * @Date: 2019/1/11 16:47
     * @Description: 测试后台websocket客户端
     */
    @RestController
    @RequestMapping("/websocket")
    public class IndexController {
    
        @Autowired
        private ScoketClient webScoketClient;
    
        @GetMapping("/sendMessage")
        public String sendMessage(String message){
            webScoketClient.groupSending(message);
            return message;
        }
    }
    

    五、最后

    其实,贴了这么多大一片的代码,感觉上影响了博客的美观,也不便于浏览,如果没看懂小伙伴,可以下载源码看下。

    里面一共两个项目,服务端、客户端(html5客户端、后台客户端),是一个网页群聊的小案例。

    https://download.csdn.net/download/weixin_38111957/10912384

     

    祝大家学习愉快~~~

    六、针对评论区的小伙伴提出的疑点进行解答

    看了小伙伴提出的疑问,小编也是非常认可的,如果是单例的情况下,这个对象的值都会被修改。

    小编就抽了时间Debug了一下,经过下图也可以反映出,能够看出,webSokcetSet中存在三个成员,并且vlaue值都是不同的,所以在这里没有出现对象改变而把之前对象改变的现象。

    服务端这样写是没问题的。

    紧接着,小编写了一个测试类,代码如下,经过测试输出的结果和小伙伴提出的疑点是一致的。

    最后总结:这位小伙伴提出的观点确实是正确的,但是在实际WebSocket服务端案例中为什么没有出现这种情况,当WebSokcet这个类标识为服务端的时候,每当有新的连接请求,这个类都是不同的对象,并非单例。

    这里也感谢“烟花苏柳”所提出的问题。

    import com.alibaba.fastjson.JSON;
    
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * @Auther: IT贱男
     * @Date: 2018/11/1 16:15
     * @Description:
     */
    public class TestMain {
    
        /**
         * 用于存所有的连接服务的客户端,这个对象存储是安全的
         */
        private static ConcurrentHashMap<String, Student> webSocketSet = new ConcurrentHashMap<>();
    
        public static void main(String[] args) {
            Student student = Student.getStudent();
            student.name = "张三";
            webSocketSet.put("1", student);
    
            Student students = Student.getStudent();
            students.name = "李四";
            webSocketSet.put("2", students);
    
            System.out.println(JSON.toJSON(webSocketSet));
        }
    }
    
    /**
     * 提供一个单例类
     */
    class Student {
    
        public String name;
    
        private Student() {
        }
    
        private static final Student student = new Student();
    
        public static Student getStudent() {
            return student;
    
        }
    }
    {"1":{"name":"李四"},"2":{"name":"李四"}}

    ----------------------------------------------------- 更新于2019-08-14 -----------------------------------------------------

    展开全文
  • 3. 服务端使用ReadFile从管道中读取数据后(即收到消息)再向管道中写入确认信息表明已经收到客户端传输的数据(即通知客户端已收到)。 4. 客户端收到确认信息后结束,调用CloseHandle关闭管道(该管道是CreateFil

    一、流程

    1. 服务端用CreateNamedPipe创建一个命名管道并使用ConnectNamedPipe等待客户端的连接。

    2. 客户端使用WaitNamedPipe连接成功后,用CreateFile打开管道并使用WriteFile向管道中写入一段数据(即向服务端发送消息)。

    3. 服务端使用ReadFile从管道中读取数据后(即收到消息)再向管道中写入确认信息表明已经收到客户端传输的数据(即通知客户端已收到)。

    4. 客户端收到确认信息后结束,调用CloseHandle关闭管道(该管道是CreateFile打开的)。

    5.服务端使用DisconnectNamedPipe和CloseHandle关闭管道。

    二、实例

    先运行服务器,再运行客户端

    服务端

    // ServicePip.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
    //
    
    #include <iostream>
    #include <windows.h>
    #include <ctime>
    using namespace std;
    
    
    #define pStrPipeName  L"\\\\.\\pipe\\NamePipe_MoreWindows"
    
    int main()
    {
    	printf("        命名管道 服务器\n");
    	printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");
    
    	printf("创建命名管道并等待连接\n");
    	HANDLE hPipe = CreateNamedPipe(pStrPipeName, PIPE_ACCESS_DUPLEX,
    		PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
    		PIPE_UNLIMITED_INSTANCES, 0, 0, NMPWAIT_WAIT_FOREVER, 0);
    	if (ConnectNamedPipe(hPipe, NULL) != NULL)//等待连接。
    	{
    		printf("连接成功,开始接收数据\n");
    
    		const int BUFFER_MAX_LEN = 256;
    		char szBuffer[BUFFER_MAX_LEN];
    		memset(szBuffer, 0, BUFFER_MAX_LEN);
    
    		
    		DWORD dwLen;
    
    		//接收客户端发送的数据
    		ReadFile(hPipe, szBuffer, BUFFER_MAX_LEN, &dwLen, NULL);//读取管道中的内容(管道是一种特殊的文件)
    		printf("接收到数据长度为%d字节\n", dwLen);
    		printf("具体数据内容如下:%s\n", szBuffer);
    
    		//确认已收到数据,并发送消息给客户端
    		printf("向客户端发送已经收到标志\n");
    		strcpy_s(szBuffer, "服务器已经收到");//服务器发送的消息
    		WriteFile(hPipe, szBuffer, strlen(szBuffer) + 1, &dwLen, NULL);
    	}
    	DisconnectNamedPipe(hPipe);
    	CloseHandle(hPipe);//关闭管道
    	return 0;
    }
    
    
    
    
    

    客户端

    #include <iostream>
    #include <windows.h>
    #include <ctime>
    #include <conio.h>
    using namespace std;
    #define BUFSIZE 5
    
    
    #define pStrPipeName  L"\\\\.\\pipe\\NamePipe_MoreWindows"
    int main()
    {
    	printf("        命名管道 客户端\n");
    	printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");
    
    	printf("按任意键以开始连接命名管道\n");
    	_getch();
    	printf("开始等待命名管道\n");
    	if (WaitNamedPipe(pStrPipeName, NMPWAIT_WAIT_FOREVER) == FALSE)
    	{
    		printf("Error! 连接命名管道失败\n");
    		return 0;
    	}
    
    	printf("打开命名管道\n");
    	HANDLE hPipe = CreateFile(pStrPipeName, GENERIC_READ | GENERIC_WRITE, 0,
    		NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    
    	printf("向服务端发送数据\n");
    	const int BUFFER_MAX_LEN = 256;
    	char szBuffer[BUFFER_MAX_LEN];
    	memset(szBuffer, 0, BUFFER_MAX_LEN);
    	DWORD dwLen = 0;
    
    	//向服务端发送数据
    	sprintf_s(szBuffer, "进程%d说\"%s\"", GetCurrentProcessId(), "Hello World!");
    	WriteFile(hPipe, szBuffer, strlen(szBuffer) + 1, &dwLen, NULL);
    	printf("数据写入完毕共%d字节\n", dwLen);
    
    	//接收服务端发回的数据
    	ReadFile(hPipe, szBuffer, BUFFER_MAX_LEN, &dwLen, NULL);//读取管道中的内容(管道是一种特殊的文件)
    	printf("接收服务端发来的确认信息长度为%d字节\n", dwLen);
    	printf("具体数据内容如下:%s\n", szBuffer);
    
    	CloseHandle(hPipe);
    	system("pause");
    	return 0;
    }
    

     

    参考:

    https://blog.csdn.net/morewindows/article/details/7390441

    https://blog.csdn.net/MoreWindows/article/details/8260087?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase

    展开全文
  • websocket主要功能就是实现网络通讯,比如说最经典的客服聊天窗口、您有新的消息通知,或者是项目与项目之间的通讯,都可以采用websocket来实现。 二、websocket介绍 在公司实际使用websocket开发,一般来都是这样的...

    一、引言

    本人最近一直在使用springboot框架开发项目,毕竟现在很多公司都在采用此框架,之后本人也会陆续写关于springboot开发常用功能的文章。

    什么场景下会要使用到websocket的呢?

    websocket主要功能就是实现网络通讯,比如说最经典的客服聊天窗口、您有新的消息通知,或者是项目与项目之间的通讯,都可以采用websocket来实现。

    二、websocket介绍

    在公司实际使用websocket开发,一般来都是这样的架构,首先websocket服务端是一个单独的项目,其他需要通讯的项目都是以客户端来连接,由服务端控制消息的发送方式(群发、指定发送)。但是也会有服务端、客户端在同一个项目当中,具体看项目怎么使用。

    本文呢,采用的是服务端与客户端分离来实现,包括使用springboot搭建websokcet服务端、html5客户端、springboot后台客户端, 具体看下面代码。

    三、服务端实现

    步骤一:springboot底层帮我们自动配置了websokcet,引入maven依赖

     <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
    </dependency>
    

    步骤二:如果是你采用springboot内置容器启动项目的,则需要配置一个Bean。如果是采用外部的容器,则可以不需要配置。

    /**
     * @Description: 配置类
     */
    @Component
    public class WebSocketConfig {
      
        /**
         * ServerEndpointExporter 作用
         *
         * 这个Bean会自动注册使用@ServerEndpoint注解声明的websocket endpoint
         *
         * @return
         */
        @Bean
        public ServerEndpointExporter serverEndpointExporter() {
            return new ServerEndpointExporter();
        }
    }
    

    步骤三:最后一步当然是编写服务端核心代码了,其实本人不是特别想贴代码出来,贴很多代码影响文章可读性。

    package com.example.socket.code;
      
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Component;
      
    import javax.websocket.OnClose;
    import javax.websocket.OnMessage;
    import javax.websocket.OnOpen;
    import javax.websocket.Session;
    import javax.websocket.server.PathParam;
    import javax.websocket.server.ServerEndpoint;
    import java.util.concurrent.ConcurrentHashMap;
      
    /**
     * @Description: websocket 服务类
     */
      
    /**
     *
     * @ServerEndpoint 这个注解有什么作用?
     *
     * 这个注解用于标识作用在类上,它的主要功能是把当前类标识成一个WebSocket的服务端
     * 注解的值用户客户端连接访问的URL地址
     *
     */
      
    @Slf4j
    @Component
    @ServerEndpoint("/websocket/{name}")
    public class WebSocket {
      
        /**
         *  与某个客户端的连接对话,需要通过它来给客户端发送消息
         */
        private Session session;
      
         /**
         * 标识当前连接客户端的用户名
         */
        private String name;
      
        /**
         *  用于存所有的连接服务的客户端,这个对象存储是安全的
         */
        private static ConcurrentHashMap<String,WebSocket> webSocketSet = new ConcurrentHashMap<>();
      
      
        @OnOpen
        public void OnOpen(Session session, @PathParam(value = "name") String name){
            this.session = session;
            this.name = name;
            // name是用来表示唯一客户端,如果需要指定发送,需要指定发送通过name来区分
            webSocketSet.put(name,this);
            log.info("[WebSocket] 连接成功,当前连接人数为:={}",webSocketSet.size());
        }
      
      
        @OnClose
        public void OnClose(){
            webSocketSet.remove(this.name);
            log.info("[WebSocket] 退出成功,当前连接人数为:={}",webSocketSet.size());
        }
      
        @OnMessage
        public void OnMessage(String message){
            log.info("[WebSocket] 收到消息:{}",message);
            //判断是否需要指定发送,具体规则自定义
            if(message.indexOf("TOUSER") == 0){
                String name = message.substring(message.indexOf("TOUSER")+6,message.indexOf(";"));
                AppointSending(name,message.substring(message.indexOf(";")+1,message.length()));
            }else{
                GroupSending(message);
            }
      
        }
      
        /**
         * 群发
         * @param message
         */
        public void GroupSending(String message){
            for (String name : webSocketSet.keySet()){
                try {
                    webSocketSet.get(name).session.getBasicRemote().sendText(message);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
      
        /**
         * 指定发送
         * @param name
         * @param message
         */
        public void AppointSending(String name,String message){
            try {
                webSocketSet.get(name).session.getBasicRemote().sendText(message);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    

    四、客户端实现

    HTML5实现:以下就是核心代码了,其实其他博客有很多,本人就不多说了。

    var websocket = null;
       if('WebSocket' in window){
           websocket = new WebSocket("ws://192.168.2.107:8085/websocket/testname");
       }
     
       websocket.onopen = function(){
           console.log("连接成功");
       }
     
       websocket.onclose = function(){
           console.log("退出连接");
       }
     
       websocket.onmessage = function (event){
           console.log("收到消息"+event.data);
       }
     
       websocket.onerror = function(){
           console.log("连接出错");
       }
     
       window.onbeforeunload = function () {
           websocket.close(num);
       }
    

    SpringBoot后台实现:本人发现多数博客都是采用js来实现客户端,很少有用后台来实现,所以本人也就写了写,大神请勿喷?。很多时候,项目与项目之间通讯也需要后台作为客户端来连接。

    步骤一:首先我们要导入后台连接websocket的客户端依赖

    <!--websocket作为客户端-->
    <dependency>
        <groupId>org.java-websocket</groupId>
        <artifactId>Java-WebSocket</artifactId>
        <version>1.3.5</version>
    </dependency>
    

    步骤二:把客户端需要配置到springboot容器里面去,以便程序调用。

    package com.example.socket.config;
      
    import lombok.extern.slf4j.Slf4j;
    import org.java_websocket.client.WebSocketClient;
    import org.java_websocket.drafts.Draft_6455;
    import org.java_websocket.handshake.ServerHandshake;
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Component;
      
    import java.net.URI;
      
    /**
     * @Description: 配置websocket后台客户端
     */
    @Slf4j
    @Component
    public class WebSocketConfig {
      
        @Bean
        public WebSocketClient webSocketClient() {
            try {
                WebSocketClient webSocketClient = new WebSocketClient(new URI("ws://localhost:8085/websocket/test"),new Draft_6455()) {
                    @Override
                    public void onOpen(ServerHandshake handshakedata) {
                        log.info("[websocket] 连接成功");
                    }
      
                    @Override
                    public void onMessage(String message) {
                        log.info("[websocket] 收到消息={}",message);
      
                    }
      
                    @Override
                    public void onClose(int code, String reason, boolean remote) {
                        log.info("[websocket] 退出连接");
                    }
      
                    @Override
                    public void onError(Exception ex) {
                        log.info("[websocket] 连接错误={}",ex.getMessage());
                    }
                };
                webSocketClient.connect();
                return webSocketClient;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
      
    }
    

    步骤三:使用后台客户端发送消息

    1、首先本人写了一个接口,里面有指定发送和群发消息两个方法。

    2、实现发送的接口,区分指定发送和群发由服务端来决定(本人在服务端写了,如果带有TOUSER标识的,则代表需要指定发送给某个websocket客户端)。

    3、最后采用get方式用浏览器请求,也能正常发送消息。

    package com.example.socket.code;
      
    /**
     * @Description: websocket 接口
     */
    public interface WebSocketService {
      
        /**
         * 群发
         * @param message
         */
         void groupSending(String message);
      
        /**
         * 指定发送
         * @param name
         * @param message
         */
         void appointSending(String name,String message);
    }
    package com.example.socket.chat;
      
    import com.example.socket.code.ScoketClient;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
      
    /**
     * @Description: 测试后台websocket客户端
     */
    @RestController
    @RequestMapping("/websocket")
    public class IndexController {
      
        @Autowired
        private ScoketClient webScoketClient;
      
        @GetMapping("/sendMessage")
        public String sendMessage(String message){
            webScoketClient.groupSending(message);
            return message;
        }
    }
    

    五、最后

    注意:

    如果是单例的情况下,这个对象的值都会被修改。

    本人就抽了时间Debug了一下,经过下图也可以反映出,能够看出,webSokcetSet中存在三个成员,并且vlaue值都是不同的,所以在这里没有出现对象改变而把之前对象改变的现象。

    服务端这样写是没问题的。

    图片

    最后总结:在实际WebSocket服务端案例中为什么没有出现这种情况,当WebSokcet这个类标识为服务端的时候,每当有新的连接请求,这个类都是不同的对象,并非单例。

    import com.alibaba.fastjson.JSON;
      
    import java.util.concurrent.ConcurrentHashMap;
      
    /**
     * @Description:
     */
    public class TestMain {
      
        /**
         * 用于存所有的连接服务的客户端,这个对象存储是安全的
         */
        private static ConcurrentHashMap<String, Student> webSocketSet = new ConcurrentHashMap<>();
      
        public static void main(String[] args) {
            Student student = Student.getStudent();
            student.name = "张三";
            webSocketSet.put("1", student);
      
            Student students = Student.getStudent();
            students.name = "李四";
            webSocketSet.put("2", students);
      
            System.out.println(JSON.toJSON(webSocketSet));
        }
    }
      
    /**
     * 提供一个单例类
     */
    class Student {
      
        public String name;
      
        private Student() {
        }
      
        private static final Student student = new Student();
      
        public static Student getStudent() {
            return student;
      
        }
    }
    

    打印结果:

    {"1":{"name":"李四"},"2":{"name":"李四"}}
    

    图片

    展开全文
  • 想通过微博来定时发送相关数据(由于没认证,所以接口调用一下就到了限制,明天继续。。。)代码地址:... 搭建简易的物联网服务端客户端目录 微博通知 1.weibo开发者平台 (1)网址...
  • 最近有个项目,大致需求是,服务端发送消息通知客户端上传指定的数据,然后处理后一部分显示在服务端界面上。也是在网上胡乱搜索一片,看到一篇Remoting广播事件的博客+Remoting觉得这么还可以做。 大致原理是:...
  • 异步选择(WSAAsyncSelect)...利用这个模型,应用程序可在一个套接字上,接收以 Windows 消息为基础的网络事件通知。具体 的做法是在建好一个套接字后,调用WSAAsyncSelect函数。该模型的核心即是WSAAsyncSelect函数。
  • 同步和异步 概念 同步与异步的重点在消息通知的方式上,也就是调用结果通知的方式。 同步: 当一个同步调用发出去后,调用者要一直等待调用结果的通知后,才能进行后续的执行。...服务端 //创建...
  • import javapns.Push; import javapns.notification.PushNotificationPayload; public class PushServer { public static void main... // 向执行设备发送Push通知的device token。 // 不同设备的device token应
  • 实现对于一些指定数据超过预期的时候,会发送邮件报警代码地址:...搭建简易的物联网服务端客户端目录 邮件通知 1.nodejs邮件模块 (1)emailjs模块send emails...
  • zabbix是一个基于WEB界面的提供...并提供柔软的通知机制以让系统管理员快速定位/解决存在的各种问题。安装平台:VirtualBox系统:centos 5.8内存:1024Mzabbix运行条件Server:zabbix server需运行在LAMP(Linux+A...
  • iot_push 基于netty + mqtt 3.1.1协议开发的物联网消息推送框架(此项目不维护了)请参考新项目( ) ...##服务端示例(iot_push_server_starter_test) 已实现: 发布订阅功能 遗言通知 会话session数据 发布保留消息
  •  CAsyncSocket是MFC中对WSAAsyncSelect异步非阻塞通知IO的一个封装类。我们在《Windows下使用WSAAsyncSelect实现窗口处理socket消息》一文中讨论过WSAAsyncSelect的用法,知道它绑定一个窗口到一个socket,并注册了...
  • android socket 客户端 服务端 监听 apk安装完成
  • v2.0.1 更新: ============================================= ...1、IServerSocketListener 增加 OnPrepareSocket(connID, socket) 通知方法用于在使用 socket 前设置 SOCKET 选项或过滤客户端连接 2、ISocketServer
  • 类似支付宝条码支付,支付结果是如何通知给app客户端的,是轮训还是建立的长连接,求知道的大神帮助下
  • v2.0.1 更新: ============================================= ...1、IServerSocketListener 增加 OnPrepareSocket(connID, socket) 通知方法用于在使用 socket 前设置 SOCKET 选项或过滤客户端连接 2、...
  • v2.0.1 更新: ============================================= ...1、IServerSocketListener 增加 OnPrepareSocket(connID, socket) 通知方法用于在使用 socket 前设置 SOCKET 选项或过滤客户端连接 2、...
  • 从各处搜集,终于实现了,WCF双工模式,服务端回调客户端,通知客户端执行动作,实现的代码在,稍后我会把项目讲解贴上来。 项目地址:github
  • WebSocket安卓客户端实现详解(三)–服务端主动通知
  • # 服务端 用WSASEND发送数据 客户端RECV成功了 为什么服务端还没有收到IOCP完成通知 只有等客户端closesocket 服务端才完全收到所有WSASEND通知 真奇怪
  • WebSocket安卓客户端实现详解(三)--服务端主动通知

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,621
精华内容 648
关键字:

服务端通知客户端