Jetty 开发指导：Jetty Websocket API

最新推荐文章于 2024-10-11 14:21:08 发布
最新推荐文章于 2024-10-11 14:21:08 发布
阅读量4.2k 收藏 4
点赞数 1
分类专栏： Java Web 文章标签： websocket jetty
本文介绍了Jetty提供的WebSocket API，包括WebSocket事件处理、Session管理、信息发送方式、注释和监听器使用方法等核心内容。同时展示了如何通过Servlet和客户端API实现WebSocket服务器和客户端的应用。
摘要由CSDN通过智能技术生成

Jetty 开发指导：Jetty Websocket API

原文 csdn tomato__ Jetty 开发指导：Jetty Websocket API

Jetty 提供了功能更强的 WebSocket API，使用一个公共的核心 API 供 WebSockets 的服务端和客户端使用。

他是一个基于 WebSocket 消息的事件驱动的API。

WebSocket 事件

每个 WebSocket 都能接收多种事件：

  1. On Connect Event

    表示 WebSocket 升级成功，WebSocket 现在打开。

    你将收到一个 org.eclipse.jetty.websocket.api.Session 对象，对应这个 Open 事件的 session。

    为通常的 WebSocket，应该紧紧抓住这个 Session，并使用它与 Remote Endpoint 进行交流。

    如果为无状态（Stateless）WebSockets，这个 Session 将被传递到它出现的每一个事件，允许你使用一个 WebSocket 的 1 个实例为多个 Remote Endpoint 提供服务。

  2. On Close Event

    表示 WebSocket 已经关闭。

    每个 Close 事件将有一个状态码（Status Code）（和一个可选的Closure Reason Message）。

    一个通常的 WebSocket 终止将经历一个关闭握手，Local Endpoint 和 Remote Endpoint 都会发送一个 Close 帧表示连接被关闭。

    本地 WebSocket 可以通过发送一个 Close 帧到 Remote Endpoint 表示希望关闭，但 是Remote Endpoint 能继续发送信息直到它送一个 Close 帧为止。这被称之为半开（Half-Open）连接，注意一旦 Local Endpoint 发送了 Close 帧后，它将不能再发送任何 WebSocket 信息。

    在一个异常的终止中，例如一个连接断开或者超时，底层连接将不经历 Close Handshake 就被终止，这也将导致一个 On Close Event（和可能伴随一个 On Error Event）。

  3. On Error Event

    如果一个错误出现，在实现期间，WebSocket 将通过这个事件被通知。

  4. On Message Event

    表示一个完整的信息被收到，准备被你的 WebSocket 处理。

    这能是一个 （UTF8）TEXT 信息或者一个原始的 BINARY 信息。

WebSocket Session

Session对象能被用于：

  1. 获取 WebSocket 的状态

    连接状态（打开或者关闭）

    if(session.isOpen()) {  
  // send message  
}

    连接是安全的吗。

    if(session.isSecure()) {  
  // connection is using 'wss://'  
}

    在升级请求和响应中的是什么。

    UpgradeRequest req = session.getUpgradeRequest();  
String channelName = req.getParameterMap().get("channelName");  

UpgradeRespons resp = session.getUpgradeResponse();  
String subprotocol = resp.getAcceptedSubProtocol();

    本地和远端地址是什么。

    InetSocketAddress remoteAddr = session.getRemoteAddress();

  2. 配置策略

    获取和设置空闲超时时间。

    session.setIdleTimeout(2000); // 2 second timeout

    获取和设置最大信息长度。

    session.setMaximumMessageSize(64*1024); // accept messages up to 64k, fail if larger

  3. 发送信息到 Remote Endpoint

    Session的最重要的特征是获取 org.eclipse.jetty.websocket.api.RemoteEndpoint。

    使用 RemoteEndpoint，你能选择发送 TEXT 或者 BINARY Websocket 信息，或者 WebSocket PING 和 PONG 控制帧。

    a. 阻塞式发送信息

    事实上大部分调用都是阻塞式的，直到发送完成（或者抛出一个异常）才返回。

```
// 实例1 发送二进制信息（阻塞）  
RemoteEndpoint remote = session.getRemote();  

// Blocking Send of a BINARY message to remote endpoint  
ByteBuffer buf = ByteBuffer.wrap(new byte[] { 0x11, 0x22, 0x33, 0x44 });  
try  
{  
    remote.sendBytes(buf);  
}  
catch (IOException e)  
{  
    e.printStackTrace(System.err);  
}  
```

