Java Academy · Pelajaran

Pemroses Anotasi saat Kompilasi

Tulis AbstractProcessor untuk membuat file sumber atau memvalidasi kode saat kompilasi.

Pelajaran 4 dari 413 langkah

Pemroses Anotasi saat Kompilasi adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.

Apa Itu Pemroses Anotasi?

Pemroses anotasi (APT—Annotation Processing Tool) berjalan selama kompilasi. Pemroses ini memeriksa anotasi kode sumber dan dapat menghasilkan berkas sumber baru, berkas sumber daya, atau memunculkan kesalahan/peringatan kompilator.

AbstractProcessor: Kelas Dasar

Perluas javax.annotation.processing.AbstractProcessor. Timpa process() untuk menangani elemen beranotasi. Nyatakan anotasi yang didukung dan versi sumber Java.

import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.*;

@SupportedAnnotationTypes("com.example.GenerateBuilder")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
public class BuilderProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations,
                           RoundEnvironment roundEnv) {
        for (Element e : roundEnv.getElementsAnnotatedWith(GenerateBuilder.class)) {
            generateBuilder((TypeElement) e);
        }
        return true;
    }
    private void generateBuilder(TypeElement cls) { /* generate source */ }
}

Mendaftarkan Pemroses

Daftarkan pemroses dalam META-INF/services/javax.annotation.processing.Processor menggunakan nama kelas yang sepenuhnya memenuhi syarat. Alat pembangunan (Maven, Gradle) akan menemukannya secara otomatis.

# META-INF/services/javax.annotation.processing.Processor
com.example.BuilderProcessor

Menghasilkan Berkas Sumber

Gunakan processingEnv.getFiler().createSourceFile() untuk menulis berkas .java baru. Kompilator kemudian mengompilasi berkas yang dihasilkan pada putaran yang sama atau berikutnya.

JavaFileObject file = processingEnv.getFiler()
    .createSourceFile("com.example.UserBuilder");
try (Writer w = file.openWriter()) {
    w.write("package com.example;\n");
    w.write("public class UserBuilder {\n");
    w.write("  // generated builder\n");
    w.write("}\n");
}

Memeriksa Model Elemen

Pemroses anotasi bekerja dengan Element (bukan Class—sumber belum dikompilasi). Gunakan TypeElement, VariableElement, dan ExecutableElement.

TypeElement classElement = (TypeElement) element;
String className = classElement.getSimpleName().toString();
List<VariableElement> fields = classElement.getEnclosedElements().stream()
    .filter(e -> e.getKind() == ElementKind.FIELD)
    .map(e -> (VariableElement) e)
    .collect(Collectors.toList());

Menghasilkan Kesalahan Kompilator

Panggil processingEnv.getMessager().printMessage() untuk menghasilkan kesalahan, peringatan, atau catatan. Inilah cara anotasi batasan khusus menandai pelanggaran saat waktu kompilasi.

processingEnv.getMessager().printMessage(
    Diagnostic.Kind.ERROR,
    "@GenerateBuilder requires at least one field",
    element
);

Pemrosesan Multi-Putaran

Pemrosesan anotasi berlangsung dalam beberapa putaran. Jika Anda menghasilkan berkas yang berisi anotasi, pemroses dapat berjalan lagi pada putaran berikutnya. roundEnv.processingOver() menandakan putaran terakhir.

if (roundEnv.processingOver()) {
    // last round — write summary files or do cleanup
}

Lombok di Balik Layar

Lombok menggunakan ekstensi APT nonstandar yang mengubah AST dari kelas yang sudah ada (tidak diizinkan oleh spesifikasi). Anotasinya seperti @Data, @Builder, dan @Getter menghasilkan metode langsung ke dalam kelas yang dikompilasi.

Pembuatan Kode MapStruct

MapStruct menghasilkan implementasi pemeta yang aman terhadap tipe saat waktu kompilasi. MapStruct membaca antarmuka yang diberi anotasi @Mapper dan menulis implementasinya sebagai kelas Java biasa—tanpa refleksi saat waktu proses.

@Mapper
public interface UserMapper {
    UserDto toDto(User user);
    User toEntity(UserDto dto);
}
// MapStruct generates: UserMapperImpl.java at compile time

Menguji Pemroses Anotasi

Gunakan google/compile-testing atau Kapt (untuk Kotlin) untuk menguji pemroses secara unit. Masukkan string sumber dan nyatakan hasil yang diharapkan untuk berkas yang dihasilkan atau kesalahan kompilator.

JavaFileObject src = JavaFileObjects.forSourceString("Test",
    "@GenerateBuilder public class Test { private String name; }");
Compilation c = Compiler.javac().withProcessors(new BuilderProcessor()).compile(src);
CompilationSubject.assertThat(c).succeeded();
CompilationSubject.assertThat(c).generatedSourceFile("TestBuilder");

Pengemasan Pemroses

Kemas pemroses dalam modul Maven terpisah. Modul anotasi (hanya berisi anotasi) adalah dependensi compile; modul pemroses memiliki cakupan annotationProcessor, bukan dependensi waktu proses.

// build.gradle:
dependencies {
    implementation "com.example:my-annotations:1.0"
    annotationProcessor "com.example:my-processor:1.0"
}

Pemeriksaan Singkat

Di mana Anda mendaftarkan pemroses anotasi agar dapat ditemukan secara otomatis?

Jawab di pelajaran interaktif

Rangkuman

Perluas AbstractProcessor, daftarkan dalam META-INF/services, hasilkan sumber dengan Filer, dan keluarkan kesalahan dengan Messager. Kemas pemroses secara terpisah. Gunakan compile-testing untuk pengujian unit. Cara ini menghilangkan overhead refleksi saat waktu proses.

Gratis untuk memulai

Belajar Java dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 104
Pelajaran: 374

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pemroses Anotasi saat Kompilasi” gratis?

Ya — teks lengkap “Pemroses Anotasi saat Kompilasi” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pemroses Anotasi saat Kompilasi”?

Tulis AbstractProcessor untuk membuat file sumber atau memvalidasi kode saat kompilasi. Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Java Academy?

Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Pemroses Anotasi saat Kompilasi” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Mendefinisikan Anotasi: Elemen dan Nilai Bawaan
Kebijakan Retensi dan Tipe Target
Pemrosesan Anotasi saat Runtime
Pemroses Anotasi saat Kompilasi

← Kembali ke Java Academy