การพัฒนา GraphQL API ด้วย Java

หากคุณเป็นนักพัฒนา Java คุณอาจเคยเผชิญกับความท้าทายเกี่ยวกับ REST API เช่น การดึงข้อมูลมากเกินไปหรือน้อยเกินไป พบกับ GraphQL—ภาษาคิวรีอันทรงพลังสำหรับ API ของคุณ ซึ่งแก้ปัญหาเหล่านี้ได้โดยให้ลูกค้ามีความสามารถในการขอข้อมูลที่ต้องการอย่างแม่นยำและไม่มีอะไรเพิ่มเติม

วันนี้ เราจะเจาะลึกถึงวิธีการที่คุณสามารถนำ GraphQL ไปใช้ใน Java เพื่อสร้าง API ที่ยืดหยุ่นและมีประสิทธิภาพ แต่ก่อนที่เราจะเจาะลึกในรายละเอียด ขอแนะนำเครื่องมือที่น่าตื่นเต้นที่จะทำให้การเดินทางของคุณราบรื่นขึ้น—Apidog

GraphQL คืออะไร?

GraphQL คือภาษาคิวรีและจัดการข้อมูลแบบโอเพนซอร์สสำหรับ API ซึ่งพัฒนาโดย Facebook ในปี 2012 และเปิดตัวต่อสาธารณชนในปี 2015 ซึ่งแตกต่างจาก REST ที่เปิดเผยหลายเอนด์พอยต์ GraphQL ช่วยให้ลูกค้าสามารถคิวรีเอนด์พอยต์เดียวและระบุข้อมูลที่ต้องการได้อย่างแม่นยำ สิ่งนี้นำไปสู่การดึงข้อมูลที่มีประสิทธิภาพมากขึ้นและลดการใช้เครือข่าย

ทำไมต้องเลือก Java สำหรับ GraphQL?

Java ซึ่งเป็นภาษาโปรแกรมที่แข็งแกร่งและใช้กันอย่างแพร่หลาย เหมาะอย่างยิ่งสำหรับการนำ GraphQL ไปใช้ด้วยเหตุผลหลายประการ:

1. การพิมพ์ที่แข็งแกร่ง: ระบบการพิมพ์ที่แข็งแกร่งของ Java สอดคล้องกับโครงสร้างตาม schema ของ GraphQL ได้อย่างดี
2. การสนับสนุนจากชุมชน: Java มีระบบนิเวศและการสนับสนุนจากชุมชนมากมาย ทำให้มั่นใจได้ว่าคุณสามารถค้นหาไลบรารีและเครื่องมือเพื่ออำนวยความสะดวกในการนำ GraphQL ไปใช้
3. ประสิทธิภาพ: ความสามารถด้านประสิทธิภาพของ Java ทำให้เหมาะสำหรับการจัดการคิวรี GraphQL ที่ซับซ้อนและขนาดใหญ่

เริ่มต้นใช้งาน GraphQL ใน Java

ตอนนี้ มาดูขั้นตอนในการตั้งค่าและใช้ GraphQL ในแอปพลิเคชัน Java กัน เราจะใช้ Spring Boot ซึ่งเป็นเฟรมเวิร์กยอดนิยมสำหรับการสร้างแอปพลิเคชัน Java พร้อมกับไลบรารี GraphQL ที่ทรงพลังบางส่วน

ขั้นตอนที่ 1: ตั้งค่าโปรเจกต์ Spring Boot ของคุณ

ขั้นแรก สร้างโปรเจกต์ Spring Boot ใหม่ คุณสามารถทำได้โดยใช้ Spring Initializr หรือ IDE ที่คุณชื่นชอบ

นี่คือการตั้งค่าอย่างง่ายโดยใช้ Spring Initializr:

1. ไปที่ start.spring.io
2. เลือก "Gradle Project" หรือ "Maven Project"
3. เพิ่ม dependencies ที่จำเป็น:

• Spring Web
• Spring Boot DevTools
• Spring Data JPA
• H2 Database (เพื่อความเรียบง่าย)

สร้างโปรเจกต์และแตกไฟล์ที่ดาวน์โหลด เปิดใน IDE ของคุณ

ขั้นตอนที่ 2: เพิ่ม GraphQL Dependencies

ถัดไป เพิ่ม GraphQL dependencies ให้กับโปรเจกต์ของคุณ ในไฟล์ build.gradle หรือ pom.xml ให้ใส่:

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

หรือสำหรับ 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>

ขั้นตอนที่ 3: กำหนด GraphQL Schema ของคุณ

สร้างโฟลเดอร์ชื่อ graphql ในไดเรกทอรี src/main/resources ในโฟลเดอร์นี้ สร้างไฟล์ชื่อ schema.graphqls เพื่อกำหนด GraphQL schema ของคุณ นี่คือตัวอย่างง่ายๆ:

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

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

