Strong 감자의 공부

Retrofit 사용해보기 #1

ugyeong — Mon, 30 Dec 2024 18:41:41 +0900

오늘은 Retrofit을 사용해 api 통신을 설정해보겠습니다~

1. 싱글톤 객체로 Retrofit 객체 생성하기

싱글톤은 전역에서 한번만 객체가 생성되어 일관된 설정이 가능하고 코드 중복을 최소화할 수 있어요

package kr.co.gamja.study_hub.data.repository

import ...


object RetrofitManager {

    private const val BASE_URL = "https://..."
    val gson =GsonBuilder().setLenient().create()

    // Retrofit 객체를 구성합니다.
    val retrofit = Retrofit.Builder()
        .baseUrl(BASE_URL)
        .addConverterFactory(GsonConverterFactory.create(gson))
        .build()
	
    // retrofit.create : Retrofit은 인터페이스를 기반으로 동적으로 구현체(Proxy 객체)를 생성.
    val api = retrofit.create(Api::class.java) // Api :  API classs는 api 요청을 정의하는 인터페이스

}

2. api 요청을 처리하는 인터페이스

package kr.co.gamja.study_hub.data.repository

import ...

interface Api {
// suspend 키워드를 사용하면 비동기적으로 네트워크 요청을 수행하고, 결과를 반환할 때까지 호출을 일시 중단.
    @GET("/api/...") 
    suspend fun study(
        @Query("page") page: Int,
        @Query("size") size: Int
    ):Response<ParticipatedStudyRequestDto>
    
}

// HTTP 응답 데이터를 포함하는 객체
data class ParticipatedStudyRequestDto(
    val participateStudyData: ParticipateStudyData,
    val totalCount: Int
)

Response는 Retrofit 라이브러리에서 네트워크 요청의 결과를 나타내는 클래스이며, 이 클래스는 HTTP 요청에 대한 응답 정보를 캡슐화하며, 요청의 성공 또는 실패 여부와 서버에서 반환된 데이터를 처리하는 데 사용돼요.

3. 호출 부

 fun updateEngagedListSize() {
        viewModelScope.launch {
            val response = RetrofitManager.api.study(0, 10)
            try {
                if (response.isSuccessful) {
                  
                }
            } catch (e: Exception) {
              
            }
        }
    }

다음엔 jwt를 사용한 코드를 소개할게요!

달력 만들기

ugyeong — Mon, 30 Dec 2024 17:56:57 +0900

안녕하세요!

이틀만에 다시 뵙습니다~!

오늘은 달력 만들기를 소개하려해요!

해당 기능을 만들 때 타 블로그를 참고해서 만들었어요 차이점이 있다면 제가 구현한 달력은 시작날짜와 끝날짜를 선택해서 기간을 설정하는 방식이예요

1. 완성본

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

2. 구현

1, 2... 일 자가 리사이클러뷰 item이고 이를 반복해 달력을 만들었어요

저 하얀색 네모에 1, 2, 3 .. 날짜가 표시될 것이고 모여서 달력이 구성돼요

날짜를 클릭하면 색이 변경돼야하므로 이를 button으로 구성했어요

파일명 : calendar_call_item.xml

<?xml version="1.0" encoding="utf-8"?>
<layout ... >

    <data>

        <variable
            name="model"
            type="kr.co.gamja.study_hub.feature.studypage.createStudy.InfoOfDays" />
    </data>

    <LinearLayout
        android:layout_width="45dp"
        android:layout_height="45dp"
        android:background="@color/syswhite"
        android:orientation="vertical">

        <androidx.appcompat.widget.AppCompatButton
            android:id="@+id/txt_day"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:background="@drawable/solid_syswhite"
            android:textColor="@color/sysblack1"
            android:textSize="18dp"
            tools:text="@{model.infoDay}" />
    </LinearLayout>

</layout>

파일명 : fragment_calendar.xml

<?xml version="1.0" encoding="utf-8"?>
<layout ...>

    <data>

        <variable
            name="viewModel"
            type="kr.co.gamja.study_hub.feature.studypage.createStudy.CreateStudyViewModel" />
    </data>

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content" ... >

        <View
            android:id="@+id/view_top"
            ... />
			
        // "완료" 버튼
        <androidx.appcompat.widget.AppCompatButton
            android:id="@+id/btn_ok"
           	... />
            
            
        // 이전 달로 가는 "<" 버튼
        <androidx.appcompat.widget.AppCompatButton
            android:id="@+id/btn_left"
            ... />
            
            
        // "month" 글자
        <TextView
            android:id="@+id/txt_Month"
            .../>
            
        // 다음 달로 가는 ">" 버튼
        <androidx.appcompat.widget.AppCompatButton
            android:id="@+id/btn_right"
            .../>
            
        // 일 ~ 토 요일 표현
        <LinearLayout
            android:id="@+id/layout_linear"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
          ...>

            <TextView
                android:id="@+id/txt_sunday"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:text="@string/sunday"
                android:textColor="@color/BG_80"
                android:gravity="center"
                android:textSize="14dp" />

            <TextView
                android:id="@+id/txt_monday"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:gravity="center"
                android:text="@string/monday"
                android:textColor="@color/BG_80"
                android:textSize="14dp" />

            <TextView
                android:id="@+id/txt_tuesday"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:text="@string/tuesday"
                android:gravity="center"
                android:textColor="@color/BG_80"
                android:textSize="14dp" />

            <TextView
                android:id="@+id/txt_wednesday"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:text="@string/wednesday"
                android:gravity="center"
                android:textColor="@color/BG_80"
                android:textSize="14dp" />

            <TextView
                android:id="@+id/txt_Thursday"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:text="@string/Thursday"
                android:gravity="center"
                android:textColor="@color/BG_80"
                android:textSize="14dp" />

            <TextView
                android:id="@+id/txt_friday"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:text="@string/friday"
                android:gravity="center"
                android:textColor="@color/BG_80"
                android:textSize="14dp" />

            <TextView
                android:id="@+id/txt_Saturday"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:gravity="center"
                android:text="@string/Saturday"
                android:textColor="@color/BG_80"
                android:textSize="14dp" />

        </LinearLayout>


        // 1~몇 일 표현
        <androidx.recyclerview.widget.RecyclerView
            android:id="@+id/recycler_day"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            ... />
    </RelativeLayout>

</layout>

이제 리사이클러뷰의 어댑터를 보러 갈게요

파일명 : CalandarAdapter.kt

package kr.co.gamja.study_hub.feature.studypage.createStudy

import ...


class CalendarAdapter(private val context: Context) :
    RecyclerView.Adapter<CalendarAdapter.CalendarHolder>() {
    ...
    var daysInfo = ArrayList<InfoOfDays>() // 날짜
    private var onCalendarItemClickListener: OnCalendarItemClickListener? = null
    ...
	
    // CalendarHolder라는 ViewHolder 객체 생성 및 바인딩 객체를 ViewHolder에 전달하여, 나중에 데이터를 뷰와 연결.
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): CalendarHolder {
        val binding =
            CalendarCellItemBinding.inflate(LayoutInflater.from(parent.context), parent, false)
        return CalendarHolder(binding)
    }
	
    // position을 통해 해당하는 데이터를 viewHolder에 넣어주기
    override fun onBindViewHolder(holder: CalendarHolder, position: Int) {
        val day = daysInfo.get(position)
        holder.setDays(day)
    }

    // onBindViewHolder로 받은 데이터 실제 뷰와 연결하기
    inner class CalendarHolder(val binding: CalendarCellItemBinding) :
        RecyclerView.ViewHolder(binding.root) {
        fun setDays(item: InfoOfDays) {
            binding.model = item // 1일... day

            // 날짜가 없는 경우 선택 불가
            if (daysInfo[absoluteAdapterPosition].infoDay.isNotEmpty()) {
            
            /*
            selectedPosition: 사용자가 선택한 아이템의 위치. absoluteAdapterPosition: 현재 ViewHolder가 관리하는 아이템의 위치.
            현재 ViewHolder가 selectedPosition의 아이템을 관리하고 있는지 확인.
            
            ⭐⭐⭐ 
            recycelrView는 뷰를 재활용하므로 꼭 확인해야함. 안그러면 재활용 된거와 전의 뷰 홀더 구분을 못하는거 같음
             
            */   
             
                if (selectedPosition == absoluteAdapterPosition) {
                   // 선택한것으로 표시
                } else {
                    // 선택 취소하기
                }
                // 날짜 클릭이벤트가 발생했을 경우 
                if (onCalendarItemClickListener != null) {
                    binding.txtDay.setOnClickListener {
                        onCalendarItemClickListener?.onItemClick(item, absoluteAdapterPosition)
                        if (selectedPosition != absoluteAdapterPosition) {
                            binding.setChecked(false)
                            notifyItemChanged(selectedPosition)
                            selectedPosition = absoluteAdapterPosition
                            // 기존 선택한 날찌 체크 풀기
                            selectedYearMonthDay.selectedYearMonth = null
                            selectedYearMonthDay.selectedDay = null
                        }

                    }
                }
            }
            
            if (startDate.selectedYearMonth.isNullOrEmpty() && startDate.selectedDay.isNullOrEmpty()) {
            	// 날짜 선택 x 경우 - 현재날짜보다 전날인경우 회색    
            } else {
                // 날짜 선택 o 경우 - 시작날짜 포함 전 날짜들은 회색 처리 +todo("현재날짜보다 전날인경우 회색")
                if (item.infoDay.isNotEmpty()) {
                    
                }
            }
        }
    }
    
    // 외부(CalendarFragment)에서 클릭 이벤트 처리하기 위함
    fun setOnCalendarItemClickListener(listener: OnCalendarItemClickListener) {
        onCalendarItemClickListener = listener // listener는 CalendarFragment에서 전달받은 것 
    }
    // 총 몇개의 데이터가 나타나야하는지 RecyclerView에게 알려주기 (viewHolder개수 아님)
     override fun getItemCount(): Int {
        return daysInfo.size
    }

    private fun CalendarCellItemBinding.setChecked(selected: Boolean) {
       // 선택된 날짜 색 바꾸기
    }


    private fun CalendarCellItemBinding.setUncheked() {
       // 시작 날짜 이전 날짜는 선택 못하게 하기 
    }

}

interface OnCalendarItemClickListener {
    fun onItemClick(item: InfoOfDays, position: Int)
}

파일명 : CalandarFragment.kt

이전(스터디 생성) 화면

