Как реализовать актуализацию информации?

Актуализация информации: методы и практики

Актуализация информации — это проблема синхронизации данных в распределённых системах, когда нужно убедиться, что различные части системы имеют самую свежую информацию.

1. Что такое актуализация?

Ситуация: у нас есть:

• Внешний источник данных (API, БД, кэш)
• Локальное хранилище данных (БД приложения, кэш)
• Нужно гарантировать, что локальные данные актуальны

2. Pull-based подход: периодическое обновление

@Service
@RequiredArgsConstructor
public class ExchangeRateService {
    private final ExchangeRateRepository repository;
    private final ExternalExchangeRateClient client;
    private final CacheManager cacheManager;
    
    private static final long CACHE_TTL_MINUTES = 30;
    
    // Периодически обновляем курсы валют
    @Scheduled(fixedRate = 60000) // каждую минуту
    public void updateExchangeRates() {
        try {
            Map<String, BigDecimal> latestRates = client.getLatestRates();
            
            latestRates.forEach((currency, rate) -> {
                ExchangeRate existing = repository.findByCurrency(currency)
                    .orElse(new ExchangeRate());
                
                existing.setCurrency(currency);
                existing.setRate(rate);
                existing.setUpdatedAt(Instant.now(UTC));
                
                repository.save(existing);
            });
            
            // Инвалидируем кэш
            cacheManager.getCache("exchange_rates").clear();
            
            logger.info("Exchange rates updated successfully");
        } catch (Exception e) {
            logger.error("Failed to update exchange rates", e);
            // не прерываем работу если обновление не прошло
        }
    }
    
    @Cacheable(value = "exchange_rates", unless = "#result == null")
    public ExchangeRate getRate(String currency) {
        return repository.findByCurrency(currency)
            .orElseThrow(() -> new CurrencyNotFoundException(currency));
    }
}

3. Push-based подход: события и webhook

// Внешний сервис отправляет нам уведомление об изменении
@RestController
@RequestMapping("/api/v1/webhooks")
@RequiredArgsConstructor
public class WebhookController {
    private final ProductService productService;
    
    @PostMapping("/product-updated")
    public ResponseEntity<Void> onProductUpdated(@RequestBody ProductUpdatedEvent event) {
        // Внешняя система отправила нам уведомление об изменении
        productService.updateProduct(event.getProductId(), event.getData());
        return ResponseEntity.ok().build();
    }
}

@Service
@RequiredArgsConstructor
public class ProductService {
    private final ProductRepository repository;
    private final CacheManager cacheManager;
    
    public void updateProduct(Long productId, ProductData newData) {
        // Получаем из БД
        Product product = repository.findById(productId)
            .orElseThrow(() -> new ProductNotFoundException(productId));
        
        // Проверяем версию (optimistic locking)
        if (product.getVersion() >= newData.getVersion()) {
            logger.warn("Ignoring outdated event for product: {}", productId);
            return;
        }
        
        // Обновляем
        product.setName(newData.getName());
        product.setPrice(newData.getPrice());
        product.setUpdatedAt(Instant.now(UTC));
        product.setVersion(newData.getVersion());
        
        repository.save(product);
        
        // Инвалидируем кэш
        cacheManager.getCache("products").evictIfPresent(productId);
    }
}

4. Гибридный подход: polling с умной стратегией

@Service
@RequiredArgsConstructor
public class SmartSyncService {
    private final ExternalApiClient externalApi;
    private final DataRepository repository;
    private final SyncMetadataRepository syncMetadata;
    
    // Обновляем только если нужно
    public void smartSync() {
        List<DataItem> allItems = repository.findAll();
        
        for (DataItem item : allItems) {
            SyncMetadata meta = syncMetadata.findByItemId(item.getId())
                .orElse(new SyncMetadata(item.getId()));
            
            // Проверяем: нужно ли синхронизировать?
            if (shouldSync(meta)) {
                ExternalData external = externalApi.get(item.getExternalId());
                
                if (!item.equals(external)) {
                    item.update(external);
                    repository.save(item);
                }
                
                meta.setLastSyncAt(Instant.now(UTC));
                meta.setLastChecksum(calculateChecksum(external));
                syncMetadata.save(meta);
            }
        }
    }
    
    private boolean shouldSync(SyncMetadata meta) {
        // Не синхронизировать чаще чем раз в 5 минут
        Duration timeSinceLastSync = Duration.between(
            meta.getLastSyncAt(),
            Instant.now(UTC)
        );
        
        return timeSinceLastSync.toMinutes() >= 5;
    }
    
    private String calculateChecksum(ExternalData data) {
        return DigestUtils.md5Hex(data.toString());
    }
}

5. Версионирование: оптимистичная блокировка

@Entity
@Table(name = "products")
@Data
public class Product {
    @Id
    private Long id;
    
