Blog

Phát triển API GraphQL với Java

Khám phá cách tận dụng GraphQL trong Java để xây dựng API hiệu quả. Hướng dẫn này đề cập đến các khái niệm, công cụ và kỹ thuật cần thiết để tối ưu hóa quá trình phát triển API của bạn. Tải Apidog miễn phí để tăng tốc hành trình API của bạn!

Minh Triết

Minh Triết

4 tháng 6 2025

Phát triển API GraphQL với Java

Nếu bạn là một nhà phát triển Java, có lẽ bạn đã phải đối mặt với những thách thức khi làm việc với REST APIs, như là lấy dữ liệu quá mức hoặc không đủ. Bây giờ hãy xem xét GraphQL—một ngôn ngữ truy vấn mạnh mẽ cho API của bạn, giải quyết những vấn đề này bằng cách cho phép khách hàng yêu cầu chính xác những gì họ cần và không gì hơn.

Hôm nay, chúng ta sẽ tìm hiểu cách bạn có thể triển khai GraphQL trong Java để tạo ra các API linh hoạt và hiệu quả. Nhưng trước khi đi sâu vào chi tiết, hãy để tôi chia sẻ một công cụ thú vị sẽ giúp chuyến hành trình của bạn trở nên dễ dàng hơn—Apidog.

💡
Apidog là một công cụ phát triển API tuyệt vời mà bạn có thể tải xuống MIỄN PHÍ để nâng cao trải nghiệm API của bạn. Tin tôi đi, đây là một sự thay đổi cuộc chơi!
button

GraphQL là gì?

GraphQL là một ngôn ngữ truy vấn và thao tác dữ liệu mã nguồn mở cho các API, được phát triển bởi Facebook vào năm 2012 và ra mắt công khai vào năm 2015. Không giống như REST, cái mà cung cấp nhiều điểm cuối, GraphQL cho phép khách hàng truy vấn một điểm cuối duy nhất và xác định chính xác những gì dữ liệu họ cần. Điều này dẫn đến việc truy xuất dữ liệu hiệu quả hơn và giảm mức sử dụng mạng.

Tại sao chọn Java cho GraphQL?

Java, một ngôn ngữ lập trình mạnh mẽ và được sử dụng rộng rãi, là sự lựa chọn hoàn hảo để triển khai GraphQL vì một số lý do:

  1. Kiểu mạnh: Hệ thống kiểu mạnh của Java phù hợp tốt với cấu trúc dựa trên sơ đồ của GraphQL.
  2. Hỗ trợ cộng đồng: Java có một hệ sinh thái rộng lớn và sự hỗ trợ từ cộng đồng, đảm bảo bạn có thể tìm thấy các thư viện và công cụ để dễ dàng thực hiện GraphQL.
  3. Hiệu suất: Các khả năng hiệu suất của Java làm cho nó phù hợp để xử lý các truy vấn GraphQL phức tạp và quy mô lớn.

Bắt đầu với GraphQL trong Java

Bây giờ, hãy cùng đi qua các bước để thiết lập và sử dụng GraphQL trong một ứng dụng Java. Chúng tôi sẽ sử dụng Spring Boot, một framework phổ biến để xây dựng các ứng dụng Java, cùng với một số thư viện GraphQL mạnh mẽ.

GraphQL và java

Bước 1: Thiết lập Dự án Spring Boot của bạn

Đầu tiên, tạo một dự án Spring Boot mới. Bạn có thể làm điều này bằng cách sử dụng Spring Initializr hoặc IDE yêu thích của bạn.

Dưới đây là một thiết lập đơn giản sử dụng Spring Initializr:

  1. Đi tới start.spring.io.
  2. Chọn "Dự án Gradle" hoặc "Dự án Maven".
  3. Thêm các phụ thuộc cần thiết:

Generate dự án và giải nén tệp đã tải xuống. Mở nó trong IDE của bạn.

Bước 2: Thêm các phụ thuộc GraphQL

Kế tiếp, thêm các phụ thuộc GraphQL vào dự án của bạn. Trong tệp build.gradle hoặc pom.xml của bạn, bao gồm:

