Какой стек выберешь для разработки проекта с нуля?

Стек технологий для нового Android проекта (2025)

На основе 10+ лет опыта и анализа современного рынка, вот мой выбор для разработки Android проекта с нуля.

Язык и платформа

Kotlin + Jetpack Compose

// Kotlin — официальный язык Android с 2019 года
// Преимущества:
// - Null-safety предотвращает миллионы багов
// - Extension functions делают код читаемым
// - Coroutines для асинхрона вместо callback hell
// - Лучше Java во всех аспектах

fun setupUI() {
    // Compose = declarative UI, как React/Vue
    // Меньше boilerplate, больше функциональности
    setContent {
        MyApp()
    }
}

Архитектура: Clean Architecture + MVVM

// Слои (от внешних к внутренним):
// 1. Presentation (UI, ViewModel)
// 2. Domain (бизнес-логика, Use Cases)
// 3. Data (Repositories, API, Database)

// Зависимости ВСЕГДА идут внутрь (dependency inversion)
Presentation → Domain ← Data

Domain слой (чистый, без зависимостей от Android):

// domain/model/User.kt
data class User(
    val id: String,
    val name: String,
    val email: String
)

// domain/usecase/GetUserUseCase.kt
interface GetUserUseCase {
    suspend operator fun invoke(userId: String): Result<User>
}

Data слой:

// data/repository/UserRepositoryImpl.kt
@Inject
class UserRepositoryImpl(
    private val apiService: ApiService,
    private val database: UserDatabase
) : UserRepository {
    
    override suspend fun getUser(userId: String): User {
        return withContext(Dispatchers.IO) {
            val localUser = database.userDao().getUser(userId)
            if (localUser != null) return@withContext localUser
            
            val remoteUser = apiService.getUser(userId)
            database.userDao().insert(remoteUser)
            remoteUser
        }
    }
}

Presentation слой (ViewModel):

@HiltViewModel
class UserViewModel @Inject constructor(
    private val getUserUseCase: GetUserUseCase
) : ViewModel() {
    
    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()
    
    fun loadUser(userId: String) {
        viewModelScope.launch {
            _uiState.value = UiState.Loading
            val result = getUserUseCase(userId)
            _uiState.value = when {
                result.isSuccess -> UiState.Success(result.getOrNull()!!)
                result.isFailure -> UiState.Error(result.exceptionOrNull()?.message)
                else -> UiState.Idle
            }
        }
    }
}

Dependency Injection: Hilt

// setup/HiltModule.kt
@Module
@InstallIn(SingletonComponent::class)
object HiltModule {
    
    @Singleton
    @Provides
    fun provideApiService(): ApiService {
        return Retrofit.Builder()
            .baseUrl(API_BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(ApiService::class.java)
    }
    
    @Singleton
    @Provides
    fun provideDatabase(@ApplicationContext context: Context): UserDatabase {
        return Room.databaseBuilder(
            context,
            UserDatabase::class.java,
            "users.db"
        ).build()
    }
    
    @Singleton
    @Provides
    fun provideUserRepository(
        api: ApiService,
        db: UserDatabase
    ): UserRepository {
        return UserRepositoryImpl(api, db)
    }
}

Асинхронность: Kotlin Coroutines

// Coroutines вместо RxJava или callback-hell
// Меньше кода, более читаемо, встроено в Jetpack

viewModelScope.launch {
    try {
        val users = withContext(Dispatchers.IO) {
            userRepository.getUsers()
        }
        showUsers(users)
    } catch (e: Exception) {
        showError(e.message)
    }
}

Database: Room + Datastore

// Room = TypeSafe SQL wrapper
@Entity(tableName = "users")
data class UserEntity(
    @PrimaryKey val id: String,
    val name: String,
    val email: String
)

@Dao
interface UserDao {
    @Query("SELECT * FROM users WHERE id = :userId")
    suspend fun getUser(userId: String): UserEntity?
    
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insert(user: UserEntity)
    