使用 `RemoteEndpoint` 送一个简单的二进制信息。这将阻塞直到信息被发送完成，如果不能发送信息可能将抛出一个 `IOException`。

```
// 实例2 发送文本信息（阻塞）  
RemoteEndpoint remote = session.getRemote();  

// Blocking Send of a TEXT message to remote endpoint  
try  
{  
    remote.sendString("Hello World");  
}  
catch (IOException e)  
{  
    e.printStackTrace(System.err);  
}  
```

使用 `RemoteEndpoint` 发送文本信息。这将阻塞直到信息发送，如果不能发送信息可能将抛出一个 `IOException`。

    b. 发送部分信息

    如果你有一个大的信息需要被发送，并且想分多次发送，每次一部分，你能使用 `RemoteEndpoint` 发送部分信息的方法。仅需要确保你最后发送一个完成发送的信息（isLast == true）

```
// 实例3 发送部分二进制信息（阻塞）  
RemoteEndpoint remote = session.getRemote();  

// Blocking Send of a BINARY message to remote endpoint  
// Part 1  
ByteBuffer buf1 = ByteBuffer.wrap(new byte[] { 0x11, 0x22 });  
// Part 2 (last part)  
ByteBuffer buf2 = ByteBuffer.wrap(new byte[] { 0x33, 0x44 });  
try  
{  
    remote.sendPartialBytes(buf1,false);  
    remote.sendPartialBytes(buf2,true); // isLast is true  
}  
catch (IOException e)  
{  
    e.printStackTrace(System.err);  
}  
```

分两次发送一个二进制信息，使用在 `RemoteEndpoint` 中的部分信息支持方法。这将阻塞直到每次信息发送完成，如果不能发送信息可能抛出一个 `IOException`。

```
// 实例4 发送部分文本信息（阻塞）  
RemoteEndpoint remote = session.getRemote();  

// Blocking Send of a TEXT message to remote endpoint  
String part1 = "Hello";  
String part2 = " World";  
try  
{  
    remote.sendPartialString(part1,false);  
    remote.sendPartialString(part2,true); // last part  
}  
catch (IOException e)  
{  
    e.printStackTrace(System.err);  
}  
```

通过两次发送一个文本信息，使用在 `RemoteEndpoint` 中的部分信息支持方法。这将阻塞直到每次信息发送完成，如果不能发送信息可能抛出一个 `IOException`。

    c. 发送 Ping/Pong 控制帧

    你也能使用 `RemoteEndpoint` 发送 `Ping` 和 `Pong` 控制帧。

```
// 实例5 发送Ping控制帧（阻塞）  
RemoteEndpoint remote = session.getRemote();  

// Blocking Send of a PING to remote endpoint  
String data = "You There?";  
ByteBuffer payload = ByteBuffer.wrap(data.getBytes());  
try  
{  
    remote.sendPing(payload);  
}  
catch (IOException e)  
{  
    e.printStackTrace(System.err);  
}  
```

发送一个 `Ping` 控制帧，附带一个负载 “You There?”（作为一个字节数组负载到达 **Remote Endpoint**）。这将阻塞直到信息发送完成，如果不能发送 `Ping` 帧，可能抛出一个 `IOException`。

```
实例6 送Pong控制帧（阻塞）  
RemoteEndpoint remote = session.getRemote();  

// Blocking Send of a PONG to remote endpoint  
String data = "Yup, I'm here";  
ByteBuffer payload = ByteBuffer.wrap(data.getBytes());  
try  
{  
    remote.sendPong(payload);  
}  
catch (IOException e)  
{  
    e.printStackTrace(System.err);  
}  
```

发送一个 Pong 控制帧，附带一个 "Yup I'm here" 负载（作为一个字节数组负载到达 **Remote Endpoint**）。这将阻塞直到信息被发送，如果不能发送Pong帧，可能抛出一个 `IOException`。

为了正确的使用Pong帧，你应该返回你在 `Ping` 帧中收到的同样的字节数组数据。

    d. 异步发送信息

    也存在来年改革异步发送信息的方法可用：

1. `RemoteEndpoint.sendBytesByFuture`（字节信息）

