Panduan Terbaik untuk Membuat Anotasi Tersuai dalam Spring Boot

Anotasi sedemikian mengisi keseluruhan projek dalam Spring Boot.

Tetapi adakah anda tahu apakah masalah yang diselesaikan oleh anotasi ini?

Mengapa anotasi tersuai diperkenalkan untuk bermula?

Bagaimana untuk membuat anotasi tersuai?

Hari ini, saya akan membuat liputan:

• Mengapa membuat anotasi tersuai?
• Apakah faedah utama menggunakan anotasi ini?
• Bagaimana untuk membuat anotasi tersuai?
• Bagaimanakah kaedah beranotasi digunakan?
• Bila hendak menggunakan anotasi tersuai?
• Bila tidak boleh menggunakan anotasi tersuai?
• Apakah keburukan menggunakan anotasi tersuai?

? Mengapa Buat Anotasi Tersuai?

Dalam Spring Boot, anotasi bukan sekadar cara untuk menambah metadata. Mereka

• Memudahkan tugas yang rumit
• Kurangkan kod plat dandang
• Tingkatkan kebolehbacaan kod

Sebelum Spring memperkenalkan anotasi tersuai, pembangun perlu mengurus konfigurasi seperti pengesahan e-mel menggunakan fail konfigurasi XML.

Konfigurasi XML akan mentakrifkan kacang, pengesah dan komponen lain yang diperlukan untuk melaksanakan tugas seperti mengesahkan alamat e-mel.

Berikut ialah contoh cara pengesahan e-mel mungkin telah dikonfigurasikan menggunakan XML dalam aplikasi Spring:

Seperti yang anda lihat, ini boleh menjadi mimpi ngeri dengan mudah apabila terdapat ratusan kelas dengan kebanyakannya bergantung antara satu sama lain.

Ini juga bermakna pembangun perlu mencari XML ini setiap kali mereka perlu menambah kebergantungan baharu.

Faedah Utama Anotasi Tersuai

Penyederhanaan Konfigurasi

Spring memperkenalkan anotasi tersuai untuk memudahkan konfigurasi dengan membenarkan pembangun menggunakan anotasi terus dalam kod mereka.

Ini mengurangkan keperluan untuk konfigurasi XML yang meluas, menjadikan pangkalan kod lebih bersih dan lebih mudah diselenggara.

Sokongan untuk Pengaturcaraan Deklaratif

Anotasi tersuai dalam Spring mendayakan pendekatan deklaratif.

Pembangun boleh menggunakan anotasi seperti @Transactional, @Cacheable atau @Scheduled untuk mengisytiharkan gelagat yang diingini tanpa menulis logik asas.

Ini menghasilkan kod yang lebih mudah dibaca dan diselenggara.

Mengendalikan Kebimbangan Merentas

Anotasi tersuai Spring, selalunya digunakan dengan Pengaturcaraan Berorientasikan Aspek (AOP), membolehkan pembangun menangani kebimbangan silang secara berpusat.

Sebagai contoh, anotasi @Transactional mengurus transaksi merentas berbilang kaedah atau kelas tanpa menyerakkan logik pengurusan transaksi ke seluruh kod.

Mengurangkan Kod Boilerplate

Ia mengurangkan keperluan untuk kod boilerplate dengan merangkum tingkah laku biasa.

Sebagai contoh, anotasi @Autowired memudahkan suntikan kebergantungan, membenarkan Spring menyuntik kebergantungan secara automatik, dan bukannya memerlukan kaedah pembina atau penetap yang jelas

Perbincangan berbeza sama ada anda perlu menggunakan @Autowired atau tidak.

Meningkatkan Kebolehbacaan dan Ketekalan Kod

Dengan mengabstrakkan konfigurasi dan merentasi kebimbangan ke dalam anotasi, Spring meningkatkan kebolehbacaan kod.

Anda dan pembangun rakan sebaya anda boleh memahami dengan cepat tujuan kaedah atau kelas dengan melihat anotasinya dan anotasi membantu menguatkuasakan konsistensi merentas pangkalan kod.

