Cliente Java SignalR para ASP.NET Core

Por Mikael Mengistu

Esse cliente Java habilita a conexão a um Servidor SignalR do ASP.NET Core por meio do código Java, incluindo aplicativos Android. 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. O cliente Java está disponível no ASP.NET Core 2.2 ou posterior.

O aplicativo de console Java de exemplo referenciado neste artigo usa o cliente Java SignalR.

Exibir ou baixar código de exemplo (como baixar)

Instalar o pacote do cliente Java SignalR

O arquivo JAR do signalr-7.0.0 permite que os clientes se conectem a hubs de SignalR. Para localizar o número de versão mais recente do arquivo JAR, confira os resultados da pesquisa do Maven.

Ao usar o Gradle, adicione a seguinte linha à seção dependencies do arquivo build.gradle :

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

Ao usar o Maven, adicione as seguintes linhas dentro do elemento <dependencies> do arquivo pom.xml:

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

Conectar-se a um hub

Para estabelecer um HubConnection, o HubConnectionBuilder deve ser usado. A URL do hub e o nível de log podem ser configurados durante a criação de uma conexão. Configure as opções necessárias chamando qualquer um dos métodos HubConnectionBuilder antes de build. Inicie a conexão com start.

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

Chamar métodos do hub a partir do cliente

Uma chamada para send invoca um método do hub. Passe o nome do método do hub e quaisquer argumentos definidos no método do hub para send.

hubConnection.send("Send", input);

Note

Chamar métodos de hub de um cliente só tem suporte ao usar o Serviço Azure SignalR no modo Padrão.

Chamar métodos de cliente do hub

Use o hubConnection.on para definir métodos no cliente que o hub possa chamar. Defina os métodos após a criação, mas antes de iniciar a conexão.

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

Adicionar log

O cliente Java SignalR usa a biblioteca SLF4J para registro em log. É 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 log específica. O snippet de código a seguir mostra como usar java.util.logging com o cliente Java SignalR.

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

Se você não configurar o logging em suas dependências, o SLF4J carregará um logger sem operação padrão com a seguinte mensagem de aviso:

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.

Notas de desenvolvimento do Android

Em relação à compatibilidade do SDK do Android para os recursos do SignalR cliente, considere os seguintes itens ao especificar a versão de destino do SDK do Android:

Configurar a autenticação com token Bearer

No cliente Java SignalR, você pode configurar um token bearer a ser usado para autenticação fornecendo uma "fábrica de tokens de acesso" para o HttpHubConnectionBuilder. Use withAccessTokenFactory para retornar um RxJavaSingle<String>. Com uma chamada para Single.defer, você pode escrever lógica para produzir tokens de acesso para seu cliente.

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 Java

Ao chamar os métodos on, invoke ou stream de HubConnection no cliente Java, os usuários devem passar um objeto Type em vez de um objeto Class<?> para descrever qualquer Object genérico passado para o método. Um Type pode ser adquirido usando a classe fornecida TypeReference . Por exemplo, usando uma classe genérica personalizada chamada Foo<T>, o código a seguir obtém o 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 .class integrado.

Ao chamar um desses métodos com um ou mais tipos de objeto, use a sintaxe generics ao invocar o método . Por exemplo, ao registrar um on manipulador para um método chamado func, que usa como argumentos um String e um objeto Foo<String>, use o seguinte código para definir uma ação para imprimir os argumentos:

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 método Object.getClass devido à eliminação de tipo em Java. Por exemplo, chamar getClass em um ArrayList<String> não retornaria Class<ArrayList<String>>, mas sim Class<ArrayList>, que não fornece ao desserializador informações suficientes para desserializar corretamente uma mensagem de entrada. O mesmo é verdadeiro para objetos personalizados.

Limitações conhecidas

  • Não há suporte para o fallback de transporte e o transporte de Eventos Enviados pelo Servidor.
  • Não há suporte para o fallback de transporte e o transporte de Eventos Enviados pelo Servidor.
  • Há suporte apenas para o protocolo JSON.
  • Há suporte apenas para o protocolo JSON.
  • Há suporte apenas para o transporte WebSockets.
  • Ainda não há suporte para streaming.

Conteúdo relacionado

  • Última atualização em