ஜாவா ஆர்எம்ஐ

வணக்கம்! இன்று நாம் ஒரு சுவாரஸ்யமான தலைப்பைக் கருத்தில் கொள்வோம்: ஜாவா ஆர்எம்ஐ. இது தொலைநிலை முறை அழைப்பைக் குறிக்கிறது. வெவ்வேறு கணினிகளில் இருந்தாலும், இரண்டு புரோகிராம்கள் ஒன்றையொன்று தொடர்புகொள்ள அனுமதிக்க RMIஐப் பயன்படுத்தலாம். அது குளிர்ச்சியாக இருக்கிறதா? :) மற்றும் அதை செய்ய மிகவும் கடினம் அல்ல! இன்றைய பாடத்தில், RMI தொடர்புகளின் கூறுகளை பகுப்பாய்வு செய்வோம் மற்றும் அதை எவ்வாறு கட்டமைப்பது என்பதைக் கண்டுபிடிப்போம். நமக்கு முதலில் தேவை ஒரு கிளையன்ட் மற்றும் சர்வர். நாம் உண்மையில் கணினி சொற்களில் ஆழமாக மூழ்க வேண்டிய அவசியமில்லை. RMIக்கு வரும்போது, ​​இவை இரண்டு திட்டங்கள் மட்டுமே. அவற்றில் ஒன்று ஒரு பொருளை உள்ளடக்கும், மற்றொன்று அந்த பொருளின் முறைகளை அழைக்கும். வேறொரு நிரலில் இருக்கும் ஒரு பொருளின் அழைப்பு முறைகள் — இப்போது நாம் இன்னும் செய்யாத ஒன்று! முயற்சி செய்ய வேண்டிய நேரம் இது! :) சிக்கிக்கொள்ளாமல் இருக்க, விடுங்கள்' எங்கள் திட்டத்தை எளிமையாக வைத்திருங்கள். பொதுவாக, ஒரு சேவையகம் ஒரு கிளையன்ட் கோரும் சில கணக்கீடுகளை செய்கிறது. அது நமக்கும் அப்படித்தான் இருக்கும். எங்கள் சர்வர் ஒரு எளிய கால்குலேட்டர் நிரலாக இருக்கும். இதற்கு ஒரே ஒரு முறை மட்டுமே இருக்கும்:பெருக்கி() . இது கிளையன்ட் நிரல் மூலம் அனுப்பப்பட்ட இரண்டு எண்களை பெருக்கி, பின்னர் முடிவை வழங்கும். முதலில், நமக்கு ஒரு இடைமுகம் தேவை:

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface Calculator extends Remote {

   int multiply(int x, int y) throws RemoteException;
}

நமக்கு ஏன் ஒரு இடைமுகம் தேவை? ஏனெனில் RMI ஆனது நீங்கள் கடந்த பாடங்களில் படித்த ப்ராக்ஸிகளை உருவாக்குவதை நம்பியுள்ளது . உங்களுக்கு நினைவிருக்கலாம், நாங்கள் இடைமுகங்கள் மூலம் ப்ராக்ஸிகளுடன் வேலை செய்கிறோம், வகுப்புகள் அல்ல. எங்கள் இடைமுகத்திற்கு 2 முக்கியமான தேவைகள் உள்ளன!

1. இது தொலை இடைமுகத்தை நீட்டிக்க வேண்டும்.
2. அதன் அனைத்து முறைகளும் RemoteException (ஐடிஇ இதை தானாகச் செய்யாது - இதை நீங்கள் கைமுறையாகச் சேர்க்க வேண்டும்!).

இப்போது நாம் நமது கால்குலேட்டர் இடைமுகத்தை செயல்படுத்தும் சர்வர் வகுப்பை உருவாக்க வேண்டும் . இங்கே, எல்லாம் மிகவும் எளிது:

import java.rmi.RemoteException;

public class RemoteCalculationServer implements Calculator {

   @Override
   public int multiply(int x, int y) throws RemoteException {
       return x*y;
   }

}

இங்கே கருத்து சொல்ல உண்மையில் எதுவும் இல்லை :) இப்போது நாம் ஒரு சர்வர் நிரலை எழுத வேண்டும், அது நமது கால்குலேட்டர் பொருளை கட்டமைத்து இயக்கும். இது இப்படி இருக்கும்:

import java.rmi.AlreadyBoundException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;

public class ServerMain {

   public static final String UNIQUE_BINDING_NAME = "server.calculator";

   public static void main(String[] args) throws RemoteException, AlreadyBoundException, InterruptedException {

       final RemoteCalculationServer server = new RemoteCalculationServer();

       final Registry registry = LocateRegistry.createRegistry(2732);

       Remote stub = UnicastRemoteObject.exportObject(server, 0);
       registry.bind(UNIQUE_BINDING_NAME, stub);

       Thread.sleep(Integer.MAX_VALUE);

   }
}

