Bina API dan sistem pertanyaan menggunakan Spring Boot dan GraphQL

Memandangkan kerumitan aplikasi moden terus meningkat, adalah semakin penting untuk membina API berskala dan sistem pertanyaan. Pada masa lalu, REST API dan SOAP ialah penyelesaian pembinaan API arus perdana, tetapi kini GraphQL juga telah menjadi pilihan yang popular. Artikel ini akan memperkenalkan cara menggunakan Spring Boot dan GraphQL untuk membina API dan sistem pertanyaan.

Apakah itu GraphQL?

GraphQL ialah bahasa pertanyaan untuk API dan sistem pertanyaan. Berbanding dengan API REST tradisional, GraphQL mempunyai kelebihan berikut:

• Fleksibiliti: GraphQL membenarkan pelanggan menentukan data yang mereka perlukan, jadi penghantaran data yang tidak perlu boleh dielakkan.
• Keterluasan: GraphQL menyediakan tahap fleksibiliti yang tinggi kepada pelanggan dan pelayan, jadi medan atau operasi baharu boleh ditambah dengan mudah.
• Prestasi: Oleh kerana GraphQL membenarkan pelanggan menentukan data yang mereka perlukan, tarikan data yang berlebihan dapat dielakkan.

Spring Boot dan GraphQL

Spring Boot ialah rangka kerja Java untuk membina aplikasi web berasaskan Java. Ia menyediakan banyak ciri berguna seperti konfigurasi automatik dan pembangunan pesat. Berbanding dengan pembangunan web Java tradisional, Spring Boot boleh menjadikan proses pembangunan lebih menyeronokkan dan cekap.

Dalam artikel ini, kami akan menggunakan Spring Boot dan GraphQL untuk membina API asas dan sistem pertanyaan. Sebelum anda bermula, anda perlu mengetahui komponen berikut:

• Spring Boot: digunakan untuk membina aplikasi web berasaskan Java.
• GraphQL Java: Pelaksanaan GraphQL Java.
• Spring Boot Starter Data JPA: Digunakan untuk menyepadukan Spring Boot dan Java Persistence API (JPA).
• Pangkalan Data H2: Pangkalan data dalam memori untuk pembangunan dan ujian tempatan.

Membina API dan sistem pertanyaan

Pertama, kita perlu mencipta aplikasi Spring Boot. Anda boleh menggunakan Spring Initializr untuk membuat aplikasi Spring Boot dengan cepat. Berikut ialah langkah-langkah untuk membuat aplikasi Spring Boot:

• Buka tapak web Spring Initializr.
• Pilih versi Spring Boot anda.
• Anda boleh memilih alat binaan pilihan anda, seperti Maven atau Gradle.
• Tambah kebergantungan yang diperlukan. Dalam artikel ini, kami memerlukan "Spring Web", "GraphQL Java Tools", "GraphQL Java Spring Boot Starter", "Spring Boot Starter Data JPA" dan "H2 Database".
• Klik butang "Jana" dan struktur aplikasi Spring Boot asas akan dimuat turun.

Mencipta Skema GraphQL

Sebelum mencipta Skema GraphQL, mari kita fikirkan apa yang perlu dilakukan oleh API kita. Kami akan membuat API dengan tiga jenis: hubungan pengarang, buku dan buku pengarang. Berikut ialah operasi API kami:

• Dapatkan senarai pengarang: Kembalikan senarai pengarang.
• Dapatkan pengarang melalui ID: Kembalikan butiran pengarang mengikut ID pengarang.
• Dapatkan senarai buku: Kembali ke senarai buku.
• Dapatkan buku dengan ID: Kembalikan butiran buku mengikut ID buku.
• Dapatkan senarai perhubungan pengarang-buku: Kembalikan senarai perhubungan pengarang-buku.
• Dapatkan buku berkaitan mengikut ID pengarang: Kembalikan semua butiran buku pengarang mengikut ID pengarang.

Langkah seterusnya ialah mencipta Skema GraphQL. Skema mentakrifkan operasi yang boleh dilakukan pada API. Dalam artikel ini, kami akan menggunakan Alat Java GraphQL untuk mencipta Skema. Langkah-langkah untuk mencipta Skema GraphQL adalah seperti berikut:

• Buat fail bernama "schema.graphqls" dalam folder src/main/resources dan tambah kod berikut:

type Author {
  id: ID!
  name: String!
}

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

type Relationship {
  id: ID!
  author: Author!
  book: Book!
}

type Query {
  authors: [Author]
  author(id: ID!): Author
  books: [Book]
  book(id: ID!): Book
  relationships: [Relationship]
  booksByAuthor(authorId: ID!): [Book]
}

