Java ile GraphQL API Geliştirme

```html

Eğer bir Java geliştiricisiyseniz, muhtemelen REST API'leriyle, örneğin aşırı veri getirme veya yetersiz veri getirme gibi zorluklarla karşılaşmışsınızdır. GraphQL'e girin—istemcilere tam olarak neye ihtiyaçları olduğunu ve daha fazlasını isteme gücü vererek bu sorunları çözen, API'niz için güçlü bir sorgu dili.

Bugün, esnek ve verimli API'ler oluşturmak için Java'da GraphQL'i nasıl uygulayabileceğinize dalıyoruz. Ancak işin inceliklerine girmeden önce, yolculuğunuzu kolaylaştıracak heyecan verici bir araç paylaşayım—Apidog.

💡

Apidog, API deneyiminizi geliştirmek için ÜCRETSİZ olarak indirebileceğiniz harika bir API geliştirme aracıdır. İnanın bana, bu bir oyun değiştirici!

button

GraphQL Nedir?

GraphQL, 2012'de Facebook tarafından geliştirilen ve 2015'te kamuya açık olarak yayınlanan, API'ler için açık kaynaklı bir veri sorgulama ve işleme dilidir. Birden fazla uç nokta sunan REST'in aksine, GraphQL, istemcilerin tek bir uç noktayı sorgulamasına ve tam olarak hangi verilere ihtiyaç duyduklarını belirtmelerine olanak tanır. Bu, daha verimli veri alımına ve daha az ağ kullanımına yol açar.

Neden GraphQL için Java'yı Seçmelisiniz?

Sağlam ve yaygın olarak kullanılan bir programlama dili olan Java, çeşitli nedenlerle GraphQL'i uygulamak için mükemmeldir:

Güçlü Yazma: Java'nın güçlü tür sistemi, GraphQL'in şema tabanlı yapısıyla iyi uyum sağlar.
Topluluk Desteği: Java, GraphQL uygulamanızı kolaylaştırmak için kütüphaneler ve araçlar bulabilmenizi sağlayan geniş bir ekosisteme ve topluluk desteğine sahiptir.
Performans: Java'nın performans yetenekleri, karmaşık ve büyük ölçekli GraphQL sorgularını işlemek için onu uygun hale getirir.

Java'da GraphQL'e Başlarken

Şimdi, bir Java uygulamasında GraphQL'i kurma ve kullanma adımlarını inceleyelim. Java uygulamaları oluşturmak için popüler bir çerçeve olan Spring Boot'u ve bazı güçlü GraphQL kütüphanelerini kullanacağız.

Adım 1: Spring Boot Projenizi Kurun

İlk olarak, yeni bir Spring Boot projesi oluşturun. Bunu Spring Initializr veya favori IDE'nizi kullanarak yapabilirsiniz.

İşte Spring Initializr kullanarak basit bir kurulum:

start.spring.io adresine gidin.
"Gradle Project" veya "Maven Project" seçeneğini seçin.
Gerekli bağımlılıkları ekleyin:

Spring Web
Spring Boot DevTools
Spring Data JPA
H2 Database (basitlik için)

Projeyi oluşturun ve indirilen dosyayı açın. IDE'nizde açın.

Adım 2: GraphQL Bağımlılıklarını Ekleyin

Ardından, projenize GraphQL bağımlılıklarını ekleyin. build.gradle veya pom.xml dosyanızda şunları ekleyin:

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

Veya Maven için:

<!-- 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>

Adım 3: GraphQL Şemanızı Tanımlayın

src/main/resources dizininde graphql adında bir klasör oluşturun. Bu klasörde, GraphQL şemanızı tanımlamak için schema.graphqls adında bir dosya oluşturun. İşte basit bir örnek:

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

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

Adım 4: Java Modellerinizi Oluşturun

Projenizde basit bir Book sınıfı oluşturun:

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 ve Setters
}

Adım 5: Depolarınızı Kurun

Book varlığınız için bir depo arayüzü oluşturun:

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

Adım 6: GraphQL Çözücüleri Oluşturun

Şimdi, GraphQL sorgularınız için çözücüler oluşturun. Çözücüler, GraphQL şemasında belirtilen verileri getirmekten sorumludur.

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

Adım 7: GraphQL API'nizi Test Edin

Her şey kurulduktan sonra, GraphQL API'nizi test etme zamanı. Spring Boot uygulamanızı çalıştırın ve tarayıcınızda http://localhost:8080/graphiql adresine gidin. Bu, sorgularınızı test edebileceğiniz GraphiQL arayüzünü açacaktır.

Tüm kitapları getirmek için aşağıdaki sorguyu deneyin:

{
    getAllBooks {
        id
        title
        author
        publishedDate
    }
}

Veritabanınızdan döndürülen bir kitap listesi görmelisiniz.

Gelişmiş GraphQL Özellikleri

Temel bir GraphQL API'si kurduğunuza göre, API'nizi daha da güçlü hale getirmek için bazı gelişmiş özellikleri keşfedelim.

Değişiklikler

Sorgulara ek olarak, GraphQL, istemcilerin verileri değiştirmesine izin veren değişiklikleri destekler. schema.graphqls dosyanıza aşağıdakileri ekleyin:

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

Ardından, bu değişiklikler için bir çözücü oluşturun:

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

Hata İşleme

Sağlam bir API için hataları zarif bir şekilde işlemek çok önemlidir. GraphQL'de, hatalar standart bir biçimde döndürülür ve bu da istemcilerin neyin yanlış gittiğini anlamasını kolaylaştırır. Özel bir istisna ve bir işleyici oluşturarak Spring Boot uygulamanızda hata işlemesini özelleştirebilirsiniz.

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

Ardından, bu istisnaları yönetmek için bir işleyici oluşturun:

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

Farkları Anlamak: GraphQL Java vs. GraphQL Spring Boot

Apidog'un yeteneklerine dalmadan önce, GraphQL Java kullanmak ile GraphQL'i Spring Boot ile entegre etmek arasındaki farkları anlamak önemlidir.

GraphQL Java

GraphQL Java, Java uygulamalarında GraphQL'i uygulamak için temel bir kütüphanedir. Şemaları tanımlamak, sorguları işlemek ve değişiklikleri işlemek için temel işlevselliği sağlar. İşte bazı önemli noktalar:

Esneklik: GraphQL Java, GraphQL şemalarınızı ve türlerinizi nasıl tanımladığınızı ve çözdüğünüzü özelleştirmenize izin veren düşük seviyeli esneklik sunar.
Manuel Kurulum: Temel bir kütüphane olduğundan, GraphQL Java kullanmak daha fazla manuel kurulum ve kalıp kodu gerektirir. Şema ayrıştırma, sorgu yürütme ve kablolama gibi yönleri manuel olarak ele almanız gerekir.
Kontrol: Karmaşık ve son derece özelleştirilmiş GraphQL uygulamaları için ideal hale getiren, GraphQL yürütme süreci üzerinde ayrıntılı kontrol sağlar.

GraphQL Spring Boot

Öte yandan GraphQL Spring Boot, GraphQL Java'nın üzerine inşa edilen ve onu Spring Boot ekosistemiyle sorunsuz bir şekilde entegre eden, fikir sahibi bir çerçevedir. İşte nasıl farklılaştığı:

Kullanım Kolaylığı: GraphQL Spring Boot, otomatik yapılandırma ve makul varsayımlar sağlayarak kurulum sürecini basitleştirir. Kalıp kodunu azaltmak için Spring Boot'un sözleşmeye göre yapılandırma yaklaşımından yararlanır.
Spring Entegrasyonu: Sağlam ve güvenli GraphQL API'leri oluşturmayı kolaylaştıran Spring Data, Spring Security ve Spring Web gibi diğer Spring bileşenleriyle sorunsuz bir şekilde entegre olur.
Gelişmiş Araçlar: Çerçeve, etkileşimli sorgu testi ve şema görselleştirme için GraphiQL ve Voyager gibi ek araçlar içerir ve geliştirici deneyimini iyileştirir.

GraphQL Spring Boot'u seçerek, geliştirme sürecini hızlandırabilir ve GraphQL kurulumunun inceliklerinden ziyade iş mantığınıza daha fazla odaklanabilirsiniz. Ancak, ince taneli kontrole ihtiyacınız varsa ve daha uygulamalı bir yaklaşımla rahatsanız, GraphQL Java güçlü bir alternatiftir.

Bu iki yaklaşım arasındaki farklılıkları netleştirdiğimize göre, Apidog'un GraphQL API geliştirme sürecinizi daha da nasıl geliştirebileceğini keşfedelim.

Apidog'u GraphQL Java Projenizle Entegre Etme

Apidog, API geliştirme sürecinizi önemli ölçüde kolaylaştırabilen kapsamlı bir API yönetim aracıdır. API yönetimi yeteneklerinizi geliştirmek için Apidog'u GraphQL Java projenize nasıl entegre edebileceğiniz aşağıda açıklanmıştır.

Adım 1: Apidog'u İndirin ve Kurun

İlk olarak, Apidog'u indirin ve kurulum talimatlarını izleyin.

button

Adım 2: GraphQL Şemanızı İçe Aktarın

Apidog'u kurduktan sonra, API'nizi daha verimli bir şekilde yönetmek ve test etmek için GraphQL şemanızı içe aktarabilirsiniz. Apidog'daki içe aktarma bölümüne gidin ve schema.graphqls dosyanızı yükleyin.

Sorgunuzu "Çalıştır" sekmesindeki Sorgu kutusuna girin. Ayrıca, Sorgu ifadeleri için "kod tamamlama" özelliğini etkinleştirmek ve Sorgu ifadeleri girmenize yardımcı olmak için giriş kutusundaki manuel Şemayı Getir düğmesini de tıklayabilirsiniz.

Adım 3: API'nizi Test Edin ve Belgeleyin

Şemanız içe aktarıldıktan sonra, sorgularınızı ve değişikliklerinizi test etmek, dokümantasyon oluşturmak ve hatta yanıtları taklit etmek için Apidog'u kullanabilirsiniz. Bu, API'nizin beklendiği gibi çalıştığından emin olmanıza yardımcı olacak ve API kullanıcılarınız için kapsamlı bir rehber sağlayacaktır.

Sonuç: API Geliştirmenin Geleceğini Kucaklayın

GraphQL ve Java birlikte, verimli ve esnek API'ler oluşturmak için güçlü bir çözüm sunar. Bu kılavuzu izleyerek, Java'da bir GraphQL API'si kurmayı, gelişmiş özellikleri uygulamayı ve geliştirme sürecinizi Apidog ile geliştirmeyi öğrendiniz.

Öyleyse, ne bekliyorsunuz? Bugün ücretsiz olarak Apidog'u indirin ve GraphQL ve Java ile yeni nesil API'ler oluşturmaya başlayın!

button

```