டைனமிக் ப்ராக்ஸி

"வணக்கம், அமிகோ."

"ஹலோ ரிஷி."

"இன்று நான் உங்களுக்கு ஒரு புதிய மற்றும் மிகவும் சுவாரஸ்யமான தலைப்பை விளக்குகிறேன்: டைனமிக் ப்ராக்ஸிகள்" .

"ஒரு குறிப்பிட்ட வகுப்பின் செயல்பாட்டை மாற்ற ஜாவாவில் பல வழிகள் உள்ளன..."

"முதல் முறை பரம்பரை."

"ஒரு வகுப்பின் நடத்தையை மாற்றுவதற்கான எளிதான வழி, அசல் (அடிப்படை) வகுப்பைப் பெற்ற புதிய வகுப்பை உருவாக்கி, அதன் முறைகளை மீறுவதாகும். பின்னர், அசல் வகுப்பைப் பயன்படுத்துவதற்குப் பதிலாக, நீங்கள் பெறப்பட்ட வகுப்பைப் பயன்படுத்துகிறீர்கள். எடுத்துக்காட்டாக:"

Reader reader = new UserCustomReader();

"இரண்டாவது முறை ஒரு ரேப்பர் வகுப்பைப் பயன்படுத்துவதாகும்."

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

Reader readerOriginal = new UserCustomReader();
Reader reader = new BufferedReader(readerOriginal);

"மூன்றாவது முறை டைனமிக் ப்ராக்ஸியை (ப்ராக்ஸி) உருவாக்குவதாகும்."

"ஜாவாவில் (java.lang.reflect.Proxy) ஒரு சிறப்பு வகுப்பு உள்ளது, இது நிரல் செயல்பாட்டின் போது (டைனமிகலாக) ஒரு பொருளை உருவாக்குவதற்கு தனி வகுப்பை உருவாக்காமல் உங்களை அனுமதிக்கிறது."

"இதைச் செய்வது மிகவும் எளிதானது:"

Reader reader = (Reader)Proxy.newProxyInstance();

"இது எனக்கு ஏற்கனவே புதிய விஷயம்!"

"ஆனால், நிச்சயமாக, முறைகள் இல்லாத ஒரு பொருள் நமக்குத் தேவையில்லை. முறைகளைக் கொண்ட பொருள் நமக்குத் தேவை, மேலும் அவை நமக்குத் தேவையானதைச் செய்ய வேண்டும். ஜாவா இதற்கு இன்வொக்கேஷன்ஹேண்ட்லர் எனப்படும் ஒரு சிறப்பு இடைமுகத்தைப் பயன்படுத்துகிறது, இது அனைத்து முறை அழைப்புகளையும் இடைமறிக்கும் . ப்ராக்ஸி பொருளுடன் தொடர்புடையது . இடைமுகங்களைப் பயன்படுத்தி மட்டுமே ப்ராக்ஸி பொருளை உருவாக்க முடியும்."

" அழைப்பு - ஒரு முறை அல்லது வகுப்பிற்கான நிலையான பெயர், அதன் முதன்மை பணி சில முறைகளை அழைப்பது."

" ஹேண்ட்லர் - சில நிகழ்வுகளைக் கையாளும் வகுப்பின் நிலையான பெயர். எடுத்துக்காட்டாக, மவுஸ் கிளிக்குகளைக் கையாளும் ஒரு வகுப்பு MouseClickHandler, முதலியன என்று அழைக்கப்படும்."

"InvocationHandler இடைமுகம் ஒற்றை அழைப்பிதழ் முறையைக் கொண்டுள்ளது, ப்ராக்ஸி பொருளுக்கான அனைத்து அழைப்புகளும் அனுப்பப்படும் . எடுத்துக்காட்டாக:"

Reader reader = (Reader)Proxy.newProxyInstance(new CustomInvocationHandler());
reader.close();

class CustomInvocationHandler implements InvocationHandler
{
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
 {
  System.out.println("yes!");
  return null;
 }
}

" ரீடரை அழைக்கும் போது . மூட () முறை, அழைப்பு முறை அழைக்கப்படும், மேலும் திரை 'ஆம்!'

"எனவே, நாங்கள் ஒரு CustomInvocationHandler, வகுப்பை அறிவித்து, InvocationHandler இடைமுகத்தையும் அதன் அழைப்பிதழ் முறையையும் செயல்படுத்தினோம். அழைப்பு முறை அழைக்கப்படும்போது, ​​அது 'ஆம்!' என்பதைக் காட்டுகிறது. பின்னர் நாங்கள் CustomInvocationHandler பொருளை உருவாக்கி, அதை உருவாக்கும்போது புதியProxyInstance முறைக்கு அனுப்பினோம். ஒரு ப்ராக்ஸி பொருள்."

