객체들의 관계를 트리 구조로 구성하여 부분-전체(Part-Whole) 계층을 표한하는 패턴 단일 객체와 복합 객체 모두 동일하게 다루도록 한다.

구현할 클래스 목록

Component 를 구현하여 필요한 함수를 사용하고 하나의 Leaf 로 구성할 수 있도록 Interface를 만들어 객체를 생성한다.

Component 만들기

interface Component {
    fun getWeight(): Int
    fun getItemCount(): Int
    fun getItemName(): String
}

아이템의 전체 구성요소가 될 Interface 를 만든다.

Component 인터페이스의 경우 Item에 반드시 필요한 객체의 상태를 구현하면 된다.

Leaf 만들기

class M4A1: Component {
    override fun getWeight(): Int {
        return 3800
    }

    override fun getItemCount(): Int {
        return 1
    }

    override fun getItemName(): String {
        return "M4A1"
    }
}

class Bullet_5(private val count: Int) : Component {
    override fun getWeight(): Int {
        return 5 * getItemCount()
    }

    override fun getItemCount(): Int {
        return count
    }

    override fun getItemName(): String {
        return "5.56mm"
    }
}

... (생략)

간단하게 총과 총알을 사용하는 Item Class 를 만들었다.

Component 인터페이스를 상속받아 구현하는 구현체를 작성한다.

각 아이템의 무게, 개수, 이름을 입력한 Leaf 를 만들 수 있다.

Composite 만들기

class BattlegroundBag(
    private val name: String
) : Component {
    private val _components: ArrayList<Component> = arrayListOf()

    fun addItem(component: Component) {
        _components.add(component)
    }

    fun hasItemList(): String {
        val iter = _components.iterator()
        val sb = StringBuilder()
        while (iter.hasNext()) {
            sb.append(iter.next().getItemName())
                .append(", ")
        }
        sb.delete(sb.lastIndex - 1, sb.lastIndex)
        return sb.toString()
    }

    override fun getWeight(): Int {
        return _components.sumOf { it.getWeight() }
    }

    override fun getItemCount(): Int {
        return _components.sumOf { it.getItemCount() }
    }

    override fun getItemName(): String {
        return name
    }
}

Compostite 클래스인 BattlegroundBag 의 는 Leaf 를 저장할 수 있는 _components 리스트가 있고 가방안에 있는 모든 아이템의 무게와 갯수를 출력할 수 있도록 구현하게 되었고

가방안에 있는 Item의 종류를 출력해주는 함수도 존재합니다.

이처럼 Leaf / Tree 구조를 통해 전체와 부분을 하나의 객체처럼 사용할 수 있도록 구현하게 됩니다.

Battleground play 해보기

class Battleground {

    init {
        val level3Bag  = BattlegroundBag("3레벨 가방")
        val m4 = M4A1()
        val Kar98 = Kar98()
        val bullet5 = Bullet_5(120)
        val bullet7 = Bullet_7(30)

        level3Bag.addItem(m4)
        level3Bag.addItem(Kar98)
        level3Bag.addItem(bullet5)
        level3Bag.addItem(bullet7)

        println(level3Bag.getItemName())
        println("가방의 총 무게 : " + level3Bag.getWeight() + "g")
        println("아이템 리스트 : " + level3Bag.hasItemList())
        println("총알 개수")
        println("5탄 : ${bullet5.getItemCount()}, 7탄 : ${bullet7.getItemCount()}")
    }
}

private fun main() {
    Battleground()
}

마무리

컴포짓 패턴의 경우 전체-부분 의 개념으로 객체를 접근하도록 구현하는 패턴입니다.

트리 구조로 만들어야하는 제약이 존재 하지만, 하나의 객체를 그룹 또는 각각의 객체로 사용하기 편하기 때문에 사용하게 됩니다.

장점

• 복잡한 트리 구조를 편리하게 사용할 수 있음.
• 다형성과 재귀를 활용할 수 있음
• 클라이언트 코드를 변경하지 않고 새로운 타입을 추가할 수 있음

단점

• 트리를 만들어야 하기 때문에(공통된 인터베이스를 정의) 지나치게 일반화 해야하는 경우가 생길 수 있음

참고