    private String name;
    private BigDecimal price;
    
    private Instant updatedAt;
    
    // Версия для контроля конфликтов обновления
    @Version
    private Long version;
}

@Service
@RequiredArgsConstructor
public class ProductService {
    private final ProductRepository repository;
    
    // JPA автоматически проверит версию перед сохранением
    public void updateProduct(Long id, String newName) {
        Product product = repository.findById(id)
            .orElseThrow(() -> new ProductNotFoundException(id));
        
        product.setName(newName);
        product.setUpdatedAt(Instant.now(UTC));
        
        try {
            repository.save(product);
        } catch (OptimisticLockingFailureException e) {
            // Версия изменилась — кто-то другой обновил
            throw new ProductModifiedException("Product was modified by another user", e);
        }
    }
}

6. ETag: кэширование с валидацией

@Service
@RequiredArgsConstructor
public class UserSyncService {
    private final ExternalUserClient externalApi;
    private final UserRepository repository;
    private final ETagCacheRepository etagCache;
    
    public User syncUser(Long userId) {
        // Получаем сохранённый ETag
        Optional<String> cachedETag = etagCache.findByUserId(userId)
            .map(ETagCache::getETag);
        
        // Запрашиваем с ETag (условный запрос)
        ExternalUserResponse response = externalApi.getUser(
            userId,
            cachedETag.orElse(null)
        );
        
        // Если 304 Not Modified — данные не изменились
        if (response.getStatus() == 304) {
            logger.info("User {} not modified", userId);
            return repository.findById(userId).orElse(null);
        }
        
        // Если 200 OK — есть новые данные
        User user = response.getBody();
        repository.save(user);
        
        // Сохраняем новый ETag
        String newETag = response.getETag();
        etagCache.save(new ETagCache(userId, newETag));
        
        return user;
    }
}

public class ExternalUserResponse {
    private int status; // 200 или 304
    private User body;
    private String etag;
}

7. Change Data Capture (CDC): реактивное обновление

// Слушаем события из БД или очереди
@Component
@RequiredArgsConstructor
public class ProductChangeListener {
    private final ProductService productService;
    private final KafkaTemplate<String, ProductChangeEvent> kafkaTemplate;
    
    @KafkaListener(topics = "product-changes")
    public void onProductChange(ProductChangeEvent event) {
        // Внешняя БД отправила событие об изменении
        switch (event.getChangeType()) {
            case CREATED:
                productService.createFromExternal(event.getData());
                break;
            case UPDATED:
                productService.updateFromExternal(event.getId(), event.getData());
                break;
            case DELETED:
                productService.deleteFromExternal(event.getId());
                break;
        }
    }
}

8. Практический пример: актуализация данных о пользователе

@Service
@RequiredArgsConstructor
public class UserDataSyncService {
    private final UserRepository userRepository;
    private final ExternalUserApi externalApi;
    private final CacheManager cacheManager;
    
    // Стратегия: lazy refresh + background update
    @Cacheable(value = "user", key = "#userId")
    public UserData getUser(Long userId) {
        UserData user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException(userId));
        
        // Проверяем: не устарели ли данные?
        if (isStale(user)) {
            refreshInBackground(userId);
        }
        
        return user;
    }
    
    private boolean isStale(UserData user) {
        Duration age = Duration.between(user.getUpdatedAt(), Instant.now(UTC));
        return age.toHours() >= 24; // обновляем если старше 24 часов
    }
    
    @Async
    public void refreshInBackground(Long userId) {
        try {
            ExternalUserInfo external = externalApi.getUser(userId);
            
            UserData user = userRepository.findById(userId).get();
            user.setName(external.getName());
            user.setEmail(external.getEmail());
            user.setUpdatedAt(Instant.now(UTC));
            
            userRepository.save(user);
            
            // Обновляем кэш
            cacheManager.getCache("user").put(userId, user);
            
            logger.info("User {} refreshed in background", userId);
        } catch (Exception e) {
            logger.warn("Failed to refresh user {}", userId, e);
            // silent fail, не прерываем работу
        }
    }
    
    // Явная инвалидация при изменении
    public void invalidateUserCache(Long userId) {
        cacheManager.getCache("user").evictIfPresent(userId);
    }
}

Сравнение подходов:

Best Practices:

1. Используй версионирование — @Version в JPA для оптимистичной блокировки
2. Кэшируй разумно — не гонись за идеальной свежестью
3. Вводи таймауты — не жди бесконечно
4. Логируй обновления — нужно отследить что произошло
5. Graceful degradation — если синхронизация упала, работать с устаревшими данными
6. Мониторь lag — как долго данные отстают от источника

Главное правило: идеальная актуальность данных стоит дорого, выбери подход в зависимости от требований бизнеса.