ஏஓபி என்றால் என்ன? அம்சம் சார்ந்த நிரலாக்கத்தின் கோட்பாடுகள்

வணக்கம், நண்பர்களே! அடிப்படைக் கருத்துகளைப் புரிந்து கொள்ளாமல், கட்டமைப்பை உருவாக்குவதற்கான கட்டமைப்புகள் மற்றும் அணுகுமுறைகளை ஆராய்வது மிகவும் கடினம். எனவே இன்று நாம் அத்தகைய ஒரு கருத்தைப் பற்றி பேசுவோம் - AOP, அல்லது அம்சம் சார்ந்த நிரலாக்கம் . இந்த தலைப்பு எளிதானது அல்ல, அரிதாகவே நேரடியாகப் பயன்படுத்தப்படுகிறது, ஆனால் பல கட்டமைப்புகள் மற்றும் தொழில்நுட்பங்கள் இதைப் பயன்படுத்துகின்றன. நிச்சயமாக, சில நேரங்களில் நேர்காணல்களின் போது, ​​இது என்ன வகையான மிருகம் மற்றும் அதை எங்கு பயன்படுத்தலாம் என்பதை பொதுவான சொற்களில் விவரிக்கும்படி கேட்கப்படலாம். எனவே ஜாவாவில் AOP இன் அடிப்படைக் கருத்துகள் மற்றும் சில எளிய எடுத்துக்காட்டுகளைப் பார்ப்போம் . இப்போது, ​​AOP என்பது அம்சம் சார்ந்த நிரலாக்கத்தைக் குறிக்கிறது, இது குறுக்கு வெட்டுக் கவலைகளைப் பிரிப்பதன் மூலம் பயன்பாட்டின் வெவ்வேறு பகுதிகளின் மட்டுத்தன்மையை அதிகரிக்கும் நோக்கம் கொண்ட ஒரு முன்னுதாரணமாகும். இதை நிறைவேற்ற, அசல் குறியீட்டில் மாற்றங்களைச் செய்யாமல் ஏற்கனவே உள்ள குறியீட்டில் கூடுதல் நடத்தை சேர்க்கப்படுகிறது. வேறு வார்த்தைகளில் கூறுவதானால், மாற்றியமைக்கப்பட்ட குறியீட்டை மாற்றாமல், முறைகள் மற்றும் வகுப்புகளின் மேல் கூடுதல் செயல்பாட்டை தொங்கவிடுவதாக நாம் நினைக்கலாம். இது ஏன் அவசியம்? விரைவில் அல்லது பின்னர், வழக்கமான பொருள் சார்ந்த அணுகுமுறை சில சிக்கல்களை எப்போதும் திறம்பட தீர்க்க முடியாது என்று முடிவு செய்கிறோம். அந்த தருணம் வரும்போது, ​​AOP மீட்புக்கு வந்து, பயன்பாடுகளை உருவாக்குவதற்கான கூடுதல் கருவிகளை எங்களுக்கு வழங்குகிறது. கூடுதல் கருவிகள் என்பது மென்பொருள் மேம்பாட்டில் அதிகரித்த நெகிழ்வுத்தன்மையைக் குறிக்கிறது, அதாவது ஒரு குறிப்பிட்ட சிக்கலைத் தீர்ப்பதற்கான கூடுதல் விருப்பங்கள்.

AOPஐப் பயன்படுத்துகிறது

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

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

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

3. ஏற்கனவே எழுதப்பட்ட முறைகள் மற்றும் வகுப்புகளில் அல்லது புதிய செயல்பாட்டில் உள்நுழைவு குறியீடு எங்கு வேண்டுமானாலும் சேர்க்கப்படலாம். இது குறியீட்டு பிழைகளின் எண்ணிக்கையைக் குறைக்கிறது.

   மேலும், வடிவமைப்பு உள்ளமைவிலிருந்து ஒரு அம்சத்தை அகற்றும் போது, ​​அனைத்து டிரேசிங் குறியீடும் போய்விட்டது மற்றும் எதுவும் தவறவிடப்படவில்லை என்பதை நீங்கள் உறுதியாக நம்பலாம்.

4. அம்சங்கள் மேம்படுத்தப்பட்டு மீண்டும் மீண்டும் பயன்படுத்தக்கூடிய தனி குறியீடு.

AOP விதிவிலக்கு கையாளுதல், தேக்ககப்படுத்துதல் மற்றும் சில செயல்பாடுகளை பிரித்தெடுப்பதற்கும் பயன்படுத்தப்படுகிறது.

AOP இன் அடிப்படைக் கொள்கைகள்

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

1. முன் - இலக்கு முறைகள், அதாவது சேரும் புள்ளிகள் செயல்படுத்தப்படுவதற்கு முன் இந்த வகையான ஆலோசனை தொடங்கப்பட்டது. அம்சங்களை வகுப்புகளாகப் பயன்படுத்தும் போது, ​​அறிவுரைகளை முன்பு வந்ததாகக் குறிக்க @Before சிறுகுறிப்பைப் பயன்படுத்துகிறோம். அம்சங்களை .aj கோப்புகளாகப் பயன்படுத்தும் போது , ​​இது முன்() முறையாக இருக்கும் .

2. பிறகு - முறைகளை (இணைப்பு புள்ளிகள்) செயல்படுத்திய பிறகு செயல்படுத்தப்படும் அறிவுரைகள், இயல்பான செயல்பாட்டிலும், விதிவிலக்குகளை வீசும்போதும் நிறைவுற்றது.

   அம்சங்களை வகுப்புகளாகப் பயன்படுத்தும் போது, ​​பின் வரும் அறிவுரை இது என்பதைக் குறிக்க @After சிறுகுறிப்பைப் பயன்படுத்தலாம் .

   அம்சங்களை .aj கோப்புகளாகப் பயன்படுத்தும் போது , ​​பின்() முறை இதுவாகும் .

3. திரும்பிய பிறகு - இலக்கு முறையானது பிழைகள் இல்லாமல் சாதாரணமாக முடிவடையும் போது மட்டுமே இந்த ஆலோசனை செய்யப்படுகிறது.

   அம்சங்களை வகுப்புகளாகக் குறிப்பிடும்போது, ​​அறிவுரையை வெற்றிகரமாக முடித்த பிறகு செயல்படுத்துவதாகக் குறிக்க @AfterReturning சிறுகுறிப்பைப் பயன்படுத்தலாம்.

   அம்சங்களை .aj கோப்புகளாகப் பயன்படுத்தும் போது , ​​பின்() திரும்பும் (Object obj) முறையாக இது இருக்கும் .

4. எறிந்த பிறகு - இந்த அறிவுரை ஒரு முறை, அதாவது சேரும் புள்ளி, விதிவிலக்குகளை வீசும் நிகழ்வுகளுக்காக வடிவமைக்கப்பட்டுள்ளது. சில வகையான தோல்வியுற்ற செயல்பாட்டைக் கையாள இந்த ஆலோசனையைப் பயன்படுத்தலாம் (உதாரணமாக, முழு பரிவர்த்தனையையும் திரும்பப் பெற அல்லது தேவையான ட்ரேஸ் லெவலுடன் பதிவு செய்ய).

   வகுப்பு அம்சங்களுக்கு, விதிவிலக்கு அளித்த பிறகு இந்த அறிவுரை பயன்படுத்தப்படுகிறது என்பதைக் குறிக்க @AfterThrowing சிறுகுறிப்பு பயன்படுத்தப்படுகிறது.

   அம்சங்களை .aj கோப்புகளாகப் பயன்படுத்தும் போது , ​​பின்() எறிதல் (விதிவிலக்கு இ) முறையாக இருக்கும் .

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

   ஜாயின் பாயிண்ட் முறை செயல்படுத்தப்படுவதற்கு முன்னும் பின்னும் இயங்கும் ஆலோசனைக் குறியீட்டை நீங்கள் எழுதலாம்.

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

   வகுப்புகளாகக் கொடுக்கப்பட்ட அம்சங்களைக் கொண்டு, ஒரு சேரப் புள்ளியை உள்ளடக்கிய ஆலோசனையை உருவாக்க, @Around சிறுகுறிப்பைப் பயன்படுத்துகிறோம் . .aj கோப்புகளின் வடிவில் அம்சங்களைப் பயன்படுத்தும் போது , ​​இந்த முறை சுற்றி() முறையாக இருக்கும் .

Join Point — ஒரு இயங்கும் நிரலின் புள்ளி (அதாவது முறை அழைப்பு, பொருள் உருவாக்கம், மாறி அணுகல்) அங்கு ஆலோசனை பயன்படுத்தப்பட வேண்டும். வேறு வார்த்தைகளில் கூறுவதானால், குறியீடு உட்செலுத்தலுக்கான இடங்களைக் கண்டறிய இது ஒரு வகையான வழக்கமான வெளிப்பாடு ஆகும் (ஆலோசனை பயன்படுத்தப்பட வேண்டிய இடங்கள்). பாயிண்ட்கட் - சேரும் புள்ளிகளின் தொகுப்பு . கொடுக்கப்பட்ட சேர்க்கை புள்ளிக்கு கொடுக்கப்பட்ட ஆலோசனை பொருந்துமா என்பதை பாயின்ட்கட் தீர்மானிக்கிறது. அம்சம் - குறுக்கு வெட்டு செயல்பாட்டை செயல்படுத்தும் ஒரு தொகுதி அல்லது வகுப்பு. சில பாயிண்ட்கட் மூலம் வரையறுக்கப்பட்ட இணைப்பு புள்ளிகளில் ஆலோசனையைப் பயன்படுத்துவதன் மூலம் மீதமுள்ள குறியீட்டின் நடத்தையை அம்சம் மாற்றுகிறது . வேறு வார்த்தைகளில் கூறுவதானால், இது ஆலோசனை மற்றும் சேரும் புள்ளிகளின் கலவையாகும். அறிமுகம்— ஒரு வகுப்பின் கட்டமைப்பை மாற்றுதல் மற்றும்/அல்லது பரம்பரை படிநிலையை மாற்றுதல், அம்சத்தின் செயல்பாட்டை வெளிநாட்டு குறியீட்டில் சேர்க்கலாம். இலக்கு - அறிவுரை பயன்படுத்தப்படும் பொருள். நெசவு - அறிவுறுத்தப்பட்ட ப்ராக்ஸி பொருட்களை உருவாக்க மற்ற பொருட்களுடன் அம்சங்களை இணைக்கும் செயல்முறை. தொகுக்கும் நேரம், ஏற்றும் நேரம் அல்லது இயங்கும் நேரத்தில் இதைச் செய்யலாம். மூன்று வகையான நெசவுகள் உள்ளன:

• தொகுத்தல்-நேர நெசவு - அம்சத்தின் மூலக் குறியீடு மற்றும் அம்சத்தைப் பயன்படுத்தும் குறியீடு உங்களிடம் இருந்தால், நீங்கள் மூலக் குறியீட்டையும் அம்சத்தையும் நேரடியாக 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 இலிருந்து reimport செய்து mvn clean compile ஐ இயக்குவது நல்லது . இப்போது நேரடியாக எடுத்துக்காட்டுகளுக்கு செல்லலாம்.

எடுத்துக்காட்டு எண். 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(...) முறையின் அனைத்து ( * ) அழைப்புகளின் செயல்பாட்டின் போது அதைப் பயன்படுத்துவதைக் குறிக்கிறது . அடுத்து ஒரு குறிப்பிட்ட ஆலோசனை வருகிறது - முன்() - இது இலக்கு முறை அழைக்கப்படுவதற்கு முன் செயல்படுத்தப்படும். : வாழ்த்து() என்பது இந்த ஆலோசனைக்கு பதிலளிக்கும் கட்பாயின்ட் ஆகும். சரி, கீழே நாம் புரிந்துகொள்ளும் ஜாவா மொழியில் எழுதப்பட்ட முறையின் உடலைக் காண்கிறோம். இந்த அம்சத்துடன் பிரதானத்தை இயக்கும்போது , ​​​​இந்த கன்சோல் வெளியீட்டைப் பெறுவோம்: printName முறைக்கான ஒவ்வொரு அழைப்பும் ஒரு அம்சத்தின் காரணமாக மாற்றியமைக்கப்பட்டிருப்பதைக் காணலாம் . சிறுகுறிப்புகளுடன் ஜாவா வகுப்பின் அம்சம் எப்படி இருக்கும் என்பதை இப்போது பார்க்கலாம்:

@Aspect
public class GreetingAspect{

  @Pointcut("execution(* Main.printName(String))")
  public void greeting() {
  }

  @Before("greeting()")
  public void beforeAdvice() {
     System.out.print("Hi, ");
  }
}

.aj அம்சக் கோப்பிற்குப் பிறகு , எல்லாம் இங்கே தெளிவாகத் தெரியும்:

• @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

எங்கள் அடுத்த எடுத்துக்காட்டில், கன்சோலில் உள்நுழைவது போன்ற ஒன்றைச் செய்வோம். முதலில், Main ஐப் பாருங்கள் , அங்கு நாங்கள் சில போலி வணிக தர்க்கத்தைச் சேர்த்துள்ளோம்:

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

முக்கியமாக , மதிப்பு நிகழ்வு மாறிக்கு மதிப்பை ஒதுக்க setValue ஐப் பயன்படுத்துகிறோம் . மதிப்பைப் பெற getValue ஐப் பயன்படுத்துகிறோம் , பின்னர் அது 10 எழுத்துகளுக்கு மேல் உள்ளதா என்பதைப் பார்க்க checkValue என்று அழைக்கிறோம். அப்படியானால், விதிவிலக்கு அளிக்கப்படும். இப்போது முறைகளின் வேலையைப் பதிவு செய்ய நாம் பயன்படுத்தும் அம்சத்தைப் பார்ப்போம்:

@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("execution(* *(..))") அனைத்து முறைகளின் அனைத்து அழைப்புகளிலும் சேரும். @AfterReturning(value = "methodExecuting()", returning = "returningValue") என்பது இலக்கு முறையை வெற்றிகரமாகச் செயல்படுத்திய பிறகு செயல்படுத்தப்படும் ஆலோசனையாகும். எங்களிடம் இரண்டு வழக்குகள் உள்ளன:

1. முறை திரும்பும் மதிப்பைக் கொண்டிருக்கும் போது - என்றால் (திரும்புதல் மதிப்பு! = பூஜ்யம்) {
2. திரும்ப மதிப்பு இல்லாத போது - வேறு {

@AfterThrowing(value = "methodExecuting()", throwing = "exception") என்பது பிழையின் போது தூண்டப்படும் ஆலோசனையாகும், அதாவது, முறை விதிவிலக்கு அளிக்கும் போது. அதன்படி, பிரதானத்தை இயக்குவதன் மூலம் , ஒரு வகையான கன்சோல் அடிப்படையிலான பதிவுகளைப் பெறுவோம்: விதிவிலக்குகளை நாங்கள் கையாளவில்லை என்பதால், நாங்கள் இன்னும் ஒரு ஸ்டேக் ட்ரேஸைப் பெறுவோம்: விதிவிலக்குகள் மற்றும் விதிவிலக்கு கையாளுதல் பற்றி இந்தக் கட்டுரைகளில் படிக்கலாம்: ஜாவாவில் விதிவிலக்குகள் மற்றும் விதிவிலக்குகள்: பிடிப்பது மற்றும் கையாளுதல் . இன்று எனக்கு அவ்வளவுதான். இன்று நாங்கள் AOP உடன் பழகினோம் , மேலும் இந்த மிருகம் சிலர் அதை உருவாக்குவது போல் பயமாக இல்லை என்பதை நீங்கள் பார்க்க முடிந்தது. அனைவருக்கும் விடைபெறுங்கள்!