Fleksibiliti dan Kebolehlanjutan Rangka Kerja

Anotasi tersuai membolehkan pembangun membuat anotasi mereka yang disesuaikan dengan keperluan khusus, sekali gus memanjangkan kefungsian rangka kerja dalam cara yang standard.

Fleksibiliti ini telah membantu Spring kekal relevan dan berkuasa merentas pelbagai aplikasi dan seni bina.

? Cara Membuat Anotasi Tersuai

Langkah 1: Tentukan Anotasi

• Buat anotasi baharu dengan mentakrifkan antara muka.
• Gunakan @antaramuka untuk mengisytiharkannya.
• Tambahkan anotasi meta untuk menentukan cara anotasi harus berkelakuan.

package co.officegeek.tokenratelimiter;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)  // Annotation available at runtime
@Target(ElementType.METHOD)          // Can be applied to methods
public @interface LogExecutionTime {
}

• @Sasaran: Menunjukkan tempat anotasi boleh digunakan (cth., kaedah, kelas).
• @Pengekalan: Menunjukkan tempoh anotasi dikekalkan (cth., masa jalan, masa kompilasi).

Langkah 2: Buat Aspek untuk Mengendalikan Anotasi

Anda boleh mencipta logik tersuai untuk memproses anotasi menggunakan Spring's BeanPostProcessor, Aspect atau logik pemprosesan anotasi tersuai.

