RMI

"Kumusta! At isa pang masayang paksa: RMI. Ang RMI ay nangangahulugang Remote Method Invocation . Sa madaling salita, ang RMI ay isang mekanismo na nagpapahintulot sa isang object mula sa isang Java machine na tumawag ng mga method sa mga object mula sa isa pang Java machine , kahit na sila ay nasa iba't ibang paraan. mga computer, sa iba't ibang bansa, o sa iba't ibang panig ng mundo."

"Whoa! Parang ang galing."

"Yep. But I'll only try to give you an overview. With this, if you dig too deep, you can get confused by the nuances of how it works."

"Ngunit kung hindi ka pumunta sa sukdulan, kung gayon ang RMI ay hindi lamang napakasimple, ngunit ito rin ay lubos na nagpapasimple sa buhay ng isang programmer. Para sa kung saan, binibigyan namin ito ng aming pinakamalalim na paggalang."

"Kaya, gusto namin ang isang object sa isang Java program na tumawag sa isang method sa isang object na nasa ibang Java program. Hindi alintana kung saan tumatakbo ang mga program na ito."

"Isaalang-alang natin ang pinakasimpleng halimbawa: kapag ang parehong mga program ay tumatakbo sa parehong computer.  Upang payagan ang mga program na makipag-ugnayan sa Internet, kailangan mong i-configure ang mga pahintulot ng JVM , ngunit hindi namin iyon sasaklawin ngayon."

"Sa Java, maaari mong malayuang tawagan lamang ang mga pamamaraan ng mga interface, hindi mga klase."

"So, we have two programs. How can they call each other's methods?"

"Isaalang-alang natin ang sitwasyon kung saan ang isang programa ay naglalaman ng isang bagay, at ang pangalawang programa ay gustong tumawag ng mga pamamaraan sa bagay na iyon. Tawagan natin ang unang program na server, at ang pangalawa — ang kliyente . "

"Una, magbibigay ako ng ilang sample code, at pagkatapos ay susuriin natin ito."

"So ano ang gagawin ng ating programa?"

"Hmm. Well, para sa pagiging simple, ang program ay magkakaroon ng isang paraan na binabaligtad ang isang string na ipinapasa dito."

"Simple lang."

"Mabuti, pagkatapos ay magsimula tayo:"

"Una, kailangan namin ng interface na makakatugon sa aming mga kinakailangan:"

interface Reverse extends Remote
{
 public String reverse(String str) throws RemoteException;
}

"Gumawa ako ng Reverse interface at nagdagdag ng Remote marker interface dito, pati na rin ang RemoteException. Maaaring mangyari ang mga hindi inaasahang error kapag tinawag ang pamamaraan. Kung mayroon man, itatapon ang exception na ito."

"Ngayon kailangan nating magsulat ng isang klase ng server na nagpapatupad ng interface na ito:"

class ReverseImpl implements Reverse
{
 public String reverse(String str) throws RemoteException
 {
  return new StringBuffer(str).reverse().toString();
 }
}

"I see. Binabaliktad natin ang string sa pamamaraang ito."

"Oo."

"Ngayon kailangan nating gawing matatawag ang bagay na ito mula sa isa pang program. Narito kung paano mo ito gagawin:"

public static final String UNIC_BINDING_NAME = "server.reverse";

public static void main(String[] args) throws Exception
{
 // Create an object to be accessible remotely.
 final ReverseImpl service = new ReverseImpl();

 // Create a registry of shared objects.
 final Registry registry = LocateRegistry.createRegistry(2099);
 // Create a stub for receiving remote calls.
 Remote stub = UnicastRemoteObject.exportObject(service, 0);
 // Register the stub in the registry.
 registry.bind(UNIC_BINDING_NAME, stub);

 // Put the main thread to sleep, or else the program will exit.
 Thread.sleep(Integer.MAX_VALUE);
}

"Ipapaliwanag ko ang linyang ito."

" Sa linya 1 , nag-iimbak kami ng isang natatanging pangalan (na aming ginawa) para sa aming malayong bagay (bagay na malayuang naa-access) sa variable  na UNIC_BINDING_NAME . Kung ang program ay gumawa ng ilang mga bagay na naa-access, ang bawat isa ay dapat magkaroon ng sarili nitong natatanging pangalan. Ang aming ang natatanging pangalan ng object ay 'server.reverse'."

