Какие знаешь виды интеграций?

Виды интеграций между системами

Интеграция — это процесс соединения различных систем, приложений и сервисов для совместной работы. Существует несколько архитектурных подходов к интеграции.

1. API-based интеграция (REST, SOAP)

REST API (Synchronous)

REST — самый простой и популярный способ интеграции через HTTP.

// Сервис A — разработчик API
@RestController
@RequestMapping("/api/v1/orders")
public class OrderController {
    @Autowired
    private OrderService orderService;
    
    @GetMapping("/{id}")
    public ResponseEntity<Order> getOrder(@PathVariable Long id) {
        Order order = orderService.findById(id);
        return ResponseEntity.ok(order);
    }
    
    @PostMapping
    public ResponseEntity<Order> createOrder(@RequestBody CreateOrderRequest request) {
        Order order = orderService.create(request);
        return ResponseEntity.status(201).body(order);
    }
}

// Сервис B — потребитель API
@Service
public class PaymentService {
    @Autowired
    private RestTemplate restTemplate;
    
    public void processPayment(Long orderId) {
        String url = "http://order-service:8080/api/v1/orders/" + orderId;
        try {
            Order order = restTemplate.getForObject(url, Order.class);
            System.out.println("Order received: " + order.getId());
        } catch (RestClientException e) {
            // Обработка ошибки
            System.out.println("Failed to get order");
        }
    }
}

// application.properties
restclient.connectTimeout=5000
restclient.readTimeout=10000

Характеристики:

• Synchronous — клиент ждёт ответ
• HTTP based — простой protocol
• Loose coupling — через URL
• Легко тестировать с mock servers

Минусы:

• Если сервис недоступен — ошибка у клиента
• Требует retry логика
• Может быть bottleneck при high load

SOAP (Simple Object Access Protocol)

// Генерируется из WSDL
@WebService
public class UserWebService {
    @WebMethod
    public User getUser(@WebParam(name = "id") Long id) {
        return userService.findById(id);
    }
}

// Клиент
UserWebService port = service.getUserWebServicePort();
User user = port.getUser(1L);

Когда используется:

• Enterprise интеграция
• Требуется XML
• Legacy системы
• Безопасность важна (WS-Security)

2. Message Queue интеграция (Asynchronous)

Message-driven (Event-based)

// Producer
@Service
public class OrderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void createOrder(OrderRequest request) {
        Order order = new Order(request);
        orderRepository.save(order);
        
        // Отправить событие
        rabbitTemplate.convertAndSend("order-exchange", "order.created", order);
    }
}

// Consumer 1 — Payment Service
@Component
public class PaymentProcessor {
    @RabbitListener(queues = "payment-queue")
    public void processPayment(Order order) {
        System.out.println("Processing payment for order: " + order.getId());
        // Обработка платежа
    }
}

// Consumer 2 — Notification Service
@Component
public class NotificationService {
    @RabbitListener(queues = "notification-queue")
    public void sendNotification(Order order) {
        System.out.println("Sending notification for order: " + order.getId());
        // Отправка уведомления
    }
}

Преимущества:

• Decoupling — producer не знает про consumers
• Асинхронность — системы не блокируют друг друга
• Scalability — легко добавить новый consumer
• Reliability — сообщения сохраняются

Минусы:

• Сложнее отловить ошибки
• Нужно гарантировать доставку сообщения
• Eventual consistency

3. File-based интеграция

// Экспорт
@Service
public class DataExporter {
    public void exportToCSV() throws IOException {
        List<User> users = userRepository.findAll();
        Path path = Paths.get("users.csv");
        
        try (CSVWriter writer = new CSVWriter(Files.newBufferedWriter(path))) {
            writer.writeNext(new String[]{"id", "name", "email"});
            for (User user : users) {
                writer.writeNext(new String[]{
                    user.getId().toString(),
                    user.getName(),
                    user.getEmail()
                });
            }
        }
    }
}

// Импорт
@Service
public class DataImporter {
    public void importFromCSV(String filename) throws IOException {
        try (CSVReader reader = new CSVReader(Files.newBufferedReader(Paths.get(filename)))) {
            String[] line;
            reader.readNext(); // Skip header
            while ((line = reader.readNext()) != null) {
                User user = new User();
                user.setId(Long.parseLong(line[0]));
                user.setName(line[1]);
                user.setEmail(line[2]);
                userRepository.save(user);
            }
        }
    }
}