// 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'
}

Hoặc cho 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>

Bước 3: Định nghĩa Sơ đồ GraphQL của bạn

Tạo một thư mục có tên graphql trong thư mục src/main/resources. Trong thư mục này, tạo một tệp có tên schema.graphqls để định nghĩa sơ đồ GraphQL của bạn. Dưới đây là một ví dụ đơn giản:

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

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

Bước 4: Tạo các Mô hình Java của bạn

Tạo một lớp Book đơn giản trong dự án của bạn:

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 và Setters
}

Bước 5: Thiết lập các Repository của bạn

Tạo một giao diện repository cho thực thể Book của bạn:

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

Bước 6: Tạo các Resolvers GraphQL

Bây giờ, hãy tạo các resolvers cho các truy vấn GraphQL của bạn. Các resolvers có nhiệm vụ truy xuất dữ liệu được chỉ định trong sơ đồ 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();
    }
}

Bước 7: Kiểm tra API GraphQL của bạn

Với mọi thứ đã được thiết lập, giờ là lúc kiểm tra API GraphQL của bạn. Chạy ứng dụng Spring Boot của bạn và truy cập http://localhost:8080/graphiql trong trình duyệt của bạn. Điều này sẽ mở giao diện GraphiQL nơi bạn có thể kiểm tra các truy vấn của mình.

Hãy thử truy vấn sau để lấy tất cả sách:

{
    getAllBooks {
        id
        title
        author
        publishedDate
    }
}

Bạn sẽ thấy một danh sách sách được trả về từ cơ sở dữ liệu của bạn.

Các Tính năng GraphQL Nâng cao

Bây giờ bạn đã có một API GraphQL cơ bản thiết lập, hãy khám phá một số tính năng nâng cao để làm cho API của bạn trở nên mạnh mẽ hơn.

Các Mutations

Ngoài các truy vấn, GraphQL hỗ trợ các mutations, cho phép khách hàng sửa đổi dữ liệu. Thêm đoạn sau vào tệp schema.graphqls của bạn:

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

Rồi, tạo một resolver cho các mutations này:

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

Xử lý Lỗi

Xử lý lỗi một cách hiệu quả là rất quan trọng cho một API vững mạnh. Trong GraphQL, các lỗi được trả về trong một định dạng chuẩn hóa, giúp khách hàng dễ dàng hiểu được điều gì đã sai. Bạn có thể tùy chỉnh xử lý lỗi trong ứng dụng Spring Boot của mình bằng cách tạo một ngoại lệ tùy chỉnh và một bộ xử lý.

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

Rồi, tạo một bộ xử lý để quản lý các ngoại lệ này:

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

Hiểu những điểm khác biệt: GraphQL Java so với GraphQL Spring Boot

Trước khi đi sâu vào khả năng của Apidog, điều quan trọng là hiểu những khác biệt giữa việc sử dụng GraphQL Java và tích hợp GraphQL với Spring Boot.

GraphQL Java

GraphQL Java là một thư viện nền tảng để triển khai GraphQL trong các ứng dụng Java. Nó cung cấp các chức năng cốt lõi để xác định các sơ đồ, xử lý các truy vấn và xử lý các mutations. Dưới đây là một số điểm chính:

  1. Tính linh hoạt: GraphQL Java cung cấp tính linh hoạt ở mức thấp, cho phép bạn tùy chỉnh cách bạn xác định và giải quyết các sơ đồ và kiểu GraphQL của mình.
  2. Thiết lập thủ công: Vì là một thư viện cốt lõi, việc sử dụng GraphQL Java yêu cầu thiết lập thủ công nhiều hơn và mã khởi tạo. Bạn sẽ cần xử lý các khía cạnh như phân tích sơ đồ, thực hiện truy vấn và kết nối thủ công.
  3. Kiểm soát: Nó cung cấp kiểm soát chi tiết về quy trình thực thi GraphQL, làm cho nó lý tưởng cho các triển khai GraphQL phức tạp và tùy chỉnh cao.

GraphQL Spring Boot

