Pengembangan API GraphQL dengan Java

Jika Anda seorang pengembang Java, Anda mungkin pernah menghadapi tantangan dengan REST API, seperti pengambilan data berlebihan (over-fetching) atau kekurangan data (under-fetching). Hadirlah GraphQL—bahasa kueri yang kuat untuk API Anda yang memecahkan masalah ini dengan memberi klien kekuatan untuk meminta hanya apa yang mereka butuhkan dan tidak lebih.

Hari ini, kita akan membahas bagaimana Anda dapat mengimplementasikan GraphQL di Java untuk membuat API yang fleksibel dan efisien. Tetapi sebelum kita masuk ke hal-hal yang lebih detail, izinkan saya berbagi alat menarik yang akan membuat perjalanan Anda lebih lancar—Apidog.

💡

Apidog adalah alat pengembangan API fantastis yang dapat Anda unduh secara GRATIS untuk meningkatkan pengalaman API Anda. Percayalah, ini akan mengubah permainan!

button

Apa itu GraphQL?

GraphQL adalah bahasa kueri dan manipulasi data sumber terbuka untuk API, yang dikembangkan oleh Facebook pada tahun 2012 dan dirilis secara publik pada tahun 2015. Tidak seperti REST, yang mengekspos beberapa titik akhir, GraphQL memungkinkan klien untuk membuat kueri satu titik akhir dan menentukan dengan tepat data apa yang mereka butuhkan. Hal ini mengarah pada pengambilan data yang lebih efisien dan pengurangan penggunaan jaringan.

Mengapa Memilih Java untuk GraphQL?

Java, bahasa pemrograman yang kuat dan banyak digunakan, sangat cocok untuk mengimplementasikan GraphQL karena beberapa alasan:

Pengetikan yang Kuat: Sistem tipe Java yang kuat selaras dengan baik dengan struktur berbasis skema GraphQL.
Dukungan Komunitas: Java memiliki ekosistem dan dukungan komunitas yang luas, memastikan Anda dapat menemukan pustaka dan alat untuk mempermudah implementasi GraphQL Anda.
Kinerja: Kemampuan kinerja Java membuatnya cocok untuk menangani kueri GraphQL yang kompleks dan berskala besar.

Memulai dengan GraphQL di Java

Sekarang, mari kita telusuri langkah-langkah untuk menyiapkan dan menggunakan GraphQL dalam aplikasi Java. Kita akan menggunakan Spring Boot, kerangka kerja populer untuk membangun aplikasi Java, bersama dengan beberapa pustaka GraphQL yang kuat.

Langkah 1: Siapkan Proyek Spring Boot Anda

Pertama, buat proyek Spring Boot baru. Anda dapat melakukan ini menggunakan Spring Initializr atau IDE favorit Anda.

Berikut adalah pengaturan sederhana menggunakan Spring Initializr:

Buka start.spring.io.
Pilih "Gradle Project" atau "Maven Project".
Tambahkan dependensi yang diperlukan:

Spring Web
Spring Boot DevTools
Spring Data JPA
H2 Database (untuk kesederhanaan)

Hasilkan proyek dan unzip file yang diunduh. Buka di IDE Anda.

Langkah 2: Tambahkan Dependensi GraphQL

Selanjutnya, tambahkan dependensi GraphQL ke proyek Anda. Di file build.gradle atau pom.xml Anda, sertakan:

// build.gradle
dependencies {
    implementation 'com.graphql-java-kickstart:graphql-spring-boot-starter:11.1.0'
    implementation 'com.graphql-java-kickstart:graphql-java-tools:11.1.0'
    implementation 'com.graphql-java-kickstart:graphiql-spring-boot-starter:11.1.0'
}

Atau untuk Maven:

<!-- pom.xml -->
<dependencies>
    <dependency>
        <groupId>com.graphql-java-kickstart</groupId>
        <artifactId>graphql-spring-boot-starter</artifactId>
        <version>11.1.0</version>
    </dependency>
    <dependency>
        <groupId>com.graphql-java-kickstart</groupId>
        <artifactId>graphql-java-tools</artifactId>
        <version>11.1.0</version>
    </dependency>
    <dependency>
        <groupId>com.graphql-java-kickstart</groupId>
        <artifactId>graphiql-spring-boot-starter</artifactId>
        <version>11.1.0</version>
    </dependency>
</dependencies>

Langkah 3: Tentukan Skema GraphQL Anda

Buat folder bernama graphql di direktori src/main/resources. Di folder ini, buat file bernama schema.graphqls untuk menentukan skema GraphQL Anda. Berikut adalah contoh sederhana:

type Query {
    getBookById(id: ID!): Book
    getAllBooks: [Book]
}

type Book {
    id: ID!
    title: String
    author: String
    publishedDate: String
}

Langkah 4: Buat Model Java Anda