2. `RemoteEndpoint.sendStringByFuture`（字符串信息）

两个方法都返回一个 `Future<Void>`，使用标准 `Java.util.concurrent.Future` 行为，能被用于测试信息发送的成功和失败。

```
// 实例7 送二进制信息（异步）  
RemoteEndpoint remote = session.getRemote();  

// Async Send of a BINARY message to remote endpoint  
ByteBuffer buf = ByteBuffer.wrap(new byte[] { 0x11, 0x22, 0x33, 0x44 });  
remote.sendBytesByFuture(buf);  
```

使用 `RemoteEndpoint` 发送一个简单的二进制信息。这个信息将被放入发送队列，不知道发送成功或者失败。

```
// 实例8 发送二进制信息（异步，等待直到成功）  
RemoteEndpoint remote = session.getRemote();  

// Async Send of a BINARY message to remote endpoint  
ByteBuffer buf = ByteBuffer.wrap(new byte[] { 0x11, 0x22, 0x33, 0x44 });  
try  
{  
    Future<Void> fut = remote.sendBytesByFuture(buf);  
    // wait for completion (forever)  
    fut.get();  
}  
catch (ExecutionException | InterruptedException e)  
{  
    // Send failed  
    e.printStackTrace();  
}  
```

使用 `RemoteEndpoint` 发送一个简单的二进制信息，追踪 `Future<Void>` 以确定发送成功还是失败。

```
// 实例9 送二进制信息（异步，发送超时）  
RemoteEndpoint remote = session.getRemote();  

// Async Send of a BINARY message to remote endpoint  
ByteBuffer buf = ByteBuffer.wrap(new byte[] { 0x11, 0x22, 0x33, 0x44 });  
Future<Void> fut = null;  
try  
{  
    fut = remote.sendBytesByFuture(buf);  
    // wait for completion (timeout)  
    fut.get(2,TimeUnit.SECONDS);  
}  
catch (ExecutionException | InterruptedException e)  
{  
    // Send failed  
    e.printStackTrace();  
}  
catch (TimeoutException e)  
{  
    // timeout  
    e.printStackTrace();  
    if (fut != null)  
    {  
        // cancel the message  
        fut.cancel(true);  
    }  
}  
```

使用 `RemoteEndpoint` 发送一个简单的二进制信息，追踪 `Future<Void>` 并等待一个有限的时间，如果时间超限则取消该信息。

```
// 实例10 发送文本信息（异步）  
RemoteEndpoint remote = session.getRemote();  

// Async Send of a TEXT message to remote endpoint  
remote.sendStringByFuture("Hello World");  
  ```

怎么使用RemoteEndpoint发送一个简单的文本信息。这个信息将被放到输出队列中，但是你将不知道发送成功还是失败。  

```
// 实例11 发送文本信息（异步，等待直到成功）  
RemoteEndpoint remote = session.getRemote();  

// Async Send of a TEXT message to remote endpoint  
try  
{  
    Future<Void> fut = remote.sendStringByFuture("Hello World");  
    // wait for completion (forever)  
    fut.get();  
}  
catch (ExecutionException | InterruptedException e)  
{  
    // Send failed  
    e.printStackTrace();  
}  
```

使用 `RemoteEndpoint` 发送一个简单的二进制信息，追踪 `Future<Void>` 以直到发送成功还是失败。

```
// 实例12 发送文本信息（异步，发送超时）  
RemoteEndpoint remote = session.getRemote();  

// Async Send of a TEXT message to remote endpoint  
Future<Void> fut = null;  
try  
{  
    fut = remote.sendStringByFuture("Hello World");  
    // wait for completion (timeout)  
    fut.get(2,TimeUnit.SECONDS);  
}  
catch (ExecutionException | InterruptedException e)  
{  
    // Send failed  
    e.printStackTrace();  
}  
catch (TimeoutException e)  
{  
    // timeout  
    e.printStackTrace();  
    if (fut != null)  
    {  
        // cancel the message  
        fut.cancel(true);  
    }  
}  
```

使用 `RemoteEndpoint` 发送一个简单的二进制信息，追踪 `Future<Void>` 并等待有限的时间，如果超时则取消。

使用 WebSocket 注释

WebSocket 的最基本的形式是一个被 Jetty WebSocket API 提供的用注释标记的 POJO。