GraphQL Spring Boot, mặt khác, là một framework có quan điểm xây dựng trên GraphQL Java, tích hợp liền mạch với hệ sinh thái Spring Boot. Dưới đây là cách mà nó khác biệt:

  1. Dễ sử dụng: GraphQL Spring Boot đơn giản hóa quy trình thiết lập bằng cách cung cấp cấu hình tự động và các mặc định hợp lý. Nó tận dụng phương pháp quy ước-thay cho cấu hình của Spring Boot để giảm mã khởi tạo.
  2. Tích hợp Spring: Nó tích hợp liền mạch với các thành phần Spring khác như Spring Data, Spring Security và Spring Web, giúp dễ dàng xây dựng các API GraphQL mạnh mẽ và an toàn.
  3. Công cụ nâng cao: Framework bao gồm các công cụ bổ sung như GraphiQL và Voyager để kiểm tra truy vấn tương tác và hình dung sơ đồ, cải thiện trải nghiệm của nhà phát triển.

Bằng cách chọn GraphQL Spring Boot, bạn có thể tăng tốc phát triển và tập trung nhiều hơn vào logic doanh nghiệp của mình thay vì những phức tạp của việc thiết lập GraphQL. Tuy nhiên, nếu bạn yêu cầu kiểm soát chi tiết và cảm thấy thoải mái với cách tiếp cận thủ công hơn, thì GraphQL Java là một lựa chọn mạnh mẽ.

Giờ đây, chúng ta đã làm rõ những sự khác biệt giữa hai cách tiếp cận này, hãy khám phá cách Apidog có thể nâng cao quy trình phát triển API GraphQL của bạn hơn nữa.

Tích hợp Apidog với Dự án GraphQL Java của bạn

Apidog là một công cụ quản lý API toàn diện có thể đáng kể làm mượt quy trình phát triển API của bạn. Dưới đây là cách bạn có thể tích hợp Apidog vào dự án GraphQL Java của mình để nâng cao khả năng quản lý API của bạn.

Bước 1: Tải xuống và cài đặt Apidog

Đầu tiên, tải xuống Apidog và thực hiện theo hướng dẫn cài đặt.

button

Bước 2: Nhập Sơ đồ GraphQL của bạn

Ngay khi bạn đã cài đặt Apidog, bạn có thể nhập sơ đồ GraphQL của mình để quản lý và kiểm tra API một cách hiệu quả hơn. Truy cập vào phần nhập trong Apidog và tải lên tệp schema.graphqls của bạn.

tạo một yêu cầu GraphQL mới

​Nhập truy vấn của bạn trong hộp Truy vấn trên tab "Chạy". Bạn cũng có thể nhấp vào nút Fetch Schema thủ công trong hộp nhập để kích hoạt tính năng "hoàn tất mã" cho các biểu thức Truy vấn, giúp nhập các câu lệnh Truy vấn dễ dàng hơn.

Yêu cầu GraphQL

Bước 3: Kiểm tra và tài liệu cho API của bạn

Với sơ đồ của bạn đã được nhập, bạn có thể sử dụng Apidog để kiểm tra các truy vấn và mutations của mình, tạo tài liệu, và thậm chí giả lập các phản hồi. Điều này sẽ giúp bạn đảm bảo API của mình hoạt động như mong đợi và cung cấp một hướng dẫn toàn diện cho người dùng API của bạn.

Yêu cầu GraphQL

Kết luận: Nắm bắt Tương lai của Phát triển API

GraphQL và Java cùng nhau cung cấp một giải pháp mạnh mẽ để xây dựng các API hiệu quả và linh hoạt. Bằng cách làm theo hướng dẫn này, bạn đã học cách thiết lập một API GraphQL trong Java, triển khai các tính năng nâng cao, và nâng cao quy trình phát triển của bạn với Apidog.

Vậy, bạn đang chờ đợi điều gì? Tải xuống Apidog miễn phí ngay hôm nay và bắt đầu xây dựng thế hệ API tiếp theo với GraphQL và Java!

button

Thực hành thiết kế API trong Apidog

Khám phá cách dễ dàng hơn để xây dựng và sử dụng API

Đăng ký miễn phíTải xuống