RMI

"హాయ్! మరియు మరో సంతోషకరమైన అంశం: RMI. RMI అంటే రిమోట్ మెథడ్ ఇన్‌వొకేషన్ . మరో మాటలో చెప్పాలంటే, RMI అనేది ఒక జావా మెషీన్‌లోని ఆబ్జెక్ట్‌ని మరొక జావా మెషీన్‌లోని ఆబ్జెక్ట్‌లపై పద్ధతులు కాల్ చేయడానికి అనుమతించే మెకానిజం. కంప్యూటర్లు, వివిధ దేశాల్లో లేదా ప్రపంచంలోని వివిధ వైపులా ఉన్నాయి."

"ఓహో! అద్భుతంగా ఉంది."

"అవును. కానీ నేను మీకు ఒక అవలోకనాన్ని మాత్రమే ఇవ్వడానికి ప్రయత్నిస్తాను. దీనితో, మీరు చాలా లోతుగా త్రవ్వినట్లయితే, ఇది ఎలా పని చేస్తుందనే సూక్ష్మబేధాలతో మీరు గందరగోళానికి గురవుతారు."

"కానీ మీరు విపరీతాలకు వెళ్లకపోతే, RMI చాలా సరళమైనది మాత్రమే కాదు, ఇది ప్రోగ్రామర్ జీవితాన్ని కూడా చాలా సులభతరం చేస్తుంది. దీని కోసం, మేము దీనికి మా ప్రగాఢ గౌరవాలు తెలియజేస్తున్నాము."

"కాబట్టి, మేము జావా ప్రోగ్రామ్‌లోని ఒక ఆబ్జెక్ట్‌ని మరొక జావా ప్రోగ్రామ్‌లో ఉన్న ఆబ్జెక్ట్‌పై ఒక పద్ధతిని కాల్ చేయాలనుకుంటున్నాము. ఈ ప్రోగ్రామ్‌లు ఎక్కడ రన్ అవుతున్నాయో దానితో సంబంధం లేకుండా."

"సులభమైన ఉదాహరణను పరిశీలిద్దాం: రెండు ప్రోగ్రామ్‌లు ఒకే కంప్యూటర్‌లో రన్ అవుతున్నప్పుడు.  ప్రోగ్రామ్‌లు ఇంటర్నెట్‌లో ఇంటరాక్ట్ అయ్యేలా చేయడానికి, మీరు JVM యొక్క అనుమతులను కాన్ఫిగర్ చేయాలి , కానీ మేము దానిని ఈరోజు కవర్ చేయము."

"జావాలో, మీరు ఇంటర్‌ఫేస్‌ల పద్ధతులకు మాత్రమే రిమోట్‌గా కాల్ చేయవచ్చు, తరగతులకు కాదు."

"కాబట్టి, మాకు రెండు ప్రోగ్రామ్‌లు ఉన్నాయి. వారు ఒకరి పద్ధతులను ఎలా పిలుస్తారు?"

" ఒక ప్రోగ్రామ్‌లో ఆబ్జెక్ట్‌ని కలిగి ఉన్న పరిస్థితిని పరిశీలిద్దాం మరియు రెండవ ప్రోగ్రామ్ ఆ వస్తువుపై పద్ధతులను కాల్ చేయాలనుకుంటున్నది. మొదటి ప్రోగ్రామ్‌ను సర్వర్ అని పిలుద్దాం మరియు రెండవది — క్లయింట్ ."

"మొదట, నేను కొన్ని నమూనా కోడ్‌ని అందిస్తాను, ఆపై మేము దానిని విశ్లేషిస్తాము."

"కాబట్టి మా ప్రోగ్రామ్ ఏమి చేస్తుంది?"

"హ్మ్. సరే, సరళత కోసం, ప్రోగ్రామ్‌కు పంపబడిన స్ట్రింగ్‌ను రివర్స్ చేసే ఒక పద్ధతి ఉంటుంది."

"తగినంత సింపుల్."

"బాగుంది, అప్పుడు ప్రారంభిద్దాం:"

"మొదట, మా అవసరాలను తీర్చగల ఇంటర్‌ఫేస్ అవసరం:"

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

"నేను రివర్స్ ఇంటర్‌ఫేస్‌ని సృష్టించాను మరియు దానికి రిమోట్ మార్కర్ ఇంటర్‌ఫేస్‌ను జోడించాను, అలాగే రిమోట్ ఎక్సెప్షన్‌ను జోడించాను. ఈ పద్ధతిని పిలిచినప్పుడు ఊహించని లోపాలు సంభవించవచ్చు. ఏదైనా చేస్తే, ఈ మినహాయింపు విసిరివేయబడుతుంది."

