WebSockets production ready server en Java?

la réponse acceptée date de 3 ans, avec la récente sortie de JEE7, maintenant tous les conteneurs Web qui implémentent servert 3.1 supporteront websocket via L'API standard ( javax.websocket).

Le code suivant montre un exemple comment mettre en œuvre 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 dans les détails ici.

conteneur Web qui supporte Websocket:

• Tomcat 8
• WildFly (antérieurement Jboss AS)
• Glassfish 4.0
• et beaucoup plus

Le Vert.l'option x vaut également la peine d'être considérée.

créer 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

donc on peut écrire son propre serveur WebSocket avec Vert.x, l'emballer comme FatJar, et l'exécuter sur son propre.

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

une autre alternative est la Conntow du serveur web de JBoss. Facile à intégrer dans les applications.

Ajouter 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();

regardez Hirsute Cadre. Il s'agit d'une superposition de haut niveau pour les serveurs WebSocket Java couramment utilisés, comme Jetty, Netty ou Tomcat. Si vous aimez Spring Framework, vous devez certainement essayer Bristleback!

avis de non-responsabilité: je contribue au projet cadre de Bristleback.

Apache Tomcat 8.0 implémente WebSockets 1.1 API ( JSR-356