AOP అంటే ఏమిటి? కారక-ఆధారిత ప్రోగ్రామింగ్ సూత్రాలు

హాయ్, అబ్బాయిలు మరియు అమ్మాయిలు! ప్రాథమిక భావనలను అర్థం చేసుకోకుండా, కార్యాచరణను రూపొందించడానికి ఫ్రేమ్‌వర్క్‌లు మరియు విధానాలను పరిశోధించడం చాలా కష్టం. కాబట్టి ఈ రోజు మనం అటువంటి కాన్సెప్ట్ గురించి మాట్లాడుతాము — AOP, aka aspect-oriented programming . ఈ అంశం సులభం కాదు మరియు చాలా అరుదుగా నేరుగా ఉపయోగించబడుతుంది, కానీ అనేక ఫ్రేమ్‌వర్క్‌లు మరియు సాంకేతికతలు దీనిని హుడ్ కింద ఉపయోగిస్తాయి. మరియు కొన్నిసార్లు, ఇంటర్వ్యూల సమయంలో, ఇది ఏ విధమైన మృగం మరియు దానిని ఎక్కడ అన్వయించవచ్చో సాధారణ పరంగా వివరించమని మిమ్మల్ని అడగవచ్చు. కాబట్టి జావాలో AOP యొక్క ప్రాథమిక భావనలు మరియు కొన్ని సాధారణ ఉదాహరణలను పరిశీలిద్దాం . ఇప్పుడు, AOP అంటే ఆస్పెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్, ఇది క్రాస్-కటింగ్ ఆందోళనలను వేరు చేయడం ద్వారా అప్లికేషన్ యొక్క వివిధ భాగాల మాడ్యులారిటీని పెంచడానికి ఉద్దేశించిన నమూనా. దీన్ని నెరవేర్చడానికి, అసలు కోడ్‌కు మార్పులు చేయకుండా ప్రస్తుత కోడ్‌కి అదనపు ప్రవర్తన జోడించబడుతుంది. మరో మాటలో చెప్పాలంటే, సవరించిన కోడ్‌ను మార్చకుండా పద్ధతులు మరియు తరగతుల పైన అదనపు కార్యాచరణను వేలాడదీయడం అని మనం భావించవచ్చు. ఇది ఎందుకు అవసరం? ముందుగానే లేదా తరువాత, సాధారణ ఆబ్జెక్ట్-ఓరియెంటెడ్ విధానం ఎల్లప్పుడూ కొన్ని సమస్యలను సమర్థవంతంగా పరిష్కరించదని మేము నిర్ధారించాము. మరియు ఆ క్షణం వచ్చినప్పుడు, AOP రక్షించటానికి వస్తుంది మరియు అప్లికేషన్‌లను రూపొందించడానికి మాకు అదనపు సాధనాలను అందిస్తుంది. మరియు అదనపు సాధనాలు అంటే సాఫ్ట్‌వేర్ డెవలప్‌మెంట్‌లో పెరిగిన వశ్యత, అంటే నిర్దిష్ట సమస్యను పరిష్కరించడానికి మరిన్ని ఎంపికలు.

AOPని వర్తింపజేస్తోంది

ఆస్పెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ క్రాస్-కటింగ్ టాస్క్‌లను నిర్వహించడానికి రూపొందించబడింది, ఇది వివిధ పద్ధతుల ద్వారా చాలాసార్లు పునరావృతమయ్యే ఏదైనా కోడ్ కావచ్చు, ఇది పూర్తిగా ప్రత్యేక మాడ్యూల్‌గా రూపొందించబడదు. దీని ప్రకారం, AOP దీన్ని ప్రధాన కోడ్ వెలుపల ఉంచడానికి మరియు నిలువుగా ప్రకటించడానికి అనుమతిస్తుంది. అప్లికేషన్‌లో భద్రతా విధానాన్ని ఉపయోగించడం ఒక ఉదాహరణ. సాధారణంగా, అప్లికేషన్ యొక్క అనేక అంశాల ద్వారా భద్రత నడుస్తుంది. ఇంకా ఏమిటంటే, అప్లికేషన్ యొక్క భద్రతా విధానం అప్లికేషన్‌లోని అన్ని ఇప్పటికే ఉన్న మరియు కొత్త భాగాలకు సమానంగా వర్తింపజేయాలి. అదే సమయంలో, ఉపయోగంలో ఉన్న భద్రతా విధానం కూడా అభివృద్ధి చెందుతుంది. AOPని ఉపయోగించడానికి ఇది సరైన ప్రదేశం . అలాగే, మరొక ఉదాహరణ లాగింగ్. మాన్యువల్‌గా లాగింగ్ ఫంక్షనల్‌ని జోడించడం కంటే లాగింగ్‌కు AOP విధానాన్ని ఉపయోగించడం వల్ల అనేక ప్రయోజనాలు ఉన్నాయి:

1. లాగింగ్ కోసం కోడ్ జోడించడం మరియు తీసివేయడం సులభం: మీరు చేయాల్సిందల్లా కొన్ని అంశాలకు సంబంధించిన రెండు కాన్ఫిగరేషన్‌లను జోడించడం లేదా తీసివేయడం.

2. లాగింగ్ కోసం అన్ని సోర్స్ కోడ్‌లు ఒకే చోట ఉంచబడతాయి, కాబట్టి మీరు దానిని ఉపయోగించిన అన్ని స్థలాలను మాన్యువల్‌గా వేటాడాల్సిన అవసరం లేదు.

3. ఇప్పటికే వ్రాసిన పద్ధతులు మరియు తరగతులలో లేదా కొత్త కార్యాచరణలో లాగింగ్ కోడ్ ఎక్కడైనా జోడించబడుతుంది. ఇది కోడింగ్ లోపాల సంఖ్యను తగ్గిస్తుంది.

   అలాగే, డిజైన్ కాన్ఫిగరేషన్ నుండి ఒక అంశాన్ని తీసివేసేటప్పుడు, అన్ని ట్రేసింగ్ కోడ్ పోయిందని మరియు ఏదీ మిస్ కాలేదని మీరు నిర్ధారించుకోవచ్చు.

4. అంశాలు ప్రత్యేక కోడ్, వీటిని మెరుగుపరచవచ్చు మరియు మళ్లీ మళ్లీ ఉపయోగించవచ్చు.

AOP మినహాయింపు నిర్వహణ, కాషింగ్ మరియు నిర్దిష్ట కార్యాచరణను సంగ్రహించడం కోసం కూడా ఉపయోగించబడుతుంది.

AOP యొక్క ప్రాథమిక సూత్రాలు

ఈ అంశంలో మరింత ముందుకు వెళ్లడానికి, ముందుగా AOP యొక్క ప్రధాన భావనలను తెలుసుకుందాం. సలహా — అదనపు లాజిక్ లేదా కోడ్ జాయిన్ పాయింట్ నుండి పిలువబడుతుంది. జాయిన్ పాయింట్‌కి ముందు, తర్వాత లేదా బదులుగా సలహాలను నిర్వహించవచ్చు (క్రింద వాటి గురించి మరింత). సాధ్యమైన సలహా రకాలు :

1. ముందు — లక్ష్య పద్ధతులకు ముందు ఈ రకమైన సలహా ప్రారంభించబడుతుంది, అనగా చేరిన పాయింట్లు అమలు చేయబడతాయి. అంశాలను తరగతులుగా ఉపయోగిస్తున్నప్పుడు, సలహాలను ముందుగా వచ్చినట్లుగా గుర్తించడానికి మేము @Before ఉల్లేఖనాన్ని ఉపయోగిస్తాము. అంశాలను .aj ఫైల్‌లుగా ఉపయోగిస్తున్నప్పుడు , ఇది ముందు() పద్ధతిగా ఉంటుంది .

2. తర్వాత - సాధారణ అమలులో మరియు మినహాయింపును విసిరేటప్పుడు పద్ధతులు (జాయిన్ పాయింట్లు) పూర్తయిన తర్వాత అమలు చేయబడిన సలహా.

   అంశాలను తరగతులుగా ఉపయోగిస్తున్నప్పుడు, ఇది తర్వాత వచ్చే సలహా అని సూచించడానికి మేము @After ఉల్లేఖనాన్ని ఉపయోగించవచ్చు.

   అంశాలను .aj ఫైల్‌లుగా ఉపయోగిస్తున్నప్పుడు , ఇది after() పద్ధతి.