ขั้นตอนที่ 4: สร้าง Java Models ของคุณ

สร้างคลาส Book ง่ายๆ ในโปรเจกต์ของคุณ:

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
}

ขั้นตอนที่ 5: ตั้งค่า Repositories ของคุณ

สร้าง interface repository สำหรับ entity Book ของคุณ:

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

ขั้นตอนที่ 6: สร้าง GraphQL Resolvers

ตอนนี้ สร้าง resolvers สำหรับคิวรี GraphQL ของคุณ Resolvers มีหน้าที่ดึงข้อมูลที่ระบุใน GraphQL schema

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

ขั้นตอนที่ 7: ทดสอบ GraphQL API ของคุณ

เมื่อตั้งค่าทุกอย่างแล้ว ก็ถึงเวลาทดสอบ GraphQL API ของคุณ รันแอปพลิเคชัน Spring Boot ของคุณและไปที่ http://localhost:8080/graphiql ในเบราว์เซอร์ของคุณ ซึ่งจะเปิดอินเทอร์เฟซ GraphiQL ที่คุณสามารถทดสอบคิวรีของคุณได้

ลองใช้คิวรีต่อไปนี้เพื่อดึงข้อมูลหนังสือทั้งหมด:

{
    getAllBooks {
        id
        title
        author
        publishedDate
    }
}

คุณควรเห็นรายการหนังสือที่ส่งคืนจากฐานข้อมูลของคุณ

คุณสมบัติ GraphQL ขั้นสูง

ตอนนี้คุณมี GraphQL API พื้นฐานแล้ว มาสำรวจคุณสมบัติขั้นสูงบางอย่างเพื่อให้ API ของคุณมีประสิทธิภาพมากยิ่งขึ้น

Mutations

นอกเหนือจากคิวรีแล้ว GraphQL ยังรองรับ mutations ซึ่งช่วยให้ลูกค้าสามารถแก้ไขข้อมูลได้ เพิ่มสิ่งต่อไปนี้ลงในไฟล์ schema.graphqls ของคุณ:

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

จากนั้น สร้าง resolver สำหรับ mutations เหล่านี้:

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

การจัดการข้อผิดพลาด

การจัดการข้อผิดพลาดอย่างเหมาะสมเป็นสิ่งสำคัญสำหรับ API ที่แข็งแกร่ง ใน GraphQL ข้อผิดพลาดจะถูกส่งกลับในรูปแบบมาตรฐาน ทำให้ลูกค้าเข้าใจสิ่งที่ผิดพลาดได้ง่ายขึ้น คุณสามารถปรับแต่งการจัดการข้อผิดพลาดในแอปพลิเคชัน Spring Boot ของคุณได้โดยการสร้างข้อยกเว้นแบบกำหนดเองและ 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;
    }
}

จากนั้น สร้าง handler เพื่อจัดการข้อยกเว้นเหล่านี้:

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

ทำความเข้าใจความแตกต่าง: GraphQL Java เทียบกับ GraphQL Spring Boot

ก่อนที่จะเจาะลึกถึงความสามารถของ Apidog สิ่งสำคัญคือต้องทำความเข้าใจความแตกต่างระหว่างการใช้ GraphQL Java และการรวม GraphQL กับ Spring Boot

GraphQL Java

GraphQL Java เป็นไลบรารีพื้นฐานสำหรับการนำ GraphQL ไปใช้ในแอปพลิเคชัน Java ซึ่งมีฟังก์ชันการทำงานหลักในการกำหนด schemas จัดการคิวรี และประมวลผล mutations นี่คือประเด็นสำคัญบางประการ:

1. ความยืดหยุ่น: GraphQL Java มีความยืดหยุ่นในระดับต่ำ ทำให้คุณสามารถปรับแต่งวิธีการกำหนดและแก้ไข GraphQL schemas และ types ของคุณได้
2. การตั้งค่าด้วยตนเอง: เนื่องจากเป็นไลบรารีหลัก การใช้ GraphQL Java ต้องมีการตั้งค่าและโค้ด boilerplate ด้วยตนเองมากขึ้น คุณจะต้องจัดการกับแง่มุมต่างๆ เช่น การแยกวิเคราะห์ schema การดำเนินการคิวรี และการเดินสายไฟด้วยตนเอง
3. การควบคุม: มีการควบคุมกระบวนการดำเนินการ GraphQL อย่างละเอียด ทำให้เหมาะสำหรับการนำ GraphQL ไปใช้ที่ซับซ้อนและปรับแต่งได้สูง

GraphQL Spring Boot

ในทางกลับกัน GraphQL Spring Boot เป็นเฟรมเวิร์กที่มีความคิดเห็นซึ่งสร้างขึ้นบน GraphQL Java โดยผสานรวมเข้ากับระบบนิเวศ Spring Boot ได้อย่างราบรื่น นี่คือความแตกต่าง:

1. ใช้งานง่าย: GraphQL Spring Boot ทำให้กระบวนการตั้งค่าง่ายขึ้นโดยให้การกำหนดค่าอัตโนมัติและการตั้งค่าเริ่มต้นที่สมเหตุสมผล ซึ่งใช้แนวทาง convention-over-configuration ของ Spring Boot เพื่อลดโค้ด boilerplate
2. การรวม Spring: ผสานรวมกับส่วนประกอบ Spring อื่นๆ ได้อย่างราบรื่น เช่น Spring Data, Spring Security และ Spring Web ทำให้ง่ายต่อการสร้าง GraphQL API ที่แข็งแกร่งและปลอดภัย
3. เครื่องมือที่ได้รับการปรับปรุง: เฟรมเวิร์กรวมถึงเครื่องมือเพิ่มเติม เช่น GraphiQL และ Voyager สำหรับการทดสอบคิวรีแบบโต้ตอบและการแสดงภาพ schema ซึ่งช่วยปรับปรุงประสบการณ์ของนักพัฒนา

ด้วยการเลือก GraphQL Spring Boot คุณสามารถเร่งการพัฒนาและมุ่งเน้นไปที่ตรรกะทางธุรกิจของคุณมากกว่าความซับซ้อนของการตั้งค่า GraphQL อย่างไรก็ตาม หากคุณต้องการการควบคุมแบบละเอียดและสะดวกสบายกับแนวทางปฏิบัติจริงมากขึ้น GraphQL Java เป็นทางเลือกที่มีประสิทธิภาพ

ตอนนี้เราได้ชี้แจงความแตกต่างระหว่างสองแนวทางนี้แล้ว มาสำรวจกันว่า Apidog สามารถปรับปรุงกระบวนการพัฒนา GraphQL API ของคุณได้อย่างไร

การรวม Apidog กับโปรเจกต์ GraphQL Java ของคุณ

Apidog เป็นเครื่องมือจัดการ API ที่ครอบคลุมซึ่งสามารถปรับปรุงกระบวนการพัฒนา API ของคุณได้อย่างมาก นี่คือวิธีที่คุณสามารถรวม Apidog เข้ากับโปรเจกต์ GraphQL Java ของคุณเพื่อเพิ่มความสามารถในการจัดการ API ของคุณ

ขั้นตอนที่ 1: ดาวน์โหลดและติดตั้ง Apidog

ขั้นแรก ดาวน์โหลด Apidog และทำตามคำแนะนำในการติดตั้ง

ขั้นตอนที่ 2: นำเข้า GraphQL Schema ของคุณ

เมื่อคุณติดตั้ง Apidog แล้ว คุณสามารถนำเข้า GraphQL schema ของคุณเพื่อจัดการและทดสอบ API ของคุณได้อย่างมีประสิทธิภาพมากขึ้น ไปที่ส่วนนำเข้าใน Apidog และอัปโหลดไฟล์ schema.graphqls ของคุณ

​ป้อนคิวรีของคุณในช่อง Query บนแท็บ "Run" คุณยังสามารถคลิกปุ่ม Fetch Schema ด้วยตนเองในช่องป้อนข้อมูลเพื่อเปิดใช้งานคุณสมบัติ "การเติมโค้ด" สำหรับนิพจน์ Query ซึ่งช่วยในการป้อนคำสั่ง Query

ขั้นตอนที่ 3: ทดสอบและจัดทำเอกสาร API ของคุณ

เมื่อนำเข้า schema ของคุณแล้ว คุณสามารถใช้ Apidog เพื่อทดสอบคิวรีและ mutations ของคุณ สร้างเอกสาร และแม้แต่จำลองการตอบสนอง ซึ่งจะช่วยให้คุณมั่นใจได้ว่า API ของคุณทำงานตามที่คาดไว้ และให้คำแนะนำที่ครอบคลุมสำหรับผู้ใช้ API ของคุณ

บทสรุป: ยอมรับอนาคตของการพัฒนา API

GraphQL และ Java ร่วมกันนำเสนอโซลูชันที่มีประสิทธิภาพสำหรับการสร้าง API ที่มีประสิทธิภาพและยืดหยุ่น ด้วยการทำตามคำแนะนำนี้ คุณได้เรียนรู้วิธีตั้งค่า GraphQL API ใน Java นำคุณสมบัติขั้นสูงไปใช้ และปรับปรุงกระบวนการพัฒนาของคุณด้วย Apidog

ดังนั้น คุณจะรออะไรอีก ดาวน์โหลด Apidog ได้ฟรีวันนี้ และเริ่มสร้าง API รุ่นต่อไปด้วย GraphQL และ Java!