Buat kelas Book sederhana di proyek Anda:

package com.example.graphql.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String author;
    private String publishedDate;

    // Getters and Setters
}

Langkah 5: Siapkan Repositori Anda

Buat antarmuka repositori untuk entitas Book Anda:

package com.example.graphql.repository;

import com.example.graphql.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
}

Langkah 6: Buat Resolver GraphQL

Sekarang, buat resolver untuk kueri GraphQL Anda. Resolver bertanggung jawab untuk mengambil data yang ditentukan dalam skema GraphQL.

package com.example.graphql.resolver;

import com.coxautodev.graphql.tools.GraphQLQueryResolver;
import com.example.graphql.model.Book;
import com.example.graphql.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class BookResolver implements GraphQLQueryResolver {

    @Autowired
    private BookRepository bookRepository;

    public Book getBookById(Long id) {
        return bookRepository.findById(id).orElse(null);
    }

    public List<Book> getAllBooks() {
        return bookRepository.findAll();
    }
}

Langkah 7: Uji API GraphQL Anda

Dengan semua yang sudah diatur, sekarang saatnya untuk menguji API GraphQL Anda. Jalankan aplikasi Spring Boot Anda dan buka http://localhost:8080/graphiql di browser Anda. Ini akan membuka antarmuka GraphiQL tempat Anda dapat menguji kueri Anda.

Coba kueri berikut untuk mengambil semua buku:

{
    getAllBooks {
        id
        title
        author
        publishedDate
    }
}

Anda akan melihat daftar buku yang dikembalikan dari database Anda.

Fitur GraphQL Tingkat Lanjut

Sekarang setelah Anda menyiapkan API GraphQL dasar, mari kita jelajahi beberapa fitur tingkat lanjut untuk membuat API Anda menjadi lebih kuat.

Mutasi

Selain kueri, GraphQL mendukung mutasi, yang memungkinkan klien untuk memodifikasi data. Tambahkan yang berikut ini ke file schema.graphqls Anda:

type Mutation {
    createBook(title: String!, author: String!, publishedDate: String!): Book
    updateBook(id: ID!, title: String, author: String, publishedDate: String): Book
    deleteBook(id: ID!): Boolean
}

Kemudian, buat resolver untuk mutasi ini:

package com.example.graphql.resolver;

import com.coxautodev.graphql.tools.GraphQLMutationResolver;
import com.example.graphql.model.Book;
import com.example.graphql.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BookMutationResolver implements GraphQLMutationResolver {

    @Autowired
    private BookRepository bookRepository;

    public Book createBook(String title, String author, String publishedDate) {
        Book book = new Book();
        book.setTitle(title);
        book.setAuthor(author);
        book.setPublishedDate(publishedDate);
        return bookRepository.save(book);
    }

    public Book updateBook(Long id, String title, String author, String publishedDate) {
        Book book = bookRepository.findById(id).orElse(null);
        if (book != null) {
            book.setTitle(title);
            book.setAuthor(author);
            book.setPublishedDate(publishedDate);
            return bookRepository.save(book);
        }
        return null;
    }

    public Boolean deleteBook(Long id) {
        bookRepository.deleteById(id);
        return true;
    }
}

Penanganan Kesalahan

Menangani kesalahan dengan baik sangat penting untuk API yang kuat. Di GraphQL, kesalahan dikembalikan dalam format standar, sehingga memudahkan klien untuk memahami apa yang salah. Anda dapat menyesuaikan penanganan kesalahan di aplikasi Spring Boot Anda dengan membuat pengecualian khusus dan handler.

package com.example.graphql.exception;

import graphql.ErrorType;
import graphql.GraphQLError;
import graphql.language.SourceLocation;

import java.util.List;

public class BookNotFoundException extends RuntimeException implements GraphQLError {

    public BookNotFoundException(String message) {
        super(message);
    }

    @Override
    public List<SourceLocation> getLocations() {
        return null;
    }

    @Override
    public ErrorType getErrorType() {
        return ErrorType.DataFetchingException;
    }
}

Kemudian, buat handler untuk mengelola pengecualian ini:

package com.example.graphql.handler;

import graphql.GraphQLError;
import graphql.servlet.GraphQLErrorHandler;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.stream.Collectors;

@Component
public class CustomGraphQLErrorHandler implements GraphQLErrorHandler {

    @Override
    public List<Graph

QLError> processErrors(List<GraphQLError> errors) {
        return errors.stream().map(this::getNested).collect(Collectors.toList());
    }

    private GraphQLError getNested(GraphQLError error) {
        if (error.getExtensions() != null && error.getExtensions().containsKey("nested")) {
            return (GraphQLError) error.getExtensions().get("nested");
        }
        return error;
    }
}

Memahami Perbedaan: GraphQL Java vs. GraphQL Spring Boot