시작하는 날 혹은 종료하는 날 박스를 클릭하면 달력이 나타나요. 아래 코드의 bundle로 시작하는 날과 끝 날짜로 구분해요

package kr.co.gamja.study_hub.feature.studypage.createStudy
import ...

class CalendarFragment : BottomSheetDialogFragment() {

    private lateinit var binding: FragmentCalendarBinding
    private val viewModel: CreateStudyViewModel by activityViewModels()
    
    private lateinit var selectedDate: LocalDate// 년 월
    private lateinit var today: String // 오늘 날짜
    private lateinit var currentYearMonth: String // 오늘이 속한달
    private lateinit var changedYear: String // 바뀐 년
    private lateinit var changedMonth:String // 바뀐 달
    private lateinit var formattedDate: String // 포멧한 값
    private lateinit var whatDay: String // 시작인지 끝날짜인지 구분 tag(스터디 생성에서 가져옴)
    private lateinit var changedYearMonth:String // 지난날짜 회색처리 위한 바뀐 날짜 yyyyMM
    var newSelectedYearMonth=InfoOfSelectedDay(null,null) // 선택된 날짜
    private lateinit var newStartDate:StartDate// 시작 날짜 < 끝 날짜
    
    
    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        binding = DataBindingUtil.inflate(inflater, R.layout.fragment_calendar, container, false)
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.viewModel = viewModel
        binding.lifecycleOwner = viewLifecycleOwner
        
        val receiveBundle = arguments // 이전(스터디 생성: 위 사진) 화면에서 받아오는 값(달력Fragment 하나로 사용하기 때문)
        var startYearMonth =""
        var startDay = ""
        
        if (receiveBundle != null) {
            val value = receiveBundle.getString("whatDayKey")
            startYearMonth= receiveBundle.getString("startYearMonth").toString()
            startDay=receiveBundle.getString("startDay").toString()
            newStartDate=StartDate(startYearMonth,startDay)
            if (value != null) whatDay = value
            else Log.e(tag, "시작날짜인지 끝인지 못받아옴")
        }
        if(whatDay=="0"){ // 시작 날짜 선택이면
            selectedDate = LocalDate.now()
            today = LocalDate.now().dayOfMonth.toString()
            currentYearMonth = toYearMonth(LocalDate.now())
        }else{ // 끝 날짜 선택이면 
            val combined = "$startYearMonth$startDay"
            val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd")
            selectedDate =LocalDate.parse(combined,formatter)
            today = selectedDate.dayOfMonth.toString()
            currentYearMonth = startYearMonth
        }

        setMonthView() // 달력 업데이트
        
        // 이전 달 보기 버튼
        binding.btnLeft.setOnClickListener {
            selectedDate = selectedDate.minusMonths(1)
            setMonthView() // 달력 업데이트
        }
        // 다음 달 보기 버튼
        binding.btnRight.setOnClickListener {
            selectedDate = selectedDate.plusMonths(1)
            setMonthView() // 달력 업데이트
        }
        
        binding.btnOk.setOnClickListener {
        	// 날짜 선택 완료
        }

    }
	
    // ✔️ 달력 업데이트 함수 
    fun setMonthView() {
        binding.txtMonth.setText(monthYearFromDate(selectedDate)) // "yyyy-MM" 달력 상단 년도 월 표시
        
        val newDayList = daysInMonthArray(selectedDate) // 해당 달에 해당하는 "일"들 만들어서 리턴 
        
        val adapter = CalendarAdapter(requireContext()).apply {
        
            setOnCalendarItemClickListener(object:OnCalendarItemClickListener{
                override fun onItemClick(item: InfoOfDays, position: Int) {
                    
                    newSelectedYearMonth=InfoOfSelectedDay(item.yearMonthDay,item.infoDay) // 선택된 날짜
                    formattedDate = "${changedYear}년 ${changedMonth}월 ${item.infoDay}일" // 이전 화면 표시용 날짜
                    binding.btnOk.isEnabled = true
                    binding.btnOk.setTextColor(ContextCompat.getColor(requireContext(), R.color.O_50))
                }
            })
        }
        val infoOfDaysList:ArrayList<InfoOfDays> =ArrayList()
        for(day in newDayList){ // day 는 1,2 ~, daysInMonthArray함수에서 받은 ArrayList<String> -> ArrayList<InfoOfDays> 맞추기 위해 
            val info = InfoOfDays(yearMonthDay = changedYearMonth, infoDay =day, isSelected = false)
            infoOfDaysList.add(info)
        }
        adapter.daysInfo=infoOfDaysList
        adapter.currentYearMonth=currentYearMonth // yyyyMM
        adapter.currentDay=today // 오늘 날짜 표시 
        adapter.selectedYearMonthDay=newSelectedYearMonth // 선택된 년도 달
        adapter.startDate=newStartDate // 시작 날짜
        
        binding.recyclerDay.adapter = adapter
        binding.recyclerDay.layoutManager = GridLayoutManager(requireContext(), 7)
    }
    
    
    
    // ✔️ 달력 만들기
    fun daysInMonthArray(newDate: LocalDate): ArrayList<String> {
        val newDayList = ArrayList<String>() // 달력 "일" 리스트 
        val newYearWithMonth = toYearMonth(newDate) // yyyyMM 형식으로 변경
        changedYear=getOnlyYear(newDate) // yyyy 형식으로 변경
        changedMonth=getOnlyMonth(newDate) //MM 형식으로 변경 
        changedYearMonth=toYearMonth(newDate) // yyyyMM
        val newMonth = YearMonth.from(newDate) // 2023-10 형식
        
        val firstDayOfMonth = selectedDate.withDayOfMonth(1)
        val lastDayOfMonth = newMonth.lengthOfMonth()
        val dayOfWeek = firstDayOfMonth.dayOfWeek.value

        // 지난달 조회 불가 < 화살표 예) 202310>202409
        if (newYearWithMonth.toInt() > currentYearMonth.toInt()) {           
        } else {
        
        ...
        
        }
        // 7*6 자리로 달력 만들기 
        for (i in 1 until 42) {
            if (i <= dayOfWeek || i > lastDayOfMonth + dayOfWeek)
                newDayList.add("")
            else newDayList.add((i - dayOfWeek).toString())
        }
        return newDayList
    }
   
}

data class InfoOfDays(
    var yearMonthDay:String, // yyyyMM
    val infoDay:String,
    var isSelected:Boolean
)

필요없는 코드들 최대한 뺐지만... 여전히 복잡해보이네요

코드에 붙인 이모티콘 위주로 봐주시면 됩니다!

안드로이드 api 통신_callback함수

ugyeong — Fri, 27 Dec 2024 19:28:21 +0900

api 통신 시 callback 함수와 viewModelScope를 사용했다.(callback은 비동기/ 동기로 사용가능하며, callback을 호출하는 함수에 따라 callback이 비동기/동기 중 어떻게 작동할지 결정된다.)

동기 콜백: 호출하는 함수가 콜백을 호출한 뒤, 콜백 작업이 완료될 때까지 호출하는 함수가 대기합니다.
비동기 콜백: 호출하는 함수가 콜백을 호출한 뒤 대기하지 않고 바로 종료됩니다.

위에 글만 읽으면 이해가 안가니 예제를 가져오겠슴다.

1. 동기식 callback예제

람다로 구성된 아래 코드를 간단히 설명하자면

executeCallback {} 안에 있는 코드가(= println("Inside callback") ) callback() 호출 시 실행되는 문이다.

executeCallback(callback: () -> Unit)를 뜯어보자면

()는 함수의 매개변수, Unit은 함수 호출 후 반환값이 없음을 말한다.

println("Inside callback")은 단순 프린트 문이라 매개변수도, 반환값도 없다.

=>람다를 사용하지 않고 함수 작성할때도 리턴값 없이 프린트 문만 출력 한다면 반환값을 void로 하는것과 같다.

fun executeCallback(callback: () -> Unit) {
    println("Before callback")
    callback() // 콜백 호출
    println("After callback")
}

fun main() {
    executeCallback {
        println("Inside callback") // 콜백의 본문 내용
    }
}

// 결과
Before callback
Inside callback
After callback

혹시 매개변수랑 리턴값이 있을 때를 궁금해할 사람들을 위해 chat gpt에서 예시 긁어왔슴당.

input은 callback으로 전달되는 "kotlin"입니다.

fun executeCallback(callback: (String) -> String) {
    println("Before callback")
    val result: String = callback("Kotlin") // 콜백 함수의 반환값을 받음
    println("Callback returned: $result") // 반환값 출력
}

fun main() {
    executeCallback { input ->
        println("Inside callback with input: $input") // 매개변수를(executeCallback에서 callback("kotlin")) 사용해 문자열 반환
        "Hello, $input!" // 리턴값
    }
}

// 결과 
Before callback
Inside callback with input: Kotlin
Callback returned: Hello, Kotlin!

2. 비동기식 callback예제

우선 알아둬야 할건 네트워크 요청은 비동기이다. 그렇기 때문에 api 호출하는 함수를 일반함수로만 작성하면 안된다!!

아래는 내가 작성한 코드이다.

// fragment.kt 코드

private val viewModel: ChangeNickNameViewModel by viewModels()

...

binding.btnComplete.setOnClickListener {
            viewModel.isDuplicationNickname(object : CallBackListener {
                override fun isSuccess(result: Boolean) {
                    if (result) {
                      // 성공 시
                    } else {
                       // 실패 시
                    }
                }
            })
        }
        
        
        
// viewModel.kt 코드

fun isDuplicationNickname(params: CallBackListener) {
        viewModelScope.launch {
            val response =
                RetrofitManager.api.checkNicknameDuplication(nickname = nickname.value.toString())
            if (response.isSuccessful) {
                params.isSuccess(true)
            } else {
                params.isSuccess(false)
            }
        }
    }
    
    
 // interface.kt 코드
 
 interface CallBackListener {
    fun isSuccess(result: Boolean)
}

코드 작동 순서

fragment에서 btnComplete라는 버튼이 눌리면 viewModel.kt에 작성된 isDuplicationNickname함수가 호출된다.

호출 시 fragment에서 구체화한 CallBackListener 구현체(isSuccess)가 호출 함수( isDuplicationNickname )에 전달된다. 다시 fragment.kt로 반환되는거 아님!

여기서 의문점...!

✔️ 호출된 isDuplicationNickname은 네트워크 응답값을 기다렸다가 끝나나? ❌