    @Delete
    suspend fun delete(user: UserEntity)
}

// Datastore вместо SharedPreferences
val userPreferences: Flow<User> = dataStore.data
    .catch { exception ->
        if (exception is IOException) emit(emptyPreferences())
        else throw exception
    }
    .map { preferences ->
        User(
            name = preferences[userNameKey] ?: "",
            isDarkMode = preferences[isDarkModeKey] ?: false
        }
    }

Networking: Retrofit + OkHttp

interface ApiService {
    @GET("api/v1/users/{id}")
    suspend fun getUser(@Path("id") userId: String): User
    
    @GET("api/v1/users")
    suspend fun getUsers(
        @Query("page") page: Int = 1,
        @Query("limit") limit: Int = 20
    ): List<User>
    
    @POST("api/v1/users")
    suspend fun createUser(@Body user: User): User
}

// OkHttp Interceptor для токенов
@Singleton
class AuthInterceptor @Inject constructor(
    private val authToken: String
) : Interceptor {
    
    override fun intercept(chain: Interceptor.Chain): Response {
        val request = chain.request()
            .newBuilder()
            .addHeader("Authorization", "Bearer $authToken")
            .build()
        return chain.proceed(request)
    }
}

UI компоненты: Jetpack Compose + Material Design 3

@Composable
fun UserScreen(viewModel: UserViewModel) {
    val uiState by viewModel.uiState.collectAsState()
    
    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp)
    ) {
        when (uiState) {
            is UiState.Loading -> {
                CircularProgressIndicator()
            }
            is UiState.Success -> {
                val user = (uiState as UiState.Success).user
                UserCard(user)
            }
            is UiState.Error -> {
                val message = (uiState as UiState.Error).message
                Text("Error: $message", color = MaterialTheme.colorScheme.error)
            }
        }
    }
}

Тестирование

// Unit тесты (JUnit 5 + Mockk)
@Test
fun testUserViewModel_whenLoadingUser_showsSuccess() {
    val mockRepository = mockk<UserRepository>()
    coEvery { mockRepository.getUser(any()) } returns User(
        "1", "John", "john@example.com"
    )
    
    val viewModel = UserViewModel(mockRepository)
    viewModel.loadUser("1")
    
    assert((viewModel.uiState.value as? UiState.Success)?.user?.name == "John")
}

// Instrumented тесты (Compose Test)
@get:Rule
val composeTestRule = createComposeRule()

@Test
fun testUserCard_displaysUserName() {
    composeTestRule.setContent {
        UserCard(User("1", "John", "john@example.com"))
    }
    composeTestRule.onNodeWithText("John").assertIsDisplayed()
}

CI/CD: GitHub Actions

name: Android CI
on: [push, pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-java@v2
        with:
          java-version: '17'
      - run: ./gradlew build
      - run: ./gradlew test
      - run: ./gradlew lint

Мониторинг и Аналитика

// Firebase для краша и аналитики (minimal)
// Sentry для ошибок (optional)
// Datadog для performance (optional для enterprise)

Полный стек в таблице

Почему этот стек?

✓ Современный — использует latest best practices ✓ Масштабируемый — легко добавлять features ✓ Тестируемый — 90%+ coverage легко достижим ✓ Producable — готов к production за недели ✓ Developer friendly — интуитивен для всех ✓ Battle-tested — используется в тысячах приложений ✓ Job market — легко найти разработчика

Что НЕ использовать

✗ Java (Kotlin лучше во всех аспектах) ✗ XML Layout (Compose современнее) ✗ RxJava (Coroutines проще и встроены) ✗ SharedPreferences (Datastore надёжнее) ✗ FirebaseUI (слишком магическая) ✗ Realm (Room лучше с Jetpack интеграцией) ✗ Koin (Hilt на основе Dagger, более мощный)

Этот стек не reinventing wheel, а использует proven solutions, которые Jetpack team сам рекомендует.