Spring AOP - การสร้าง Custom Annotations ด้วย AOP

----

Introduction: AOP คืออะไร?

ในการพัฒนาแอปพลิเคชันในยุคปัจจุบัน การเขียนโค้ดที่เป็นมิตรต่อการบำรุงรักษาและขยายเป็นสิ่งสำคัญ Aspect-Oriented Programming (AOP) เป็นแนวคิดการเขียนโปรแกรมที่มาเพื่อช่วยให้เราแยกแยะ concerns หรือข้อพิจารณาที่ซับซ้อน อันไม่เกี่ยวข้องกับเหตุการณ์หลักของแอปพลิเคชันออกจากกันได้ เช่น การตรวจสอบสิทธิ์ หรือการจัดการการล็อก

Spring Framework ซึ่งเป็นหนึ่งในกรอบงานยอดนิยมสำหรับการพัฒนาซอฟต์แวร์ Java นั้นได้ผสาน AOP ไว้ด้วยเพื่อความยืดหยุ่นที่มากขึ้น โดยเฉพาะการใช้งาน Annotations ในการปรับแต่งพฤติกรรมของโปรแกรมได้ขยายออกไป ซึ่งในบทความนี้เราจะไปสำรวจเกี่ยวกับการสร้าง Custom Annotations ด้วย Spring AOP ครับ

AOP และ Custom Annotations

AOP อาจดูน่าสับสนสำหรับผู้เริ่มต้น แต่ถ้าว่ากันง่ายๆ ก็คือการจัดการและนำทาง Cross-Cutting Concerns ออกไปจากโค้ดปกติของเรา โดยผ่านทาง "Aspects" ซึ่งประกอบด้วย "Advice" หรือที่เรียกว่าการดำเนินการพิเศษที่เกิดขึ้นในระบบตาม "Join Points" หรือจุดที่เราจะต้องการเข้าสู่

Custom Annotations ใน Spring AOP ช่วยให้เราสามารถสร้างตรรกะที่สามารถนำไปใช้ซ้ำในหลายๆ ส่วนของแอปพลิเคชันเพียงแค่ใช้ Annotation ที่กำหนดเอง

การสร้าง Custom Annotations

สมมติว่าเราต้องการบันทึกข้อมูลการดำเนินการเฉพาะบางบล็อกในแอปพลิเคชันของเรา คุณสามารถสร้าง Custom Annotation "LogExecutionTime" เพื่อจับเวลาและบันทึกการดำเนินการนั้นได้

ขั้นที่ 1: สร้าง Custom Annotation

เรามาเริ่มด้วยการสร้าง Annotation ก่อน:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogExecutionTime {
}

- `@Retention(RetentionPolicy.RUNTIME)`: กำหนดว่า Annotation นี้จะมีอายุใช้งานในช่วง Runtime

- `@Target(ElementType.METHOD)`: กำหนดว่า Annotation นี้จะถูกใช้กับ Method เท่านั้น

ขั้นที่ 2: สร้าง Aspect สำหรับจัดการ Annotations

ต่อไป เราจำเป็นต้องสร้าง Aspect ที่จะจัดการกับ `LogExecutionTime` Annotation ของเรา:

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    @Around("@annotation(LogExecutionTime)")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();

        Object proceed = joinPoint.proceed();

        long executionTime = System.currentTimeMillis() - start;

        System.out.println(joinPoint.getSignature() + " executed in " + executionTime + "ms");
        return proceed;
    }
}

ใน Aspect นี้เราใช้ `@Around` advice เพื่อสั่งให้รัน method รอบก่อนและหลังที่มีการใช้ `LogExecutionTime` Annotation แล้วเราก็จะทำการจับเวลาและบันทึก

ขั้นที่ 3: ใช้ Custom Annotation

สุดท้าย เราก็สามารถใช้ Custom Annotation ที่สร้างขึ้นได้เลย:

import org.springframework.stereotype.Component;

@Component
public class SampleService {

    @LogExecutionTime
    public void serve() throws InterruptedException {
        Thread.sleep(2000); // Method ใช้เวลาในการทำงาน
    }
}

Use Case และประโยชน์

การใช้ Spring AOP ร่วมกับ Custom Annotations ในโปรเจ็กต์ของคุณช่วยลดการกระจายของ Cross-Cutting Concerns ได้ดี เช่น การ Track, การจับภาพสถิติ, และเรื่อง Security เป็นต้น ด้วยวิธีนี้โค้ดของคุณจะสะอาด อ่านง่าย และง่ายต่อการบำรุงรักษา

สรุป

การใช้ Spring AOP สำหรับการสร้าง Custom Annotations เปิดโอกาสใหม่ๆ ให้กับการพัฒนาแอปพลิเคชันที่แตกต่าง ด้วยการแยกความซับซ้อนออกจาก Logic หลัก ทำให้นักพัฒนาสามารถมุ่งมั่นกับฟังก์ชันหลักของแอปพลิเคชันได้ดียิ่งขึ้น หากคุณสนใจอยากเรียนรู้ Spring AOP หรือสอนเกี่ยวกับการโปรแกรมเพิ่มเติม เริ่มต้นได้ที่สถานศึกษา Expert-Programming-Tutor (EPT) ของเราที่จะช่วยแนะแนวทางในการเรียนรู้และฝึกฝนการพัฒนาโปรแกรมด้วย Spring Framework ได้อย่างมีประสิทธิภาพ!

หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง

หากเจอข้อผิดพลาด หรือต้องการพูดคุย ติดต่อได้ที่ https://m.me/expert.Programming.Tutor/