해당 일반 함수는 그냥 끝난다. = 끝나니까 네트워크 응답값이 나중에 와도 못받음!

✔️ 호출된 isDuplicationNickname 함수가 종료되면 해담 함수 안의 params.isSuccess(true) or (false)은 어떻게 동작하는가?

viewModelScope.launch로 코루틴을 시작하면, 이 코루틴은 백그라운드에서 네트워크 요청을 처리된다.
isDuplicationNickname 함수는 종료되더라도 코루틴 내의 네트워크 작업은 계속 진행된다.

✔️ 만약 viewModelScope.launch와 같은 코루틴 스코프로 감싸지 않으면?

코루틴이 아닌 일반 함수로 동작하게 된다.
네트워크 요청이 실행되더라도 함수 자체는 결과를 기다리지 않고 그대로 종료된다.

TⓂ️ℹ️

처음 서버와 통신하는 기능을 구현할 때 callback 개념을 몰라 넘 막막했다...

코루틴 스코프같은 비동기 컨텍스트도 몰라 api 요청 시 함수 종료로 에러가 발생했는데 그 당시 나땜에 프젝 진행 안될까봐 발동동 구르며 전전긍긍 앓았다

해결하기위해 구글링하는 과정에서 많은 북마크를 날렸고 그때의 급급함이 북마크에 고스란히 남아있다..(북마크 언제 정리하지 )

2022-2023 심정

발에 불 떨어지면 어떻게든 하는 나..

앱 게시 문제_#심사는 끝났는데 플레이 스토어에 앱이 안보일 때

ugyeong — Fri, 27 Dec 2024 18:14:20 +0900

앱 심사는 끝난거 같은데 플레이스토어에 앱이 안올라온 경험이 있습니다. 옾채통해 해결했네요ㅠ(도와주신 익명님 감사합니다)

⭐⭐⭐앱이 플레이스토어에 출시됐을 경우(플레이스토어에 내 앱이 보이는 경우) : 플레이콘솔 "홈" -> 앱상태 "프로덕션" 입니다.

⭐⭐⭐플레이 스토어에 출시 안됐을 경우(플레이스토어에 내 앱이 안보이는 경우) : 앱상태는 "출시 안됨"으로 표기 됩니다!

✔️만약 앱 심사 기간이 지났고 별다른 이상 메시지가 오지도 않았는데 플레이콘솔 "홈" -> 앱상태 "출시 안됨" 으로 표기된다면? 동시에 아래 사진처럼 해당 앱 대시보드 -> 출시개요에는 "프로덕션"이라고 뜬다면?

해당 앱 > 테스트 및 출시 > 설정 > 고급 설정 > 앱 이용 가능 여부가 출시됨으로 되어있는지 확인해보세요!!

앱 출시 회고_intro

ugyeong — Thu, 26 Dec 2024 20:56:42 +0900

2023년 7월부터 기획한 앱을 24년 3월에 플레이 스토어에 출시하고 유지보수를 거쳐 드.디.어 24년12월 1차 마무리 지었어요!!

1년 6개월 동안 부캠 병행에 앱 출시까지...! 넘 수고했돠...!(뿌듯)

알림 기능 등 더 추가하고 싶은 기능은 많지만...! 취업이 우선이라 취뽀 후 취미로 앱 고도화 할 계획이예요!

포스팅 작성하는 첫번째 이유는...

앱 개발할 땐 시간에 쫓겨 기능이 작동만하면 넘어갔기 때문에 스스로 회고하기 위함입니다!

두번째 이유는 앱개발을 시작하는 누군가에게 도움이 되기를 바라는 마음에 작성합니다!

바야흐로 22년 9월, 저는 처음 안드로이드 앱개발을 접했습니다. 그 당시 비동기를 활용한 로그인 화면 개발 조차 못했어요ㅜㅜ 이때 도움을 준 사람이 교내 동아리 스터디원이였는데 정말 이 친구 없었으면 개발을 마치지 못했을거예요..!

그 친구가 모르는 부분 딱 한부분을 짚어줬는데 정말 그 덕분에 앱 개발의 실마리를 찾고 출시까지 할 수 있었어요!

그래서 앱 개발을 시작하는 누군가에게 도움이 되기를 바라면 포스팅시작합니다!

먼저 말씀드릴건

1. 제 코드가 별로일 가능성 99%입니다! 위에서 언급했듯이 개발 시 시간에 쫓겨 후다닥 만들었기에 코드 정리 못했습니다.

2. 그럼 지금 코드 정리하면 되지않나? 싶겠지만 저는 지금 취준 병행이고 안드로이드 포스팅 자체는 취미라... 코드 리팩터보단 사용했던 개념 소개나 트러블슈팅에 집중할 계획입니다.(코드 리팩터는 취뽀 후... 나중에 취뽀 전 후 코드 변천사를 보는것도 재밌을거 같네요 ㅎㅎ)

모쪼록 앱 개발 초심자에게 도움이 되기를 바라며 포스팅 마칩니다!! + 언제든 코드 훈수 대환영⭐

https://play.google.com/store/apps/details?id=kr.co.gamja.study_hub&hl=ko

StudyHub(스터디허브) - Google Play 앱

스터디 팀원을 찾고 계신가요? 인천대학교 학생을 위한 스터디 매칭 서비스, 스터디 허브에서 스터디를 시작해 보세요!

play.google.com

Ch_14 코루틴 처리

ugyeong — Sun, 12 Nov 2023 10:49:03 +0900

- 목차

1. 코루틴 동시성 알아보기

2. 코루틴 정보 전달 알아보기

코루틴의 기본개념

- 코루틴의 주요 특징은 서브루틴(함수가 호출되면 결과를 반환, 순차적 처리)과는 다르게 실행중 중단이 가능하며 필요할 때 다시 그 지점부터 실행 재개가 가능합니다.

non-blocking에 대해

중단 및 재개: 코루틴은 특정 작업(예: I/O 작업)을 실행할 때 중단될 수 있습니다. 이때, 코루틴은 현재 상태를 저장하고 실행을 일시 중지합니다. 이러한 기능 덕분에 코루틴이 블로킹 작업을 요청하더라도, 다른 코루틴으로 실행 흐름을 넘겨 프로그램의 나머지 부분이 계속 실행될 수 있습니다.
이벤트 루프 및 스케줄러: 코루틴은 이벤트 루프나 스케줄러와 같은 메커니즘을 사용하여 관리됩니다. 이러한 메커니즘은 코루틴 간에 실행을 효율적으로 전환하고, I/O와 같은 논블로킹 작업이 완료되었을 때 코루틴을 재개합니다.
비동기 I/O 작업: 코루틴은 비동기 I/O 작업에 최적화되어 있습니다. 예를 들어, 네트워크 요청을 할 때 코루틴은 요청을 보내고, 응답을 기다리는 동안 중단됩니다. 이때 다른 코루틴은 계속 실행될 수 있으며, 응답이 도착하면 원래 코루틴은 다시 활성화되어 나머지 작업을 수행합니다.
효율적인 자원 사용: 코루틴은 전통적인 멀티스레딩에 비해 상대 코루틴은 스레드에 비해 적은 메모리를 사용합니다. 각 스레드는 일반적으로 고정된 스택 메모리(예: 수 MB)를 할당받지만, 코루틴은 필요한 만큼의 메모리만 사용하며, 이는 대개 훨씬 적은 양입니다. 적으로 적은 오버헤드로 많은 수의 동시 작업을 처리할 수 있습니다. 또한, 컨텍스트 스위칭: 코루틴 간의 컨텍스트 스위칭은 스레드 간 스위칭보다 오버헤드가 훨씬 적습니다. 스레드 간의 컨텍스트 스위칭은 운영 체제의 개입을 필요로 하며, 이는 상대적으로 많은 시간과 자원을 소모합니다. 반면, 코루틴은 사용자 레벨에서의 경량 스위칭을 통해 빠르고 효율적으로 실행 상태를 전환합니다. (코루틴이 실행 상태를 전환할 때 필요한 데이터와 상태 정보를 최소화하여 관리한다는 의미)

- 코루틴은 스레드를 사용하지만, 스레드와 다른 점은 블로킹을 하지 않고 난블로킹 상태로 코루틴을 스레드 환경에서 실행한다. 그래서 일반적인 스레드 처리보다 메모리 성능이 뛰어납니다.

코루틴 구성

스레드와 달리 코루틴은 코루틴이 실행되는 별도의 영역인 코루틴 스코프를 구성해야한다. 그리고 이 코루틴 스코프에서 코루틴 빌더 함수와 일시중단 함수를 사용합니다.

- 코루틴 스코프 : GlobalScope, CoroutineScope는 코루틴 스코프를 구성해서 내부에 코루틴 빌더 함수로 코루틴을 계층 구성하고 내부에 일시 중단 함수 등을 사용해서 코루틴을 처리하는 영역입니다.

- 코루틴 빌더 함수 : launch, runBlocking 등은 코루틴 스코프를 생성하는 함수이거나 코루틴을 처리하는 함수입니다.

- 일반 중단 함수 : delay 함수는 코루틴 내부의 특정 기능을 하는 함수입니다.

- 코루틴 결과 처리 : Job과 Deffeered는 코루틴의 결과를 반환하거나 코루틴 처리의 중단 등을 처리 할 수 있습니다.

런블로킹 작동원리

런블러킹 방식은 스레드와 코루틴의 중간정도의 요건을 처리한다.세북적인 처리 내용을 보면 코루틴을 스레드에서 간단하게 처리하는 방식을 제공합니다.

단점 : 현재 처리되는 스레드가 종료되면 같이 종료됩니다.

아래의 방식은 메인 함수는 일반 스레드가 작동하고 그 내부에 tunBlocking이 빌더한 경우만 코루틴으로 처리합니다.

주요 코루틴 빌더 함수

- launch 확장함수 : 코루틴 스코프에 코루틴을 빌더하는 함수이고 반환값은 Job이다. 이 Job으로 코루틴을 중단할 수 있습니다.

- async 확장함수 : 코루틴 스코프에 코루틴을 빌더하는 함수이다. 반환값은 Deffered<T>이고 이에 코루틴의 처리결과도 같이 반환된다. 그래서 await로 반환값을 처리할 수 있습니다.

- withContext 일시중단함수 : 컨텍스트를 변경하면서 처리하는 코루틴 빌더이다. 특히 예외 처리가 필요할 때, finally 내에 noncallable과 같이 처리하면 세로운 코루틴을 실행시킬 수 있습니다.

