[Java][Kotlin][Android] 안드로이드 자바와 코틀린 함께 사용하기 - 안드로이드 Legacy 코드 유지보수 하기 (1)

안녕하세요 👋

거의 한 달 만에 포스팅으로 찾아뵙는 것 같습니다.

여러 프로젝트들을 경험하다 보면 자바로 되어있는 코드를 코틀린으로 바꾸거나

레거시 코드들을 유지 보수하면서 코틀린을 함께 사용하는 경우가 더러 있습니다.

오늘은 이런 경우에 대한 여러가지 내용들을 포스팅해보려 합니다.

이번 포스팅은 총 2편으로 기획이 될 것으로 보이며 

1편(본 포스팅)은 자바와 코틀린을 함께 사용하는 방법

2편은 자바 코드를 코틀린으로 변경하는 방법에 대해서 포스팅 해보려 합니다!

 

그럼 바로 시작해보도록 할까요? 😎

---

1. 설정 

자바 기반 프로젝트에서 코틀린을 사용하기 위해 위 코드와 같이 build.gradle을 설정해줍니다. 

// Project gradle
plugins {
    ... // 생략
    id 'org.jetbrains.kotlin.android' version '1.8.10' apply false
}

// Module gradle
plugins {
	... // 생략
    id 'org.jetbrains.kotlin.android'
}

android {
	... // 생략
    
    sourceSets{
        main.java.srcDirs+='src/main/kotlin'
    }
}

dependencies {
    ... // 생략
    
    // Kotlin
    implementation 'org.jetbrains.kotlin:kotlin-stdlib:1.8.10'
}

 

 

2. 디렉토리 생성

Android Studio에서 프로젝트 보기 설정을 Android -> Project로 변경 후 main에 kotlin이라는 이름으로 디렉토리를 생성해 줍니다.

 

디렉토리 생성

우선 기본적인 설정은 이렇게 마치면 되겠습니다. 🤩

그럼 지금부터는 아직 자바를 쓰고 있는 프로젝트에 여러 가지 라이브러리 및 패턴 등을 적용시키는 방법을 알아보겠습니다.

---

· MainActivity

@AndroidEntryPoint
public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    private ActivityMainBinding mBinding;
    private MainViewModel mViewModel;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mBinding = DataBindingUtil.setContentView(this , R.layout.activity_main);
        mViewModel = new ViewModelProvider(this).get(MainViewModel.class);
        mViewModel.callAllBeachList();
        observeData();
    }

    private void observeData() {
        mViewModel.getToastMessage().observe(this, new Observer<String>() { // Toast Message
            @Override
            public void onChanged(String message) {
                Toast.makeText(MainActivity.this, message , Toast.LENGTH_SHORT).show();
            }
        });

        mViewModel.getBeachList().observe(this, new Observer<List<BeachDTO>>() {
            @Override
            public void onChanged(List<BeachDTO> beachDTOs) {
                for(BeachDTO beach : beachDTOs){
                    Log.d(TAG, "onChanged: " + beach.toString());
                }
            }
        });
    }
}

 

· MainViewModel

@HiltViewModel
public class MainViewModel extends ViewModel {
    private BeachRepository mBeachRepository;
    private CompositeDisposable mCompositeDisposable;

    private MutableLiveData<List<BeachDTO>> mBeachList = new MutableLiveData<>();
    public LiveData<List<BeachDTO>> getBeachList() {
        return mBeachList;
    }

    private MutableLiveData<String> mToastMessage = new MutableLiveData<>();
    public void setToastMessage(String message) {
        mToastMessage.setValue(message);
    }
    public MutableLiveData<String> getToastMessage() {
        return mToastMessage;
    }

    @Inject
    MainViewModel(BeachRepository repository){
        mBeachRepository = repository;
    }

    /**
     * RxJava를 통해 해수욕장 혼잡도를 가져오는 메소드
     * **/
    public void callAllBeachList() {
        if(mCompositeDisposable == null){
            mCompositeDisposable = new CompositeDisposable();
        }
        mCompositeDisposable.add(
                mBeachRepository.getBeachCongestion()
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribeWith(new DisposableSingleObserver<BeachListDTO>(){
                            @Override
                            public void onSuccess(@NonNull BeachListDTO beachListDTO) {
                                mBeachList.setValue(beachListDTO.getAllBeachList());
                            }

                            @Override
                            public void onError(@NonNull Throwable e) {
                                mToastMessage.setValue("통신에 실패했습니다!");
                            }
                        })
        );
    }

