GraphQL Federation в Spring Boot и создание API с помощью Apollo

                ┌─────────────────┐
                │   Apollo     │
                │   Gateway    │
                └───────┬───────┘
                        │ Routes queries
            ┌───────────┼──────────────┐
            │           │              │
┌──────────▼─────┐ ┌────▼───────────┐ ┌─────▼─────────┐
│ User Service  │ │ Order Service  │ │ Product      │
│ (Spring Boot) │ │ (Spring Boot)  │ │ Service      │
└───────────────┘ └────────────────┘ └───────────────┘

@Component
public class UserDataLoader {
    private final BatchLoader<String, User> userBatchLoader = ids -> 
        CompletableFuture.supplyAsync(() -> userService.findAllByIds(ids));
    
    private final DataLoader<String, User> dataLoader = 
        DataLoader.newDataLoader(userBatchLoader);
    
    public CompletableFuture<User> load(String id) {
        return dataLoader.load(id);
    }
}

@SchemaMapping
public Float totalWithDiscount(Order order, @SchemaMapping.Context User user) {
    float discount = user.isVip() ? 0.1f : 0.0f;
    return order.getTotal() * (1 - discount);
}

// Настройка трассировки запросов
GatewayConfig config = GatewayConfig.builder()
    .tracer(openTracingTracer)
    .build();

// Резолвер, обращающийся к REST API
@SchemaMapping
public CompletableFuture<List<Product>> products(Category category) {
    return restTemplate
        .getForEntity("/products?category=" + category.getId(), ProductList.class)
        .thenApply(response -> response.getBody().getItems());
}

spring.graphql.path=/graphql
spring.graphql.graphiql.enabled=true
server.port=8081

@Node // Аннотация для поддержки федерации
public class User {
    @Id
    private String id;
    private String username;
    private String email;
    
    // Геттеры и сеттеры
}

@Controller
public class UserController {
 
    private final UserRepository userRepository;
    
    public UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    @QueryMapping
    public User user(@Argument String id) {
        return userRepository.findById(id).orElse(null);
    }
    
    @QueryMapping
    public List<User> users() {
        return userRepository.findAll();
    }
    
    // Ключевой метод для федерации!
    @SchemaMapping(typeName = "__Federation")
    public User findUserById(Map<String, Object> representations) {
        String id = (String) representations.get("id");
        return userRepository.findById(id).orElse(null);
    }
}

@Controller
public class OrderController {
 
    private final OrderRepository orderRepository;
    private final UserClient userClient; // REST-клиент для сервиса пользователей
    
    // Конструктор...
    
    @QueryMapping
    public Order order(@Argument String id) {
        return orderRepository.findById(id).orElse(null);
    }
    
    @QueryMapping
    public List<Order> orders() {
        return orderRepository.findAll();
    }
    
    // Резолвер для поля buyer
    @SchemaMapping
    public User buyer(Order order) {
        // Делаем запрос к сервису пользователей
        return userClient.getUser(order.getBuyerId());
    }
    
    // Резолвер для поля orders в User
    @SchemaMapping(typeName = "User")
    public List<Order> orders(User user) {
        return orderRepository.findByBuyerId(user.getId());
    }
    
    // Метод для федеративного протокола
    @SchemaMapping(typeName = "__Federation")
    public Order findOrderById(Map<String, Object> representations) {
        String id = (String) representations.get("id");
        return orderRepository.findById(id).orElse(null);
    }
}

@Component
public class UserClient {
    
    private final RestTemplate restTemplate;
    
    public UserClient(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    public User getUser(String id) {
        return restTemplate.getForObject("/api/users/{id}", User.class, id);
    }
}

@Configuration
public class GraphQLConfig {
    
    @Bean
    public ServletRegistrationBean<HttpServlet> graphQLServlet(GraphQL graphQL) {
        ServletRegistrationBean<HttpServlet> servlet = new ServletRegistrationBean<>(
            new GraphQLHttpServlet() {
                @Override
                protected GraphQL getGraphQL() {
                    return graphQL;
                }
                
                @Override
                protected GraphQLContext createContext(
                    HttpServletRequest request, 
                    HttpServletResponse response
                ) {
                    // Извлекаем JWT токен из заголовка
                    String token = request.getHeader("Authorization");
                    
                    // Создаём контекст с информацией о пользователе
                    return new GraphQLContext(request, response, token);
                }
            },
            "/graphql"
        );
        return servlet;
    }
}

@QueryMapping
public User user(@Argument String id, @ContextValue String token) {
    // Проверяем права доступа на основе токена
    if (!authService.canAccessUser(token, id)) {
        throw new AccessDeniedException("Не авторизован для доступа к пользователю");
    }
    
    return userRepository.findById(id).orElse(null);
}

@Component
public class AuthDirectiveWiring implements SchemaDirectiveWiring {
    
