[Android] 안드로이드 Clean Architecture에 대해서 (2) - 안드로이드 프로젝트에 적용하는 방법

안녕하세요 👋

오늘은 지난 포스팅에 이어 안드로이드 프로젝트에서

어떻게 Clean Architecture를 적용시키는지에 대해서 포스팅해보려 합니다.

Clean Architecture의 개념에 대해서는 아래 포스팅을 참고 부탁드립니다 🤔

 

[Android] 안드로이드 Clean Architecture에 대해서 ( 1 ) - Clean Architecture의 개념

 

Android에서 Clean Architecture를 적용하기 위해서는 앞서 말했듯

3가지 layer로 나누는 것부터 시작합니다.

 

저는 이전에 포스팅 했던 Hilt 예제 샘플에 적용해 보았습니다. 😎

프로젝트 구조

---

Domain Layer

Domain Layer의 패키지 구조

 

[Beach.kt] ( Data에서 전달받은 BeachDTO에서 UI에서 사용할 해변의 정보만을 정의한 class )

data class Beach(
    val poiNm : String = "",
    val congestion : String = ""
)

[BeachCongestionList.kt] ( 위 해변의 정보를 모아놓은 List를 정의해놓은 class )

data class BeachCongestionList(
    val beachList : ArrayList<Beach>
)

[BeachCongestionList.kt] ( Repository interface )

interface MainRepository {
    suspend fun getBeachCongestion() : BeachCongestionList
}

[GetBeachCongestionList.kt] ( 해변 혼잡도 정보를 포함한 리스트를 가져오는 UseCase )

class GetBeachCongestionList @Inject constructor(
    private val repository: MainRepository
) {
    suspend fun invoke() : BeachCongestionList{
        return repository.getBeachCongestion()
    }
}

[build.gradle]

module간 의존성 주입 X

---

Data Layer

Data Layer의 패키지 구조

 

[MyApi.kt] ( 해수욕장 혼잡도를 가져오는 API )

interface MyApi {
    @GET(DataConst.GET_CONGESTION_URL)
    suspend fun getBeachCongestion() : BeachCongestionListDTO
}

[DataConst.kt] ( Data Layer에서 사용할 common 한 상수를 정의한 class )

class DataConst {
    companion object{
        const val GET_CONGESTION_URL = "/seantour_map/travel/getBeachCongestionApi.do" // 해수욕장 혼잡도 구하는 URL
    }
}

[DTO classes] ( 해수욕장 혼잡도 API의 DTO class들로 API정보는 공공데이터 포털을 통해 확인 바랍니다. )

data class BeachDTO(
    val etlDt : String = "",
    val seqId : Int = -1,
    val poiNm : String = "",
    val uniqPop : Int = -1,
    val congestion : String = ""
)

class BeachCongestionListDTO {
    private lateinit var beachListDTO : MutableList<BeachDTO>

    @SerializedName("Beach0")
    val beachDTO0 : BeachDTO? = null
    @SerializedName("Beach1")
    val beachDTO1 : BeachDTO? = null
    @SerializedName("Beach2")
    val beachDTO2 : BeachDTO? = null
    @SerializedName("Beach3")
    val beachDTO3 : BeachDTO? = null
    @SerializedName("Beach4")
    val beachDTO4 : BeachDTO? = null
    @SerializedName("Beach5")
    val beachDTO5 : BeachDTO? = null
    @SerializedName("Beach6")
    val beachDTO6 : BeachDTO? = null
    @SerializedName("Beach7")
    val beachDTO7 : BeachDTO? = null
    @SerializedName("Beach8")
    val beachDTO8 : BeachDTO? = null
    @SerializedName("Beach9") // 이하 생략
   

    fun getAllBeachList() : MutableList<BeachDTO> {
        if(!::mBeachListDTO.isInitialized){
            mBeachListDTO = mutableListOf()
            mBeachListDTO.add(beachDTO0 as BeachDTO)
            mBeachListDTO.add(beachDTO1 as BeachDTO)
            mBeachListDTO.add(beachDTO2 as BeachDTO)
            mBeachListDTO.add(beachDTO3 as BeachDTO)
            mBeachListDTO.add(beachDTO4 as BeachDTO)
            mBeachListDTO.add(beachDTO5 as BeachDTO)
            mBeachListDTO.add(beachDTO6 as BeachDTO)
            mBeachListDTO.add(beachDTO7 as BeachDTO)
            mBeachListDTO.add(beachDTO8 as BeachDTO)
            mBeachListDTO.add(beachDTO9 as BeachDTO)
            mBeachListDTO.add(beachDTO10 as BeachDTO) // 이하 생략
        }
        return beachListDTO
    }
}