    @Override
    protected void onCleared() {
        super.onCleared();
        if(mCompositeDisposable != null){
            mCompositeDisposable.clear(); // ViewModel이 clear 될때 CompositeDisposable 삭제
            mCompositeDisposable = null;
        }
    }
}

 

위 보시는 바와 같이 MainActivity는 Java기반으로 RxJava와 LiveData를 통해 통신하고 있습니다.

해당 Activity와 함께 사용하는 Repository와 Hilt의 module , Model에서 사용할 class 등을 코틀린으로

작성해 함께 사용하는 방법에 대해 알아보도록 하겠습니다.

 

 

· RestApi (Retrofit API 통신을 위한 Interface)

interface RestApi {
    @GET(Utils.GET_BEACH_CONGESTION_URL)
    fun getBeachCongestion() : Single<BeachListDTO>
}

 

· BeachRepository ( Repository Interface RxJava와 함께 사용하기 위해 Single 객체를 전달받는다. )

interface BeachRepository {
    /**
     * 해수욕장 혼잡도 가져오기
     * **/
    fun getBeachCongestion() : Single<BeachListDTO>
}

 

· BeachRepositoryImpl (Repository의 구현체 )

class BeachRepositoryImpl @Inject constructor(
    private val restApi: RestApi
) : BeachRepository {
    /**
     * 해수욕장 혼잡도 가져오기
     * **/
    override fun getBeachCongestion(): Single<BeachListDTO> {
        return restApi.getBeachCongestion()
    }
}

 

· Model에서 사용할 DTO class들

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

class BeachListDTO {
    private lateinit var mBeachList : MutableList<BeachDTO>

    @SerializedName("Beach0")
    val beach0 : BeachDTO? = null
    @SerializedName("Beach1")
    val beach1 : BeachDTO? = null
    @SerializedName("Beach2")
    ... 생략

    fun getAllBeachList() : MutableList<BeachDTO> {
        if(!::mBeachList.isInitialized){
            mBeachList = mutableListOf()
            mBeachList.add(beach0 as BeachDTO)
            mBeachList.add(beach1 as BeachDTO)
            mBeachList.add(beach2 as BeachDTO)
            ... 생략
        }
       return mBeachList
    }
}

 

· ProvideModule( Provides를 해줄 요소들을 모아놓은 Module )

@Module
@InstallIn(SingletonComponent::class)
object ProvideModule {
    @Provides
    @Singleton
    fun provideRestApi(okHttpClient: OkHttpClient) : RestApi {
        return Retrofit.Builder()
            .baseUrl(Utils.BEACH_BASE_URL)
            .client(okHttpClient)
            .addCallAdapterFactory(RxJava3CallAdapterFactory.create())
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(RestApi::class.java)
    }

    @Provides
    @Singleton
    fun provideOkHttpClient() : OkHttpClient {
        val interceptor = HttpLoggingInterceptor()
        interceptor.level= HttpLoggingInterceptor.Level.BODY

        return OkHttpClient.Builder()
            .addInterceptor(interceptor)
            .connectTimeout(Utils.CONNECTION_TIMEOUT, TimeUnit.MILLISECONDS)
            .build()
    }
}

 

· BindModule( Binds를 해줄 요소들을 모아놓은 Module )

@Module
@InstallIn(SingletonComponent::class)
abstract class BindModule {
    @Binds
    @Singleton
    abstract fun bindBeachRepository(beachRepositoryImpl: BeachRepositoryImpl) : BeachRepository
}

위에서 보이듯이 Hilt 및 여러 가지 Repository 등은 코틀린으로 새로 추가하여 사용할 수 있습니다.

애초에 코틀린의 장점 중 하나가 자바와 호환이 된다는 것이기 때문에 이렇게 사용하는 것은 당연할 텐데요

오래된 프로젝트들을 유지 보수 하다 보면 자바로 된 부분은 자바로 유지보수를 진행하고

신규 기능부터는 코틀린을 적용하여 개발하는 경우가 많은데 어떻게 시작을 해야 할지 감이 안 잡히는 경우가 많습니다.

그런 분들에게 조금이나마 도움이 되었으면 좋겠습니다.  🙏

 

다음 포스팅으로는 해당 자바 코드를 어떻게 코틀린으로 Migration 하는지에 대해 다뤄보겠습니다.

그럼

오늘도 즐코하세요 :)