Share via

Externe service in Java met Reliable Services

  • Artikel

Voor services die niet zijn gekoppeld aan een bepaald communicatieprotocol of een bepaalde stack, zoals WebAPI, Windows Communication Foundation (WCF) of andere, biedt het Reliable Services-framework een extern mechanisme om snel en eenvoudig externe procedureoproepen voor services in te stellen. In dit artikel wordt beschreven hoe u externe procedureoproepen instelt voor services die zijn geschreven met Java.

Externe toegang instellen voor een service

Het instellen van externe toegang voor een service wordt uitgevoerd in twee eenvoudige stappen:

  1. Maak een interface voor uw service die u wilt implementeren. Deze interface definieert de methoden die beschikbaar zijn voor een externe procedure-aanroep in uw service. De methoden moeten asynchrone methoden zijn die taken retourneren. De interface moet implementeren microsoft.serviceFabric.services.remoting.Service om aan te geven dat de service een externe interface heeft.
  2. Gebruik een externe listener in uw service. Dit is een CommunicationListener implementatie die externe mogelijkheden biedt. FabricTransportServiceRemotingListener kan worden gebruikt om een externe listener te maken met behulp van het standaardprotocol voor externe communicatie.

De volgende staatloze service maakt bijvoorbeeld één methode beschikbaar om 'Hallo wereld' te krijgen via een externe procedure-aanroep.

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;
    }
}

Notitie

De argumenten en de retourtypen in de service-interface kunnen eenvoudige, complexe of aangepaste typen zijn, maar ze moeten serialiseerbaar zijn.

Externe servicemethoden aanroepen

Het aanroepen van methoden voor een service met behulp van de externe stack wordt uitgevoerd met behulp van een lokale proxy naar de service via de microsoft.serviceFabric.services.remoting.client.ServiceProxyBase klasse. De ServiceProxyBase methode maakt een lokale proxy met behulp van dezelfde interface die door de service wordt geïmplementeerd. Met die proxy kunt u eenvoudig methoden op de interface op afstand aanroepen.


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

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

Het externe framework doorgeeft uitzonderingen die zijn gegenereerd bij de service aan de client. De logica voor het afhandelen van uitzonderingen bij de client kan dus rechtstreeks omgaan met ServiceProxyBase uitzonderingen die door de service worden gegenereerd.

Levensduur van serviceproxy

Het maken van ServiceProxy is een lichtgewicht bewerking, zodat u zoveel kunt maken als u nodig hebt. Serviceproxy-exemplaren kunnen opnieuw worden gebruikt zolang ze nodig zijn. Als een aanroep van een externe procedure een uitzondering genereert, kunt u hetzelfde proxy-exemplaar nog steeds opnieuw gebruiken. Elke ServiceProxy bevat een communicatieclient die wordt gebruikt om berichten via de kabel te verzenden. Tijdens het aanroepen van externe aanroepen worden interne controles uitgevoerd om te bepalen of de communicatieclient geldig is. Op basis van de resultaten van deze controles wordt de communicatieclient indien nodig opnieuw gemaakt. Als er een uitzondering optreedt, hoeft u daarom niet opnieuw te maken ServiceProxy.

Levensduur van ServiceProxyFactory

FabricServiceProxyFactory is een fabriek die proxy maakt voor verschillende externe interfaces. Als u API ServiceProxyBase.create gebruikt voor het maken van een proxy, maakt framework een FabricServiceProxyFactory. Het is handig om er handmatig een te maken wanneer u ServiceRemotingClientFactory-eigenschappen moet overschrijven. Fabriek is een dure operatie. FabricServiceProxyFactory onderhoudt de cache van communicatieclients. Best practice is om de cache zo lang mogelijk in de cache te plaatsen FabricServiceProxyFactory .

Verwerking van externe uitzonderingen

Alle externe uitzonderingen die door de service-API worden gegenereerd, worden teruggestuurd naar de client als RuntimeException of FabricException.

ServiceProxy verwerkt alle failover-uitzondering voor de servicepartitie waarvoor deze is gemaakt. Hiermee worden de eindpunten opnieuw omgezet als er failover-uitzonderingen (niet-tijdelijke uitzonderingen) zijn en wordt de aanroep opnieuw geprobeerd met het juiste eindpunt. Het aantal nieuwe pogingen voor failover-uitzondering is onbepaald. In het geval van TransientExceptions wordt alleen de aanroep opnieuw geprobeerd.

Standaardparameters voor opnieuw proberen worden aangeboden door OperationRetrySettings. U kunt deze waarden configureren door het Object OperationRetrySettings door te geven aan serviceProxyFactory-constructor.

Volgende stappen