Dalam lanskap pengembangan web yang terus berkembang, GraphQL telah muncul sebagai alternatif yang kuat untuk REST API tradisional, menawarkan pendekatan yang lebih fleksibel dan efisien untuk pengambilan data. Jika Anda ingin menjelajahi teknologi kreatif ini dan mengintegrasikannya dengan mulus dengan Spring, Anda telah datang ke tempat yang tepat.
Selamat datang di tutorial GraphQL komprehensif kami, di mana kita akan memulai perjalanan untuk menguraikan konsep GraphQL dan memandu Anda melalui proses memulai dengan Spring untuk GraphQL.
Apa itu Spring GraphQL dan Fitur Utamanya
Spring GraphQL adalah ekstensi dari Spring Framework populer yang memberdayakan pengembang untuk membangun API berbasis GraphQL dengan mulus. Ini menggabungkan kekuatan kemudahan pengembangan Spring Boot dengan fleksibilitas dan efisiensi GraphQL, menjadikannya pilihan ideal untuk mengembangkan API modern.
Fitur utama Spring GraphQL meliputi:
- Pengembangan berbasis skema: Dengan Spring GraphQL, pengembang dapat memulai dengan mendefinisikan skema API menggunakan GraphQL Schema Definition Language (SDL). Pendekatan berbasis skema ini memastikan bahwa desain API jelas dan terdefinisi dengan baik sejak awal, mempromosikan proses pengembangan yang lebih terorganisir dan terstruktur.
- Pengambilan data dengan resolver: Spring GraphQL menyederhanakan pengambilan data dengan menyediakan resolver. Resolver bertanggung jawab untuk mengambil data yang diperlukan untuk setiap bidang dalam kueri GraphQL. Pengembang dapat mengimplementasikan resolver untuk mengambil data dari berbagai sumber seperti database, API eksternal, atau repositori data lainnya, memungkinkan fleksibilitas dan penggunaan kembali yang lebih besar.
- Integrasi dengan ekosistem Spring: Sebagai bagian dari keluarga Spring, Spring GraphQL terintegrasi dengan mulus dengan komponen Spring lainnya, seperti Spring Data JPA untuk interaksi database dan Spring Security untuk otentikasi dan otorisasi. Integrasi yang erat ini memastikan pengalaman pengembangan yang lancar dan kohesif.
- Pembaruan waktu nyata dengan langganan: Spring GraphQL mendukung pembaruan data waktu nyata melalui langganan GraphQL. Langganan memungkinkan klien untuk berlangganan peristiwa tertentu dan menerima pembaruan data waktu nyata saat peristiwa tersebut terjadi. Fitur ini sangat berguna untuk membangun aplikasi waktu nyata, seperti sistem obrolan atau umpan data langsung.
Bagaimana Cara Menyiapkan Lingkungan Anda?
Sebelum Anda memulai perjalanan Anda dengan GraphQL dan Spring, pastikan pengaturan Anda sudah siap. Berikut adalah cara Anda dapat mempersiapkan lingkungan Anda untuk membangun proyek Spring Boot dengan GraphQL:
Prasyarat:
- JDK 17: Dapatkan JDK 17 yang terinstal di sistem Anda. Anda dapat mengunduhnya dari Oracle atau OpenJDK.
- Pemahaman Dasar Spring Boot: Ketahui dasar-dasar Spring Boot. Ini akan membantu saat Anda menggabungkan GraphQL.
Membuat Proyek Spring Boot:
Spring Initializr: Buka start.spring.io, titik awal Anda untuk proyek Spring Boot.
Pertama, berikan detail pengaturan proyek seperti memberi nama proyek Anda, menentukan nama grup dalam format domain terbalik (misalnya, com.example), dan menetapkan nama paket untuk kode Java aplikasi Anda. Anda juga dapat menyertakan metadata seperti deskripsi dan versi jika diperlukan.
Kedua, tambahkan dependensi yang diperlukan. Di bagian Dependensi, pilih "Spring Web" untuk mengaktifkan dukungan untuk membuat aplikasi web dengan Spring. Demikian pula, centang "Spring GraphQL" untuk mengaktifkan fitur terkait GraphQL. Setelah Anda mengonfigurasi proyek Anda dan memilih dependensi, klik tombol "Generate" untuk melanjutkan.
Mengimpor Proyek Anda ke IDE Anda:
Pertama, ekstrak isi file ZIP untuk mengakses isinya. Kedua, buka Integrated Development Environment (IDE) Anda, seperti IntelliJ IDEA. Selanjutnya, impor proyek yang sebelumnya Anda ekstrak.
Itu saja! Lingkungan Anda sudah diatur, Anda telah membuat proyek Spring Boot, dan Anda telah memasang GraphQL. IDE Anda adalah taman bermain Anda untuk petualangan pengkodean.
Bagaimana Cara Menyiapkan Lapisan Data?
Di bagian ini, kita akan membuat contoh sederhana, seperti kedai kopi, untuk menunjukkan bagaimana GraphQL dapat meningkatkan pengambilan dan pengelolaan data.
Pengantar Contoh:
Bayangkan Anda sedang mengembangkan API untuk kedai kopi untuk mengelola menu dan pesanannya. Untuk mengilustrasikan ini, kita akan mendefinisikan model data dasar untuk item kopi dan pelanggan, dan menyiapkan layanan untuk menangani data ini.
Mendefinisikan Model Data Dasar:
Mari kita mulai dengan membuat dua model data sederhana: Coffee dan Size. Model-model ini akan diimplementasikan sebagai kelas Java, masing-masing dengan atribut yang mewakili informasi yang relevan.
Anda perlu membuat dua kelas dalam dua file yang berbeda dan Di setiap kelas, Anda perlu menambahkan konstruktor, getter, dan setter untuk atribut.
public class Coffee {
private int id;
private String name;
private Size size;
// Constructors, getters, setters
}
public class Size {
private int id;
private String name;
// Constructors, getters, setters
}
Setelah membuat dan menambahkan kelas-kelas ini, Anda perlu memastikan bahwa mereka terletak di paket yang sesuai dalam proyek Spring Boot Anda. Struktur paket harus mencerminkan nama paket yang Anda berikan saat membuat proyek di Spring Initializr.
Berikut adalah cara Anda dapat menambahkan setter, getter, dan konstruktor untuk kelas Coffee.java.
Menyiapkan Manajemen Data:
Kita akan membuat kelas CoffeeService sederhana untuk berfungsi sebagai repositori data dalam memori dan mengelola data kopi. Untuk mendemonstrasikan, kita akan mengisi repositori ini dengan beberapa item kopi sampel.
import java.util.ArrayList;
import java.util.List;
@Component
public class CoffeeService {
private final List<Coffee> coffees = new ArrayList<>();
@PostConstruct
public void init() {
Size smallSize = new Size(1, "Small");
Size mediumSize = new Size(2, "Medium");
Size largeSize = new Size(3, "Large");
coffees.add(new Coffee(1, "Espresso", smallSize));
coffees.add(new Coffee(2, "Latte", mediumSize));
coffees.add(new Coffee(3, "Cappuccino", largeSize));
}
public List<Coffee> getAllCoffees() {
return coffees;
}
public Coffee getCoffeeById(int id) {
return coffees.stream()
.filter(coffee -> coffee.getId() == id)
.findFirst()
.orElse(null);
}
}
Kelas CoffeeService mengelola data terkait kopi, bertindak sebagai sistem penyimpanan dan pengambilan. Ini menginisialisasi data kopi sampel saat pembuatan, menawarkan metode untuk mengambil semua kopi atau yang spesifik berdasarkan ID. Abstraksi ini menyederhanakan akses dan manipulasi data, menyiapkan data untuk interaksi dalam skema GraphQL.
Bagaimana Cara Membuat Skema GraphQL?
Buat file bernama schema.graphqls di folder src/main/resources dan definisikan skema GraphQL menggunakan Schema Definition Language (SDL).
type Query {
getAllCoffees: [Coffee!]!
getCoffeeById(id: Int!): Coffee
}
type Coffee {
id: Int!
name: String!
size: Size!
}
type Size {
id: Int!
name: String!
}
Berikut adalah cara Anda dapat melakukannya.
Buat Pengambil Data:
Kode mendefinisikan kelas bernama CoffeeDataFetcher yang bertanggung jawab untuk mengambil data untuk kueri GraphQL. Ini dianotasi dengan @Component untuk dikelola oleh Spring. Pengambil getAllCoffees() mengambil daftar item kopi menggunakan metode coffeeService.getAllCoffees(). Pengambil getCoffeeById() mengekstrak ID dari argumen kueri dan menggunakannya untuk mengambil item kopi tertentu dari CoffeeService.
import graphql.schema.DataFetcher;
import graphql.schema.DataFetchingEnvironment;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class CoffeeDataFetcher {
@Autowired
private CoffeeService coffeeService;
public DataFetcher<List<Coffee>> getAllCoffees() {
return environment -> coffeeService.getAllCoffees();
}
public DataFetcher<Coffee> getCoffeeById() {
return environment -> {
int id = environment.getArgument("id");
return coffeeService.getCoffeeById(id);
};
}
}
Berikut adalah cara Anda dapat melakukannya.
Buat Pengontrol GraphQL:
Di Spring, pengontrol GraphQL menyediakan titik akhir untuk berinteraksi dengan skema GraphQL Anda. Pengontrol ini menangani kueri masuk dan mengembalikan data yang sesuai.
import graphql.GraphQL;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class GraphQLController {
@Autowired
private GraphQL graphQL;
@PostMapping("/graphql")
public Map<String, Object> executeQuery(@RequestBody String query) {
ExecutionResult executionResult = graphQL.execute(query);
return executionResult.toSpecification();
}
}
Pengontrol ini akan menangani kueri GraphQL masuk dan berinteraksi dengan skema GraphQL Anda. Ini menyediakan titik akhir RESTful di /graphql yang menerima permintaan POST dengan kueri GraphQL di badan permintaan. Pengontrol kemudian menggunakan instance GraphQL untuk mengeksekusi kueri dan mengembalikan hasil eksekusi sebagai peta.
Spring GraphQL adalah kerangka kerja yang kuat yang memungkinkan pengembang untuk membangun API yang efisien menggunakan bahasa kueri GraphQL. Tidak seperti REST API tradisional, di mana beberapa titik akhir mendikte pengambilan data, GraphQL memberdayakan klien untuk menentukan dengan tepat data apa yang mereka butuhkan dalam satu permintaan, mengurangi pengambilan data berlebihan atau kekurangan data. Spring GraphQL memanfaatkan kekuatan ekosistem Spring, menggabungkan kesederhanaan Spring Boot dengan fleksibilitas GraphQL.
Prosesnya melibatkan pendefinisian model data Anda, membuat lapisan layanan untuk mengelola data, dan membuat skema dengan tipe dan kueri. Pendekatan berbasis skema Spring GraphQL memastikan desain yang jelas dan proses pengembangan yang terstruktur. Pengambilan data disederhanakan melalui resolver, dan pembaruan waktu nyata difasilitasi oleh langganan.
Alat Pengujian GraphQL:
GraphQL telah menjadi cara populer untuk membangun API, dan mengujinya sangat penting untuk memastikan mereka bekerja dengan benar. Alat pengujian membantu pengembang memeriksa apakah API GraphQL mereka berfungsi seperti yang diharapkan.
Salah satu alat ini adalah Apidog, yang menawarkan berbagai fitur untuk membuat pengujian API lebih mudah. Mari kita lihat apa yang dapat dilakukan Apidog dan menyebutkan beberapa alat pengujian berguna lainnya untuk GraphQL.
Apidog:
Apidog adalah toolkit serbaguna yang mencakup seluruh proses pembuatan API. Ini seperti pisau Swiss Army untuk API, membantu dengan desain, pengujian, dan banyak lagi. Berikut adalah apa yang ditawarkan Apidog:
Apa yang Ditawarkan Apidog untuk Pengujian GraphQL:
Apidog berfungsi dengan baik untuk menguji API GraphQL juga. Ia memiliki fitur seperti:
- Dukungan untuk GraphQL: Apidog dapat menguji dan men-debug API GraphQL.
- Otomatisasi: Ia dapat mengotomatiskan tugas dan menjaga definisi API Anda tetap sinkron.
- Integrasi Database: Apidog dapat terhubung ke database untuk pengujian yang lebih baik.
Kesimpulan
Saat API terus berkembang, perpaduan GraphQL, Spring GraphQL, dan alat seperti Apidog membentuk kembali cara API dibuat. Kombinasi ini memberi pengembang lebih banyak kontrol dan efisiensi, menghasilkan API yang kuat, mudah beradaptasi, dan berkinerja tinggi.