இதைக் கண்டுபிடிப்போம் :) முதல் வரியில், சில சரம் மாறிகளை அறிவிக்கிறோம்:

public static final String UNIQUE_BINDING_NAME = "server.calculator";

இந்த சரம் தொலைதூர பொருளின் தனிப்பட்ட பெயர். எங்கள் சேவையகத்தைக் கண்டறிய எங்கள் கிளையன்ட் நிரல் இந்தப் பெயரைப் பயன்படுத்துகிறது: இதை நீங்கள் பின்னர் பார்க்கலாம். அடுத்து, எங்கள் கால்குலேட்டர் பொருளை உருவாக்குகிறோம்:

final RemoteCalculationServer server = new RemoteCalculationServer();

இங்கே எல்லாம் தெளிவாக உள்ளது. அடுத்து வருவது மிகவும் சுவாரஸ்யமானது:

final Registry registry = LocateRegistry.createRegistry(2732);

இந்த ரெஜிஸ்ட்ரி ஆப்ஜெக்ட் தொலைதூர பொருள்களின் பதிவேடு. இவை மற்ற புரோகிராம்கள் தொலைவிலிருந்து அணுகக்கூடிய பொருள்கள் :) 2732 என்ற எண்ணை LocateRegistry.createRegistry() முறைக்கு அனுப்பினோம் . இது போர்ட் எண் — பிற புரோகிராம்கள் நமது ஆப்ஜெக்ட் ரெஜிஸ்ட்ரியைக் கண்டறிய பயன்படுத்தும் தனித்துவமான எண் (மீண்டும், இதை நீங்கள் கீழே காண்பீர்கள்). வலதுபுறம் நகர்கிறது... அடுத்த வரியில் என்ன நடக்கிறது என்று பார்ப்போம்:

Remote stub = UnicastRemoteObject.exportObject(server, 0);

இந்த வரியில் ஒரு குட்டையை உருவாக்குகிறோம். ஒரு ஸ்டப் முழு தொலை அழைப்பையும் இணைக்கிறது. இதை நீங்கள் RMI இன் மிக முக்கியமான அங்கமாகக் கருதலாம். அது என்ன செய்யும்?

1. சில முறைகளின் தொலை அழைப்பு பற்றிய அனைத்து தகவல்களையும் இது பெறுகிறது.
2. முறை அளவுருக்கள் இருந்தால், ஸ்டப் அவற்றை சிதைக்கும். இந்த புள்ளியில் கவனம் செலுத்துங்கள்! தொலைவிலிருந்து அழைக்கப்படும் முறைகளுக்கு நீங்கள் அனுப்பும் வாதங்கள் வரிசைப்படுத்தக்கூடியதாக இருக்க வேண்டும் (எல்லாவற்றிற்கும் மேலாக, அவை பிணையத்தில் அனுப்பப்படும்). இது எங்களுக்கு எந்த பிரச்சனையும் இல்லை - நாங்கள் எண்களை அனுப்புகிறோம். ஆனால் நீங்கள் பொருட்களை கடத்துகிறீர்கள் என்றால், இந்த தேவையை மறந்துவிடாதீர்கள்!
3. அதன் பிறகு, ஸ்டப் விரும்பிய முறையை அழைக்கிறது.

நாங்கள் எங்கள் கால்குலேட்டர் சர்வர் பொருளை UnicastRemoteObject.exportObject() முறைக்கு அனுப்புகிறோம். அதன் முறைகளை தொலைதூரத்தில் அழைப்பதை இதுவே சாத்தியமாக்குகிறது. செய்ய வேண்டியது ஒன்றே ஒன்றுதான்:

registry.bind(UNIQUE_BINDING_NAME, stub);

ஆரம்பத்திலேயே நாங்கள் உருவாக்கிய பெயரில் ரிமோட் ஆப்ஜெக்ட் ரெஜிஸ்ட்ரியில் எங்கள் ஸ்டப்பை "பதிவு" செய்கிறோம். இப்போது வாடிக்கையாளர் அதைக் கண்டுபிடிக்க முடியும்! நிரலின் முக்கிய நூலை இறுதியில் தூங்க வைப்பதை நீங்கள் கவனித்திருக்கலாம்:

Thread.sleep(Integer.MAX_VALUE);

