Системное мышление: как подходить к решению сложных программных проблем

public class OrderService {
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    
    public OrderResult processOrder(Order order) {
        // Вызываем оба сервиса последовательно
        InventoryResult inventory = inventoryService.checkAvailability(order);
        if (!inventory.isAvailable()) {
            return OrderResult.failed("Items not available");
        }
        
        PaymentResult payment = paymentService.processPayment(order);
        if (!payment.isSuccessful()) {
            // Упс, деньги не списались, но товары заблокированы
            return OrderResult.failed("Payment failed");
        }
        
        return OrderResult.success();
    }
}

public class AutoScaler {
    private final MetricsService metricsService;
    private final InstanceManager instanceManager;
    
    public void adjustCapacity() {
        double cpuLoad = metricsService.getAverageCpuLoad();
        
        if (cpuLoad > 0.7) { // Высокая нагрузка
            int newInstances = calculateRequiredInstances(cpuLoad);
            instanceManager.addInstances(newInstances);
            // Мы не учли, что добавление инстансов создаст дополнительную
            // нагрузку из-за синхронизации состояния!
        } else if (cpuLoad < 0.3) {
            instanceManager.removeUnderUtilizedInstances();
        }
    }
}

// Гибкий подход к определению границ системы
public class SystemBoundary<T> {
    private final Set<Component> includedComponents;
    
    // Фабричные методы для разных представлений системы
    public static SystemBoundary<MonitoringView> forMonitoring() {
        return new SystemBoundary<>(Set.of(
            Component.BACKEND_SERVICES,
            Component.DATABASES,
            Component.BROWSER_JAVASCRIPT,
            Component.MOBILE_CLIENTS
        ));
    }
    
    public static SystemBoundary<DevelopmentView> forDevelopment() {
        return new SystemBoundary<>(Set.of(
            Component.BACKEND_SERVICES,
            Component.DATABASES
        ));
    }
    
    // ...и так далее
}

graph TD
    A[Клиентское приложение] --> B[API Gateway]
    B --> C[Сервис аутентификации]
    B --> D[Сервис профилей]
    B --> E[Сервис заказов]
    E --> F[Сервис оплаты]
    E --> G[Сервис нотификаций]
    E --> H[Сервис аналитики]
    H --> I[Тупиковый сервис?]

public class InventoryService {
    private final DatabaseService primaryDb;
    private final LocalCacheService emergencyCache;
    
    public InventoryResult checkAvailability(String productId, int quantity) {
        try {
            return primaryDb.checkInventory(productId, quantity);
        } catch (DatabaseException e) {
            log.warn("Primary database failed, using emergency cache", e);
            // Деградация сервиса - используем локальный кэш
            return emergencyCache.checkInventoryLocally(productId, quantity);
            // В крайнем случае, разрешаем операцию и фиксируем для последующей синхронизации
        }
    }
}

| Сервис         | Auth | Orders | Catalog | Payment | Analytics |
|----------------|------|--------|---------|---------|-----------|
| Auth           | -    | Strong | Weak    | Medium  | None      |
| Orders         | Weak | -      | Strong  | Strong  | Medium    |
| Catalog        | None | Medium | -       | None    | Strong    |
| Payment        | Weak | Strong | None    | -       | Medium    |
| Analytics      | None | Medium | Medium  | Weak    | -         |
| Common Library | HIGH | HIGH   | HIGH    | HIGH    | HIGH      |

// Было: ресурс не освобождается при исключении
try {
    Connection conn = pool.getConnection();
    // работа с соединением
    conn.close(); // Это не выполнится при исключении!
} catch (Exception e) {
    log.error("Database error", e);
    // Нет закрытия соединения
}
 
// Стало: используем try-with-resources
try (Connection conn = pool.getConnection()) {
    // работа с соединением
    // conn автоматически закроется при любом исходе
} catch (Exception e) {
    log.error("Database error", e);
}

