Cliente Java SignalR para ASP.NET Core

  • Artigo

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 e 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 signalr-7.0.0 permite que os clientes se conectem aos hubs 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 de hub do cliente

Uma chamada send para invocar um método de hub. Passe o nome do método do hub e todos os argumentos definidos no método de hub para send.

hubConnection.send("Send", input);

Observação

Os métodos de hub de chamada de um cliente só têm suporte ao usar o Serviço SignalR do Azure no modo Padrão. Para obter mais informações, confira Perguntas frequentes (repositório azure-signalr do GitHub).

Chamar métodos de cliente do hub

Use hubConnection.on para definir métodos no cliente que o hub pode 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 registro em 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 registro em log em suas dependências, o SLF4J carregará um agente 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 SignalR do cliente, considere os seguintes itens ao especificar a versão de destino do SDK do Android:

Configurar a autenticação de token de portador

No cliente Java SignalR, você pode configurar um token de portador a ser usado para autenticação fornecendo uma "fábrica de tokens de acesso" para o HttpHubConnectionBuilder. Use withAccessTokenFactory para fornecer uma cadeia de caracteres única<>RxJava. 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, invokeou stream de HubConnection no cliente Java, os usuários devem passar um objeto Type em vez de um objeto Class<?> para descrever qualquer genérico Object 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 interno .class.

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 é possível 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 ON JS.
  • Há suporte apenas para o protocolo ON JS.
  • Há suporte apenas para o transporte WebSockets.
  • Ainda não há suporte para streaming.

Recursos adicionais