ASP.NET Core SignalR cliente JavaASP.NET Core SignalR Java client

Por Mikael MengistuBy Mikael Mengistu

O cliente Java permite conectar-se a um SignalR servidor ASP.NET Core do código Java, incluindo aplicativos Android.The Java client enables connecting to an ASP.NET Core SignalR server from Java code, including Android apps. Assim como o cliente JavaScript e o cliente .net, o cliente Java permite que você receba e envie mensagens para um Hub em tempo real.Like the JavaScript client and the .NET client, the Java client enables you to receive and send messages to a hub in real time. O cliente Java está disponível no ASP.NET Core 2,2 e posterior.The Java client is available in ASP.NET Core 2.2 and later.

O aplicativo de console Java de exemplo referenciado neste artigo usa o SignalR cliente Java.The sample Java console app referenced in this article uses the SignalR Java client.

Exibir ou baixar código de exemplo (como baixar)View or download sample code (how to download)

Instalar o SignalR pacote do cliente JavaInstall the SignalR Java client package

O arquivo signalr-1.0.0 jar permite que os clientes se conectem a SignalR hubs.The signalr-1.0.0 JAR file allows clients to connect to SignalR hubs. Para localizar o número de versão mais recente do arquivo JAR, consulte os resultados da pesquisa do Maven.To find the latest JAR file version number, see the Maven search results.

Se estiver usando gradle, adicione a seguinte linha à dependencies seção do arquivo Build. gradle :If using Gradle, add the following line to the dependencies section of your build.gradle file:

implementation 'com.microsoft.signalr:signalr:1.0.0'

Se estiver usando o Maven, adicione as seguintes linhas dentro do <dependencies> elemento do seu arquivo de pom.xml :If using Maven, add the following lines inside the <dependencies> element of your pom.xml file:

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

Conectar-se a um hubConnect to a hub

Para estabelecer um HubConnection , o HubConnectionBuilder deve ser usado.To establish a HubConnection, the HubConnectionBuilder should be used. A URL do Hub e o nível de log podem ser configurados durante a criação de uma conexão.The hub URL and log level can be configured while building a connection. Configure as opções necessárias chamando qualquer um dos HubConnectionBuilder métodos antes build .Configure any required options by calling any of the HubConnectionBuilder methods before build. Inicie a conexão com start .Start the connection with start.

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

Métodos do hub de chamadas do clienteCall hub methods from client

Uma chamada para send invoca um método de Hub.A call to send invokes a hub method. Passe o nome do método de Hub e quaisquer argumentos definidos no método de Hub para send .Pass the hub method name and any arguments defined in the hub method to send.

hubConnection.send("Send", input);

Observação

Somente há suporte para métodos de Hub de chamada de um cliente ao usar o serviço do Azure SignalR no modo padrão .Calling hub methods from a client is only supported when using the Azure SignalR Service in Default mode. Para obter mais informações, consulte perguntas frequentes (repositório GitHub do Azure-signalr).For more information, see Frequently Asked Questions (azure-signalr GitHub repository).

Chamar métodos de cliente do HubCall client methods from hub

Use hubConnection.on para definir métodos no cliente que o Hub pode chamar.Use hubConnection.on to define methods on the client that the hub can call. Defina os métodos após a compilação, mas antes de iniciar a conexão.Define the methods after building but before starting the connection.

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

Adicionar registro em logAdd logging

O SignalR cliente Java usa a biblioteca SLF4J para registro em log.The SignalR Java client uses the SLF4J library for logging. É uma API de log de alto nível que permite que os usuários da biblioteca escolham sua própria implementação de log específica, trazendo uma dependência de registro em log específica.It's a high-level logging API that allows users of the library to chose their own specific logging implementation by bringing in a specific logging dependency. O trecho de código a seguir mostra como usar java.util.logging o com o SignalR cliente Java.The following code snippet shows how to use java.util.logging with the SignalR Java client.

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

Se você não configurar o registro em log em suas dependências, o SLF4J carregará um agente sem operação padrão com a seguinte mensagem de aviso:If you don't configure logging in your dependencies, SLF4J loads a default no-operation logger with the following warning message:

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.