3. తిరిగి వచ్చిన తర్వాత - లక్ష్య పద్ధతి లోపాలు లేకుండా సాధారణంగా పూర్తయినప్పుడు మాత్రమే ఈ సలహా చేయబడుతుంది.

   అంశాలు తరగతులుగా సూచించబడినప్పుడు, మేము సలహాను విజయవంతంగా పూర్తి చేసిన తర్వాత అమలు చేస్తున్నట్లుగా గుర్తించడానికి @AfterReturning ఉల్లేఖనాన్ని ఉపయోగించవచ్చు.

   అంశాలను .aj ఫైల్‌లుగా ఉపయోగిస్తున్నప్పుడు , ఇది తర్వాత() రిటర్నింగ్ (ఆబ్జెక్ట్ obj) పద్ధతిగా ఉంటుంది .

4. విసిరిన తర్వాత - ఈ సలహా ఒక పద్ధతి, అంటే చేరిన పాయింట్, మినహాయింపును విసిరిన సందర్భాల కోసం ఉద్దేశించబడింది. కొన్ని రకాల విఫలమైన అమలును నిర్వహించడానికి మేము ఈ సలహాను ఉపయోగించవచ్చు (ఉదాహరణకు, మొత్తం లావాదేవీని వెనక్కి తీసుకోవడానికి లేదా అవసరమైన ట్రేస్ లెవల్‌తో లాగ్ చేయడానికి).

   తరగతి అంశాల కోసం, మినహాయింపును విసిరిన తర్వాత ఈ సలహా ఉపయోగించబడుతుందని సూచించడానికి @AfterThrowing ఉల్లేఖనం ఉపయోగించబడుతుంది.

   అంశాలను .aj ఫైల్‌లుగా ఉపయోగిస్తున్నప్పుడు , ఇది ఆఫ్టర్() త్రోయింగ్ (మినహాయింపు ఇ) పద్ధతిగా ఉంటుంది .

5. చుట్టూ — బహుశా సలహా యొక్క అత్యంత ముఖ్యమైన రకాల్లో ఒకటి. ఇది ఒక పద్ధతిని చుట్టుముడుతుంది, అంటే, మనం ఉపయోగించగల జాయిన్ పాయింట్, ఉదాహరణకు, ఇచ్చిన జాయిన్ పాయింట్ పద్ధతిని నిర్వహించాలా వద్దా అని ఎంచుకోండి.

   మీరు జాయిన్ పాయింట్ పద్ధతిని అమలు చేయడానికి ముందు మరియు తర్వాత అమలు చేసే సలహా కోడ్‌ను వ్రాయవచ్చు.

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

   తరగతులుగా అందించబడిన అంశాలు, చేరిక పాయింట్‌ను చుట్టే సలహాలను రూపొందించడానికి మేము @Around ఉల్లేఖనాన్ని ఉపయోగిస్తాము. .aj ఫైల్‌ల రూపంలో అంశాలను ఉపయోగిస్తున్నప్పుడు , ఈ పద్ధతి చుట్టూ() పద్ధతిగా ఉంటుంది .