// 实例13 AnnotatedEchoSocket.java  
package examples.echo;  

import org.eclipse.jetty.websocket.api.Session;  
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;  
import org.eclipse.jetty.websocket.api.annotations.WebSocket;  

/** 
 * Example EchoSocket using Annotations. 
 */  
@WebSocket(maxTextMessageSize = 64 * 1024)  
public class AnnotatedEchoSocket {  

    @OnWebSocketMessage  
    public void onText(Session session, String message) {  
        if (session.isOpen()) {  
            System.out.printf("Echoing back message [%s]%n", message);  
            session.getRemote().sendString(message, null);  
        }  
    }  
}

上面的例子是一个简单的 WebSocket 回送端点，将回送所有它收到的文本信息。

这个实现使用了一个无状态的方法，因此对每个出现的事件 Session 都会被传递到 Message 处理方法中。这将允许你在同多个端口交互时可以重用 AnnotatedEchoSocket 的单实例。

你可用的注释如下：

  1. @WebSocket

    一个必须的类级别的注释。

    标记这个 POJO 作为一个 WebSocket。

    类必须不是 abstract，且是 public。

  2. @OnWebSocketConnect

    一个可选的方法级别的注释。

    标记一个在类中的方法作为 On Connect 事件的接收者。

    方法必须是 public ，且不是 abstract ，返回 void ，并且有且仅有一个 Session 参数。

  3. @OnWebSocketClose

    一个可选的方法级的注释。

    标记一个在类中的方法作为 On Close 事件的接收者。

    方法标签必须是 public ，不是 abstract ，并且返回 void。

    方法的参数包括：

    a. Session session（可选）

    b. int closeCode（必须）

    c. String closeReason（必须）

  4. @OnWebSocketMessage

    一个可选的方法级注释。

    标记在类中的 2 个方法作为接收 On Message 事件的接收者。

    方法标签必须是 public，不是 abstract，并且返回 void。

    为文本信息的方法参数包括：

    a. Session（可选）

    b. String text（必须）

    为二进制信息的方法参数包括：

    a. Session（可选）

    b. byte buf[]（必须）

    c. int offset（必须）

    d. int length（必须）

  5. @OnWebSocketError

    一个可选的方法级注释。

    标记一个类中的方法作为 Error 事件的接收者。

    方法标签必须是 public，不是 abstract，并且返回 void。

    方法参数包括：

    a. Session（可选）

    b. Throwable cause（必须）

  6. @OnWebSocketFrame

    一个可选的方法级注释。

    标记一个类中的方法作为 Frame 事件的接收者。

    方法标签必须是 public，不是 abstract，并且返回 void。

    方法参数包括：

    a. Session（可选）

    b. Frame（必须）

    收到的 Frame 将在这个方法上被通知，然后被 Jetty 处理，可能导致另一个事件，例如 On Close，或者 On Message。对 Frame 的改变将不被 Jetty 看到。

用 WebSocketListener

一个 WebSocket 的基本形式是使用 org.eclipse.jetty.websocket.api.WebSocketListener 处理收到的事件。

// 实例14 ListenerEchoSocket.java  
package examples.echo;  

import org.eclipse.jetty.websocket.api.Session;  
import org.eclipse.jetty.websocket.api.WebSocketListener;  

/** 
 * Example EchoSocket using Listener. 
 */  
public class ListenerEchoSocket implements WebSocketListener {  

    private Session outbound;  

    @Override  
    public void onWebSocketBinary(byte[] payload, int offset, int len) {  
    }  

    @Override  
    public void onWebSocketClose(int statusCode, String reason) {  
        this.outbound = null;  
    }  

    @Override  
    public void onWebSocketConnect(Session session) {  
        this.outbound = session;  
    }  

    @Override  
    public void onWebSocketError(Throwable cause) {  
        cause.printStackTrace(System.err);  
    }  

    @Override  
    public void onWebSocketText(String message) {  
        if ((outbound != null) && (outbound.isOpen())) {  
            System.out.printf("Echoing back message [%s]%n", message);  
            outbound.getRemote().sendString(message, null);  
        }  
    }  
}

如果 listener 做了太多的工作，你能使用 WebSocketAdapter 代替。

使用 WebSocketAdapter

WebSocketListener 的适配器。

// 实例15 AdapterEchoSocket.java  
package examples.echo;  

