Что такое crossline?

# Crossline: концепция и практика в Android-разработке

Что такое Crossline?

Crossline (кросслайн) — это архитектурный паттерн и подход к организации кода, который предполагает объединение связанных по бизнес-логике операций из разных Clean Architecture слоёв в единые транзакционные цепочки. Основная идея — создание сквозных вертикальных срезов (cross-cutting concerns) через горизонтальные слои архитектуры для выполнения конкретной бизнес-операции.

Проблема, которую решает Crossline

В классической Clean Architecture или многослойных подходах (Presentation → Domain → Data) часто возникает проблема "распыления" логики одной бизнес-операции:

// Традиционный подход - логика размазана по слоям

// Presentation Layer
class MyViewModel @Inject constructor(
    private val getUserUseCase: GetUserUseCase,
    private val validateUserUseCase: ValidateUserUseCase,
    private val updateUserUseCase: UpdateUserUseCase
) : ViewModel() {
    fun updateUserProfile() {
        // 1. Получаем пользователя
        val user = getUserUseCase.execute(userId)
        // 2. Валидируем
        if (!validateUserUseCase.execute(user)) return
        // 3. Обновляем
        updateUserUseCase.execute(user)
        // Каждый UseCase идет в свой репозиторий, свою datasource и т.д.
    }
}

Реализация Crossline

Crossline объединяет эти операции в единый поток:

// Domain Layer - Crossline класс
class UserProfileCrossline @Inject constructor(
    private val userRepository: UserRepository,
    private val validationService: ValidationService,
    private val analyticsTracker: AnalyticsTracker
) {
    suspend fun updateUserProfile(userId: String, updates: UserUpdates): Result<User> {
        // Вся логика в одном месте, но с разделением ответственности внутри
        return crossline {
            // Шаг 1: Получение данных
            val user = step("get_user") {
                userRepository.getUser(userId)
            }
            
            // Шаг 2: Валидация
            step("validate") {
                if (!validationService.validate(user)) {
                    throw ValidationException("Invalid user data")
                }
            }
            
            // Шаг 3: Обновление
            val updatedUser = step("update") {
                userRepository.updateUser(userId, updates)
            }
            
            // Шаг 4: Побочные эффекты (логирование, аналитика)
            step("analytics") {
                analyticsTracker.trackProfileUpdate(userId)
            }
            
            updatedUser
        }.onFailure { error ->
            // Централизованная обработка ошибок
            analyticsTracker.trackError("profile_update", error)
        }
    }
}

Ключевые характеристики Crossline

1. Транзакционность

class PaymentCrossline {
    suspend fun processPayment(orderId: String): Result<PaymentResult> {
        return transaction {
            // Все операции выполняются как единая транзакция
            step("reserve_funds") { paymentGateway.reserve(orderId) }
            step("update_order") { orderRepository.markAsPaid(orderId) }
            step("notify_user") { notificationService.sendReceipt(orderId) }
            // Если любой шаг падает - откатывается вся транзакция
        }
    }
}

2. Сквозное логирование и мониторинг

// Crossline автоматически добавляет сквозные concerns
class CrosslineExecutor {
    suspend fun <T> execute(
        crosslineName: String,
        block: suspend CrosslineScope.() -> T
    ): T {
        // Начало операции
        val traceId = monitoring.startTrace(crosslineName)
        
        try {
            // Исполнение с таймингом каждого шага
            return MonitoringScope(traceId).use { scope ->
                scope.block()
            }
        } finally {
            // Завершение операции
            monitoring.endTrace(traceId)
        }
    }
}

3. Управление зависимостями

// Crossline инкапсулирует все зависимости для операции
class OrderProcessingCrossline @Inject constructor(
    // Все необходимые зависимости в одном месте
    private val orderRepo: OrderRepository,
    private val paymentService: PaymentService,
    private val inventoryService: InventoryService,
    private val shippingService: ShippingService,
    private val notificationService: NotificationService
) {
    // Вся логика обработки заказа в одном классе
    suspend fun processCompleteOrder(orderId: String) { ... }
}

Преимущества подхода

1. Улучшенная сопровождаемость

• Вся логика бизнес-операции в одном месте
• Легко понять последовательность шагов
• Проще рефакторинг и изменение потоков

2. Упрощенное тестирование