"ஆம், அதெல்லாம் சரிதான்."

"இது மிகவும் சக்திவாய்ந்த கருவியாகும். பொதுவாக, இந்த ப்ராக்ஸிகள் மற்றொரு கணினியில் இயங்கும் நிரல்களில் உள்ள பொருட்களை உருவகப்படுத்துவதற்காக உருவாக்கப்படுகின்றன .  அல்லது அணுகலைக் கட்டுப்படுத்த."

"தற்போதைய பயனரின் அனுமதிகளை நீங்கள் சரிபார்க்கலாம், பிழைகளைக் கையாளலாம், பதிவு பிழைகள் மற்றும் பலவற்றை இந்த முறையில் செய்யலாம்."

"இங்கே ஒரு உதாரணம் உள்ளது, இதில் அழைப்பு முறையானது அசல் பொருளின் முறைகளையும் அழைக்கிறது:"

Reader original = new UserCustomReader();

Reader reader = (Reader)Proxy.newProxyInstance(new CustomInvocationHandler(original));
reader.close();

class CustomInvocationHandler implements InvocationHandler
{
 private Reader readerOriginal;

 CustomInvocationHandler(Reader readerOriginal)
 {
  this.readerOriginal = readerOriginal;
 }

 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
 {
  if (method.getName().equals("close"))
  {
   System.out.println("Reader closed!");
  }

  // This calls the readerOriginal object's close method.
  // The method's name and a description of its parameters are stored in the method variable.
  return method.invoke(readerOriginal, args);
 }
}

"இந்த உதாரணம் இரண்டு சிறப்பு அம்சங்களைக் கொண்டுள்ளது."

"முதலில், «அசல்» ரீடர் பொருள் கட்டமைப்பாளருக்கு அனுப்பப்படுகிறது, மேலும் அது பற்றிய குறிப்பு CustomInvocationHandler க்குள் சேமிக்கப்படும் .

"இரண்டாவதாக, இதே முறையை மீண்டும் அழைப்பு முறையில் அழைக்கிறோம், ஆனால் இந்த முறை "அசல்" பொருளில்."

"ஆ. வேறுவிதமாகக் கூறினால், இந்த கடைசி வரி அதே முறையை அழைக்கிறது, ஆனால் அசல் பொருளில்:"

return method.invoke(readerOriginal, args);

"ஆமாம்."

"இது மிகவும் வெளிப்படையானது என்று நான் கூறமாட்டேன், ஆனால் அது இன்னும் புரிந்துகொள்ளக்கூடியது. அல்லது அப்படித் தோன்றுகிறது."

"நல்லது. அப்புறம் இன்னொரு விஷயம். newProxyInstance முறையில், ஒரு ப்ராக்ஸி பொருளை உருவாக்க, நீங்கள் இன்னும் கொஞ்சம் வீட்டு பராமரிப்புத் தகவலை அனுப்ப வேண்டும். ஆனால் நாங்கள் பயங்கரமான ப்ராக்ஸி பொருட்களை உருவாக்கவில்லை என்பதால், அசல் வகுப்பிலிருந்தே இந்தத் தகவல் எளிதாகப் பெறப்படுகிறது. "

"இதோ மற்றொரு உதாரணம்:"

Reader original = new UserCustomReader();

ClassLoader classLoader = original.getClass().getClassLoader();
Class<?>[] interfaces = original.getClass().getInterfaces();
CustomInvocationHandler invocationHandler = new CustomInvocationHandler(original);

Reader reader = (Reader)Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);

class CustomInvocationHandler implements InvocationHandler
{
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
 {
  return null;
 }
}

"ஆ. கிளாஸ்லோடர் மற்றும் இடைமுகங்களின் பட்டியல். இது பிரதிபலிப்பிலிருந்து வந்த ஒன்று, இல்லையா?"

"ஆமாம்."

"பார்க்கிறேன். சரி, எனக்கு எப்போதாவது தேவைப்பட்டால், ஒரு பழமையான, மிக எளிமையான ப்ராக்ஸி பொருளை உருவாக்க முடியும் என்று நினைக்கிறேன்."

"அப்படியானால், டியாகோவுடன் சரிபார்க்கவும்."