package co.officegeek.tokenratelimiter;

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 LogExecutionTimeAspect {

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

Langkah 3: Gunakan Anotasi

Gunakan anotasi tersuai anda pada kaedah, medan atau kelas seperti yang ditakrifkan.

package co.officegeek.tokenratelimiter;

import org.springframework.stereotype.Service;

@Service
public class TestService {

    @LogExecutionTime
    public void serve() throws InterruptedException {
        // Simulate some work
        Thread.sleep(2000);
    }
}

How It Works:

• The @LogExecutionTime annotation doesn't cause any method to be called directly.
• The Spring AOP framework detects that a method has the @LogExecutionTime annotation using reflection.
• The LogExecutionTimeAspect aspect is configured to apply around advice when a method with the @LogExecutionTime annotation is called.
• The logExecutionTime method in the aspect is executed before and after the annotated method (serve), logging the execution time.

---

How does the annotated method get invoked?

When you apply a custom annotation to a method, class, or field, the annotation itself doesn't directly cause any method to be called.

Instead, the logic associated with the annotation is typically implemented using reflection or aspect-oriented programming (AOP) in frameworks like Spring.

Here's a breakdown of how the compiler and runtime environment know what method to call when an annotation is applied:

1. Compile-Time Processing (Annotation Processors)

Some annotations are handled at compile time by annotation processors.

Java's javax.annotation.processing package allows developers to create custom annotation processors that generate code, validate annotations, or even modify the abstract syntax tree (AST) of the code being compiled.

The annotation processor reads the annotations during compilation and executes code based on those annotations.

This can include generating new classes or methods that the code will use later.

The @Override annotation is a compile-time annotation that doesn't invoke a method but instead tells the compiler to check if the method actually overrides a superclass method.

How It Works:

• You define a custom annotation processor by extending AbstractProcessor and overriding the process method.
• The processor will be invoked by the compiler when it encounters your annotation, allowing you to generate code or perform other tasks.

2. Runtime Processing (Reflection)

Custom annotations can be processed at runtime using reflection.

The runtime system (e.g., a framework like Spring) uses reflection to detect the presence of annotations on methods, classes, or fields, and then applies the corresponding behavior.

A custom annotation like @LogExecutionTime doesn't directly trigger any method call.

Instead, an aspect or some other reflective mechanism checks for the presence of the annotation at runtime and then wraps the method call with additional logic.

How It Works:

• At runtime, you use Java's reflection API to check if a method or class has a specific annotation using methods like isAnnotationPresent.
• Once detected, you can invoke methods or execute logic associated with that annotation.  For example, if a method has a @LogExecutionTime annotation, you might measure the time before and after the method call.

3. Aspect-Oriented Programming (AOP)

In frameworks like Spring, AOP is commonly used to handle custom annotations.

AOP allows you to define "aspects" that can intercept method calls and perform additional processing before or after the method execution.

When the AOP framework (e.g. Spring AOP) detects an annotation, it triggers the execution of an advice method associated with the aspect.

This advice method contains the logic that the AOP framework executes when the annotated method is called.

A @Transactional annotation in Spring doesn't execute any logic by itself.

Instead, the Spring framework's AOP infrastructure intercepts calls to methods annotated with @Transactional and wraps them with transaction management logic.

How It Works:

• You define an aspect class with advice methods that are associated with specific pointcuts (join points where you want to apply the advice).
• The aspect uses annotations like @Around or @Before to specify when the advice should be executed.
• The AOP framework ensures that when a method with a custom annotation is called, the corresponding advice is executed automatically.

Use Cases Where Custom Annotations Are a Good Approach

Cross-Cutting Concerns

Custom annotations are ideal for handling cross-cutting concerns like logging, security, transaction management, and caching.

These are concerns that affect multiple parts of an application but are not related to the core business logic.

Anotasi @LogExecutionTime di atas ialah contoh yang baik kerana ia boleh digunakan merentas semua kaedah dan ia tidak mempunyai sebarang logik perniagaan.

Pengaturcaraan Deklaratif

Apabila anda ingin menentukan perkara yang sepatutnya berlaku dan bukannya bagaimana ia sepatutnya berlaku, anotasi tersuai menyediakan cara yang bersih dan ekspresif untuk melakukan perkara ini.

Anotasi seperti @Cacheable atau @Retry membenarkan pembangun mendayakan caching atau mencuba semula logik secara deklaratif, tanpa menulis kod pelaksanaan secara manual.

Rangka Kerja atau Integrasi Perpustakaan

Anotasi tersuai boleh memudahkan penyepaduan rangka kerja atau pustaka dengan menyembunyikan kerumitan di sebalik anotasi yang mudah digunakan.

Anotasi seperti @Autowired dalam Spring membantu dalam menyuntik kebergantungan tanpa perlu membuat seketika secara manual.

Enkapsulasi Logik Kompleks

Apabila logik kompleks perlu dirangkumkan dalam cara yang boleh digunakan semula, anotasi tersuai boleh menyediakan API yang bersih untuk menggunakan logik ini.

Anotasi seperti @RateLimit boleh merangkum logik untuk mengehadkan bilangan kali kaedah boleh dipanggil, tanpa mengacaukan badan kaedah dengan logik ini.

Gunakan Kes Di Mana Anotasi Tersuai Tidak Boleh Digunakan

Logik Mudah atau Sekaligus

Jika logiknya mudah atau hanya perlu digunakan di satu tempat, membuat anotasi tersuai adalah berlebihan dan boleh merumitkan kod secara tidak perlu.

Logik yang Memerlukan Tingkah Laku Dinamik

Anotasi ditakrifkan secara statik pada masa penyusunan, menjadikannya tidak sesuai untuk senario di mana gelagat perlu ditentukan secara dinamik semasa masa jalan.

Jika tingkah laku kaedah harus berubah berdasarkan input pengguna atau konfigurasi luaran, pengendalian ini dengan anotasi tersuai boleh membawa kepada penyelesaian yang rumit.

Logik Perniagaan

Logik perniagaan teras tidak boleh diabstraksikan ke dalam anotasi tersuai, kerana ini boleh menjadikan logik kurang telus dan lebih sukar untuk dikekalkan.

Menggunakan anotasi untuk merangkum proses perniagaan seperti @ProcessOrder mungkin menyembunyikan peraturan perniagaan yang penting, menjadikan kod lebih sukar untuk difahami dan dikekalkan.

Interaksi Kompleks Antara Anotasi

Jika gelagat bergantung pada interaksi kompleks antara berbilang anotasi, ia boleh membawa kepada hasil yang tidak dijangka dan menjadikan kod sukar difahami dan nyahpepijat.

Menggabungkan berbilang anotasi tersuai yang mempengaruhi kaedah yang sama (cth., @Retry, @Cacheable, @LogExecutionTime) boleh mengakibatkan tingkah laku yang tidak dapat diramalkan dan sukar untuk diurus

Kod Kritikal Prestasi

Anotasi tersuai selalunya bergantung pada pantulan atau mekanisme proksi, yang boleh memperkenalkan overhed prestasi.

Ia tidak boleh digunakan dalam bahagian kod yang kritikal prestasi.

Menggunakan anotasi tersuai untuk menambahkan pengelogan pada kaedah yang dipanggil berjuta-juta kali dalam gelung ketat boleh merendahkan prestasi dengan ketara.

? Ringkasan - Bila Menggunakan Anotasi Tersuai

Anotasi tersuai sesuai untuk menangani kebimbangan silang seperti pembalakan, keselamatan dan pengurusan transaksi.

Ia juga bagus untuk senario di mana anda perlu menggunakan gelagat yang sama merentas berbilang bahagian aplikasi anda.

Walau bagaimanapun, untuk logik yang ringkas, sekali sahaja atau apabila kawalan dan fleksibiliti yang terperinci diperlukan, anotasi tersuai mungkin bukan pendekatan terbaik.

Pertimbangkan pertukaran sebelum anda memutuskan untuk melaksanakannya.

? Pemikiran Akhir

Anotasi tersuai ialah alat yang berkuasa dalam senjata Spring Boot anda, tetapi seperti mana-mana alat, ia harus digunakan dengan bijak.

Mereka menawarkan cara yang bersih dan boleh digunakan semula untuk mengendalikan tugasan yang berulang dan menguatkuasakan konsistensi merentas pangkalan kod anda.

Tetapi berhati-hati dengan potensi kelemahan, terutamanya untuk kerumitan dan prestasi.

---

?? Pengumuman

Saya melancarkan kursus berasaskan kohort selama 10 hari untuk pembangun perisian dan arkitek perkhidmatan mikro yang bercita-cita untuk mereka bentuk dan melaksanakan perkhidmatan mengehadkan kadar menggunakan Spring Boot dan Bucket4j.

Anda akan belajar:

✅ Cara mereka bentuk dan membina perkhidmatan mikro sedia pengeluaran

✅ Pengetahuan mendalam tentang algoritma pengehad kadar dan pelaksanaannya

✅ Amalan terbaik dalam pembangunan Spring Boot, ujian dan kontena

Tetapi ia juga tentang

✅ memecahkan projek kepada tugas-tugas tertentu

✅ Bertanggungjawab kepada diri sendiri

✅ Mereka bentuk dan Membina projek dengan betul

Ia disasarkan kepada pembangun perisian yang ingin mereka bentuk dan membangunkan perkhidmatan mikro yang merupakan kes penggunaan yang berkaitan dengan kebanyakan syarikat.

Terutama untuk mereka yang lebih awal dalam kerjaya pembangun perisian mereka yang mungkin tidak mempunyai "pengalaman projek" tetapi banyak semangat dan cita-cita.

Jika ini adalah sesuatu yang anda fikir akan membantu anda atau walaupun anda hanya ingin tahu lebih lanjut:

Daftar minat anda dan saya akan memberitahu anda butiran bengkel.

---

Ini pertama kali diterbitkan pada Substack saya. Langgan Substack saya - Pembangun Hujung Minggu untuk mendapatkan kemas kini dahulu.

Adakah anda pembangun yang memerlukan maklum balas tentang kod yang anda tulis?

Atau adakah anda mahu seseorang menyemak kod anda supaya anda melakukan perkara yang betul?

Saya membantu pengguna dengan sesi semakan kod percuma supaya mereka boleh mendapatkan maklum balas awal dan menulis kod yang lebih baik

DM saya di Twitter (X) atau di LinkedIn dan saya akan membantu anda dengan kod anda.

Atas ialah kandungan terperinci Panduan Terbaik untuk Membuat Anotasi Tersuai dalam Spring Boot. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!