சேவையகம் நீண்ட நேரம் இயங்க வேண்டும். IDE இல், நாங்கள் ஒரே நேரத்தில் இரண்டு முக்கிய() முறைகளை தொடங்குவோம்: முதலில், சர்வரின் மெயின்() முறை ( நாம் ஏற்கனவே எழுதியுள்ள சர்வர்மெயின் வகுப்பில்), இரண்டாவது, கிளையண்டின் மெயின்() முறை (ClientMain வகுப்பில் , நாம் கீழே எழுதுவோம்). கிளையண்டைத் தொடங்கும் போது சர்வர் நிரல் நிறுத்தப்படாமல் இருப்பது முக்கியம், எனவே அதை நீண்ட நேரம் தூங்க வைக்கிறோம். எந்த நிகழ்விலும், அது தொடர்ந்து இயங்கும் :) இப்போது நாம் நமது சர்வரின் மெயின்() முறையை இயக்கலாம் . அது இயங்கட்டும் மற்றும் கிளையன்ட் நிரல் சில முறைகளை அழைக்க காத்திருக்கவும் :) இப்போது கிளையன்ட் நிரலை எழுதுவோம்! பெருக்குவதற்கு எண்களை நமது சர்வருக்கு அனுப்பும்.

import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class ClientMain {

   public static final String UNIQUE_BINDING_NAME = "server.calculator";

   public static void main(String[] args) throws RemoteException, NotBoundException {

       final Registry registry = LocateRegistry.getRegistry(2732);

       Calculator calculator = (Calculator) registry.lookup(UNIQUE_BINDING_NAME);

       int multiplyResult = calculator.multiply(20, 30);

       System.out.println(multiplyResult);
   }
}

இது எளிமையானதாகத் தெரிகிறது. ஆனால் இங்கே என்ன நடக்கிறது? முதலில், கிளையன்ட் பொருளின் தனிப்பட்ட பெயரை அறிந்திருக்க வேண்டும், அதன் முறைகள் தொலைதூரத்தில் அழைக்கப்படும். அதன்படி, கிளையன்ட் திட்டத்தில், பொது நிலையான இறுதி சரத்தை உருவாக்கினோம் UNIQUE_BINDING_NAME = "server.calculator"; மாறி. அடுத்து, மெயின்() முறையில், தொலைநிலைப் பொருள்களின் பதிவேடுக்கான அணுகலைப் பெறுகிறோம். இதைச் செய்ய, நாங்கள் LocateRegistry.getRegistry() முறையை அழைக்க வேண்டும் மற்றும் சர்வர்மெயின் நிரலில் எங்கள் பதிவேட்டை உருவாக்கப் பயன்படுத்தப்படும் போர்ட் எண்ணை அனுப்ப வேண்டும் (போர்ட் 2732; இந்த எண் ஒரு எடுத்துக்காட்டு - நீங்கள் வேறு எண்ணைப் பயன்படுத்தி முயற்சி செய்யலாம்):

final Registry registry = LocateRegistry.getRegistry(2732);

இப்போது நாம் விரும்பிய பொருளை பதிவேட்டில் இருந்து பெற வேண்டும்! இது எளிதானது, ஏனென்றால் அதன் தனித்துவமான பெயர் எங்களுக்குத் தெரியும்!

Calculator calculator = (Calculator) registry.lookup(UNIQUE_BINDING_NAME);

வார்ப்பு வகைக்கு கவனம் செலுத்துங்கள். பெறப்பட்ட பொருளை நாங்கள் கால்குலேட்டர் இடைமுகத்திற்கு அனுப்புகிறோம், ரிமோட்கால்குலேஷன் சர்வர் வகுப்பிற்கு அல்ல . பாடத்தின் ஆரம்பத்தில் நாங்கள் கூறியது போல், RMI ஒரு ப்ராக்ஸியை நம்பியுள்ளது, எனவே தொலைநிலை அழைப்புகள் இடைமுகத்தின் முறைகளுக்கு மட்டுமே கிடைக்கும், வகுப்புகளின் முறைகள் அல்ல. இறுதியாக, பெருக்கி() முறையை நமது பொருளின் மீது தொலைநிலையில் அழைக்கிறோம் மற்றும் முடிவை கன்சோலுக்கு வெளியிடுகிறோம்.

int multiplyResult = calculator.multiply(20, 30);
System.out.println(multiplyResult);

ServerMain வகுப்பின் முக்கிய() முறை ஏற்கனவே நீண்ட காலமாக இயங்கி வருகிறது . இப்போது கிளையன்ட் புரோகிராமில் ( ClientMain ) மெயின்() முறையை இயக்க வேண்டிய நேரம் வந்துவிட்டது ! கன்சோல் வெளியீடு:

600

அவ்வளவுதான்! எங்களின் புரோகிராம் (உண்மையில் இரண்டு புரோகிராம்கள்!) என்ன செய்ய வேண்டுமோ அதைச் செய்திருக்கிறது :) உங்களுக்கு நேரமும் விருப்பமும் இருந்தால், இதை கொஞ்சம் மசாலா செய்யலாம். எடுத்துக்காட்டாக, கால்குலேட்டரை நான்கு நிலையான எண்கணித செயல்பாடுகளை ஆதரிக்கவும், மேலும் எண்களை ஆரம்ப வகைகளாக இல்லாமல், CalculationInstance(int x, int y) ஆப்ஜெக்ட்களாக அனுப்பவும். அடுத்த பாடத்தில் சந்திப்போம்! :)