Java WebSocket端点注释中编码器列表或解码器列表的用例是什么？

我正在学习TyrusWebSocket的实现。但我不明白为什么以及何时我们需要websocket端点中的多个编码器或解码器。例如：

@ServerEndpoint(value = "/subscribe", decoders = { TextStreamMessageDecoder.class }, encoders = { TextStreamMessageEncoder.class })
public class ChatServerEndPoint {
......
}

解码器和编码器列表中只有一个解码器和编码器。由于这些是解码器或编码器阵列，因此我可以一次使用多种类型的编码器或解码器。但在随后提到的api描述中

websocket运行时将使用列表中第一个能够解码消息的解码器，而忽略其余的解码器。 如果它总是使用列表的第一个元素，那么WebSockets API中多个编码器或解码器的用例是什么

编辑后 客户端发送到服务器： 客户端使用MessageEncoder类发送消息，而服务器有两个编码器和解码器，包括TextStreamMessageEncoder或decoder和MessageEncoder或decoder。那么，当客户端向服务器发送消息时，将使用哪个解码器呢？

解码器确实有，所以您可以有一个解码json，另一个用于解码hocon等

Ad编码器-它们是根据泛型类型选择的-运行时应始终根据您尝试发送的类型（编码）选择“最接近”的编码器

---

此外，您可以有多个方法类型-text/binary，因此您可能需要注册测试和二进制解码器。

根据第一个答案，我将其总结为：

让我们创建两种类型的编码器和解码器，包括文本和二进制流

public class JsonMessageEncoder implements Encoder.Text<JsonWrapper> {

    public String encode(JsonWrapper jsonWrapper) throws EncodeException {
        return jsonWrapper.getJson().toString();
    }

}

public class JsonMessageDecoder implements Decoder.Text<JsonWrapper> {

    public JsonWrapper decode(String s) throws DecodeException {
        JsonObject json = Json.createReader(new StringReader(s)).readObject();
        System.out.println("JsonWrapper decode: "+json);
        return new JsonWrapper(json);
    }

    public boolean willDecode(String s) {
        // TODO Auto-generated method stub
        try {
            Json.createReader(new StringReader(s)).read();
            return true;
        } catch (JsonException ex) {
            ex.printStackTrace();
            return false;
        }
    }

}

public class BinaryStreamMessageEncoder implements Encoder.BinaryStream<BinaryMessage>{

    public void encode(BinaryMessage object, OutputStream os)
            throws EncodeException, IOException {
        ObjectOutput objectOutput = new ObjectOutputStream(os);
        objectOutput.writeObject(object);

    }

}

public class BinaryStreamMessageDecoder implements Decoder.BinaryStream<BinaryMessage>{

    public BinaryMessage decode(InputStream is) throws DecodeException,
            IOException {
        ObjectInput objectInput = new ObjectInputStream(is);
        try {
            BinaryMessage binaryMessage= (BinaryMessage) objectInput.readObject();
            return binaryMessage;
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;

    }

}

客户端向服务器发送消息： 服务器向客户端发送消息： 在示例中：我们对每个端点使用两个@OnMessage方法，其中一个用于文本类型，另一个用于二进制流类型解码器。客户端和服务器相互发送不同类型的消息，其中客户端发送具有一个字符串属性的BinaryMessage，而服务器发送Json对象。所以运行时将检测通信时将使用哪种类型的解码器和编码器

输出客户端： JsonWrapper解码：{“id”：1，“消息”：“已接受连接”}

ServerMessage[id=1，message=已接受连接]

输出服务器：

---

BinaryMessage[name=Binary Message]

如果ClientEndPoint只有TextStream消息解码器，而ServerEndPoint只有文本消息解码器，则消息是否应在两侧正确解码。对我来说，这是正确的解码。但我不知道原因。它们正在解码相同的JsonWrapper类，但编码类型不同。你能解释一下吗？请分享你的解码器实现和发送消息的代码-服务器端和客户端。我不知道为什么您的案例不起作用，因为您没有共享所需的详细信息。我通过添加所有类编辑了我的问题。您根本没有使用编码器/解码器-两个@OnMessage方法都使用“字符串消息”，这是由Tyrus隐式处理的。您只需删除它（大大降低了代码的复杂度），您仍然会得到相同的行为。您的回答让我清楚地了解了编码器和解码器。我在这里用例子写了完整的答案。谢谢