- withTimeOut 일시중단함수 :특정 코루틴 처리를 특정 시간까지 작동합니다.

GlobalScope, CoroutineScope차이

글로벌 스코프: 앱의 생명 주기와 함께 동작하기 때문에 앱이 실행되는 동안은 별도의 생명주기 관리가 필요하지 않습니다. 만약 앱의 시작부터 종료될 때까지 혹은 장시간 실행되어야 하는 코루틴이 있다면 GlobalScope를 사용하면 됩니다.
코루틴 스코프: 버튼을 클릭해서 서버의 정보를 가져오거나 파일을 여는 용도라면 필요할 때 만 열고 완료되면 닫는 CoroutineScope를 사용해야 합니다

join() 메서드는 코루틴이 실행이 종료된 후 메인스레드 코루틴이 종료합니다.

코루틴 스코프 안에 선언된 여러 개의 launch 블록은 모두 새로운 코루틴으로 분기되면서 동시에 처리되기 때문에 순서를 정할 수 없습니다.

이럴 때 launch 블록 끝에 join() 메서드를 사용하면 각각의 코루틴이 순차적으로 실행됩니다.

CroutineScope(Dispatchers.default).launch() {
    launch {
        for (i in 0..5) {
            delay(500)
            Log.d("코루틴", "결과1 = $i")
        }
    }.join()

    launch {
        for (i in 0..5) {
            delay(500)
            Log.d("코루틴", "결과2 = $i")
        }
    }
}

코루틴은 launch와 async로 시작할 수 있습니다.

- launch() : 호출하는 것만으로도 코루틴을 생성, 반환되는 Job을 변수에 넣어두고 상태관리용으로 사용합니다.

- async() : 상태를 관리하고 await를 이용해 반환값을 받을 수 있습니다.

CoroutineScope(Dispatchers.Default).async {
    val deferred1 = async {
        delay(500)
        350
    }
    val deferred2 = async {
        delay(1000)
        200
    }
    Log.d("코루틴", "연산 결과 = ${deferred1.await() + deferred2.await()}")
}

cancel() : 코루틴의 동작을 멈추는 상태 관리 메서드입니다.

하나의 스코프 안에 여러 개의 코루틴이 있다면 하위의 코루틴도 모두 동작을 멈춥니다.

다음 코드의 job의 cancel메서드가 호출되면 job 뿐만 아니라 같은 스코프에 있는 job1의 코드도 모두 동작을 중단합니다. job의 cancel메서드가 호출되면 job 뿐만 아니라 같은 스코프에 있는 job1의 코드도 모두 동작을 중단합니다.

val job = CoroutineScope(Dispatchers.Default).launch {
    var job1 = launch {
        for (i in 0..10) {
            delay(500)
            Log.d("코루틴", "결과 = $i")
        }
    }
}

suspend

코루틴 안에서 suspend 키워드로 선언된 함수가 호출되면 이전까지의 코드 실행이 멈추고, suspend 함수가 처리가 완료된 후에 멈춰 있던 원래 스코프의 다음 코드가 실행됩니다.

- subRoutine() 함수를 suspend 키워드로 선언합니다.

CoroutineScope가 실행되면 (코드 1)이라고 작성된 부분이 실행된 후 subRoune() 함수가 호출됩니다.

그리고 suspend 키워드를 사용했기 때문에 subRoutine() 안의 코드가 모두 실행된 후에 (코드 2)가 실행됩니다.

suspend가 코루틴을 가장 잘 나타내는 이유는 subRoutine()이 실행되면서 호출한 측의 코드를 잠시 멈췄지만 스레드의 중단이 없기 때문입니다.

- 이 코드를 스레드로 작성했다면??

부모에 해당하는 ‘(코드 1)’이 동작하는 스레드를 멈춰야만 가능한데, 코루틴에서는 부모 루틴의 상태 값을 저장한 후 subRoutine()을 실행하고, 다시 subRoutine()이 종류된 후 부모 루틴의 상태 값을 복원하는 형태로 동작하므로 스레드에는 영향을 주지 않습니다.

이런 구조가 스레드의 동시성에서 발생할 수 있는 성능 저하도 막아줍니다.

suspend fun subRoutine() {
    for (i in 0..10) {
        Log.d("subRoutine", "$i")
    }
}

CoroutineScope(Dispatchers.Main).launch {
    // (코드 1)
    subRoutine()
    // (코드 2)
}

Dispatcher

코루틴이 실행될 스레드를 지정하는 것이라고 생각하면 됩니다.

-디스패처의 종류

코루틴이 실행될 스레드를 정하는 디스패처 (Dispatcher) 는 IO, Main, Default, Unconfined 등이 있는데, 모두 사용할 필요는 없고 우선은 IO와 Main을 잘 조합해서 사용하면 됩니다.

Dispatchers.Default	CPU를 많이 사용하는 작업을 백그라운드 스레드에서 실행하도록 최적화되어 있는 디스패처입니다. 안드로이드의 기본 스레드풀 (Thread Pool)을 사용합니다.
Dispatchers.IO	이미지 다운로드, 파일 입출력 등의 입출력에 최적화되어 있는 디스패처입니다.
Dispatchers.Main	안드로이드의 기본 스레드에서 코루틴을 실행하고 UI와 상호작용에 최적화되어 있는 디스패처입니다. 택스트뷰에 글자를 입력해야 할 경우 Main 컨텍스트를 사용해야 합니다.
Dispatchers.Unconfined	자신을 호출한 컨텍스트를 기본으로 사용하는데, 중단 후 다시 실행하는 시점에 컨텍스트가 바뀌면 자신의 컨텍스트도 다시 실행하는 컨텍스트를 따라갑니다.

withContext로 디스패처 분리

suspend 함수를 코루틴 스코프에서 호출할 때 호출한 스코프와 다른 디스패처를 사용할 때가 있습니다.

예를 들어 호출 측 코루틴은 main 디스패처에서 UI를 제어하는데, 호출되는 suspend함수는 디스크에서 파일을 일거와야 하는 경우가 있습니다.

이럴 때 withCotext를 사용해서 호출되는 suspend 함수의 디스패처를 IO로 변경할 수 있습니다.

호출되는 suspend 함수에 반환 값이 있다면 변숭 저장하고 사용할 수도 있습니다.

suspend fun readFile(): String {
    return "파일 내용"
}

CoroutineScope(Dispatchers.Main).launch {
    // 화면 처리
    val result = withContext(Dispatchers.IO) {
        readFile()
    }
    Log.d("코루틴", "파일 결과 = $result")
}

Ch_ 13 파일 입출력과 스레드 처리

ugyeong — Tue, 31 Oct 2023 23:00:31 +0900

chapter13 내용 중

02. 스레드에 대해 포스팅 해보겠습니다!

프로세스와 스레드

- 프로세스 : 특정 프로그램을 task로 보고 이 task를 실행단위로 처리. 특히 멀티스레드를 지원하면서 스레드 단위로 프로그램을 처리할 수 있다.

- 스레드 : 프로세스 내에 작은 단위로 실행할 수 있는 기능. 하나의 프로세스에서 처리되는 스레드는 프로그램을 실행한 스택을 따로 생성하지만, 메모리 등은 프로세스에서 제공하는 것을 공유해서 처리.

- 프로세스의 자원을 사용해서 자기 스레드가 실행되는 동안 다른 스레드를 처리하지 못하게 블로킹한다. 그 다음에 자기 스레드가 블로킹되면 다른 스레드가 실행된다.

- 프로세스는 보통 기본 메인 스레와 다른 작업을 실행하는 별도의 스레드로 관리된다. 별도의 스레드를 생성하지 않으면 메인스레드 하나로 프로그램을 처리한다. 멀티 스레드 처리는 메인 스레드 외에 별도의 스레드를 생성해서 프로그램을 나눠 처리하는 방식이다.

프로세스와 스레드 확인

코어 개수 = Runtime.getRuntime().availableProcessors()

현재스레드 개수 = Thread.currentThread()

쓰레드 상태 알아보기

스레드를 만들려면 Thread 클래스를 상속하거나 Runnable 인터페이스와 Thread 클래스를 사용해서 작성한다.

start : 실제 스레드 환경을 구성한 환경을 실행하는 메서드. 이 메서드를 실행해야 내부에 있는 run메서드가 실행된다.

run : 스레드 클래스를 정의할 때 내부에서 실행될 코드를 작성하는 메서드

join : 스레드가 실행된 다음 종료할 때까지 기다린다.

sleep : 스레드를 잠시 중단하고 다른 스레드를 처리한 후 다시 자기 스레드를 작동할 수 있게 만든다.

fun main(){
    println("클래스 참조 :  ${Thread::class}")
    println("인터페이스 참조 : ${Runnable::class}")
    println("현재 스레드 개수 : ${Thread.activeCount()}")
    println(" 현재 스레드 : ${Thread.currentThread()} ")

    fun <T:Any> T.dir():Set<String>{
        val a = this.javaClass.kotlin
        println(a.simpleName)
        val ll = a.members.map { it.name }
        return ll.toSet()
    }

    val tr1 = Thread()
    println("스레드 멤버 개수 : ${tr1.dir().count()}")
    println("스레드 그룹 : ${tr1.threadGroup}")
    println("스레드 생존여부 ${tr1.isAlive}")
    tr1.start()
    println("스레드 생존여부 ${tr1.isAlive}")
    tr1.join()
}
// 결과 
클래스 참조 :  class java.lang.Thread
인터페이스 참조 : class java.lang.Runnable
현재 스레드 개수 : 2
현재 스레드 : Thread[main,5,main]
Thread
스레드 멤버 개수 : 88
스레드 그룹 : java.lang.ThreadGroup[name=main,maxpri=10]
스레드 생존여부 false
스레드 생존여부 true

Process finished with exit code 0

스레드 생성 <- 스레드 클래스 상속

스레드를 정의할 때는 run 메서드를 재정의하지만, 내부의 start메서드가 자동 실행되면서 run 메서드를 실행한다.

-join은 스레드를 처리할 때 메인스레드가 먼저 종료할 수 있으므로 현재 진행 중인 스레드가 모두 처리될 때까지 기다리려고 join메서드를 실행

-실행된 결과를 보면 메인스레드와 보조 스레드를 사용해서 각각의 기능을 처리한 것을 볼 수 있다.

import kotlin.system.exitProcess

