精华内容
下载资源
问答
  • java调用websocket接口
    千次阅读
    2021-02-12 20:22:37

    项目中需要调用第三方语音电话接口,代码如下:

    1.pom.xml引入websocket依赖

    org.java-websocket

    Java-WebSocket

    1.3.8

    2.YiWeiDialUtil.java

    package com.yudu.sms.util;

    import com.alibaba.fastjson.JSONObject;

    import org.java_websocket.WebSocket;

    import org.java_websocket.client.WebSocketClient;

    import org.java_websocket.handshake.ServerHandshake;

    import org.slf4j.Logger;

    import org.slf4j.LoggerFactory;

    import java.net.URI;

    import java.net.URISyntaxException;

    public class YiWeiDialUtil {

    private static final Logger logger = LoggerFactory.getLogger(YiWeiDialUtil.class);

    public static void dial(String ws, String phone, String recordName) {

    try {

    URI uri = new URI(ws);

    WebSocketClient client = new WebSocketClient(uri) {

    @Override

    public void onOpen(ServerHandshake serverHandshake) { }

    @Override

    public void onMessage(String s) {

    logger.info("返回的数据:" + s);

    JSONObject jo = JSONObject.parseObject(s);

    String dynamicdata = jo.getString("dynamicdata");

    if (dynamicdata != null) {

    JSONObject jo_dynamicdata = JSONObject.parseObject(dynamicdata);

    String realtimestate = jo_dynamicdata.getString("realtimestate");

    if (realtimestate.equals("outconnected")) {

    send("{\"command\":\"closeheadsettochannel\"}");

    String recordMp3 = System.getProperty("user.dir") + "\\src\\main\\resources\\" + recordName + ".mp3";

    String record = "{\"command\":\"PlayStartRecord\",\"arguments\":{\"content\":\"" + recordMp3 + "\"}}";

    send(record);

    }

    }

    }

    @Override

    public void onClose(int i, String s, boolean b) { }

    @Override

    public void onError(Exception e) {

    logger.error(e.getMessage());

    }

    };

    //建立连接

    client.connect();

    while (!client.getReadyState().equals(WebSocket.READYSTATE.OPEN)) {

    logger.info("连接中...");

    }

    String dial = "{\"command\":\"Dial\",\"arguments\":{\"phone\":\"" + phone + "\"}}";

    client.send(dial);

    } catch (URISyntaxException e) {

    logger.info(e.getMessage());

    }

    }

    }

    ···

    更多相关内容
  • 在数据实效性要求更高的今天,实时通讯成为必然,webSocket为浏览器提供了解决方案,而现在基本所有浏览器都对其进行了支持,其...本案例针对webSocket使用提供了完整案例,下载后便可以直接运行使用,为入门提供便利
  • java代码-使用java解决websocket的问题的源代码 ——学习参考资料:仅用于个人学习使用
  • WebSocket服务端 创建Springboot工程,引入WebSocket依赖 配置WebSocketConfig 配置WebSocketServer Java客户端 创建Springboot工程,引入java客户端依赖 配置JavaClient 创建连接 测试效果 ...

    目录

     

    WebSocket服务端

    创建Springboot工程,引入WebSocket依赖

    配置WebSocketConfig

    配置WebSocketServer

    Java客户端

    创建Springboot工程,引入java客户端依赖

    配置JavaClient

    创建连接

    测试效果


    WebSocket服务端

    简单说一下WebSocket,本身就是一种基于TCP的有状态的双向通信协议,可以实现即时通讯、消息推送等需要长连接的业务场景。

    创建Springboot工程,引入WebSocket依赖

    本示例引入的pom依赖如下:

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    配置WebSocketConfig

    代码如下

    package com.websocket.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.socket.server.standard.ServerEndpointExporter;
    
    /**
     * WebSocket配置类
     * @author Neo
     */
    @Configuration
    public class WebSocketConfig {
    
        @Bean
        public ServerEndpointExporter serverEndpointExporter(){
    
            return new ServerEndpointExporter();
    
        }
    }

    配置WebSocketServer

    代码如下

    package com.websocket.server;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Component;
    
    import javax.websocket.*;
    import javax.websocket.server.ServerEndpoint;
    import java.io.IOException;
    import java.util.concurrent.CopyOnWriteArraySet;
    import java.util.concurrent.atomic.AtomicInteger;
    
    /**
     * WebSocket服务类
     * @author Neo
     */
    @Slf4j
    @ServerEndpoint(value = "/ws/server")
    @Component
    public class WebSocketServer {
    
        //存储每一个客户端会话信息的线程安全的集合
        private static final CopyOnWriteArraySet<Session> sessions = new CopyOnWriteArraySet<>();
        //使用线程安全的计数器,记录在线数
        private static final AtomicInteger onlineCount = new AtomicInteger(0);
    
        /**
         * 连接成功时调用的方法
         * @param session
         */
        @OnOpen
        public void onOpen(Session session) {
            //存储会话信息
            sessions.add(session);
            //计数+1
            int cnt = onlineCount.incrementAndGet();
            //打印日志
            log.info("有连接加入,当前连接数为:" + cnt);
            //给客户端发消息
            this.sendMessage(session, "连接成功");
        }
    
        /**
         * 连接关闭时调用的方法
         * @param session
         */
        @OnClose
        public void onClose(Session session) {
            //删除会话信息
            sessions.remove(session);
            //计数-1
            int cnt = onlineCount.decrementAndGet();
            //打印日志
            log.info("有连接关闭,当前连接数为:" + cnt);
        }
    
        /**
         * 收到客户端消息时调用的方法
         * @param message
         * @param session
         */
        @OnMessage
        public void onMessage(String message, Session session) {
            //打印日志
            log.info("来自客户端的消息:" + message);
            //给客户端发消息
            this.sendMessage(session, "收到消息,消息内容:" + message);
        }
    
        /**
         * 出现异常时调用的方法
         * @param session
         * @param error
         */
        @OnError
        public void onError(Session session, Throwable error) {
            //打印日志
            log.error("发生错误:Session ID:" + error.getMessage() + session.getId());
        }
    
        /**
         * 发送消息
         * @param session
         * @param message
         */
        public void sendMessage(Session session, String message) {
            try {
                //发送消息
                session.getBasicRemote().sendText("SID:::" + session.getId() + ":::" + message);
            } catch (IOException e) {
                //打印日志
                log.error("发送消息出错:" + e.getMessage());
            }
        }
    
        /**
         * 群发消息
         * 这个方法可以升级为消息推送的工具,给在线的客户端弹个广告啥的
         * @param message
         * @throws IOException
         */
        public void sendMessage(String message) throws IOException {
            for (Session session : sessions) {
                //判断连接是否开着
                if(session.isOpen()){
                    //一个一个发
                    this.sendMessage(session, message);
                }
            }
        }
    
        /**
         * 给指定的客户端发消息
         * 这个方法可以升级为即时通讯的工具,例如客户端A、客户端B、服务端WS
         * 首先,客户端要有身份id与WS的session进行绑定
         * 然后,A要给B发送消息,先获取B的身份id,然后将消息和B的身份id发给WS
         * WS收到A的消息后,拿着B的身份id去查询B与WS的会话信息,找到了,就把A的消息发送给B
         * @param sessionId
         * @param message
         * @throws IOException
         */
        public void sendMessage(String sessionId,String message) throws IOException {
            Session session = null;
            //遍历找会话信息
            for (Session s : sessions) {
                if(s.getId().equals(sessionId)){
                    session = s;
                    break;
                }
            }
            if(session!=null){
                //找到了,发消息
                this.sendMessage(session, message);
            } else{
                //打印日志
                log.warn("没有找到指定的会话:" + sessionId);
            }
        }
    }

    到这里,WebSocket的服务端就配置完成了。

    Java客户端

    这里的java客户端,其实就是用java代码,去建立与websocket服务端连接的,java工程

    创建Springboot工程,引入java客户端依赖

    pom依赖如下:

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.java-websocket</groupId>
            <artifactId>Java-WebSocket</artifactId>
            <version>1.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    配置JavaClient

    代码如下:

    package com.websocket.javaclient;
    
    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.stereotype.Component;
    
    import java.net.URI;
    import java.net.URISyntaxException;
    
    @Slf4j
    @Component
    public class JavaClient {
    
    
        /**
         * 获取客户端连接实例
         * @param uri
         * @return
         */
        public WebSocketClient getClient(String uri){
    
            try {
    
                //创建客户端连接对象
                WebSocketClient client = new WebSocketClient(new URI(uri),new Draft_6455()) {
    
                    /**
                     * 建立连接调用
                     * @param serverHandshake
                     */
                    @Override
                    public void onOpen(ServerHandshake serverHandshake) {
                        log.info("建立连接");
                    }
    
                    /**
                     * 收到服务端消息调用
                     * @param s
                     */
                    @Override
                    public void onMessage(String s) {
                        log.info("收到来自服务端的消息:::" + s);
                    }
    
                    /**
                     * 断开连接调用
                     * @param i
                     * @param s
                     * @param b
                     */
                    @Override
                    public void onClose(int i, String s, boolean b) {
                        log.info("关闭连接:::" + "i = " + i + ":::s = " + s +":::b = " + b);
                    }
    
                    /**
                     * 连接报错调用
                     * @param e
                     */
                    @Override
                    public void onError(Exception e) {
                        log.error("报错了:::" + e.getMessage());
                    }
    
                };
    
                //请求与服务端建立连接
                client.connect();
    
                //判断连接状态,0为请求中  1为已建立  其它值都是建立失败
                while(client.getReadyState().ordinal() == 0){
    
                    try {
    
                        Thread.sleep(200);
    
                    }catch (Exception e){
    
                        log.warn("延迟操作出现问题,但并不影响功能");
    
                    }
    
                    log.info("连接中。。。");
    
                }
    
                //连接状态不再是0请求中,判断建立结果是不是1已建立
                if (client.getReadyState().ordinal() == 1){
    
                    return client;
    
                }
    
            }catch (URISyntaxException e){
    
                log.error(e.getMessage());
            }
    
            return null;
        }
    }

    创建连接

    这里创建连接的方式采用了web接口访问的方式,其实可以直接用main函数跑,没办法,web职业病
    代码如下:

    package com.websocket.controller;
    
    
    import com.websocket.javaclient.JavaClient;
    import org.java_websocket.client.WebSocketClient;
    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;
    
    @RestController
    @RequestMapping(value = "/jc")
    public class JavaClientController {
    
        @Autowired
        private JavaClient javaClient;
    
        @GetMapping(value = "hello")
        public void hello(String str){
    
            WebSocketClient client = this.javaClient.getClient("ws://localhost:8080/ws/server");
    
            if (client != null){
    
                client.send(str);
    
            }
            
        }
    }

    测试效果

    测试1:

    客户端:

    在这里插入图片描述

    服务端:
    在这里插入图片描述
    测试2:

    在这里插入图片描述

    客户端:
    在这里插入图片描述
    服务端:
    在这里插入图片描述

    展开全文
  • java 实现websocket的两种方式

    千次阅读 2022-02-25 22:16:56
    1.两种方式,一种使用tomcat的websocket实现,一种使用spring的websocket 2.tomcat的方式需要tomcat 7.x,JEE7的支持。 3.spring与websocket整合需要spring 4.x,并且使用了socketjs,对不支持websocket的浏览器可以...

    简单说明

    1.两种方式,一种使用tomcat的websocket实现,一种使用spring的websocket

    2.tomcat的方式需要tomcat 7.x,JEE7的支持。

    3.spring与websocket整合需要spring 4.x,并且使用了socketjs,对不支持websocket的浏览器可以模拟websocket使用

    方式一:tomcat

    使用这种方式无需别的任何配置,只需服务端一个处理类,

    服务器端代码

    package com.Socket;  
      
    import java.io.IOException;  
    import java.util.Map;  
    import java.util.concurrent.ConcurrentHashMap;  
    import javax.websocket.*;  
    import javax.websocket.server.PathParam;  
    import javax.websocket.server.ServerEndpoint;  
    import net.sf.json.JSONObject;  
      
    @ServerEndpoint("/websocket/{username}")  
    public class WebSocket {  
      
        private static int onlineCount = 0;  
        private static Map<String, WebSocket> clients = new ConcurrentHashMap<String, WebSocket>();  
        private Session session;  
        private String username;  
          
        @OnOpen  
        public void onOpen(@PathParam("username") String username, Session session) throws IOException {  
      
            this.username = username;  
            this.session = session;  
              
            addOnlineCount();  
            clients.put(username, this);  
            System.out.println("已连接");  
        }  
      
        @OnClose  
        public void onClose() throws IOException {  
            clients.remove(username);  
            subOnlineCount();  
        }  
      
        @OnMessage  
        public void onMessage(String message) throws IOException {  
      
            JSONObject jsonTo = JSONObject.fromObject(message);  
              
            if (!jsonTo.get("To").equals("All")){  
                sendMessageTo("给一个人", jsonTo.get("To").toString());  
            }else{  
                sendMessageAll("给所有人");  
            }  
        }  
      
        @OnError  
        public void onError(Session session, Throwable error) {  
            error.printStackTrace();  
        }  
      
        public void sendMessageTo(String message, String To) throws IOException {  
            // session.getBasicRemote().sendText(message);  
            //session.getAsyncRemote().sendText(message);  
            for (WebSocket item : clients.values()) {  
                if (item.username.equals(To) )  
                    item.session.getAsyncRemote().sendText(message);  
            }  
        }  
          
        public void sendMessageAll(String message) throws IOException {  
            for (WebSocket item : clients.values()) {  
                item.session.getAsyncRemote().sendText(message);  
            }  
        }  
          
          
      
        public static synchronized int getOnlineCount() {  
            return onlineCount;  
        }  
      
        public static synchronized void addOnlineCount() {  
            WebSocket.onlineCount++;  
        }  
      
        public static synchronized void subOnlineCount() {  
            WebSocket.onlineCount--;  
        }  
      
        public static synchronized Map<String, WebSocket> getClients() {  
            return clients;  
        }  
    }  
    

    客户端js

    var websocket = null;  
    var username = localStorage.getItem("name");  
      
    //判断当前浏览器是否支持WebSocket  
    if ('WebSocket' in window) {  
        websocket = new WebSocket("ws://" + document.location.host + "/WebChat/websocket/" + username + "/"+ _img);  
    } else {  
        alert('当前浏览器 Not support websocket')  
    }  
      
    //连接发生错误的回调方法  
    websocket.onerror = function() {  
        setMessageInnerHTML("WebSocket连接发生错误");  
    };  
      
    //连接成功建立的回调方法  
    websocket.onopen = function() {  
        setMessageInnerHTML("WebSocket连接成功");  
    }  
      
    //接收到消息的回调方法  
    websocket.onmessage = function(event) {  
        setMessageInnerHTML(event.data);  
    }  
      
    //连接关闭的回调方法  
    websocket.onclose = function() {  
        setMessageInnerHTML("WebSocket连接关闭");  
    }  
      
    //监听窗口关闭事件,当窗口关闭时,主动去关闭websocket连接,防止连接还没断开就关闭窗口,server端会抛异常。  
    window.onbeforeunload = function() {  
        closeWebSocket();  
    }  
      
    //关闭WebSocket连接  
    function closeWebSocket() {  
        websocket.close();  
    }  
    

    发送消息只需要使用websocket.send(“发送消息”),就可以触发服务端的onMessage()方法,当连接时,触发服务器端onOpen()方法,此时也可以调用发送消息的方法去发送消息。关闭websocket时,触发服务器端onclose()方法,此时也可以发送消息,但是不能发送给自己,因为自己的已经关闭了连接,但是可以发送给其他人。

    方法二:spring整合

    此方式基于spring mvc框架,相关配置可以看我的相关博客文章

    WebSocketConfig.java

    这个类是配置类,所以需要在spring mvc配置文件中加入对这个类的扫描,第一个addHandler是对正常连接的配置,第二个是如果浏览器不支持websocket,使用socketjs模拟websocket的连接。

    package com.websocket;  
      
    import org.springframework.context.annotation.Bean;  
    import org.springframework.context.annotation.Configuration;  
    import org.springframework.web.socket.config.annotation.EnableWebSocket;  
    import org.springframework.web.socket.config.annotation.WebSocketConfigurer;  
    import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;  
    import org.springframework.web.socket.handler.TextWebSocketHandler;  
      
    @Configuration  
    @EnableWebSocket  
    public class WebSocketConfig implements WebSocketConfigurer {  
        @Override  
        public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {  
            registry.addHandler(chatMessageHandler(),"/webSocketServer").addInterceptors(new ChatHandshakeInterceptor());  
            registry.addHandler(chatMessageHandler(), "/sockjs/webSocketServer").addInterceptors(new ChatHandshakeInterceptor()).withSockJS();  
        }  
       
        @Bean  
        public TextWebSocketHandler chatMessageHandler(){  
            return new ChatMessageHandler();  
        }  
      
    }  
    

    ChatHandshakeInterceptor.java

    这个类的作用就是在连接成功前和成功后增加一些额外的功能,Constants.java类是一个工具类,两个常量。

    package com.websocket;  
      
    import java.util.Map;  
    import org.apache.shiro.SecurityUtils;  
    import org.springframework.http.server.ServerHttpRequest;  
    import org.springframework.http.server.ServerHttpResponse;  
    import org.springframework.web.socket.WebSocketHandler;  
    import org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor;  
      
    public class ChatHandshakeInterceptor extends HttpSessionHandshakeInterceptor {  
      
        @Override  
        public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,  
                Map<String, Object> attributes) throws Exception {  
            System.out.println("Before Handshake");  
            /* 
             * if (request instanceof ServletServerHttpRequest) { 
             * ServletServerHttpRequest servletRequest = (ServletServerHttpRequest) 
             * request; HttpSession session = 
             * servletRequest.getServletRequest().getSession(false); if (session != 
             * null) { //使用userName区分WebSocketHandler,以便定向发送消息 String userName = 
             * (String) session.getAttribute(Constants.SESSION_USERNAME); if 
             * (userName==null) { userName="default-system"; } 
             * attributes.put(Constants.WEBSOCKET_USERNAME,userName); 
             *  
             * } } 
             */  
      
            //使用userName区分WebSocketHandler,以便定向发送消息(使用shiro获取session,或是使用上面的方式)  
            String userName = (String) SecurityUtils.getSubject().getSession().getAttribute(Constants.SESSION_USERNAME);  
            if (userName == null) {  
                userName = "default-system";  
            }  
            attributes.put(Constants.WEBSOCKET_USERNAME, userName);  
      
            return super.beforeHandshake(request, response, wsHandler, attributes);  
        }  
      
        @Override  
        public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,  
                Exception ex) {  
            System.out.println("After Handshake");  
            super.afterHandshake(request, response, wsHandler, ex);  
        }  
      
    }  
    

    ChatMessageHandler.java

    这个类是对消息的一些处理,比如是发给一个人,还是发给所有人,并且前端连接时触发的一些动作

    package com.websocket;  
      
    import java.io.IOException;  
    import java.util.ArrayList;  
    import org.apache.log4j.Logger;  
    import org.springframework.web.socket.CloseStatus;  
    import org.springframework.web.socket.TextMessage;  
    import org.springframework.web.socket.WebSocketSession;  
    import org.springframework.web.socket.handler.TextWebSocketHandler;  
      
    public class ChatMessageHandler extends TextWebSocketHandler {  
      
        private static final ArrayList<WebSocketSession> users;// 这个会出现性能问题,最好用Map来存储,key用userid  
        private static Logger logger = Logger.getLogger(ChatMessageHandler.class);  
      
        static {  
            users = new ArrayList<WebSocketSession>();  
        }  
      
        /** 
         * 连接成功时候,会触发UI上onopen方法 
         */  
        @Override  
        public void afterConnectionEstablished(WebSocketSession session) throws Exception {  
            System.out.println("connect to the websocket success......");  
            users.add(session);  
            // 这块会实现自己业务,比如,当用户登录后,会把离线消息推送给用户  
            // TextMessage returnMessage = new TextMessage("你将收到的离线");  
            // session.sendMessage(returnMessage);  
        }  
      
        /** 
         * 在UI在用js调用websocket.send()时候,会调用该方法 
         */  
        @Override  
        protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {  
            sendMessageToUsers(message);  
            //super.handleTextMessage(session, message);  
        }  
      
        /** 
         * 给某个用户发送消息 
         * 
         * @param userName 
         * @param message 
         */  
        public void sendMessageToUser(String userName, TextMessage message) {  
            for (WebSocketSession user : users) {  
                if (user.getAttributes().get(Constants.WEBSOCKET_USERNAME).equals(userName)) {  
                    try {  
                        if (user.isOpen()) {  
                            user.sendMessage(message);  
                        }  
                    } catch (IOException e) {  
                        e.printStackTrace();  
                    }  
                    break;  
                }  
            }  
        }  
      
        /** 
         * 给所有在线用户发送消息 
         * 
         * @param message 
         */  
        public void sendMessageToUsers(TextMessage message) {  
            for (WebSocketSession user : users) {  
                try {  
                    if (user.isOpen()) {  
                        user.sendMessage(message);  
                    }  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
      
        @Override  
        public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {  
            if (session.isOpen()) {  
                session.close();  
            }  
            logger.debug("websocket connection closed......");  
            users.remove(session);  
        }  
      
        @Override  
        public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {  
            logger.debug("websocket connection closed......");  
            users.remove(session);  
        }  
      
        @Override  
        public boolean supportsPartialMessages() {  
            return false;  
        }  
      
    }  
    

    spring-mvc.xml

    正常的配置文件,同时需要增加对WebSocketConfig.java类的扫描,并且增加

    xmlns:websocket="http://www.springframework.org/schema/websocket"  
                  http://www.springframework.org/schema/websocket   
                  <a target="_blank" href="http://www.springframework.org/schema/websocket/spring-websocket-4.1.xsd">http://www.springframework.org/schema/websocket/spring-websocket-4.1.xsd</a>  
    

    客户端

    <script type="text/javascript"  
            src="http://localhost:8080/Bank/js/sockjs-0.3.min.js"></script>  
        <script>  
            var websocket;  
          
            if ('WebSocket' in window) {  
                websocket = new WebSocket("ws://" + document.location.host + "/Bank/webSocketServer");  
            } else if ('MozWebSocket' in window) {  
                websocket = new MozWebSocket("ws://" + document.location.host + "/Bank/webSocketServer");  
            } else {  
                websocket = new SockJS("http://" + document.location.host + "/Bank/sockjs/webSocketServer");  
            }  
          
            websocket.onopen = function(evnt) {};  
            websocket.onmessage = function(evnt) {  
                $("#test").html("(<font color='red'>" + evnt.data + "</font>)")  
            };  
          
            websocket.onerror = function(evnt) {};  
            websocket.onclose = function(evnt) {}  
          
            $('#btn').on('click', function() {  
                if (websocket.readyState == websocket.OPEN) {  
                    var msg = $('#id').val();  
                    //调用后台handleTextMessage方法  
                    websocket.send(msg);  
                } else {  
                    alert("连接失败!");  
                }  
            });  
        </script>  
    

    注意导入socketjs时要使用地址全称,并且连接使用的是http而不是websocket的ws

    展开全文
  • NULL 博文链接:https://genius.iteye.com/blog/451378
  • java client连接websocket接口(简单demo) 网上例子太复杂,两部 一,引入依赖 &lt;dependency&gt; &lt;groupId&gt;org.java-websocket&lt;/groupId&gt; &lt;artifactId&gt...

    java client连接websocket接口(简单demo)

    网上例子太复杂,两部

    一,引入依赖

            <dependency>
                <groupId>org.java-websocket</groupId>
                <artifactId>Java-WebSocket</artifactId>
                <version>1.3.8</version>
            </dependency>

    二,运行调用

    package com.quantfn.strategy.atrfuture.test;
    
    import org.java_websocket.client.WebSocketClient;
    import org.java_websocket.handshake.ServerHandshake;
    
    import java.net.URI;
    
    public class TestApp {
    
        public static void main(String[] args) {
            try {
            // 这里用的binance的socket接口,国内调用需要VPN,使用换成你的就行
    //            String url = "wss://stream.binance.com:9443/ws/ethbtc@ticker";
    //            String url = "wss://stream.binance.com:9443/ws/ethbtc@depth20";
                String url = "wss://stream.binance.com:9443/stream?streams=ethbtc@ticker/ethbtc@depth20/trxbtc@ticker/trxbtc@depth20";
                URI uri = new URI(url);
                WebSocketClient mWs = new WebSocketClient(uri){
                    @Override
                    public void onOpen(ServerHandshake serverHandshake) {
    
                    }
    
                    @Override
                    public void onMessage(String s) {
                        System.out.println(s);
                    }
    
                    @Override
                    public void onClose(int i, String s, boolean b) {
    
                    }
    
                    @Override
                    public void onError(Exception e) {
    
                    }
                };
                mWs.connect();
                System.out.println("haha");
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    }
    
    
    
    展开全文
  • import java.util.Set;import javax.websocket.Endpoint;import javax.websocket.server.ServerApplicationConfig;import javax.websocket.server.ServerEndpointConfig;/*** 1, webSocket 的配置类,...
  • 1.添加pom依赖 <dependency> <groupId>org.springframework.boot<...spring-boot-starter-websocket</artifactId> </dependency> 2.添加webSocket配置类 import o...
  • 1、maven依赖 <dependency> <groupId>org.springframework.boot<...spring-boot-starter-websocket</artifactId> </dependency> 2、java代码 a、配置类 import org....
  • 1.pom中引入依赖 ...org.java-websocket</groupId> <artifactId>Java-WebSocket</artifactId> <version>1.3.4</version> </dependency> 2.测试代码 import org.apache.c
  • WebSocket.java:package com.controller;import java.io.IOException;import java.util.ArrayList;import java.util.List;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;import javax....
  • Java SE 11开始,JDK包含一个客户端WebSocket API。Javadoc包含一些代码示例,但是您不能立即使用这些示例。在网上搜索“ java websocket client”将主要显示有关旧JSR 352 websocket的示例和指南。设置一切以完成...
  • Java发送websocket

    2022-02-23 10:40:25
    import java.security.Principal; /** * 如有要看例子,请打开注释 * **/ @RestController public class WebSoketDemoController { //spring提供的发送消息模板 @Autowired private SimpMessagingTemplate ...
  • java+websocket前后端调用过程解析

    千次阅读 2021-01-17 18:26:56
    import javax.websocket.OnClose; import javax.websocket.OnError; import javax.websocket.OnMessage; import javax.websocket.OnOpen; import javax.websocket.Session; import javax.websocket.server....
  • java实现websocket

    2021-08-09 14:43:48
    在H5出来之前,消息推送基本上都是使用HTTP请求的,但HTTP请求只能在客户端发起请求后服务端返回消息,而不能再客户端未发起请求时服务端主动推送消息给客户端,而对于HTTP的方式实现消息推送时,有以下几种方式: ...
  • WebSocket应用程序中,服务器发布WebSocket端点,客户端使用url连接到服务器。建立连接后,服务器和客户端就可以互相发送消息。客户端通常连接到一台服务器,服务器接受多个客户端的连接。1.1 WebSocket协议...
  • Java后端WebSocket的实现

    2022-04-19 11:37:38
    WebSocket 1.什么是WebSocket? webSocket是HTML5开始提供的一种在单个TCP连接上进行全双工通讯的协议。 webSocket使得客户端和服务器之间的数据交换变得更加简单,(在线聊天基础)允许服务端主动向客户端推送数据...
  • 随着智能行业蓬勃发展,难免有一种业务是:APP/web的一个http/https请求,需要获取智能设备的基本信息,又或者,机器人使用ros模块化通信的时候,需要联络各个模块把基本信息回执发回给服务端。本文章解决的是一个...
  • WebSocket简单使用网上有使用Okhttp进行封装,在封装的,还有使用java-websocket这个包的。而我选择的是后者。因为这个包有maven包,好像还是麻省理工实验室出的,使用起来也算比较简单。**第一步:**去gitHub上...
  • 最近了解了下websocket和socket这个东西,说不得不来说下为何要使用 WebSocket ,和为何不用http。为何需要WebSocket ?HTTP 协议是一种无状态的、无连接的、单向的应用层协议。它采用了请求/响应模型。通信请求只能...
  • 我想在连接到spring websocket时向用户发送消息,我已经@Configuration@EnableWebSocketMessageBrokerpublic class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {@Autowiredprivate ...
  • Java-WebSocket实现简单对话示例

    千次阅读 2019-07-10 16:29:34
    Java-WebSocket是对WebSocket进行封装的java语言开源框架,用于简化使用java语言和WebSocket技术建立客户端与服务端长连接的操作。关于WebSocket,下面是百度百科的一段概述,这里不做深入分析,重点在该框架的基本...
  • Java WebSocket介绍

    2021-09-15 09:54:59
    日常工作中,大家会接触到websocket和socket,但有时分不清二者的用处和区别,这篇文章介绍websockect的用处和实现。 一、消息推送的选型对比 1.1 轮询 介绍:客户端定时向服务端发送ajax请求,服务器收到请求后立即...
  • javawebsocket的应用

    2021-02-12 09:35:37
    在上一篇文章中,笔者简要介绍了websocket的应用场景及优点,戳这里这篇文章主要来介绍一下在java项目中,特别是java web项目中websocket的应用。场景:我做了一个商城系统,跟大多数商城系统,分为客户端和后台,...
  • SpringBoot实现WebSocket接口 pom.xml添加 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </...
  • java实现webSocket客户端

    2020-12-02 18:00:06
    两个类 1、启动类 package main.entry.webapp; import java.net.URI;...import org.java_websocket.drafts.Draft_17; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springfra

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,500
精华内容 11,000
关键字:

java调用websocket接口

java 订阅
友情链接: Maze_Skelete.rar