[ Идея ] -- 3 дня --> [ Согласование ] -- 10 дней --> [ Разработка ] -- 2 дня --> 
[ Ожидание ревью ] -- 5 дней --> [ Код-ревью ] -- 1 день --> 
[ Исправление замечаний ] -- 0.5 дня --> [ Тестирование ] -- 3 дня --> 
[ Исправление багов ] -- 0.5 дня --> [ Ожидание релиза ] -- 15 дней --> [ Релиз ]
 
Время добавления ценности: 7 дней (15.5%)
Время ожидания: 38 дней (84.5%)

// Без CQRS - одна модель для чтения и записи
public class UserRepository {
    public User findById(Long id) {
        // Запрос из основной базы
    }
    
    public void save(User user) {
        // Запись в ту же базу
    }
}
 
// С CQRS - разделение моделей
public class UserCommandRepository {
    public void save(User user) {
        // Запись в мастер-базу
        // Генерация события об изменении
    }
}
 
public class UserQueryRepository {
    public UserReadModel findById(Long id) {
        // Запрос из реплики или денормализованного хранилища
    }
}

// Антикоррупционный слой между техническим и финансовым контекстами
public class TaskFinancialAdapter {
    private final TechnicalTask technicalTask;
    
    public FinancialTask adaptToFinancial() {
        FinancialTask financial = new FinancialTask();
        financial.setTaskId(technicalTask.getId());
        financial.setEstimatedHours(convertComplexityToHours(technicalTask.getComplexity()));
        financial.setRate(determineRateByTaskType(technicalTask.getType()));
        // другие преобразования...
        return financial;
    }
    
    private double convertComplexityToHours(Complexity complexity) {
        // Преобразование технической сложности в часы
        switch (complexity) {
            case TRIVIAL: return 2.0;
            case EASY: return 4.0;
            case MEDIUM: return 8.0;
            case COMPLEX: return 16.0;
            default: return 8.0;
        }
    }
    
    // Другие методы адаптации...
}

// Было в монолите:
public class OrderService {
    public OrderResult createOrder(OrderRequest request) {
        // Вся логика в одном месте - валидация, обработка, сохранение
        return processOrderInternally(request);
    }
}
 
// Стало в микросервисах (упрощенно):
public class OrderService {
    private final CustomerClient customerClient;
    private final InventoryClient inventoryClient;
    private final PaymentClient paymentClient;
    private final ShippingClient shippingClient;
 
    public OrderResult createOrder(OrderRequest request) {
        // Десятки вызовов в другие сервисы
        CustomerInfo customer = customerClient.getCustomer(request.getCustomerId());
        boolean available = inventoryClient.checkAvailability(request.getItems());
        PaymentResult payment = paymentClient.processPayment(request.getPayment());
        ShippingResult shipping = shippingClient.calculateShipping(request.getAddress());
        // И так далее...
    }
}

// Прокси-слой в монолите
public class OrderFacade {
    private final LegacyOrderService legacyService;
    private final NewOrderServiceClient newServiceClient;
    private final FeatureFlagService featureFlags;
 
    public OrderResult createOrder(OrderRequest request) {
        if (featureFlags.isEnabled("use-new-order-service", request.getCustomerId())) {
            try {
                return newServiceClient.createOrder(request);
            } catch (Exception e) {
                log.error("New service failed, falling back to legacy", e);
                return legacyService.createOrder(request);
            }
        } else {
            return legacyService.createOrder(request);
        }
    }
}

public class OrderRepository {
    private final JdbcTemplate jdbcLegacy;
    private final OrderServiceClient newService;
    
    @Transactional
    public void save(Order order) {
        // Сохранение в старую БД
        jdbcLegacy.update("INSERT INTO orders...", order.getParams());
        
        // Дублирование записи в новый сервис
        try {
            newService.createOrder(convertToDto(order));
        } catch (Exception e) {
            // Логируем, но не блокируем основную транзакцию
            log.error("Failed to duplicate write to new service", e);
        }
    }
}

@Component
@C4Component(description = "Обрабатывает создание новых заказов",
             relationships = {
                 @C4Relationship(target = "PaymentService", description = "Инициирует оплату"),
                 @C4Relationship(target = "InventoryService", description = "Резервирует товары")
             })