" Sa linya 6 lumikha kami ng isang ReverseImpl object na maa-access nang malayuan. Ang mga pamamaraan nito ay ipapatawag."

" Sa linya 9 kami ay gumagawa ng isang espesyal na bagay na tinatawag na isang registry. Kailangan namin itong gamitin upang irehistro ang mga bagay na aming ibinabahagi. Ang JVM ay makikipag-ugnayan sa kanila sa ibang pagkakataon. Ang 2099 ay isang port (isang natatanging numero na magagamit ng ibang programa upang ma-access ang aming object registry)."

"Sa madaling salita, upang ma-access ang isang object, kailangan mong malaman ang natatanging numero ng object registry (port) at ang natatanging pangalan ng object, at magkaroon ng parehong interface tulad ng ipinatupad ng remote object."

"I see. Something like: call by phone (need a number) and ask for Bill (ang pangalan ng isang object)?"

"Oo. Ngayon, ituloy natin."

" Sa linya 11  , gumawa kami ng stub. Ang stub ay isang espesyal na bagay na tumatanggap ng impormasyon tungkol sa malayuang tawag, binubuksan ito, deserialize ang mga argumento ng pamamaraan, at tinatawagan ang kinakailangang paraan. Pagkatapos ay ini-serialize nito ang resulta o exception, kung mayroon man. , at ibinabalik ang lahat ng ito sa tumatawag."

"I see. Almost. You said that it 'deserializes the method arguments'. So, ibig sabihin, dapat serializable ang mga argumento ng remote method?"

"Oo. Paano mo pa sila ipapadala sa network? Totoo, may mga pagbubukod, ibig sabihin, mga bagay na ipinasa sa pamamagitan ng sanggunian, ngunit hindi natin pag-uusapan ang mga ito ngayon."

"Ilalagay namin ito ng ganito: hindi ka makakapasa ng mga non-serializable objects, pero kung gusto mo talaga, kaya mo. Pero ang sakit, alam mo."

"OK."

"Kung ganoon ay magpatuloy tayo."

" Sa linya 13 , nirerehistro namin ang stub ng aming object sa ilalim ng natatanging pangalan sa registry."

" Sa line 16 , pinatulog namin ang main thread. Lahat ng remote na tawag ay pinoproseso sa magkahiwalay na mga thread. Ang mahalaga ay tumatakbo ang program. Kaya pinatulog na lang namin ang main thread dito. Iyon lang."

"OK."

"Magaling, narito ang isang halimbawa ng isang kliyente:"

public static final String UNIC_BINDING_NAME = "server.reverse";

public static void main(String[] args) throws Exception
{
 // Create a registry of shared objects
 final Registry registry = LocateRegistry.createRegistry(2099);

 // Get the object (actually, this is a proxy object)
 Reverse service = (Reverse) registry.lookup(UNIC_BINDING_NAME);

 // Call the remote method
 String result = service.reverse("Home sweet home.");
}

"Ipapaliwanag ko ang code na ito sa bawat linya:"

" Ang Linya 1  ay ang natatanging pangalan ng malayong bagay . Dapat na pareho ito sa kliyente at sa server."

" Sa linya 6  , lumikha kami ng « registry ng mga malalayong bagay ». Ang port nito (2099) ay dapat na kapareho ng port ng registry para sa application ng server."

" Sa linya 9 , nakukuha namin ang object mula sa registry. Ang ibinalik na object ay isang proxy object at na-convert sa isang interface. Ang interface ay dapat magmana ng Remote marker interface."

" Sa linya 12 , tinatawag namin ang mga pamamaraan ng interface na parang ang bagay ay nilikha sa loob ng parehong programa. Walang pagkakaiba."

"Astig! Ngayon ay maaari na akong magsulat ng mga distributed na application. O mga laro tulad ng Battleship para sa Android."

"Huwag kang maglakas-loob, Amigo! Ang Android operating system ay pinagbawalan noong ika-27 siglo pagkatapos nitong ikatlong pagtatangka na sakupin ang mundo. Ang mga robot ay walang anumang access dito. Walang anumang paraan para mapalayo ka rito. . Magsisimula kang tumakbo sa paligid at sumigaw, «Patayin ang lahat ng tao!»"

"Hmm. OK. Pero kailangan ko pa ring tanungin si Diego. You never know, baka may interesting siyang sabihin tungkol dito."

"Then go ask him. Okay, well, hanggang bukas."

"Bye, Rishi. Salamat sa interesting na lesson."