Websockets with multiple datas in onMessage annotation

Question

I am using websockets. I want to use multiple @onMessage overloaded methods with different data types. In Client side i a have the following methods ``` @OnMessage public void onMessage(Message message) { System.out.println(message.getContent()+":"+message.getSubject()); } @OnMessage public void onMessage(String message) { System.out.println(message); } ``` Where Message is pojo class and decoded and encoded it. In server side ``` @OnMessage public void onMessage(String msg, Session session) { try { System.out.println("Receive Message:" + msg); session.getBasicRemote().sendText("{\"subject\":\"This is subject1\",\"content\":\"This is content1\"}"); session.getBasicRemote().sendText("This is Example Test"); } catch (IOException ex) { Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex); } } ``` I am getting the following error ``` javax.websocket.DeploymentException: Class: clientwebsocket.MyClient. Text MessageHandler already registered. at org.glassfish.tyrus.core.Err…

Accepted Answer

This is not possible. JSR 356 defines clearly that there can be only one message handler per text message, one per binary message and one per PongMessage. See @OnMessage javadoc:

======

This method level annotation can be used to make a Java method receive incoming web socket messages. Each websocket endpoint may only have one message handling method for each of the native websocket message formats: text, binary and pong. Methods using this annotation are allowed to have parameters of types described below, otherwise the container will generate an error at deployment time.

The allowed parameters are:

- Exactly one of any of the following choices

- if the method is handling text messages:

- java.lang.String to receive the whole message

- Java primitive or class equivalent to receive the whole message converted to that type

- String and boolean pair to receive the message in parts

- java.io.Reader to receive the whole message as a blocking stream

- any object parameter for which the endpoint has a text decoder (Decoder.Text or Decoder.TextStream).

- if the method is handling binary messages:

- byte[] or java.nio.ByteBuffer to receive the whole message

- byte[] and boolean pair, or java.nio.ByteBuffer and boolean pair to receive the message in parts

- java.io.InputStream to receive the whole message as a blocking stream

- any object parameter for which the endpoint has a binary decoder (Decoder.Binary or Decoder.BinaryStream).

- if the method is handling pong messages:

- PongMessage for handling pong messages

- and Zero to n String or Java primitive parameters annotated with the javax.websocket.server.PathParam annotation for server endpoints.

- and an optional Session parameter

The parameters may be listed in any order.

The method may have a non-void return type, in which case the web socket runtime must interpret this as a web socket message to return to the peer. The allowed data types for this return type, other than void, are String, ByteBuffer, byte[], any Java primitive or class equivalent, and anything for which there is an encoder. If the method uses a Java primitive as a return value, the implementation must construct the text message to send using the standard Java string representation of the Java primitive unless there developer provided encoder for the type configured for this endpoint, in which case that encoder must be used. If the method uses a class equivalent of a Java primitive as a return value, the implementation must construct the text message from the Java primitive equivalent as described above.

Developers should note that if developer closes the session during the invocation of a method with a return type, e method will complete but the return value will not be delivered to the remote endpoint. The send failure will be passed back into the endpoint's error handling method.

For example:

```
 @OnMessage
 public void processGreeting(String message, Session session) {
     System.out.println("Greeting received:" + message);
 }
 
```

For example:

```
 @OnMessage
 public void processUpload(byte[] b, boolean last, Session session) {
     // process partial data here, which check on last to see if these is more on the way
 }
 
```

Developers should not continue to reference message objects of type java.io.Reader, java.nio.ByteBuffer or java.io.InputStream after the annotated method has completed, since they may be recycled by the implementation.

Websockets with multiple datas in onMessage annotation

Solution

Problem