WebSockets servidor listo para producción en Java?

Question

EDIT: se eliminó la referencia a C# ya que la única respuesta aceptada es sobre Java. Si alguien necesita información sobre la implementación del servidor websocket en C#, haga una nueva pregunta.

¿Conoce el marco de "producción preparada" para la creación de WebSockets Server en Java? Encontré una biblioteca http://nugget.codeplex.com/ pero no sabía cómo es estable y rápida.

Answer 1

Para Java, consulte este informative post. Copiar y pegar desde allí:

• Jetty WebSocket Server - embarcadero ha apoyado WebSockets desde septiembre pasado. Esta parece ser una buena opción.
• Caucho Resin
• jWebSocket
• GlassFish/Grizzly (ver una contabilización DZone en él here)
• JBoss Netty (ver parche here)
• Webbit

Fuera de estas opciones, supongo embarcadero y Resina son los más maduro y estable. Sin embargo, siempre es bueno hacer tu propia prueba.

Answer 2

Eche un vistazo a Bristleback Framework. Es una superposición de alto nivel para los servidores Java Websocket comúnmente utilizados, como Jetty, Netty o Tomcat. ¡Si te gusta Spring Framework, definitivamente debes probar Bristleback!

Descargo de responsabilidad: Soy colaborador en el proyecto Bristleback Framework.

Answer 3

La respuesta aceptada es de 3 años de antigüedad, con el reciente lanzamiento de JEE7, ahora todos los contenedores web que implementan servert 3.1 admitirán websocket a través del paquete API estándar (javax.websocket).

El siguiente código de programa de ejemplo cómo implementar WebSocket usando 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()); 
    } 
} 

Ejemplo en detalles here.

Container

web con soporte para WebSocket:

• Tomcat 8
• WildFly (Anteriormente JBoss AS)
• Glassfish 4.0
• y mucho más

Answer 4

La opción Vert.x es también vale la pena considerando.

Creación de un servidor de WS puede ser tan simple como

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

o

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); 
     } 
    }); 

Para más detalles mira aquí http://vertx.io/docs/vertx-core/java/#_websockets

Así que uno puede escribir su propio servidor WebSocket con Vert.x , empaquételo como FatJar y ejecútelo solo.

O puede incrustar Vert.x env. en su aplicación, y despliegue su verticle (que implementa el servidor ws) programáticamente.

---

Otra alternativa es Undertow servidor web de JBoss. Que es fácil de integrar en las aplicaciones.

Añadir estas dependencias:

<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> 

Y aquí está un servidor WS muestra:

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

Answer 5

Apache Tomcat 8.0 implementa WebSockets 1.1 API (JSR-356). Incluso puedes jugar con ejemplos después de la instalación navegando a la carpeta examples: hay echo chat y snake game.

Answer 6

AMARRE

he pasado la última semana apabullante sobre cómo hacer que un servidor WebSocket. Finalmente tengo algo para trabajar espero que esto ayude. Utiliza bibliotecas de Jetty (jarras).

WebRTC_IceServer.java Archivo

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

WebsocketPOJO.java Archivo

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 
}