Rehat kopi #230. Apa itu Record di Java dan bagaimana cara kerjanya?

Sumber: JavaTechOnline Artikel ini memberikan pandangan mendalam tentang konsep Records di Java beserta contohnya, termasuk sintaksisnya, cara membuatnya, dan cara menggunakannya. Catatan di Java adalah salah satu fitur hebat yang pertama kali diperkenalkan di Java 14 sebagai fitur pratinjau dan akhirnya keluar pada rilis Java 17. Banyak pengembang yang secara aktif menggunakannya, yang membantu mereka berhasil mengurangi sejumlah besar kode boilerplate. Selain itu, berkat catatan, Anda tidak perlu menulis satu baris kode pun untuk membuat kelas tidak dapat diubah.

Kapan menggunakan Rekam di Java?

Jika Anda ingin meneruskan data yang tidak dapat diubah di antara berbagai lapisan aplikasi Anda, menggunakan Record bisa menjadi pilihan yang baik. Secara default, Records di Java tidak dapat diubah, artinya kita tidak dapat mengubah propertinya setelah dibuat. Hasilnya, ini membantu kami menghindari kesalahan dan meningkatkan keandalan kode. Sederhananya, dengan menggunakan Record di Java, kita dapat membuat kelas secara otomatis.

Di mana saya bisa menggunakan Record di Java?

Secara umum, kita dapat menggunakan catatan dalam situasi apa pun ketika kita perlu mendeklarasikan wadah data sederhana dengan properti yang tidak dapat diubah dan metode yang dihasilkan secara otomatis. Sebagai contoh, berikut adalah beberapa kasus penggunaan dimana record dapat berguna: Objek transfer data (DTO): Kita dapat menggunakan Record untuk mendeklarasikan objek transfer data sederhana yang berisi data. Hal ini berguna ketika mentransfer data antar lapisan aplikasi yang berbeda, seperti antara lapisan layanan dan lapisan database. Objek Konfigurasi : Catatan dapat digunakan untuk mendeklarasikan objek konfigurasi yang berisi sekumpulan properti konfigurasi untuk aplikasi atau modul. Objek-objek ini biasanya memiliki properti yang tidak dapat diubah, menjadikannya aman untuk thread dan mudah digunakan. Nilai benda. Record dapat digunakan untuk mendeklarasikan objek nilai yang berisi sekumpulan nilai yang mewakili konsep atau model domain tertentu. Respons API : Saat membuat REST API, data biasanya dikembalikan dalam bentuk JSON atau XML. Dalam kasus seperti ini, Anda mungkin perlu menentukan struktur data sederhana yang mewakili respons API. Catatan ideal untuk ini karena memungkinkan Anda menentukan struktur data yang ringan dan tidak dapat diubah yang dapat dengan mudah diserialkan ke JSON atau XML. Data uji. Saat menulis pengujian unit, Anda sering kali perlu membuat data pengujian yang mewakili skenario tertentu. Dalam kasus seperti ini, Anda mungkin perlu menentukan struktur data sederhana yang mewakili data pengujian. Catatan bisa menjadi pilihan ideal untuk hal ini karena memungkinkan kita menentukan struktur data yang ringan dan tidak dapat diubah dengan kode boilerplate minimal. Objek mirip Tuple : Rekaman dapat digunakan untuk mendeklarasikan objek mirip Tuple yang berisi sejumlah nilai terkait yang tetap. Ini bisa berguna saat mengembalikan beberapa nilai dari suatu metode atau saat bekerja dengan kumpulan nilai terkait.

Apa itu Rekam di Java?

Record di Java adalah kelas yang dirancang untuk menyimpan data. Ini mirip dengan kelas Java tradisional, namun lebih ringan dan memiliki beberapa fitur unik. Catatan tidak dapat diubah secara default, yang berarti statusnya tidak dapat diubah setelah dibuat. Hal ini menjadikannya ideal untuk menyimpan data yang tidak dapat diubah, seperti parameter konfigurasi atau nilai yang dikembalikan dari kueri database. Ini juga merupakan cara untuk membuat tipe data khusus yang terdiri dari sekumpulan bidang atau variabel, serta metode untuk mengakses dan memodifikasi bidang tersebut. Rekam di Java mempermudah pengerjaan data dengan mengurangi jumlah kode boilerplate yang harus ditulis berulang kali oleh pengembang. Sintaks untuk membuat entri di Java adalah:

record Record_Name(Fields....)

Bagaimana cara membuat dan menggunakan Record di Java dengan contoh?

Mari kita lihat cara membuat dan menggunakan record di Java secara terprogram.

Membuat Catatan

Membuat catatan secara terprogram tidak terlalu mirip dengan membuat kelas reguler di Java. Alih-alih class kami menggunakan kata kunci record . Anda juga perlu mendeklarasikan kolom dengan tipe data dalam tanda kurung nama rekaman. Berikut adalah contoh kode yang menunjukkan cara membuat entri di Java:

public record Book(String name, double price) { }

Dalam contoh ini, kami membuat catatan bernama Buku dengan dua bidang: nama dan harga . Kata kunci publik menunjukkan bahwa entri ini dapat diakses di luar paket yang ditentukan.

Menggunakan Rekam

Untuk menggunakan record di Java, kita dapat membuat instance-nya menggunakan kata kunci new, seperti yang kita lakukan dengan kelas biasa. Berikut ini contohnya:

Book book = new Book( "Core Java" , 324.25);

Di sini contoh rekaman Buku baru dibuat dengan bidang nama disetel ke Core Java dan bidang harga disetel ke 324.25 . Setelah rekaman dibuat, bidangnya dapat diakses menggunakan nama bidang itu sendiri. Tidak ada metode dapatkan atau setel. Sebaliknya, nama field menjadi nama metode.

String name = book.name();

double price = book.price();

Di sini kita melihat nilai bidang nama dan harga yang diambil dari catatan Buku . Selain bidang, rekaman juga memiliki beberapa metode bawaan yang dapat Anda gunakan untuk memanipulasinya. Misalnya, toString() , sama dengan() dan hashCode() . Ingatlah bahwa catatan Java tidak dapat diubah secara default, artinya setelah dibuat, statusnya tidak dapat diubah. Mari kita lihat contoh lain tentang cara membuat dan menggunakan record di Java. Mari kita ambil kasus di mana kita memerlukan catatan untuk menyimpan informasi tentang seorang siswa.

public record Student(String name, int age, String subject) {}

Ini menciptakan catatan bernama Student dengan tiga bidang: name , age dan subject . Kita dapat membuat instance entri ini sebagai berikut:

Student student = new Student("John Smith", 20, "Computer Science");

Kita kemudian bisa mendapatkan nilai bidang menggunakan nama bidang:

String name = student.name();
int age = student.age();
String subject= student.subject();

Seperti apa tampilan Record setelah dikompilasi?

Karena Record hanyalah jenis kelas khusus, kompiler juga mengubahnya menjadi kelas biasa, tetapi dengan beberapa batasan dan perbedaan. Ketika kompiler mengubah catatan (file Java) menjadi bytecode setelah proses kompilasi, file .class yang dihasilkan berisi beberapa deklarasi tambahan dari kelas Record . Misalnya, di bawah ini adalah bytecode yang dihasilkan untuk entri Student oleh kompiler Java:

record Student(String name, int age) {   }

Menulis ke file .class (setelah kompilasi)

Kita juga dapat menemukan kelas yang dikonversi di bawah ini jika kita menggunakan alat javap dan menerapkan perintah di bawah ini dari baris perintah. Penting untuk dicatat bahwa baris perintah Java menyertakan alat javap , yang dapat Anda gunakan untuk melihat informasi tentang bidang, konstruktor, dan metode file kelas. >javap Student Kesimpulan: Jika kita memeriksa bytecode dengan cermat, kita mungkin mendapatkan beberapa pengamatan:

• Kompiler mengganti kata kunci Record dengan class .
• Kompiler mendeklarasikan kelas final . Hal ini menunjukkan bahwa kelas ini tidak dapat diperluas. Artinya juga tidak dapat diwariskan dan bersifat kekal.
Kelas yang dikonversi meluas java.lang.Record . Hal ini menunjukkan bahwa semua record adalah subkelas dari kelas Record yang didefinisikan dalam paket java.lang .
• Kompiler menambahkan konstruktor berparameter.
• Kompiler secara otomatis menghasilkan metode toString() , hashCode() dan equal() .
• Kompiler telah menambahkan metode untuk mengakses bidang. Perhatikan konvensi penamaan metode - keduanya sama persis dengan nama bidang, tidak boleh ada get atau set sebelum nama bidang .

Bidang dalam Catatan

Catatan di Java menentukan statusnya menggunakan sekumpulan bidang, masing-masing dengan nama dan tipe berbeda. Bidang rekaman dideklarasikan di header rekaman. Misalnya:

public record Person(String name, int age) {}

Entri ini memiliki dua bidang: nama tipe String dan umur tipe int . Bidang rekaman secara implisit bersifat final dan tidak dapat ditetapkan ulang setelah rekaman dibuat. Kita dapat menambahkan kolom baru, namun hal ini tidak disarankan. Bidang baru yang ditambahkan ke catatan harus bersifat statis. Misalnya:

public record Person(String name, int age) {

   static String sex;
}

Konstruktor dalam Catatan

Seperti konstruktor kelas tradisional, konstruktor rekaman digunakan untuk membuat instance rekaman. Catatan memiliki dua konsep konstruktor: konstruktor kanonik dan konstruktor kompak . Konstruktor kompak menyediakan cara yang lebih ringkas untuk menginisialisasi variabel status dalam rekaman, sedangkan konstruktor kanonik menyediakan cara yang lebih tradisional dengan fleksibilitas lebih.

Konstruktor kanonik

Kompiler Java default memberi kita konstruktor semua argumen (konstruktor semua bidang) yang memberikan argumennya ke bidang terkait. Ini dikenal sebagai konstruktor kanonik. Kita juga dapat menambahkan logika bisnis seperti pernyataan kondisional untuk memvalidasi data. Di bawah ini contohnya:

public record Person(String name, int age) {

       public Person(String name, int age) {
           if (age < 18) {
              throw new IllegalArgumentException("You are not allowed to participate in general elections");
           }
      }
}

Desainer kompak

Konstruktor kompak mengabaikan semua argumen, termasuk tanda kurung. Bidang terkait ditetapkan secara otomatis. Misalnya, kode berikut menunjukkan konsep konstruktor kompak di Records :

public record Person(String name, int age) {

      public Person {
          if (age < 18) {
              throw new IllegalArgumentException("You are not allowed to participate in general elections");
          }
     }
}

Selain konstruktor ringkas, Anda dapat mendefinisikan konstruktor reguler di Record , seperti di kelas reguler. Namun, Anda perlu memastikan bahwa semua konstruktor menginisialisasi semua bidang rekaman.

Metode dalam Catatan

Catatan di Java secara otomatis menghasilkan serangkaian metode untuk setiap bidang dalam catatan. Metode ini disebut metode pengakses dan memiliki nama yang sama dengan bidang yang terkait dengannya. Misalnya, jika suatu catatan mempunyai bidang bernama price , maka secara otomatis akan ada metode bernama price() yang mengembalikan nilai bidang price . Selain metode pengakses yang dihasilkan secara otomatis, kita juga dapat menentukan metode kita sendiri dalam sebuah entri, seperti di kelas biasa. Misalnya:

public record Person(String name, int age) {
   public void sayHello() {
      System.out.println("Hello, my name is " + name);
   }
}

Entri ini memiliki metode sayHello() yang mencetak salam menggunakan kolom nama .

Bagaimana Record membantu mengurangi kode boilerplate

