Spring Remoting met RMI

1. Overzicht

Java Aanroep van externe methode maakt het mogelijk een object aan te roepen dat zich in een ander bevindt Java virtuele machine. Het is een gevestigde technologie, maar toch een beetje omslachtig in het gebruik, zoals we kunnen zien in het officiële Oracle-parcours dat aan dit onderwerp is gewijd.

In dit korte artikel zullen we onderzoeken hoe Lente Remoting maakt het mogelijk om te profiteren RMI op een gemakkelijkere en schonere manier.

Dit artikel maakt ook het overzicht van Lente Remoting. U kunt details over andere ondersteunde technologieën vinden in de vorige afleveringen: HTTP Invokers, JMS, AMQP, Hessian en Burlap.

2. Maven afhankelijkheden

Zoals we in onze vorige artikelen hebben gedaan, gaan we er een paar opzetten Spring Boot applicaties: een server die het op afstand aanroepbare object blootlegt en een client die de blootgestelde service aanroept.

Alles wat we nodig hebben, zit in de lente-context jar - zodat we het kunnen binnenbrengen met wat dan ook Spring Boot helper die we verkiezen - omdat ons belangrijkste doel is om alleen de belangrijkste bibliotheken beschikbaar te hebben.

Laten we nu verder gaan met het gebruikelijke spring-boot-starter-web - eraan te denken de Kater afhankelijkheid om de embedded webservice uit te sluiten:

 org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter-tomcat 

3. Servertoepassing

We beginnen met het declareren van een interface die een service definieert om een ​​rit in een taxi te boeken, die uiteindelijk aan klanten zal worden getoond:

openbare interface CabBookingService {Booking bookRide (String pickUpLocation) gooit BookingException; }

Vervolgens zullen we een boon definiëren die de interface implementeert. Dit is de boon die de bedrijfslogica op de server daadwerkelijk zal uitvoeren:

@Bean CabBookingService bookingService () {retourneer nieuwe CabBookingServiceImpl (); }

Laten we doorgaan met het verklaren van het Exporteur dat maakt de dienst beschikbaar voor klanten. In dit geval gebruiken we de RmiServiceExporter:

@Bean RmiServiceExporter exporteur (CabBookingService implementatie) {Class serviceInterface = CabBookingService.class; RmiServiceExporter-exporteur = nieuwe RmiServiceExporter (); exporter.setServiceInterface (serviceInterface); exporter.setService (implementatie); exporter.setServiceName (serviceInterface.getSimpleName ()); exporter.setRegistryPort (1099); terugkeer exporteur; }

Door setServiceInterface () we bieden een verwijzing naar de interface die op afstand kan worden opgeroepen.

We moeten ook een verwijzing geven naar het object waarmee de methode daadwerkelijk wordt uitgevoerd setService (). We konden dan de haven van de RMI-register beschikbaar op de computer waarop de server draait als we de standaardpoort 1099 niet willen gebruiken.

We moeten ook een servicenaam instellen, waarmee de weergegeven service in het RMI register.

Met de gegeven configuratie kan de klant contact opnemen met het CabBookingService op de volgende URL: rmi: // HOST: 1199 / CabBookingService.

Laten we eindelijk de server starten. We hoeven het RMI-register niet eens zelf te starten, omdat Voorjaar zal dat automatisch voor ons doen als een dergelijk register niet beschikbaar is.

4. Clienttoepassing

Laten we nu de clienttoepassing schrijven.

We beginnen het RmiProxyFactoryBean die een bean zal creëren die dezelfde interface heeft die wordt getoond door de service die aan de serverkant wordt uitgevoerd en die de aanroepen die het zal ontvangen transparant naar de server zal routeren:

@Bean RmiProxyFactoryBean service () {RmiProxyFactoryBean rmiProxyFactory = nieuwe RmiProxyFactoryBean (); rmiProxyFactory.setServiceUrl ("rmi: // localhost: 1099 / CabBookingService"); rmiProxyFactory.setServiceInterface (CabBookingService.class); retourneer rmiProxyFactory; }

Laten we dan een eenvoudige code schrijven die de clienttoepassing start en de proxy gebruikt die in de vorige stap is gedefinieerd:

public static void main (String [] args) gooit BookingException {CabBookingService service = SpringApplication .run (RmiClient.class, args) .getBean (CabBookingService.class); Boeking bookingOutcome = service .bookRide ("13 Seagate Blvd, Key Largo, FL 33037"); System.out.println (bookingOutcome); }

Het is nu voldoende om de client te starten om te verifiëren dat deze de service oproept die door de server wordt weergegeven.

5. Conclusie

In deze tutorial hebben we gezien hoe we Lente Remoting om het gebruik van RMI dat zal anders een reeks vervelende taken vergen, zoals onder meer het opzetten van een register en het definiëren van services met behulp van interfaces die veel gebruik maken van gecontroleerde uitzonderingen.

Zoals gewoonlijk vind je de bronnen op GitHub.