В чем разница между gRPC и HTTP?

Разница между gRPC и HTTP

gRPC и HTTP — это два разных подхода к построению сетевых сервисов. Вот основные отличия:

HTTP (REST)

HTTP — это текстовый протокол, использующийся в веб-сервисах.

// Классический REST API на HTTP
@RestController
@RequestMapping("/api/users")
public class UserController {
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
    
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
}

// Запрос (JSON):
// GET /api/users/1 HTTP/1.1
// Host: example.com
// Content-Type: application/json

// Ответ (JSON):
// {
//   "id": 1,
//   "name": "John",
//   "email": "john@example.com"
// }

gRPC

gRPC (Google Remote Procedure Call) — это современный высокопроизводительный RPC фреймворк от Google.

// Определение сервиса (protobuf)
syntax = "proto3";

package user;

service UserService {
    rpc GetUser(UserRequest) returns (User);
    rpc CreateUser(User) returns (User);
    rpc ListUsers(Empty) returns (stream User);
}

message UserRequest {
    int64 id = 1;
}

message User {
    int64 id = 1;
    string name = 2;
    string email = 3;
}

// Java реализация gRPC сервиса
public class UserServiceImpl extends UserServiceGrpc.UserServiceImplBase {
    @Override
    public void getUser(UserRequest request, StreamObserver<User> responseObserver) {
        User user = userService.findById(request.getId());
        responseObserver.onNext(user);
        responseObserver.onCompleted();
    }
    
    @Override
    public void listUsers(Empty request, StreamObserver<User> responseObserver) {
        userService.findAll().forEach(responseObserver::onNext);
        responseObserver.onCompleted();
    }
}

Сравнительная таблица

Основные отличия

1. Формат данных

// HTTP/REST: JSON (текст)
{
  "id": 1,
  "name": "John",
  "email": "john@example.com"
}
// Размер: примерно 60-80 байт

// gRPC: Protocol Buffers (binary)
// Размер: примерно 20-30 байт (3x меньше!)

2. Производительность

// HTTP/REST:
// - Парсинг JSON (медленнее)
// - HTTP/1.1 требует новое соединение на каждый запрос
// - Больше overhead

// gRPC:
// - Бинарный формат (быстрее парсить)
// - HTTP/2 мультиплексинг (один TCP для многих запросов)
// - Меньше overhead

3. Потоковая передача данных

// gRPC поддерживает потоки данных
service StreamService {
    // Сервер отправляет поток
    rpc DownloadData(Request) returns (stream DataChunk);
    
    // Клиент отправляет поток
    rpc UploadData(stream DataChunk) returns (Response);
    
    // Двухсторонний поток
    rpc BidirectionalStream(stream Message) returns (stream Message);
}

// Практический пример gRPC потока
public void downloadData(Request request, StreamObserver<DataChunk> observer) {
    List<DataChunk> chunks = service.generateLargeData();
    
    for (DataChunk chunk : chunks) {
        observer.onNext(chunk);  // Отправить по частям
    }
    observer.onCompleted();
}

4. Типизация

// HTTP/REST: не типизирован на уровне протокола
// Легко получить ошибку типа в JSON
GET /api/users/not-a-number  // Не гарантирует ошибку

// gRPC: строго типизирован через protobuf
// Компилятор генерирует типизированный код
rpc GetUser(UserRequest) returns (User);  // Типы явные

Когда использовать что

Используй HTTP/REST когда:

• Нужна поддержка браузеров
• Нужна простота и стандартность
• API будет использован третьей стороной
• Не критична высокая производительность
• Нужно кэширование на уровне HTTP

// Пример: публичный API
@RestController
@RequestMapping("/api/v1/products")
public class ProductController {
    @GetMapping("/{id}")
    public ResponseEntity<Product> getProduct(@PathVariable Long id) {
        return ResponseEntity.ok(productService.findById(id));
    }
}

Используй gRPC когда:

• Нужна высокая производительность (microsservices)
• Много запросов (высокая нагрузка)
• Нужна потоковая передача данных
• Нужна двусторонняя коммуникация (WebSocket-like)
• Клиент и сервер под одним контролем

// Пример: микросервис для микросервиса
public class PaymentServiceImpl extends PaymentServiceGrpc.PaymentServiceImplBase {
    @Override
    public void processPayments(
        StreamObserver<PaymentRequest> requests,
        StreamObserver<PaymentResponse> responses) {
        
        // Обработка потока платежей
        // Двухсторонний поток данных
    }
}

Практический пример: HTTP vs gRPC

// HTTP/REST клиент
RestTemplate restTemplate = new RestTemplate();
User user = restTemplate.getForObject(
    "http://user-service/api/users/1", 
    User.class
);

// gRPC клиент
ManagedChannel channel = ManagedChannelBuilder
    .forAddress("user-service", 50051)
    .usePlaintext()
    .build();

UserServiceGrpc.UserServiceBlockingStub stub = 
    UserServiceGrpc.newBlockingStub(channel);

User user = stub.getUser(UserRequest.newBuilder().setId(1).build());

Итог

• HTTP: универсален, прост, медленнее, для веб-приложений и публичных API
• gRPC: производителен, требует protobuf, идеален для микросервисов и потоков
• Гибридный подход: использование gRPC для сервиса-сервиса связи и HTTP для браузера через API Gateway