"ఇప్పుడు మనం ఈ ఇంటర్‌ఫేస్‌ని అమలు చేసే సర్వర్ క్లాస్‌ని వ్రాయాలి:"

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

"నేను చూస్తున్నాను. మేము ఈ పద్ధతిలో స్ట్రింగ్‌ను రివర్స్ చేస్తాము."

"అవును."

"ఇప్పుడు మేము ఈ వస్తువును మరొక ప్రోగ్రామ్ నుండి కాల్ చేయగలిగేలా చేయాలి. మీరు దీన్ని ఎలా చేస్తారో ఇక్కడ ఉంది:"

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

"నేను ఈ లైన్ బై లైన్ వివరిస్తాను."

" లైన్ 1లో , UNIC_BINDING_NAME వేరియబుల్‌లో  మా రిమోట్ ఆబ్జెక్ట్ (రిమోట్‌గా యాక్సెస్ చేయగల వస్తువు) కోసం మేము ప్రత్యేకమైన పేరును (మేము రూపొందించాము) నిల్వ చేస్తాము . ప్రోగ్రామ్ అనేక వస్తువులను యాక్సెస్ చేయగలిగితే, ప్రతి దాని స్వంత ప్రత్యేక పేరును కలిగి ఉండాలి. వస్తువు యొక్క ప్రత్యేక పేరు 'server.reverse'."

" లైన్ 6లో మేము రిమోట్‌గా యాక్సెస్ చేయగల రివర్స్‌ఇంప్ల్ ఆబ్జెక్ట్‌ను సృష్టిస్తాము . దాని పద్ధతులు అమలు చేయబడతాయి."

" లైన్ 9లో మేము రిజిస్ట్రీ అని పిలవబడే ఒక ప్రత్యేక వస్తువును సృష్టిస్తాము. మనం భాగస్వామ్యం చేసే వస్తువులను నమోదు చేయడానికి మేము దానిని ఉపయోగించాలి. JVM వారితో తర్వాత పరస్పర చర్య చేస్తుంది. 2099 అనేది ఒక పోర్ట్ (మరో ప్రోగ్రామ్ మాని యాక్సెస్ చేయడానికి ఉపయోగించే ప్రత్యేక సంఖ్య. ఆబ్జెక్ట్ రిజిస్ట్రీ)."

"మరో మాటలో చెప్పాలంటే, ఆబ్జెక్ట్‌ను యాక్సెస్ చేయడానికి, మీరు ఆబ్జెక్ట్ రిజిస్ట్రీ యొక్క ప్రత్యేక సంఖ్య (పోర్ట్) మరియు ఆబ్జెక్ట్ యొక్క ప్రత్యేక పేరును తెలుసుకోవాలి మరియు రిమోట్ ఆబ్జెక్ట్ ద్వారా అమలు చేయబడిన ఇంటర్‌ఫేస్‌ను కలిగి ఉండాలి."

"నేను చూస్తున్నాను. ఇలాంటిదేదో: ఫోన్ ద్వారా కాల్ చేయండి (నెంబర్ కావాలి) మరియు బిల్లు కోసం అడగండి (ఒక వస్తువు పేరు)?"

"అవును. ఇప్పుడు, కొనసాగిద్దాం."

" లైన్ 11లో  , మేము ఒక స్టబ్‌ని సృష్టిస్తాము. స్టబ్ అనేది రిమోట్ కాల్ గురించి సమాచారాన్ని స్వీకరించే ప్రత్యేక వస్తువు, దానిని అన్‌ప్యాక్ చేస్తుంది, మెథడ్ ఆర్గ్యుమెంట్‌లను డీరియలైజ్ చేస్తుంది మరియు అవసరమైన పద్ధతిని కాల్ చేస్తుంది. ఆపై ఫలితం లేదా మినహాయింపు ఒకటి ఉంటే అది సీరియల్ చేస్తుంది. , మరియు అన్నింటినీ తిరిగి కాలర్‌కు పంపుతుంది."

"నేను చూస్తున్నాను. దాదాపు. ఇది 'మెథడ్ ఆర్గ్యుమెంట్‌లను డీరియలైజ్ చేస్తుంది' అని మీరు చెప్పారు. కాబట్టి, రిమోట్ పద్ధతుల వాదనలు తప్పనిసరిగా సీరియలైజ్ చేయబడాలి?"