import java.io.IOException;  
import org.eclipse.jetty.websocket.api.WebSocketAdapter;  

/** 
 * Example EchoSocket using Adapter. 
 */  
public class AdapterEchoSocket extends WebSocketAdapter {  

    @Override  
    public void onWebSocketText(String message) {  
        if (isConnected()) {  
            try {  
                System.out.printf("Echoing back message [%s]%n", message);  
                getRemote().sendString(message);  
            } catch (IOException e) {  
                e.printStackTrace(System.err);  
            }  
        }  
    }  
}

这个类比 WebSocketListener 跟为便利，并提供了有用的方法检查 Session 的状态。

Jetty WebSocket Server API

Jetty 通过 WebSocketServlet 和 servlet 桥接的使用，提供了将 WebSocket 端点到 Servlet 路径的对应。

内在地，Jetty 管理 HTTP 升级到 WebSocket，并且从一个 HTTP 连接移植到一个 WebSocket 连接。

这只有当运行在 Jetty 容器内部时才工作。

Jetty WebSocketServlet

为了通过 WebSocketServlet 对应你的 WebSocket 到一个指定的路径，你将需要扩展 org.eclipse.jetty.websocket.servlet.WebSocketServlet 并指定什么 WebSocket 对象应该被创建。

// 实例16 MyEchoServlet.java  
package examples;  

import javax.servlet.annotation.WebServlet;  
import org.eclipse.jetty.websocket.servlet.WebSocketServlet;  
import org.eclipse.jetty.websocket.servlet.WebSocketServletFactory;  

@SuppressWarnings("serial")  
@WebServlet(name = "MyEcho WebSocket Servlet", urlPatterns = { "/echo" })  
public class MyEchoServlet extends WebSocketServlet {  

    @Override  
    public void configure(WebSocketServletFactory factory) {  
        factory.getPolicy().setIdleTimeout(10000);  
        factory.register(MyEchoSocket.class);  
    }  
}

这个例子将创建一个 Sevlet ，通过 @WebServlet 注解匹配到 Servlet 路径 /echo（或者你能在你的 web 应用的 WEB-INF/web.xml 中手动的配置），当收到 HTTP 升级请求时将创建 MyEchoSocket 实例。

WebSocketServlet.configure(WebSocketServletFactory factory) 是为你的 WebSocket 指定配置的地方。在这个例子中，我们指定一个 10s 的空闲超时，并注册 MyEchoSocket ，即当收到请求时我们想创建的 WebSocket 类，使用默认的 WebSocketCreator 创建。

使用 WebSocketCreator

所有 WebSocket 都是通过你注册到 WebSocketServletFactory 的 WebSocketCreator 创建的。

默认，WebSocketServletFactory 是一个简单的 WebSocketCreator ，能创建一个单例的 WebSocket 对象。 使用 WebSocketCreator.register(Class<?> websocket )告诉 WebSocketServletFactory 应该实例化哪个类（确保它有一个默认的构造器）。

如果你有更复杂的创建场景，你可以提供你自己的 WebSocketCreator，基于在 UpgradeRequest 对象中出现的信息创建的 WebSocket。

// 实例17 MyAdvancedEchoCreator.java  
package examples;  

import org.eclipse.jetty.websocket.servlet.ServletUpgradeRequest;  
import org.eclipse.jetty.websocket.servlet.ServletUpgradeResponse;  
import org.eclipse.jetty.websocket.servlet.WebSocketCreator;  

public class MyAdvancedEchoCreator implements WebSocketCreator {  

    private MyBinaryEchoSocket binaryEcho;  

    private MyEchoSocket textEcho;  

    public MyAdvancedEchoCreator() {  
        this.binaryEcho = new MyBinaryEchoSocket();  
        this.textEcho = new MyEchoSocket();  
    }  

    @Override  
    public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) {  
        for (String subprotocol : req.getSubProtocols()) {  
            if ("binary".equals(subprotocol)) {  
                resp.setAcceptedSubProtocol(subprotocol);  
                return binaryEcho;  
            }  
            if ("text".equals(subprotocol)) {  
                resp.setAcceptedSubProtocol(subprotocol);  
                return textEcho;  
            }  
        }  
        return null;  
    }  
}

这儿我们展示了一个 WebSocketCreator，将利用来自请求的 WebSocket 子协议信息决定什么类型的 WebSocket 应该被创建。