Skema ini mentakrifkan tiga jenis: Pengarang, Buku dan Perhubungan. Ia juga mentakrifkan enam operasi: dapatkan senarai pengarang, dapatkan pengarang mengikut ID, dapatkan senarai buku, dapatkan buku mengikut ID, dapatkan senarai perhubungan dan dapatkan buku berkaitan mengikut ID pengarang.

• Buat perkhidmatan GraphQL dalam projek dan muatkan fail schema.graphqls ke dalam perkhidmatan. Cipta kelas baharu bernama "GraphQLProvider" dalam folder src/main/java/com.example.demo dengan kod berikut:

package com.example.demo;

import com.example.demo.entity.*;
import com.example.demo.repository.*;
import com.example.demo.resolver.*;

import java.util.List;

import javax.annotation.PostConstruct;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import graphql.schema.DataFetcher;
import graphql.schema.DataFetchingEnvironment;
import graphql.schema.GraphQLSchema;
import graphql.schema.idl.RuntimeWiring;
import graphql.schema.idl.SchemaGenerator;
import graphql.schema.idl.SchemaParser;
import graphql.schema.idl.TypeRuntimeWiring;
import graphql.servlet.GraphQLServlet;
import graphql.servlet.SimpleGraphQLHttpServlet;

@Configuration
public class GraphQLProvider {
    private static final Logger LOGGER = LoggerFactory.getLogger(GraphQLProvider.class);

    private final AuthorRepository authorRepository;
    private final BookRepository bookRepository;
    private final RelationshipRepository relationshipRepository;
    private List<DataFetcher> fetchDataers;

    @Autowired
    public GraphQLProvider(
      AuthorRepository authorRepository,
      BookRepository bookRepository,
      RelationshipRepository relationshipRepository,
      List<DataFetcher> fetchDataers
    ) {
        this.authorRepository = authorRepository;
        this.bookRepository = bookRepository;
        this.relationshipRepository = relationshipRepository;
        this.fetchDataers = fetchDataers;
    }

    @PostConstruct
    public void setup() {
        fetchDataers.add(new DataFetcher() {
            @Override
            public Object get(DataFetchingEnvironment environment) {
                return authorRepository.findAll();
            }
        });

        fetchDataers.add(new DataFetcher() {
            @Override
            public Object get(DataFetchingEnvironment environment) {
                return authorRepository.findById(environment.getArgument("id")).get();
            }
        });

        fetchDataers.add(new DataFetcher() {
            @Override
            public Object get(DataFetchingEnvironment environment) {
                return bookRepository.findAll();
            }
        });

        fetchDataers.add(new DataFetcher() {
            @Override
            public Object get(DataFetchingEnvironment environment) {
                return bookRepository.findById(environment.getArgument("id")).get();
            }
        });

        fetchDataers.add(new DataFetcher() {
            @Override
            public Object get(DataFetchingEnvironment environment) {
                return relationshipRepository.findAll();
            }
        });

        fetchDataers.add(new DataFetcher() {
            @Override
            public Object get(DataFetchingEnvironment environment) {
                return bookRepository.findByAuthor_Id(environment.getArgument("authorId"));
            }
        });
    }

    @Bean
    public GraphQLSchema schema() {
        SchemaParser schemaParser = new SchemaParser();
        SchemaGenerator schemaGenerator = new SchemaGenerator();
        TypeRuntimeWiring.Builder authorWiring = newTypeWiring("Author").dataFetchers(fetchDataers);

        return schemaGenerator.makeExecutableSchema(schemaParser.parse(getClass().getResource("/schema.graphqls").getPath()), RuntimeWiring.newRuntimeWiring()
          .type(authorWiring)
          .build());
    }

    @Bean
    public GraphQLServlet graphQLServlet() {
        return new SimpleGraphQLHttpServlet(new GraphQL.Builder(schema()).build());
    }
}

Kelas ini mencipta perkhidmatan GraphQL, menukar skema The .graphqls fail dimuatkan ke dalam perkhidmatan dan Pengambil Data ditentukan. Pengambil Data bertanggungjawab untuk mengambil data dan mengisinya dengan hasil operasi GraphQL.

Mencipta Entiti dan Repositori JPA

Sekarang, kita perlu mencipta entiti dan memetakannya ke dalam pangkalan data. Dalam artikel ini, kami akan mencipta entiti Pengarang, Buku dan Perhubungan dan memetakannya ke pangkalan data H2 menggunakan JPA.

• Buat antara muka baharu bernama "AuthorRepository" dalam pakej src/main/java/com.example.demo.repository dengan kod berikut:

package com.example.demo.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.demo.entity.Author;

@Repository
public interface AuthorRepository extends JpaRepository<Author, Long> {
}

• Ikuti kaedah di atas untuk mencipta BookRepository dan RelationshipRepository.
• Buat entiti dan perhubungan dalam pakej src/main/java/com.example.demo.entity. Berikut ialah kod sampel untuk entiti Pengarang:

package com.example.demo.entity;

import lombok.Data;

import javax.persistence.*;

@Data
@Entity
public class Author {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String name;

    protected Author() {}

    public Author(String name) {
        this.name = name;
    }
}

Dalam contoh di atas, kami telah mencipta entiti Java bernama Pengarang menggunakan medan "id" dan "nama" anotasi @Data Lombok.

• Masukkan buku dan perhubungan.

Mengisi data

Kini kami boleh mengisi data menggunakan konsol H2 atau menulis kod Java.

Gunakan konsol H2 untuk mengisi data:

• 在src/main/resources文件夹中创建一个名为“data.sql”的文件，并添加以下代码：

INSERT INTO author (id, name) VALUES (1, 'William Shakespeare');
INSERT INTO author (id, name) VALUES (2, 'John Milton');
INSERT INTO author (id, name) VALUES (3, 'Charles Dickens');

INSERT INTO book (id, title, author_id) VALUES (1, 'Hamlet', 1);
INSERT INTO book (id, title, author_id) VALUES (2, 'Paradise Lost', 2);
INSERT INTO book (id, title, author_id) VALUES (3, 'Oliver Twist', 3);

INSERT INTO relationship (id, author_id, book_id) VALUES (1, 1, 1);
INSERT INTO relationship (id, author_id, book_id) VALUES (2, 2, 2);
INSERT INTO relationship (id, author_id, book_id) VALUES (3, 3, 3);

• 启动应用程序并访问http://localhost:8080/h2-console。
• 在H2控制台中，更改JDBC URL为jdbc:h2:mem:testdb并单击Connect按钮。
• 执行data.sql文件中的查询以填充数据。

使用Java代码填充数据：

• 在src/main/java/com.example.demo.seed包中创建一个新类并命名为“DataSeed”，其中包含以下代码：

package com.example.demo.seed;

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import com.example.demo.entity.Author;
import com.example.demo.entity.Book;
import com.example.demo.entity.Relationship;
import com.example.demo.repository.AuthorRepository;
import com.example.demo.repository.BookRepository;
import com.example.demo.repository.RelationshipRepository;

@Component
public class DataSeed implements CommandLineRunner {

    private AuthorRepository authorRepository;
    private BookRepository bookRepository;
    private RelationshipRepository relationshipRepository;

    public DataSeed(AuthorRepository authorRepository,
                    BookRepository bookRepository,
                    RelationshipRepository relationshipRepository) {
        this.authorRepository = authorRepository;
        this.bookRepository = bookRepository;
        this.relationshipRepository = relationshipRepository;
    }

    @Override
    public void run(String... args) throws Exception {
        Author shakespeare = new Author("William Shakespeare");
        Author milton = new Author("John Milton");
        Author dickens = new Author("Charles Dickens");

        authorRepository.save(shakespeare);
        authorRepository.save(milton);
        authorRepository.save(dickens);

        Book hamlet = new Book("Hamlet", shakespeare);
        Book paradiseLost = new Book("Paradise Lost", milton);
        Book oliverTwist = new Book("Oliver Twist", dickens);

        bookRepository.save(hamlet);
        bookRepository.save(paradiseLost);
        bookRepository.save(oliverTwist);

        relationshipRepository.save(new Relationship(shakespeare, hamlet));
        relationshipRepository.save(new Relationship(milton, paradiseLost));
        relationshipRepository.save(new Relationship(dickens, oliverTwist));
    }
}

在上面的示例中，我们创建了一个CommandLineRunner工具类，它在应用程序启动时添加示例数据到数据库中。

测试GraphQL API

我们现在可以使用GraphQL Playground工具查询GraphQL API。

以下是一些示例查询：

获取作者列表：

query {
  authors {
    id
    name
  }
}

按ID获取作者：

query {
  author(id: 1) {
    id
    name
  }
}

获取书籍列表：

query {
  books {
    id
    title
    author {
      id
      name
    }
  }
}

按ID获取书籍：

query {
  book(id: 1) {
    id
    title
    author {
      id
      name
    }
  }
}

获取作者-书籍关系列表：

query {
  relationships {
    id
    author {
      id
      name
    }
    book {
      id
      title
    }
  }
}

按作者ID获取关联书籍：

query {
  booksByAuthor(authorId: 1) {
    id
    title
    author {
      id
      name
    }
  }
}

结论

本文介绍了如何使用Spring Boot和GraphQL构建API和查询系统，并执行基本的操作。可以使用GraphQL Java Tools和JPA轻松定义Schema和映射实体。GraphQL的灵活性和可扩展性使得它成为构建现代Web应用程序的理想选择。

Atas ialah kandungan terperinci Bina API dan sistem pertanyaan menggunakan Spring Boot dan GraphQL. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!