జాయిన్ పాయింట్ — రన్నింగ్ ప్రోగ్రామ్‌లోని పాయింట్ (అంటే మెథడ్ కాల్, ఆబ్జెక్ట్ క్రియేషన్, వేరియబుల్ యాక్సెస్) ఇక్కడ సలహాను వర్తింపజేయాలి. మరో మాటలో చెప్పాలంటే, ఇది కోడ్ ఇంజెక్షన్ కోసం స్థలాలను కనుగొనడానికి ఉపయోగించే ఒక రకమైన సాధారణ వ్యక్తీకరణ (సలహా వర్తించవలసిన ప్రదేశాలు). పాయింట్‌కట్ — చేరిన పాయింట్ల సమితి . ఇచ్చిన జాయిన్ పాయింట్‌కి ఇచ్చిన సలహా వర్తిస్తుందో లేదో పాయింట్‌కట్ నిర్ణయిస్తుంది. యాస్పెక్ట్ — క్రాస్-కటింగ్ ఫంక్షనాలిటీని అమలు చేసే మాడ్యూల్ లేదా క్లాస్. కొన్ని పాయింట్‌కట్ ద్వారా నిర్వచించబడిన జాయిన్ పాయింట్‌ల వద్ద సలహాను వర్తింపజేయడం ద్వారా మిగిలిన కోడ్ యొక్క ప్రవర్తనను Aspect మారుస్తుంది . మరో మాటలో చెప్పాలంటే, ఇది సలహా మరియు జాయిన్ పాయింట్ల కలయిక. పరిచయం— ఫారిన్ కోడ్‌కు అంశం యొక్క కార్యాచరణను జోడించడానికి తరగతి యొక్క నిర్మాణాన్ని మార్చడం మరియు/లేదా వారసత్వ సోపానక్రమాన్ని మార్చడం. లక్ష్యం - సలహా వర్తించే వస్తువు. నేయడం — సలహా ఇవ్వబడిన ప్రాక్సీ వస్తువులను సృష్టించడానికి ఇతర వస్తువులకు అంశాలను లింక్ చేసే ప్రక్రియ. ఇది కంపైల్ సమయం, లోడ్ సమయం లేదా రన్ టైమ్‌లో చేయవచ్చు. నేయడంలో మూడు రకాలు ఉన్నాయి:

• కంపైల్-టైమ్ వీవింగ్ — మీరు ఆస్పెక్ట్ యొక్క సోర్స్ కోడ్ మరియు మీరు కారకాన్ని ఉపయోగించే కోడ్‌ని కలిగి ఉంటే, మీరు నేరుగా AspectJ కంపైలర్‌ని ఉపయోగించి సోర్స్ కోడ్ మరియు అంశాన్ని కంపైల్ చేయవచ్చు;

• పోస్ట్-కంపైల్ వీవింగ్ (బైనరీ వీవింగ్) — మీరు కోడ్‌లో అంశాలను నేయడానికి సోర్స్ కోడ్ పరివర్తనలను ఉపయోగించలేకపోతే లేదా ఉపయోగించకూడదనుకుంటే, మీరు గతంలో కంపైల్ చేసిన తరగతులు లేదా జార్ ఫైల్‌లను తీసుకోవచ్చు మరియు వాటిలో అంశాలను ఇంజెక్ట్ చేయవచ్చు;

• లోడ్-టైమ్ వీవింగ్ — ఇది కేవలం బైనరీ నేయడం, ఇది క్లాస్‌లోడర్ క్లాస్ ఫైల్‌ను లోడ్ చేసే వరకు మరియు JVM కోసం క్లాస్‌ను నిర్వచించే వరకు ఆలస్యం అవుతుంది.

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

AspectJ — క్రాస్-కటింగ్ టాస్క్‌లను నిర్వహించగల సామర్థ్యాన్ని అమలు చేసే AOP నమూనా యొక్క నిర్దిష్ట అమలు . డాక్యుమెంటేషన్ ఇక్కడ చూడవచ్చు .

జావాలో ఉదాహరణలు

తరువాత, AOP గురించి మంచి అవగాహన కోసం , మేము చిన్న "హలో వరల్డ్"-శైలి ఉదాహరణలను పరిశీలిస్తాము. బ్యాట్ కుడివైపు, మా ఉదాహరణలు కంపైల్-టైమ్ నేవింగ్‌ని ఉపయోగిస్తాయని నేను గమనించాను . ముందుగా, మన pom.xml ఫైల్‌లో కింది డిపెండెన్సీని జోడించాలి :

<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjrt</artifactId>
  <version>1.9.5</version>
</dependency>

నియమం ప్రకారం, ప్రత్యేక ajc కంపైలర్ మేము అంశాలను ఎలా ఉపయోగిస్తాము. IntelliJ IDEA దీన్ని డిఫాల్ట్‌గా చేర్చదు, కాబట్టి దీన్ని అప్లికేషన్ కంపైలర్‌గా ఎంచుకున్నప్పుడు, మీరు తప్పనిసరిగా 5168 75 AspectJ పంపిణీకి మార్గాన్ని పేర్కొనాలి. ఇది మొదటి మార్గం. రెండవది, నేను ఉపయోగించినది, ఈ క్రింది ప్లగిన్‌ను pom.xml ఫైల్‌లో నమోదు చేయడం:

<build>
  <plugins>
     <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>aspectj-maven-plugin</artifactId>
        <version>1.7</version>
        <configuration>
           <complianceLevel>1.8</complianceLevel>
           <source>1.8</source>
           <target>1.8</target>
           <showWeaveInfo>true</showWeaveInfo>
           <<verbose>true<verbose>
           <Xlint>ignore</Xlint>
           <encoding>UTF-8</encoding>
        </configuration>
        <executions>
           <execution>
              <goals>
                 <goal>compile</goal>
                 <goal>test-compile</goal>
              </goals>
           </execution>
        </executions>
     </plugin>
  </plugins>
</build>

దీని తర్వాత, Maven నుండి తిరిగి దిగుమతి చేసుకోవడం మరియు mvn క్లీన్ కంపైల్ రన్ చేయడం మంచిది . ఇప్పుడు నేరుగా ఉదాహరణలకు వెళ్దాం.

ఉదాహరణ సంఖ్య 1

ఒక ప్రధాన తరగతిని క్రియేట్ చేద్దాం . దీనిలో, మేము ఒక ఎంట్రీ పాయింట్ మరియు కన్సోల్‌లో పాస్ చేసిన పేరును ప్రింట్ చేసే పద్ధతిని కలిగి ఉంటాము:

public class Main {
 
  public static void main(String[] args) {
  printName("Tanner");
  printName("Victor");
  printName("Sasha");
  }
 
  public static void printName(String name) {
     System.out.println(name);
  }
}

ఇక్కడ సంక్లిష్టంగా ఏమీ లేదు. మేము ఒక పేరును ఆమోదించాము మరియు దానిని కన్సోల్‌లో ప్రదర్శిస్తాము. మేము ఇప్పుడు ప్రోగ్రామ్‌ను అమలు చేస్తే, కన్సోల్‌లో కింది వాటిని చూస్తాము: ఇప్పుడు, AOP యొక్క శక్తిని సద్వినియోగం చేసుకునే సమయం వచ్చింది. ఇప్పుడు మనం కారక ఫైల్‌ను సృష్టించాలి . అవి రెండు రకాలు: మొదటిది .aj ఫైల్ పొడిగింపును కలిగి ఉంది. రెండవది AOP సామర్థ్యాలను అమలు చేయడానికి ఉల్లేఖనాలను ఉపయోగించే సాధారణ తరగతి. .aj పొడిగింపుతో ఫైల్‌ని మొదట చూద్దాం :

public aspect GreetingAspect {
 
  pointcut greeting() : execution(* Main.printName(..));
 
  before() : greeting() {
     System.out.print("Hi, ");
  }
}

ఈ ఫైల్ కాస్త క్లాస్ లాగా ఉంది. ఇక్కడ ఏమి జరుగుతుందో చూద్దాం: పాయింట్‌కట్ అనేది చేరిన పాయింట్ల సమితి; గ్రీటింగ్() అనేది ఈ పాయింట్‌కట్ పేరు; : అమలు అనేది Main.printName(...) పద్ధతి యొక్క అన్ని ( * ) కాల్‌ల అమలు సమయంలో దీన్ని వర్తింపజేయాలని సూచిస్తుంది . తదుపరి ఒక నిర్దిష్ట సలహా వస్తుంది — before() — ఇది లక్ష్య పద్ధతిని పిలవడానికి ముందు అమలు చేయబడుతుంది. : గ్రీటింగ్() అనేది ఈ సలహాకు ప్రతిస్పందించే కట్‌పాయింట్. బాగా, మరియు క్రింద మేము పద్ధతి యొక్క శరీరాన్ని చూస్తాము, ఇది జావా భాషలో వ్రాయబడింది, ఇది మనకు అర్థం అవుతుంది. మేము ఈ అంశంతో ప్రధానంగా రన్ చేసినప్పుడు , మేము ఈ కన్సోల్ అవుట్‌పుట్‌ని పొందుతాము: ప్రింట్‌నేమ్ పద్ధతికి సంబంధించిన ప్రతి కాల్ ఒక అంశానికి ధన్యవాదాలు సవరించబడిందని మనం చూడవచ్చు . ఇప్పుడు ఉల్లేఖనాలతో జావా క్లాస్ ఎలా ఉంటుందో చూద్దాం:

@Aspect
public class GreetingAspect{
 
  @Pointcut("execution(* Main.printName(String))")
  public void greeting() {
  }
 
  @Before("greeting()")
  public void beforeAdvice() {
     System.out.print("Hi, ");
  }
}

.aj aspect ఫైల్ తర్వాత , ప్రతిదీ ఇక్కడ మరింత స్పష్టంగా కనిపిస్తుంది:

• @Aspect ఈ తరగతి ఒక అంశం అని సూచిస్తుంది;
• @Pointcut("execution(* Main.printName(String))") అనేది స్ట్రింగ్ రకం ఇన్‌పుట్ ఆర్గ్యుమెంట్‌తో Main.printName కి చేసే అన్ని కాల్‌ల కోసం ట్రిగ్గర్ చేయబడిన కట్‌పాయింట్ ;
• @బిఫోర్("గ్రీటింగ్()") అనేది గ్రీటింగ్() కట్‌పాయింట్‌లో పేర్కొన్న కోడ్‌కి కాల్ చేయడానికి ముందు వర్తించే సలహా .

ఈ అంశంతో మెయిన్‌ని అమలు చేయడం వలన కన్సోల్ అవుట్‌పుట్ మారదు:

ఉదాహరణ సంఖ్య 2

క్లయింట్‌ల కోసం కొన్ని కార్యకలాపాలను నిర్వహించే కొన్ని పద్ధతిని కలిగి ఉన్నాము మరియు మేము ఈ పద్ధతిని ప్రధాన నుండి పిలుస్తాము :

public class Main {
 
  public static void main(String[] args) {
  performSomeOperation("Tanner");
  }
 
  public static void performSomeOperation(String clientName) {
     System.out.println("Performing some operations for Client " + clientName);
  }
}

"సూడో-లావాదేవీ"ని సృష్టించడానికి @Around ఉల్లేఖనాన్ని ఉపయోగిస్తాము :

@Aspect
public class TransactionAspect{
 
  @Pointcut("execution(* Main.performSomeOperation(String))")
  public void executeOperation() {
  }

  @Around(value = "executeOperation()")
  public void beforeAdvice(ProceedingJoinPoint joinPoint) {
     System.out.println("Opening a transaction...");
     try {
        joinPoint.proceed();
        System.out.println("Closing a transaction...");
     }
     catch (Throwable throwable) {
        System.out.println("The operation failed. Rolling back the transaction...");
     }
  }
  }

ProceedingJoinPoint ఆబ్జెక్ట్ యొక్క ప్రొసీడ్ మెథడ్‌తో , సలహాలో దాని స్థానాన్ని గుర్తించడానికి మేము చుట్టే పద్ధతిని పిలుస్తాము . కాబట్టి, joinPoint.proceed() పైన ఉన్న పద్ధతిలోని కోడ్ ; ముందు ఉంది , దాని క్రింద ఉన్న కోడ్ తర్వాత . మేము ప్రధాన రన్ చేస్తే , మేము దీన్ని కన్సోల్‌లో పొందుతాము: కానీ మేము మా పద్ధతిలో త్రో మరియు మినహాయింపు (విఫలమైన ఆపరేషన్‌ను అనుకరించడానికి):

public static void performSomeOperation(String clientName) throws Exception {
  System.out.println("Performing some operations for Client " + clientName);
  throw new Exception();
}

అప్పుడు మనకు ఈ కన్సోల్ అవుట్‌పుట్ వస్తుంది: కాబట్టి మేము ఇక్కడ ముగించినది ఒక రకమైన లోపం నిర్వహణ సామర్ధ్యం.

ఉదాహరణ సంఖ్య 3

మా తదుపరి ఉదాహరణలో, కన్సోల్‌కి లాగింగ్ వంటిది చేద్దాం. ముందుగా, మెయిన్‌ని పరిశీలించండి , ఇక్కడ మేము కొన్ని నకిలీ వ్యాపార తర్కాన్ని జోడించాము:

public class Main {
  private String value;
 
  public static void main(String[] args) throws Exception {
     Main main = new Main();
     main.setValue("<some value>");
     String valueForCheck = main.getValue();
     main.checkValue(valueForCheck);
  }
 
  public void setValue(String value) {
     this.value = value;
  }
 
  public String getValue() {
     return this.value;
  }
 
  public void checkValue(String value) throws Exception {
     if (value.length() > 10) {
        throw new Exception();
     }
  }
}

ప్రధానంగా , విలువ ఉదాహరణ వేరియబుల్‌కు విలువను కేటాయించడానికి మేము సెట్‌వాల్యూని ఉపయోగిస్తాము . విలువను పొందడానికి మేము getValueని ఉపయోగిస్తాము , ఆపై అది 10 అక్షరాల కంటే ఎక్కువగా ఉందో లేదో చూడటానికి చెక్‌వాల్యూ అని పిలుస్తాము. అలా అయితే, అప్పుడు మినహాయింపు విసిరివేయబడుతుంది. ఇప్పుడు మనం పద్ధతుల పనిని లాగ్ చేయడానికి ఉపయోగించే అంశాన్ని చూద్దాం:

@Aspect
public class LogAspect {
 
  @Pointcut("execution(* *(..))")
  public void methodExecuting() {
  }
 
  @AfterReturning(value = "methodExecuting()", returning = "returningValue")
  public void recordSuccessfulExecution(JoinPoint joinPoint, Object returningValue) {
     if (returningValue != null) {
        System.out.printf("Successful execution: method — %s method, class — %s class, return value — %s\n",
              joinPoint.getSignature().getName(),
              joinPoint.getSourceLocation().getWithinType().getName(),
              returningValue);
     }
     else {
        System.out.printf("Successful execution: method — %s, class — %s\n",
              joinPoint.getSignature().getName(),
              joinPoint.getSourceLocation().getWithinType().getName());
     }
  }
 
  @AfterThrowing(value = "methodExecuting()", throwing = "exception")
  public void recordFailedExecution(JoinPoint joinPoint, Exception exception) {
     System.out.printf("Exception thrown: method — %s, class — %s, exception — %s\n",
           joinPoint.getSignature().getName(),
           joinPoint.getSourceLocation().getWithinType().getName(),
           exception);
  }
}

ఏమి జరుగుతుంది ఇక్కడ? @Pointcut("ఎగ్జిక్యూషన్(* *(..))") అన్ని పద్ధతుల యొక్క అన్ని కాల్‌లలో చేరుతుంది. @AfterReturning(value = "methodExecuting()", returning = "returningValue") అనేది లక్ష్య పద్ధతిని విజయవంతంగా అమలు చేసిన తర్వాత అమలు చేయబడే సలహా. మాకు ఇక్కడ రెండు కేసులు ఉన్నాయి:

1. పద్ధతి తిరిగి విలువను కలిగి ఉన్నప్పుడు — ఉంటే (రిటర్నింగ్ వాల్యూ! = శూన్యం) {
2. రిటర్న్ విలువ లేనప్పుడు — వేరే {

@ఆఫ్టర్ త్రోయింగ్(విలువ = "మెథడ్ ఎగ్జిక్యూటింగ్()", త్రోయింగ్ = "మినహాయింపు") అనేది లోపం సంభవించినప్పుడు, అంటే, పద్ధతి మినహాయింపును విసిరినప్పుడు సూచించబడే సలహా. మరియు తదనుగుణంగా, ప్రధాన రన్ చేయడం ద్వారా , మేము ఒక రకమైన కన్సోల్-ఆధారిత లాగింగ్‌ను పొందుతాము: మరియు మేము మినహాయింపులను నిర్వహించనందున, మేము ఇప్పటికీ స్టాక్ ట్రేస్‌ను పొందుతాము: మీరు ఈ కథనాలలో మినహాయింపులు మరియు మినహాయింపు నిర్వహణ గురించి చదువుకోవచ్చు: జావాలో మినహాయింపులు మరియు మినహాయింపులు: పట్టుకోవడం మరియు నిర్వహించడం . ఈరోజు నాకు అంతే. ఈ రోజు మనం AOP తో పరిచయం పొందాము మరియు ఈ మృగం కొంతమంది వ్యక్తులు చేసినంత భయానకంగా లేదని మీరు చూడగలిగారు. వీడ్కోలు, అందరూ!