• 헤드퍼스트 개정판 [hanbit.co.kr/store/books/look.php?p_code=B6113501223]
• 인프런 - 코딩으로 학습하는 GoF 디자인 패턴 [https://www.inflearn.com/course/디자인-패턴]
• https://velog.io/@lsj8367/Composite-패턴

추상적인 것과 구체적인 것을 분리하여 연결하는 패턴.

구현할 클래스 목록

• Abstraction : 기능 계층의 최상위 클래스, 추상 인터페이스
• Refind Abstraction : 기능 계층에서 새로운 부분을 확장한 클래스
• Implementation : Abstraction의 기능을 구현하기 위한 인터페이스
• Concreate Implementation : 실제 기능을 구현한 클래스

Implementation & Concreate Implementation

TV Interface 구현

interface TV {
    fun on()
    fun off()
    fun tuneChannel(channel: Int)
    fun getChannel(): Int
}

TV를 동작시키기 위해 필요한 공통 기능을 TV interface 에 함수로 정의 하고 Concreate Implementation 에 구현하도록 정의 합니다.

추상화(RemoteControl)는 TV interface 에 선언된 메서드를 통해서만 구현 객체와 소통할 수 있습니다.

Concreate Implementation 구현

/**
    공통으로 사용하는 on, off 함수를 구현하고 TV의 타입을 받아 구별한다.
*/
abstract class DefaultTV(
    val type: String
) : TV {

    override fun on() {
        println("Turning on the $type TV.")
    }

    override fun off() {
        println("Turning off the $type TV.")
    }

/**
    LG 브랜드의 TV를 정의하고
    각 TV에 저장된 `channel` 변수를 사용하여 채널을 조작한다.
*/
class LG : DefaultTV("LG") {
    private var channel: Int = 1

    override fun tuneChannel(channel: Int) {
        this.channel = channel
        println("Set the $type TV Channel to ${this.channel}")
    }

    override fun getChannel(): Int {
        return this.channel
    }

}

각 브랜드 별 TV의 맞춤 코드를 작성하여 동작하도록 합니다.

Abasraction & Refind Abstraction

RemoteControl 구현

abstract class RemoteControl(private val tvFactory: TVFactory) {
    private lateinit var tv: TV

    fun on() {
        this.tv.on()
    }

    fun off() {
        this.tv.off()
    }

    fun setChannel(channel: Int) {
        tv.tuneChannel(channel)
    }

    fun getChannel(): Int {
        return this.tv.getChannel()
    }

    fun setTV(type: String) {
        try {
            tv = tvFactory.getTV(type)
        } catch (e: Exception) {
            println(e)
        }
    }
}

TV Factory 에서 TV의 종류를 가져와 리모컨의 역할을 수행할 수 있도록 구현된 구현체이다.

구현 객체(TV interface)에 의존해 하위 수준의 작업을 진행한다.

GenericRemote 구현

class GenericRemote(tvFactory: TVFactory) : RemoteControl(tvFactory) {

    fun nextChannel() {
        val channel = this.getChannel()
        this.setChannel(channel + 1)
    }

    fun prevChannel() {
        val channel = this.getChannel()
        this.setChannel(channel - 1)
    }
}

RemoteControl 의 변형된 코드를 제공합니다. 부모처럼 구현 객체를 가져와 새로운 또는 복잡한 동작을 정의합니다.

실행해보기

class BridgeClient {
    init {
        val tvFactory = TVFactory()
        val remoteSony = SpecialRemote(tvFactory)
        println()
        println("Connect your remote to the TV.")
        remoteSony.setTV("Sony")
        remoteSony.on()
        remoteSony.up()
        remoteSony.up()
        remoteSony.down()
        remoteSony.off()
        println("==============================\n")

        val remoteLG = GenericRemote(tvFactory)
        println("Connect your remote to the TV.")
        remoteLG.setTV("LG")
        remoteLG.on()
        remoteLG.setChannel(30)
        remoteLG.nextChannel()
        remoteLG.prevChannel()
        remoteLG.prevChannel()
        remoteLG.off()
        println("==============================\n")

        val remoteSamsung = GenericRemote(tvFactory)
        println("Connect your remote to the TV.")
        remoteSamsung.setTV("Samsung")
        remoteSamsung.setChannel(99)
        remoteSamsung.nextChannel()
        remoteSamsung.nextChannel()
        remoteSamsung.nextChannel()
        remoteSamsung.off()

    }
}

마무리

브릿지 패턴은 추상적인 것과 구체적인 것을 분리하고 브릿지(다리)를 통해 서로 이어주는 패턴 입니다.

개발자는 해당 패턴을 사용하기 전에 미리 추상적인 것과 구체적인 것을 분리하는 과정이 필요합니다.

장점

• 추상적인 코드를 구체적인 코드 변경 없이도 독립적으로 확장할 수 있다. (OCP)
• 추상적인 코드와 구체적인 코드를 분리할 수 있다.

단점

• 계층 구조가 늘어나 복잡도가 증가할 수 있다.

참고

• 헤드퍼스트 개정판 [hanbit.co.kr/store/books/look.php?p_code=B6113501223]
• 인프런 - 코딩으로 학습하는 GoF 디자인 패턴 [https://www.inflearn.com/course/디자인-패턴]
• Refactoring GURU website [https://refactoring.guru/ko/design-patterns/bridge]

주어진 상황 및 용도에 따라 어떤 객체에 책임을 덧붙이는 패턴으로, 기능 확장이 필요할 때, 서브클래싱 대신 쓸 수 있는 유연한 대안이 될 수 있다. 데코레이터(Decortor) 뜻 그대로 원하는 클래스를 장식한다. 즉, Wrapping 한다 라고 생각할 수 있다.

구현할 클래스 목록

Beverage 를 사용하여 커피를 만듭니다.

Component (Beverage) 구현

interface Beverage {

    fun getDescription(): String {
        return "Unknown Beverage"
    }

    fun cost(): Double
}

Interface 를 활용하면 실제 구현체를 서브 클래스로 위임할 수 있게 된다.

구현은 ConcreateComponent 에서 override 를 활용하여 구현하게 된다.

ConcreateComponent

다이어 그램과 같이 Beverage implements 하여 구현체를 작성하는 ConcreateComponent 만든다.

class Espresso : Beverage {

    override fun getDescription(): String {
        return "Espresso"
    }

    override fun cost(): Double {
        return 1.99
    }
}

class Decaf : Beverage {

    override fun getDescription(): String {
        return "Decaf Coffee"
    }
    override fun cost(): Double {
        return 1.05
    }
}

Beverage 의 구현체 클래스를 만들어 보았습니다.

Beverage는 인터페이스기 때문에 Client 에서 사용하기 위해 구현체 클래스를 만들어 주어야 합니다.

Client 에서 사용하기 위해 Espresso , Decaf 클래스를 만들었습니다.

Decorator & ConcreateDecorator

// 비슷한 카테고리를 한번에 처리하기 위해 abstract class 만들어 사용할 수 있다.
abstract class CondimentDecorator : Beverage {
    abstract val beverage: Beverage
}

// 기본 Beverage 를 생성자로 받아서 행동을 추가하는 class 이다.
class Milk(override val beverage: Beverage) : CondimentDecorator() {

    override fun getDescription(): String {
        return beverage.getDescription() + ", Milk"
    }
    override fun cost(): Double {
        return .10 + beverage.cost()
    }
}

기본적인 Beverage 클래스를 Decorator 할 클래스를 만듭니다.

abstract class 로 만들어 Beverage 에서 사용하는 class 를 override 할 수 있도록 하고

Beverage 를 서브 클래스에서 사용하도록 강제합니다.

서브클래스에서는 기본 Beverage 의 값에 추가로 장식할 수 있도록 함수를 재정의합니다.

Decorator class 만들어 사용하게 되면, 원래 데이터가 Wrapping 되는 효과를 얻을 수 있습니다.

사용해보기

class AppCafe {
    init {
        val bw = System.out.bufferedWriter()
        var beverage1: Beverage = Decaf()
        bw.appendLine("1번 커피 주문")
        bw.appendLine("${beverage1.getDescription()} $${beverage1.cost()}")

        var beverage2: Beverage = HouseBlend()
        beverage2 = Mocha(beverage2)
        beverage2 = Mocha(beverage2)
        beverage2 = Whip(beverage2)
        bw.appendLine("2번 커피 주문")
        bw.appendLine("${beverage2.getDescription()} $${beverage2.cost()}")

        var beverage3: Beverage = Espresso()
        beverage3 = Milk(beverage3)
        beverage3 = Soy(beverage3)
        beverage3 = Mocha(beverage3)
        bw.appendLine("3번 커피 주문")
        bw.appendLine("${beverage3.getDescription()} $${beverage3.cost()}")

        bw.flush()
    }
}

private fun main() {
    AppCafe()
}

모든 데코레이터를 만들고 커피를 주문해보겠습니다.

1번 커피의 경우 디카페인 커피에 아무것도추가하지 않습니다.

2번 커피는 기본 블랜딩 + 2개의 모카 + 휘핑 으로 주문합니다.

3번 커피는 에스프레소 + 우유 + 두유 + 모카 로 주문합니다.

기본 Beverage 에 Decorator class 덮어 Wrapping 하면 Beverage 에 Decorator에서 추가한 작업이 (+) 되어 return 됩니다.

마무리

Decorator 하고 싶은 Target을 Interface로 정의하고 구현체 Class 추가로 만듭니다.

생성자로 Target Interface 를 받아 장식하고 싶은 부분을 override 를 사용하여 추가합니다.

Decortor 를 지난 Target 은 Wrapping 되어 내가 추가한 값이 저장됩니다.

장점

• 새로운 클래스를 만들지 않고 기존 기능을 조합할 수 있다.(이미 생성된 Decortor class 조합하면 다양한 경우의 수를 조합할 수 있습니다.)
• 컴파일 타임이 아닌 런타임에 동적으로 기능을 변경할 수 있다.

단점

• 테코레어터를 조합하는 코드가 복잡할 수 있다.

참고

• 헤드퍼스트 개정판 [hanbit.co.kr/store/books/look.php?p_code=B6113501223]
• 인프런 - 코딩으로 학습하는 GoF 디자인 패턴 [https://www.inflearn.com/course/디자인-패턴]
• 준비된 개발자 [https://readystory.tistory.com/125]

기존 코드를 클라이언트가 사용하는 인터페이스의 구현체로 바꿔주는 패턴

클라이언트가 사용하는 인터페이스를 따르지 않는 기존 코드를 재사용할 수 있게 해준다.

구현할 클래스 목록

Account 객체로 LoginHelper 를 통해 해당 유저가 로그인이 가능한 상태인지 확인합니다.

Adaptee 구현

// 사용자의 데이터를 저장하는 객체
data class Account(
    var name: String,
    var password: String,
    var email: String
)

// 저장된 사용자의 정보를 핸들링 할 수 있는 class
// 예시를 위해 findAccountByUsername 할 때,
// Account 를 생성하도록 구현하였습니다.
class AccountService {
    fun findAccountByUsername(username: String): Account {
        val account = Account(
            name = username,
            password = username,
            email = username
        )

        return account
    }

    fun createNewAccount(account: Account) {}

    fun updateAccount(account: Account) {}
}

Adaptee 에 해당하는 클래스를 만들었습니다.

Account 객체에는 회원가입된 사용자의 정보를 담을 수 있는 정보를 가지고 있으며,

AccountService 는 Account 의 생성, 변경, 찾기 등 여러 동작을 지원하는 클래스입니다.

우리가 구현하고자하는 목표는 Account 를 활용하여 LoginHelper를 통해 로그인이 가능한지 확인하는 것입니다.

Account를 LoginHeldper 에서 사용할 수 있도록 하는 어댑터가 필요합니다.

Target Interface 만들기

// Account 의 정보를 가지고 올 수 있는 target
interface UserDetails {
    fun getUsername(): String
    fun getPassword(): String
}

// 로그인 하고자 하는 username 을 통해 UserDetail 를 return
interface UserDetailService {
    fun loadUser(username: String): UserDetails
}

2가지 Target Interface 를 구현합니다.

• UserDetailService : username 을 이용하여 즉, 사용자의 이름을 이용하여 UserDeatils 을 반환합니다. 이렇게 만들면 Account 객체를 직접 참조하지 않고 UserDetails 클래스에 정의된 함수를 통해 Account 의 데이터에 접근할 수 있습니다.
• UserDetails : Account 객체를 직접 참조 하지 않고 구현체에 동작을 위임 할 수 있습니다. 현재는 간단하게 getUsername(), getPassword() 만 구현 하였지만 Adapter 클래스에서 해당 함수를 구현할 때, validate 처리, 잘못 된 값 처리 등 다양한 동작을 추가할 수 있습니다.

Adapter 만들기

class AccountUserDetails(
    private val account: Account
) : UserDetails {
    override fun getUsername(): String {
        return this.account.name
    }

    override fun getPassword(): String {
        return this.account.password
    }
}

class AccountUSerDetailService(
    private val accountService: AccountService
) : UserDetailService {

    override fun loadUser(username: String): UserDetails {
        val account = accountService.findAccountByUsername(username)
        return AccountUserDetails(account)
    }
}

• AccountUserDetailService

  • AccountService 를 생성자로 받아와서 사용자의 정보(Account) 를 찾아서 AccountDetails Adapter를 반환합니다.
  • Account 는 AccountUserDetails Adapter 에 캡슐화 되어 직접 참조가 불가능한 상태가 되어 집니다.

• AccountUserDetails

  • Account 를 생성자로 받아 Account 의 데이터를 UserDetails Target Interface 에 정의된 함수로 값을 return 합니다.
  • 직접 참조하지 않고 오버라이딩 된 함수를 통해서만 Account 객체에 접근할 수 있어 보다 안전하게 객체를 관리할 수 있습니다.

로그인 할 수 있는지 확인하기

class LoginHandler(private var userDetailsService: UserDetailService) {

    fun login(username: String, password: String): String {
        val userDetails = userDetailsService.loadUser(username)
        return if (userDetails.getPassword() == password) {
            userDetails.getUsername()
        } else {
            throw IllegalArgumentException()
        }
    }
}

// App.kt
private fun main() {
    val accountService = AccountService()
    val userDetailService = AccountUSerDetailService(accountService)
    val loginHandler = LoginHandler(userDetailService)
    val login = loginHandler.login("Jack", "Jack")
    println(login)
}

모든 구현이 끝났습니다.

LoginHelper 에 login() 매소드를 통해 해당 유저가 로그인 가능한지 확인하면 됩니다.

LoginHelper 는 UserDetailService 생성자를 통해 로그인한 사용를 조회 합니다.

Account 객체 대신 UserDetails 객체를 반환하고 userDetails.getPassword() == password 조회된 사용자의 비밀번호와 입력한 비밀번호가 같다면 로그인

다르다면 Exception 을 던지도록 구현합니다.

마무리

쉽게 생각하면 A 생성자로 B 라는 새로운 객체를 만든다고 생각하시면 쉽게 이해할 수 있습니다.

모든 어탭터 패턴이 A → B → C 이렇게 변하지는 않습니다.

장점

• 기존 코드를 변경하지 않고 원하는 인터페이스 구현체를 만들어 재사용할 수 있다. (Open-Close principle, Single Responsibility principle)
• 기존 코드가 하던 일과 특정 인터페이스 구현체로 변환하는 작업을 각기 다른 클래스로 분리하여 관리할 수 있다. (Interface Segregation principle)

단점

• 새 클래스가 생겨 복잡도가 증가할 수 있다. 경우에 따라서는 기존 코드가 해당 인터페이스를 구현하도록 수정하는 것이 좋은 선택이 될 수도 있다.

참고

• 헤드퍼스트 개정판 [hanbit.co.kr/store/books/look.php?p_code=B6113501223]
• 인프런 - 코딩으로 학습하는 GoF 디자인 패턴 [https://www.inflearn.com/course/디자인-패턴]
• dp.chys - velog [https://velog.io/@ljinsk3/디자인-패턴-Adapter-Pattern]
• 준비된 개발자 [https://readystory.tistory.com/125]

복잡한 객체를 생성하는 방법을 정의하는 클래스와 표현하는 방법을 정의하는 클래스를 별도로 분리. 서로 다른 표현이라도 이를 생성할 수 있는 동일한 절차를 제공

• Android 개발을 진행하면 Builder Pattern을 많이 찾아 볼 수 있습니다.

  ex) Dialog, Retrofit, Okhttp, Glidle 등

구현할 클래스 목록

• BuilderClientSimple: 빌더 항목을 사용합니다.
• TourPlanBuilder: 빌더 생성에 필요한 메소드를 제공
• Tour, DetailPlan: 빌더를 만들기 위한 Data Class(Product)
• DefaultTourBuilder: 인터페이스를 구현하여 Tour 객체를 만듬

Product 만들기

/*
  빌더에 사용될 복잡한 Data Class 정의합니다.
*/
data class Tour(
    val name: String,
    val startDate: LocalDate,
    val nights: Int,
    val days: Int,
    val whereToStay: String,
    val detailPlans: List<DetailPlan>
) {
    override fun toString(): String {
        val sb = StringBuffer()
        sb.appendLine("====  $name  ====")
            .appendLine("date: $startDate")
            .appendLine("$nights 박 $days 일")
            .appendLine("stay: $whereToStay")
            .appendLine("plan")
            .appendLine(detailPlans.makeToString())
        return sb.toString()
    }

    private fun List<DetailPlan>.makeToString(): String {
        val sb = StringBuilder()
        this.forEach {
            sb.append(it)
                .append("\n")
        }
        if (this.isEmpty()) sb.append("There are no detailed plans.")
        return sb.toString()
    }
}

data class DetailPlan(
    val no: Int,
    val plan: String
) {
    override fun toString(): String {
        return "$no - $plan"
    }
}

Tour 객체를 생성하기 위해서는 총 6가지의 파라미터를 넣어주어야하며,

nights, days 객체의 상관관계가 포함되어야 합니다.

fun main() {
  // 예시
    val tour = Tour(
        name = "tour",
        startDate = LocalDate.now(),
        nights = -123,
        days = 4,
        whereToStay = "",
        detailPlans = listOf()
    )
}

위 예시 처럼 -123박 4일 이라는 불완전한 객체가 생성 되어 버렸습니다.

Builder Pattern 을 사용하면 이러한 경우를 방지하는 코드를 만들 수 있고, 객체간의 상관 관계를 정의 하여 객체를 완전하게 생성할 수 있게 됩니다.

Builder Interface 만들기

interface TourPlanBuilder {

    fun nightsAndDays(nights: Int, days: Int): TourPlanBuilder

    fun title(title: String): TourPlanBuilder

    fun startDate(startDate: LocalDate): TourPlanBuilder

    fun whereToStay(whereToStay: String): TourPlanBuilder

    fun addPlan(no: Int, plan: String): TourPlanBuilder

    fun removePlan(plan: DetailPlan): TourPlanBuilder

    fun build(): Tour
}

Tour 객체 생성에 필요한 필드를 설정할 수 있도록 메소드를 만듭니다.

직접 적인 구현은 Builder Interface 를 상속받은 Class 에서 정의해주면 됩니다. 여기서는 객체 생성에 필요한 함수만 만들어 주면 됩니다.

Concreate Builder 만들기

class DefaultTourBuilder : TourPlanBuilder {

    private var name: String = "Default Tour"
    private var startDate: LocalDate = LocalDate.now()
    private var nights: Int = 0
    private var days: Int = 1
    private var whereToStay: String = "Hotel"
    private val detailPlans: MutableList<DetailPlan> = mutableListOf()
    override fun nightsAndDays(nights: Int, days: Int): TourPlanBuilder = apply {
        this.nights = nights
        this.days = days
    }

    override fun title(title: String): TourPlanBuilder = apply {
        this.name = title
    }

    override fun startDate(startDate: LocalDate): TourPlanBuilder = apply {
        this.startDate = startDate
    }

    override fun whereToStay(whereToStay: String): TourPlanBuilder = apply {
        this.whereToStay = whereToStay
    }

    override fun addPlan(no: Int, plan: String): TourPlanBuilder = apply {
        this.detailPlans.add(DetailPlan(no, plan))
    }

    override fun removePlan(plan: DetailPlan): TourPlanBuilder = apply {
        if (this.detailPlans.contains(plan)) {
            this.detailPlans.remove(plan)
        }
    }

    override fun build(): Tour {
        println("Create Default Tour !!")
        return Tour(name, startDate, nights, days, whereToStay, detailPlans)
    }

}

Kotlin 의 최대 장점인 확장 함수를 통해 Concreate Builder Class 만들었습니다.

apply를 활용하여 builder 객체를 무조건 적으로 반환할 수 있도록 구현 할 수 있습니다.

마지막에 build() 함수를 통해 우리가 원하는 Tour 객체를 만들 수 있습니다.

Tour 객체에 필요한 파라미터 변수는 Concreate class 에서만 접근 할 수 있도록 private 로 선언해야합니다. 그래서 interface 로 추가해준 함수로 값을 접근할 수 있도록 해야 합니다.

Client 만들기

class BuilderClientSimple {
    init {
        val defaultTourBuilder = DefaultTourBuilder()
        val tour = defaultTourBuilder
            .title("JangHee Tour")
            .nightsAndDays(2, 3)
            .startDate(LocalDate.of(2023, 3, 13))
            .whereToStay("근사한 호텔")
            .addPlan(1, "비행기 타기")
            .addPlan(2, "바다 보기")
            .addPlan(3, "맛있는 저녁 먹기")
            .build()

        println(tour)

        val simpleTour = DefaultTourBuilder()
            .title("Simple Tour")
            .startDate(LocalDate.of(2023, 5, 5))
            .build()
        println(simpleTour)
    }
}

private fun main() {
    BuilderClientSimple()
}

2가지의 예시 투어를 만들었습니다.

1번은 상세계획이 있는 Tour 이고

2번은 간단한 Tour 입니다.

builder에 함수를 계속 추가하여 객체를 생성합니다.

출력 결과

1번 자세한 Tour

2번 간단한 Tour

장점

만들기 복잡한 객체를 순차적으로 만들 수 있다. 복잡한 객체를 만드는 과정을 숨길 수 있다. 동일한 프로세스를 통해 각기 다르게 구성된 객체를 만들 수 있다. 불완전한 객체를 사용하지 못하도록 방지 할 수 있다.

단점

원하는 객체를 만들기 전에 빌더 부터 만들어야 한다. 구조가 복잡해 진다.

참고

• 헤드퍼스트 개정판 [hanbit.co.kr/store/books/look.php?p_code=B6113501223]
• 인프런 - 코딩으로 학습하는 GoF 디자인 패턴 [https://www.inflearn.com/course/디자인-패턴]

객체가 특정 객체 상태 변화를 감지하고 알림을 받는 패턴. 발생(publish) - 구독(subscribe) 패턴을 구현할 수 있다. 객체의 상태가 변경되면 Observer 의존하고 있는 객체에 업데이트된 상태를 알려주며, 일대다(one-to-many) 의존성 정의이다.

구현할 옵저버 패턴 클래스

옵저버 인터페이스 만들기

• Observer

interface Observer {
        // update 함수의 생성자를 통해
        // 알려주고 싶은 상태를 생성자에 정의한다.
    fun update(temp: Float, humidity: Float, pressure: Float)
}

• Subject

/**
 * 옵저버를 등록, 제거, 알림 기능을 제공하는 인터페이스이다.
 * 옵저버 패턴은 구독을하고 해제하는 함수를 항상 만들어 두어야 하며,
 * 필요가 없는 시점에 해제하지 않으면 메모리릭이 발생하기 때문에 사용하지 않는다면,
 * 꼭 해제를 명시적으로 해제를 시켜주어야 한다.
 * notifyObservers() 함수를 통해 구독된 옵저버 모두에게 변경된 상태를 알려 준다.
 */
interface Subject {
    fun registerObserver(o: Observer)
    fun removeObserver(o: Observer)
    fun notifyObservers()
}

옵저버 인터페이스와 옵저버를 등록하는 인터페이스를 만들었다.

다음으로는 Subject 정의하는 클래스를 만들어 보자.

옵저버 등록, 해제, 알림 클래스 만들기

class WeatherData : Subject {
    private var observers: ArrayList<Observer> = arrayListOf()
    private var temperature: Float = 0f
    private var humidity: Float = 0f
    private var pressure: Float = 0f

    override fun registerObserver(o: Observer) {
        observers.add(o)
    }

    override fun removeObserver(o: Observer) {
        observers.remove(o)
    }

    override fun notifyObservers() {
        observers.forEach {
            it.update(temperature, humidity, pressure)
        }
    }

    fun measurementsChanged() {
        notifyObservers()
    }

    fun setMeasurements(temperature: Float, humidity: Float, pressure: Float) {
        this.temperature = temperature
        this.humidity = humidity
        this.pressure = pressure
        measurementsChanged()
    }
}

• Subject 인터페이스를 등록한다.
• 일대다(one-to-many) 구현을 위해 ArrayList<Observer> 생성한다.
• 업데이트해 줄 데이터를 선언한다.
• Subject 인터페이스의 매소드를 구현한다.
• 상태가 변경되면 notifyObservers() 호출하여 구독하고 있는 사용자에게 알려준다.

registerObserver(Observer) 함수를 통해 ArrayList 에 구독자 정보를 저장하고 notifyObservers() 함수를 통해 ArrayList 에 저장되어 있는 모든 Observer 객체에게 데이터가 변경되 었다고 알려준다.

더 이상 구독된 정보를 받기를 원하지 않는 경우 또는 옵저버를 사용하지 않는 경우에 removeObserver(Observer) 함수를 통해 메모리에서 삭제한다.

옵저버 객체 만들기

class ForecastDisplay(
    weatherData: WeatherData
) : Observer, DisplayElement {
    private var currentPressure = 29.92f
    private var lastPressure: Float = 0f

    init {
        weatherData.registerObserver(this)
    }

    override fun display() {
        println("Forecast: ")
        if (currentPressure > lastPressure) {
            println("Improving weather on the way!")
        } else if (currentPressure == lastPressure) {
            println("More of the same")
        } else if (currentPressure < lastPressure) {
            println("Watch out for cooler, rainy weather")
        }
    }

    override fun update(temp: Float, humidity: Float, pressure: Float) {
        lastPressure = currentPressure
        currentPressure = pressure
        display()
    }
}

• 생성자에 Subject 가 만들어져 있는 클래스를 받는다.
• Observer 인터페이스를 상속하여 update() 함수를 정의한다.
• init 함수를 통해 구독 요청을 보낸다.
• notifyObservers() 함수가 호출 되면 update() 정의해둔 로직이 실행 되어 데이터의 상태가 변경 된다.

옵저버 실행 하기

fun main() {
    val weatherData: WeatherData = WeatherData()

    val currentDisplay = CurrentConditionsDisplay(weatherData)
    val statisticsDisplay = StatisticsDisplay(weatherData)
    val forecastDisplay = ForecastDisplay(weatherData)

    println("첫 번째 데이터")
    weatherData.setMeasurements(85f, 65f, 30.4f)
    println("두 번째 데이터")
    weatherData.setMeasurements(82f, 70f, 29.2f)
    println("세 번째 데이터")
    weatherData.setMeasurements(78f, 90f, 29.2f)

    weatherData.removeObserver(forecastDisplay)
    println("\nForecastDisplay 구독 취소 후 데이터")
    weatherData.setMeasurements(62f, 90f, 28.1f)
}

• Subject 생성하는 WeatherData 클래스를 초기화 한다.
• 구독을 원하는 Observer 상속되어 있는 클래스를 초기화 한다.
• setMeasurements() 함수를 통해 구독자에게 데이터가 변경되었음을 알려준다.
• forecastDisplay 객체의 구독을 제거한다.
• 그 이후 데이터는 어떻게 나오게 될까? 확인해 보자.

결과

ForecastDisplay 구독을 취소 후 데이터를 변경하면,

기존에 CurrentConditionsDisplay, StatisticsDisplay의 데이터만 변경되고

ForecastDisplay는 더 이상 데이터 변화를 감지할 수 없다.

특징

• 장점

  • 상태를 변경하는 객체(Publisher)와 변경을 감지하는 객체(Subsriber)의 관계를 느슨하게 유지할 수 있다.
  • Subejct의 상태 변경을 주기적으로 조회하지 않고 자동으로 감지할 수 있다.
  • 런타임에 옵저버를 추가하거나 제거할 수 있다.

• 단점

  • 복잡도가 증가한다.
  • 다수의 Observer 객체를 등록 이후 해지하지 않는다면 메모리릭이 발생할 수도 있다.

참고

• 헤드퍼스트 개정판 [hanbit.co.kr/store/books/look.php?p_code=B6113501223]
• 인프런 - 코딩으로 학습하는 GoF 디자인 패턴 [https://www.inflearn.com/course/디자인-패턴]

• Contribute을 하기 위해서 Readme에 Contribute작성 가이드를 확인 후 버그를 수정하고 pull request를 보내면 된다.

이슈 수정 시작하기

1. 이슈 열기

이슈는 Github 페이지의 issue 탭에 들어가서 게시물을 작성하면 됩니다.

1. 우측 상단의 “New iusse” 버튼을 클릭

2. 해당 이슈의 종류를 선택 ( 버그 or 다른 요청 )

3. 버그리포트 작성시 작성 가이드를 아래 사진과 같이 준다면 해당 가이드에 맞춰 작성

4. 우측 라벨에 어떤 종류의 버그인지 태그 기능 사용

5. “Submit new issue” 버튼 클릭하여 이슈 등록 → 끝 !!

2. 이슈 수정

• 수정 전 이슈 사항

좌우 스와이프를 했을 때, 년, 월 Spinner Adapter의 item이 선택된 데이터와 일치하지 않는 문제를 발견하고 수정을 진행 하였습니다.

• 원인파악

캘린더의 스와이프 이벤트를 먼저 찾아보겠습니다.

// CalendarSheet.kt
package com.maxkeppeler.sheets.calendar

...

private fun setupMonthScrollListener() {
        // 캘린더의 스와이프 이벤트가 발생 되는 곳
    binding.calendarView.monthScrollListener = { month ->
        val day = month.weekDays.first().first { it.owner == DayOwner.THIS_MONTH }
        selectedViewDate = day.date
        monthAdapter.updateCurrentYearMonth(day.date.yearMonth)
        updateSpinnerValues()
    }
}
...

해당 함수의 동작을 파악한 결과

monthScrollListener 에서 날짜 정보를 받아서 Spinner의 value를 바꿔주고 있습니다.

선택된 Month Item 구현 코드

// MonthAdapter.kt
package com.maxkeppeler.sheets.calendar

...

// 현재 상태를 확인하여 글자의 Style를 변경하는 코드
private fun SheetsCalendarMonthItemBinding.handleState(monthAtIndex: Month) = when {
    disablePast && currentSelectedYear.year == currentYearMonth.year 
&& monthAtIndex.value < currentYearMonth.month.value -> {
        month.isSelected = false
        month.setTextAppearance(ctx, R.style.TextAppearance_MaterialComponents_Subtitle2)
        month.setTextColor(textColor)
        month.alpha = 0.2f
    }
    disableFuture && currentSelectedYear.year == currentYearMonth.year 
&& monthAtIndex.value > currentYearMonth.month.value -> {
        month.isSelected = false
        month.setTextAppearance(ctx, R.style.TextAppearance_MaterialComponents_Subtitle2)
        month.setTextColor(textColor)
        month.alpha = 0.2f
    }
    currentYearMonth.month == monthAtIndex && selectedMonth == monthAtIndex -> {
        month.isSelected = true
        month.setTextAppearance(ctx, R.style.TextAppearance_MaterialComponents_Subtitle2)
        month.setTextColor(primaryColor)
        month.alpha = 1f
    }
    currentYearMonth.month == monthAtIndex -> {
        month.isSelected = true
        month.setTextAppearance(ctx, R.style.TextAppearance_MaterialComponents_Body2)
        month.setTextColor(primaryColor)
        month.alpha = 1f
    }
    selectedMonth == monthAtIndex -> {
        month.isSelected = false
        month.setTextAppearance(ctx, R.style.TextAppearance_MaterialComponents_Subtitle2)
        month.setTextColor(primaryColor)
        month.alpha = 1f
    }
    else -> {
        month.isSelected = false
        month.setTextAppearance(ctx, R.style.TextAppearance_MaterialComponents_Body2)
        month.setTextColor(textColor)
        month.alpha = 1f
    }
}

// 선택된 item 변경
private fun updateSelectedMonth(month: Month) {
    selectedMonth = month
    notifyDataSetChanged()
}
...

해당 Adapter를 확인해보시면 private fun updateSelectedMonth(month: Month) 인데 private함수로 MonthAdapter.kt 파일 안에서만 사용할 수 있도록 구현되어 있습니다.

여기서 item의 선택된 변수가 Adapter의 click event에만 적용되어 있어 클릭을 하지 않으면 현재날짜와 item의 날짜가 다르게 표현되었습니다.

• 원인 수정

Adapter의 updateSelectedMonth(month: Month) 함수를 CalendarView.monthScrollListener(month: CalendarMonth) 에 구현해 주면 간단하게 Selected item을 구현할 수 있습니다.

구현 코드는 아래와 같습니다.

// CalendarSheet.kt
package com.maxkeppeler.sheets.calendar

...

private fun setupMonthScrollListener() {

    binding.calendarView.monthScrollListener = { month ->
        val day = month.weekDays.first().first { it.owner == DayOwner.THIS_MONTH }
        selectedViewDate = day.date
        monthAdapter.updateCurrentYearMonth(day.date.yearMonth)

                // monthAdapter, yearAdapter의 updateSelected 함수 추가
        monthAdapter.updateSelectedMonth(day.date.yearMonth.month)
        yearAdapter.updateSelectedYear(Year.of(day.date.yearMonth.year))

        updateSpinnerValues()
    }
}
...

Adapter 외 다른 클래스에서 사용하기 위해서는 updateSelected() 를 공개적으로 사용할 수 있게 public으로 변경해 준다.

// MonthAdapter.kt
package com.maxkeppeler.sheets.calendar

...
// private --> public
fun updateSelectedMonth(month: Month) {
    selectedMonth = month
    notifyDataSetChanged()
}
...

• 결과

3. Pull Request 보내기

Pull Request를 확인 후 main으로 merge가 되었다.

WoW !!

느낀점

간단하지만 처음으로 오픈소스를 수정하여 Contributor이 되었다. 정말 신기하고 해당 수정버전이 merge되고 실제 프로덕션으로 배포가 되어 다른 사용자들이 사용한다고 생각하니까 뿌듯하다!!

추상 팩토리 패턴(Abstract Facgtory Pattern)은 구상 클래스에 의존하지 않고 서로 연관되거나 의존적인 객채로 이루어진 제품군을 생산하는 인터페이스 제공 구상 클래스는 서브 클래스에서 만듬

📌  팩토리 쪽에만 집중하면 팩토리 메소드 패턴과 유사하지만, 클라이언트에서 추상 팩토리를 어떻게 사용하는지에 대한 관점으로 접근해야 목적과 처리점을 이해하기 쉽다.

구현할 추상 팩토리 메소드 클래스

Product Class

abstract class PizzaAF {

    var name: String = ""

    var dough: Dough? = null
    var sauce: Sauce? = null
    var cheese: Cheese? = null
    var clams: Clams? = null
    var veggie: Veggie? = null
    var tomato: Tomato? = null

    abstract fun prepare()

    fun bake() {
        println("25분 동안 피자를 굽습니다.")
    }

    fun cut() {
        println("피자를 8등분으로 자릅니다.")
    }

    fun box() {
        println("피자 박스에 피자를 담고 있습니다.")
    }

        override fun toString(): String {
            ... 생략
        }
}

일반 팩토리 메소드와 생성자의 구성은 비슷합니다.

달라진 부분이라면 dough, sauce, cheese, clams, veggie, tomato 변수가 각각의 AbstractProduct로 변경되었다는 점 입니다.

해당 객체는 아래에서 자세히 구현하도록 하겠습니다.

AbstractFactory 만들기

interface PizzaIngredientFactory {
    fun createDough(): Dough
    fun createSauce(): Sauce
    fun createCheese(): Cheese
    fun createVeggie(): Veggie
    fun createClams(): Clams
    fun createTomato(): Tomato
}

추상 팩토리 클래스 또는 인터페이스를 통해 Dough, Sauce, Cheese, Veggie, Clams, Tomato 객체에 대한 서브 클래스를 리턴해 줍니다.

이는 객체지향(OOP)의 다형성을 아주 잘 활용한 방식이라 볼 수 있습니다.

자세한 구현은 ConcreteFactory 를 통해 구현해보도록 하겠습니다.

ConcreteFactory 만들기

class NYPizzaIngredientFactory : PizzaIngredientFactory {
    override fun createDough(): Dough = NYDough()

    override fun createSauce(): Sauce = NYSauce()

    override fun createCheese(): Cheese = NYCheese()

    override fun createVeggie(): Veggie = NYVeggie()

    override fun createClams(): Clams = NYClams()

    override fun createTomato(): Tomato = NYTomato()
}

NYPizzaIngredientFactory(ConcreteFactory) 클래스를 만들고 PizzaIngredientFactory(AbstractFactory) 인터페이스를 상속 받습니다.

PizzaIngredientFactory의 함수를 override 하게 되고 여기서 NYPizza 스타일에 맞는 서브 Product 클래스를 넣어 줍니다.

PizzaAF 에 있는 Dough, Sauce, Cheese, Veggie, Clams, Tomato 객체를 Factory를 통해 만들었습니다.

AbstractProduct 만들기

interface Cheese {
    override fun toString(): String
}

interface Clams {
    override fun toString(): String
}

interface Dough {
    override fun toString(): String
}

interface Sauce {
    override fun toString(): String
}

interface Tomato {
    override fun toString(): String
}

interface Veggie {
    override fun toString(): String
}

간단하게 AbstractProduct 클래스들을 만들어 보았습니다.

이제 AbstractProduct를 상속 받아 해당 객체를 구현해줄 서브 클래스들을 만들어 주어야 합니다.

Product Sub Class 만들기

class NYCheese : Cheese {
    override fun toString(): String {
        return "## 뉴욕 치즈 ##"
    }
}

class ChicagoClams : Clams {
    override fun toString(): String {
        return "## 시카고 조개 ##"
    }
}

... 등등

서브 클래스까지 모두 만들었습니다.

이제 Client를 만들어야 합니다.

제가 구현한 프로젝트에서 Client는 PizzaStore 클래스를 상속 받고 있는 클래스들 입니다.

해당 클래스의 상세 구현으로 넘어가 보겠습니다.

Client Class 만들기

abstract class PizzaStoreAF {
        // 팩토리 메소드와 같은 함수 입니다.
    abstract fun createPizza(item: PizzaTypeAF): PizzaAF

    fun orderPizza(type: PizzaTypeAF): PizzaAF {
        val pizza: PizzaAF = createPizza(type)
        println("--- Making a ${pizza.name} ---")
        return pizza.apply {
            prepare()
            bake()
            cut()
            box()
        }
    }
}

class NYPizzaStore : PizzaStoreAF() {

    override fun createPizza(item: PizzaTypeAF): PizzaAF {
        val ingredientFactory = NYPizzaIngredientFactory()

        return when(item) {
            PizzaTypeAF.CHEESE -> {
                CheesePizza(ingredientFactory).apply {
                    name = "뉴욕 치즈 피자"
                }
            }
            PizzaTypeAF.CLAM -> {
                ClamsPizza(ingredientFactory).apply {
                    name = "뉴욕 조개 피자"
                }
            }
            PizzaTypeAF.TOMATO -> {
                TomatoPizza(ingredientFactory).apply {
                    name = "뉴욕 토마토 피자"
                }
            }
            PizzaTypeAF.VEGGIE -> {
                VeggiePizza(ingredientFactory).apply {
                    name = "뉴욕 야채 피자"
                }
            }
        }
    }
}

class ChicagoPizzaStore : PizzaStoreAF() {
        override fun createPizza(item: PizzaTypeAF): PizzaAF {
                ...
        }
}

Client를 자세히 보면 제일 처음 다이어그램에서 처럼 AbstractFacotry와 AbstractProduct 를 가지고 각각의 Pizza를 만들어 주는 것을 볼 수 있습니다.

Client 클래스인 PizzaStore도 모두 만들었습니다.

직접 사용할 수 있도록 코드를 작성해 봅시다.

결과

fun main() {
    val nyStore = NYPizzaStore()
    val chicagoStore = ChicagoPizzaStore()

    var pizzaAF = nyStore.orderPizza(PizzaTypeAF.CHEESE)
    println("A 주문 피자: $pizzaAF")

    pizzaAF = chicagoStore.orderPizza(PizzaTypeAF.TOMATO)
    println("B 주문 피자: $pizzaAF")

    pizzaAF = chicagoStore.orderPizza(PizzaTypeAF.VEGGIE)
    println("C 주문 피자: $pizzaAF")

    pizzaAF = nyStore.orderPizza(PizzaTypeAF.CLAM)
    println("D 주문 피자: $pizzaAF")
}

내가 원하는 Client 에서 원하는 Type의 피자를 주문하면 뉴욕 or 시카고 스타일의 피자를 만들어 줍니다.

사용하는 부분(직접 구현하는 부분)에서 if-else 또는 when 문을 사용하지 않고 쉽게 원하는 피자를 생성이 가능하게 되었습니다.

추가로 다른 종류의 피자를 추가한다면 추상 클래스 or 인터페이스를 추가하면 간단하게 확장이 가능하며, 기존 코드는 변경되지 않습니다.(OCP)

특징

구현(Implement)보다 인터페이스(Interface)를 위한 코드 접근법을 제공. sub class를 확장이 쉽다. 클라이언트 코드에서 구체적인 클래스의 의존성을 줄여주어 느슨한 결함이 가능함.

팩토리 매소드 & 추상 팩토리 매소드 패턴 차이점

• 관점이 다르다.
  • 팩토리 패턴은 “팩토리를 구현하는 방법 (inheritance)”에 초점을 둔다.
  • 추상 팩토리 패턴은 “팩토리를 사용하는 방법 (composition)”에 초점을 둔다.
• 목정이 조금 다르다.
  • 팩토리 패턴은 구체적인 객체 생성 과정을 하위 또는 구체적은 클래스로 옮기는 것이 목적
  • 추장 팩토리 패턴은 관련있는 여러 객체를 구체적인 클래스에 의존하지 않고 만들 수 있게 해주는 것이 목적

참고

• 헤드퍼스트 개정판 [hanbit.co.kr/store/books/look.php?p_code=B6113501223]
• 인프런 - 코딩으로 학습하는 GoF 디자인 패턴 [https://www.inflearn.com/course/디자인-패턴]
• 위키백과 - 추상 팩토리 메서드 패턴 [https://ko.wikipedia.org/wiki/추상_팩토리_메서드_패턴]

객체지향 다형성의 원리를 기반으로 만들어짐 다양한 구현체(Product)가 있고, 특정한 구현체를 만들 수 있는 팩토리(Creator)를 제공

확장에는 열려있고 변경에는 닫혀 있는 구조

부모(상위) 클래스에 알려지지 않은 구체 클래스를 생성하는 패턴이며, 자식(하위) 클래스가 어떤 객체를 생성할지 결정하도록 하는 패턴이다.

• Product 공통으로 생성될 객체의 인터페이스

• ConcreateProduct 구체적으로 객체가 생성되는 클래스

• Creator 팩토리 매서드를 가지고 있는 클래스

• ConcreateCreator 팩토리 매서드를 구현하는 클래스, ConcreateProduct 객체 생성

구현할 팩토리 매소드 클래스

생성자(Product) 만들기

• 생성자 Pizza 클래스를 만들어 봅니다.

abstract class Pizza {

    var name: String = ""
    var dough: String = ""
    var sauce: String = ""

    override fun toString(): String {
        return """
            { name : $name, dough : $dough, sauce : $sauce }
        """.trimIndent()
    }

    fun prepare() {
        println("Prepare $name")
        println("도우 셋팅 중...")
        println("소스 추가 중...")
        println("토핑 추가 중: ")
    }

    fun bake() {
        println("25분 동안 피자를 굽습니다.")
    }

    fun cut() {
        println("피자를 8등분으로 자릅니다.")
    }

    fun box() {
        println("피자 박스에 피자를 담고 있습니다.")
    }
}

피자에는 총 3가지의 변수를 가집니다.

• name: 피자의 이름
• dough: 도우 종류
• sauce: 소스의 종류

피자를 준비에 필요한 행동(매소드)를 정의합니다.

• fun prepare(): 피자를 만들기 위한 준비
• fun bake(): 피자 굽기
• fun cut(): 피자 자르기
• fun box(): 피자를 박스에 담기

여기서 피자는 어떤 피자를 만들게 될지 모르고 주문이 들어왔을 때,

주문에 맞는 피자를 만들게 됩니다.

ConcreateProduct 클래스 만들기

• 뉴욕 스타일 피자와 시카고 스타일 피자를 만들어 보겠습니다.

class NYStyleCheesePizza : Pizza() {
    init {
        name = "NY 치즈 피자"
        dough = "치즈 도우"
        sauce = "치즈 소스"
    }
}

class ChicagoStyleCheesePizza: Pizza() {
    init {
        name = "시카고 치즈 피자"
        dough = "두꺼운 도우"
        sauce = "체다 치즈 소스"
    }
}

피자의 종류를 알 수 있는 클래스를 만들었습니다.

PizzaType.kt 에 맞는 Pizza ConcreateProduct 클래스를 만들어 주면 됩니다.

클래스가 많아져도 괜찮습니다.

이제 피자의 종류를 알고 있으니 피자가게에가서 주문하면 됩니다.

주문은 ConcreateCreator 를 통해서 Pizza를 전달하고 Creator에서 만들어 줍니다.

PizzaStore(Creator) 만들기

• 피자를 만들 수 있는 피자상점을 만들어 봅니다.

abstract class PizzaStore {

    abstract fun createPizza(item: PizzaType): Pizza

    fun orderPizza(type: PizzaType): Pizza {
        val pizza: Pizza = createPizza(type)
        println("--- Making a ${pizza.name} ---")
        return pizza.apply {
            prepare()
            bake()
            cut()
            box()
        }
    }
}

피자의 종류에 따른 Pizza 를 만들어 주문을 넣을 수 있도록 합니다.

enum class PizzaType {
    CHEESE,
    TOMATO,
    CLAM,
    VEGGIE
}

Pizza 객체에 따른 피자를 만들기 위해 abstract fun createPizza(item: PizzaType): Pizza 구현 할 수 있는 ConcreateCreator 클래스를 만들어 주어야 합니다.

ConcreateCreator(뉴욕, 시카고 피자 상점) 만들기

• 저희는 뉴욕 피자, 시카고 피자 총 2가지의 종류의 피자를 주문할 수 있습니다.
• 스타일에 맞는 피자 상점을 만들어 PizzaType 으로 어떤 종류의 피자인지 알게됩니다.

class NYPizzaStore: PizzaStore() {
    override fun createPizza(item: PizzaType): Pizza {
        return when(item) {
            PizzaType.CHEESE -> NYStyleCheesePizza()
            PizzaType.TOMATO -> NYStyleTomatoPizza()
            PizzaType.CLAM -> NYStyleClamPizza()
            PizzaType.VEGGIE -> NYStyleVeggiePizza()
            else -> throw IllegalArgumentException()
        }
    }
}

class ChicagoPizzaStore : PizzaStore() {
    override fun createPizza(item: PizzaType): Pizza {
        return when(item) {
            PizzaType.CHEESE -> ChicagoStyleCheesePizza()
            PizzaType.CLAM -> ChicagoStyleClamPizza()
            PizzaType.TOMATO -> ChicagoStyleTomatoPizza()
            PizzaType.VEGGIE -> ChicagoStyleVeggiePizza()
            else -> throw IllegalArgumentException()
        }
    }
}

뉴욕스타일 피자 상점과 시카고 스타일 피자 상점을 만들어 주었습니다.

override fun createPizza(item: PizzaType): Pizza 구현하여 Pizza 객체를 PizzaStore(Creator) 클래스로 주게 됩니다.

결과

fun main() {
    val nyStore = NYPizzaStore()
    val chicagoStore = ChicagoPizzaStore()

    val pizza: Pizza = nyStore.orderPizza(PizzaType.CHEESE)
    println("철수 주문 : ${pizza.name}, \n$pizza")

    print("\n\n")

    val chicagoTomatoPizza: Pizza = chicagoStore.orderPizza(PizzaType.TOMATO)
    println("영희 주문 : ${chicagoTomatoPizza.name}, \n$chicagoTomatoPizza")
}

PizzaType에 맞는 피자를 PizzaStore(Creator) 클래스에서 만들어 주는 모습을 볼 수 있습니다.

간단하게 팩토리 메서드를 활용한 피자만들기를 구현해 보았습니다.

• Product Diagram

• Creator Diagarm

장점

기존 코드를 수정하지 않고 새로운 인스턴스를 확장 할 수 있다. Product - Creator 느슨한 결합으로 만들 수 있다. 코드가 간결해 진다.

단점

클래스가 많아 진다. 제품이 변경, 추가 될 때 마다 클래스를 생성해야한다.

사용 이유

• 생성할 객체 타입을 예측할 수 없을 때
• 생성할 객체를 기술하는 책임을 서브클래스에게 정의하고자 할 때
• 객체 생성의 책임을 서브클래스에 위임시키고 서브클래스에 대한 정보를 은닉하고자 할 때

참고

• 헤드퍼스트 개정판 [hanbit.co.kr/store/books/look.php?p_code=B6113501223]
• 인프런 - 코딩으로 학습하는 GoF 디자인 패턴 [https://www.inflearn.com/course/디자인-패턴]
• 위키백과 - 팩토리 메서드 패턴 [https://ko.wikipedia.org/wiki/팩토리_메서드_패턴]

안드로이드 5.0 이상에서 사용가능 camera2 기능 활용 + 생명주기 인식 구글 CameraX 예제

발생한 이슈

• 프리뷰가 실행되는 시점에서 권한 체크를 하면 프리뷰 화면이 나오지 않음
• 안드로이드 Q(10) 이상 파일 다운로드 위치 지정하기 쉽지 않음
• 화면 이동을 viewmodel.observe 사용시 break가 필요

1. 프리뷰 화면 나오지 않는 버그

아직까지 어떠한 방법을 찾지 못했음. 추후에 찾아서 포스팅 예정

2. 안드로이드 Q(10) 파일 다운로드 위치

개인정보를 중요시 하면서 안드로이드에 개인정보에 많은 부분이 제약이 걸린 버전. 기기의 고유 값을 가져올 수 없음. 앱 외부 공용 파일에 저장하지 않기를 권고

Google 공식 문서

Custom View 만들기

• @JvmOverLoads 어노테이션 (constructor 오버로딩)
• attr format 종류 (reference(id), dimension(dp, px, sp...), string, int, boolean, eunm ...)
• DataBinding

1. @JvmOverLoads

커스텀 뷰를 생성할때, 생성자 오버로딩이 필수적이다. 그 부분을 어노테이션이 대신해 준다.

java

 public class CustomView extends View {
     public CustomView(Context context) {
        super(context);
    }
    public CustomView(Context context, AttributeSet attr) {
        super(context, attr);
    }
    // ... etc
 }

kotlin

 class CustomView : View {
     constructor(context: Context) : super(context)
        constructor(context: Context, attr: AttributeSet) : super(context, attr)
 }
 // ... etc

constructor을 사용하여 자바와 비슷한 코드를 만들 수 있지만

@JvmOverloads 어노케이션을 사용하면 간결하게 생성자 오버로딩을 지원한다.

 class CustomView @JvmOverloads constructor(
     context: Context,
     attr:AttributeSet? = null
 ) : View(context, attr) {
     // ... etc
}

2. attr format 종류

• referemce : id 값
• dimension : dp, sp, px ...
• enum : 열거형
• fraction : ??
• flag : ??
• color : 색깔
• integer, float, string, boolean ...

3. DataBinding

안드로이드 FCM 시작하기

순서

1. 안드로이드 프로젝트 콘솔에 등록
2. FCMService 만들기
3. Manifast에 인터넷 권한 주기
4. intent-filter MESSAGE_EVENT 추가
5. onNewToken, onMessageRecived 구현

만들면서 발생한 이슈

1. http -> http v1 변경

서비스 키 --> OAuth2.0 OAuth2.0을 활용하여 주기적으로 토큰 값을 갱신하여 주어야함 장점 : 주기적인 토큰 갱신으로 보안성 우수 단점 : 토큰을 계속적으로 요청해야 되기 때문에 구현 난이도 상승

Postman - http v1

Postman - http

2. Data & Notification

FCM의 경우 2가지로 데이터를 표시할 수 있다. 하나. Notification, 상단 알림창을 만들 수 있는 기능 둘. Data, 제목, 내용 뿐만아니라 다양한 커스텀 메시지를 보낼 수 있음

Firebase 공식 문서

• 모두 사용한 경우 onMessageReceived 함수 호출 불가
• 데이터를 인텐트로 받아야함
• 화면 깨우기 불가

앞으로 공부하는 부분 열심히 올려보자