డైనమిక్ ప్రాక్సీ

"హాయ్, అమిగో."

"హలో, రిషీ."

"ఈ రోజు నేను మీకు కొత్త మరియు చాలా ఆసక్తికరమైన అంశాన్ని వివరిస్తాను: డైనమిక్ ప్రాక్సీలు" .

"ఒక నిర్దిష్ట తరగతి యొక్క కార్యాచరణను మార్చడానికి జావాకు అనేక మార్గాలు ఉన్నాయి..."

"మొదటి పద్ధతి వారసత్వం."

"తరగతి ప్రవర్తనను మార్చడానికి సులభమైన మార్గం అసలైన (బేస్) తరగతిని వారసత్వంగా పొందే కొత్త తరగతిని సృష్టించడం మరియు దాని పద్ధతులను భర్తీ చేయడం. తర్వాత, అసలు తరగతిని ఉపయోగించకుండా, మీరు ఉత్పన్నమైన తరగతిని ఉపయోగిస్తారు. ఉదాహరణకు:"

Reader reader = new UserCustomReader();

"రెండవ పద్ధతి రేపర్ తరగతిని ఉపయోగించడం."

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

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, classని ప్రకటించాము మరియు InvocationHandler ఇంటర్‌ఫేస్ మరియు దాని ఇన్‌వోక్ పద్ధతిని అమలు చేసాము. ఇన్‌వోక్ పద్ధతిని పిలిచినప్పుడు, అది 'అవును!'ని ప్రదర్శిస్తుంది. తర్వాత మేము CustomInvocationHandler ఆబ్జెక్ట్‌ని సృష్టించాము మరియు సృష్టించేటప్పుడు దాన్ని newProxyInstance పద్ధతికి పంపాము. ఒక ప్రాక్సీ వస్తువు."

"అవును, అదంతా కరెక్ట్."

"ఇది చాలా శక్తివంతమైన సాధనం. సాధారణంగా, ఈ ప్రాక్సీలు భౌతికంగా మరొక కంప్యూటర్‌లో నడుస్తున్న ప్రోగ్రామ్‌లలోని వస్తువులను అనుకరించడానికి  లేదా యాక్సెస్‌ని నియంత్రించడానికి సృష్టించబడతాయి ."

"మీరు ఈ పద్ధతిలో ప్రస్తుత వినియోగదారు అనుమతులను తనిఖీ చేయవచ్చు, లోపాలను నిర్వహించవచ్చు, లోపాలను లాగ్ చేయవచ్చు మరియు మరిన్ని చేయవచ్చు."

"ఇక్కడ ఒక ఉదాహరణ ఉంది, దీనిలో ఇన్‌వోక్ పద్ధతి అసలైన వస్తువు యొక్క పద్ధతులను కూడా పిలుస్తుంది:"

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

"ఆహ్. క్లాస్‌లోడర్ మరియు ఇంటర్‌ఫేస్‌ల జాబితా. ఇది రిఫ్లెక్షన్ నుండి వచ్చినది, కాదా?"

"అవును."

"నేను చూస్తున్నాను. సరే, నాకు ఎప్పుడైనా అవసరమైతే ఒక ఆదిమ, అతి సాధారణ ప్రాక్సీ వస్తువును సృష్టించగలనని అనుకుంటున్నాను."

"అప్పుడు డియెగోతో చెక్ ఇన్ చేయండి."