Spring GraphQL — REST 대안으로 GraphQL을 스프링에서 사용하는 방법

# REST: GET /api/articles/1 → 모든 필드 반환
# GraphQL: 필요한 필드만 요청
query {
  article(id: 1) {
    title
    author {
      name
    }
    comments {
      content
    }
  }
}

// build.gradle
implementation 'org.springframework.boot:spring-boot-starter-graphql'
implementation 'org.springframework.boot:spring-boot-starter-web'

# application.yml
spring:
  graphql:
    graphiql:
      enabled: true    # GraphiQL UI 활성화 (개발용)
    schema:
      locations: classpath:graphql/  # 스키마 파일 위치

# src/main/resources/graphql/schema.graphqls

type Query {
    article(id: ID!): Article
    articles(page: Int = 0, size: Int = 10): ArticlePage!
    searchArticles(keyword: String!): [Article!]!
}

type Mutation {
    createArticle(input: CreateArticleInput!): Article!
    updateArticle(id: ID!, input: UpdateArticleInput!): Article!
    deleteArticle(id: ID!): Boolean!
}

type Article {
    id: ID!
    title: String!
    content: String!
    author: Author!
    comments: [Comment!]!
    createdAt: String!
}

type Author {
    id: ID!
    name: String!
    email: String!
    articles: [Article!]!
}

type Comment {
    id: ID!
    content: String!
    author: Author!
    createdAt: String!
}

type ArticlePage {
    content: [Article!]!
    totalElements: Int!
    totalPages: Int!
}

input CreateArticleInput {
    title: String!
    content: String!
    authorId: ID!
}

input UpdateArticleInput {
    title: String
    content: String
}

@Controller
@RequiredArgsConstructor
public class ArticleController {

    private final ArticleService articleService;

    @QueryMapping
    public Article article(@Argument Long id) {
        return articleService.findById(id);
    }

    @QueryMapping
    public ArticlePage articles(
            @Argument int page, @Argument int size) {
        return articleService.findAll(PageRequest.of(page, size));
    }

    @QueryMapping
    public List<Article> searchArticles(@Argument String keyword) {
        return articleService.search(keyword);
    }
}

@Controller
@RequiredArgsConstructor
public class ArticleMutationController {

    private final ArticleService articleService;

    @MutationMapping
    public Article createArticle(
            @Argument CreateArticleInput input) {
        return articleService.create(input);
    }

    @MutationMapping
    public Article updateArticle(
            @Argument Long id,
            @Argument UpdateArticleInput input) {
        return articleService.update(id, input);
    }

    @MutationMapping
    public boolean deleteArticle(@Argument Long id) {
        articleService.delete(id);
        return true;
    }
}

@Controller
@RequiredArgsConstructor
public class ArticleSchemaController {

    private final AuthorService authorService;
    private final CommentService commentService;

    // Article.author 필드를 해결
    @SchemaMapping(typeName = "Article")
    public Author author(Article article) {
        return authorService.findById(article.getAuthorId());
    }

    // Article.comments 필드를 해결
    @SchemaMapping(typeName = "Article")
    public List<Comment> comments(Article article) {
        return commentService.findByArticleId(article.getId());
    }
}

@Configuration
public class DataLoaderConfig {

    @Bean
    public BatchLoaderRegistry batchLoaderRegistry(
            AuthorService authorService) {
        BatchLoaderRegistry registry = new BatchLoaderRegistry();

        registry.forTypePair(Long.class, Author.class)
            .registerMappedBatchLoader((authorIds, env) -> {
                // 한 번의 쿼리로 모든 작성자 조회
                Map<Long, Author> authors =
                    authorService.findByIds(authorIds);
                return Mono.just(authors);
            });

        return registry;
    }
}

@Controller
public class ArticleSchemaController {

    @SchemaMapping(typeName = "Article")
    public CompletableFuture<Author> author(
            Article article, DataLoader<Long, Author> authorDataLoader) {
        // 개별 호출이 아닌 배치로 모아서 처리
        return authorDataLoader.load(article.getAuthorId());
    }
}

// Before (N+1):
SELECT * FROM authors WHERE id = 1;
SELECT * FROM authors WHERE id = 2;
...
SELECT * FROM authors WHERE id = 10;

// After (DataLoader):
SELECT * FROM authors WHERE id IN (1, 2, ..., 10);  // 1번의 쿼리

@Controller
@RequiredArgsConstructor
public class SecureArticleController {

    @QueryMapping
    public Article article(@Argument Long id) {
        return articleService.findById(id);  // 모두 접근 가능
    }

    @MutationMapping
    @PreAuthorize("hasRole('EDITOR')")
    public Article createArticle(@Argument CreateArticleInput input) {
        return articleService.create(input);
    }

    @MutationMapping
    @PreAuthorize("hasRole('ADMIN')")
    public boolean deleteArticle(@Argument Long id) {
        articleService.delete(id);
        return true;
    }

    // 현재 사용자의 데이터만 반환
    @QueryMapping
    @PreAuthorize("isAuthenticated()")
    public List<Article> myArticles(
            @AuthenticationPrincipal UserDetails user) {
        return articleService.findByAuthorEmail(user.getUsername());
    }
}

@Controller
public class ArticleController {

    @QueryMapping
    public Article article(@Argument Long id) {
        return articleService.findById(id);
        // 예외 발생 시 GraphQL 에러 응답으로 변환
    }
}

// 커스텀 에러 처리
@Component
public class CustomGraphQlExceptionHandler
        implements DataFetcherExceptionResolver {

    @Override
    public Mono<List<GraphQLError>> resolveException(
            Throwable exception, DataFetchingEnvironment env) {

        if (exception instanceof NotFoundException) {
            GraphQLError error = GraphqlErrorBuilder.newError(env)
                .message(exception.getMessage())
                .errorType(ErrorType.NOT_FOUND)
                .build();
            return Mono.just(List.of(error));
        }

        return Mono.empty();  // 기본 처리에 위임
    }
}