javax.websocket.OnMessage Java Examples

@OnMessage
public void handleMessage(Session session, final ByteBuffer message, boolean last) throws IOException {
    if(out == null) {
        out = session.getBasicRemote().getSendStream();
    }
    byte[] data = new byte[message.remaining()];
    message.get(data);
    out.write(data);

    if(last) {
        out.close();
        out = null;
    } else {
        out.flush();
    }
}
 

@OnMessage
public void echoTextMessage(Session session, String msg, boolean last) {
    if (sb == null) {
        sb = new StringBuilder();
    }
    sb.append(msg);
    if (last) {
        // Before we send the next message, have to wait for the previous
        // message to complete
        try {
            f.get();
        } catch (InterruptedException | ExecutionException e) {
            // Let the container deal with it
            throw new RuntimeException(e);
        }
        f = session.getAsyncRemote().sendText(sb.toString());
        sb = null;
    }
}
 

@OnMessage
public void onMessage(Session session, String message) {
    log.info("Message received: " + message);
    events.onMessageCalled.countDown();
    awaitLatch(events.onMessageWait, "onMessageWait not triggered");

    if (events.onMessageSends) {
        try {
            int count = 0;
            // The latches above are meant to ensure the correct
            // sequence of events but in some cases, particularly with
            // APR, there is a short delay between the client closing /
            // resetting the connection and the server recognising that
            // fact. This loop tries to ensure that it lasts much longer
            // than that delay so any close / reset from the client
            // triggers an error here.
            while (count < 10) {
                count++;
                session.getBasicRemote().sendText("Test reply");
                Thread.sleep(500);
            }
        } catch (IOException | InterruptedException e) {
            // Expected to fail
        }
    }
}
 

@OnMessage
public void echoTextMessage(Session session, String msg, boolean last) {
    if (sb == null) {
        sb = new StringBuilder();
    }
    sb.append(msg);
    if (last) {
        // Before we send the next message, have to wait for the previous
        // message to complete
        try {
            f.get();
        } catch (InterruptedException | ExecutionException e) {
            // Let the container deal with it
            throw new RuntimeException(e);
        }
        f = session.getAsyncRemote().sendText(sb.toString());
        sb = null;
    }
}
 

@OnMessage
public void echoBinaryMessage(byte[] msg, Session session, boolean last)
        throws IOException {
    if (stream == null) {
        stream = session.getBasicRemote().getSendStream();
    }
    stream.write(msg);
    stream.flush();
    if (last) {
        stream.close();
        stream = null;
    }
}
 

