autobahn java
v21.7.1
Biblioteca cliente que proporciona WAMP en Java 8 (Netty) y Android, además de WebSocket (seguro) para Android.
Autobahn|Java es un subproyecto del proyecto Autobahn y proporciona implementaciones de cliente de código abierto para
ejecutándose en Android y Netty/Java8/JVM.
La capa WebSocket utiliza una API de usuario basada en devolución de llamada y está escrita específicamente para Android. Por ejemplo, no ejecuta ningún elemento de red en el hilo principal (UI).
La capa WAMP utiliza Java 8 CompletableFuture para acciones WAMP (llamar, registrarse, publicar y suscribirse) y el patrón Observer para eventos de ciclo de vida de sesión, suscripción y registro de WAMP.
La biblioteca tiene licencia del MIT, es mantenida por el Proyecto Crossbar.io, probada con AutobahnTestsuite y publicada como JAR para Maven y como imagen de la cadena de herramientas Docker para Dockerhub.
Tomar a través de Maven:
< dependency >
< groupId >io.crossbar.autobahn</ groupId >
< artifactId >autobahn-android</ artifactId >
< version >21.7.1</ version >
</ dependency >Gradle:
dependencies {
implementation ' io.crossbar.autobahn:autobahn-android:21.7.1 '
} Para sistemas que no sean Android, use artefactoID autobahn-java o simplemente descargue el último JAR
Los clientes de demostración son fáciles de ejecutar, solo necesita instalar make y docker para que todo funcione.
$ make crossbar # Starts crossbar in a docker container
$ make python # Starts a python based WAMP components that provides calls for the Java demo client
y finalmente
$ make java # Starts the java (Netty) based demo client that performs WAMP actions
El código en la galería de demostración contiene algunos ejemplos sobre cómo usar la biblioteca de autopistas y también contiene métodos convenientes de usar. A continuación se muestra un conjunto básico de ejemplos de código que muestran las 4 acciones de WAMP.
public void demonstrateSubscribe ( Session session , SessionDetails details ) {
// Subscribe to topic to receive its events.
CompletableFuture < Subscription > subFuture = session . subscribe ( "com.myapp.hello" ,
this :: onEvent );
subFuture . whenComplete (( subscription , throwable ) -> {
if ( throwable == null ) {
// We have successfully subscribed.
System . out . println ( "Subscribed to topic " + subscription . topic );
} else {
// Something went bad.
throwable . printStackTrace ();
}
});
}
private void onEvent ( List < Object > args , Map < String , Object > kwargs , EventDetails details ) {
System . out . println ( String . format ( "Got event: %s" , args . get ( 0 )));
} Como solo accedemos args en onEvent(), podríamos simplificarlo de la siguiente manera:
private void onEvent ( List < Object > args ) {
System . out . println ( String . format ( "Got event: %s" , args . get ( 0 )));
} public void demonstratePublish ( Session session , SessionDetails details ) {
// Publish to a topic that takes a single arguments
List < Object > args = Arrays . asList ( "Hello World!" , 900 , "UNIQUE" );
CompletableFuture < Publication > pubFuture = session . publish ( "com.myapp.hello" , args );
pubFuture . thenAccept ( publication -> System . out . println ( "Published successfully" ));
// Shows we can separate out exception handling
pubFuture . exceptionally ( throwable -> {
throwable . printStackTrace ();
return null ;
});
}Una llamada más simple sería así:
public void demonstratePublish ( Session session , SessionDetails details ) {
CompletableFuture < Publication > pubFuture = session . publish ( "com.myapp.hello" , "Hi!" );
...
} public void demonstrateRegister ( Session session , SessionDetails details ) {
// Register a procedure.
CompletableFuture < Registration > regFuture = session . register ( "com.myapp.add2" , this :: add2 );
regFuture . thenAccept ( registration ->
System . out . println ( "Successfully registered procedure: " + registration . procedure ));
}
private CompletableFuture < InvocationResult > add2 (
List < Object > args , Map < String , Object > kwargs , InvocationDetails details ) {
int res = ( int ) args . get ( 0 ) + ( int ) args . get ( 1 );
List < Object > arr = new ArrayList <>();
arr . add ( res );
return CompletableFuture . completedFuture ( new InvocationResult ( arr ));
} Un add2 muy preciso puede verse así:
private List < Object > add2 ( List < Integer > args , InvocationDetails details ) {
int res = args . get ( 0 ) + args . get ( 1 );
return Arrays . asList ( res , details . session . getID (), "Java" );
} public void demonstrateCall ( Session session , SessionDetails details ) {
// Call a remote procedure.
CompletableFuture < CallResult > callFuture = session . call ( "com.myapp.add2" , 10 , 20 );
callFuture . thenAccept ( callResult ->
System . out . println ( String . format ( "Call result: %s" , callResult . results . get ( 0 ))));
}Procedimiento de llamada con parámetros de tipo de datos variables
public void demonstrateCall ( Session session , SessionDetails details ) {
// Call a remote procedure.
byte [] var1 = new byte [ 20 ];
String var2 = "A sample text" ;
int var3 = 99 ;
List < Object > args = new ArrayList <>();
args . add ( var1 );
args . add ( var2 );
args . add ( var3 );
CompletableFuture < CallResult > callFuture = session . call ( "com.myapp.myproc" , args );
callFuture . thenAccept ( callResult ->
System . out . println ( String . format ( "Call result: %s" , callResult . results . get ( 0 ))));
} public void main () {
// Create a session object
Session session = new Session ();
// Add all onJoin listeners
session . addOnJoinListener ( this :: demonstrateSubscribe );
session . addOnJoinListener ( this :: demonstratePublish );
session . addOnJoinListener ( this :: demonstrateCall );
session . addOnJoinListener ( this :: demonstrateRegister );
// finally, provide everything to a Client and connect
Client client = new Client ( session , url , realm );
CompletableFuture < ExitInfo > exitInfoCompletableFuture = client . connect ();
}La autenticación es simple, solo necesitamos crear un objeto del autenticador deseado y pasárselo al Cliente.
public void main () {
...
IAuthenticator authenticator = new TicketAuth ( authid , ticket );
Client client = new Client ( session , url , realm , authenticator );
CompletableFuture < ExitInfo > exitInfoCompletableFuture = client . connect ();
} public void main () {
...
IAuthenticator authenticator = new ChallengeResponseAuth ( authid , secret );
Client client = new Client ( session , url , realm , authenticator );
CompletableFuture < ExitInfo > exitInfoCompletableFuture = client . connect ();
} public void main () {
...
IAuthenticator authenticator = new CryptosignAuth ( authid , privkey , pubkey );
Client client = new Client ( session , url , realm , authenticator );
CompletableFuture < ExitInfo > exitInfoCompletableFuture = client . connect ();
}También puede proporcionar una lista de autenticadores.
public void main () {
...
List < IAuthenticator > authenticators = new ArrayList <>();
authenticators . add ( new TicketAuth ( authid , ticket ));
authenticators . add ( new CryptosignAuth ( authid , privkey , pubkey ));
Client client = new Client ( session , url , realm , authenticators );
CompletableFuture < ExitInfo > exitInfoCompletableFuture = client . connect ();
}Autobahn también admite POJO
A continuación se explica cómo llamar a un procedimiento remoto que devuelve una lista de POJO de persona
// Call a remote procedure that returns a Person with id 1
CompletableFuture < Person > callFuture = mSession . call ( "com.example.get_person" , 1 );
callFuture . whenCompleteAsync (( person , throwable ) -> {
if ( throwable != null ) {
// handle error
} else {
// success!
// do something with person
}
}, mExecutor ); // call a remote procedure that returns a List<Person>
CompletableFuture < List < Person >> callFuture = mSession . call (
// remote procedure to call
"com.example.get_persons_by_department" ,
// positional call arguments
new ArrayList < Object >() { List . of ( "department-7" )},
// call return type
new TypeReference < List < Person >>() {}
);
callFuture . whenCompleteAsync (( persons , throwable ) -> {
if ( throwable != null ) {
// handle error
} else {
// success!
for ( Person person : persons ) {
// do something with person
}
}
}, mExecutor );Registrar también un procedimiento que devuelve una Persona
private Person get_person () {
return new Person ( "john" , "doe" , "hr" );
}
private void main () {
CompletableFuture < Registration > regFuture = session . register (
"io.crossbar.example.get_person" , this :: get_person );
regFuture . whenComplete (( registration , throwable ) -> {
System . out . println ( String . format (
"Registered procedure %s" , registration . procedure ));
});
}Ejemplo de eco
WebSocketConnection connection = new WebSocketConnection ();
connection . connect ( "wss://echo.websocket.org" , new WebSocketConnectionHandler () {
@ Override
public void onConnect ( ConnectionResponse response ) {
System . out . println ( "Connected to server" );
}
@ Override
public void onOpen () {
connection . sendMessage ( "Echo with Autobahn" );
}
@ Override
public void onClose ( int code , String reason ) {
System . out . println ( "Connection closed" );
}
@ Override
public void onMessage ( String payload ) {
System . out . println ( "Received message: " + payload );
connection . sendMessage ( payload );
}
});Construir Autobahn es bastante simple
Para Android, recomendamos utilizar Android Studio. Simplemente importe el proyecto en Android Studio, le dirá si faltan dependencias, instálelas y luego simplemente cree el proyecto desde Build > Rebuild Project y tendrá el artefacto aar en autobahn/build/outputs/aar/
Para producir una compilación para sistemas que no sean Android, asegúrese de tener Docker y Make instalado, luego simplemente use el comando ejecutar a continuación en el directorio raíz del proyecto.
make build_autobahn y eso generará el archivo jar en autobahn/build/libs/ .
Ponte en contacto uniéndote a nuestro foro.
La versión 1 de esta biblioteca todavía se encuentra en el repositorio aquí, pero ya no se mantiene.
La versión 1 solo admitía WebSocket no seguro en Android y solo admitía WAMP v1.
Ambos problemas están solucionados en la versión (actual) de Autobahn|Java.