Sebelum menyelami kemampuan Apidog, penting untuk memahami perbedaan antara menggunakan GraphQL Java dan mengintegrasikan GraphQL dengan Spring Boot.

GraphQL Java

GraphQL Java adalah pustaka dasar untuk mengimplementasikan GraphQL dalam aplikasi Java. Ini menyediakan fungsionalitas inti untuk menentukan skema, menangani kueri, dan memproses mutasi. Berikut adalah beberapa poin penting:

Fleksibilitas: GraphQL Java menawarkan fleksibilitas tingkat rendah, memungkinkan Anda untuk menyesuaikan cara Anda menentukan dan menyelesaikan skema dan tipe GraphQL Anda.
Pengaturan Manual: Karena ini adalah pustaka inti, menggunakan GraphQL Java memerlukan lebih banyak pengaturan manual dan kode boilerplate. Anda perlu menangani aspek-aspek seperti penguraian skema, eksekusi kueri, dan pemasangan secara manual.
Kontrol: Ini memberikan kontrol granular atas proses eksekusi GraphQL, menjadikannya ideal untuk implementasi GraphQL yang kompleks dan sangat disesuaikan.

GraphQL Spring Boot

GraphQL Spring Boot, di sisi lain, adalah kerangka kerja berpendapat yang dibangun di atas GraphQL Java, mengintegrasikannya dengan mulus dengan ekosistem Spring Boot. Berikut adalah perbedaannya:

Kemudahan Penggunaan: GraphQL Spring Boot menyederhanakan proses pengaturan dengan menyediakan konfigurasi otomatis dan default yang masuk akal. Ini memanfaatkan pendekatan konvensi-atas-konfigurasi Spring Boot untuk mengurangi kode boilerplate.
Integrasi Spring: Ini terintegrasi dengan mulus dengan komponen Spring lainnya seperti Spring Data, Spring Security, dan Spring Web, sehingga memudahkan untuk membangun API GraphQL yang kuat dan aman.
Peralatan yang Ditingkatkan: Kerangka kerja ini mencakup alat tambahan seperti GraphiQL dan Voyager untuk pengujian kueri interaktif dan visualisasi skema, meningkatkan pengalaman pengembang.

Dengan memilih GraphQL Spring Boot, Anda dapat mempercepat pengembangan dan lebih fokus pada logika bisnis Anda daripada kerumitan pengaturan GraphQL. Namun, jika Anda memerlukan kontrol yang lebih baik dan merasa nyaman dengan pendekatan yang lebih langsung, GraphQL Java adalah alternatif yang kuat.

Sekarang setelah kita mengklarifikasi perbedaan antara kedua pendekatan ini, mari kita jelajahi bagaimana Apidog dapat lebih meningkatkan proses pengembangan API GraphQL Anda.

Mengintegrasikan Apidog dengan Proyek GraphQL Java Anda

Apidog adalah alat manajemen API komprehensif yang dapat secara signifikan merampingkan proses pengembangan API Anda. Berikut adalah cara Anda dapat mengintegrasikan Apidog ke dalam proyek GraphQL Java Anda untuk meningkatkan kemampuan manajemen API Anda.

Langkah 1: Unduh dan Instal Apidog

Pertama, unduh Apidog dan ikuti petunjuk instalasi.

button

Langkah 2: Impor Skema GraphQL Anda

Setelah Anda menginstal Apidog, Anda dapat mengimpor skema GraphQL Anda untuk mengelola dan menguji API Anda dengan lebih efisien. Buka bagian impor di Apidog dan unggah file schema.graphqls Anda.

Masukkan kueri Anda di kotak Kueri pada tab "Jalankan". Anda juga dapat mengklik tombol Ambil Skema manual di kotak input untuk mengaktifkan fitur "pelengkapan kode" untuk ekspresi Kueri, membantu dalam memasukkan pernyataan Kueri.

Langkah 3: Uji dan Dokumentasikan API Anda

Dengan skema Anda diimpor, Anda dapat menggunakan Apidog untuk menguji kueri dan mutasi Anda, menghasilkan dokumentasi, dan bahkan mengejek respons. Ini akan membantu Anda memastikan API Anda berfungsi seperti yang diharapkan dan memberikan panduan komprehensif untuk pengguna API Anda.

Kesimpulan: Rangkul Masa Depan Pengembangan API

GraphQL dan Java bersama-sama menawarkan solusi yang kuat untuk membangun API yang efisien dan fleksibel. Dengan mengikuti panduan ini, Anda telah mempelajari cara menyiapkan API GraphQL di Java, mengimplementasikan fitur-fitur canggih, dan meningkatkan proses pengembangan Anda dengan Apidog.

Jadi, tunggu apa lagi? Unduh Apidog secara gratis hari ini dan mulailah membangun generasi API berikutnya dengan GraphQL dan Java!

button