Spring Boot 및 GraphQL을 사용하여 API 및 쿼리 시스템 구축-java지도 시간-php.cn

최신 애플리케이션의 복잡성이 계속 증가함에 따라 확장 가능한 API 및 쿼리 시스템을 구축하는 것이 점점 더 중요해지고 있습니다. 과거에는 REST API와 SOAP가 주류 API 구축 솔루션이었지만 이제는 GraphQL도 인기 있는 옵션이 되었습니다. 이 기사에서는 Spring Boot와 GraphQL을 사용하여 API 및 쿼리 시스템을 구축하는 방법을 소개합니다.

GraphQL이란 무엇인가요?

GraphQL은 API 및 쿼리 시스템을 위한 쿼리 언어입니다. 기존 REST API와 비교하여 GraphQL에는 다음과 같은 장점이 있습니다.

유연성: GraphQL을 사용하면 클라이언트가 필요한 데이터를 지정할 수 있으므로 불필요한 데이터 전송을 피할 수 있습니다.
확장성: GraphQL은 클라이언트와 서버에 높은 수준의 유연성을 제공하므로 새로운 필드나 작업을 쉽게 추가할 수 있습니다.
성능: GraphQL을 사용하면 클라이언트가 필요한 데이터를 지정할 수 있으므로 과도한 데이터 가져오기가 방지됩니다.

Spring Boot 및 GraphQL

Spring Boot는 Java 기반 웹 애플리케이션을 구축하기 위한 Java 프레임워크입니다. 자동 구성, 신속한 개발 등 유용한 기능을 많이 제공합니다. 기존 Java 웹 개발과 비교하여 Spring Boot는 개발 프로세스를 더욱 즐겁고 효율적으로 만들 수 있습니다.

이 기사에서는 Spring Boot와 GraphQL을 사용하여 기본 API 및 쿼리 시스템을 구축하겠습니다. 시작하기 전에 다음 구성 요소를 알아야 합니다.

Spring Boot: Java 기반 웹 애플리케이션을 구축하는 데 사용됩니다.
GraphQL Java: Java의 GraphQL 구현입니다.
Spring Boot Starter Data JPA: Spring Boot와 JPA(Java Persistence API)를 통합하는 데 사용됩니다.
H2 데이터베이스: 로컬 개발 및 테스트를 위한 인메모리 데이터베이스입니다.

API 및 쿼리 시스템 구축

먼저 Spring Boot 애플리케이션을 생성해야 합니다. Spring 초기화를 사용하여 Spring Boot 애플리케이션을 빠르게 생성할 수 있습니다. Spring Boot 애플리케이션을 생성하는 단계는 다음과 같습니다.

Spring Initializr 웹 사이트를 엽니다.
Spring Boot 버전을 선택하세요.
Maven이나 Gradle 등 선호하는 빌드 도구를 선택할 수 있습니다.
필수 종속성을 추가하세요. 이 기사에서는 "Spring Web", "GraphQL Java Tools", "GraphQL Java Spring Boot Starter", "Spring Boot Starter Data JPA" 및 "H2 Database"가 필요합니다.
"생성" 버튼을 클릭하면 기본 Spring Boot 애플리케이션 구조가 다운로드됩니다.

Creating a GraphQL Schema

GraphQL 스키마를 만들기 전에 API에서 수행해야 할 작업에 대해 생각해 보겠습니다. 저자, 도서, 저자-도서 관계의 세 가지 유형으로 API를 작성하겠습니다. 다음은 API 작업입니다.

작성자 목록 가져오기: 작성자 목록을 반환합니다.
ID로 저자 가져오기: 저자 ID로 저자 세부 정보를 반환합니다.
도서 목록 가져오기: 도서 목록으로 돌아갑니다.
ID로 책 가져오기: 도서 ID로 책 세부정보를 반환합니다.
저자-도서 관계 목록 가져오기: 저자-도서 관계 목록을 반환합니다.
저자 ID로 관련 도서 가져오기: 저자 ID별로 해당 저자의 모든 도서 세부정보를 반환합니다.

다음 단계는 GraphQL 스키마를 생성하는 것입니다. 스키마는 API에서 수행할 수 있는 작업을 정의합니다. 이 기사에서는 GraphQL Java 도구를 사용하여 스키마를 생성합니다. GraphQL 스키마를 생성하는 단계는 다음과 같습니다.

src/main/resources 폴더에 "schema.graphqls"라는 파일을 생성하고 다음 코드를 추가합니다.

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

로그인 후 복사

이 스키마는 작성자, 책의 세 가지 유형을 정의합니다. 그리고 관계. 또한 저자 목록 가져오기, ID로 저자 가져오기, 도서 목록 가져오기, ID로 도서 가져오기, 관계 목록 가져오기, 저자 ID로 관련 도서 가져오기 등 6가지 작업을 정의합니다.

프로젝트에서 GraphQL 서비스를 생성하고 Schema.graphqls 파일을 서비스에 로드합니다. 다음 코드를 사용하여 src/main/java/com.example.demo 폴더에 "GraphQLProvider"라는 새 클래스를 생성합니다.

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

로그인 후 복사

이 클래스는 GraphQL 서비스를 생성하고 해당 서비스에 Schema.graphqls 파일을 로드합니다. 가져오기 도구가 정의되어 있습니다. 데이터 가져오기 프로그램은 데이터를 가져와서 GraphQL 작업 결과로 채우는 역할을 담당합니다.

JPA 엔터티 및 저장소 생성

이제 엔터티를 생성하고 데이터베이스에 매핑해야 합니다. 이 기사에서는 Author, Book 및 Relationship 엔터티를 생성하고 JPA를 사용하여 H2 데이터베이스에 매핑합니다.

다음 코드가 포함된 src/main/java/com.example.demo.repository 패키지에 "AuthorRepository"라는 새 인터페이스를 만듭니다.

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

로그인 후 복사

위 방법에 따라 BookRepository 및 RelationshipRepository를 만듭니다.
src/main/java/com.example.demo.entity 패키지에서 엔터티와 관계를 생성합니다. 다음은 Author 엔터티에 대한 샘플 코드입니다.

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

로그인 후 복사

위의 예에서는 Lombok @Data 주석의 "id" 및 "name" 필드를 사용하여 Author라는 Java 엔터티를 만들었습니다.

책과 관계를 입력하세요.

데이터 채우기

이제 H2 콘솔을 사용하거나 Java 코드를 작성하여 데이터를 채울 수 있습니다.

H2 콘솔을 사용하여 데이터 채우기:

在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应用程序的理想选择。

위 내용은 Spring Boot 및 GraphQL을 사용하여 API 및 쿼리 시스템 구축의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!