fun exec(tr: Thread){
    println("${tr}: 보조 스레드 작동중")
}
class MyThread: Thread(){
    override fun run() {
        super.run()
        val tr = Thread.currentThread()
        exec(tr)
        println("${tr} : 보조 스레드 종료")
    }
}

fun main(){
    val mtr =Thread.currentThread()
    println("${mtr} : 메인스레드 작동중")
    val myThread = MyThread()
    myThread.start()
    exec(myThread)
    println("${mtr}: 대기중")
    myThread.join()
}
// 결과 
Thread[main,5,main] : 메인스레드 작동중
Thread[Thread-0,5,main]: 보조 스레드 작동중
Thread[Thread-0,5,main]: 보조 스레드 작동중
Thread[main,5,main]: 대기중
Thread[Thread-0,5,main] : 보조 스레드 종료

스레드 실행하면서 상태 확인

스레드의 상태여부를 확인하면서 스레드가 작동하는지 알 수 있다.

- 한번 사용한 스레드는 다시 시작할 수 없다, 스레드는 실행이 필요할 때마다 생성해서 start 메서드로 실행해야 한다.

class SimpleThread:Thread(){
    override fun run() {
        super.run()
        println("현재 스레드 이름 : ${this.name}")
    }
}
fun main(){
    println("메인 스레드 : ${Thread.currentThread()}")
    val thread =SimpleThread()
    thread.run()
    println("스레드 활동여부1 : " + thread.isAlive)
    thread.join()
    println("스레드 활동여부2 : " + thread.isAlive)
    thread.run()
    thread.join()
    println("스레드 활동여부3 : " + thread.isAlive) // start를 하지 않았기에 false로만 나온다.

    val th2 = SimpleThread()
    th2.start()
    println("스레드 활동여부4 : " + th2.isAlive)
    th2.join()
    println("스레드 활동여부5 : " + th2.isAlive)
}
// 결과 
메인 스레드 : Thread[main,5,main]
현재 스레드 이름 : Thread-0
스레드 활동여부1 : false
스레드 활동여부2 : false
현재 스레드 이름 : Thread-0
스레드 활동여부3 : false
스레드 활동여부4 : true
현재 스레드 이름 : Thread-1
스레드 활동여부5 : false

인터페이스로 스레드 정의 후 스레드 생성

Runnable 인터페이스를 상속해서 run 메서드를 클래스 내에 구현하고 이 클래스의 객체를 생성해 Thread 클래스의 생성자에 전달해서 스레드 객체를 만든다.

class First:Runnable{
    override fun run() {
        println("Helper 5000 대기중")
        Thread.sleep(5000)
    }
}
class Second:Runnable{
    override fun run() {
        println("Tester 5000 대기중")
        Thread.sleep(5000)
    }
}
fun main(){
    val obj1 = Second()
    val th1 =Thread(obj1)

    val obj2 = First()
    val th2 = Thread(obj2)

    th1.start()
    println("스레드 1 이름 : "+th1.name)
    println("스레드 1 ID : "+ th1.id)
    println("스레드 1 우선순위 : "+ th1.priority)
    println("스레드 1 상태 : "+ th1.state)
    th2.start()
    println("스레드 2 이름 : "+th1.name)
    println("스레드 2 ID : "+ th1.id)
    println("스레드 2 우선순위 : "+ th1.priority)
    println("스레드 2 상태 : "+ th1.state)
    th1.join()
    th2.join()
}

// 결과 
스레드 1 이름 : Thread-0
스레드 1 ID : 16
스레드 1 우선순위 : 5
스레드 1 상태 : BLOCKED

스레드 2 이름 : Thread-0
스레드 2 ID : 16
스레드 2 우선순위 : 5
Tester 5000 대기중
스레드 2 상태 : BLOCKED
Helper 5000 대기중

object 표현식으로 스레드 생성

인터페이스 상속과 다르게 더 간단히 object 표현식으로 객체를 생성한다. 하지만 스레드 객체를 상속받는 점은 결국 같다.

fun createThread():Thread{
    return object : Thread(){ // 스레드 객체 상속
        override fun run() {
            super.run()
            println("5000 중단 ")
            Thread.sleep(5000)
        }}
}
fun main(){
    val th1 =createThread()
    val th2 = createThread()

    th1.start()
    println("스레드 1 이름 : "+th1.name)
    println("스레드 1 ID : "+ th1.id)
    println("스레드 1 우선순위 : "+ th1.priority)
    println("스레드 1 상태 : "+ th1.state)
    th2.start()
    println("스레드 2 이름 : "+th1.name)
    println("스레드 2 ID : "+ th1.id)
    println("스레드 2 우선순위 : "+ th1.priority)
    println("스레드 2 상태 : "+ th1.state)
    th1.join()
    th2.join()
}

// 결과 
5000 중단
스레드 1 이름 : Thread-0
스레드 1 ID : 16
스레드 1 우선순위 : 5
스레드 1 상태 : TIMED_WAITING
스레드 2 이름 : Thread-0
스레드 2 ID : 16
스레드 2 우선순위 : 5
스레드 2 상태 : TIMED_WAITING
5000 중단

코틀린에서 제공하는 스레드 함수 사용

