Kom godt i gang med Java RMI

1. Oversigt

Når to JVM'er skal kommunikere, er Java RMI en mulighed, vi skal få det til at ske. I denne artikel starter vi et simpelt eksempel, der viser Java RMI-teknologi.

2. Oprettelse af serveren

Der er to trin, der er nødvendige for at oprette en RMI-server:

  1. Opret en grænseflade, der definerer klient / serverkontrakten.
  2. Opret en implementering af denne grænseflade.

2.1. Definition af kontrakten

Lad os først og fremmest oprette grænsefladen til det eksterne objekt. Denne grænseflade udvider java.rmi. fjernbetjening markørgrænseflade.

Derudover kaster hver metode, der er angivet i grænsefladen, java.rmi.RemoteException:

offentlig grænseflade MessengerService udvider Remote {String sendMessage (String clientMessage) kaster RemoteException; }

Bemærk dog, at RMI understøtter den fulde Java-specifikation for metodesignaturer, så længe Java-typerne implementeres java.io.Serializable.

Vi ser i fremtidige sektioner, hvordan både klienten og serveren bruger denne grænseflade.

For serveren opretter vi implementeringen, ofte kaldet Fjernbetjening.

For klienten RMI-biblioteket opretter dynamisk en implementering kaldet a Stub.

2.2. Implementering

Lad os desuden implementere den eksterne grænseflade, der igen kaldes Fjernbetjening:

offentlig klasse MessengerServiceImpl implementerer MessengerService {@Override public String sendMessage (String clientMessage) {return "Client Message" .equals (clientMessage)? "Servermeddelelse": null; } offentlig streng unexposedMethod () {/ * kode * /}}

Bemærk, at vi har holdt op med kasterRemoteException klausul fra metodedefinitionen.

Det ville være usædvanligt, at vores fjerntliggende objekt kastede en RemoteException da denne undtagelse typisk er forbeholdt RMI-biblioteket til at rejse kommunikationsfejl til klienten.

At udelade det har også fordelen ved at holde vores implementering RMI-agnostisk.

Også, eventuelle yderligere metoder, der er defineret i det eksterne objekt, men ikke i grænsefladen, forbliver usynlige for klienten.

3. Registrering af tjenesten

Når vi har oprettet fjernimplementeringen, er vi nødt til at binde det eksterne objekt til et RMI-register.

3.1. Oprettelse af en stub

Først skal vi oprette en stub af vores fjernbetegnede objekt:

MessengerService-server = ny MessengerServiceImpl (); MessengerService stub = (MessengerService) UnicastRemoteObject .exportObject ((MessengerService) server, 0);

Vi bruger det statiske UnicastRemoteObject.exportObject metode til at skabe vores stubimplementering. Stubben er, hvad der betyder magien ved at kommunikere med serveren via den underliggende RMI-protokol.

Det første argument til exportObject er det eksterne serverobjekt.

Det andet argument er den port, der exportObject bruger til at eksportere det eksterne objekt til registreringsdatabasen.

At angive en værdi på nul indikerer, at vi er ligeglad med hvilken port exportObject anvendelser, hvilket er typisk og så valgt dynamisk.

Desværre er exportObject () metode uden portnummer udfases.

3.2 Oprettelse af et register

Vi kan oprette et register, der er lokalt til vores server, eller som en separat stand-alone-tjeneste.

For enkelheds skyld opretter vi en, der er lokal for vores server:

Registry registry = LocateRegistry.createRegistry (1099);

Dette opretter et register, som stubs kan være bundet af servere og opdaget af klienter.

Vi har også brugt createRegistry metode, da vi opretter registreringsdatabasen lokalt til serveren.

Som standard kører en RMI-registreringsdatabase på port 1099. I stedet kan en anden port også angives i createRegistry fabriksmetode.

Men i den enkeltstående sag ville vi ringe getRegistry, videresender værtsnavn og portnummer som parametre.

3.3 Indbinding af stub

Lad os derfor binde vores stub til registreringsdatabasen. Et RMI-register er en navngivningsfacilitet som JNDI osv. Vi kan følge et lignende mønster her og binde vores stub til en unik nøgle:

registry.rebind ("MessengerService", stub); 

Som et resultat er fjernobjektet nu tilgængeligt for enhver klient, der kan finde registreringsdatabasen.

4. Oprettelse af klienten

Endelig, lad os skrive klienten for at påberåbe sig fjernmetoderne.

For at gøre dette finder vi først RMI-registreringsdatabasen. Derudover ser vi op på den eksterne objektstub ved hjælp af den afgrænsede unikke nøgle.

Og endelig påkalder vi os Send besked metode:

Registry registry = LocateRegistry.getRegistry (); MessengerService server = (MessengerService) registreringsdatabase .lookup ("MessengerService"); String responseMessage = server.sendMessage ("Client Message"); String expectMessage = "Servermeddelelse"; assertEquals (forventet besked, svar besked);

Da vi kører RMI-registreringsdatabasen på den lokale maskine og standardport 1099, videregiver vi ingen parametre til getRegistry.

Faktisk, hvis registreringsdatabasen snarere er på en anden vært eller en anden port, kan vi levere disse parametre.

Når vi først har slået stubobjektet op ved hjælp af registreringsdatabasen, kan vi påberåbe sig metoderne på den eksterne server.

5. Konklusion

I denne vejledning fik vi en kort introduktion til Java RMI, og hvordan det kan være grundlaget for klient-server applikationer. Hold øje med yderligere indlæg om nogle af RMIs unikke funktioner!

Kildekoden til denne vejledning kan findes på GitHub.


$config[zx-auto] not found$config[zx-overlay] not found