@OnMessage
public void echoBinaryMessage(Session session, ByteBuffer bb,
        boolean last) {
    try {
        if (session.isOpen()) {
            session.getBasicRemote().sendBinary(bb, last);
        }
    } catch (IOException e) {
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}
 

@OnMessage
public void echoTextMessage(Session session, String msg, boolean last) {
    try {
        if (session.isOpen()) {
            session.getBasicRemote().sendText(msg, last);
        }
    } catch (IOException e) {
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}
 

@OnMessage(maxMessageSize = MAX_SIZE)
public void echoTextMessage(Session session, String msg) {
    try {
        session.getBasicRemote().sendText(msg);
    } catch (IOException e) {
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}
 

@SuppressWarnings("unused")
@OnMessage
public void echoTextMessage(Session session, String msg, boolean last) {
    try {
        synchronized (monitor) {
            while (block) {
                monitor.wait();
            }
        }
    } catch (InterruptedException e) {
        // Ignore
    }
}
 

@OnMessage(maxMessageSize = MAX_SIZE)
public void echoBinaryMessage(Session session, ByteBuffer msg) {
    try {
        session.getBasicRemote().sendBinary(msg);
    } catch (IOException e) {
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}
 

@OnMessage
public void echoTextMessage(Session session, @SuppressWarnings("unused") String msg) {
    try {
        session.getBasicRemote().getSendWriter();
        // Simulate an error
        throw new RuntimeException();
    } catch (IOException e) {
        // Should not happen
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}
 

@OnMessage
public void echoTextMessage(Session session, String msg) {
    try {
        session.getBasicRemote().sendText(msg);
    } catch (IOException e) {
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}
 

@OnMessage
public String onMessage(String message, Session session) throws IOException {
    received.add(message);
    session.getAsyncRemote().setBatchingAllowed(true);
    session.getAsyncRemote().sendText(MESSAGE_ONE);
    return MESSAGE_TWO;
}
 

@OnMessage
public void onMessage(String msg) {
    if (!failed && !PASS.equals(msg)) {
        failed = true;
    }
    msgCount.incrementAndGet();
}
 

@OnMessage
public String onMessage(@SuppressWarnings("unused") String msg) {
    if (Thread.currentThread().getContextClassLoader() instanceof WebappClassLoaderBase) {
        return PASS;
    } else {
        return FAIL;
    }
}
 

@OnMessage(maxMessageSize = MAX_SIZE)
public void echoBinaryMessage(Session session, ByteBuffer msg) {
    try {
        session.getBasicRemote().sendBinary(msg);
    } catch (IOException e) {
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}
 

@OnMessage
public void incoming(String message) {
    // Never trust the client
    String filteredMessage = String.format("%s: %s",
            nickname, HTMLFilter.filter(message.toString()));
    broadcast(filteredMessage);
}
 

@OnMessage
public void echoBinaryMessage(byte[] msg, Session session, boolean last)
        throws IOException {
    if (stream == null) {
        stream = session.getBasicRemote().getSendStream();
    }
    stream.write(msg);
    stream.flush();
    if (last) {
        stream.close();
        stream = null;
    }
}
 

@SuppressWarnings("unused")
@OnMessage
public void echoBinaryMessage(Session session, ByteBuffer msg,
        boolean last) {
    try {
        synchronized (monitor) {
            while (block) {
                monitor.wait();
            }
        }
    } catch (InterruptedException e) {
        // Ignore
    }
}
 

@OnMessage
public void onMessage(String message) {
    //todo 现在有个定时任务刷，应该去掉
	log.debug("【websocket消息】收到客户端消息:"+message);
	JSONObject obj = new JSONObject();
	obj.put("cmd", "heartcheck");//业务类型
	obj.put("msgTxt", "心跳响应");//消息内容
	session.getAsyncRemote().sendText(obj.toJSONString());
}
 

@OnMessage
public void onMessage(Session session, String msg) throws IOException {

    if (started) {
        return;
    }
    synchronized (this) {
        if (started) {
            return;
        } else {
            started = true;
        }
    }

    System.out.println("Received " + msg + ", now sending data");

    session.getUserProperties().put(
            org.apache.tomcat.websocket.Constants.BLOCKING_SEND_TIMEOUT_PROPERTY,
            Long.valueOf(SEND_TIME_OUT_MILLIS));

    Basic remote = session.getBasicRemote();
    remote.setBatchingAllowed(true);

    for (int i = 0; i < MESSAGE_COUNT; i++) {
        remote.sendText(MESSAGE);
        if (i % (MESSAGE_COUNT * 0.4) == 0) {
            remote.setBatchingAllowed(false);
            remote.setBatchingAllowed(true);
        }
    }

    // Flushing should happen automatically on session close
    session.close();
}
 

@OnMessage
public void echoTextMessage(Session session, String msg, boolean last) {
    try {
        if (session.isOpen()) {
            session.getBasicRemote().sendText(msg, last);
        }
    } catch (IOException e) {
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}
 

@OnMessage
public void echoBinaryMessage(Session session, ByteBuffer bb,
        boolean last) {
    try {
        if (session.isOpen()) {
            session.getBasicRemote().sendBinary(bb, last);
        }
    } catch (IOException e) {
        try {
            session.close();
        } catch (IOException e1) {
            // Ignore
        }
    }
}
 

@OnMessage
public void handleMessage(Session session, final String message) throws IOException {
    if(closed != null) {
        System.out.println("closed message " + closed);
    }
    if(message.equals("close")) {
        closed = Thread.currentThread().getName();
        session.close();
        return;
    }
    MESSAGES.add(message);
}
 

@OnMessage
public void onMessage(String message) {
	//log.info("【websocket消息】收到客户端消息:"+message);
	JSONObject obj = new JSONObject();
	obj.put("cmd", "heartcheck");//业务类型
	obj.put("msgTxt", "心跳响应");//消息内容
	session.getAsyncRemote().sendText(obj.toJSONString());
}
 

@OnMessage
public void handleMessage(final String message) throws IOException {
    QUEUE.add(message);
    if(message.equals("app-error")) {
        throw new RuntimeException("an error");
    } else if(message.equals("io-error")) {
        throw new IOException();
    }
}
 

@OnMessage
public void handleMessage(final String message, Session session, boolean last) throws IOException {
    if (writer == null) {
        writer = session.getBasicRemote().getSendWriter();
    }
    writer.write(message);
    if (last) {
        writer.close();
        writer = null;
    }
}
 

@OnMessage
public void handleMessage(final byte[] message, Session session, boolean last) throws IOException {
    if (stream == null) {
        stream = session.getBasicRemote().getSendStream();
    }
    stream.write(message);
    stream.flush();
    if (last) {
        stream.close();
        stream = null;
    }
}
 

@OnMessage
public String text(String message, Session session) throws IOException {
    if(message.equals("close")) {
        session.close();
        return null;
    }
    return "ECHO-" + message;
}
 

@OnMessage
public void onMessage(String message) {
    //todo 现在有个定时任务刷，应该去掉
	log.debug("【websocket消息】收到客户端消息:"+message);
	JSONObject obj = new JSONObject();
	obj.put(WebsocketConst.MSG_CMD, WebsocketConst.CMD_CHECK);//业务类型
	obj.put(WebsocketConst.MSG_TXT, "心跳响应");//消息内容
	session.getAsyncRemote().sendText(obj.toJSONString());
}