public class OrderCreationProcessor {
    // Реализация
}

// Излишне оптимизированный код, который на практике не нужен
public class UserRepository {
private final ConcurrentHashMap<Integer, ConcurrentHashMap<String, User>> shardedUserCache;
private final int SHARD_COUNT = 256;
 
public UserRepository() {
    shardedUserCache = new ConcurrentHashMap<>(SHARD_COUNT);
    for (int i = 0; i < SHARD_COUNT; i++) {
        shardedUserCache.put(i, new ConcurrentHashMap<>());
    }
}
 
public User findById(String userId) {
    int shardKey = calculateShardKey(userId);
    return shardedUserCache.get(shardKey).get(userId);
}
 
private int calculateShardKey(String userId) {
    return Math.abs(userId.hashCode() % SHARD_COUNT);
}
}
 
// Более прагматичный вариант, который решает реальную проблему
public class SimpleUserRepository {
private final Map<String, User> userCache = new HashMap<>();
 
public User findById(String userId) {
    return userCache.get(userId);
}
}

// Туннельное зрение: микрооптимизация парсинга
public class OptimizedJsonParser {
// Сложная кастомная реализация с ручным парсингом байтов
// 200+ строк кода для ускорения на 30%
}
 
// Системное мышление: кеширование на уровень выше
public class CachedDataService {
private final JsonParser parser = new StandardJsonParser();
private final Cache<String, ParsedData> cache = CacheBuilder.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(5, TimeUnit.MINUTES)
    .build();
 
public ParsedData getData(String jsonString) {
    return cache.get(jsonString, () -> parser.parse(jsonString));
}
}

// До: монолитная команда - монолитный код
// Вся команда отвечает за всё, что приводит к размытой ответственности
public class UserService {
    // Методы, написанные разными людьми с разными подходами
    public User registerUser(UserRegisterRequest request) { ... }
    public User updateProfile(UpdateProfileRequest request) { ... }
    public void sendPasswordResetEmail(String email) { ... }
    public boolean validatePassword(String password) { ... }
    public UserPreferences loadPreferences(Long userId) { ... }
    // И еще 20+ методов для всего, что связано с пользователями
}
 
// После: разделение команды привело к естественному разделению кода
// Команда аутентификации
public class AuthService {
    public User registerUser(UserRegisterRequest request) { ... }
    public void sendPasswordResetEmail(String email) { ... }
    public boolean validatePassword(String password) { ... }
}
 
// Команда профилей
public class ProfileService {
    public User updateProfile(UpdateProfileRequest request) { ... }
    public UserPreferences loadPreferences(Long userId) { ... }
}

// Код с высокой когнитивной нагрузкой
public void processUserRequest(UserRequest request) {
    if (request.getType() == RequestType.REGISTRATION) {
        if (userExists(request.getUsername())) {
            if (request.isForceUpdate()) {
                if (hasAdminPermissions(request.getToken())) {
                    updateExistingUser(request);
                } else {
                    throw new PermissionDeniedException();
                }
            } else {
                throw new UserAlreadyExistsException();
            }
        } else {
            createNewUser(request);
        }
    } else if (request.getType() == RequestType.PASSWORD_RESET) {
        // Еще 20 строк вложенных условий
    }
}
 
// Тот же код с меньшей когнитивной нагрузкой
public void processUserRequest(UserRequest request) {
    switch (request.getType()) {
        case REGISTRATION:
            processRegistration(request);
            break;
        case PASSWORD_RESET:
            processPasswordReset(request);
            break;
        // Обработка других типов запросов
    }
}
 
private void processRegistration(UserRequest request) {
    if (userExists(request.getUsername())) {
        handleExistingUserRegistration(request);
    } else {
        createNewUser(request);
    }
}
 
private void handleExistingUserRegistration(UserRequest request) {
    if (!request.isForceUpdate()) {
        throw new UserAlreadyExistsException();
    }
    
    if (!hasAdminPermissions(request.getToken())) {
        throw new PermissionDeniedException();
    }
    
    updateExistingUser(request);
}