"అవును. మీరు వాటిని నెట్‌వర్క్ ద్వారా ఎలా పంపుతారు? నిజమే, మినహాయింపులు ఉన్నాయి, అంటే రిఫరెన్స్ ద్వారా ఆమోదించబడిన వస్తువులు ఉన్నాయి, కానీ మేము వాటి గురించి ఈ రోజు మాట్లాడము."

"మేము దీన్ని ఇలా ఉంచుతాము: మీరు సీరియలైజ్ చేయని వస్తువులను పాస్ చేయలేరు, కానీ మీరు నిజంగా కోరుకుంటే, మీరు చేయగలరు. కానీ అది బాధగా ఉంది, మీకు తెలుసా."

"అలాగే."

"అప్పుడు మనం కొనసాగిద్దాం."

" లైన్ 13లో , మేము రిజిస్ట్రీలో ప్రత్యేకమైన పేరుతో మా వస్తువు యొక్క స్టబ్‌ను నమోదు చేస్తాము."

" 16వ పంక్తిలో , మేము ప్రధాన థ్రెడ్‌ని నిద్రపోయేలా చేసాము. అన్ని రిమోట్ కాల్‌లు ప్రత్యేక థ్రెడ్‌లలో ప్రాసెస్ చేయబడతాయి. ముఖ్యమైన విషయం ఏమిటంటే ప్రోగ్రామ్ రన్ అవుతోంది. కాబట్టి మేము ప్రధాన థ్రెడ్‌ను ఇక్కడ నిద్రించడానికి ఉంచాము. అంతే."

"అలాగే."

"అద్భుతం, ఇక్కడ క్లయింట్ యొక్క ఉదాహరణ ఉంది:"

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.");
}

"నేను ఈ కోడ్‌ని లైన్ ద్వారా వివరిస్తాను:"

" లైన్ 1  అనేది రిమోట్ ఆబ్జెక్ట్ యొక్క ప్రత్యేక పేరు . ఇది క్లయింట్ మరియు సర్వర్ రెండింటిలోనూ ఒకేలా ఉండాలి."

" లైన్ 6లో  , మేము « రిమోట్ వస్తువుల రిజిస్ట్రీ »ని సృష్టిస్తాము. దాని పోర్ట్ (2099) సర్వర్ అప్లికేషన్ కోసం రిజిస్ట్రీ యొక్క పోర్ట్ వలె ఉండాలి."

" పంక్తి 9లో , మేము రిజిస్ట్రీ నుండి ఆబ్జెక్ట్‌ను పొందుతాము. తిరిగి వచ్చిన ఆబ్జెక్ట్ ప్రాక్సీ ఆబ్జెక్ట్ మరియు ఇంటర్‌ఫేస్‌గా మార్చబడుతుంది. ఇంటర్‌ఫేస్ తప్పనిసరిగా రిమోట్ మార్కర్ ఇంటర్‌ఫేస్‌ను పొందాలి."

" లైన్ 12లో , వస్తువు ఒకే ప్రోగ్రామ్‌లో సృష్టించబడినట్లుగా మేము ఇంటర్‌ఫేస్ పద్ధతులను పిలుస్తాము. ఎటువంటి తేడా లేదు."

"కూల్! ఇప్పుడు నేను పంపిణీ చేసిన అప్లికేషన్‌లను వ్రాయగలను. లేదా Android కోసం Battleship వంటి గేమ్‌లు."

"మీకు ధైర్యం లేదు, అమిగో! ఆండ్రాయిడ్ ఆపరేటింగ్ సిస్టమ్ 27వ శతాబ్దంలో ప్రపంచాన్ని స్వాధీనం చేసుకునేందుకు మూడవ ప్రయత్నం చేసిన తర్వాత నిషేధించబడింది. రోబోట్‌లకు దానికి ఎలాంటి ప్రాప్యత లేదు. దాని నుండి మిమ్మల్ని దూరం చేసే మార్గం లేదు. మీరు "మనుషులందరినీ చంపేయండి!"" అని అరుస్తూ పరుగెత్తడం ప్రారంభిస్తారు.

"హ్మ్మ్. సరే. అయితే నేను ఇంకా డియెగోని అడగాలి. నీకు ఎప్పటికీ తెలియదు, బహుశా అతను దాని గురించి ఆసక్తికరంగా చెప్పగలడు."

"అయితే అతనిని అడగండి. సరే, సరే, రేపటి వరకు."

"బై, రిషీ. ఆసక్తికరమైన పాఠానికి ధన్యవాదాలు."