Isso pode ser ignorado com segurança.This can safely be ignored.

Notas de desenvolvimento do AndroidAndroid development notes

Com relação à compatibilidade SDK do Android para os SignalR recursos do cliente, considere os seguintes itens ao especificar sua versão de SDK do Android de destino:With regards to Android SDK compatibility for the SignalR client features, consider the following items when specifying your target Android SDK version:

Configurar autenticação de token de portadorConfigure bearer token authentication

No SignalR cliente Java, você pode configurar um token de portador a ser usado para autenticação, fornecendo uma "fábrica de token de acesso" ao HttpHubConnectionBuilder.In the SignalR Java client, you can configure a bearer token to use for authentication by providing an "access token factory" to the HttpHubConnectionBuilder. Use withAccessTokenFactory para fornecer um RxJava único <String> .Use withAccessTokenFactory to provide an RxJava Single<String>. Com uma chamada para Single. Defer, você pode escrever lógica para produzir tokens de acesso para seu cliente.With a call to Single.defer, you can write logic to produce access tokens for your client.

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

Passando informações de classe em JavaPassing Class information in Java

Ao chamar os on invoke métodos, ou stream de HubConnection no cliente Java, os usuários devem passar um Type objeto em vez de um Class<?> objeto para descrever qualquer genérico Object passado para o método.When calling the on, invoke, or stream methods of HubConnection in the Java client, users should pass a Type object rather than a Class<?> object to describe any generic Object passed to the method. Um Type pode ser adquirido usando a TypeReference classe fornecida.A Type can be acquired using the provided TypeReference class. Por exemplo, usando uma classe genérica personalizada chamada Foo<T> , o código a seguir obtém o Type :For example, using a custom generic class named Foo<T>, the following code gets the Type:

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

Para não genéricos, como primitivos ou outros tipos não parametrizados como String , você pode simplesmente usar o interno .class .For non-generics, such as primitives or other non-parameterized types like String, you can simply use the built-in .class.

Ao chamar um desses métodos com um ou mais tipos de objeto, use a sintaxe genérica ao invocar o método.When calling one of these methods with one or more object types, use the generics syntax when invoking the method. Por exemplo, ao registrar um on manipulador para um método chamado func , que usa como argumentos uma cadeia de caracteres e um Foo<String> objeto, use o seguinte código para definir uma ação para imprimir os argumentos:For example, when registering an on handler for a method named func, which takes as arguments a String and a Foo<String> object, use the following code to set an action to print the arguments:

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

Essa convenção é necessária porque não podemos recuperar informações completas sobre tipos complexos com o Object.getClass método devido à eliminação de tipo em Java.This convention is necessary because we can not retrieve complete information about complex types with the Object.getClass method due to type erasure in Java. Por exemplo, chamar getClass em um ArrayList<String> não retornaria Class<ArrayList<String>> , mas em vez disso Class<ArrayList> , que não dá ao desserializador informações suficientes para desserializar corretamente uma mensagem de entrada.For example, calling getClass on an ArrayList<String> would not return Class<ArrayList<String>>, but rather Class<ArrayList>, which does not give the deserializer enough information to correctly deserialize an incoming message. O mesmo é verdadeiro para objetos personalizados.The same is true for custom objects.

Limitações conhecidasKnown limitations

  • O fallback de transporte e o transporte de eventos do servidor enviados não têm suporte.Transport fallback and the Server Sent Events transport aren't supported.
  • O fallback de transporte e o transporte de eventos do servidor enviados não têm suporte.Transport fallback and the Server Sent Events transport aren't supported.
  • Somente o protocolo JSON tem suporte.Only the JSON protocol is supported.
  • Somente o protocolo JSON tem suporte.Only the JSON protocol is supported.
  • Somente o transporte WebSockets tem suporte.Only the WebSockets transport is supported.
  • Não há suporte para streaming ainda.Streaming isn't supported yet.

Recursos adicionaisAdditional resources