Mari kita lihat contoh sederhana untuk melihat bagaimana notasi Java dapat membantu menghilangkan kode boilerplate. Katakanlah kita memiliki kelas bernama Person yang mewakili seseorang dengan nama, umur dan alamat email. Inilah cara kami mendefinisikan kelas dengan cara tradisional. Kode tanpa menggunakan Record :

public class Person {

    private String name;
    private int age;
    private String email;

    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    public String getName() {

       return name;
    }

    public int getAge() {
       return age;
    }

    publicString getEmail() {
       return email;
    }

    public void setName(String name) {
       this.name = name;
    }

    public voidsetAge(int age) {
       this.age = age;
    }

    public void setEmail(String email) {
       this.email = email;
    }

    @Override
    public String toString() {
       return "Person{" +
         "name='" + name + '\'' +
         ", age=" + age +
         ", email='" + email + '\'' +
      '}';
    }
}

Seperti yang bisa kita lihat, kelas ini memerlukan banyak kode boilerplate untuk mendefinisikan bidang, konstruktor, pengambil, penyetel, dan metode toString() . Selain itu, misalkan kita ingin membuat kelas ini tidak dapat diubah. Untuk melakukan ini kita harus melakukan beberapa langkah tambahan seperti:

• Menyatakan kelas sebagai final sehingga tidak dapat diperpanjang.
• Deklarasikan semua kolom bersifat pribadi dan final sehingga tidak dapat diubah di luar konstruktor.
• Jangan berikan metode penyetel apa pun untuk bidang.
• Jika salah satu bidang dapat diubah, Anda harus mengembalikan salinannya alih-alih mengembalikan objek aslinya.

Kode menggunakan Rekam :

public record Person(String name, int age, String email) {}

Itu saja! Hanya dengan satu baris kode, kita telah mendefinisikan kelas yang memiliki bidang, konstruktor, pengambil, penyetel, dan metode toString() yang sama dengan kelas tradisional. Sintaks Record menangani semua kode boilerplate untuk kita. Dari contoh di atas, jelas bahwa menggunakan catatan di Java dapat membantu menghilangkan kode boilerplate dengan menyediakan sintaksis yang lebih ringkas untuk mendefinisikan kelas dengan kumpulan bidang yang tetap. Lebih sedikit kode yang diperlukan untuk mendefinisikan dan menggunakan catatan dibandingkan pendekatan tradisional, dan catatan menyediakan akses langsung ke bidang menggunakan metode untuk memperbarui bidang. Hal ini membuat kode lebih mudah dibaca, dipelihara, dan mengurangi rawan kesalahan. Selain itu, dengan sintaksis Record , kita tidak perlu melakukan apa pun tambahan untuk membuat kelas tidak dapat diubah. Secara default, semua bidang dalam rekaman bersifat final dan kelas rekaman itu sendiri tidak dapat diubah. Oleh karena itu, membuat kelas yang tidak dapat diubah menggunakan sintaksis tulis jauh lebih sederhana dan memerlukan lebih sedikit kode dibandingkan pendekatan tradisional. Dengan catatan, kita tidak perlu mendeklarasikan bidang sebagai final , menyediakan konstruktor yang menginisialisasi bidang, atau menyediakan pengambil untuk semua bidang.

Kelas Rekaman Umum

Java juga dapat mendefinisikan kelas Records generik . Kelas entri generik adalah kelas entri yang memiliki satu atau lebih parameter tipe. Berikut ini contohnya:

public record Pair<T, U>(T first, U second) {}

Dalam contoh ini , Pair adalah kelas rekaman generik yang mengambil dua parameter bertipe T dan U. Kita dapat membuat instance dari record ini sebagai berikut:

Pair<String, Integer>pair = new Pair<>( "Hello" , 123);

Kelas bersarang di dalam Record

Anda juga dapat menentukan kelas dan antarmuka bersarang dalam sebuah entri. Ini berguna untuk mengelompokkan kelas dan antarmuka terkait, dan dapat membantu meningkatkan pengorganisasian dan pemeliharaan basis kode Anda. Berikut adalah contoh entri yang berisi kelas bersarang:

public record Person(String name, int age, Contact contact){

    public static class Contact {