val myThread = thread(){

println("${Thread.currentThread()} : 보조 스레드 작동" // 스레드 함수에 익명함수 전달

} // 코틀린에서 제공하는 함수로 스레드를 만든다. 이 함수의 인자로 함수를 받으므로 람다표현식으로 함수를 전달한다.

사용자 정의 스레드 함수 사용

-스레드 함수의 매개변수는 기본으로 start가 있다. 즉 스레드를 자동으로 실행하는 것인데 isDeamon은 백그라운드에서 스레드를 실행하는 것이다.

-데몬 :

멀티태스킹 운영체제에서 데몬은 사용자가 직접적으로 제어하지 않고, 백그라운드에서 돌면서 여러 작업을 하는 프로그램이다.

일반 스레드와 비교해서 가장 크게 다른 점은 프로그램이 종료할 때 발생한다. 사용자의 어플리케이션이 종료될 때, 사용자가 생성한 모든 일반 스레드으 수행이 종료되어야 JVM이프로세스가 종료된다. 하지만 데몬은 우선순위가 낮은 스레드로 JVM은 데몬스레드르의 종료를 기다리지 않고 셧다운 작업을 진행한다. 이런 특성으로 종료사 특별한 처리가 필요한 작업의 경우 데몬스레드에서 실행되도 되는지 생각해봐야한다.

1. 주 스레드의 작업을 돕는 보조적인 역할을 수행하는 스레드

2. 주 스레드가 종료되면 데몬 스레드는 강제적으로 자동 종료된다.

import kotlin.concurrent.thread

fun makethread(start: Boolean = true,
               isDamon: Boolean = false,
               contextClassLoader: ClassLoader? = null,
               name: String? = null,
               priority: Int = -1,
               block: () -> Unit
): Thread {
    val thread = object : Thread() {
        override fun run() {
            super.run()
            block()
        }
    }
    if (isDamon) thread.isDaemon = true // 데몬처리
    if (priority > 0) thread.priority = priority
    name?.let { thread.name = it }
    contextClassLoader?.let {
        thread.contextClassLoader = it // 클래스 로더 처리
    }
    return thread
}

fun main() {
    val ss = "스레드 처리 : ${Thread.currentThread()}"
    val th1 = makethread(block = { println(ss) })

    println(th1.javaClass)
    th1.start()
    println("스레드 종료")
    th1.join()
}
// 결과 
class ExcKt$makethread$thread$1
스레드 종료
스레드 처리 : Thread[#1,main,5,main]

Thread[#1,main,5,main]에서 #1 : 스레드의 이름이 따로 설정되지 않았기 때문에 JVM이 자동으로 할당한 이름입니다. 첫번째 "main"은 메인스레드 이름, "5"는 스레드의 우선순위, 마지막 "main"은 스레드 그룹의 이름 나타냅니다. "main" 스레드 그룹은 JVM이 시작할 때 생성되며, 메인 스레드를 포함하는 기본 스레드 그룹입니다.

쓰레드 풀사용

스레드를 무작정 만들면 컴퓨터의 자원을 너무 많이 사용한다. 특정 개수의 스레드를 풀(pool)을 만들어서 특정 스레드를 계속 활용한다.

스레드 여러개 만들기

동일한 처리의 스레드를 여러 개 생성해서 리스트 객체에 넣고 이를 내부 순환으로 실행

import kotlin.concurrent.thread

fun main() {
    var count = 0
    val threads = List(10) { // read-only list 
        thread {
            Thread.sleep(10)
            print(".")
            count += 1
            print(count)
        }
    }
    threads.forEach(Thread::join) // 각각의 스레드가 종려될때까지 기다림
}
// 결과
.1.2.3.4.5.6.7.8.9.10

스레드 풀을 만들어 스레드 실행

- 스레드 풀의 스레드는 execute로 실행. 실행할 코드는 람다표현식으로 전달

import java.util.concurrent.Executors

fun main() {
    val executor = Executors.newFixedThreadPool(2) // 특정 스레드 개수만큼만
    var count = 0
    repeat(3) {
        executor.execute {
            Thread.sleep(10)
            println(Thread.currentThread().name)
            count++
            println(count)
        }
    }
    println(executor.isTerminated) // 스레드 풀 미종료
    executor.shutdown() // 스레드 풀 종료
    println(executor.isShutdown) // 스레드 풀 종료 확인
}
// 결과 
false
true
pool-1-thread-2
1
pool-1-thread-1
2
pool-1-thread-2
3

스레드 풀을 사용해 처리

실제 스레드 풀에서 스레드를 실행하는 execute 메서드가 Runnable 객체를 인자로 전달하면 내부적으로 스레드를 실행해준다. 스레드를 5개 만들고 스레드 풀은3개로 지정.

import java.text.SimpleDateFormat
import java.util.*
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit

class Task(val name:String) : Runnable{
    override fun run() {
        val d = Date()
        val ft = SimpleDateFormat("hh:mm:ss")
        println("초기 시간 확인"+"task name- "+name+"="+ft.format(d))
        Thread.sleep(100)
    }
}
fun main(){
    val MAX_T=5
    val r1=Task("task1") // 테스크 객체 생성
    val r2=Task("task2")
    val r3=Task("task3")
    val r4=Task("task4")
    val r5=Task("task5")

    val pool = Executors.newFixedThreadPool(MAX_T) // 스레드 풀 생성
    pool.execute(r1) // 풀에서 스레드 실행
    pool.execute(r2)
    pool.execute(r3)
    pool.execute(r4)
    pool.execute(r5)
    pool.awaitTermination(3000L,TimeUnit.MICROSECONDS) // 스레드를 특정 시간까지 대기한 후 종료 
}

// 결과 
초기 시간 확인task name- task4=11:34:15
초기 시간 확인task name- task3=11:34:15
초기 시간 확인task name- task1=11:34:15
초기 시간 확인task name- task2=11:34:15
초기 시간 확인task name- task5=11:34:15

스레드 풀을 사용해서 순환 실행

스레드 풀을 사용해서 5개의 스레드가 반복해서 사용됨.

import java.util.concurrent.Executors

fun main(){
    val task =object :Runnable{
        override fun run() {
            println("Thread : "+Thread.currentThread().name)
        }
    }
    val service= Executors.newFixedThreadPool(5)
    for(i in 1..10){
        service.submit(task) // 스레드 실행
    }
    service.shutdown()
}
// 결과 
Thread : pool-1-thread-3
Thread : pool-1-thread-2
Thread : pool-1-thread-4
Thread : pool-1-thread-1
Thread : pool-1-thread-5
Thread : pool-1-thread-1
Thread : pool-1-thread-2
Thread : pool-1-thread-4
Thread : pool-1-thread-5
Thread : pool-1-thread-3

스레드 하나씩 실행 반환값 처리

스레드가 실행된 결과를 반환받아서 그 결과를 확인하거나 다른 용도로 사용할 수 있다.

- 스레드 풀에서 submit 메서드로 스레드를 실행하면 스레드의 결과를 반환값으로 받을 슈 있다.

- 반환 결과를 get메서드로 가져오면 스레드 반환결과를 확인 할 수 있다. 또한, 이 get 메서드에 특정시간을 넘기면 특정식간을 기다렸다가 정보를 가져온다.

- 반환결과를 cancel 메서드로 스레드를 중단할 수 있다.

import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit

fun main() {
    val callable = {
        Thread.sleep(10)
        println("Thread:" + Thread.currentThread().name)
        Thread.currentThread().name+"반환값"
    }
    val executeService = Executors.newFixedThreadPool(2)
    val future1 = executeService.submit(callable)
    println("퓨쳐 객체 :" + future1.javaClass)

    val future2 = executeService.submit(callable)
    val future3 = executeService.submit(callable)

    var value = future1.get() // 작업 끝날때까지 기다려 값 받기
    println("value1 : " +value)
    var canceled = future2.cancel(true) // 작업취소, 취소 여부를 돌려받는다.
    println("canceled : "+canceled)
    value = future3.get(500, TimeUnit.MILLISECONDS) // 500밀리세컨드 동안만 기다려 값 받기
    println("value2 : " +value)
    
}
// 결과
퓨쳐 객체 :class java.util.concurrent.FutureTask
Thread:pool-1-thread-1
Thread:pool-1-thread-2
value1 : pool-1-thread-1반환값
canceled : false
Thread:pool-1-thread-2
value2 : pool-1-thread-2반환값

cancel(true) 현재 실행 중인 경우에도 즉시 중단을 시도해야 함을 나타냅니다. 즉, 스레드에 Interrupt 신호를 보내 작업을 중단시키려고 시도합니다. 그리고 작업이 성공적으로 취소되었으면 true, 그렇지 않으면 false를 반환합니다.
반면에, cancel(false)를 호출하면 현재 실행 중인 작업을 중단하지 않고, 만약 작업이 대기 중이라면 실행되지 않도록 취소합니다. 실행 중인 작업에는 영향을 주지 않습니다.

❓var canceled = future2.cancel(true) 값이 false인 이유

future2.cancel(true) 호출이 취소에 실패한 이유는 future2가 이미 실행되었거나 실행 중이었기 때문일 가능성이 높습니다.
위 코드에서 future1, future2, future3 모두 거의 동시에 제출(submit)됩니다. 고정 스레드 풀의 크기가 2이기 때문에 future1과 future2는 거의 동시에 실행을 시작할 것입니다. 따라서 future2.cancel(true)가 호출될 때, future2는 이미 실행 중일 가능성이 높습니다.
cancel(true) 메서드는 실행 중인 작업을 중단하려고 시도하지만, 작업 내부에서 인터럽트 상태를 적절하게 처리하지 않으면 실제로 중단되지 않을 수 있습니다.

-chat gpt 센빠이가 알려주셨다.

참고 ) 데몬 - https://hbase.tistory.com/285

api 응답 값 에러 시 확인 절차

ugyeong — Thu, 21 Sep 2023 14:44:58 +0900

1. 프론트에서 api통신하는데 에러가 났다면 서버가 정상인지 확인한다.(+ 프론트에서 log찍고 응답코드 확인 )

Swagger 사용 안 한다면 postman을 통해 서버가 제대로 된 응답값을 반환하는지부터 확인한다.

2. swagger나 postman에서 서버의 응답값이 잘 도착한다면 응답 코드를 봐본다.

성공적인 응답값 코드는 [200,300) 사이다.

3. 서버의 응답값이 너무 멀쩡하다 = 프론트 문제이다.

에러 원인은 다양하겠지만 생각나는거 적자면...

1) 프론트에서 response.code를 확인한다.

- response.code가 400이라면 프론트에서 요청값 형식을 서버에 맞지 않게 전달한거다.

- 서버에서 요구하는 형식이 파라미터인지, body인지 등 확인하기

(parameter는 Http Request의 쿼리 매개변수, body는 Http Request의 body)

2) 프론트에서 response.code를 특정 숫자로 제한했는지 확인하기

예를 들면 if(response.code = 200) 인 경우만 성공으로 걸어둔건지 확인 필수

성공적인 응답값 코드는 [200,300) 사이다.

아래는 스웨거2 사진스..

왼쪽은 http통신 시 parameter 오른쪽은 body 형식

Ch_10 함수 추가 사항 알아보기

ugyeong — Wed, 13 Sep 2023 13:17:12 +0900

목차-

1. 함수형 프로그래밍이란?

a. 일급 객체 함수(first Class function)
b. 지연 평가 함수 실행

2. 고차함수, 합성함수, 재귀함수 알아보기

3. 함수의 추가 기능 알아보기

a. 스코프 함수
b. SAM 인터페이스(Single Abstract Method)

01 함수형 프로그래밍이란?

a. 일급 객체 함수(first Class function)

▪️ 함수를 변수에 할당할 수 있음

▪️ 함수를 매개변수 인자로 전달할 수 있음

▪️ 함수를 반환값으로 사용할 수 있음

▪️ 함수를 컬렉션 자료구조에 할당할 수 있음

이처럼 일급객체로 만든 것은 함수도 정수나 문자처럼 객체로 사용할 수 있는 것을 말한다.

fun main() {
    val add1 = fun(x: Int, y: Int): Int = x + y // 익명함수를 변수에 할당
    val add2 = { x: Int, y: Int -> x + y } // 람다표현식을 변수에 할당
    val add3: (Int, Int) -> Int = { x: Int, y: Int -> x + y } // 위 람다식에서 자료형을 추가
    println(add1(10, 20)) // 30 
    println(add2(10, 20)) // 30
    println(add3(10, 20)) // 30

    fun highfunc(sum: (Int, Int) -> Int, a: Int, b: Int): Int = sum(a, b) // 매개변수에 함수 자료형 정의
    println(highfunc({ x: Int, y: Int -> x + y }, 10, 20))  // 30, 람다 표현식을 인자로 전달

    fun refunc(): (Int, Int) -> Int { // 함수 반환자료형의 함수
        return { x: Int, y: Int -> x + y } // 람다표현식으로 반환
    }

    val rf = refunc() // 함숳 호출(객체로)
    println(rf(10, 20)) // 30


}

b. 지연 평가 함수 실행

함수 정의 를 필요할 경우 호출 처리

-최상위 속성을 정의할 때 by로 속성위임에 lazy함수를 사용할 수 있다. 이 속성을 참조할 때 람다표현식이 실행돼 속성의 초깃값이 만들어진다.

-무한 시퀀스도함수인데 이 시퀀스를 만들면 실제 실행이 되지 않고 액션 toList메서드가 실행되어야 무한 시퀀스가 실행되어 take에 전달된 정수만큼만 원소를 가져와 리스트로 반환.

-외부함수와 내부함수를 정의 후 외부함수를 실행해도 최종적으로 내부 함수가 실행되어야 함수가 종료된다.

fun main() {
    val func by lazy { { x: Int -> x } }
    println(func(100))

    val seq = generateSequence(0) { it + 100 } // 무한 시퀀스 정의
    println(seq.take(5).toList()) // 특정 시점에 값을 실행

    fun outer(x: Int): (Int) -> Int { // 부분함수 정의
        fun inner(y: Int): Int = x + y // 내부함수가 실제 연산 결과 반환
        return ::inner // 함수 참조로 반환
    }

    val out = outer(100)
    println(out(200))
}
// 결과값
100
[0, 100, 200, 300, 400]
300

무한 시퀀스 함수에 대해

public fun <T : Any> generateSequence(
seed: T?,
nextFunction: (T) -> T?
): Sequence<T>
Returns a sequence defined by the starting value seed and the function nextFunction, which is invoked to calculate the next value based on the previous one on each iteration.
The sequence produces values until it encounters first null value. If seed is null, an empty sequence is produced.
The sequence can be iterated multiple times, each time starting with seed.

c. 함수 인터페이스를 상속해 실행 연산 함수 구현

fun main() {
    object : () -> Unit { // object표현식 정의
        override fun invoke(): Unit { // 함수 인터페이스에 실행연산자가 없어서 구현
            println("함수 객체가 만들어지고 실행")
        }
    }

    val f = AddFunc() // 객체 생성
    println(f(10, 20))

    fun func(): (Int) -> Int {
        return { x: Int ->
            println("함수 표현식 전달");
            x
        }
    }

    val c = object : () -> ((Int) -> Int) {
        override fun invoke(): (Int) -> Int {
            println("함수 반환")
            return { y: Int -> y }
        }
    }
    println(func().invoke(100))
    val funC=c()
    println(funC.invoke(200))
}

class AddFunc : (Int, Int) -> Int {
    override fun invoke(p1: Int, p2: Int): Int {
        println("클래스 실행연산자 호출")
        return p1 + p2
    }
}
// 결과값
클래스 실행연산자 호출
30
함수 표현식 전달
100
함수 반환
200

d. 커링함수 알아보기