 try {
            Gson gson = new Gson();
            session.getBasicRemote().sendObject(
                    gson.toJson(new ServerMessage(1, "connection accepted")));
        } catch (EncodeException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
    }

try {
        Gson gson = new Gson();
        session.getBasicRemote().sendObject(
                gson.toJson(new ClientMessage(1, "FirstName")));
    } catch (EncodeException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
}

public class JsonMessageEncoder implements Encoder.Text<JsonWrapper> {

    public String encode(JsonWrapper jsonWrapper) throws EncodeException {
        return jsonWrapper.getJson().toString();
    }

}

public class JsonMessageDecoder implements Decoder.Text<JsonWrapper> {

    public JsonWrapper decode(String s) throws DecodeException {
        JsonObject json = Json.createReader(new StringReader(s)).readObject();
        System.out.println("JsonWrapper decode: "+json);
        return new JsonWrapper(json);
    }

    public boolean willDecode(String s) {
        // TODO Auto-generated method stub
        try {
            Json.createReader(new StringReader(s)).read();
            return true;
        } catch (JsonException ex) {
            ex.printStackTrace();
            return false;
        }
    }

}

public class BinaryStreamMessageEncoder implements Encoder.BinaryStream<BinaryMessage>{

    public void encode(BinaryMessage object, OutputStream os)
            throws EncodeException, IOException {
        ObjectOutput objectOutput = new ObjectOutputStream(os);
        objectOutput.writeObject(object);

    }

}

public class BinaryStreamMessageDecoder implements Decoder.BinaryStream<BinaryMessage>{

    public BinaryMessage decode(InputStream is) throws DecodeException,
            IOException {
        ObjectInput objectInput = new ObjectInputStream(is);
        try {
            BinaryMessage binaryMessage= (BinaryMessage) objectInput.readObject();
            return binaryMessage;
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;

    }

}

@ClientEndpoint(decoders = { JsonMessageDecoder.class, BinaryStreamMessageDecoder.class}, encoders = { JsonMessageEncoder.class, BinaryStreamMessageEncoder.class })
public class ChatClientEndPoint {
@OnMessage
    public void onMessage(JsonWrapper message, Session session) {
        logger.info("JsonWrapper onMessage: " + session.getId());
        if (this.messageHandler != null)
            this.messageHandler.handleMessage(message);

    }

    @OnMessage
    public void onMessage(BinaryMessage message, Session session) {
        logger.info("BinaryMessage onMessage: " + session.getId());
        if (this.messageHandler != null)
            this.messageHandler.handleMessage(message);

    }
}

@ServerEndpoint(value = "/subscribe", decoders = { JsonMessageDecoder.class, BinaryStreamMessageDecoder.class}, encoders = { JsonMessageEncoder.class,BinaryStreamMessageEncoder.class })
public class ChatServerEndPoint {
@OnMessage
    public void onMessage(JsonWrapper message, Session session) {
        logger.info("JsonWrapper onMessage: " + session.getId());
        // logger.info("onMessage: " + message.toString());
        Gson gson = new Gson();
        ClientMessage clientMessage = gson.fromJson(message.getJson().toString(),
                ClientMessage.class);
        System.out.println(clientMessage.toString());
    }
    @OnMessage
    public void onMessage(BinaryMessage message, Session session) {
        logger.info("BinaryMessage onMessage: " + session.getId());
        System.out.println(message.toString());
    }
}

try {
            session.getBasicRemote().sendObject(new BinaryMessage("Binary Message"));
        } catch (EncodeException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

try {
            session.getBasicRemote().sendObject(
                    gson.toJson(new ServerMessage(1, "connection accepted")));
        } catch (EncodeException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }