Apa iku AOP? Prinsip pemrograman berorientasi aspek

Halo, wong lanang lan wadon! Tanpa mangerteni konsep dhasar, cukup angel nyelidiki kerangka kerja lan pendekatan kanggo fungsi bangunan. Dadi dina iki kita bakal ngomong babagan siji konsep kasebut - AOP, alias pemrograman berorientasi aspek . Topik iki ora gampang lan arang digunakake langsung, nanging akeh kerangka lan teknologi sing digunakake ing ngisor iki. Lan mesthi, kadhangkala sajrone wawancara, sampeyan bisa uga dijaluk njlèntrèhaké kanthi umum apa jenis kéwan iki lan ing ngendi bisa ditrapake. Dadi ayo dideleng ing konsep dhasar lan sawetara conto prasaja AOP ing Jawa . Saiki, AOP tegese pemrograman berorientasi aspek, yaiku paradigma sing dimaksudake kanggo nambah modularitas saka macem-macem bagean aplikasi kanthi misahake keprihatinan salib. Kanggo ngrampungake iki, prilaku tambahan ditambahake menyang kode sing wis ana tanpa ngganti kode asli. Ing tembung liyane, kita bisa nganggep minangka nggandhol fungsi tambahan ing ndhuwur metode lan kelas tanpa ngganti kode sing diowahi. Yagene iki perlu? Cepet utawa mengko, kita nyimpulake yen pendekatan berorientasi obyek sing khas ora bisa ngatasi masalah tartamtu kanthi efektif. Lan nalika wayahe teka, AOP teka ngluwari lan menehi alat tambahan kanggo aplikasi bangunan. Lan alat tambahan tegese tambah keluwesan ing pangembangan piranti lunak, sing tegese luwih akeh pilihan kanggo ngrampungake masalah tartamtu.

Aplikasi AOP

Pemrograman berorientasi aspek dirancang kanggo nindakake tugas nglereni, sing bisa dadi kode apa wae sing bisa diulang kaping pirang-pirang kanthi cara sing beda-beda, sing ora bisa ditata kanthi lengkap dadi modul sing kapisah. Mulane, AOP ngidini kita nyimpen iki ing njaba kode utama lan nyatakake kanthi vertikal. Conto nggunakake kabijakan keamanan ing aplikasi. Biasane, keamanan mbukak liwat akeh unsur aplikasi. Kajaba iku, kabijakan keamanan aplikasi kudu ditrapake kanthi padha kanggo kabeh bagean aplikasi sing wis ana lan anyar. Ing wektu sing padha, kabijakan keamanan sing digunakake bisa berkembang dhewe. Iki minangka papan sing cocog kanggo nggunakake AOP . Uga, conto liyane yaiku logging. Ana sawetara kaluwihan kanggo nggunakake pendekatan AOP kanggo logging tinimbang nambahake fungsi logging kanthi manual:

1. Kode kanggo logging gampang ditambahake lan dibusak: sampeyan mung kudu nambah utawa mbusak sawetara konfigurasi saka sawetara aspek.

2. Kabeh kode sumber kanggo logging disimpen ing sak panggonan, dadi sampeyan ora perlu kanthi manual mburu kabeh panggonan sing digunakake.

3. Kode logging bisa ditambahake ing ngendi wae, ing metode lan kelas sing wis ditulis utawa ing fungsi anyar. Iki nyuda jumlah kesalahan coding.

   Uga, nalika mbusak aspek saka konfigurasi desain, sampeyan bisa yakin manawa kabeh kode tilak wis ilang lan ora ana sing kejawab.

4. Aspek minangka kode kapisah sing bisa ditambah lan digunakake maneh lan maneh.

AOP uga digunakake kanggo nangani pangecualian, caching, lan ngekstrak fungsi tartamtu supaya bisa digunakake maneh.

Prinsip dhasar AOP

Kanggo luwih maju ing topik iki, ayo ngerti konsep utama AOP. Saran - Logika tambahan utawa kode sing diarani saka titik gabungan. Saran bisa ditindakake sadurunge, sawise, utawa tinimbang titik gabung (liyane babagan ing ngisor iki). Jenis saran sing bisa :

1. Sadurunge — saran jinis iki diluncurake sadurunge metode target, yaiku gabung poin, dieksekusi. Nalika nggunakake aspek minangka kelas, kita nggunakake anotasi @Before kanggo menehi tandha saran minangka sadurunge. Nalika nggunakake aspèk minangka file .aj , iki bakal sadurunge () cara.

2. Sawise - saran sing dileksanakake sawise eksekusi cara (titik gabung) rampung, loro ing eksekusi normal uga nalika mbuwang pangecualian.

   Nalika nggunakake aspèk minangka kelas, kita bisa nggunakake @After anotasi kanggo nunjukaké sing iki saran sing teka sawise.

   Nalika nggunakake aspèk minangka file .aj , iki sawise () cara.

3. Sawise Returning — saran iki dileksanakake mung nalika cara target rampung normal, tanpa kasalahan.

   Nalika aspek dituduhake minangka kelas, kita bisa nggunakake anotasi @AfterReturning kanggo menehi tandha saran minangka eksekusi sawise rampung sukses.

   Nalika nggunakake aspèk minangka file .aj , iki bakal sawise () cara bali (Obyek obj) .

4. Sawise Mbuwang — saran iki dimaksudaké kanggo kedadean nalika cara, sing, gabung titik, mbalang pangecualian. Kita bisa nggunakake saran iki kanggo nangani jinis eksekusi gagal tartamtu (contone, kanggo mbalekake kabeh transaksi utawa log kanthi tingkat tilak sing dibutuhake).

   Kanggo aspek kelas, anotasi @AfterThrowing digunakake kanggo nunjukake yen saran iki digunakake sawise mbuwang pengecualian.

   Nalika nggunakake aspèk minangka file .aj , iki bakal sawise () cara mbuwang (Istiméwa e) .

5. Around - mbok menawa salah siji saka jinis paling penting saka saran. Iku ngubengi cara, yaiku, titik gabung sing bisa digunakake, contone, milih arep nindakake metode titik gabung utawa ora.

   Sampeyan bisa nulis kode saran sing mlaku sadurunge lan sawise metode titik gabung dieksekusi.

   Saran watara tanggung jawab kanggo nelpon cara titik gabung lan nilai bali yen cara ngasilake soko. Ing tembung liyane, ing saran iki, sampeyan mung bisa simulasi operasi saka cara target tanpa nelpon, lan bali apa wae sing dikarepake minangka asil bali.

   Diwenehi aspek minangka kelas, kita nggunakake @Around anotasi kanggo nggawe saran sing mbungkus titik gabung. Nalika nggunakake aspèk ing wangun file .aj , cara iki bakal watara () cara.

Join Point — titik ing program mlaku (IE cara nelpon, obyek nggawe, variabel akses) ngendi saran kudu Applied. Ing tembung liya, iki minangka ekspresi reguler sing digunakake kanggo nemokake panggonan kanggo injeksi kode (panggonan sing kudu ditrapake). Pointcut — sakumpulan titik gabungan . Pointcut nemtokake manawa saran sing diwenehake ditrapake kanggo titik gabung sing diwenehake. Aspek - modul utawa kelas sing ngleksanakake fungsi salib. Aspek ngganti prilaku kode sing isih ana kanthi ngetrapake saran ing titik gabungan sing ditetepake dening sawetara titik . Ing tembung liyane, iku kombinasi saran lan gabung poin. Pambuka- ngganti struktur kelas lan / utawa ngganti hirarki warisan kanggo nambah fungsi aspek kanggo kode manca. Target - obyek sing bakal ditrapake saran. Tenun - proses ngubungake aspèk menyang obyek liyane kanggo nggawe obyek proxy sing disaranake. Iki bisa ditindakake ing wektu kompilasi, wektu mbukak, utawa wektu mbukak. Ana telung jinis tenun:

• Compile-time weaving — yen sampeyan duwe kode sumber aspek lan kode ing ngendi sampeyan nggunakake aspek kasebut, sampeyan bisa ngumpulake kode sumber lan aspek kasebut langsung nggunakake kompiler AspectJ;

• Post-compile weaving (biner weaving) - yen sampeyan ora bisa utawa ora pengin nggunakake transformasi kode sumber kanggo nenun aspèk menyang kode, sampeyan bisa njupuk kelas sadurunge nyawiji utawa file jar lan inject aspèk menyang wong;

• Load-time weaving — iki mung binar weaving sing ditundha nganti classloader mbukak file kelas lan nemtokake kelas kanggo JVM.

  Siji utawa luwih loader kelas tenun dibutuhake kanggo ndhukung iki. Lagi salah siji tegas diwenehake dening runtime utawa diaktifake dening "agen weaving."

AspectJ - A implementasine tartamtu saka paradigma AOP sing ngleksanakake kemampuan kanggo nindakake tugas salib. Dokumentasi bisa ditemokake ing kene .

Tuladha ing basa Jawa

Sabanjure, kanggo luwih ngerti AOP , kita bakal katon ing cilik "Hello World" -gaya conto. Tengen saka bat, aku bakal nyathet yen conto kita bakal nggunakake tenun wektu kompilasi . Kaping pisanan, kita kudu nambah dependensi ing ngisor iki ing file pom.xml :

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

Minangka aturan, compiler ajc khusus yaiku carane nggunakake aspek. IntelliJ IDEA ora kalebu minangka standar, supaya nalika milih minangka compiler aplikasi, sampeyan kudu nemtokake path menyang distribusi 5168 75 AspectJ . Iki minangka cara pisanan. Kapindho, sing digunakake, yaiku ndhaptar plugin ing ngisor iki ing file 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>

Sawise iki, luwih becik ngimpor maneh saka Maven lan mbukak mvn clean compile . Saiki ayo nerusake langsung menyang conto.

Tuladha No. 1

Ayo nggawe kelas Utama . Ing kono, kita bakal duwe titik entri lan cara sing nyithak jeneng sing dilewati ing konsol:

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

Ora ana sing rumit ing kene. We liwati jeneng lan nampilake ing console. Yen kita mbukak program saiki, kita bakal weruh ing ngisor iki ing console: Saiki, wektune kanggo njupuk kauntungan saka kekuwatan AOP. Saiki kita kudu nggawe file aspek . Ana rong jinis: sing pisanan nduweni ekstensi file .aj . Kapindho yaiku kelas biasa sing nggunakake anotasi kanggo ngleksanakake kemampuan AOP . Ayo katon dhisik file kanthi ekstensi .aj :

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

File iki kaya kelas. Ayo ndeleng apa sing kedadeyan ing kene: pointcut minangka set titik gabungan; salam () iku jeneng pointcut iki; : eksekusi nuduhake kanggo aplikasi sak eksekusi kabeh ( * ) telpon saka Main.printName (...) cara. Sabanjure ana saran tartamtu - sadurunge () - sing dieksekusi sadurunge metode target diarani. : salam () minangka titik potong sing ditanggepi saran iki. Inggih, ing ngandhap punika kawontênakên badanipun tata cara piyambak, ingkang kaserat mawi basa Jawi, ingkang dipun mangrêtosi. Nalika kita mbukak utama kanthi aspek iki, kita bakal entuk output konsol iki: Kita bisa ndeleng manawa saben telpon menyang metode printName wis diowahi amarga ana aspek. Saiki ayo deleng apa aspek kasebut minangka kelas Jawa kanthi anotasi:

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

Sawise file aspek .aj , kabeh dadi luwih jelas ing kene:

• @Aspect nuduhake yen kelas iki minangka aspek;
• @Pointcut("execution(* Main.printName(String))") iku cutpoint sing dipicu kanggo kabeh panggilan menyang Main.printName kanthi argumen input sing jinis String ;
• @Before ("salam ()") minangka saran sing ditrapake sadurunge nelpon kode kasebut ing titik potong salam () .

Mlaku utama kanthi aspek iki ora ngganti output konsol:

Tuladha No. 2

Upaminipun kita duwe sawetara cara sing nindakake sawetara operasi kanggo klien, lan kita nelpon cara iki saka utama :

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

Ayo gunakake anotasi @Around kanggo nggawe "pseudo-transaction":

@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...");
     }
  }
  }

Kanthi cara nerusake obyek ProceedingJoinPoint , kita nelpon cara bungkus kanggo nemtokake lokasi ing saran. Mulane, kode ing cara ndhuwur joinPoint.proceed (); yaiku Sadurunge , dene kode ing ngisor iki yaiku Sawise . Yen kita mbukak main , kita entuk iki ing console: Nanging yen kita mbuwang lan istiméwa ing cara kita (kanggo simulasi operasi gagal):

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

Banjur kita entuk output konsol iki: Dadi apa sing wis rampung ing kene yaiku jinis kemampuan nangani kesalahan.

Tuladha No. 3

Ing conto sabanjure, ayo nglakoni kaya mlebu menyang konsol. Pisanan, deleng Main , ing ngendi kita wis nambah sawetara logika bisnis pseudo:

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

Ing utama , kita nggunakake setValue kanggo nemtokake nilai kanggo variabel conto nilai . Banjur kita nggunakake getValue kanggo entuk nilai, banjur nelpon checkValue kanggo ndeleng yen luwih saka 10 karakter. Yen mangkono, pangecualian bakal dibuwang. Saiki ayo goleki aspek sing bakal digunakake kanggo log karya metode:

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

Apa sing kedadeyan ing kene? @Pointcut("eksekusi(* *(..))") bakal nggabungake kabeh panggilan kabeh cara. @AfterReturning(value = "methodExecuting()", returning = "returningValue") iku saran sing bakal dileksanakake sawise kasil eksekusi metode target. Kita duwe rong kasus ing kene:

1. Nalika metode kasebut nduweni nilai bali - yen (returningValue! = Null) {
2. Nalika ora ana nilai bali - liya {

@AfterThrowing(value = "methodExecuting ()", mbuwang = "exception") iku saran sing bakal micu ing cilik saka kesalahan, sing, nalika cara mbalang pangecualian. Lan kanthi mangkono, kanthi mlaku main , kita bakal entuk jinis log adhedhasar konsol: Lan amarga kita ora nangani pangecualian, kita isih bakal entuk tilak tumpukan: Sampeyan bisa maca babagan pangecualian lan penanganan pangecualian ing artikel iki: Pangecualian ing Jawa lan Pangecualian: nyekel lan nangani . Iku kabeh kanggo kula dina iki. Dina iki kita kenal karo AOP , lan sampeyan bisa ndeleng manawa kewan iki ora medeni kaya sing dikira sawetara wong. Sugeng tanggap warsa!