// 实例18 MyAdvancedEchoServlet.java  
package examples;  

import javax.servlet.annotation.WebServlet;  
import org.eclipse.jetty.websocket.servlet.WebSocketServlet;  
import org.eclipse.jetty.websocket.servlet.WebSocketServletFactory;  

@SuppressWarnings("serial")  
@WebServlet(name = "MyAdvanced Echo WebSocket Servlet", urlPatterns = { "/advecho" })  
public class MyAdvancedEchoServlet extends WebSocketServlet {  

    @Override  
    public void configure(WebSocketServletFactory factory) {  
        factory.getPolicy().setIdleTimeout(10000);  
        factory.setCreator(new MyAdvancedEchoCreator());  
    }  
}

当你想要一个定制的 WebSocketCreator 时，使用 WebSocketServletFactory.setCreator(WebSocketCreator creator)，然后 WebSocketServletFactory 将为所有在这个 servlet 上收到的 Upgrade 请求用你的创造器。

一个 WebSocketCreator 还可以用于：

  1. 控制 WebSocket 子协议的选择

  2. 履行任何你认为重要的 WebSocket 源

  3. 从输入的请求获取 HTTP 头

  4. 获取 Servlet HttpSession 对象（如果它存在）

  5. 指定一个响应状态码和原因

如果你不想接收这个请求，简单的从 WebSocketCreator.createWebSocket(UpgradeRequest req, UpgradeResponse resp) 返回 null。

Jetty WebSocket Client API

Jetty 也提供了一个 Jetty WebSocket Client 库，为了更容易的与 WebSocket 服务端交互。
为了在你自己的 Java 项目上使用 Jetty WebSocket Client，你将需要下面的 maven 配置：

<dependency>  
  <groupId>org.eclipse.jetty.websocket</groupId>  
  <artifactId>websocket-client</artifactId>  
  <version>${project.version}</version>  
</dependency>

WebSocketClient

为了使用 WebSocketClient，你将需要连接一个 WebSocket 对象实例到一个指定的目标 WebSocket URI。

// 实例19 SimpleEchoClient.java  
package examples;  

import java.net.URI;  
import java.util.concurrent.TimeUnit;  
import org.eclipse.jetty.websocket.client.ClientUpgradeRequest;  
import org.eclipse.jetty.websocket.client.WebSocketClient;  

/** 
 * Example of a simple Echo Client. 
 */  
public class SimpleEchoClient {  