@Test
fun `test user profile update crossline`() = runTest {
    // Тестируем всю операцию целиком
    val crossline = UserProfileCrossline(
        mockUserRepo,
        mockValidationService,
        mockAnalytics
    )
    
    val result = crossline.updateUserProfile("user123", updates)
    
    assertTrue(result.isSuccess)
    verify(mockAnalytics).trackProfileUpdate("user123")
}

3. Единая точка обработки ошибок

// Централизованная обработка
class CrosslineWithErrorHandling {
    suspend fun performOperation(): Result<Data> {
        return try {
            crossline {
                step1()
                step2()
                step3()
            }
        } catch (e: NetworkException) {
            Result.failure(RetryableError(e))
        } catch (e: ValidationException) {
            Result.failure(UserError(e.message))
        } catch (e: Exception) {
            Result.failure(UnexpectedError(e))
        }
    }
}

Практическое применение в Android

Пример: обработка заказа в e-commerce приложении

class ECommerceOrderCrossline @Inject constructor(
    private val orderRepository: OrderRepository,
    private val paymentProcessor: PaymentProcessor,
    private val inventoryManager: InventoryManager,
    private val shippingCoordinator: ShippingCoordinator,
    private val notificationManager: NotificationManager,
    private val analytics: Analytics
) {
    
    suspend fun placeOrder(orderRequest: OrderRequest): Result<OrderConfirmation> {
        return crossline("place_order_${orderRequest.id}") {
            // Шаг 1: Валидация заказа
            val validatedOrder = step("validate") {
                validateOrder(orderRequest)
            }
            
            // Шаг 2: Проверка наличия товаров
            val availableItems = step("check_inventory") {
                inventoryManager.checkAvailability(validatedOrder.items)
            }
            
            // Шаг 3: Обработка платежа
            val paymentResult = step("process_payment") {
                paymentProcessor.process(validatedOrder.payment)
            }
            
            // Шаг 4: Создание заказа в системе
            val order = step("create_order") {
                orderRepository.createOrder(validatedOrder, availableItems)
            }
            
            // Шаг 5: Организация доставки
            val shipping = step("arrange_shipping") {
                shippingCoordinator.arrangeShipping(order)
            }
            
            // Шаг 6: Отправка уведомлений
            step("send_notifications") {
                notificationManager.sendOrderConfirmation(order, shipping)
            }
            
            // Возврат результата
            OrderConfirmation(order, shipping, paymentResult)
        }.onSuccess { confirmation ->
            analytics.trackOrderSuccess(confirmation.order.id)
        }.onFailure { error ->
            analytics.trackOrderFailure(orderRequest.id, error)
        }
    }
}

Сравнение с другими подходами

Best Practices при использовании Crossline

1. Размер Crossline

• Один Crossline = одна бизнес-операция
• Избегайте создания "божественных объектов"
• Разделяйте слишком большие Crossline на подоперации

2. Обработка ошибок

// Используйте Result-типы для типобезопасной обработки ошибок
sealed class CrosslineResult<out T> {
    data class Success<T>(val value: T) : CrosslineResult<T>()
    data class Failure(val error: CrosslineError) : CrosslineResult<Nothing>()
}

// Композиция нескольких Crossline
suspend fun complexOperation(): CrosslineResult<Output> {
    return crossline1()
        .flatMap { result1 -> crossline2(result1) }
        .flatMap { result2 -> crossline3(result2) }
}

3. Мониторинг и логирование

// Добавляйте structured logging
class MonitoredCrossline {
    suspend fun execute(): Result<Data> {
        return withLoggingContext(
            "crossline_name" to "user_registration",
            "timestamp" to System.currentTimeMillis()
        ) {
            crossline {
                // Каждый шаг автоматически логируется
                step("validation") { ... }
                step("persistence") { ... }
                step("notification") { ... }
            }
        }
    }
}

Заключение

Crossline — это мощный паттерн для Android-разработки, который особенно полезен в сложных бизнес-приложениях с многошаговыми операциями. Он обеспечивает:

1. Лучшую организацию кода для сложных бизнес-процессов
2. Упрощенную отладку и мониторинг сквозных операций
3. Встроенную поддержку транзакционности и откатов
4. Улучшенную тестируемость полных пользовательских сценариев

Однако важно не применять его слепо — для простых CRUD-операций традиционные UseCase могут быть более подходящими. Crossline показывает свою силу именно в комплексных операциях, затрагивающих несколько систем и требующих согласованности изменений.