하나의 함수에서 매개변수를 분리해 외부함수와 내부함수로 저장해서 처리가능. 이처럼 함수를 부분으로 나눠 처리하는 것을 커링 함수라고 한다.

fun main() {
    fun a(n: Int): (d: Int) -> Int {
        var acc = n
        return { x ->
            acc += x;
            acc // Int값 반환
        }
    }

    val a100 = a(100)
    println(a100(5)) // 105
}

e. 연속 호출하는 체이닝 처리

함수나 메서드가 연속으로 호출돼서 처리하는 것을 메서드 체이닝이라고 한다. 객체를 반환하면 그 내부 메서드를 연속에서 실행할 수 있다. 다만 너무 많이 사용하면 실제 코드를 이해하는데 너무 어려울수 있어 적당히 사용해야한다.

-함수 연속 호출

fun main() {
    fun Outer(x: Int): (Int) -> Int {
        fun inner(y: Int): Int {
            return x + y
        }
        return ::inner
    }
    println(Outer(100)(200)) // 300, 함수 연속 실행
    // 계층 처리
    val out = Outer(100)
    println(out(200)) // 300 

    val lamda = { x: Int -> { y: Int -> { z: Int -> x + y + z } } }
    println(lamda(100)(200)(300)) // 600, 함수 연속 실행
}

- 메서드 체인 처리

fun main() {

    val c = Car("감자", "레드")
    c.changeOwner("돌자반").repair("파랑").info() // 소유자=돌자반, 색상 =파랑
}
class Car(var ownerName: String, var color: String) {
    fun changeOwner(newName: String): Car {
        this.ownerName = newName
        return this
    }

    fun repair(newColor: String): Car {
        this.color = newColor
        return this
    }

    fun info(): Unit =
        println("소유자=$ownerName, 색상 =$color")
}

02 고차함수, 확장함수, 재귀함수 알아보기

a. 고차함수란 함수를 객체로 생각해서 인자로 전달되거나 반환값으로 처리되는 함수 패턴을 말한다.

typealias f = (Int, Int) -> Int

fun main() {
    fun one(vararg x: Int, op: f): Int {
        return x.toList().reduce(op)
    }
    println(one(1, 2, 3, 4, op = { x: Int, y: Int -> x + y })) // 10, 함수를 매개변수로 받는 고차함수

    fun add(x: Int, y: Int): Int = x + y
    println(one(1, 2, 3, 4, 5, op = ::add)) // 15

    fun two(): f {
        return { x, y -> x + y }
    }
    println(two()(10, 20)) // 30
}

b. 합성함수의 정의

두 함수를 하나의 함수로 연결하는 것을 합성함수라고 한다. 함수를 구성할려면 함수의 매개변수와 자료형이 일치해야하므로 함수를 합칠때는 주의해야 한다.

- 두 함수의 매개변수 개수와 반환자료형이 같아야한다.

-두 함수를 결합한 함수도 두 함수의 매개변수와 자료형이 같아야한다.

fun main() {
    fun composeF(f: (Int) -> Int, g: (Int) -> Int): (Int) -> Int {
        return { p1: Int -> f(g(p1)) }
    }

    val f = { x: Int -> x + 2 }
    val g = { y: Int -> y + 3 }
    val composeFunc = composeF(f, g)

    println(f(g(3))) //8
    println(composeFunc(3)) //8, 3은 p1값
}

c. 재귀함수와 꼬리재귀 처리

재귀함수: 재귀할 때마다 함수가 메모리 스택에 올라간다. 성능상의 문제가 있다.

꼬리 재귀: tailrec 예약어를 붙인다. 내부적으로 코드를 변환해서 메모리 스택을 최소화한다.

차이점: 누적값을 매개변수로 지정해서 재귀함수와 다른 연산을 처리하지 않고 항상 함수 호출만 발생하는 것

fun main() {
    fun factorial(n: Int): Long {
        if (n == 1) {
            return n.toLong()
        } else {
            return n * factorial(n - 1)
        }
    }

    var result = factorial(4)
    println(result) // 24

    // 꼬리 재귀
    tailrec fun tailFactorial(n: Int, total: Int = 1): Long {
        if (n == 1) {
            return total.toLong()
        } else {
            return tailFactorial(n - 1, n * total)
        }
    }
    result = tailFactorial(4)
    println("꼬리 재귀 연산 : $result") // 24

}

03 함수의 추가 기능 알아보기

a. 스코프 함수

출처 : https://medium.com/@limgyumin/%EC%BD%94%ED%8B%80%EB%A6%B0-%EC%9D%98-apply-with-let-also-run-%EC%9D%80-%EC%96%B8%EC%A0%9C-%EC%82%AC%EC%9A%A9%ED%95%98%EB%8A%94%EA%B0%80-4a517292df29

1. apply

public inline fun <T> T.apply(
block: T.() -> Unit
): T

apply는 모든 명령이 수행되고 나면 명령들이 적용되어 새로 생성된 인스턴스를 반환한다.

2. also

public inline fun <T> T.also(
block: (T) -> Unit
): T

3. run

public inline fun <T, R> T.run(
block: T.() -> R
): R

import java.awt.print.Book

fun main() {
    var a = Book("해로의 모험", 10000).apply {
        name = "[세일중]" + name
        discount()
    }
    var bookCost = a.run {
        println("상품명: ${name}, 가격: ${price}")
        price + 2000
    }
    println("원가는 $bookCost 입니다.") // 이 값이 반환
}

class Book(var name: String, var price: Int) {
    fun discount() {
        price -= 2000
    }
}
// 결과값
상품명: [세일중]해로의 모험, 가격: 8000
원가는 10000 입니다.

apply와의 차이점 apply는 객체를 반환하지만 run은 스코프내 실행결과값이다.

4. let

public inline fun <T, R> T.let(
block: (T) -> R
): R

5. with

public inline fun <T, R> with(
receiver: T,
block: T.() -> R
): R

b. SAM 인터페이스(Single Abstract Method)

하나의 추상메서드만 있는 인터페이스를 보다 단순하게 처리하기 위해 함수를 정의하는 fun 예약어를 인터페이스 앞에 붙여 SAM인터페이스를 만든다.

장점: 상속하고 구현해서 처리할 수도 있고, 상속없이 재정의 해 직접 람다식으로 받아서 처리가능

fun main() {
    val str = object : StringAble { // 인터페이스처럼 상속해서 재정의 가능
        override fun accept(s: String) {
            println(s)
        }
    }
    str.accept("object 표현식으로 익명 객체 처리")
    val consume = StringAble { s -> println(s) } // 람다표현식으로 할당
    consume.accept("바로 람다 표현식을 전달해서 재정의")
    consume.hello()
}

fun interface StringAble { // SAM인터페이스는 앞에 fun 붙임
    fun accept(s: String) // 추상메서드 한개
    fun hello() = println("일반메소드") // 일반메서드
}

//결과값
object 표현식으로 익명 객체 처리
바로 람다 표현식을 전달해서 재정의
일반메소드

참고) 스코프 함수- https://haero.tistory.com/21

Ch_07 클래스 관계 등 추가 사항 알아보기

ugyeong — Fri, 25 Aug 2023 19:19:39 +0900

-목차

1. 속성과 메서드 재정의

2. 특정 자료를 다루는 클래스 알아보기

1. 속성과 메서드 재정의

1.1 속성 정의

⚫ 속성의 메서드 세터를 비공개 처리하기

특정 속성의 변경 제한을 처리하려면 속성의 세터 메서드를 private 처리한다.

아래 코드는 ++을 어디에 두느냐에 따라 getter호출 수가 다르다.

책 예제의 get호출되는 수가 예상과 달라서 ++과 print문을 옮겨가며 찍어봤다.

fun main() {
    val counter = Counter()
    for (i in 1..2) {
        counter.inc()
        println(counter.value)
    }

}

class Counter {
    var value: Int = 0
        get() {
            println("get value $field")
            return field
        }
        private set // 값 수정은 비공개 처리 -> 클래스 안 메서드로 접근

    fun inc() = ++value // value값 가져올때 1, 더해서 return시 2, 위에서 println 할때 또 get 3
}
// 결과값 
get value 0
get value 1
get value 1
1
get value 1
get value 2
get value 2
2

아래는 디컴파일 한 것이다.

// ExpKt.java

public final class ExpKt {
   public static final void main() {
      Counter counter = new Counter();
      int var1 = 1;

      for(byte var2 = 2; var1 <= var2; ++var1) {
         counter.inc();
         int var3 = counter.getValue();
         System.out.println(var3);
      }

   }

   // $FF: synthetic method
   public static void main(String[] var0) {
      main();
   }
}
// Counter.java

public final class Counter {
   private int value;

   public final int getValue() {
      String var1 = "get value " + this.value;
      System.out.println(var1);
      return this.value;
   }

   public final int inc() {
      this.value = this.getValue() + 1;
      return this.getValue();
   }
}

fun main() {
    val counter = Counter()
    for (i in 1..2) {
        counter.inc()
        println(counter.value)
    }

}

class Counter {
    var value: Int = 0
        get() {
            println("get value $field")
            return field
        }
        private set // 값 수정은 비공개 처리 -> 클래스 안 메서드로 접근

    fun inc() = value++ // 더해서 return시 1, 위에서 print 2
}
// 결과값
get value 0
get value 1
1
get value 1
get value 2
2

아래는 디컴파일 한 것이다.

// ExpKt.java

public final class ExpKt {
   public static final void main() {
      Counter counter = new Counter();
      int var1 = 1;

      for(byte var2 = 2; var1 <= var2; ++var1) {
         counter.inc();
         int var3 = counter.getValue();
         System.out.println(var3);
      }

   }

   // $FF: synthetic method
   public static void main(String[] var0) {
      main();
   }
}

// Counter.java

public final class Counter {
   private int value;

   public final int getValue() {
      String var1 = "get value " + this.value;
      System.out.println(var1);
      return this.value;
   }

   public final int inc() {
      int var1;
      this.value = (var1 = this.getValue()) + 1;
      return var1; // var1++이라 var1을 return
   }
}

아래는 책에 있는 예제이다.

fun main() {
    val counter = Counter()
    for (i in 1..2) {
        counter.inc()
    }
    println(counter.value)
}

class Counter {
    var value: Int = 0
        get() {
            println("get value $field")
            return field
        }
        private set // 값 수정은 비공개 처리 -> 클래스 안 메서드로 접근