    public static void main(String[] args) {  
        String destUri = "ws://echo.websocket.org";  
        if (args.length > 0) {  
            destUri = args[0];  
        }  
        WebSocketClient client = new WebSocketClient();  
        SimpleEchoSocket socket = new SimpleEchoSocket();  
        try {  
            client.start();  
            URI echoUri = new URI(destUri);  
            ClientUpgradeRequest request = new ClientUpgradeRequest();  
            client.connect(socket, echoUri, request);  
            System.out.printf("Connecting to : %s%n", echoUri);  
            socket.awaitClose(5, TimeUnit.SECONDS);  
        } catch (Throwable t) {  
            t.printStackTrace();  
        } finally {  
            try {  
                client.stop();  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}

上面的例子连接到一个远端 WebSocket 服务端，并且连接后使用一个 SimpleEchoSocket 履行在 websocket 上的处理逻辑，等待 socket 关闭。

// 实例20 SimpleEchoSocket.java  
package examples;  

import java.util.concurrent.CountDownLatch;  
import java.util.concurrent.Future;  
import java.util.concurrent.TimeUnit;  
import org.eclipse.jetty.websocket.api.Session;  
import org.eclipse.jetty.websocket.api.StatusCode;  
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;  
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;  
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;  
import org.eclipse.jetty.websocket.api.annotations.WebSocket;  

/** 
 * Basic Echo Client Socket 
 */  
@WebSocket(maxTextMessageSize = 64 * 1024)  
public class SimpleEchoSocket {  

    private final CountDownLatch closeLatch;  

    @SuppressWarnings("unused")  
    private Session session;  

    public SimpleEchoSocket() {  
        this.closeLatch = new CountDownLatch(1);  
    }  

    public boolean awaitClose(int duration, TimeUnit unit) throws InterruptedException {  
        return this.closeLatch.await(duration, unit);  
    }  

    @OnWebSocketClose  
    public void onClose(int statusCode, String reason) {  
        System.out.printf("Connection closed: %d - %s%n", statusCode, reason);  
        this.session = null;  
        this.closeLatch.countDown();  
    }  

    @OnWebSocketConnect  
    public void onConnect(Session session) {  
        System.out.printf("Got connect: %s%n", session);  
        this.session = session;  
        try {  
            Future<Void> fut;  
            fut = session.getRemote().sendStringByFuture("Hello");  
            fut.get(2, TimeUnit.SECONDS);  
            fut = session.getRemote().sendStringByFuture("Thanks for the conversation.");  
            fut.get(2, TimeUnit.SECONDS);  
            session.close(StatusCode.NORMAL, "I'm done");  
        } catch (Throwable t) {  
            t.printStackTrace();  
        }  
    }  

    @OnWebSocketMessage  
    public void onMessage(String msg) {  
        System.out.printf("Got msg: %s%n", msg);  
    }  
}

当 SimpleEchoSocket 连接成功后，它发送 2 个文本信息，然后关闭 socket。

onMessage(String msg) 收到来自远端 WebSocket 的响应，并输出他们到控制台。

qyvlik
关注
专栏目录
embedded-jetty-websocket-examples:嵌入式Jetty WebSocket示例
05-13
您可以将2种与Jetty一起使用的API，本机WebSocket API和javax.websocket API。 项目：javax.websocket-example 演示如何使用javax.websocket API创建WebSocket客户端或WebSocket服务器。 项目：native-jetty-...
Jetty容器中使用WebSocket
炒鸡加倍
05-15 6239
这两天因为有需要学习了一下WebSocket。在看了大量博客之后，发现网上实现WebSocket基本都是用tomcat，网上对于所要引用包也是众说纷纭。参考别人代码后搬过来自己的jetty环境下发现各种报错，前台请求都是404，焦头烂额。后来发现一位老哥写的文章，jetty跑websocket踩的坑。原文传送门：https://blog.csdn.net/qq_21413417/article/d...
Jetty之webSocket使用案例
Lovincc的博客
01-09 1万+
Jetty 以前使用的tomcat，没接触过jetty，最近使用到jetty。jetty相对Tomcat，给我第一个使用感觉，那就是加载速度比tomcat快多了。而jetty还有一个最大的优点是tomcat不能达到的优势。 jetty倡导嵌入式开发，什么叫嵌入式开发呢？ 与tomcat作个比较，tomcat相当于一个容器，我们需要把自己的web项目放入到tomcat指定目录中，
WebSocket通信深度解析与实战
最新发布
weixin_42611310的博客
10-11 870
本文还有配套的精品资源，点击获取 简介：本文深入探讨了WebSocket技术，它允许客户端和服务器之间建立持久性连接进行双向通信，适用于实时应用如在线游戏、股票交易等。文章还讨论了如何通过WebSocket远程控制浏览器、实现双向消息传递，以及WebSocket通信的工作流程和执行上下文。其中涉及WebSocket API、HTTP升级过程、帧格式、安全性、跨域策略、服务器...
Jetty开发指导：Jetty Websocket API
热门推荐
宁静致远
08-07 2万+
Jetty WebSocket API使用 Jetty提供了功能更强的WebSocket API，使用一个公共的核心API供WebSockets的服务端和客户端使用。 他是一个基于WebSocket消息的事件驱动的API。 WebSocket事件 每个WebSocket都能接收多种事件： On Connect Event  表示WebSocket升级成功，WebSocket现在打开。
java jetty websocket_websocket基于jetty9的java服务端＋客户端实现
weixin_33941707的博客
02-16 676
接上文，“websocket协议简析”。分享一下基于jetty9实现java版的webcoket服务端和客户端demo。没有理论，话不多说，代码奉上。准备工作：新建maven工程，pom文件引入：org.eclipse.jetty.websocketwebsocket-client9.4.6.v20170531org.eclipse.jetty.websocketwebsocket-server9...
SpringBoot使用Jetty内置的WebSocket实现简单前后端通信
重复生活的博客
01-08 2363
提示: 本文章适用于通过内置Jetty容器或者外部Jetty容器运行项目的情况
websocket-api-9.4.11.v20180605-API文档-中文版.zip
06-26
Maven坐标：org.eclipse.jetty.websocket:websocket-api:9.4.11.v20180605； 标签：eclipse、jetty、websocket、api、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，...
websocket+tomcat+jetty+netty
12-29
Jetty对WebSocket的支持非常全面，它实现了WebSocket API，使得开发者可以方便地在Jetty服务器上构建WebSocket应用。 Netty则是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端...
websocket-api-9.4.43.v20210629-API文档-中文版.zip
06-05
Maven坐标：org.eclipse.jetty.websocket:websocket-api:9.4.43.v20210629； 标签：eclipse、jetty、websocket、api、中文文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，...
Spring-Boot-Jetty-WebSocket-Example:如何使用Spring Boot配置Jetty WebSocket的基本示例
05-18
Spring Boot简化了Java应用的开发，包括WebSocket的配置和使用。我们将讨论以下几个关键知识点： 1. **Spring Boot简介**：Spring Boot是Spring框架的扩展，它提供了开箱即用的功能，简化了创建独立的、生产级别的...
jetty实现websocket功能
12-10
使用jetty实现websocket功能，jetty已经集成了websocket的标准方法。
java jetty websocket_java – Jetty 8.1.1 Websocket客户端握手
weixin_29477915的博客
02-24 370
一些好消息和一些坏消息.一,好消息：要设置Sec-WebSocket-Protocol标头,请使用以下命令.client.setProtocol("xsCrossfire");在使用client.open()之前接下来,坏消息：使用Jetty 8.x,您无法设置任意非websocket标头.这是由于WebSocket的早期实验草稿是如何编写的.根据早期草案规范,您根本不允许设置任意标头,因此Jet...
Jetty搭建WebSocket
stevenwuuuu的博客
05-04 2566
//收到Client端的消息会回调到这里import org.eclipse.jetty.websocket.api.Session; import org.eclipse.jetty.websocket.api.WebSocketListener; public class MyWebSocketListener implements WebSocketListener { private ...
Jetty开发指导：WebSocket介绍
宁静致远
08-06 3338
WebSocket是一个新的基于HTTP的双向通讯的协议。 它是基于低级别的框架协议，使用UTF-8 TEXT或者BINARY格式传递信息。 在WebSocket中的单个信息可以是任何长度（然而底层框架有单帧63bits的限制）。 发送的信息数量不受限制。 信息被持续的发送，基础协议不支持交叉的信息。 一个WebSocket连接经历一些基本的状态改变：  1）CONNECTING：HT
Tomcat和Jetty对WebSocket的支持
lrenjundk的专栏
10-09 9453
公司项目需要，了解了下目前几种支持WebSocket的框架。以前用jWebSocket做过一些项目，相对来说，改jWebSocket的源码略复杂，也不是一天两天能搞定的。一调研才发现，现在很多主流的web框架都已经开始支持WebSocket了，不得不感慨时间太快，科技进步太快，在微策略的几年真的荒废了。不多说，先记录下今天的研究。 Tomcat：        J2EE下面用的最多的容
jetty websocket实现聊天+心跳保持连接
辰小白
03-22 1402
效果图 1.配置maven需要的jar包-pom.xml <dependency> <groupId>org.eclipse.jetty.websocket</groupId> <artifactId>websocket-server</artifactId> <version&...
java jetty websocket_在Jetty中使用websocket
weixin_35565325的博客
02-16 818
1.序言在工作中，我们有时候需要使用能与前端实时通信传输以通信，这种技术就是由Socket实现的，而Socket又有短连接和长连接之分，长连接技术就是我们今天要介绍的websocket。2.websocket服务启动设置首先创建一个基于HTTP协议的jetty Servlet server，Jetty通过WebSocketServlet和servlet桥接的使用，提供了将WebSocket端点到...
Go语言实现TCP服务端和客户端
ccf19881030的专栏
10-21 832
Go语言实现TCP服务端和客户端Go语言实现TCP通信TCP协议TCP服务端TCP客户端 本文转载自Go语言实现TCP通信 Go语言实现TCP通信 TCP协议 TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议，是一种面向连接（连接导向）的、可靠的、基于字节流的传输层（Transport layer）通信协议，因为是面向连接的协议，数据像水流一样传输，会存在黏包问题。 TCP服务端 一个TCP服务端可以同时连接很多个客户端
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值