Fjärrfjärrkontroll med RMI

1. Översikt

Java Remote Method Invocation tillåter anrop av ett objekt som finns i en annan Java Virtual Machine . Det är en väletablerad teknik men ändå lite besvärlig att använda, som vi kan se i den officiella Oracle-trail tillägnad ämnet.

I den här snabba artikeln kommer vi att undersöka hur Spring Remoting gör det möjligt att utnyttja RMI på ett enklare och renare sätt.

Den här artikeln kompletterar också översikten över vårfjärrkontroll . Du kan hitta information om andra tekniker som stöds i de tidigare delarna: HTTP Invokers, JMS, AMQP, Hessian och Burlap.

2. Maven Beroenden

Som vi gjorde i våra tidigare artiklar kommer vi att ställa in ett par Spring Boot- applikationer: en server som exponerar det fjärrstyrbara objektet och en klient som åberopar den exponerade tjänsten.

Allt vi behöver finns i fjäder sammanhang burk - så att vi kan få det att använda vad Spring Boot hjälpare föredrar vi - eftersom vårt främsta mål är bara att ha huvudbibliotek finns.

Låt oss nu gå vidare med den vanliga våren-start-start-webben - kom ihåg att ta bort Tomcat- beroendet för att utesluta den inbäddade webbtjänsten:

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

3. Serverapplikation

Vi börjar deklarera ett gränssnitt som definierar en tjänst för att boka en åktur i en hytt, som så småningom kommer att exponeras för kunder:

public interface CabBookingService { Booking bookRide(String pickUpLocation) throws BookingException; }

Då definierar vi en böna som implementerar gränssnittet. Det här är bönan som faktiskt kommer att utföra affärslogiken på servern:

@Bean CabBookingService bookingService() { return new CabBookingServiceImpl(); }

Låt oss fortsätta att förklara exportören som gör tjänsten tillgänglig för kunder. I det här fallet använder vi RmiServiceExporter :

@Bean RmiServiceExporter exporter(CabBookingService implementation) { Class serviceInterface = CabBookingService.class; RmiServiceExporter exporter = new RmiServiceExporter(); exporter.setServiceInterface(serviceInterface); exporter.setService(implementation); exporter.setServiceName(serviceInterface.getSimpleName()); exporter.setRegistryPort(1099); return exporter; }

Genom setServiceInterface () ger vi en referens till gränssnittet som kommer att göras fjärrstyrbart.

Vi bör också ge en referens till objektet som faktiskt kör metoden med setService () . Vi kan sedan tillhandahålla porten i RMI-registret som är tillgängligt på den maskin där servern körs om vi inte vill använda standardporten 1099.

Vi bör också ange ett tjänstnamn som gör det möjligt att identifiera den exponerade tjänsten i RMI- registret.

Med den givna konfigurationen kan klienten kontakta CabBookingService på följande URL: rmi: // HOST: 1199 / CabBookingService .

Låt oss äntligen starta servern. Vi behöver inte ens starta RMI-registret själv eftersom Spring kommer att göra det automatiskt för oss om ett sådant register inte är tillgängligt.

4. Kundansökan

Låt oss skriva nu klientapplikationen.

Vi börjar deklarera RmiProxyFactoryBean som kommer att skapa en böna som har samma gränssnitt som exponeras av tjänsten som körs på serversidan och som transparent dirigerar de anrop som den får till servern:

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

Låt oss sedan skriva en enkel kod som startar klientapplikationen och använder den proxy som definierades i föregående steg:

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

Det räcker nu att starta klienten för att verifiera att den åberopar den tjänst som exponeras av servern.

5. Sammanfattning

I den här handledningen såg vi hur vi kunde använda Spring Remoting för att underlätta användningen av RMI som annars kommer att kräva en serie tråkiga uppgifter som bland alla att spinna upp ett register och definiera tjänster med gränssnitt som använder tunga kontrollerade undantag.

Som vanligt hittar du källorna på GitHub.