Dela via

ASP.NET Core SignalR Java-klient

  • Artikel

Av Mikael Mengistu

Java-klienten gör det möjligt att ansluta till en ASP.NET Core SignalR-server från Java-kod, inklusive Android-appar. Precis som JavaScript-klienten och .NET-klientenkan du med Java-klienten ta emot och skicka meddelanden till en hubb i realtid. Java-klienten är tillgänglig i ASP.NET Core 2.2 och senare.

Java-exempelkonsolappen som refereras i den här artikeln använder SignalR Java-klienten.

Visa eller ladda ned exempelkod (hur du laddar ned)

Installera SignalR Java-klientpaketet

Med signalr-7.0.0 JAR-fil kan klienter ansluta till SignalR hubbar. Information om hur du hittar det senaste jar-filversionsnumret finns i Maven-sökresultatet.

Om du använder Gradle lägger du till följande rad i avsnittet dependencies i filen build.gradle:

implementation 'com.microsoft.signalr:signalr:7.0.0'

Om du använder Maven lägger du till följande rader i <dependencies>-elementet i filen pom.xml:

<dependency>
    <groupId>com.microsoft.signalr</groupId>
    <artifactId>signalr</artifactId>
    <version>1.0.0</version>
</dependency>

Ansluta till en hubb

För att upprätta en HubConnectionska HubConnectionBuilder användas. Hubb-URL:en och loggnivån kan konfigureras när du skapar en anslutning. Konfigurera alla nödvändiga alternativ genom att anropa någon av de HubConnectionBuilder metoderna innan build. Starta anslutningen med start.

HubConnection hubConnection = HubConnectionBuilder.create(input)
        .build();

Anropa hubbmetoder från klienten

Ett anrop till send anropar en hubbmetod. Skicka hubbmetodens namn och de argument som definierats i hubbmetoden till send.

hubConnection.send("Send", input);

Not

Anrop av hubbmetoder från en klient stöds endast när man använder Azure SignalR-tjänsten i standardläge för. Mer information finns i Vanliga frågor och svar (GitHub-lagringsplats för azure-signalr).

Anropa klientmetoder från hubben

Använd hubConnection.on för att definiera metoder på klienten som hubben kan anropa. Definiera metoderna efter att du har skapat men innan du startar anslutningen.

hubConnection.on("Send", (message) -> {
    System.out.println("New Message: " + message);
}, String.class);

Lägg till loggning

SignalR Java-klienten använder SLF4J-biblioteket för loggning. Det är ett högnivåloggnings-API som gör det möjligt för biblioteksanvändare att välja sin egen specifika loggningsimplementering genom att införa ett specifikt loggningsberoende. Följande kodfragment visar hur du använder java.util.logging med SignalR Java-klienten.

implementation 'org.slf4j:slf4j-jdk14:1.7.25'

Om du inte konfigurerar loggning i dina beroenden läser SLF4J in en standardloggning utan åtgärd med följande varningsmeddelande:

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.

Detta kan ignoreras på ett säkert sätt.

Android-utvecklingsanteckningar

När det gäller Android SDK-kompatibilitet för SignalR-klientfunktioner bör du tänka på följande när du anger din Android SDK-målversion:

Konfigurera ägartokenautentisering

I SignalR Java-klienten kan du konfigurera en ägartoken som ska användas för autentisering genom att tillhandahålla en "åtkomsttokenfabrik" till HttpHubConnectionBuilder. Använd med AccessTokenFactory för att tillhandahålla en RxJava<String>. Med ett anrop till Single.deferkan du skriva logik för att skapa åtkomsttoken för klienten.

HubConnection hubConnection = HubConnectionBuilder.create("YOUR HUB URL HERE")
    .withAccessTokenProvider(Single.defer(() -> {
        // Your logic here.
        return Single.just("An Access Token");
    })).build();

Skicka klassinformation i Java

När användarna anropar on, invokeeller stream metoder för HubConnection i Java-klienten bör de skicka ett Type objekt i stället för ett Class<?> objekt för att beskriva alla generiska Object som skickas till metoden. En Type kan hämtas med hjälp av den angivna TypeReference-klassen. Om du till exempel använder en anpassad generisk klass med namnet Foo<T>hämtar följande kod Type:

Type fooType = new TypeReference<Foo<String>>() { }).getType();

För icke-generiska objekt, till exempel primitiver eller andra icke-parametriserade typer som String, kan du helt enkelt använda den inbyggda .class.

När du anropar en av dessa metoder med en eller flera objekttyper använder du syntaxen generics när du anropar metoden. När du till exempel registrerar en on-hanterare för en metod med namnet func, som tar som argument en sträng och ett Foo<String>-objekt, använder du följande kod för att ange en åtgärd för att skriva ut argumenten:

hubConnection.<String, Foo<String>>on("func", (param1, param2) ->{
    System.out.println(param1);
    System.out.println(param2);
}, String.class, fooType);

Den här konventionen är nödvändig eftersom vi inte kan hämta fullständig information om komplexa typer med Object.getClass-metoden på grund av typ radering i Java. Om du till exempel anropar getClass på en ArrayList<String> returneras inte Class<ArrayList<String>>, utan i stället Class<ArrayList>, vilket inte ger deserialiseraren tillräckligt med information för att korrekt deserialisera ett inkommande meddelande. Detsamma gäller för anpassade objekt.

Kända begränsningar

  • Transportåterställning och transport av skickade serverhändelser stöds inte.
  • Transportåterställning och transport av skickade serverhändelser stöds inte.
  • Endast JSON-protokollet stöds.
  • Endast JSON-protokollet stöds.
  • Endast WebSockets-transporten stöds.
  • Direktuppspelning stöds inte än.

Ytterligare resurser