[BeachMapper.kt] ( Data의 DTO객체를 Domain의 Model들로 mapping 시키는 class )

object BeachMapper {
    private fun mapperToBeach(beachDTO: BeachDTO) : Beach {
        val beach = beachDTO.run {
            Beach(poiNm, congestion)
        }
        return beach
    }

    fun mapperToBeachCongestionList(beachCongestionListDTO: BeachCongestionListDTO) : BeachCongestionList {
        val list = arrayListOf<Beach>()
        beachCongestionListDTO.getAllBeachList().forEach {
            val beach = mapperToBeach(it)
            list.add(beach)
        }

        return BeachCongestionList(list)
    }
}

[MainRepositoryImpl.kt] ( MainRepository의 구현체 해당 구현체를 통해 Data의 값을 Domain으로 전달 )

class MainRepositoryImpl @Inject constructor(
    private val beachDataSource: BeachDataSource
) : MainRepository {
    override suspend fun getBeachCongestion(): BeachCongestionList {
        return beachDataSource.getCongestionList()
    }
}

[build.gradle] 

Domain Layer 의존성 주입

dependencies {
	// ... 생략
    implementation project(':domain')
}

---

Presenatation Layer

[MainApplication.kt]

@HiltAndroidApp
class MainApplication : Application()

[NetworkConst.kt]

const val BASE_URL = "https://www.tournmaster.com"

[AppModule.kt] ( Hilt에서 Provide를 제공하기 위한 Module )

@Module
@InstallIn(SingletonComponent::class)
object AppModule {

    @Provides
    @Singleton
    fun provideMyApi() : MyApi {
        return Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(MyApi::class.java)
    }
}

[BindModule.kt] ( Hilt에서 Bind를 제공하기 위한 Module )

@Module
@InstallIn(SingletonComponent::class)
abstract class BindModule {
    @Binds
    @Singleton
    abstract fun bindMainRepository(mainRepositoryImpl: MainRepositoryImpl) : MainRepository

    @Binds
    @Singleton
    abstract fun bindBeachDataSource(beachDataSourceImpl: BeachDataSourceImpl) : BeachDataSource
}

[MyViewModel.kt] ( MainActivity의 ViewModel class )

@HiltViewModel
class MyViewModel @Inject constructor(
    private val getBeachCongestionList: GetBeachCongestionList
) : ViewModel(){
    private val _beachCongestionList = MutableLiveData<BeachCongestionList>()
    val beachCongestionList : LiveData<BeachCongestionList>
    get() = _beachCongestionList

    private val _toastMessage = MutableLiveData<String>()
    val toastMessage : LiveData<String>
    get() = _toastMessage

    fun getBeachInfo(){
        val exceptionHandler = CoroutineExceptionHandler{ _ , exception ->
            when(exception){
                is SocketTimeoutException -> {onError("통신시간 초과!")}
            }
        }
        viewModelScope.launch(exceptionHandler) {
            _beachCongestionList.value = getBeachCongestionList.invoke()
        }
    }

    private fun onError(message : String) {
        _toastMessage.value = message
    }
}

[MainActivity.kt]

private const val TAG = "MainActivity"

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    private lateinit var binding : ActivityMainBinding
    private val viewModel : MyViewModel by viewModels()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater).also {
            setContentView(it.root)
        }
        observeData()
    }

    override fun onResume() {
        super.onResume()
        viewModel.getBeachInfo()
    }

    private fun observeData() {
        with(viewModel){
            beachCongestionList.observe(this@MainActivity){
                Log.d(TAG, "observeData: $it")
            }
            toastMessage.observe(this@MainActivity){
                Toast.makeText(this@MainActivity , it , Toast.LENGTH_SHORT).show()
            }
        }
    }
}

[build.gradle] 

Domain  , Data Layer 의존성 주입

dependencies {
    implementation project(':domain')
    implementation project(':data')
    // ... 생략
}

---

Clean Architecture는 정답이 없고 각 계층의 조건들이 부합한다면 개인의 따라서 패키지의 구조 등은 바뀔 수 있다고 합니다.

저 또한 공부를 하며 적용해 본 것이기에 잘못된 부분이 있다면 많은 피드백 부탁드리며 

많은 분들에게 참고가 되었으면 좋겠습니다 🙇🏻‍♂️

 

이상으로 Clean Architecture에 대한 포스팅은 모두 마치도록 하겠습니다.

 

오늘도 즐코하세요 :)