    fun inc() = value++
}
// 결과값
get value 0 // inc
get value 1 // inc
get value 2 // print 할 때 접근
2 // print(valuea)

⚫ 배킹핑드 사용하지 않기

class Thing(val name: String) 

class Container(private val maxCapacity: Int) {
    private val things = mutableListOf<Thing>()
    val capacity: Int
        get() = maxCapacity - things.size
    val isFull: Boolean
        get() = things.size == maxCapacity

    fun put(thing: Thing): Boolean =
        if (isFull) false
        else {
            things += thing // 삽입
            true
        }

    fun take(): Thing = things.removeAt(0)
    fun query(): List<String> = things.map { it.name }
}

fun main() {
    var container = Container(3)
    container.put(Thing("침대"))
    container.put(Thing("의자"))
    container.put(Thing("받침대"))

    println(container.isFull)
    println(container.query())
    println(container.take().name)
    println(container.query())

}
// 결과값 
true
[침대, 의자, 받침대]
침대
[의자, 받침대]

1.2 연산자 오버로딩

⚫ 연산자 오버로딩 처리 규직

1. operator fun 으로 작성

2. 클래스 내부의 메서드나 확장함수로 정의 가능

3. 메서드나 함수의 오버로딩 규칙에 따라 매개변수의 개수나 자료형이 다르면 여러개 정의 가능

⚫ 아래는 오버로딩 규칙에 따라 두개의 plus 메서드를 정의한 예이다.

fun main() {
    val amt01 = Amount(200, 100)
    val amt02 = Amount(300, 100)
    val amt03 = amt01 + amt02
    val amt04 = amt02 + 100 
    
    println(amt03) // Amount(500, 200)
    println(amt04) // Amount(400, 200)
}

class Amount(var total: Int, var balance: Int) {
    operator fun plus(other: Amount) = Amount(
        this.total + other.total, 
        this.balance + other.balance
    )

    operator fun plus(scale: Int) = Amount(this.total + scale, this.balance + scale)
    override fun toString(): String = "Amount($total, $balance)"
}

⚫ 확장함수 연산자 오버로딩

class Amount(var total: Int, var balance: Int) {
    operator fun plus(other: Amount) = Amount(
        this.total + other.total,
        this.balance + other.balance
    )

    operator fun plus(scale: Int) = Amount(this.total + scale, this.balance + scale)
    override fun toString(): String = "Amount($total, $balance)"
}

// 확장함수 연산자 오버로딩
operator fun Amount.times(other: Amount): Amount {
    // 타 클래스안 메서드처럼 리시버클래스 안 속성 접근이 가능하다. 
    return Amount(total * other.total, balance * other.balance)
}

fun main() {
    val amt01 = Amount(200, 100)
    val amt02 = Amount(300, 100)
    val amt05 = amt01 * amt02
    print(amt05) // Amount(60000, 10000)
}

⚫infix 처리

1. infix fun 처럼 함수나 메서드 정의시 맨 앞에 둔다.

2. 매개변수가 1개여야 한다.

2. 매개변수에 초기값을 지정할 수 없다.

fun main() {
    val a = Add(100)
    println(a add 20)
    println(a.add(200))
    println(a times 200)
    println(a * 200)
    println(a div 200)

    // 결과값
    120
    300
    20000
    20000
    0

}

class Add(var x: Int = 0) {
    infix fun add(y: Int) = x + y
    infix operator fun times(y: Int) = x * y
    infix fun divide(y: Int) = x / y
}

infix fun Add.div(y: Int) = this.divide(y) // 확장함수에 infix 지정하기

1.3 메서드 재정의

⚫ 메서드 재정의 규칙

1. method overload : 클래스 안에 동일한 이름의 메서드를 여러개 정의. 매개변수의 개수, 자료형에 따라 다르게 처리

2. method override : 클래스 상속관계에서 슈퍼클래스의 메서드를 서브클래스 메서드에 동일한 이름과 매개변수로 정의.

- 서브클래스에서 추가로 기능을 재정의 가능. 항상 서브클래스가 먼저 참조되고 없으면 슈퍼클래스의 메서드 검색.

- 서브클래스에서 앞으로의 재정의를 막을려면 "final override fun 메서드이름" 처럼 쓴다.

- 부모클래스에 있는 것을 재정의 할 때, 부모클래스꺼엔 open을 붙이고, 자식클래스에선 override를 붙인다.

- 부모클래스에 있는 속성들은 기본이 final이라 open을 붙이지 않으면 재정의 할 수 없다.

open class Person(var name: String = "돌자반", var food: String = "치킨") {
    fun eat() {
        println("$name 은 굽네를 먹는다.")
    }

    open fun sleep() {
        println("$name 은 오늘도 일찍 일어난다.")
    }
}

class Student(name: String) : Person("감자", "설렁탕") {

    override fun sleep() {
        println("$name 은 늦게 일어났다...뽈")
    }

    fun activity() {
        println("$name 신나게 $food 먹는다")
    }

    fun doAll() {
        eat()
        sleep()
        activity()
    }
}

fun main() {
    var st = Student("돌자르르르ㅡ반")
    st.doAll()
    // 결과값
    감자 은 굽네를 먹는다.
    감자 은 늦게 일어났다...뽈 
    감자 신나게 설렁탕 먹는다
}

2. 특정 자료를 다루는 클래스 알아보기(데이터, 이넘 클래스)

데이터 클래스

클래스일 때 == 객체끼리 연산이 false

fun main() {
    val p1 = Person("감자")
    val p2 = Person("감자")

    println(p1)
    println(p2)
    println(p1 == p2)
    println(p1 === p2)
    
    // 결과값
    Person@27d6c5e0
    Person@4f3f5b24
    false
    false
}

class Person(name: String)

데이터 클래스 일 때 == 연산이 true

fun main() {
    val p1 = Person("감자")
    val p2 = Person("감자")

    println(p1)
    println(p2)
    println(p1 == p2)
    println(p1 === p2)

    // 결과값
    Person(name=감자)
    Person(name=감자)
    true
    false
}

data class Person(val name: String)

데이터 클래스는 주생성자에 정의된 속성값이 같으면 동일한 값의 객체로 본다. 즉 주생성자의 속성 값이 같을 때 == 연산시 true가 반환된다.

데이터 클래스가 상속 받더라도 값이 같은지(==)의 기준은 데이터 클래스의 주생성자이다.

2.2 이넘 클래스 -> kotlin 1.9.0 에서는 entries 추천

⚫ 이넘 클래스 작성법

1. enum class 이렇게 작성한다.

2. 생성할 객체를 모두 내부에 정의하고 객체의 이름을 상수처럼 사용하고 대문자로 작성해야한다.

fun main() {
    println(Card.PLATINUM.ordinal) // 객체 순서번호 출력
    println(Card.PLATINUM.name) // 객체 이름 출력
    println(Card.GOLD < Card.SIVER) // 객체 간 순서 비교
    
    // 결과값
    2
    Card.PLATINUM
    false

}

enum class Card {
    SIVER, GOLD, PLATINUM // 0번, 1번, 2번 순서
}

웬만하면 oridinary를 쓰지 않는다. 새로운 값이 들어왔을 때 순서가 바뀌기 때문

순서가 필요하다면 속성을 추가하자.

3. 이넘 클래스에 속성 추가

import java.awt.Color.orange
import java.awt.Color.red

fun main() {
    println(Card.PLATINUM.color) // 내부 속성 조회
    println(Card.valueOf("GOLD")) // 객체 있는지 조회
    val type = enumValueOf<Card>("GOLD") // GOLD 검색
    println(type)
    
    println(Card.PLATINUM.name)
    println(Card.PLATINUM.color)

    // 결과값 1
    orange
    Card.GOLD
    Card.GOLD
    Card.PLATINUM
    orange
    
    val array1 = Card.values() // Array타입
    array1.forEach { println("${it.name}=${it.color}") }
    
    // 결과값 2
    Card.SIVER =red
    Card.GOLD =gold
    Card.PLATINUM =orange

    val array2 = enumValues<Card>() // Array타입
    array2.forEach { println("${it.name}=${it.color}") }
    
    // 결과값 3
    Card.SIVER =red
    Card.GOLD =gold
    PLATINUM=orange
    
    array2.filter { it.color == "red" }.map { it.color }.forEach { println(it) }
    
    // 결과값 4
    red
    
}

enum class Card(var color: String) {
    SIVER("red"), GOLD("gold"), PLATINUM("orange") // 0번, 1번, 2번 순서
}

4. 이넘 클래스에 동반객체를 작성할 수 있다. -> 메서드를 클래스 이름으로 바로 접근 가능

fun main() {
    for (i in Card.getIter()) { 
        println(i)
    }
}
// 결과값
SIVER
GOLD
PLATINUM

enum class Card(var color: String) {
    SIVER("red"), GOLD("gold"), PLATINUM("orange"); // 마지막 객체엔 ;를 넣어줘야한다!!

    companion object {
        fun getIter() = values() // 반복자
    }
}

5. 이넘 클래스 내부에 추상메서드를 정의하면 모든 객체 내부에 메서드를 재정의한다.

fun main() {
println(Card.SIVER.calculate(3)) // 6000
}

enum class Card(var color: String) {
    SIVER("red") {
        override fun calculate(grade: Int): Int = when (grade) {
            in 0..3 -> 6000
            in 4..5 -> 404
            else -> 3333
        }
    },
    GOLD("gold") {
        override fun calculate(grade: Int): Int = when (grade) {
            in 0..3 -> 6000
            in 4..5 -> 404
            else -> 3333
        }
    };

    abstract fun calculate(grade: Int): Int // 객체 선언 후 뒤에 적어야 함
}

6. 인터페이스를 상속받아 내부에 구현할 수 있다. 상수가 객체마다 다른 경우에는 각각 구현하고 전체가 같을 경우엔 하나만 구현.

fun main() {
    println(Card.SIVER.calculate(3)) // 6000
}

interface Calculable {
    fun calculate(grade: Int): Int
}

enum class Card(var color: String) : Calculable {
    SIVER("red"),
    GOLD("gold");

    override fun calculate(grade: Int): Int = when (grade) {
        in 0..3 -> 6000
        in 4..5 -> 404
        else -> 3333
    }
}

kotli 1.9.0에서 인라인 클래스에 세컨더리 컨스트럭터가 생겼다!

data object가 생겼고 toString(), equals(), hashcode 으로 비교도 가능하다.

용도 : 데이터의 성격을 띤 오브젝트 명시, data class에서 속성이 없을 때