Tjänstmoting i Java med Reliable Services

Artikel
08/25/2024

För tjänster som inte är knutna till ett visst kommunikationsprotokoll eller en viss stack, till exempel WebAPI, Windows Communication Foundation (WCF) eller andra, tillhandahåller Reliable Services-ramverket en fjärrkommunikationsmekanism för att snabbt och enkelt konfigurera fjärrproceduranrop för tjänster. I den här artikeln beskrivs hur du konfigurerar fjärrproceduranrop för tjänster som skrivits med Java.

Konfigurera fjärrkommunikation på en tjänst

Du konfigurerar fjärrkommunikation för en tjänst i två enkla steg:

Skapa ett gränssnitt för din tjänst att implementera. Det här gränssnittet definierar de metoder som är tillgängliga för ett fjärrproceduranrop i tjänsten. Metoderna måste vara aktivitetsreturerande asynkrona metoder. Gränssnittet måste implementeras microsoft.serviceFabric.services.remoting.Service för att signalera att tjänsten har ett fjärrkommunikationsgränssnitt.
Använd en fjärrkommunikationslyssnare i tjänsten. Det här är en CommunicationListener implementering som tillhandahåller fjärrkommunikationsfunktioner. FabricTransportServiceRemotingListener kan användas för att skapa en fjärrkommunikationslyssnare med standardprotokollet för fjärrkommunikation.

Följande tillståndslösa tjänst exponerar till exempel en enda metod för att hämta "Hello World" via ett fjärrproceduranrop.

import java.util.ArrayList;
import java.util.concurrent.CompletableFuture;
import java.util.List;
import microsoft.servicefabric.services.communication.runtime.ServiceInstanceListener;
import microsoft.servicefabric.services.remoting.Service;
import microsoft.servicefabric.services.runtime.StatelessService;

public interface MyService extends Service {
    CompletableFuture<String> helloWorldAsync();
}

class MyServiceImpl extends StatelessService implements MyService {
    public MyServiceImpl(StatelessServiceContext context) {
       super(context);
    }

    public CompletableFuture<String> helloWorldAsync() {
        return CompletableFuture.completedFuture("Hello!");
    }

    @Override
    protected List<ServiceInstanceListener> createServiceInstanceListeners() {
        ArrayList<ServiceInstanceListener> listeners = new ArrayList<>();
        listeners.add(new ServiceInstanceListener((context) -> {
            return new FabricTransportServiceRemotingListener(context,this);
        }));
        return listeners;
    }
}

Kommentar

Argumenten och returtyperna i tjänstgränssnittet kan vara enkla, komplexa eller anpassade typer, men de måste vara serialiserbara.

Anropa fjärrtjänstmetoder

Anropa metoder för en tjänst med hjälp av fjärrkommunikationsstacken görs med hjälp av en lokal proxy till tjänsten via microsoft.serviceFabric.services.remoting.client.ServiceProxyBase klassen. Metoden ServiceProxyBase skapar en lokal proxy genom att använda samma gränssnitt som tjänsten implementerar. Med den proxyn kan du helt enkelt anropa metoder i gränssnittet via fjärranslutning.


MyService helloWorldClient = ServiceProxyBase.create(MyService.class, new URI("fabric:/MyApplication/MyHelloWorldService"));

CompletableFuture<String> message = helloWorldClient.helloWorldAsync();

Ramverket för fjärrkommunikation sprider undantag som genereras i tjänsten till klienten. Så undantagshanteringslogik på klienten med hjälp ServiceProxyBase av kan direkt hantera undantag som tjänsten genererar.

Livslängd för tjänstproxy

ServiceProxy-skapande är en enkel åtgärd, så du kan skapa så många du behöver. Tjänstproxyinstanser kan återanvändas så länge de behövs. Om ett fjärrproceduranrop utlöser ett undantag kan du fortfarande återanvända samma proxyinstans. Varje ServiceProxy innehåller en kommunikationsklient som används för att skicka meddelanden via kabeln. När fjärranrop anropas utförs interna kontroller för att avgöra om kommunikationsklienten är giltig. Baserat på resultatet av dessa kontroller återskapas kommunikationsklienten om det behövs. Om ett undantag inträffar behöver du därför inte återskapa ServiceProxy.

Livslängd för ServiceProxyFactory

FabricServiceProxyFactory är en fabrik som skapar proxy för olika fjärrkommunikationsgränssnitt. Om du använder API ServiceProxyBase.create för att skapa proxy skapar framework en FabricServiceProxyFactory. Det är användbart att skapa en manuellt när du behöver åsidosätta Egenskaperna ServiceRemotingClientFactory . Fabrik är en dyr åtgärd. FabricServiceProxyFactory underhåller cachelagring av kommunikationsklienter. Bästa praxis är att cachelagrat FabricServiceProxyFactory så länge som möjligt.

Hantering av fjärrkommunikationsfel

Alla fjärrundantag som genereras av tjänst-API:et skickas tillbaka till klienten antingen som RuntimeException eller FabricException.

ServiceProxy hanterar alla redundansundansundansfel för den tjänstpartition som den skapas för. Den löser slutpunkterna igen om det finns redundansundantag (icke-tillfälliga undantag) och försöker anropa igen med rätt slutpunkt. Antalet återförsök för redundansundantag är obestämt. Om det gäller TransientExceptions försöker den bara anropa igen.

Standardparametrar för återförsök visas av OperationRetrySettings. Du kan konfigurera dessa värden genom att skicka Objektet OperationRetrySettings till ServiceProxyFactory-konstruktorn.

Nästa steg

Skydda kommunikationen för Reliable Services

Dela via