Используется для:

• Batch обработка
• EDI (Electronic Data Interchange)
• Legacy системы
• Scheduled data transfers

4. Database-centric интеграция

// Две приложения с доступом к одной БД
@Entity
@Table(name = "shared_orders")
public class Order {
    @Id
    private Long id;
    private String status;  // Оба приложения могут изменять
}

// Приложение 1
@Service
public class OrderManagementService {
    @Autowired
    private OrderRepository orderRepository;
    
    public void updateOrderStatus(Long id, String status) {
        Order order = orderRepository.findById(id).orElseThrow();
        order.setStatus(status);
        orderRepository.save(order);
    }
}

// Приложение 2
@Service
public class PaymentService {
    @Autowired
    private OrderRepository orderRepository;
    
    public void checkAndProcess() {
        List<Order> pendingOrders = orderRepository.findByStatus("pending");
        for (Order order : pendingOrders) {
            // Обработка платежа
        }
    }
}

Минусы:

• Высокая связанность между приложениями
• Сложно масштабировать
• Конфликты при одновременном доступе
• Трудно развивать независимо

5. RPC-based интеграция (gRPC)

// Proto service
service UserService {
    rpc GetUser(UserRequest) returns (UserResponse) {}
    rpc ListUsers(Empty) returns (stream UserResponse) {}
}

// Server
@GrpcService
public class UserService extends UserServiceGrpc.UserServiceImplBase {
    @Override
    public void getUser(UserRequest request, StreamObserver<UserResponse> responseObserver) {
        User user = userRepository.findById(request.getId()).orElseThrow();
        UserResponse response = UserResponse.newBuilder()
                .setId(user.getId())
                .setName(user.getName())
                .build();
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

// Client
UserServiceGrpc.UserServiceBlockingStub stub = UserServiceGrpc.newBlockingStub(channel);
UserResponse user = stub.getUser(UserRequest.newBuilder().setId(1).build());

Преимущества:

• Очень быстро (HTTP/2, protobuf)
• Типизированный контракт
• Bidi streaming поддержка

6. Webhook интеграция (Push-based)

// System A — отправляет webhook
@Service
public class WebhookSender {
    @Autowired
    private RestTemplate restTemplate;
    
    public void notifyOrderCreated(Order order) {
        Map<String, Object> payload = Map.of(
            "event", "order.created",
            "order_id", order.getId(),
            "amount", order.getAmount(),
            "timestamp", LocalDateTime.now()
        );
        
        // Отправить на зарегистрированный webhook URL
        String webhookUrl = "https://system-b.com/webhooks/orders";
        try {
            restTemplate.postForObject(webhookUrl, payload, String.class);
        } catch (RestClientException e) {
            // Retry
            retryWebhook(webhookUrl, payload);
        }
    }
}

// System B — получает webhook
@RestController
@RequestMapping("/webhooks")
public class WebhookController {
    @PostMapping("/orders")
    public ResponseEntity<Void> handleOrderEvent(@RequestBody OrderEvent event) {
        System.out.println("Received order event: " + event.getOrderId());
        // Обработка события
        return ResponseEntity.ok().build();
    }
}

Особенности:

• System A push уведомления
• System B реактивна
• Real-time обновления
• Требует retry логика

7. ETL интеграция (Extract, Transform, Load)

// Spring Batch для ETL
@Configuration
public class EtlJobConfiguration {
    @Bean
    public Job etlJob(JobBuilderFactory jobBuilderFactory,
                     StepBuilderFactory stepBuilderFactory) {
        return jobBuilderFactory.get("etlJob")
                .start(step1(stepBuilderFactory))
                .build();
    }
    
    @Bean
    public Step step1(StepBuilderFactory stepBuilderFactory) {
        return stepBuilderFactory.get("step1")
                .<User, User>chunk(10)
                .reader(reader())
                .processor(processor())
                .writer(writer())
                .build();
    }
}

Используется для:

• Data warehouse
• Batch migrations
• Big data processing
• Scheduled transformations

Сравнение интеграций

Best Practices

• REST для синхронных операций (быстрый ответ)
• Message Queue для асинхронных (высокая нагрузка)
• API Gateway перед всеми REST сервисами
• Retry и Circuit Breaker для reliability
• Versioning API для backward compatibility
• Event sourcing для аудита и восстановления
• Idempotency — обработать дважды безопасно