    @Override
    public GraphQLFieldDefinition onField(SchemaDirectiveWiringEnvironment<GraphQLFieldDefinition> env) {
        GraphQLFieldDefinition field = env.getElement();
        GraphQLFieldsContainer parentType = env.getFieldsContainer();
        
        // Получаем ресурчер поля
        DataFetcher<?> originalFetcher = env.getCodeRegistry().getDataFetcher(parentType, field);
        
        // Создаём обёртку с проверкой авторизации
        DataFetcher<?> authFetcher = dataFetchingEnvironment -> {
            Map<String, Object> args = dataFetchingEnvironment.getArguments();
            GraphQLContext context = dataFetchingEnvironment.getContext();
            
            // Проверяем права на основе токена
            if (!authService.isAuthorized(context.getToken(), role)) {
                throw new AccessDeniedException("Не авторизован");
            }
            
            // Если авторизован, выполняем исходный резолвер
            return originalFetcher.get(dataFetchingEnvironment);
        };
        
        // Регистрируем новый резолвер
        env.getCodeRegistry().dataFetcher(parentType, field, authFetcher);
        
        return field;
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/graphql").permitAll() // Публичный доступ к graphql
                .anyRequest().authenticated()
            .and()
            .oauth2ResourceServer() // Настройка JWT валидации
                .jwt();
    }
}

FROM node:14-alpine
 
WORKDIR /app
 
COPY package*.json ./
RUN npm install
 
COPY . .
 
EXPOSE 4000
 
CMD ["node", "gateway.js"]

// Плохо - N+1 запросов к сервису пользователей
@SchemaMapping
public User buyer(Order order) {
    return userClient.getUser(order.getBuyerId()); // Отдельный запрос для каждого заказа
}

@Component
public class UserDataLoader {
    private final UserClient userClient;
    
    public UserDataLoader(UserClient userClient) {
        this.userClient = userClient;
    }
    
    private final BatchLoader<String, User> batchLoader = ids -> 
        CompletableFuture.supplyAsync(() -> {
            // Один запрос вместо N запросов
            return userClient.getUsersByIds(new ArrayList<>(ids));
        });
    
    private final DataLoader<String, User> dataLoader = 
        DataLoader.newDataLoader(batchLoader);
    
    public CompletableFuture<User> load(String id) {
        return dataLoader.load(id);
    }
}

@SchemaMapping
public CompletableFuture<User> buyer(Order order) {
    return userDataLoader.load(order.getBuyerId());
}

@Configuration
@EnableCaching
public class CachingConfig {
    
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager("users", "orders");
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .maximumSize(1000));
        return cacheManager;
    }
}

@Cacheable(value = "users", key = "#id")
public User findUserById(String id) {
    return userRepository.findById(id).orElse(null);
}

@Service
public class UserService {
    
    private final UserRepository repository;
    private final ApplicationEventPublisher eventPublisher;
    
    // Конструктор...
    
    @CachePut(value = "users", key = "#user.id")
    public User updateUser(User user) {
        User updated = repository.save(user);
        // Публикуем событие об изменении
        eventPublisher.publishEvent(new UserUpdatedEvent(updated));
        return updated;
    }
}

@Component
public class UserCacheEvictListener {
  
  private final CacheManager cacheManager;
  private final OrderClient orderClient;
  
  // Конструктор...
  
  @EventListener
  public void handleUserUpdated(UserUpdatedEvent event) {
      // Инвалидируем локальный кэш
      cacheManager.getCache("users").evict(event.getUser().getId());
      
      // Уведомляем другие сервисы о необходимости обновить данные
      orderClient.invalidateUserCache(event.getUser().getId());
  }
}

@Bean
public GraphQLQueryInstrumentation apolloTracing() {
    return new ApolloTracingInstrumentation();
}

@Configuration
public class MetricsConfig {
    @Bean
    public GraphQLQueryInstrumentation metricsInstrumentation(MeterRegistry registry) {
        return new GraphQLQueryInstrumentation() {
            @Override
            public InstrumentationContext<ExecutionResult> beginExecution(InstrumentationExecutionParameters parameters) {
                Timer.Sample sample = Timer.start(registry);
                return new SimpleInstrumentationContext<>() {
                    @Override
                    public void onCompleted(ExecutionResult result, Throwable t) {
                        sample.stop(registry.timer("graphql.query", 
                          "operation", parameters.getOperation()));
                    }
                };
            }
        };
    }
}

@Bean
public Filter distributedTraceFilter(Tracer tracer) {
    return (request, response, chain) -> {
        Span span = tracer.buildSpan("graphql-request").start();
        try (Scope scope = tracer.scopeManager().activate(span)) {
            chain.doFilter(request, response);
        } finally {
            span.finish();
        }
    };
}

// В Gatling-сценарии
http("GraphQL Query")
    .post("/graphql")
    .header("Content-Type", "application/json")
    .body(StringBody("""
        {
            "query": "{ user(id: \"123\") { name orders { id products { name price } } } }"
        }
    """))
    .check(status().is(200))

@QueryMapping // Оптимизировано для чтения
public User user(@Argument String id) {
    return userReadRepository.findById(id).orElse(null);
}
 
@MutationMapping // Оптимизировано для записи
public User updateUser(@Argument UserInput input) {
    return userWriteService.update(input);
}

server.tomcat.max-threads=200
server.tomcat.min-spare-threads=20
server.connection-timeout=5000

@QueryMapping
public Mono<User> user(@Argument String id) {
    return userRepository.findById(id);
}