web-dev-qa-db-fra.com

Serveur prêt pour la production WebSockets en Java?

[~ # ~] modifier [~ # ~] : suppression de la référence à C # car la seule réponse acceptée concerne Java. Si quelqu'un a besoin d'informations sur l'implémentation du serveur websocket en C #, posez une nouvelle question.

Connaissez-vous le framework "prêt pour la production" pour la création de WebSockets Server en Java? J'ai trouvé une bibliothèque http://nugget.codeplex.com/ mais je ne savais pas comment elle était stable et rapide.

javawebsocket
28
Edward83

Pour Java, consultez ceci article informatif . Copiez-collez à partir de là:

Parmi ces options, je suppose que Jetty et La résine sont les plus matures et stable. Cependant, il est toujours bon de faire vos propres tests.

35
Neeme Praks

La réponse acceptée remonte à 3 ans, avec la sortie récente de JEE7, désormais tous les conteneurs Web qui implémentent le serveur 3.1 prendront en charge Websocket via le package API standard ( javax.websocket ).

Le code suivant montre comment implémenter websocket à l'aide de JEE7:

import Java.util.logging.Level;
import Java.util.logging.Logger;
import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint(value = "/chat")
public class ChatServer {

    private static final Logger LOGGER = 
            Logger.getLogger(ChatServer.class.getName());

    @OnOpen
    public void onOpen(Session session) {
        LOGGER.log(Level.INFO, "New connection with client: {0}", 
                session.getId());
    }

    @OnMessage
    public String onMessage(String message, Session session) {
        LOGGER.log(Level.INFO, "New message from Client [{0}]: {1}", 
                new Object[] {session.getId(), message});
        return "Server received [" + message + "]";
    }

    @OnClose
    public void onClose(Session session) {
        LOGGER.log(Level.INFO, "Close connection for client: {0}", 
                session.getId());
    }

    @OnError
    public void onError(Throwable exception, Session session) {
        LOGGER.log(Level.INFO, "Error for client: {0}", session.getId());
    }
}

Exemple en détails ici .

Conteneur Web prenant en charge Websocket:

46
Pau Kiat Wee

L'option Vert.x mérite également d'être envisagée.

La création d'un serveur WS peut être aussi simple que

vertx.websocketHandler(new Handler<ServerWebSocket>() {
    public void handle(ServerWebSocket ws) {
        // A WebSocket has connected!
    }
}).listen(8080);

ou

vertx.createHttpServer().websocketHandler(new Handler<ServerWebSocket>() {
        @Override
        public void handle(final ServerWebSocket ws) {
            logger.info("ws connection established with " + ws.remoteAddress());
            ws.dataHandler(new Handler<Buffer>() {
                @Override
                public void handle(Buffer data) {
                    JsonObject item = new JsonObject(data.toString());
                    logger.info("data in -> " + item.encodePrettily());
                       // if you want to write something back in response to the client
                    //ws.writeTextFrame(...);
            }
            });
        }
    }).listen(port, new Handler<AsyncResult<HttpServer>>() {
        @Override
        public void handle(AsyncResult<HttpServer> event) {
            logger.info("ws server is up and listening on port " + port);
        }
    });

Pour plus de détails, regardez ici http://vertx.io/docs/vertx-core/Java/#_websockets

Ainsi, on peut écrire son propre serveur WebSocket avec Vert.x, le conditionner en FatJar et l'exécuter seul.

Ou vous pouvez intégrer Vert.x env. dans votre application et déployez votre verticle (qui implémente le serveur ws) par programme.

Le serveur Web Undertow de JBoss est une autre alternative. Qui est facilement intégrable dans les applications.

Ajoutez ces dépendances:

<dependency>
  <groupId>io.undertow</groupId>
  <artifactId>undertow-servlet</artifactId>
  <version>${version.io.undertow}</version>
</dependency>

<dependency>
  <groupId>io.undertow</groupId>
  <artifactId>undertow-websockets-jsr</artifactId>
  <version>${version.io.undertow}</version>
</dependency>

Et voici un exemple de serveur WS:

Undertow server = Undertow.builder()
            .addHttpListener(8080, "localhost")
            .setHandler(path()
                    .addPrefixPath("/myapp", websocket(new WebSocketConnectionCallback() {

                        @Override
                        public void onConnect(WebSocketHttpExchange exchange, WebSocketChannel channel) {
                            channel.getReceiveSetter().set(new AbstractReceiveListener() {

                                @Override
                                protected void onFullTextMessage(WebSocketChannel channel, BufferedTextMessage message) {
                                    final String messageData = message.getData();
                                    for (WebSocketChannel session : channel.getPeerConnections()) {
                                        WebSockets.sendText(messageData, session, null);
                                    }
                                }
                            });
                            channel.resumeReceives();
                        }
                    }))
            .build();

    server.start();
4
aymens

Jetez un œil au Bristleback Framework . Il s'agit d'une superposition de haut niveau pour les serveurs Websocket couramment utilisés Java, comme Jetty, Netty ou Tomcat. Si vous aimez Spring Framework, vous devez absolument essayer Bristleback!

Avertissement: je suis un contributeur dans le projet Bristleback Framework.

2
voitec

JETÉE

J'ai passé la semaine dernière à réfléchir à la façon de créer un serveur WebSocket. J'ai enfin eu quelque chose à travailler, j'espère que cela vous aidera. Il utilise des bibliothèques de Jetty (jars).

Fichier WebRTC_IceServer.Java

package com.evanstools;
import org.Eclipse.jetty.server.*;
import org.Eclipse.jetty.websocket.server.*;
public class WebRTC_IceServer{
public static void main(String[] args){
try{
////////////////////////
if(args.length == 0){
  System.out.printf("%s%n","WebRTC_IceServer [port]");
  return;
}
Server server = new Server(Integer.parseInt(args[0]));
WebSocketHandler.Simple webSocketHandlerSimple = new WebSocketHandler.Simple(WebsocketPOJO.class);
server.setHandler(webSocketHandlerSimple);
server.start();
server.join();
////////////////////////
}catch(Exception w){w.printStackTrace();}
}
}

Fichier WebsocketPOJO.Java

package com.evanstools;
import org.Eclipse.jetty.websocket.api.annotations.*;
import org.Eclipse.jetty.websocket.api.Session;
//The class must be not abstract and public.
@WebSocket
public class WebsocketPOJO{
//Flags one method in the class as receiving the On Connect event.
//Method must be public, not abstract, return void, and have a single Session parameter.
@OnWebSocketConnect
public void onWebSocketConnect(Session session){
    System.out.printf("%s%n","test client connected");
}
//Flags one method in the class as receiving the On Close event.
//Method signature must be public, not abstract, and return void.
//The method parameters:
////Session (optional)
////int closeCode (required)
////String closeReason (required)
@OnWebSocketClose
public void OnWebSocketClose(Session session,int closeCode,String closeReason){}
//Flags up to 2 methods in the class as receiving On Message events.
//You can have 1 method for TEXT messages, and 1 method for BINARY messages.
//Method signature must be public, not abstract, and return void.
//The method parameters for Text messages:
////Session (optional)
////String text (required)
//The method parameters for Binary messages:
////Session (optional)
////byte buf[] (required)
////int offset (required)
////int length (required)
@OnWebSocketMessage
public void onWebSocketMessageString(Session session, String text){}
//Flags one method in the class as receiving Error events from the WebSocket implementation.
//Method signatures must be public, not abstract, and return void.
//The method parameters:
////Session (optional)
////Throwable cause (required)
//@OnWebSocketError
//Flags one method in the class as receiving Frame events from the WebSocket implementation after they have been processed by any extensions declared during the Upgrade handshake.
//Method signatures must be public, not abstract, and return void.
//The method parameters:
////Session (optional)
///Frame (required)
//The Frame received will be notified on this method, then be processed by Jetty, possibly resulting in another event, such as On Close, or On Message. Changes to the Frame will not be seen by Jetty.
//@OnWebSocketFrame
}
0
user28775

Apache Tomcat 8. implémente l'API WebSockets 1.1 ( JSR-356 ). Vous pouvez même jouer avec des exemples après l'installation en accédant au dossier d'exemples: il y a le chat d'écho et le jeu de serpent.

0
timeking