       private final String email;
       private final String phone;

       public Contact(String email, String phone){
           this.email = email;
           this.phone = phone;
       }

       public String getEmail(){
          return email;
       }

       public String getPhone(){
          return phone;
       }
    }
}

Dalam contoh ini, Person adalah entri yang berisi kelas Kontak yang disarangkan . Pada gilirannya, Kontak adalah kelas bersarang statis yang berisi dua bidang akhir pribadi: alamat email dan telepon. Ia juga memiliki konstruktor yang menerima email dan nomor telepon, dan dua metode pengambil: getEmail() dan getPhone() . Kita dapat membuat instance Person seperti ini:

Person person = new Person("John",30, new Person.Contact("john@example.com", "123-456-7890"));

Dalam contoh ini, kita membuat objek Person baru bernama John , usia 30 tahun, dan objek Kontak baru dengan email john@example.com dan telepon 123-456-7890 .

Antarmuka bersarang di dalam Record

Berikut adalah contoh entri yang berisi antarmuka bersarang:

public record Book(String title, String author, Edition edition){
    public interface Edition{
       String getName();
   }
}

Dalam contoh ini, Buku adalah entri yang berisi antarmuka Edisi bersarang . Pada gilirannya, Edisi adalah antarmuka yang mendefinisikan metode getName() tunggal . Kita dapat membuat instance Buku sebagai berikut:

Book book = new Book("The Hitchhiker's Guide to the Galaxy", "Douglas Adams", new Book.Edition() {

   public String getName() {

      return "Science Fiction";
   }
});

Dalam contoh ini, kita membuat objek Buku baru dengan judul The Hitchhiker's Guide to the Galaxy oleh Douglas Adams dan implementasi anonim baru dari antarmuka Edisi yang mengembalikan nama Fiksi Ilmiah ketika metode getName() dipanggil .

Apa lagi yang bisa dilakukan Records?

• Entri dapat menentukan konstruktor khusus. Catatan mendukung konstruktor berparameter, yang dapat memanggil konstruktor default dengan parameter yang disediakan di tubuhnya. Selain itu, rekaman juga mendukung konstruktor kompak, yang mirip dengan konstruktor default namun dapat menyertakan fungsionalitas tambahan seperti pemeriksaan di badan konstruktor.
• Seperti kelas lainnya di Java, Record dapat mendefinisikan dan menggunakan metode instan. Artinya kita bisa membuat dan memanggil metode khusus untuk kelas rekaman.
• Dalam Record , mendefinisikan variabel instan sebagai anggota kelas tidak diperbolehkan karena variabel tersebut hanya dapat ditentukan sebagai parameter konstruktor. Namun, catatan mendukung bidang statis dan metode statis, yang dapat digunakan untuk menyimpan dan mengakses data umum untuk semua contoh kelas catatan.

Bisakah rekaman mengimplementasikan antarmuka?

Ya, menulis di Java bisa mengimplementasikan antarmuka. Misalnya, kode di bawah ini menunjukkan konsepnya:

public interface Printable {
   void print();
}

public record Person(String name, int age) implements Printable {
   public void print() {
      System.out.println("Name: " + name + ", Age: " + age);
   }
}

Di sini kita telah mendefinisikan antarmuka Printable dengan metode print() tunggal . Kami juga mendefinisikan entri Person yang mengimplementasikan antarmuka Printable . Catatan Person memiliki dua bidang: nama dan usia , dan mengesampingkan metode cetak antarmuka Printable untuk mencetak nilai bidang ini. Kita dapat membuat instance entri Person dan memanggil metode cetaknya seperti ini:

Person person = new Person("John", 30);
person.print();

Ini akan menampilkan Name: John, Age: 30 ke konsol . Seperti yang ditunjukkan dalam contoh, catatan Java dapat mengimplementasikan antarmuka seperti kelas biasa. Hal ini dapat berguna untuk menambahkan perilaku pada sebuah entri atau untuk memastikan bahwa sebuah entri sesuai dengan kontrak yang ditentukan oleh antarmuka.