<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by 뿌요 on Medium]]></title>
        <description><![CDATA[Stories by 뿌요 on Medium]]></description>
        <link>https://medium.com/@bbuyo?source=rss-3bb76b7aabf8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*g82XvLx3DOeSxgCueVJTHg.png</url>
            <title>Stories by 뿌요 on Medium</title>
            <link>https://medium.com/@bbuyo?source=rss-3bb76b7aabf8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 10:48:08 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@bbuyo/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[[SwiftUI] ForEach 최적화 기법: Identifiable 프로토콜과 Id]]></title>
            <link>https://medium.com/@bbuyo/swiftui-foreach-%EC%B5%9C%EC%A0%81%ED%99%94-%EA%B8%B0%EB%B2%95-identifiable-%ED%94%84%EB%A1%9C%ED%86%A0%EC%BD%9C%EA%B3%BC-id-ae0c39bbfad9?source=rss-3bb76b7aabf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae0c39bbfad9</guid>
            <dc:creator><![CDATA[뿌요]]></dc:creator>
            <pubDate>Wed, 21 May 2025 13:46:03 GMT</pubDate>
            <atom:updated>2025-05-21T13:46:03.160Z</atom:updated>
            <content:encoded><![CDATA[<p>SwiftUI는 전통적인 명령형 UI 프레임워크와 달리, 상태 기반의 선언형 모델에 따라 동작합니다.</p><p>이 선언적 구조의 핵심은 상태 변화에 따른 최소 단위의 뷰 업데이트인데, 이를 가능하게 하는 내부 메커니즘은 뷰 트리의 diffing 시스템입니다.</p><p>이 시스템의 성능과 예측 가능성을 담보하기 위해서는 각 데이터 요소의 고유 식별성이 필수적이며, Swift에서는 이를 Identifiable 프로토콜과 id를 통해 구조화 합니다.</p><p>이 글에서는 SwiftUI의 랜더링 최적화 매커니즘 관점에서 id의 역할과 요구 조건을 분석하고 ForEach 등의 리스트 뷰 요구사항을 구현 시 최적화 방안을 제시합니다.</p><h3>선언형 UI에서 id가 필요한 이유</h3><p>SwiftUI의 뷰 재구성은 프레임 단위로 전체 트리를 리랜더링하지 않습니다. 대신 직전 상태와 현재 기준을 비교(diff)하여 변경이 발생한 최소 단위만을 재계산합니다. 이때 사용되는 비교 기준이 id이며, 이 값이 불안정하거나 무효한 경우 diff로직은 실패하거나 과잉 동작을 유발합니다.</p><pre>ForEach(items) { item in<br>    Text(item.title)<br>}</pre><p>이 코드 예제에서 items 배열의 각 원소는 SwiftUI가 diffing시 “동일한 요소”로 판단할 수 있어야 합니다. 즉 item은 Identifiable을 준수한 값이어야 하고, 이때 item.id는 논리적 동등성을 보장하는 요소로 작용합니다.</p><h3>Identifiable 프로토콜?</h3><p>Identifiable은 id: ID라는 단일 요구사항을 가지며, 해당 ID는 Hashable해야 합니다.</p><pre>public protocol Identifiable&lt;ID&gt; {<br>    associatedtype ID : Hashable<br>    var id: Self.ID { get }<br>}</pre><p>ID의 값은 정적이어야 하며, 객체의 정체성을 표현해야 합니다.</p><p>SwiftUI의 ForEach는 이 프로토콜을 채택한 타입을 대상으로 id를 자동으로 추론하여 diff 기준으로 활용합니다.</p><pre>struct User: Identifiable { <br>    let id: String { <br>    let name: String<br>    ...<br>}<br><br>let users: [User] = [ ... ]<br><br>// ❌<br>ForEach(users, id: \.id) { user in  // id: \.id 생략가능<br>    Text(user.name)<br>}<br><br>// ✅<br>ForEach(users) { user in<br>    Text(user.name)<br>}</pre><p>이러한 추상화는 개발자가 diffing로직에 직접 개입하지 않아도 되는 구조를 제공하며, id 사용을 유도함으로써 모델 설계의 일관성을 높여줍니다.</p><h3>안티패턴 1: 계산 프로퍼티로 UUID를 생성하는 경우</h3><p>간혹, id로 사용할만한 요소가 없어 아래와 같이 id를 계산 프로퍼티로 매번 UUID()를 생성하여 사용하는 경우가 있습니다.</p><p>id로 사용할 적절한 요소가 없어 UUID()를 매번 생성하는 방식으로 Identifiable을 구현하는 것은 잘못된 설계입니다.</p><p>예를 들어, 다음과 같이 UUID()를 계산 프로퍼티로 구현할 경우, id가 매번 다른 값으로 평가되어 SwiftUI의 diffing 시스템이 해당 객체를 동일한 것으로 인식하지 못합니다:</p><pre>// ❌ 잘못된 예시 (매번 새로운 UUID 생성)<br>struct MyItem: Identifiable { <br>    var id: UUID {<br>        UUID()<br>    }<br>    let name: String<br>}</pre><p>이렇게 구현하면 ForEach(myItems)와 같이 사용할 때, SwiftUI는 매번 모든 요소를 새로운 뷰로 인식하고 <strong>모든 뷰를 재생성</strong>하게 됩니다.</p><pre>let myItems: [MyItem] = [ ... ] <br><br>ForEach(myItems) { item in<br>    VStack {<br>        MyItemView(item: item) // 다음 랜더링 사이클에서 처음부터 끝까지 모두 재생성<br>    }<br>}</pre><p>이로 인해 LazyVStack과 같은 <strong>뷰 재사용 최적화 기법이 무력화</strong>되고, 퍼포먼스 저하로 이어질 수 있습니다.</p><p>특히 뷰 내부에 비싼 계산이나 비동기 작업, 애니메이션 등이 있다면 전부 매번 다시 초기화되어 시스템에 부하가 걸립니다.</p><p>만약 1000개의 뷰가 있다면 상태가 바뀔 때마다 매번 다시 계산하고 다시 그려야 합니다.</p><p>따라서 id는 반드시 <strong>객체의 동등성을 안정적으로 식별할 수 있는 불변 값</strong>이어야 하며, UUID()와 같은 동적 생성자를 id에 직접 사용하는 방식은 지양해야 합니다.</p><pre>// ✅<br>struct MyItem: Identifiable {<br>    let id: UUID // 생성 시 고정<br>    let name: String<br>}</pre><h3>안티패턴2: id: \.self의 잘못된 사용</h3><p>SwiftUI는 상태변화 시 화면 전체를 다시 그리지 않고, 변화가 생긴 요소만 다시 그립니다. 이걸 가능하게 하는 것이 diffing 메커니즘인데, id를 기준으로 “같은 항목인지&quot;를 판단합니다.</p><p>Element가 Hashable을 준수하면 self자체를 id대신 <strong>식별자</strong>로 사용할 수 있습니다.<br>즉, hashValue와 ==를 사용하여 diffing 메커니즘이 작동한다는 의미입니다.</p><p>앞서 설명한대로 diffing 메커니즘이 제대로 작동하려면 식별자가 안정적이어야 합니다. 즉 식별자가 정적이고 고유해야 합니다.</p><p>만약 self가 고정된 값이고, 고유하다면 diffing이 정확히 동작하기 때문에 SwiftUI가 의도한 대로 뷰 랜더링 시 최적화될 수 있습니다</p><pre>// ❌ <br>struct Message: Hashable {<br>  let sender: String<br>  let content: String<br>}<br><br>let messages = [<br>  Message(sender: &quot;A&quot;, content: &quot;Hi&quot;),<br>  Message(sender: &quot;A&quot;, content: &quot;Hi&quot;), // 값이 완전히 같음<br>]<br><br>ForEach(messages, id: \.self) { msg in<br>  Text(msg.content)<br>}</pre><p>하지만 예시 코드와 같이 Message가 같은 값이라면 hashValue가 완전히 같은 결과값을 가지게 되기 때문에 SwiftUI는 같은 항목으로 간주합니다.</p><p>결과적으로 뷰가 사라지거나 업데이트 되지 않는 등 뷰 랜더링 버그가 유발될 가능성이 매우 높아집니다.</p><p>SwiftUI는 선언형 UI의 특성상 내부적으로 수많은 상태 비교와 뷰 재계산이 발생합니다. 이 때 성능 저하 없이 안정적으로 동작하게 하려면 각 항목의 id가 논리적으로 의미 있는 동일성을 제공해야 합니다. Identifiable은 이 개념을 정형화된 형태로 구현할 수 있는 인터페이스이며, 이를 적절히 설계하는 것은 SwiftUI 프로젝트의 구조적 건전성을 좌우하는 요인입니다.</p><p>따라서 id는 단순히 눈에 띄는 값이 아닌, <strong>객체의 본질적 동일성을 나타내는 핵심 식별자</strong>로 간주되어야 하며, 실무에서는 이 원칙을 위배하지 않도록 철저히 관리해야 합니다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae0c39bbfad9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[경매 임장 어플리케이션: Coordinator 패턴으로 화면전환하기]]></title>
            <link>https://medium.com/@bbuyo/%EA%B2%BD%EB%A7%A4-%EC%9E%84%EC%9E%A5-%EC%96%B4%ED%94%8C%EB%A6%AC%EC%BC%80%EC%9D%B4%EC%85%98-coordinator-%ED%8C%A8%ED%84%B4%EC%9C%BC%EB%A1%9C-%ED%99%94%EB%A9%B4%EC%A0%84%ED%99%98%ED%95%98%EA%B8%B0-d229f7b9bb58?source=rss-3bb76b7aabf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/d229f7b9bb58</guid>
            <dc:creator><![CDATA[뿌요]]></dc:creator>
            <pubDate>Thu, 17 Apr 2025 13:49:04 GMT</pubDate>
            <atom:updated>2025-04-17T14:29:47.665Z</atom:updated>
            <content:encoded><![CDATA[<h3>Modular Project + Coordinator Pattern + Navigation Stack</h3><p>모듈화 프로젝트를 설계할 때 가장 고민됐던 부분이 화면과 화면의 전환이었어요.</p><p>프로젝트가 복잡해질수록 뷰 내부에서 상태 관리와 화면 전환 로직이 뒤섞이기 쉬워요. 이렇게 되면 유지보수가 어렵고, 테스트도 까다로워지죠. 이럴 때 유용한 것이 바로 <strong>Coordinator 패턴</strong>이에요. 이번 글에서는 실제 프로젝트 코드를 기반으로 Coordinator 패턴의 구조와 사용 방법을 깊이 있게 알아볼게요.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*7VFp8vxsgmtIqA1CNtDgtA.jpeg" /><figcaption><a href="https://pixabay.com/photos/crossing-crosswalk-transition-road-4856876/">https://pixabay.com/photos/crossing-crosswalk-transition-road-4856876/</a></figcaption></figure><h3>Coordinator 패턴이란?</h3><p>Coordinator 패턴은 앱 내의 화면 전환 로직을 한곳에 모아서 관리하는 디자인 패턴이에요. 각 뷰는 화면 전환에 대한 책임을 직접 지지 않고, 단지 화면 전환 요청만 Coordinator에게 전달할 뿐이죠. 이렇게 되면 뷰는 순수하게 UI만 관리하고, Coordinator는 네비게이션 흐름을 관리하는 역할만 담당하게 돼요.</p><p>이 패턴을 사용하면 여러 화면 간의 복잡한 의존성을 해소하고, 각 모듈을 독립적으로 관리하기 쉬워져서 유지보수와 테스트가 매우 편해져요.</p><h3>왜 Feature 모듈 간 직접 참조하면 안 될까요?</h3><p>여러분이 여러 모듈로 프로젝트를 나누는 이유는 결국 의존성을 명확히 관리하고, 독립적인 유지보수를 가능하게 하기 위해서죠. 만약 A라는 모듈이 B 모듈을 직접 참조하게 되면, A는 더 이상 독립적으로 존재할 수 없고 항상 B의 상태를 신경 써야 해요. 결국 하나의 모듈 변경이 다른 모듈의 변경을 강제하게 되는, 매우 불안정한 시스템이 만들어질 수밖에 없어요.</p><p>결국 모듈 간 직접 참조가 생기면, 하나의 변경이 연쇄적으로 다른 모듈의 수정까지 요구하는 구조가 됩니다. 이는 곧 의존성의 방향이 잘못 설계되었다는 신호이고, 결과적으로 전체 시스템의 유연성을 떨어뜨리고, 변경에 매우 취약한 구조가 되어버려요.</p><p>이러한 의존성 문제를 해결하기 위한 효과적인 방법은 중앙 집중형 네비게이션 모듈을 별도로 두는 것이에요. 즉, 화면 전환과 관련된 모든 로직을 Feature 모듈 밖으로 분리하여 독립적인 모듈에서 통합 관리하는 방식이죠.</p><p>이렇게 하면 Feature 모듈들은 서로를 참조할 필요 없이, 단순히 “이 화면으로 이동하고 싶다”는 요청만 외부로 전달하면 됩니다. 실제 화면 전환은 중앙의 네비게이션 모듈, 즉 Coordinator가 처리하게 되죠.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H8YHvd8P593b8ha-AIff3g.png" /></figure><p>저는 화면전환과 관련된 코드들을 Router 모듈을 생성하여 관리하고 있는데요,</p><p>Router의 가장 중추적인 부분이 되는 것이 바로 ViewFactory 프로토콜 입니다.</p><pre>import SwiftUI<br>import Combine<br><br>public protocol ViewFactory {<br>  associatedtype NavigationContext: Hashable<br>  associatedtype ScreenStep: Hashable<br>  associatedtype ViewType: View<br>  <br>  @ViewBuilder<br>  func makeView(<br>    _ route: ScreenStep,<br>    navigationSubject: PassthroughSubject&lt;NavigationEvent&lt;NavigationContext&gt;, Never&gt;<br>  ) -&gt; ViewType<br>}</pre><p>ViewFactory는 Hashable을 준수하고 있는 ScreenStep 그리고 NavigationContext가 있습니다.</p><p>아래에 설명하겠지만 ScreenRoute는 아래에 설명하겠지만, ScreenStep는 <strong>현재 뷰에 해당하는 화면 전환 단위(route)</strong> 를 의미합니다.</p><p>예를 들어 로그인 화면이라면 .signIn, 회원가입 화면이라면 .signUp처럼 각각의 화면을 대표하는 enum 값이라고 보시면 됩니다.</p><p>결국 하나의 ViewFactory는 특정 기능(Feature)에 대한 화면 전환을 책임지게 되고, 그 내부에서 어떤 뷰를 보여줄지 ScreenStep 값을 통해 판단하게 되는 구조예요.</p><p>반면 NavigationContext는 <strong>상위 흐름, 즉 네비게이션 계층 전체의 맥락</strong>을 의미합니다.</p><p>예를 들어 SignInRoute, AuctionRoute 등이 각각의 ScreenRoute였다면, 이들을 묶는 하나의 상위 context로 FeatureRoute 같은 enum을 둘 수 있겠죠.</p><p>이렇게 ViewFactory가 ScreenRoute와 NavigationContext를 분리해서 가지게 되면, <strong>하위 라우트(ScreenRoute)는 각 FeatureViewFactory에서 독립적으로 관리</strong>하면서도, <strong>상위 라우트(NavigationContext)는 통합된 흐름을 구성</strong>하는 데 활용할 수 있어요.</p><p>하위 피쳐 모듈인 SignIn 의 SignInViewFactory 를 보겠습니다.</p><pre>public struct SignInViewFactory: ViewFactory {<br>  <br>  public func makeView(<br>    _ route: SignInStep,<br>    coordinator: PassthroughSubject&lt;NavigationEvent&lt;FeatureRoute&gt;, Never&gt;<br>  ) -&gt; some View {<br>    switch route.step {<br>    case .signIn:<br>      SignInView(<br>        coordinator: coordinator,<br>    ...<br>      )<br>    }<br>  }<br>}</pre><pre>public struct SignInStep: Hashable {<br>  public private(set) var step: Step<br>  <br>  public init(step: Step) {<br>    self.step = step<br>  }<br>  <br>  public enum Step: Hashable {<br>    case signIn<br>    /// 필요하면 추가<br>  }<br>  <br>  public func hash(into hasher: inout Hasher) {<br>    hasher.combine(step)<br>  }<br>}</pre><p>이처럼 SignInViewFactory는 로그인 기능의 화면 전환만을 담당합니다. 이 팩토리는 SignInStep을 통해 필요한 화면을 식별하고, 해당 화면에 필요한 의존성을 주입한 뒤, 적절한 View를 생성하는 역할만 수행해요.</p><p>핵심은, <strong>해당 ViewFactory가 자신의 Route(Step)만 알고 있을 뿐</strong>, 상위 네비게이션 흐름(FeatureRoute)에 대해서는 아무것도 알지 못한다는 점이에요.</p><p>이런 구조 덕분에 각 기능 모듈은 서로 독립적으로 존재할 수 있고, ViewFactory들도 완전히 분리된 상태로 유지됩니다. 결과적으로 전체 화면 전환 구조는 모듈화되고 기능별로 깔끔하게 분리되면서도, 앱의 전체적인 네비게이션 흐름은 자연스럽게 연결됩니다.</p><p>덕분에 전체 화면 전환 구조를 모듈화하고, 기능별로 명확히 분리하면서도, 전체 앱의 네비게이션 흐름은 유기적으로 연결할 수 있게 됩니다.</p><p>또 한 가지 중요한 부분은 navigationSubject인데요.</p><p>이 subject는 PassthroughSubject&lt;NavigationEvent&lt;NavigationContext&gt;, Never&gt; 타입으로, 화면 전환 이벤트를 외부로 publish하는 역할을 해요.</p><p>즉, 하위 화면에서 발생한 네비게이션 이벤트를 이 subject를 통해 Coordinator 쪽으로 전달하게 되고, Coordinator는 전달받은 이벤트를 해석해서 적절한 화면 전환을 수행합니다.</p><p>이러한 구조 덕분에 우리는 다음과 같은 장점을 얻을 수 있어요:</p><ul><li>View는 자신이 어디로 이동할지 모른 채 오직 이벤트만 발행합니다 (decoupling).</li><li>Coordinator는 이 이벤트를 받아 해석하고, 어떤 ViewFactory를 통해 어떤 View를 띄울지 결정합니다 (control inversion).</li><li>각 Feature 모듈은 자신만의 Route와 ViewFactory를 가지므로 <strong>모듈 간 의존성이 생기지 않습니다.</strong></li></ul><p>PassthroughSubject&lt;NavigationEvent&lt;NavigationContext&gt;, Never&gt; 에 NavigationEvent라는 녀석이 있습니다.</p><pre>public enum NavigationEvent&lt;Route: Hashable&gt; {<br>  case push(Route)<br>  case pop<br>  case popTo(Route)<br>  case popToRoot<br>  case presentFullScreen(Route)<br>  case dismissFullScreen<br>}</pre><p>이렇게 생겼는데요, 결국 네비게이션 이벤트를 정의한 enum이라고 보면 됩니다.</p><p>결국 어떤 화면을 “어떻게” 띄울 것인가를 결정하는 타입이라고 볼 수 있겠네요.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NvlhvV4twAJagakmkc3V8g.png" /></figure><p>PassthroughSubject를 통해서 어느 화면을 띄울지 결정했다면, 이것을 핸들링 하는 코디네이터 객체가 필요하게 됩니다.</p><p>이 객체는 NavigationEvent를 구독하여, 그 이벤트의 종류에 따라 내부의 NavigationPath나 풀스크린 상태를 업데이트해주는 구조죠.</p><pre>import SwiftUI<br>import Combine<br><br>public final class NavigationCoordinator&lt;Route: Hashable&gt;: ObservableObject {<br>  @Published public var navigationPath = NavigationPath()<br>  @Published public var isFullScreenPresented = false<br>  @Published public var fullScreenPath = NavigationPath()<br>  public var fullScreenRoute: Route? = nil<br>  public var eventSubject = PassthroughSubject&lt;NavigationEvent&lt;Route&gt;, Never&gt;()<br>  <br>  private var cancellables = Set&lt;AnyCancellable&gt;()<br>  private var navigationStack: [Route] = []<br>  private var fullScreenStack: [Route] = []<br>  <br>  public init() {<br>    eventSubject<br>      .sink { [weak self] event in<br>        self?.handle(event: event)<br>      }<br>      .store(in: &amp;cancellables)<br>  }<br>  <br>  private func handle(event: NavigationEvent&lt;Route&gt;) {<br>    switch event {<br>    case .push(let route):<br>      if isFullScreenPresented {<br>        fullScreenStack.append(route)<br>        fullScreenPath.append(route)<br>      } else {<br>        navigationStack.append(route)<br>        navigationPath.append(route)<br>      }<br>    case .pop:<br>      if isFullScreenPresented {<br>        if fullScreenStack.isEmpty {<br>          isFullScreenPresented = false<br>          fullScreenRoute = nil<br>        } else {<br>          fullScreenStack.removeLast()<br>          fullScreenPath = NavigationPath(fullScreenStack)<br>        }<br>      } else if !navigationStack.isEmpty {<br>        navigationStack.removeLast()<br>        navigationPath = NavigationPath(navigationStack)<br>      }<br>    case .popToRoot:<br>      if isFullScreenPresented {<br>        fullScreenStack = []<br>        fullScreenPath = NavigationPath()<br>        isFullScreenPresented = false<br>        fullScreenRoute = nil<br>      }<br>      navigationStack = []<br>      navigationPath = NavigationPath()<br>    case .popTo(let route):<br>      if isFullScreenPresented {<br>        if let index = fullScreenStack.lastIndex(of: route) {<br>          let newStack = Array(fullScreenStack[...index])<br>          fullScreenStack = newStack<br>          fullScreenPath = NavigationPath(newStack)<br>        }<br>      } else {<br>        if let index = navigationStack.lastIndex(of: route) {<br>          let newStack = Array(navigationStack[...index])<br>          navigationStack = newStack<br>          navigationPath = NavigationPath(newStack)<br>        }<br>      }<br>    case .presentFullScreen(let route):<br>      guard !isFullScreenPresented else { return }<br>      isFullScreenPresented = true<br>      fullScreenRoute = route<br>    case .dismissFullScreen:<br>      guard isFullScreenPresented else { return }<br>      isFullScreenPresented = false<br>      fullScreenRoute = nil<br>      fullScreenPath = NavigationPath()<br>    }<br>  }<br>}</pre><h3>NavigationPath와 Stack을 분리한 이유</h3><p>여기서 눈여겨볼 부분은 navigationPath 외에도 별도로 navigationStack이라는 [Route] 배열을 관리한다는 점이에요.</p><p>NavigationPath는 내부적으로 AnyHashable 기반의 타입 지워진 값들을 사용하기 때문에, 실제 값을 추적하거나 조작하기가 쉽지 않아요.</p><p>예를 들어 popTo(route)와 같이 특정 route까지 스택을 잘라내는 작업은 NavigationPath만으로는 구현하기 까다롭죠.</p><p>하지만 [Route] 배열을 직접 관리하면 이러한 작업을 훨씬 직관적으로 처리할 수 있어요.</p><p>따라서 navigationStack과 fullScreenStack으로 화면 스택을 추적하고, 화면 갱신이 필요할 때는 NavigationPath(...)를 새로 생성해서 반영합니다.</p><h3>NavigationStack + FullScreen 전환 분리</h3><p>또 하나 흥미로운 건 navigationPath와 fullScreenPath를 따로 관리한다는 점입니다.</p><p>SwiftUI에서 .fullScreenCover는 기본적으로 하나의 화면만 덮기 때문에, 이 안에서도 다시 navigation stack을 쓰고 싶다면 별도의 NavigationPath를 유지해야 해요.</p><p>그래서 이 구조에서는:</p><ul><li>isFullScreenPresented로 현재 풀스크린 여부를 판단하고</li><li>fullScreenRoute를 통해 어떤 화면을 덮고 있는지 추적하고</li><li>fullScreenPath로 그 안의 네비게이션 흐름까지 관리할 수 있습니다.</li></ul><p>이렇게 만든 코디네이터 패턴을 NavigationStack에 적용해보겠습니다.</p><pre>struct AppView: View {<br>  @StateObject private var coordinator = NavigationCoordinator&lt;FeatureRoute&gt;()<br>  <br>  var body: some View {<br>      NavigationStack(path: $coordinator.navigationPath) {<br>        TabbarViewWrapperView(navigationSubject: coordinator.eventSubject)<br>          .navigationDestination(for: FeatureRoute.self) { route in<br>            RootViewFactory().makeView(route, navigationSubject: coordinator.eventSubject)<br>          }<br>      }<br>      .fullScreenCover(isPresented: $coordinator.isFullScreenPresented) {<br>        if let route = coordinator.fullScreenRoute {<br>          NavigationStack(path: $coordinator.fullScreenPath) {<br>            RootViewFactory().makeView(route, navigationSubject: coordinator.eventSubject)<br>              .navigationDestination(for: FeatureRoute.self) { route in<br>                RootViewFactory().makeView(route, navigationSubject: coordinator.eventSubject)<br>              }<br>          }<br>        }<br>      }<br>    }<br>  }<br>}</pre><p>이 구조에서 눈여겨볼 부분은 두 가지입니다.</p><p>첫째, NavigationStack과 .fullScreenCover가 모두 @StateObject로 관리되는 NavigationCoordinator&lt;FeatureRoute&gt;를 기반으로 구성된다는 점이에요.</p><p>즉, 화면 전환의 상태는 모두 이 하나의 Coordinator 객체를 통해 제어되고, View 단에서는 어떤 화면을 띄워야 할지를 전혀 신경 쓰지 않습니다.</p><p>둘째, 실제로 화면을 그리는 책임은 전적으로 RootViewFactory에 위임하고 있습니다.</p><p>이 덕분에 각 Feature 모듈은 자신만의 ViewFactory만 신경 쓰면 되고, 상위에서는 <strong>Route enum만으로 모든 화면 흐름을 통제</strong>할 수 있어요.</p><p>최종적으로 Feature 모듈인 SignIn모듈에서 coordinator를 사용하는 코드를 살펴보겠습니다.</p><pre>public struct SignInView: View {<br>  let coordinator: PassthroughSubject&lt;NavigationEvent&lt;FeatureRoute&gt;, Never&gt;<br>  <br>  public init(<br>    coordinator: PassthroughSubject&lt;NavigationEvent&lt;FeatureRoute&gt;, Never&gt;,<br>  ...<br>  ) {<br>    self.coordinator = coordinator<br>    ...<br>  }<br>  <br>  public var body: some View {<br>    ZStack {<br>    ...<br>    ...<br>     await handleSignIn(with: type)<br>    ...<br>    ...<br>  }<br>  <br>  @MainActor<br>  private func handleSignIn(with provider: OauthProvider) async {<br>    do {<br>   ...<br>      coordinator.send(.dismissFullScreen)<br>    }<br>  }<br>}</pre><p>뷰에서도 Coordinator가 제공하는 navigationSubject만 받아서 .send(...)를 호출하면 되기 때문에, 모든 네비게이션 흐름은 <strong>의도 기반(Event-Driven)</strong>으로 처리됩니다.</p><p>이러한 설계를 통해 다음과 같은 이점을 얻을 수 있어요:</p><ul><li>View는 오직 UI와 사용자 상호작용에만 집중</li><li>화면 전환 로직은 Coordinator에 집중되어 테스트 및 유지보수 용이</li><li>Feature 간 결합도를 낮춘 명확한 모듈 분리</li><li>복잡한 전환 시나리오(예: 풀스크린 + 네비게이션 동시 처리)도 하나의 흐름 안에서 처리 가능</li></ul><p>이쯤에서 이런 의문이 들 수 있어요.</p><p>🤨 그냥 최상위 NavigationStack의 @State로 들고있는 NavigationPath를 하위뷰의 생성자 주입으로 바인딩 하면 되는게 아닌가?</p><p>하지만 그렇게 해버리면 <strong>화면 전환의 주도권이 View에 쏠리게 됩니다.</strong></p><p>NavigationPath를 @Binding이나 ObservedObject 형태로 하위 뷰에 전달해서, 하위 뷰가 직접 navigationPath.append(...), navigationPath.removeLast() 등을 호출하게 되면</p><p>그 순간부터 View는 단순히 UI를 그리는 수준을 넘어서, <strong>앱의 흐름(flow)과 상태 전환까지 관장하는 역할을 떠안게 돼요.</strong></p><p>이건 몇 가지 명백한 문제를 야기합니다.</p><h4><strong>1. 관심사 분리가 무너집니다</strong></h4><p>화면은 UI와 유저 상호작용에만 집중해야 하는데, “지금 어떤 화면으로 가야 하는지”, “어디까지 pop 해야 하는지” 같은 <strong>비즈니스 흐름까지 직접 판단</strong>하게 됩니다.</p><p>이는 코드를 읽는 사람이 동작의 의도를 파악하기 어렵게 만들며,</p><p>동일한 전환 로직이 여러 뷰에 중복되기 쉽습니다.</p><h4>2. 테스트하기 어렵습니다</h4><p>하위 뷰가 직접 NavigationPath를 조작하면, 해당 뷰의 독립적인 테스트나 네비게이션 흐름의 mocking이 사실상 불가능해집니다.</p><p>UI 테스트에서는 경로 변경을 트리거할 수 있지만, 유닛 테스트에서는 화면 이동의 의도를 검증하기가 거의 불가능합니다.</p><h4>3. 확장성과 재사용성이 떨어집니다</h4><p>처음에는 단순한 append/pop만으로 충분하지만, 시간이 지날수록 복잡한 조건 분기와 화면 흐름이 생깁니다.</p><p>예를 들어 로그인 후 동의 화면을 거치거나, 팝업 표시 후 다음 화면으로 이동하는 등의 상황이 발생합니다.</p><p>이런 흐름을 뷰 내부에서 처리하면, 해당 뷰는 특정 문맥(예: 로그인 후 진입)에서만 사용 가능하게 되어 재사용성이 떨어지고 유지보수가 어려워집니다.</p><p>바로 이 지점에서 NavigationEvent 기반의 이벤트 전달 방식이 필요합니다.</p><p>하위 뷰는 “나는 이 화면으로 이동하고 싶어”, “이 화면을 닫고 싶어”와 같은 <strong>의도(Intent)</strong>만을 발행하고, Coordinator는 그 의도를 받아서 실제 네비게이션을 <strong>실행(Interpret)</strong>합니다.</p><p>이렇게 설계를 하면:</p><ul><li>View는 UI에만 집중할 수 있고</li><li>화면 전환은 중앙 집중적으로 관리되며</li><li>복잡한 전환 흐름도 선언적으로 표현할 수 있게 됩니다.</li></ul><p>즉, <strong>NavigationPath를 하위 뷰에 직접 넘겨서 조작하게 하는 방식은 단기적으로는 간단해 보여도, 장기적으로는 유지보수성과 테스트 가능성 모두를 해치게 됩니다.</strong></p><p>그럼 마지막으로, 이 코디네이터 패턴이 실제로 어떻게 동작하는지를 확인해보기 위해, 아주 간단한 테스트용 라우트와 뷰 구조를 구성해보겠습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/295/1*wtoGVGD0t3wyIOX4eMpHdw.gif" /><figcaption>Router의 테스트 앱</figcaption></figure><p>먼저, 테스트용 라우트는 SampleRoute라는 enum으로 구성되어 있고, 각 케이스는 단순히 문자열로 구분할 수 있도록 String, Identifiable, CaseIterable을 채택하고 있습니다.</p><pre>enum SampleRoute: String, Hashable, Identifiable, CaseIterable {<br>  var id: String {<br>    return self.rawValue<br>  }<br>  <br>  case a, b, c, d, e, f, g<br>}</pre><p>이제 이 SampleRoute에 대응하는 ViewFactory를 만들어볼게요. SampleViewFactory는 ViewFactory 를 채택하고 있으며, 각 라우트에 따라 간단한 테스트용 View를 반환합니다.</p><pre>struct SampleViewFactory: ViewFactory {<br>  <br>  func makeView(_ route: SampleRoute, navigationSubject: PassthroughSubject&lt;NavigationEvent&lt;SampleRoute&gt;, Never&gt;) -&gt; some View {<br>    switch route {<br>    case .a:<br>      AView(coordinator: navigationSubject)<br>    case .b:<br>      BView(coordinator: navigationSubject)<br>    case .c:<br>      CView(coordinator: navigationSubject)<br>    case .d:<br>      DView(coordinator: navigationSubject)<br>    case .e:<br>      EView(coordinator: navigationSubject)<br>    case .f:<br>      FView(coordinator: navigationSubject)<br>    case .g:<br>      GView(coordinator: navigationSubject)<br>    }<br>  }<br>}</pre><p>각 View는 실제 화면 전환과는 무관한, 단순히 이름만 표기하는 테스트용 UI여도 상관없습니다.</p><p>핵심은 라우트 → 뷰의 연결이 Factory를 통해 이루어졌다는 점이에요.</p><p>그 다음은 직접 이벤트를 트리거해볼 수 있는 RouterView입니다.</p><pre><br>struct RouterView: View {<br>  var coordinator: PassthroughSubject&lt;NavigationEvent&lt;SampleRoute&gt;, Never&gt;<br>  <br>  var body: some View {<br>    ScrollView(.vertical) {<br>      VStack(spacing: 4) {<br>        ForEach(SampleRoute.allCases) { route in<br>          Button {<br>            coordinator.send(.push(route))<br>          } label: {<br>            Text(&quot;push goto \(route.rawValue)&quot;)<br>              .foregroundStyle(.black)<br>          }<br>        }<br>        <br>        ForEach(SampleRoute.allCases) { route in<br>          Button {<br>            coordinator.send(.presentFullScreen(route))<br>          } label: {<br>            Text(&quot;full screen present \(route.rawValue)&quot;)<br>              .foregroundStyle(.black)<br>          }<br>        }<br>        <br>        Button {<br>          coordinator.send(.pop)<br>        } label: {<br>          Text(&quot;pop&quot;)<br>        }<br>        <br>        Button {<br>          coordinator.send(.dismissFullScreen)<br>        } label: {<br>          Text(&quot;dismiss fullScreen&quot;)<br>        }<br>        <br>        Button {<br>          coordinator.send(.popTo(SampleRoute.b))<br>        } label: {<br>          Text(&quot;pop to B if it&#39;s stacked&quot;)<br>        }<br>        <br>      }<br>    }<br>    .frame(maxWidth: .infinity)<br>    .padding(.top, 20)<br>  }<br>}</pre><p>새로운 Route를 추가하거나 전환 방식을 확장할 때에도, 이 테스트 뷰만 있으면 빠르게 검증이 가능하죠.</p><p>이처럼 ViewFactory + Coordinator + NavigationEvent 기반의 설계는 <strong>SwiftUI의 선언적 구조를 해치지 않으면서도, 명확한 역할 분리와 테스트 가능성까지 확보할 수 있는 강력한 화면 설계 패턴 </strong>이라고 할 수 있습니다.</p><p>실제 코드와 구현이 궁금하신 분들은 아래 깃허브를 참고하시면 좋겠습니다.</p><p><a href="https://github.com/ttok-deal-lab/Mercury">GitHub - ttok-deal-lab/Mercury</a></p><h3>이 시리즈의 글</h3><ul><li><a href="https://medium.com/@bbuyo/%EA%B2%BD%EB%A7%A4-%EC%A0%95%EB%B3%B4-%EC%95%B1-%EC%84%A4%EA%B3%84%ED%95%98%EA%B8%B0-984f4baaee9f">경매 임장 어플리케이션: 설계하기</a></li><li><a href="https://medium.com/@bbuyo/%EA%B2%BD%EB%A7%A4-%EC%A0%95%EB%B3%B4-%EC%95%B1-github-action-%EC%8B%B8%EC%9B%8C-%EC%9D%B4%EA%B8%B0%EA%B8%B0-b91dbd5c1a07">경매 임장 어플리케이션: CI, CD 구성</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d229f7b9bb58" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[경매 임장 어플리케이션: CI, CD 구성]]></title>
            <link>https://medium.com/@bbuyo/%EA%B2%BD%EB%A7%A4-%EC%A0%95%EB%B3%B4-%EC%95%B1-github-action-%EC%8B%B8%EC%9B%8C-%EC%9D%B4%EA%B8%B0%EA%B8%B0-b91dbd5c1a07?source=rss-3bb76b7aabf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/b91dbd5c1a07</guid>
            <dc:creator><![CDATA[뿌요]]></dc:creator>
            <pubDate>Tue, 01 Oct 2024 10:19:12 GMT</pubDate>
            <atom:updated>2025-04-17T14:34:33.459Z</atom:updated>
            <content:encoded><![CDATA[<p>Modular Project + Tuist + Fastlane Match + Github Action</p><h4>이전 글</h4><p><a href="https://medium.com/@bbuyo/%EA%B2%BD%EB%A7%A4-%EC%A0%95%EB%B3%B4-%EC%95%B1-%EC%84%A4%EA%B3%84%ED%95%98%EA%B8%B0-984f4baaee9f">경매 임장 어플리케이션: 설계하기</a></p><p>Github Action을 이용한 CI 및 CD에 구성 방식에 대해서 다뤄보겠습니다.</p><p>저는 Bitbucket Pipeline을 이용한 local host 구축경험만 있고, 이번처럼 빌드머신 없이 클라우드 환경에서의 작업 경험이 처음이라 많이 헤메었던 기억이 나는데요, 이 포스트를 통해 CI와 CD를 구축하실 때 도움이 되었으면 좋겠습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/382/1*tFpBaa-y7vylsBb72_BDtA.png" /></figure><p>프로젝트는 xcconfig 파일들을 통해 각 모듈의 build setting을 설정하고 있기 때문에, 이 xcconfig들의 구성과 연결을 이해하는게 중요해요.</p><p><a href="https://github.com/ttok-deal-lab/Mercury/tree/develop/XCConfigs">여기</a>에서 직접 파일구성을 확인할 수 있어요</p><p>모듈화 된 프로젝트는 아래 그림처럼, 빌드 및 배포 대상이 되는 어플리케이션이 다른 모듈들을 참조하고 있는 형태일 거에요.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/735/1*IpH2FTvc4GsfTWbFtB3c_A.png" /></figure><p>때문에 App에만 적용되는 build setting을 다른 모듈의 build setting과 섞이지 않도록 분리해서 하나 만들어줬어요. 파일 명은 Mercury.xcconfig라고 할게요.</p><p>이 Mercuery.xcconfig의 구성은 다음과 같아요.</p><pre>#include &quot;./MarketingVersion.xcconfig&quot;<br>#include &quot;./Sensitive.xcconfig&quot;<br><br>CODE_SIGN_IDENTITY = iPhone Development<br>PROVISIONING_PROFILE_SPECIFIER = match Development com.auction.mercury<br>IPHONEOS_DEPLOYMENT_TARGET = 16.0<br>PRODUCT_NAME = $(TARGET_NAME)<br>SUPPORTS_MACCATALYST = NO<br>SWIFT_VERSION = 5.9<br>TARGETED_DEVICE_FAMILY = 1<br>OTHER_LDFLAGS=$(inherited) -ObjC -all_load<br>CODE_SIGN_STYLE = Manual<br>DEVELOPMENT_TEAM = M3U22RZ325<br>CODE_SIGNING_REQUIRED = YES<br>CODE_SIGNING_ALLOWED = YES<br>VERSIONING_SYSTEM = Apple Generic<br>CURRENT_PROJECT_VERSION = 1</pre><p>CODE_SIGN_IDENTITY와 PROVISIONING_PROFILE_SPECIFIER를 보면 기본적으로 build를 위한 세팅이 들어가 있는것을 볼 수 있어요. 하지만 나중에 배포를 위한 값으로 덮어씌울거임다.</p><p>맨 위에 #include 되어 있는 다른 xcconfig들은 이름에서 알 수 있듯 마케팅버전과 공개되면 안되는 값들을 위한 파일이에요.</p><p>이렇게 구성하면 App에 대한 xcconfig 구성은 끝이에요.</p><p>이제 나머지 모듈은 어떻게 구성되어 있는지 볼게요. 나머지 모듈을 위한 xcconfig 파일명은 Module.xcconfig에요.</p><pre>CODE_SIGN_STYLE = Automatic<br>CODE_SIGNING_REQUIRED = NO<br>CODE_SIGNING_ALLOWED = NO<br>CODE_SIGNING_INJECT_BASE_ENTITLEMENTS = NO<br>DEVELOPMENT_TEAM = M3U22RZ325</pre><p>Mercury.xcconfig와는 확연한 차이가 있는데, 그것은 Manual 한 코드사이닝을 막는거에요. (CODE_SIGN_STYLE = Automatic)</p><p>다른 모듈(서드파티 포함)은 프레임워크 및 라이브러리로 구성되어 있는데, 이 모듈들에게 서명기능을 강제하면 App용으로 구성되어 있는 Match Provisioning Profile로 해당 모듈을 서명하려는 시도가 일어나 실패하게 돼요.</p><p>다른 모듈들은 최종적으로 이 앱에 포함되어 있기 때문에, 결과물인 App에만 정상적으로 서명이 이루어지면 전체 앱의 무결성이 이루어진다고 할 수 있어요.</p><p>그림으로 정리해볼까요?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qDxZQcQ4RlorXG_1QTWXeg.png" /></figure><p>Develop, Stage, Release는 예상하셨다시피 환경분리를 위한 전처리 플래그를 세팅한 값 등이 들어가 있어요.</p><p>여기까지 이해하셨다면 다음으로 fastlane에서 어떻게 App 모듈 앱스토어에 업로드하는지 알아보시죠!</p><p>앱을 앱스토어에 전달하려면 세 가지 단계가 필요해요.</p><ol><li>프로비저닝 프로파일 읽어오기</li><li>빌드 + 아카이브하기</li><li>앱스토어에 올리기</li></ol><p>차례대로 구현을 살펴볼게요.</p><h3>프로비저닝 프로파일 읽어오기</h3><p>프로젝트는 Match를 이용하여 인증서를 관리하고 있어요.</p><p>구체적으로는, Github에 private 레포지토리를 생성하고 Apple Developer의 Provisioning Profiles와 Certificates를 해당 레포에 업로드하여 프로파일 관리를 일원화하는거에요.</p><p>본격적으로 코드를 보기에 앞서 설명이 필요한 부분이 있어요.</p><p>“#{ ~~~ }” 으로 되어있는 부분은 fastlane 폴더에 .env.default 파일에 있는 값들을 미리 불러와서 변수에 저장해 놓고, 해당 변수를 가져다 쓰는 부분이에요.</p><p>예를 들어 .env.default에 아래와 같은 값이 있다고 하면</p><pre>MATCH_KEYCHAIN_NAME=&quot;temp_keychain&quot;<br>MATCH_KEYCHAIN_PASSWORD=&quot;password_for_temp_keychain&quot;</pre><p>fastfile에서는 상위에 이 값들을 읽어와서 변수로 지정해요</p><pre>MATCH_KEYCHAIN_NAME = ENV[&quot;MATCH_KEYCHAIN_NAME&quot;]<br>MATCH_KEYCHAIN_PASSWORD = ENV[&quot;MATCH_KEYCHAIN_PASSWORD&quot;]</pre><p>그럼 이제 fastfile에서 이 변수들을 자유롭게 사용할 수 있어요.</p><pre>...  <br>  keychain_name: &quot;#{MATCH_KEYCHAIN_NAME}&quot;,<br>  keychain_password: &quot;#{MATCH_KEYCHAIN_PASSWORD}&quot;<br>)</pre><p>이제 Fastfile에서 어떻게 match 프로파일을 읽어오는지 살펴볼게요. <br><a href="https://docs.fastlane.tools/actions/match/#match">공식문서</a>는 기본적으로 함께 참고해주세요.</p><pre>lane :match_appstore do<br>  match(<br>    storage_mode: &quot;git&quot;,<br>    type: &quot;appstore&quot;,<br>    readonly: true,<br>    skip_docs: true,<br>    generate_apple_certs: false,<br>    app_identifier: &quot;#{APP_IDENTIFIER}&quot;,<br>    api_key_path: &quot;fastlane/portal.json&quot;,<br>    git_private_key: &quot;#{GIT_PRIVATE_KEY}&quot;,<br>    git_url: &quot;#{MATCH_GIT_URL}&quot;,<br>    git_branch: &quot;#{MATCH_GIT_BRANCH}&quot;,<br>    keychain_name: &quot;#{MATCH_KEYCHAIN_NAME}&quot;,<br>    keychain_password: &quot;#{MATCH_KEYCHAIN_PASSWORD}&quot;<br>  )<br>end</pre><ol><li><strong>storage_mode</strong>: 프로파일을 저장한 레포지토리의 타입 (github, bitbucket 등등이 있어요) 지정</li><li><strong>type</strong>: 프로파일 타입(development, adhoc, appstore) 지정</li><li><strong>readonly</strong>: 인증서 갱신 및 읽기 여부. CI 환경이므로 읽기 기능만 세팅</li><li><strong>generate_apple_certs</strong>: 필요한 경우 새로운 인증서 생성 여부. CI 환경이므로 기존 인증서만 사용하도록 세팅</li><li><strong>api_key_path</strong>: App Store Connect API의 정보가 담긴 json 파일. <a href="https://docs.fastlane.tools/app-store-connect-api/#using-fastlane-api-key-json-file">여기</a>를 참고하세요. 민감한 정보이므로 반드시 gitignore등의 처리를 통해 숨겨야 합니다.</li><li><strong>git_private_key</strong>: Github의 Personal Access Token(PAT) 정보. 마찬가지로 숨겨야 합니다.</li><li><strong>git_branch</strong>: Match 저장소의 브랜치. 이 옵션이 없으면 master를 기본으로 바라봅니다.</li><li><strong>keychain_name</strong>: CI 환경에서 사용할 임시 키체인의 이름을 지정합니다. 아무값이나 넣어도 괜찮습니다.</li><li><strong>keychain_password</strong>: CI 환경에서 사용할 임시 키체인의 비밀번호을 지정합니다. 아무값이나 넣어도 괜찮습니다.</li></ol><p>자, 이렇게 했으면 Match 저장소에 있는 프로파일들을 성공적으로 불러올 수 있어요.</p><p>이제 이 프로파일 정보를 가지고 앱을 빌드하고 아카이브 시켜볼게요.</p><h3>빌드 + 아카이브 하기</h3><p>Fastlane의 Gym을 이용해볼게요. <a href="https://docs.fastlane.tools/actions/gym/">공식문서</a>를 보면 사용법이 자세히 나와있어요. gym에 어떤 인자를 전달하는지 살펴볼게요.</p><pre>gym(<br>  clean: true,<br>  verbose: true,<br>  workspace: &quot;Mercury.xcworkspace&quot;,<br>  scheme: &quot;MercuryApp&quot;,<br>  configuration: &quot;Release&quot;,<br>  export_method: &quot;app-store&quot;,<br>  xcargs: &quot;CODE_SIGN_IDENTITY=&#39;iPhone Distribution&#39; PROVISIONING_PROFILE_SPECIFIER=&#39;match AppStore com.auction.mercury&#39;&quot;,<br>  output_directory: &quot;./output&quot;,<br>  export_options: {<br>    method: &quot;app-store&quot;,<br>    provisioningProfiles: {<br>      &quot;com.auction.mercury&quot; =&gt; &quot;match AppStore com.auction.mercury&quot;<br>    }<br>  }<br>)</pre><ol><li><strong>clean</strong>: 프로젝트 빌드하기 전 clean</li><li><strong>verbose</strong>: 상세한 로그 요청</li><li><strong>workspace</strong>: 워크스페이스의 이름 지정</li><li><strong>scheme</strong>: 빌드 및 아카이브 대상 스킴 지정</li><li><strong>configuration</strong>: 빌드 및 아카이브 할 환경(Configuration) 지정</li><li><strong>export_method</strong>: 아카이브 타입 지정</li><li><strong>xcargs</strong>: (중요) xcodebuild에 추가인수를 전달합니다. 결과적으로 프로젝트에서 지정한 xcconfig의 값들을 덮어씌울 수 있습니다. 배포에 알맞은 값들을 넣어줍니다. CODE_SIGN_IDENTITY는 앱 서명에 사용될 인증서의 유형을 지정합니다. 배포할 것이므로 iPhone Distribution으로 설정합니다. PROVISIONING_PROFILE_SPECIFIER은 사용할 프로비저닝 프로파일을 지정합니다. gym 실행 전에 match appstore를 읽어왔으므로, 읽어온 프로파일의 이름을 지정합니다.</li><li><strong>output_directory</strong>: 추출될 ipa의 경로 지정</li><li><strong>export_options</strong>: (중요) 아카이브 옵션입니다. 여기서 프로비저닝 프로필 정보를 배포 스킴과 매칭시킵니다. 만약 export_options의 provisioiningProfiles가 빠져있다면, error: exportArchive Provisioning profile “match Development com.auction.mercury” is not an “iOS App Store” profile. 에러가 발생합니다. 이는 Mercury.xcconfig의 PROVISIONING_PROFILE_SPECIFIER = match Development com.auction.mercury 값이 아카이브 옵션으로 취급되어 발생하므로 아카이브 옵션을 반드시 따로 설정시키는 것이 좋습니다. (혹은 배포용 xcconfig를 만드는 방법도 있습니다.)</li></ol><p>이렇게 하면 ipa 파일이 output_directory에 지정한 폴더안에 생성돼요. 이제 이 파일을 앱스토어에 올려볼까요?</p><h3>앱스토어에 올리기</h3><p>fastlane pilot을 통해 앱스토어에 업로드 시켜볼게요. <a href="https://docs.fastlane.tools/actions/pilot/#pilot">공식문서</a>에 더 자세한 내용이 있어요.</p><pre>pilot(<br>  skip_waiting_for_build_processing: true,<br>  app_identifier: &quot;#{APP_IDENTIFIER}&quot;,<br>  team_id: &quot;#{TEAM_ID}&quot;,<br>  ipa: &quot;./output/AuctionGod.ipa&quot;,<br>  api_key: api_key<br>)</pre><p>인자들을 살펴보죠.</p><ol><li><strong>skip_waiting_for_build_processing</strong>: 빌드가 완전하게 올라가는 시간을 스킵하는지에 대한 여부에요. CI 환경에서는 빌드시간에 따라 요금이 부과되기 때문에 스킵합니다.</li><li><strong>app_identifier</strong>: 앱 Bundle Id 지정</li><li><strong>team_id</strong>: Apple Developer의 Team ID 지정.</li><li><strong>ipa</strong>: 아카이브 결과로 나온 ipa 파일의 경로</li><li><strong>api_key</strong>: 아래에서 자세하게 설명할게요.</li></ol><pre>api_key = app_store_connect_api_key(<br>  key_id: &quot;#{APP_STORE_CONNECT_KEY_ID}&quot;,<br>  issuer_id: &quot;#{APP_STORE_CONNECT_ISSUER_ID}&quot;,<br>  key_content: &quot;#{APP_STORE_CONNECT_KEY_BASE64}&quot;,<br>  is_key_content_base64: true<br>)<br><br>...<br><br>pilot(<br>  ...<br>  api_key: api_key<br>)</pre><p>api_key_path와 같이 App Store Connect API의 값을 담지만 key_content에는 앱스토어 커넥트 API의 키값(.p8)의 내용을 Base64로 인코딩 시킨 값이 들어가요.</p><p>이렇게 한 이유는 기존에 json형태의 앱스토어 커넥트 API 값을 올바르게 읽어오지 못해 invalid curve name 오류가 발생했기 때문이에요. 이 에러는 키 값이 &quot;-----BEGIN PRIVATE KEY-----\n키값\n-----END PRIVATE KEY-----&quot; 이런 형식인데 \n을 누락했거나 큰따옴표(“)를 누락한 경우 발생해요. 하지만 이 경우가 아님에도 지속적으로 오류가 발생해서 키값을 Base64로 인코딩 한 값으로 대체했어요.</p><p>여기까지 오셨다면 정말 고생하셨습니다 :D</p><p>이제 전체 코드를 보면 어떻게 구성됐는지 이해할 수 있어요.</p><h3>전체 코드 (Fastfile)</h3><pre>APPLE_ID = ENV[&quot;APPLE_ID&quot;]<br>TEAM_ID = ENV[&quot;TEAM_ID&quot;]<br>APP_IDENTIFIER = ENV[&quot;APP_IDENTIFIER&quot;]<br>APP_STORE_CONNECT_ISSUER_ID = ENV[&quot;APP_STORE_CONNECT_ISSUER_ID&quot;]<br>APP_STORE_CONNECT_KEY_ID = ENV[&quot;APP_STORE_CONNECT_KEY_ID&quot;]<br>APP_STORE_CONNECT_KEY = ENV[&quot;APP_STORE_CONNECT_KEY&quot;]<br>APP_STORE_CONNECT_KEY_BASE64 = ENV[&quot;APP_STORE_CONNECT_KEY_BASE64&quot;]<br>KEYCHAIN_NAME = ENV[&quot;KEYCHAIN_NAME&quot;]<br>KEYCHAIN_PASSWORD = ENV[&quot;KEYCHAIN_PASSWORD&quot;]<br>GIT_PRIVATE_KEY = ENV[&quot;GIT_PRIVATE_KEY&quot;]<br>DISCORD_WEBHOOK = ENV[&quot;DISCORD_WEBHOOK&quot;]<br>MATCH_GIT_URL = ENV[&quot;MATCH_GIT_URL&quot;]<br>MATCH_GIT_BRANCH = ENV[&quot;MATCH_GIT_BRANCH&quot;]<br>MATCH_KEYCHAIN_NAME = ENV[&quot;MATCH_KEYCHAIN_NAME&quot;]<br>MATCH_KEYCHAIN_PASSWORD = ENV[&quot;MATCH_KEYCHAIN_PASSWORD&quot;]<br><br>platform :ios do<br><br>  lane :match_appstore do<br>    match(<br>      storage_mode: &quot;git&quot;,<br>      type: &quot;appstore&quot;,<br>      readonly: true,<br>      skip_docs: true,<br>      generate_apple_certs: false,<br>      app_identifier: &quot;#{APP_IDENTIFIER}&quot;,<br>      api_key_path: &quot;fastlane/portal.json&quot;,<br>      git_private_key: &quot;#{GIT_PRIVATE_KEY}&quot;,<br>      git_url: &quot;#{MATCH_GIT_URL}&quot;,<br>      git_branch: &quot;#{MATCH_GIT_BRANCH}&quot;,<br>      keychain_name: &quot;#{MATCH_KEYCHAIN_NAME}&quot;,<br>      keychain_password: &quot;#{MATCH_KEYCHAIN_PASSWORD}&quot;<br>    )<br>  end<br><br>  lane :upload_stage_to_testflight do<br>    match_appstore<br><br>    api_key = app_store_connect_api_key(<br>      key_id: &quot;#{APP_STORE_CONNECT_KEY_ID}&quot;,<br>      issuer_id: &quot;#{APP_STORE_CONNECT_ISSUER_ID}&quot;,<br>      key_content: &quot;#{APP_STORE_CONNECT_KEY_BASE64}&quot;,<br>      is_key_content_base64: true<br>    )<br><br>    latest_build = latest_testflight_build_number(<br>      app_identifier: &quot;#{APP_IDENTIFIER}&quot;,<br>      api_key: api_key<br>    )<br><br>    increment_build_number(<br>      xcodeproj: &quot;Projects/MercuryApp/MercuryApp.xcodeproj&quot;,<br>      build_number: latest_build + 1<br>    )<br><br>    gym(<br>      clean: true,<br>      verbose: true,<br>      workspace: &quot;Mercury.xcworkspace&quot;,<br>      scheme: &quot;MercuryApp&quot;,<br>      configuration: &quot;Stage&quot;,<br>      export_method: &quot;app-store&quot;,<br>      xcargs: &quot;CODE_SIGN_IDENTITY=&#39;iPhone Distribution&#39; PROVISIONING_PROFILE_SPECIFIER=&#39;match AppStore com.auction.mercury&#39;&quot;,<br>      output_directory: &quot;./output&quot;,<br>      export_options: {<br>        method: &quot;app-store&quot;,<br>        provisioningProfiles: {<br>          &quot;com.auction.mercury&quot; =&gt; &quot;match AppStore com.auction.mercury&quot;<br>        }<br>      }<br>    )<br><br>    pilot(<br>      skip_waiting_for_build_processing: true,<br>      app_identifier: &quot;#{APP_IDENTIFIER}&quot;,<br>      team_id: &quot;#{TEAM_ID}&quot;,<br>      ipa: &quot;./output/AuctionGod.ipa&quot;,<br>      api_key: api_key<br>    )<br>  end<br><br>  lane :make_keychain_for_CI do // 이건 CI 파이프라인에서만 사용해요<br>    create_keychain(<br>      name: &quot;#{MATCH_KEYCHAIN_NAME}&quot;,<br>      password: &quot;#{MATCH_KEYCHAIN_PASSWORD}&quot;,<br>      timeout: 3600,<br>      unlock: true,<br>      lock_when_sleeps: false<br>    )<br>  end<br><br>end</pre><p>이제 드디어 Github Action의 파이프라인을 살펴볼 시간이 왔어요!</p><p>이 포스트에서는 파이프라인 중 Stage에 올라가는 경우만 설명해요. 전체코드는 <a href="https://github.com/ttok-deal-lab/Mercury/blob/develop/.github/workflows/pipeline.yml">프로젝트의 pipeline 파일</a>를 참고하세요.</p><p>설명하기에 앞서 전체 플로우를 보여드릴게요.</p><pre>stage_merged:<br>    runs-on: macos-latest<br>    if: |<br>      github.event_name == &#39;push&#39; &amp;&amp; github.ref == &#39;refs/heads/stage&#39; ||<br>      github.event_name == &#39;pull_request&#39; &amp;&amp; github.base_ref == &#39;stage&#39;<br><br>    steps:<br>      - uses: actions/checkout@v3<br>      - uses: jdx/mise-action@v2.1.0<br>      - uses: ruby/setup-ruby@v1<br>        with:<br>          ruby-version: &#39;3.3&#39;<br>      <br>      - name: Setup SSH<br>        uses: shimataro/ssh-key-action@v2<br>        with:<br>          key: ${{ secrets.SSH_KEY }}<br>          known_hosts: github.com<br>          config: |<br>            Host github.com<br>              HostName github.com<br>              IdentityFile ~/.ssh/id_rsa<br>              StrictHostKeyChecking yes<br><br>      - name: Fetch Ignore Files<br>        uses: actions/checkout@v3<br>        with: <br>          repository: naldal/Mercury-ignored<br>          token: ${{ secrets.GIT_PRIVATE_KEY }}<br>          path: .ignored-files<br><br>      - name: Copy files to appropriate locations<br>        run: |<br>          cp .ignored-files/Sensitive.xcconfig XCConfigs/<br>          cp .ignored-files/.env.default fastlane/<br>          cp .ignored-files/portal.json fastlane/<br><br>      - name: Setup xcode version<br>        uses: maxim-lobanov/setup-xcode@v1<br>        with:<br>          xcode-version: &#39;16.0&#39;<br>    <br>      - name: Install Fastlane<br>        run: brew install fastlane<br>            <br>      - name: Install mise<br>        run: |<br>          mise install tuist@4.20.0<br>          mise use tuist@4.20.0<br>          mise exec -- tuist version<br><br>      - name: Install Tuist<br>        run: tuist install -u<br><br>      - name: Install Notice Essensial<br>        run: |<br>          brew install libsodium<br>          yes | fastlane add_plugin discord_notifier<br><br>      - name: Test SSH Access<br>        run: git ls-remote git@github.com:naldal/MercuryMatch.git<br><br>      - name: Setup Keychain<br>        run: fastlane ios make_keychain_for_CI<br><br>      - name: Generate Project<br>        run: tuist generate --no-open<br><br>      - name: Upload Testflight<br>        env:<br>          MATCH_PASSWORD: ${{ secrets.MATCH_PASSWORD }}<br>        run: fastlane ios upload_stage_to_testflight<br><br>      - name: Notify<br>        run: fastlane ios discord_alert branch:&quot;Stage&quot;</pre><p>당황…하셨죠..? <br>하지만 하나하나 이해하면 되니까요! 힘내봅시다!</p><pre>runs-on: macos-latest<br>if: |<br>  github.event_name == &#39;push&#39; &amp;&amp; github.ref == &#39;refs/heads/stage&#39; ||<br>  github.event_name == &#39;pull_request&#39; &amp;&amp; github.base_ref == &#39;stage&#39;</pre><p><strong>runs-on</strong>: 파이프라인이 실행될 OS를 설정합니다. 우리는 당연히 macos여야겠죠?<br><strong>if</strong>: push 일 때 브랜치가 stage 일 때혹은, pull_request일 때 base 브랜치가 stage일 때 실행</p><pre>- uses: actions/checkout@v3<br>- uses: jdx/mise-action@v2.1.0<br>- uses: ruby/setup-ruby@v1<br>  with:<br>    ruby-version: &#39;3.3&#39;</pre><p>Github Action의 사용자 라이브러리들을 실행해요.</p><p><strong>actions/checkout@v3</strong>: Git 관련 모든 액션(pull, checkout, fetch …)들을 사용가능하도록 해요.<br><strong>jdx/mise-action</strong>: mise 의 액션들을 사용가능하도록 해요<br><strong>ruby/setup-ruby@v1</strong>: 루비를 설치해요. 루비버전은 3.3으로 고정해요.</p><pre>- name: Setup SSH<br>  uses: shimataro/ssh-key-action@v2<br>  with:<br>    key: ${{ secrets.SSH_KEY }}<br>    known_hosts: github.com<br>    config: |<br>      Host github.com<br>        HostName github.com<br>        IdentityFile ~/.ssh/id_rsa<br>        StrictHostKeyChecking yes</pre><p>SSH 작업을 설정해요. SSH를 통해 프라이빗 저장소에 접근하는 작업을 위해 수행해요.</p><p><strong>uses: shimataro/ssh-key-action@v2</strong>: SSH 설정을 도와주는 사용자 라이브러리<br><strong>key</strong>: 로컬환경에서 SSH 키를 생성 한 후, 개인 키와 공개 키 중 개인 키를 Github Secrets에 저장하여 사용해요.</p><p>좀 더 자세히 설명해볼게요.</p><p>먼저 SSH를 얻으려면 내 컴퓨터에서 아래 커맨드를 실행해요.</p><pre>ssh-keygen -t rsa -b 4096 -C &quot;your_email@example.com&quot; (깃헙과 연결된 이메일)</pre><p>이후 기본경로를 사용하거나 원하는 경로에 SSH키를 저장하고 나면 두 가지 파일이 생성돼요.</p><ol><li>id_rsa: 개인 키 (Private key)</li><li>id_rsa.pub: 공개 키 (Public key)</li></ol><p>이 중 id_rsa 개인키의 파일을 복사해서 프로젝트의 Github Secrets에 저장해요.</p><p>id_rsa.pub는 Github 계정, 특정 저장소에 등록하여 인증을 설정할 수 있어요. Match 저장소의 값들을 읽어올 예정이므로, Match 저장소에 공개 SSH 값을 등록할게요.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RixiX0PjZ4qWQ-gL5IrkiA.png" /></figure><p><strong>known_hosts</strong>: github.com 이하:</p><p>known hosts 는 SSH 연결을 시도할 때 해당 서버(호스트)가 신뢰할 수 있는 서버인지 검증하는데 사용돼요. 값을 github.com으로 설정하면 github.com의 호스트 키를 known_hosts 파일에 추가해요.</p><pre>- name: Fetch Ignore Files<br>  uses: actions/checkout@v3<br>  with: <br>    repository: naldal/Mercury-ignored<br>    token: ${{ secrets.GIT_PRIVATE_KEY }}<br>    path: .ignored-files<br><br>- name: Copy files to appropriate locations<br>  run: |<br>    cp .ignored-files/Sensitive.xcconfig XCConfigs/<br>    cp .ignored-files/.env.default fastlane/<br>    cp .ignored-files/portal.json fastlane/</pre><p>ignore 된 파일들을 다른 저장소에서 불러와요.</p><p>fastlane을 구성하는 .env.default 파일이나 sensitive.xcconfig 처럼 외부에 공개되면 안되지만 프로젝트 구성상 반드시 필요한 파일들을 프라이빗 레포에 담고, 불러온다고 생각하면 돼요.</p><p>불러온 저장소 (naldal/Mercury-ignored) 의 파일들을 임시 경로(.ignore-files)에 담고, cp 명령어를 통해 올바른 디릭토리에 위치시켜요.</p><pre>- name: Setup xcode version<br>  uses: maxim-lobanov/setup-xcode@v1<br>  with:<br>    xcode-version: &#39;16.0&#39;<br><br>- name: Install Fastlane<br>  run: brew install fastlane<br>      <br>- name: Install mise<br>  run: |<br>    mise install tuist@4.20.0<br>    mise use tuist@4.20.0<br>    mise exec -- tuist version<br><br>- name: Install Tuist<br>  run: tuist install -u<br><br>- name: Install Notice Essensial<br>  run: |<br>    brew install libsodium<br>    yes | fastlane add_plugin discord_notifier<br><br><br>- name: Test SSH Access<br>  run: git ls-remote git@github.com:naldal/MercuryMatch.git<br><br>- name: Setup Keychain<br>  run: fastlane ios make_keychain_for_CI</pre><p>어렵지 않은 내용이니 한번에 설명할게요.</p><p><strong>maxim-lobanov/setup-xcode@v1</strong>: Xcode의 버전을 지정해요. (16.0)</p><p><strong>Install Fastlane</strong>: Fastlane을 설치</p><p><strong>Install mise</strong>: mise 설치 및 버전 픽스</p><p><strong>Install Tuist</strong>: 프로젝트 서드파티 의존성 설치</p><p><strong>Install Notice Essensial</strong>: 디스코드 노티를 위한 fastlane 플러그인 설치</p><p><strong>Test SSH Access</strong>: Match 저장소와 SSH 통신이 가능한지 테스트</p><p><strong>Setup Keychain</strong>: CI/CD 환경에서 사용할 임시 키체인 생성. Match 인증서가 이 키체인에 저장돼요. 파이프라인이 끝나면 키체인도 삭제돼요.</p><pre>- name: Generate Project<br>  run: tuist generate --no-open<br><br>- name: Upload Testflight<br>  env:<br>    MATCH_PASSWORD: ${{ secrets.MATCH_PASSWORD }}<br>  run: fastlane ios upload_stage_to_testflight<br><br>- name: Notify<br>  run: fastlane ios discord_alert branch:&quot;Stage&quot;</pre><p><strong>Generate Project</strong>: tuist generate를 이용하여 각 모듈의 .xcodeproj 를 생성해요</p><p><strong>Upload Testflight</strong>: fastfile에 정의한 match 인증서 적용 + 빌드 + 배포 단계를 실행해요. 이때 MATCH_PASSWORD는 Match의 비밀번호에요. 반드시 MATCH_PASSWORD가 Key의 이름이여야 해요.</p><blockquote>공식문서 중:</blockquote><blockquote>To set the passphrase to decrypt your profiles using an environment variable (and avoid the prompt) use MATCH_PASSWORD.</blockquote><p><strong>Notify</strong>: 디스코드 webhook으로 알림을 보내요. 이 <a href="https://github.com/nikolas-theodosis/fastlane-discord_notifier">플러그인</a>을 이용했어요.</p><p>여기까지 해서~ Github Action을 이용한 CI/CD를 성공적으로 마무리 할 수 있었어요.</p><p>배포 파이프라인을 구축하면서 고통받으시는 개발자분들에게 도움이 될 수 있기를 바랍니다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b91dbd5c1a07" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[경매 임장 어플리케이션: 설계하기]]></title>
            <link>https://medium.com/@bbuyo/%EA%B2%BD%EB%A7%A4-%EC%A0%95%EB%B3%B4-%EC%95%B1-%EC%84%A4%EA%B3%84%ED%95%98%EA%B8%B0-984f4baaee9f?source=rss-3bb76b7aabf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/984f4baaee9f</guid>
            <dc:creator><![CDATA[뿌요]]></dc:creator>
            <pubDate>Tue, 24 Sep 2024 14:23:18 GMT</pubDate>
            <atom:updated>2025-04-17T13:54:37.755Z</atom:updated>
            <content:encoded><![CDATA[<p>경매 및 임장 어플리케이션을 개발하여 실제 서비스를 운영하는 것을 목표로 팀을 구성하여 개발을 진행하고 있어요.</p><p>프로젝트의 기초 설계부터 기능 구현, 배포 과정을 차례대로 공유하려고 합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*yPaUDqQafE9_R6fXFDmyGQ.jpeg" /><figcaption><a href="https://pixabay.com/photos/screw-pin-engineering-gold-golden-4929711/">https://pixabay.com/photos/screw-pin-engineering-gold-golden-4929711/</a></figcaption></figure><p><strong>설계를 왜 해야할까요?</strong></p><p>이런 질문을 받으면 여러분들은 뭐라고 대답하실건가요?</p><p>저는 처음 개발을 시작했을 당시 설계와 관련된 아티클을 보면,</p><p>🤨 그냥 잘 돌아가기만 하면 되는거 아닌가? 괜히 복잡하게 짜놓으면 나중에 유지보수는 어떻게 하려고 그러지?</p><p>라는.. 지금 생각해보면 멍청한 생각을 하곤 했는데요;</p><p>여러 경험들과 지식들을 조금씩 습득해나가고 있는 지금 제게 같은 질문을 던진다면 이렇게 대답할 것 같습니다.</p><p>“시스템은 계속 변화를 요구받기 때문에, 변경하기 쉬운 구조를 만드는 것이 시스템이 장기적으로 생존하기 유리하기 때문이다”</p><p>저는 <strong>좋은 설계</strong>에 대한 원칙을 세우고 철저하게 이를 지켜나가는 것을 목표로 프로젝트를 구성할 생각이에요.</p><p>아래 원칙들은 프로젝트의 근간이 되는 설계 원칙입니다.</p><h3>SOLID는 뻔하지만 중요해요.</h3><p>객체지향 설계에서 빠질 수 없는 원칙이 SOLID에요.</p><p>지겹도록 SOLID가 중요하다, 잘 지켜져야 한다~ 고 강조되는 이유는 그만큼 이 원칙을 지켜낼 수록 단단한 구조의 구현과 설계가 가능하기 때문이에요.</p><p>다시 말해 결국 응집도를 높이고 결합도를 낮추기 위한 최소 전제조건이라고 봐야해요.</p><p>아래는 짧게 다섯 항목들을 정리해서 적어놓지만 더 심도있는 내용들은 클린아키텍처의 챕터3(설계원칙) 파트를 보시는 것을 강력하게 추천합니다.</p><ul><li><strong>SRP (Single Responsibility Principle)</strong>: 하나의 모듈은 하나의 이유로만 변경되어야 한다. 이는 기능을 중심으로 코드 블록을 나누는 것이 아니라, 변경의 축(액터)를 기준으로 설계를 분할하라는 요구.</li><li><strong>OCP (Open-Closed Principle)</strong>: 소프트웨어 구성요소는 확장에는 열려 있어야 하고, 기존 코드를 변경하지 않고도 새로운 요구사항을 수용할 수 있어야 한다. 이는 추상화를 통해 정책과 구현을 분리하고, 새로운 기능이 기존 구조를 침범하지 않도록 만드는 설계 방식.</li><li><strong>LSP (Liskov Substitution Principle)</strong>: 하위 타입은 상위 타입을 대체할 수 있어야 한다. 이는 다형성을 보장하는 기술적인 조건이기도 하지만, 본질적으로는 행위의 일관성을 유지하라는 계약에 가깝다.</li><li><strong>ISP (Interface Segregation Principle)</strong>: 클라이언트는 자신이 사용하지 않는 인터페이스에 의존해서는 안 된다. 이는 지나치게 방대한 추상화는 오히려 결합도를 높일 수 있다는 경고이며, 컨텍스트에 맞는 협약 단위를 설계하라는 지침이다.</li><li><strong>DIP (Dependency Inversion Principle)</strong>: 고수준 모듈은 저수준 모듈에 의존해서는 안 되며, 둘 모두 추상화에 의존해야 한다. 이는 구체적 구현에서 독립된 정책 중심의 설계를 가능하게 하며, 궁극적으로는 구현의 교체 가능성을 극대화하는 핵심 기제이다.</li></ul><h3>부끄러운 코드를 짜자</h3><p>객체지향 설계에서 자주 강조되는 개념 중 하나가 바로 “부끄러운 코드”예요.<br> 이 말이 조금 생소하게 느껴질 수도 있지만, 결국 핵심은 객체가 <strong>자신의 책임을 수행하는 데 꼭 필요한 최소한의 퍼블릭 인터페이스만 드러내야 한다</strong>는 거예요.</p><p>내부 상태나 구현 디테일은 최대한 감추고, 바깥에서는 그 객체가 어떤 방식으로 동작하는지 알 필요 없이 필요한 메시지만 주고받는 거죠.</p><p>이렇게 설계가 되어 있을 때 상속이나 다형성도 훨씬 자연스럽고 강력하게 작동해요.</p><p>결국 부끄러운 코드라는 건 <strong>외부에 노출된 범위는 작고, 메시지 중심으로 객체들이 협력하는 구조</strong>를 말해요.</p><p>이게 바로 객체지향 설계에서 지향하는 중요한 가치 중 하나고, 시스템의 결합도를 낮추고 유지보수성과 확장성을 확보하는 데 핵심적인 역할을 해요.</p><h3>퍼블릭 인터페이스로만 협력한다</h3><p>객체나 모듈이 외부와 소통할 수 있는 유일한 창구가 바로 퍼블릭 인터페이스예요.</p><p>단순히 호출 가능한 메서드들의 목록을 의미하는 게 아니라, 이건 곧 외부와 맺는 계약이고, 시스템의 안정성과 유연성을 좌우하는 핵심 지점이기도 해요.</p><p>마틴 파울러는 퍼블릭 인터페이스를 변경을 캡슐화하기 위한 장치라고 정의해요. 무슨 말이냐면, <strong>인터페이스만 잘 지켜진다면 내부 구현은 언제든 변경 가능</strong>하고 <strong>이 변화가 외부로 번지지 않게 할 수 있다</strong>는 거죠.</p><p>반대로 인터페이스가 넓거나 모호하게 설계되어 있다면, 사소한 내부 수정이 전체 구조에 영향을 끼치는 불안정한 시스템이 되기 쉬워요.</p><p>이런 이유로 퍼블릭 인터페이스를 최소화하고, 도메인 관점의 추상화로 구성하는 것이 매우 중요해요.</p><h3>리팩토링은 습관이다</h3><p>소프트웨어는 새로운 기능이 추가되는 순간, 그만큼 복잡성도 함께 증가해요.</p><p>마틴 파울러는 이 복잡성을 통제하기 위한 방법으로 리팩토링을 제시했는데, 그는 이를 <strong>단순한 정리 작업이 아니라 시스템의 구조적 품질을 유지</strong>하는 공학적 활동으로 보았어요.</p><p>리팩토링은 보통 이런 순환 흐름 속에서 등장해요:</p><ol><li>기능 구현 (변화 유입)</li><li>테스트 및 안정화 (안전망 확보)</li><li>리팩토링 (구조 정돈)</li><li>반복</li></ol><p>이건 단순한 작업 루틴이 아니라, 시스템이 유연성과 확장성을 유지하기 위해 반드시 거쳐야 하는 <strong>생존 메커니즘</strong>에 가까워요.</p><p>이 흐름이 사라지면 시스템은 점점 내부가 뒤엉키고, 변화에 저항하는 경직된 구조로 변해버려요.</p><h3>결국 모듈화다</h3><p>모듈화는 단순히 코드를 파일 단위로 나누거나, 네임스페이스를 구분하는 수준에서 끝나지 않아요. 중요한 건<strong> ‘시스템을 구성하는 기능, 정책, 기술 요소들 간의 경계와 관계를 어떻게 설계하느냐’</strong> 에요.</p><p>궁극적으로 모듈화의 목적은 복잡한 시스템을 이해 가능한 단위로 나누고,<br> 각 단위가 서로 간섭 없이 독립적으로 발전할 수 있는 구조를 만드는 데 있어요.</p><p>모듈을 나눌 때 고려할 수 있는 기준은 크게 세 가지 계층으로 나눠볼 수 있어요:</p><ol><li><strong>기능적 정합성 (Functional Cohesion)</strong>: 하나의 모듈은 명확한 목적을 가진 기능 단위를 구성해야 하고, 그 안에서는 높은 응집도가 유지되어야 해요.</li><li><strong>정책적 독립성 (Policy Independence)</strong>: 도메인 로직은 웹, 데이터베이스, 프레임워크 같은 기술적 세부사항과 분리되어야 해요. 이는 클린 아키텍처에서도 핵심적으로 강조하는 원칙이에요.</li><li><strong>기술적 유연성 (Technical Replaceability)</strong>: 구현은 언제든 바뀔 수 있어야 해요. 이를 가능하게 하는 게 바로 추상화와 의존 역전 원칙을 기반으로 한 설계예요.</li></ol><p>이 기준들을 바탕으로, 좋은 모듈은 다음과 같은 조건을 갖춰야 해요:</p><ul><li>인터페이스는 작고 명확해야 한다 (Interface Segregation)</li><li>외부와의 의존은 최소화되어야 한다 (Low Coupling)</li><li>내부는 높은 응집도를 유지해야 한다 (High Cohesion)</li></ul><p>이제 프로젝트의 구조 및 구성에 대해서 설명할게요.</p><p>이 프로젝트는 모듈화를 중점으로 구성하기로 했어요. 프로젝트 사이즈가 현재까지는 작지만 앞으로 추가 될 기능들과 비즈니스 로직들의 관리를 용이하게 하기 위해서에요.</p><p>이때 각 모듈이 독립적인 배포 단위로 동작하고, 유닛 테스트 타겟과 샘플 앱 타겟이 기본적으로 함께 모듈에 존재하도록 구성했어요.</p><p>아래는 프로젝트 주요 모듈과 각 의존성을 나타냈어요.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MHbL-stGNOxcIgg6J_83yQ.png" /></figure><h4>주요 모듈 및 역할</h4><p>각 모듈은 클린아키텍처에 기반하여 그 행위와 의미를 담아내야 합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/677/1*_0e-h5roESqwJUOgx5kdIQ.png" /></figure><p>안쪽부터 분리:</p><p><strong>Entity 계층</strong>: Domain<br><strong>Usecase 계층</strong>: Domain<br><strong>Interface Adapter 계층</strong>: Feature/**, Infrastructure<br><strong>Framework &amp; Driver 계층</strong>: Feature/**, Router, Network, UIComponent, AppFoundation</p><h3>Entity, Domain계층</h3><h4>포함 모듈: Domain</h4><p>도메인 계층은 시스템의 핵심 비즈니스 로직과 도메인 모델을 정의해요. 이 계층은 외부의 어떤 기술적인 구현에도 의존하지 않아야 합니다.</p><p>Domain 모듈은 <strong>Entity</strong>와 <strong>UseCase</strong> 계층을 모두 포함해요.</p><p>여기서 Entity는 비즈니스 개념을 나타내는 순수 데이터 구조체나 클래스이다. UseCase는 비즈니스 로직을 실행하는 서비스 계층입니다.</p><p>이 모듈은 클린 아키텍처에서 가장 안쪽에 위치하며, 모든 외부 계층은 Domain의 구체적인 구현을 직접 참조해서는 안돼요.</p><h3>Interface Adapter 계층</h3><h4>포함 모듈: Feature/**, Infrastructure</h4><p>Interface Adapter 계층은 도메인 계층과 외부 계층(UI, 데이터 소스 등) 사이의 중간 역할을 해요. 데이터 포맷을 변환하거나, UseCase 인터페이스를 호출하는 Adapter를 구성하는게목표에요 .</p><ul><li>Feature/** 모듈은 각 기능별로 분리된 화면(UI 포함)과 ViewModel을 포함. 이 중 ViewModel이 Interface Adapter에 해당하며, 도메인과 UI 간의 데이터를 연결합니다.</li><li>Infrastructure 모듈은 외부 시스템(API, UserDefaults 등)과의 통신을 담당하는 Repository 구현체들을 포함합니다. UseCase에서 정의된 Repository 인터페이스를 실제로 구현하는 위치로, Interface Adapter의 전형적인 예시에요.</li></ul><p>이 계층은 외부와 도메인을 연결하지만, 여전히 도메인에 비해 바깥쪽에 위치하므로 도메인 모델을 사용하는 방향으로만 의존해야 한다.</p><h3>Framework &amp; Driver 계층</h3><h4>포함 모듈: Feature/**, Router, Network, UIComponent, AppFoundation</h4><p>Framework &amp; Driver 계층은 앱의 구동에 필요한 외부 시스템과 기술들을 구현하는 계층이다. UI, 화면 전환, 네트워크 통신, 시스템 API 접근 등이 여기에 해당합니다.</p><ul><li>Feature/** 모듈 내부에는 View, ViewFactory 등 실제 화면의 구현과 화면 전환과 관련된 프레임워크 종속 코드가 함께 존재한다. 이 부분은 Framework &amp; Driver 계층에 해당해요. 즉, Feature는 ViewModel을 제외한 나머지 UI 관련 코드는 Framework &amp; Driver로, MVVM 패턴을 위해 Interface Adapter계층과 겹쳐져 있어요.</li><li>Router는 화면 전환의 흐름을 제어하는 코디네이터 기반 로직을 포함하고 있으며, UIKit/SwiftUI에 종속적이므로 이 계층에 속해요.</li><li>Network는 실제 네트워크 호출과 관련된 클라이언트 코드, API 정의 등을 포함한다. 이는 외부와의 통신을 직접 다루므로 Framework &amp; Driver에 해당돼요.</li><li>UIComponent는 재사용 가능한 UI 요소(Button, Badge 등)를 제공하는 모듈로, UIKit이나 SwiftUI 기반으로 구현되어 있어요. 프레임워크에 직접 의존하고 있으므로 이 계층에 속해야 해요.</li><li>AppFoundation은 앱 전반에서 사용하는 정의, 에러 타입, 의존성 주입 관련 컨테이너, 확장, 상수 등을 포함한다. 기술적인 유틸리티에 가깝고 도메인에 의존하지 않기 때문에 역시 Framework &amp; Driver에 포함됩니다.</li></ul><p>휴! 이렇게 해서 프로젝트의 전반적인 설계원칙과 클린아키텍처와 실제 모듈들간의 관계성에 대해 설명했어요.</p><p>영원한 설계 방법론 같은건 없지만, 가장 유연하고 단단한 구조의 어플리케이션을 만들기 위해서 이러한 원칙들을 잘 세워나가는게 중요하다고 생각해요.</p><p>Github <a href="https://github.com/ttok-deal-lab/Mercury">https://github.com/ttok-deal-lab/Mercury</a> 놀러오시면 저의 부끄러운 코드들을 감상? 혹은 비웃?어보실 수 있습니다 ㅎㅎ;</p><p>그럼 이만!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=984f4baaee9f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[첫 해커톤 Let us: Hack! 참가후기]]></title>
            <link>https://medium.com/@bbuyo/%EC%B2%AB-%ED%95%B4%EC%BB%A4%ED%86%A4-let-us-hack-%EC%B0%B8%EA%B0%80%ED%9B%84%EA%B8%B0-27405ad736f5?source=rss-3bb76b7aabf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/27405ad736f5</guid>
            <dc:creator><![CDATA[뿌요]]></dc:creator>
            <pubDate>Mon, 01 Jul 2024 14:08:41 GMT</pubDate>
            <atom:updated>2024-07-01T14:08:41.961Z</atom:updated>
            <content:encoded><![CDATA[<p>오랜만에 돌아온 뿌요입니다 😎</p><p>지난 주 토요일에 열렸던 Let us: Hack! (찍먹톤) 참가후기를 들고 돌아왔어요 ㅎㅎ</p><p>해커톤을 이전에는 기술멘토 역할로 참여해봤지만 개발멤버로 참여한것은 이번이 난생 처음이었어요!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uG6It1l6IE972_22DsK9zA.jpeg" /></figure><p>이번 해커톤의 주제는 WWDC 2024 에서 나온 새로운 기술들을 찍먹해보는 (그래서 찍먹톤?) 어플리케이션 개발이었는데요,</p><p>저희는 지구온난화로 녹아가는 북극의 심각성을 강조하기 위해 북극의 평균온도와 현재온도를 비교하여 이를 시각화하는 어플리케이션을 만들었답니다.</p><p>이를 위해서 WWDC 2024에서 발표한 기술들 중 WeatherKit Statistic / Swift Charts — Vectorized plots / Custom Transition 을 채택했구요.</p><p>구체적으로는 북극 각 지역의 온도를 나타내는 점(dot)을 vectorized plot 차트로 찍고</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/366/1*g4yHY69mB3QMT73sbNTF3w.png" /><figcaption>이런 느낌으루다가</figcaption></figure><p>슬라이드 바를 조절하여 1970년 부터 지금까지의 온도변화를 점(dot)의 크기와 색깔을 조절하는 애니메이팅을 넣으려고 하였으나….</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/334/1*qmaQEQrW9wxpoixLrgz9JA.png" /></figure><p>해커톤은 자기 마음대로 되지 않는법…</p><p>WeatherKit이 2~3년 전의 데이터도 제대로 가져오지 못한다는 비보가 전해져 왔습니다 ㅠㅠ</p><p>북극지역과 위도-경도의 정확한 매칭포인트를 잡기 위해서 지도투영법을 열심히 구현하고 있었지만 파기 💥</p><pre>struct Angle {<br>    var degrees: Double<br>    var radians: Double {<br>        return degrees * .pi / 180.0<br>    }<br>}<br><br>struct PolarProjection: Sendable {<br>    var x, y: Double<br>    <br>    init(xLongitude: Angle, yLatitude: Angle) {<br>        let centralLatitude = Angle(degrees: 90.0).radians<br>        let lambda = xLongitude.radians<br>        let phi = yLatitude.radians<br>        let rho = centralLatitude - phi<br>        let theta = lambda<br>        <br>        self.x = rho * sin(theta)<br>        self.y = -rho * cos(theta)<br>    }<br>}</pre><p>이건 그 흔적..</p><p>이 시점에서 완료시간까지 4시간밖에 남지 않았지만 다시 머리를 맞대어 새로운 아이디어가 나왔는데요! 바로바로 지구지키기 퀘스트~를 주는 앱~</p><p>WeatherKit을 통해서 평균온도와 현재온도를 비교하여 1도의 차이만큼 지구를 지키는 퀘스트를 주도록 구현했어요. (만약 현재온도 — 평균온도 = 3 이라면, 3개의 퀘스트 제공)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/309/1*YATDbIziM0WYVB__T0g8IA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/308/1*QpGkpERfnZRYO857AE1Opw.png" /></figure><p>뒤에 멋진 그라데이션이 보이시나요?</p><p>퀘스트를 깰때마다 화면이 점점 파란색으로 채워지는 애니메이션을 넣었어요 (실제로 보면 예쁨. 아무튼 예쁨)</p><p>퀘스트를 전부 다 채우면 왕따봉을 화려한 애니메이션 효과와 함께 보여주는 그런 멋진!!!앱이에요 (아무튼 멋짐. 반박안받읍니다)</p><p>해커톤이 진행되는 동안 정말 큰 즐거움을 느꼈어요.</p><p>하나의 목표를 항해서 뜻을 같이하는 3분의 멋진 개발자분들이 나와 호흡을 맞추고 있다는 사실이 코드를 짜면서도 희열과 짜릿함을 느끼게 해줬거든요.</p><p>코딩이 이렇게 즐거웠다는 사실을 오랜만에 느끼게 해준 고마운 자리였다고 감히 말할수 있겠습니다 ㅎㅎ</p><p>다음에도 해까톤 참여할 기회가 있으면 득달같이 달려가리..</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=27405ad736f5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[뿌요와 함께하는 Combine: Subscriber]]></title>
            <link>https://medium.com/@bbuyo/%EB%BF%8C%EC%9A%94%EC%99%80-%ED%95%A8%EA%BB%98%ED%95%98%EB%8A%94-combine-subscriber-47b44afd8937?source=rss-3bb76b7aabf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/47b44afd8937</guid>
            <category><![CDATA[combine]]></category>
            <dc:creator><![CDATA[뿌요]]></dc:creator>
            <pubDate>Fri, 15 Mar 2024 13:37:31 GMT</pubDate>
            <atom:updated>2025-04-18T04:45:10.035Z</atom:updated>
            <content:encoded><![CDATA[<p><a href="https://admitted-peripheral-8ed.notion.site/Combine-c33cd5c227b7488f87a563c227fbc4a1?pvs=4">한번에 모아보기 — 노션</a></p><h3>Subscriber</h3><p>이 글에서는 Subscriber개념을 Publisher 메서드와 함께 묶어 설명합니다.</p><p>아직 Publisher에 대해 잘 모른다면 <a href="https://www.notion.so/Publisher-926dfc2224304349abaf2739b5b64173?pvs=21">Publisher란?</a> 을 읽고 돌아와주세요</p><p>Subscriber은 Publisher로부터 이벤트나 값을 전달받아 구독하는 객체에요.</p><p>protocol Subscirber을 보면 두 가지 타입과 세 가지 메서드가 있어요.</p><pre>public protocol Subscriber&lt;Input, Failure&gt; : CustomCombineIdentifierConvertible {<br>  associatedtype Input<br>  associatedtype Failure : Error<br>    <br>  func receive(subscription: any Subscription)<br>  func receive(_ input: Self.Input) -&gt; Subscribers.Demand<br>  func receive(completion: Subscribers.Completion&lt;Self.Failure&gt;)<br>}</pre><p>먼저 Input과 Failure은 Publisher로 부터 받는 출력(Output)과 Failure이에요.</p><pre>public protocol Publisher&lt;Output, Failure&gt; {<br>  associatedtype Output<br>  associatedtype Failure : Error<br>  <br>  ...   <br>}</pre><p>때문에 Subscriber의 Input과 Failure은 Publisher의 Output과 Failure의 타입과 일치해야 해요.</p><p>이제 Subscriber에 선언되어 있는 세 가지 메서드를 볼게요.</p><pre>public protocol Subscriber&lt;Input, Failure&gt; : CustomCombineIdentifierConvertible {<br>  ...<br>  func receive(subscription: any Subscription)<br>  func receive(_ input: Self.Input) -&gt; Subscribers.Demand<br>  func receive(completion: Subscribers.Completion&lt;Self.Failure&gt;)<br>}</pre><p><strong>1 . Subscription 시작</strong></p><p>func receive(subscription: any Subscription)</p><p>Publisher를 성공적으로 구독하고 Publisher에게 이벤트나 값을 요구할 수 있음을 Subscriber에게 알리는 역할입니다.</p><p>여기에서 파라미터 subscription은 Subscriber과 Publisher를 연결하고 데이터 스트림의 흐름을 제어하게 해주는 Subscription 객체의 인스턴스에요.</p><p><strong>2 . Demand 요청 + 값 발행</strong></p><p>func receive(_ input: Self.Input) -&gt; Subscribers.Demand</p><p>Subscription이 시작되면, input 파라미터로 들어온 Self.Input 값을 발행하고 Subscription을 통해 데이터 요청을 하게돼요.</p><p>이때 추가 데이터 요청 가능 수량을 Demand로 명시할 수 있어요.</p><p>종류는</p><ul><li>현재 데이터 외 추가로 요청하지 않는 .none</li><li>무제한 요청인 .unlimited</li><li>구체적인 추가 요청숫자를 지정하는 max(_:) 가 있어요.</li></ul><pre>@frozen public struct Demand : Equatable, Comparable, Hashable, Codable, CustomStringConvertible {<br>  public static let unlimited: Subscribers.Demand<br>  public static let none: Subscribers.Demand<br>  @inlinable public static func max(_ value: Int) -&gt; Subscribers.Demand</pre><p><strong>3 . 데이터 스트림 상태 변경</strong></p><p>func receive(completion: Subscribers.Completion&lt;Self.Failure&gt;)</p><p>Publisher는 모든 데이터 발행을 마치고 스트림을 종료해요.</p><p>이때 Subscribers.Completion&lt;Self.Failure&gt; 타입의 값을 completion handler로 넘기게 돼요.</p><pre>@frozen public enum Completion&lt;Failure&gt; where Failure : Error {<br>  case finished<br>  case failure(Failure)<br>}</pre><p>정상적으로 데이터 스트림이 종료됐다면 .finished 를, 에러가 발생했다면 .failure(Failure) 상태를 발행해요.</p><p>이제 Publisher를 Subscriber가 구독하게 될 때를 순서대로 정리해볼게요.</p><p>1 . Just나 DataTaskPublisher 같은 방출 객체를 생성합니다.</p><pre>let publisher = Just(&quot;Hello world&quot;)</pre><p>2 . sink 혹은 assign을 사용하여 Subscriber가 Publisher에 구독을 시작하게 합니다.</p><pre>publisher<br>  .sink { value in <br>   print(value)<br>}</pre><p>내부적으로는 Publisher는 subscribe(_:) 메서드를 호출하여 Subscriber를 구독자 목록에 추가합니다.</p><pre>// in Publisher<br><br>public func subscribe&lt;S&gt;(<br>  on scheduler: S,<br>  options: S.SchedulerOptions? = nil<br>) -&gt; Publishers.SubscribeOn&lt;Self, S&gt; where S : Scheduler</pre><p>3 . Publisher는 구독을 수락하고, Subscription 객체를 <strong>생성</strong>하여 Subscriber에게 전달합니다.</p><p>이때 Subscriber는 receive(subsciption:) 메서드를 통해 Subscription 객체를 받습니다</p><pre>// in Subscriber<br>func receive(subscription: any Subscription)</pre><p>4 . receive(subscription:) 메서드 내에서 Subscriber는 Subscription에 request(_:) 메서드를 호출하여, 원하는 데이터의 양을 요청합니다.</p><pre>public protocol Subscription : Cancellable, CustomCombineIdentifierConvertible {<br>  func request(_ demand: Subscribers.Demand)<br>}</pre><ol><li>Publisher는 Demand에 따라 데이터를 발행합니다.</li><li>Subscriber는 receive(_:) 메서드를 통해 이 데이터를 받습니다. 이 메서드는 방출될 때마다 호출되며, 필요에 따라 Demand를 반환할 수도 있습니다.</li><li>Publisher는 모든 데이터 발행이 완료되었거나 오류가 발생하면 완료 혹은 오류 신호를 발행합니다</li><li>Subscriber는 receive(completion:) 메서드를 통해 이 신호를 받고, 스트림의 종료 혹은 오류처리를 합니다.</li></ol><p>위의 설명을 토대로 해서 커스텀 Publisher — Subscriber을 만들어볼게요</p><p>여기서 만들 Publisher는 Int 배열을 받아 짝수만 방출하도록 하고 Subscriber는 최대 10개의 데이터를 요청하도록 해볼게요.</p><pre>import Combine<br><br>// 커스텀 Publisher 정의<br>struct EvenNumbersPublisher: Publisher {<br>  typealias Output = Int<br>  typealias Failure = Never<br>  <br>  let numbers: [Int]<br>  <br>  // Subscriber 타입을 받는 receive 메서드 구현<br>  func receive&lt;S&gt;(subscriber: S) where S : Subscriber, Never == S.Failure, Int == S.Input {<br>    let subscription = EvenNumbersSubscription(subscriber: subscriber, numbers: numbers)<br>    subscriber.receive(subscription: subscription)<br>  }<br>  <br>  // Subscription 정의<br>  private class EvenNumbersSubscription&lt;S: Subscriber&gt;: Subscription where S.Input == Int, S.Failure == Never {<br>    private var subscriber: S?<br>    private let numbers: [Int]<br>    <br>    init(subscriber: S, numbers: [Int]) {<br>      self.subscriber = subscriber<br>      self.numbers = numbers<br>    }<br>    <br>    func request(_ demand: Subscribers.Demand) {<br>      var demand = demand<br>      guard let subscriber = subscriber, demand &gt; 0 else { return }<br>      <br>      for number in numbers where number % 2 == 0 {<br>        // demand가 0이 되면, 더 이상의 값을 방출하지 않음<br>        guard demand &gt; 0 else { break }<br>        <br>        demand -= 1 // demand 감소<br>        demand += subscriber.receive(number) // 방출하고, 반환된 demand를 더함<br>      }<br>      <br>      // 모든 짝수를 방출한 후, 완료 이벤트를 전송<br>      subscriber.receive(completion: .finished)<br>    }<br>    <br>    func cancel() {<br>      subscriber = nil<br>    }<br>  }<br>}<br>// 커스텀 Subscriber 정의<br>class EvenNumbersSubscriber: Subscriber {<br>  typealias Input = Int<br>  typealias Failure = Never<br>  <br>  // 데이터를 받았을 때 호출될 메서드<br>  func receive(_ input: Int) -&gt; Subscribers.Demand {<br>    print(&quot;Received even number: \\(input)&quot;)<br>    // 추가 데이터 요청 없음을 나타냄. 더 많은 데이터를 요청하려면 .unlimited 또는 .max(숫자)를 반환<br>    return .none<br>  }<br>  <br>  // 구독 시작 시 호출될 메서드<br>  func receive(subscription: Subscription) {<br>    // 최초 데이터 요청. 여기서는 최대 10개의 데이터를 요청<br>    subscription.request(.max(10))<br>  }<br>  <br>  // 스트림 완료 시 호출될 메서드<br>  func receive(completion: Subscribers.Completion&lt;Never&gt;) {<br>    switch completion {<br>    case .finished:<br>      print(&quot;Received all even numbers.&quot;)<br>    case .failure:<br>      // Failure 타입이 Never이므로 이 경우는 발생하지 않음<br>      break<br>    }<br>  }<br>}</pre><p>EvenNumbersSubscription 이 final class 인 이유는 Subscription은 Publisher에서 생성하여 사용하는 개념이기 때문에 publisher가 private으로 접근을 제한하고 용도를 한정하는 것이 적합하기 때문입니다.</p><p>이제 EvenNumbersPublisher를 EvenNumbersSubscriber이 구독하게 합시다!</p><pre>let evenPublisher = EvenNumbersPublisher(numbers: [1,2,3,4,5,6,7,8,9,10])<br>let evenSubscriber = EvenNumbersSubscriber()<br><br>evenPublisher.subscribe(evenSubscriber)<br><br><br>// 결과<br>Received even number: 2<br>Received even number: 4<br>Received even number: 6<br>Received even number: 8<br>Received even number: 10<br>Received all even numbers.</pre><p>이렇게 해서 직접 Publisher과 Subscriber을 채택한 클래스를 만들어 데이터 발행과 구독을 구현할 수 있어요!</p><h3>sink</h3><p>sink는 내부적으로 Subscriber 객체를 만들어 Publisher를 구독하는 메서드에요.</p><p>Publisher에서 발행한 값과 이벤트를 처리하기 위한 탈출 클로저를 매개변수로 받아요.</p><h4>특징</h4><ul><li>sink는 Subscriber를 자체 생성해요. 커스텀 Subscriber을 만들때의 번거로움이 없어져요!</li><li>이 Subscriber의 Demand 값은 기본적으로 무제한(.unlimited)에요. 따라서 Publisher가 발행할 수 있는 모든 값을 받기 전에는 스트림이 종료되지 않아요.</li><li>sink 는 AnyCancellable 타입의 객체를 반환해요. 이 객체는 적절한 변수나 컬렉션에 저장되지 않으면 그 즉시 구독관계가 취소되고 Subscriber는 더 이상 Publisher로부터 어떠한 값이나 이벤트를 받을 수 없어요.</li></ul><h4>사용</h4><p>두 가지 형태의 sink 메서드가 있어요.</p><ol><li>Publisher가 Failure를 가질 수 있는 경우</li></ol><pre>public func sink(<br>  receiveCompletion: @escaping ((Subscribers.Completion&lt;Self.Failure&gt;) -&gt; Void),<br>  receiveValue: @escaping ((Self.Output) -&gt; Void)<br>) -&gt; AnyCancellable</pre><ol><li>Publisher의 Failure이 Never인 경우</li></ol><pre>public func sink(<br>  receiveValue: @escaping ((Self.Output) -&gt; Void)<br>) -&gt; AnyCancellable</pre><p>둘의 차이는 receiveCompletion 탈출 클로저의 유무에요.</p><p>Publisher의 Failure이 Never인 경우 완료 이벤트는 무조건 정상(.finished) 이므로, 에러핸들링이 필요없기 때문에 발행되는 값만 바라보면 되기 때문이에요.</p><p>기본적인 사용법은 다음과 같아요</p><pre>var cancellables = Set&lt;AnyCancellable&gt;()<br>Publisher 인스턴스 (Failure가 Never이 아닌)<br>    .sink(receiveCompletion: { completion in<br>        switch completion {<br>        case .finished:<br>            print(&quot;finished&quot;)<br>        case .failure(let error):<br>            print(error)<br>        }<br>    }, receiveValue: { value in<br>        print(value)<br>    })<br>  .store(in: &amp;cancellables)</pre><p>만일 Failure가 Never인 경우 receiveCompletion 부분을 무시할 수 있어요.</p><pre>var cancellables = Set&lt;AnyCancellable&gt;()<br>Just(&quot;just value&quot;)<br>    .sink(receiveValue: { value in<br>        print(value)<br>    })<br>  .store(in: &amp;cancellables)</pre><p>클로저 축약형식으로 다음처럼 쓸 수 있어요</p><pre>var cancellables = Set&lt;AnyCancellable&gt;()<br>Empty&lt;Int, Error&gt;(completeImmediately: true)<br>    .sink {<br>        switch $0 {<br>        case .finished:<br>            print(&quot;finished&quot;)<br>        case .failure(let error):<br>            print(error)<br>        }<br>    } receiveValue: {<br>        print($0)<br>    }<br>  .store(in: &amp;cancellables)</pre><h3>assign</h3><p>assign은 KeyPath를 받아 해당 인스턴스의 값을 계속해서 업데이트 할 수 있는 메서드에요.</p><p>KeyPath는 간단히 말해서 어떤 인스턴스의 프로퍼티에 접근하기 위한 방법 중 하나로, KVO(Key Value Coding) 나 KVC(Key Value Observing) 같은 기능을 제공하지만, 프로퍼티의 이름 그 자체로 프로퍼티에 접근할 수 있어서 훨씬 안정적이고 변화에 대응하기 쉬워요.</p><p><strong>추천 레퍼런스</strong></p><ul><li><a href="https://developer.apple.com/documentation/swift/keypath">Apple swift keypath 공식문서</a></li><li><a href="https://ios-development.tistory.com/984">김종권의 iOS앱 개발 알아가기 — KVC, KVO 개념</a></li><li><a href="https://ios-development.tistory.com/982">김종권의 iOS앱 개발 알아가기 — KeyPath 이해하기</a></li></ul><p>assign은 sink 메서드처럼 Publisher로부터 발행된 값을 받아 핸들링 할 수 있습니다.</p><p>하지만 sink와는 다른 특징들이 몇 가지 있어요.</p><h4>sink와 구분되는 특징</h4><ul><li>assign은 sink와 달리, <strong>특정 객체의 프로퍼티에 값을 할당하는데에 목적이 있어요.</strong> 예를 들어, 뷰모델의 값을 뷰 속성에 별도의 클로저 없이 직접 연결해야 할 때 유용해요. 별도의 클로저가 없기 때문에 코드가 훨씬 간결해져요.</li><li>assign은 sink와 달리 <strong>unowned</strong> 참조를 사용하기 때문에 신중하게 생명주기를 컨트롤해야 해요.</li><li>assign은 sink와 달리 에러처리 없이 해당 객체의 프로퍼티에 직접 값을 할당해요. 따라서 Publisher의 Failure이 Never일 때만 사용할 수 있어요.</li></ul><pre>extension Publisher where Self.Failure == Never { // Failure == Never!<br>     public func assign&lt;Root&gt;(to keyPath: ...) -&gt; AnyCancellable <br>}</pre><h4>사용</h4><p>여기에서는 ViewModel에 있는 프로퍼티의 값이 바뀔 때마다 View의 프로퍼티에 이 값을 할당하는 예제를 만들어볼게요.</p><p>먼저 UserModel이라는 이름의 ViewModel 입니다.</p><pre>class UserModel: ObservableObject {<br>    @Published var userName: String = &quot;Russell&quot;<br>}</pre><p>그리고 SomeView라는 View 역할의 클래스를 만들어볼게요</p><pre>class SomeView {<br>    var userModel: UserModel<br>    var userName: String = &quot;&quot; {<br>        didSet {<br>            print(&quot;UserName updated to: \\(userName)&quot;)<br>        }<br>    }<br>    private var cancellables = Set&lt;AnyCancellable&gt;()</pre><pre>    init(userModel: UserModel) {<br>        self.userModel = userModel</pre><pre>        userModel.$userName<br>            .assign(to: \\.userName, on: self)<br>            .store(in: &amp;cancellables)<br>    }<br>    <br>    deinit {<br>        print(&quot;\\(self) deinited&quot;)<br>    }<br>}</pre><p>userModel.$userName 은 Publisher로써, assign 메서드는 이 Publisher의 값이 발행될 때마다 self(SomeView)의 userName에 해당 값을 할당해요.</p><p>이제 userModel의 userName에 다른 값을 넣어볼게요.</p><pre>let userModel = UserModel()<br>var someView: SomeView? = SomeView(userModel: userModel)</pre><pre>userModel.userName = &quot;Bbuyo&quot;<br>someView = nil</pre><p>SomeView의 userName didSet문에서 나오는 결과는 아래와 같아요.</p><pre>UserName updated to: Russell Song<br>UserName updated to: Bbuyo</pre><p>잘 작동해요! 하지만.. deinit 되지 않는 문제가 생겼어요. 메모리릭이 발생했다는 뜻이에요 😟</p><p>포럼에서도 이 문제에 대한 논의가 이루어진 것을 확인했어요</p><p><a href="https://forums.swift.org/t/does-assign-to-produce-memory-leaks/29546">Does ‘assign(to:)’ produce memory leaks?</a></p><p>위 논의에서 나온 결론은, assign 메서드를 오버로드해서 쓰자! 에요</p><p><a href="https://forums.swift.org/t/does-assign-to-produce-memory-leaks/29546/9"><strong>grapperon</strong></a></p><pre>extension Publisher where Self.Failure == Never {<br>    public func assignNoRetain&lt;Root&gt;(to keyPath: ReferenceWritableKeyPath&lt;Root, Self.Output&gt;, on object: Root) -&gt; AnyCancellable where Root: AnyObject {<br>        sink { [weak object] (value) in<br>            guard let object = object else { return }<br>            _ = Just(value).assign(to: keyPath, on: object)<br>        }<br>    }<br>}</pre><p><a href="https://forums.swift.org/t/does-assign-to-produce-memory-leaks/29546/11"><strong>stefanomondino</strong></a></p><pre>extension Publisher where Failure == Never {<br>    func assign&lt;Root: AnyObject&gt;(to keyPath: ReferenceWritableKeyPath&lt;Root, Output&gt;, on root: Root) -&gt; AnyCancellable {<br>       sink { [weak root] in<br>            root?[keyPath: keyPath] = $0<br>        }<br>    }<br>}</pre><p>흠.. 그냥 sink를 사용하는게 훨씬 안전할 것 같은걸요?</p><h3>AnyCancellable</h3><p>AnyCancellable은 Cancellable이라는 프로토콜의 구현체로, 메모리 관리와 리소스 관리 차원에서 굉장히 중요한 역할을 담당하고 있어요.</p><p>Cancellable은 cancel() 단 한개의 메서드만 가지고 있어요.</p><pre>public protocol Cancellable {<br>    func cancel()<br>}</pre><p>이 메서드를 호출하면 구독이 취소되고, Publisher로부터 더 이상 데이터 스트림을 받지 않아요.</p><p>이 개념이 굉장히 중요한 이유는 구독을 취소하지 않으면 메모리 누수가 발생하게 되어 앱 성능이 떨어지게 돼요!</p><p>이제 Cancellable을 구현한 AnyCancellable에 대해 알아볼게요.</p><h4>특징</h4><ul><li><strong>AnyCancellable은 deinit 시 cancel 메서드를 자동으로 호출해요.</strong></li><li>sink 나 assign이 구독을 시작할 때 AnyCancellable 객체를 반환하는데, 각각의 AnyCancellable을 cancel 하여 구독상태를 취소할 수도 있지만, 보틍은 Set&lt;AnyCancellable&gt; 변수에 저장해요. Set이 소멸할 때 한 번에 관련 구독상태들을 전부 취소할 수 있기 때문이에요.</li></ul><h4>사용</h4><p>Publisher을 구독할 때 항상 .store(in: &amp;cancellables) 를 붙이던 거, 기억나시나요?</p><pre>var cancellables = Set&lt;AnyCancellable&gt;()</pre><pre>Just(&quot;Hello, Combine!&quot;)<br>    .sink {<br>	    ...<br>    } receiveValue: {<br>	    ...<br>    }<br>    .store(in: &amp;cancellables) // !</pre><p>이때의 진행과정을 자세하게 풀어볼게요.</p><ol><li>sink 메서드 사용과 동시에 구독을 시작.</li><li>이때 이 구독(Subscription)을 취소할 수 있는 AnyCancellable 객체가 리턴.</li><li>이 AnyCancellable 객체를 Set에 저장.</li><li>Set이 메모리에서 해제될 때 여기에 담겼던 AnyCancellable이 cancel() 을 호출.</li></ol><p>.store(in:) 은 결국 sink에서 리턴되는 AnyCancellable 객체를 어딘가에 저장하기 위함임을 알 수 있어요.</p><p>그렇다면 store(in:) 메서드를 사용하지 않고도 같은 효과를 낼 수 있어요.</p><pre>let cancellable = Just(&quot;Hello, Combine!&quot;)<br>    .sink(receiveValue: { value in<br>        print(value)<br>    })</pre><p>이렇게 하면 변수 cancellable에 sink에서 리턴되는 AnyCancellable이 저장됨에 따라 cancellable이 메모리에서 해제될 때 구독관계가 해제돼요.</p><p>AnyCancellable의 매커니즘에 대해 조금 더 쉽게 비유를 하자면 …</p><p>우리가 모든 구독관계에 대해서 컨트롤하기 매우 귀찮고 힘들기 때문에, 한번에 처리될 수 있는 쓰레기처리장(Set) 에 구독 삭제 발생장치(AnyCancellable) 를 적재하는 함수가 store(in:) 인 거에요.</p><p>쓰레기처리가 시작되면, 이 구독 삭제 발생장치가 자기가 관리하고 있던 구독권을 삭제해버리면 끝!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=47b44afd8937" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[뿌요와 함께하는 Combine: Publisher]]></title>
            <link>https://medium.com/@bbuyo/%EB%BF%8C%EC%9A%94%EC%99%80-%ED%95%A8%EA%BB%98%ED%95%98%EB%8A%94-combine-publisher-f78d44215ff5?source=rss-3bb76b7aabf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/f78d44215ff5</guid>
            <category><![CDATA[combine]]></category>
            <dc:creator><![CDATA[뿌요]]></dc:creator>
            <pubDate>Fri, 15 Mar 2024 13:33:17 GMT</pubDate>
            <atom:updated>2025-04-09T05:53:43.621Z</atom:updated>
            <content:encoded><![CDATA[<p><a href="https://admitted-peripheral-8ed.notion.site/Combine-c33cd5c227b7488f87a563c227fbc4a1?pvs=4">한번에 모아보기 — 노션</a></p><h3>Publisher란?</h3><p>Publisher는 직역하면 <strong>발행자</strong>입니다.</p><p>데이터 스트림이나 이벤트를 생성하고 이것을 Subscriber(구독자) 에게 전달하는 역할을 하는 객체라고 할 수 있어요.</p><p>좀 어렵나요?</p><p>실제 생활에서의 예시로 빗대어 표현해보자면</p><p>Publisher는 신문사, Subscriber는 신문 구독자와의 관계라고 할 수 있겠네요.</p><p>신문사는 신문을 발행합니다. 신문을 구독하는 사람은 관심있는 신문사를 구독하고 정기적으로 신문사의 정보를 받아볼 수 있어요.</p><p>Publisher는 신문 대신에 데이터나 이벤트를 발행해요. Subscriber는 원하는 Publisher의 이벤트를 받을 수 있어요.</p><h4>데이터 스트림</h4><p>Publisher에서 연결되어 Subscriber까지 이어지는 데이터의 흐름이 생기는 이러한 것을 Data Stream(데이터 스트림) 이라고 합니다.</p><p>데이터 스트림을 좀더 정확하게 말해보자면, <strong>시간에 따라 연속적으로 발생하는 데이터 시퀀스</strong>를 말해요. 시퀀스이기 때문에 순차적으로 처리되거나 관찰될 수 있어요.</p><p>데이터 스트림은 업스트립(UpStream) 과 다운스트림(DownStream)으로 구성되는데, 업스트림은 데이터 소스 발생지를 말해요. 다운 스트림은 데이터가 처리되고 소비되는 지점을 말해요.</p><p>신문사가 신문을 발행하는 것처럼 Publisher는 데이터를 발행하니까 업스트림이 됩니다.</p><p>구독자가 신문을 받아보는 것처럼 Subscriber는 데이터를 받고 처리하니까 다운스트림이 됩니다.</p><p>만약 여러개의 Publisher가 있다면 하위 Publisher는 상위 Publisher에 대해 다운스트림이라고 불러요. 반드시 Publisher라고 해서 업스트림, Subscriber라고 해서 다운스트림으로 부르는 것은 잘못된 표현이에요 😉</p><h4>구독의 종료</h4><p>신문사와 신문구독자와의 관계와 Publisher과 Subscriber의 관계가 항상 동일한 개념은 아니에요.</p><p>Publisher은 발행을 종료하는 시점이 확실히 정해져 있거든요.</p><ul><li><strong>모든 데이터를 발행했을 때</strong> 완료 이벤트를 발행하여 구독을 종료하고 .finished 이벤트 발행.</li><li><strong>작업 중 오류를 만날 때</strong> Failure를 발행하고 .failure 이벤트와 함께 스트림 종료.</li><li>Subscriber가 명시적으로 구독을 취소했을 때 특별한 종료 이벤트 없이 구독 종료.</li></ul><h4>Deep Dive in Publisher</h4><p>앞으로 설명할 것들은 Publisher 프로토콜에 정의되어 있는 요소들이에요.</p><p>우리가 개발할 때는 이 Publisher을 채택한 다양한 내장 Publisher들을 사용하거나 sink 같은 고수준 API를 주로 사용해요.</p><p>그렇기 때문에 직접 사용할 일은 드물겠지만 어떻게 구성되어 있는지 안다면 좀더 탄탄한 기본기를 가져갈 수 있을거에요.</p><pre>public protocol Publisher&lt;Output, Failure&gt; {<br>  associatedtype Output<br>  associatedtype Failure : Error<br>  func receive&lt;S&gt;(subscriber: S) where S : Subscriber, Self.Failure == S.Failure, Self.Output == S.Input<br>}</pre><p>먼저 Publisher는 두 가지 제네릭 타입을 반드시 가지고 있어야 해요. Output 그리고 Failure 에요.</p><p>Output은 Publisher가 발행할 종류(타입)이에요. Output으로 사용 될 타입이 확정되면 더 이상 다른 타입으로 바꿔서 발행할 수 없어요.</p><p>Failure은 Publisher가 <strong>발행할 수도 있는</strong> 에러에요. (The kind of errors this publisher <strong>might publish</strong>.)</p><p>Failure에 대해서 좀 더 설명하자면, Error타입을 준수하는 어떤 객체든 상관없이 Failure가 될 수 있기 때문에 사용자 정의된 에러를 넣을 수 있어요.</p><p>이렇게 타입을 확실하게 명시하기 때문에 타입 안정성이 보장된다고 말할 수 있어요. 컴파일러가 에러를 런타임 전에 미리 잡을 수 있다는 뜻이에요.</p><p>이제 구현해야 하는 메서드를 알아봅시다.</p><pre>func receive&lt;S&gt;(subscriber: S) where S : Subscriber, Self.Failure == S.Failure, Self.Output == S.Input</pre><p>이 메서드는 Publisher가 Subscriber을 받을 때 호출되며 Publisher가 Subscriber에게 Subscription 인스턴스를 전달하면서 구독을 시작해요.</p><p>뒤에서 설명하게 될 내용이지만 Subscription 인스턴스는 Publisher과 Subscriber 사이의 구독 생명주기를 관리하는 객체에요.</p><p>여기에서는 자세히 다루지 않고 Subscriber 가 Publisher 에게 “야! 내가 구독을 시작할게!” 라고 알리는 정도로만 기억하고 넘어갑시다.</p><p>다른 메서드도 살펴볼까요?</p><pre>extension Publisher {<br>  func subscribe&lt;S&gt;(_ subscriber: S) where S : Subscriber, Self.Failure == S.Failure, Self.Output == S.Input<br>  func subscribe&lt;S&gt;(_ subject: S) -&gt; AnyCancellable where S : Subject, Self.Failure == S.Failure, Self.Output == S.Output<br>}</pre><p>이 둘 메서드는 Publisher가 특정 Subscriber 타입의 인스턴스를 구독자로 받아들이고, 데이터 스트림의 발행을 시작해요.</p><p>결국 subscribe 메서드는 구독 프로세스의 시작점이고 내부적으로는 위에서 설명한 receive 메서드를 호출하게 되면서 실제 구독을 활성화 하고 구체적인 작업을 하게돼요.</p><pre>func receive&lt;S&gt;(subscriber: S) where S : Subscriber, Self.Failure == S.Failure, Self.Output == S.Input</pre><p>시작부터 너무 어려웠나요?</p><p>걱정하지 말아요. 앞으로 나올 Publisher 종류들은 Publisher 프로토콜을 채택하여 내부적으로 위에서 설명한 메서드들을 모두 구현해놓은 추상화 객체들이에요.</p><p>그렇기 때문에 우리가 편하게 Publisher를 사용할 수 있어요.</p><p>하지만 쉬운길로 가기전에 어려운 내용을 먼저 익히게 된다면 사고의 지평이 넓어지고 흡수되는 지식의 퀄리티 또한 기하급수적으로 상승할 거에요 😎</p><h3>Just</h3><p>Just는 가장 단순한 형태의 Publisher에요.</p><h4>특징</h4><ul><li>에러를 보낼 수 없어요 (Failure 타입 Never)</li><li><strong>한 번</strong> 값을 방출하면 더 이상 추가로 방출할 수 없어요.</li><li><strong>한 번</strong> 값을 방출하면 완료(.finished) 돼요.</li></ul><p>공식문서를 보면 Abstract에 이렇게 써있어요.</p><blockquote><em>한 개의 아웃풋을 각각의 Subscriber에게 단 한 번 보내고, 종료합니다. A publisher that emits an output to each subscriber just once, and then finishes.</em></blockquote><p>그리고 실제로 코드를 보면 Failure가 Never로 고정되어 있어요.</p><p>즉, Just는 에러를 발행할 수 없고 항상 Output만을 발행할 수 있다는 뜻이에요</p><pre>public struct Just&lt;Output&gt; : Publisher {<br>  public typealias Failure = Never<br>  public let output: Output<br>  public init(_ output: Output)<br>  public func receive&lt;S&gt;(subscriber: S) where Output == S.Input, S : Subscriber, S.Failure == Never<br>}</pre><h4>사용</h4><pre>let helloPublisher = Just(&quot;Hello Combine!&quot;)<br>helloPublisher<br>  .sink { completion in<br>    switch completion {<br>    case .finished:<br>      print(&quot;finished&quot;)<br>    case .failure:<br>      break // 에러를 방출하지 않으므로 break<br>    }<br>  } receiveValue: { value in<br>    print(&quot;value received: \\(value)&quot;)<br>  }<br><br><br><br>// 결과<br>value received: Hello Combine!<br>finished</pre><p>sink는 Publisher를 구독하기 위한 함수에요.</p><p>sink를 사용하면 Publisher에서 발행되는 이벤트와 값들을 받아볼 수 있어요.</p><p>앞으로 Publisher들의 종류에 대해서 설명할 때 sink를 많이 보게 될거에요.</p><p>또 다른 구독하기 위한 수단으로 assign이라는 함수도 있지만 당분간은 sink로 Publisher을 구독할게요.</p><h3>Empty</h3><p>Empty는 값을 발행하지 않고 선택적으로 즉시 스트림을 종료할 수 있는 퍼블리셔에요.</p><h4>특징</h4><ul><li>값을 발행하지 않아요. 기본적으로 아무런 데이터도 전송하지 않아야 할 때 써요.</li><li>에러타입을 ‘지정’할 수 있어요 (발행하는게 아니에요). 하지만 Empty 자체에서 에러를 발행하는 것이 아니라 타입 일치를 위한 설계에요. 밑에서 좀더 자세하게 설명할게요.</li><li>completeImmediately 파라미터를 통해서 구독 직후에 완료 이벤트를 발행할 것인지 결정할 수 있어요.</li></ul><p>눈여겨 봐야할 것은 completeImmediately 파라미터에요.</p><p>이 파라미터는 기본값으로 true로 설정되어 있지만 false로 설정할 수 있어요.</p><p>false로 설정하면 완료 이벤트가 발행되지 않아요.</p><h4>사용</h4><ul><li>completeImmediately: true</li></ul><pre>let emptyPublisher = Empty&lt;Int, Never&gt;(completeImmediately: true)<br>emptyPublisher<br>  .sink { completion in<br>    switch completion {<br>    case .finished:<br>      print(&quot;finshed&quot;)<br>    case .failure(let customError):<br>      print(&quot;error occured : \\(customError)&quot;)<br>    }<br>  } receiveValue: { value in<br>    print(&quot;value received: \\(value)&quot;)<br>  }<br><br><br><br>// 결과<br>finshed<br>프로그램 종료 (exit 0)</pre><ul><li>completeImmediately: false</li></ul><pre>let emptyPublisher = Empty&lt;Int, Never&gt;(completeImmediately: false)<br>emptyPublisher<br>  .sink { completion in<br>    switch completion {<br>    case .finished:<br>      print(&quot;finshed&quot;)<br>    case .failure(let customError):<br>      print(&quot;error occured : \\(customError)&quot;)<br>    }<br>  } receiveValue: { value in<br>    print(&quot;value received: \\(value)&quot;)<br>  }<br><br><br><br>// 결과<br>프로그램 종료 (exit 0)</pre><h4>Empty의 Failure</h4><p>Empty 구조체를 보면 이상한 점이 있어요.</p><pre>public struct Empty&lt;Output, Failure&gt; : Publisher, Equatable where Failure : Error {</pre><p>Empty 퍼블리셔의 Failure 타입은 Just 처럼 Never이 아니라는 것이에요.</p><p>즉 에러타입을 Empty의 인자로 넣을 수 있다는 말이에요.</p><p>하지만 Empty는 에러를 발행하지 않아요! (엄밀히 말하자면 아무런 값도 발행하지 않아요)</p><p>이게 무슨 소리냐구요?</p><p>코드로 설명하면 금방 이해할 수 있어요.</p><p>이제부터 설명할 것은 두 개의 Publisher을 연결하고 이것을 구독할 때의 에러 핸들링이에요.</p><p>먼저 Error 채택하는 CustomError가 있어요.</p><pre>enum CustomError: Error {<br>  case unknownError<br>}</pre><p>그리고 여기 Subject가 있어요. 아직 다루지는 않았지만 지금은 Publisher이자 Subscriber의 역할을 모두 할 수 있는 객체라고 이해하고 넘어가요.</p><p>Subject는 Output과 Failure의 타입을 정할 수 있어요. 여기에서는 Subject에 Failure만을 전달할거에요.</p><pre>let subject = PassthroughSubject&lt;Int, CustomError&gt;()</pre><p>이제 subject에 에러가 발생했을 때 에러를 Empty 퍼블리셔로 변환하기 위해서 catch Operator를 사용할게요.</p><pre>let errorHandlingSubject = subject<br>  .catch { error -&gt; Empty&lt;Int, CustomError&gt; in <br>    print(&quot;Error caught: \\(error)&quot;)<br>    return Empty&lt;Int, CustomError&gt;(completeImmediately: true)<br>  }</pre><p>여기서 잠깐 catch에 간략하게 설명할게요. catch는 error를 받아서 Publishers.Catch 객체로 리턴해요.</p><p>이때 리턴된 Publishers.Catch객체는 원본 Publisher과 리턴된 Publisher 두개를 묶어서 타입으로 가져요.</p><p>그리고 이제부터 리턴된 Publisher을 원본 Publisher 대신 사용해요.</p><pre>public func `catch`&lt;P&gt;(<br>  _ handler: @escaping (Self.Failure) -&gt; P<br>) -&gt; Publishers.Catch&lt;Self, P&gt; where P : Publisher, Self.Output == P.Output<br><br>public init(<br>  upstream: Upstream,<br>  handler: @escaping (Upstream.Failure) -&gt; NewPublisher<br>)</pre><p>위에서 설명한 코드를 보면, 원본 Publisher는 PassthroughSubject&lt;Int, CustomError&gt; 이고 리턴된 Publisher는 Empty&lt;Int, CustomError&gt; 이니까, let errorHandlingSubject의 타입은</p><p>Publishers.Catch&lt;PassthroughSubject&lt;Int, CustomError&gt;, Empty&lt;Int, CustomError&gt;&gt; 에요.</p><p>그래서 이 Catch 객체의 새로운 퍼블리셔는 Empty&lt;Int, CustomError&gt; 라는 점!</p><p>Catch에 대한 더 자세한 설명은 여기에서 하지 않을게요. (이미 급발진을 한번 한것같지만..)</p><p>이제 errorHandlingSubject를 구독해볼까요?</p><pre>errorHandlingSubject<br>  .sink(<br>    receiveCompletion: { completion in<br>      switch completion {<br>      case .finished:<br>        print(&quot;Completed without error.&quot;)<br>      case .failure(let error):<br>        print(&quot;Received an error: \\(error)&quot;)<br>      }<br>    },<br>    receiveValue: { value in<br>      print(&quot;Received value: \\(value)&quot;)<br>    }<br>  )<br>	.store(in: &amp;cancellables)</pre><p>그리고 마지막으로 subject에 에러를 발행합니다!</p><pre>subject.send(completion: .failure(.customError))</pre><p>이제 한번 전체코드를 볼까요?</p><pre>enum CustomError: Error {<br>  case customError<br>}<br><br>let subject = PassthroughSubject&lt;Int, CustomError&gt;()<br>let errorHandlingSubject = subject<br>  .catch { error -&gt; Empty&lt;Int, CustomError&gt; in<br>    print(&quot;Error caught: \\(error)&quot;)<br>    return Empty&lt;Int, CustomError&gt;(completeImmediately: true)<br>  }<br>errorHandlingSubject<br>  .sink(<br>    receiveCompletion: { completion in<br>      switch completion {<br>      case .finished:<br>        print(&quot;Completed without error.&quot;)<br>      case .failure(let error):<br>        print(&quot;Received an error: \\(error)&quot;)<br>      }<br>    },<br>    receiveValue: { value in<br>      print(&quot;Received value: \\(value)&quot;)<br>    }<br>  )<br>  .store(in: &amp;cancellables)<br><br><br><br>// 에러 발행<br>subject.send(completion: .failure(.customError))</pre><p>이것의 결과는 다음과 같아요.</p><pre>Error caught: customError<br>Completed without error.</pre><p>Empty에서는 아무런 에러도 발행하지 않는다고 말했 듯, 위 예제에서도 값을 구독할 때 에러를 받지 않았어요.</p><p>결론적으로 Empty는 아무런 값을 방출하지 않고 선택적으로 데이터 스트림의 종료가 필요할 때 사용하게 돼요.</p><p>Empty에 Failure 타입이 필요한 이유는 Combine의 타입 시스템 내에서 유연성과 일관성을 유지하기 때문이에요.</p><p>어떤 Publisher이든 Failure 타입을 반드시 명시해야 하기 때문에 프로토콜을 준수하는 차원에서 Empty에도 Failure가 필요하다고 할 수 있어요.</p><h3>Fail</h3><p>Fail은 에러와 함께 즉시 데이터 스트림을 종료하는 Publisher에요.</p><h4>특징</h4><ul><li>에러만을 발행해요. 값(Output)을 발행하지 않아요.</li><li>Failure을 발행하기 때문에 즉시 스트림이 종료돼요.</li></ul><h4>사용</h4><pre>let failPublisher = Fail&lt;Never, CustomError&gt;(error: .customError)<br>failPublisher<br>  .sink { completion in<br>    switch completion {<br>    case .finished:<br>      print(&quot;finished!&quot;)<br>    case .failure(let error):<br>      print(&quot;error occured: \\(error)&quot;)<br>    }<br>  } receiveValue: { value in<br>    print(&quot;value received: \\(value)&quot;)<br>  }<br><br><br><br>// 결과<br>error occured: customError</pre><p>기본적으로 Completion이 .failure을 반환하면 데이터 스트림은 즉시 종료돼요.</p><p>오로지 에러만을 전달하는 Publisher라고 보면 돼요.</p><h3>Future</h3><p>Future은 단일 작업의 결과값을 비동기적으로 생성하고 완료할때까지 기다리는 Publisher에요.</p><p>다른 Publisher들과는 달리 <strong>비동기 이벤트를 핸들링</strong>하기 적합하게 만들어진 Publisher에요.</p><h4>특징</h4><ul><li>생성되는 그 즉시 비동기 작업을 수행해요.</li><li>비동기 작업의 결과가 리턴되기 전까지 대기해요.</li><li>작업의 결과를 단 한 번 Subscriber들 에게 발행해요.</li><li>반환 시 Promise 형태로 반환해요.</li><li>다른 Publisher들과는 다르게 클래스에요.</li></ul><h4>사용</h4><p>여기에서는 실제 네트워킹을 통해 데이터를 불러오고 이 데이터를 Future Publisher에 담아 구독하는 일련의 흐름을 설명할게요.</p><p>먼저 Data를 리턴하는 함수를 만들어요.</p><pre>func fetchUserDataAsync() async throws -&gt; Data {<br>  guard let url = URL(string: &quot;&lt;https://api.publicapis.org/entries&gt;&quot;) else {<br>    throw URLError(.badURL)<br>  }<br>  let (data, response) = try await URLSession.shared.data(from: url)<br>  guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {<br>    throw URLError(.badServerResponse)<br>  }<br>  return data<br>}</pre><p>그리고 Future을 통해 비동기 이벤트의 결과를 전달해요.</p><p>Future은 promise라는 클로저를 인자로 넘겨서 개발자가 성공과 실패에 대한 결과값을 이 promise 안에 담을 수 있어요.</p><p>이때 promise의 타입은 (Result&lt;Data, Error&gt;) -&gt; Void 이에요.</p><p>Future의 Output과 Failure값을 그대로 받는 것을 알 수 있어요.</p><pre>let futurePublisher = Future&lt;Data, Error&gt; { promise in<br>  Task {<br>    do {<br>      let data = try await fetchUserDataAsync()<br>      promise(.success(data))<br>    } catch {<br>      promise(.failure(error))<br>    }<br>  }<br>}</pre><p>이제 futurePublisher을 구독해요</p><p>성공 시 receiveValue에 값이 전달되고 스트림이 정상 종료돼요.</p><p>실패 시 failure(let error)에 에러가 할당돼요.</p><p>주의할 점은, 만일 비동기 결과가 두 번 이상 발생한다면, 이때의 결과는 무시돼요.</p><p>기본적으로 Future은 첫 번째의 비동기 결과만 발행할 수 있고, 이후의 이벤트는 발행되지 않아요.</p><p><strong>전체코드</strong></p><pre>var cancellables = Set&lt;AnyCancellable&gt;()<br><br>func fetchUserDataAsync() async throws -&gt; Data {<br>  guard let url = URL(string: &quot;&lt;https://api.publicapis.org/entries&gt;&quot;) else {<br>    throw URLError(.badURL)<br>  }<br>  let (data, response) = try await URLSession.shared.data(from: url)<br>  guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {<br>    throw URLError(.badServerResponse)<br>  }<br>  return data<br>}<br>let futurePublisher = Future&lt;Data, Error&gt; { promise in<br>  Task {<br>    do {<br>      let data = try await fetchUserDataAsync()<br>      promise(.success(data))<br>    } catch {<br>      promise(.failure(error))<br>    }<br>  }<br>}<br>futurePublisher<br>  .sink { completion in<br>    switch completion {<br>    case .finished:<br>      print(&quot;finished!&quot;)<br>    case .failure(let error):<br>      print(&quot;error: \\(error)&quot;)<br>    }<br>  } receiveValue: { value in<br>    print(value)<br>  }<br>  .store(in: &amp;cancellables)</pre><h4>Deep dive in Future</h4><p>먼저 Future의 구조를 살펴볼게요.</p><pre>final public class Future&lt;Output, Failure&gt; : Publisher where Failure : Error {<br><br>public typealias Promise = (Result&lt;Output, Failure&gt;) -&gt; Void<br>    public init(<br>      _ attemptToFulfill: @escaping (@escaping Future&lt;Output, Failure&gt;.Promise) -&gt; Void<br>    )<br>}</pre><p>먼저 Future은 다른 Publisher와는 다르게 <strong>클래스</strong>에요.</p><p>왜 클래스여야 할까요?</p><p><strong>클래스는</strong> 레퍼런스 타입이기 때문에 인스턴스가 참조에 의해 전달되어요. 여러곳에서 동일한 인스턴스를 참조한다면 모두 같은 주소값을 바라보고 있기 때문에 비동기 작업의 결과와 같은 변경 가능한 상태를 여러 구독자나 핸들러 사이에서 쉽게 공유할 수 있어요.</p><p><strong>반면에</strong> 구조체는 value 타입이기 때문에 구조체 인스턴스를 전달할 때마다 실제 데이터의 복사본이 생성돼요. 이는 데이터 불변성을 보장하지만, 비동기 작업의 결과와 같은 변경 가능한 상태를 공유하기에는 복사본 간의 동기화를 보장하기 힘들어요.</p><p>Future는 비동기 작업의 결과를 내부적으로 저장하고, 이 결과를 Future을 구독하고 있는 한 개 이상의 Subscriber(들)에게 공유해요. 그렇기 때문에 값 복사보다는 참조에 의한 인스턴스 공유가 상태를 훨씬 더 관리하기 용이해요.</p><p>실제 사용할 때 어떤 흐름으로 Future가 사용되는지 이해해볼게요.</p><p>Future의 이니셜라이저를 보면 attemptToFulfill 클로저가 Promise라는 타입을 인자로 해서 Void를 리턴해요.</p><pre>public init(<br>  _ attemptToFulfill: @escaping (@escaping Future&lt;Output, Failure&gt;.Promise) -&gt; Void<br>)</pre><p>여기서 Promise는 @escaping (Result&lt;Output, Failure&gt;) -&gt; Void 타입의 typealias 에요.</p><p>결국 attemptToFulfill 클로저는</p><p>@escaping (@escaping (Result&lt;Output, Failure&gt;) -&gt; Void) -&gt; Void 형식을 취하게 돼요.</p><p>위에서 사용한 Future를 볼게요.</p><pre>let futurePublisher = Future&lt;Data, Error&gt; { promise in<br>  ...<br>}</pre><p>이제 여기서 사용되고 있는 promise 의 타입이 짐작가시나요?</p><p><strong>promise: (Result&lt;Data, Error&gt;) -&gt; Void</strong></p><p>이제 promise의 정체를 알았으니 어떻게 사용하는지 다시 한번 볼게요.</p><pre>let futurePublisher = Future&lt;Data, Error&gt; { promise in<br>  ... <br>  do {<br>    promise(.success(data))<br>  } catch {<br>    promise(.failure(error)) <br>  }<br>  ...<br>}</pre><p>성공시 Result.success에 발행할 값을 담고, 실패시 Result.failure에 담을 에러를 담고 있어요.</p><p>그리고 구독 시 이 Result 타입에 따라 넘어오는 이벤트가 달라지게 돼요.</p><p>그런데 이상한 일이죠? Future 구조 어디에도 Promise 클로저를 처리하는 코드가 없어요.</p><p>이것은 애플이 비공식 API를 통해 Promise 클로저에 있는 값을 일련의 과정으로 처리해서 Subscriber에게 넘겨줌을 시사해요.</p><p>이는 Future 뿐 아니라 다른 기본제공되는 내장 Publisher들도 마찬가지에요. Publisher와 Subscriber의 관계성만 개발자가 정의하고 발행될 데이터가 어떠한 구체적인 프로세스로 구독되는지는 알 수 없어요 😲</p><p>결론적으로 Future을 사용할 때 개발자는 promise 클로저의 result 인자만 채워서 넘겨주면 되는거죠!</p><p>이제 promise의 정체를 알았으니 어떻게 사용하는지 다시 한번 볼게요.</p><pre>let futurePublisher = Future&lt;Data, Error&gt; { promise in<br>  ... <br>  do {<br>    promise(.success(data))<br>  } catch {<br>    promise(.failure(error)) <br>  }<br>  ...<br>}</pre><p>성공시 Result.success에 발행할 값을 담고, 실패시 Result.failure에 담을 에러를 담고 있어요.</p><p>그리고 구독 시 이 Result 타입에 따라 넘어오는 이벤트가 달라지게 돼요.</p><p>그런데 이상한 일이죠? Future 구조 어디에도 Promise 클로저를 처리하는 코드가 없어요.</p><p>이것은 애플이 비공식 API를 통해 Promise 클로저에 있는 값을 일련의 과정으로 처리해서 Subscriber에게 넘겨줌을 시사해요.</p><p>이는 Future 뿐 아니라 다른 기본제공되는 내장 Publisher들도 마찬가지에요. Publisher와 Subscriber의 관계성만 개발자가 정의하고 발행될 데이터가 어떠한 구체적인 프로세스로 구독되는지는 알 수 없어요 😲</p><p>결론적으로 Future을 사용할 때 개발자는 promise 클로저의 result 인자만 채워서 넘겨주면 되는거죠!</p><h3>Record</h3><p>Record 는 사전에 정의된 값을 순차적으로 발행하고, 정의된 완료 이벤트를 발행하는 Publisher입니다.</p><p>미리 정해진 값을 그대로 발행한다는 점에서 테스트 목적으로 주로 사용돼요.</p><h4>특징</h4><ol><li>미리 정의된 값을 순차적으로 발행해요. 즉, 어떻게 구독될 값은 생성시점에 이미 결정돼요.</li><li>외부 데이터 소스 없이 Mock Data만 사용하므로 단위테스트용으로 사용하기 적합해요.</li><li>Record는 구독하는 모든 Subscriber은 동일한 데이터 시퀀스와 완료이벤트를 받아요. 테스트시 일관된 조건을 유지하려고 할때 유용해요.</li></ol><h4>사용</h4><ul><li>에러를 발행하지 않을 경우</li></ul><pre>let recordPublisher = Record&lt;Int, Never&gt;(output: [1,2,3], completion: .finished)<br><br>recordPublisher<br>  .sink(receiveCompletion: { completion in<br>    switch completion {<br>    case .finished:<br>      print(&quot;finished&quot;)<br>    case .failure(let failure):<br>      print(failure)<br>    }<br>  }, receiveValue: { value in<br>    print(value)<br>  })<br>  .store(in: &amp;cancellables)<br><br><br><br>-- 결과<br>1<br>2<br>3<br>finished</pre><ul><li>에러를 발행할 경우</li></ul><pre>enum CustomError: Error  {<br>  case unknownError<br>}<br><br>let recordPublisher = Record&lt;Int, CustomError&gt;(output: [1,2,3], completion: .failure(.unknownError))<br>recordPublisher<br>  .sink(receiveCompletion: { completion in<br>    switch completion {<br>    case .finished:<br>      print(&quot;finished&quot;)<br>    case .failure(let failure):<br>      print(failure)<br>    }<br>  }, receiveValue: { value in<br>    print(value)<br>  })<br>  .store(in: &amp;cancellables)<br><br><br><br>-- 결과<br>1<br>2<br>3<br>unknownError</pre><h3>Deferred</h3><p>Deferred는 클로저 안에 정의된 Publisher가 실제로 구독이 되기 전까지 생성을 지연시키는 Publisher에요.</p><h4>특징</h4><ul><li>Deferred 는 생성 시 Publisher를 리턴하는 클로저를 가져요.</li><li>리턴된 Publisher는 즉각 인스턴스가 만들어지지 않고 lazy 하게 생성돼요. 즉 구독되는 시점에서 생성돼요.</li><li>리턴된 Publisher는 구독 시점의 최신 상태를 반영할 수 있어요.</li></ul><h4>사용</h4><pre>let deferredPublisherWithDelay = Deferred {<br>  return Just([1,2,3,4,5]) // 네트워킹 작업을 가정한 Publisher<br>  .delay(for: .seconds(1), scheduler: RunLoop.main)<br>}<br><br>deferredPublisherWithDelay<br>  .sink { values in<br>    print(values)<br>  }<br>  .store(in: &amp;cancellables)</pre><p>위 예제에서 Deferred의 내부 생성된 Publisher Just([1,2,3,4,5]) 는 sink 메서드를 통해서 구독이 이루어 질때 인스턴스가 생성돼요.</p><h4>동적 Publisher 생성</h4><p>Deferred는 Publisher을 주입하여 사용하기 때문에 상황에 따라 동적으로 다른 Publisher를 생성할 수 있습니다.</p><p>여기서는 인터넷 연결상태에 따라 Local 또는 원격 API 에서 데이터를 가져오는 Publisher를 구독하는 코드를 작성해보겠습니다.</p><pre>// 로드될 구조체<br>struct UserProfile {<br>  var userId: Int<br>  var profileUrl: URL<br>}<br><br>// 로컬 데이터 로드<br>func fetchUserFromLocal() -&gt; AnyPublisher&lt;Result&lt;UserProfile, Error&gt;, CustomError&gt; {<br>  return Just(.success(UserProfile(userId: -1, profileUrl: URL(string: &quot;&lt;https://www.mock.placeholder&gt;&quot;)!)))<br>    .setFailureType(to: CustomError.self)<br>    .eraseToAnyPublisher()<br>}<br>// 원격 데이터 로드<br>func fetchUserFromRemote(userId: Int) -&gt; AnyPublisher&lt;Result&lt;UserProfile, Error&gt;, CustomError&gt; {<br>  // 예제를 위한 가상의 URL<br>  let url = URL(string: &quot;&lt;https://example.com/users/\\(userId)&gt;&quot;)!<br>  return Future&lt;Result&lt;UserProfile, Error&gt;, Never&gt; { promise in<br>    promise(.success(.success(UserProfile(userId: userId, profileUrl: url))))<br>  }<br> .setFailureType(to: CustomError.self)<br>  .eraseToAnyPublisher()<br>}<br>// 인터넷 연결여부 체크 가정<br>func isConnectedToInternet() -&gt; Bool { <br> return Bool.random()<br>}<br>// 인터넷 연결여부에 따라 다른 Publisher 적용<br>let dynamicPublisher = Deferred { <br> isConnectedToInternet() ? fetchUserFromRemote(userId: 1) : fetchUserFromLocal()<br>}<br>// Deferred 구독<br>dynamicPublisher<br>  .sink { completion in<br>    switch completion {<br>    case .finished:<br>      print(&quot;finished&quot;)<br>    case .failure(let error):<br>      print(&quot;error occured: \\(error)&quot;)<br>    }<br>  } receiveValue: { result in<br>    switch result {<br>    case .success(let userProfile):<br>      print(userProfile)<br>    case .failure(let error):<br>      print(&quot;custom error occured: \\(error)&quot;)<br>    }<br>  }<br>  .store(in: &amp;cancellables)</pre><p>로컬에서 데이터를 로드할 때는 Just, 원격에서 로드할 때는 Future Publisher을 사용했어요.</p><p>구독할 Publisher의 종류가 동일해야 하므로 eraseToAnyPublisher로 타입을 지워줘면 돼요.</p><p>AnyPublisher는 구체 Publisher 타입을 래핑한 것으로, Publisher 타입을 지워서 구독 시 실제 Publisher의 타입과 무관하게 사용가능하게 만드는 역할을 수행해요.</p><h3>AnyPublisher</h3><p>AnyPublisher는 프로토콜 Publisher을 준수하는 어떤 Publisher를 추상화하여 해당 Publisher의 구체 타입을 소거하는 Publisher 입니다.</p><h4>특징</h4><ul><li>Publisher 프로토콜을 준수하기만 하면 어떤 타입이든 상관없이 적용할 수 있어요. 이는 변환 타입을 통일하여 구독 시 publisher chain을 구성할 때 강점을 발휘해요.</li><li>Publisher 프로토콜의 모든 기능을 수행할 수 있어요.</li></ul><h4>사용</h4><pre>func fetchData() -&gt; AnyPublisher&lt;Data, Error&gt; {<br>  URLSession.shared.dataTaskPublisher(for: URL(string: &quot;&lt;https://example.com&gt;&quot;)!)<br>      .map { $0.data }<br>      .mapError { $0 as Error }<br>      .eraseToAnyPublisher() // URLSession의 Publisher를 AnyPublisher로 타입 소거<br>}<br><br>fetchData()<br>  .sink { completion in<br>    switch completion {<br>    case .finished:<br>      print(&quot;finished&quot;)<br>    case .failure(let error):<br>      print(&quot;error: \\(error)&quot;)<br>    }<br>  } receiveValue: { value in<br>    print(value)<br>  }<br>  .store(in: &amp;cancellables)</pre><p>URLSession의 dataTaskPublisher을 사용하면 URLSession.DataTaskPublisher 타입의 Publisher가 리턴돼요.</p><pre>public func dataTaskPublisher(for url: URL) -&gt; URLSession.DataTaskPublisher</pre><p>이후 map 과 mapError을 Operator을 사용하여 dataTaskPublisher의 Output과 Failure을 가져오고, eraseToAnyPublisher을 통해 AnyPublisher 로 래핑하는 코드에요.</p><p>물론 타입소거 없이 그대로 사용하는 방법도 있어요</p><pre>func fetchData() -&gt; URLSession.DataTaskPublisher {<br>  URLSession.shared.dataTaskPublisher(for: URL(string: &quot;&lt;https://example.com&gt;&quot;)!)<br>}</pre><p>하지만 이후 다른 Publisher와 상호작용 해야하는 상황이 발생한다면 구체타입을 더 이상 사용할 수 없으므로 AnyPublisher로 추상화 시켜야 해요.</p><p>상황에 맞게 사용하면 됩니다 😊</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f78d44215ff5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[뿌요와 함께하는 Combine: 시작하기]]></title>
            <link>https://medium.com/@bbuyo/%EB%BF%8C%EC%9A%94%EC%99%80-%ED%95%A8%EA%BB%98%ED%95%98%EB%8A%94-combine-t-7f3dc9e197a6?source=rss-3bb76b7aabf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/7f3dc9e197a6</guid>
            <category><![CDATA[combine]]></category>
            <dc:creator><![CDATA[뿌요]]></dc:creator>
            <pubDate>Fri, 15 Mar 2024 13:26:28 GMT</pubDate>
            <atom:updated>2025-04-09T05:52:52.534Z</atom:updated>
            <content:encoded><![CDATA[<h3>뿌요와 함께하는 Combine 시작하기</h3><p>안녕하세요.</p><p>오랜만에 돌아온 게으른 뿌요입니다. <br>엄청나게 바쁜 시기들을 지나긴 했지만..! 그래도 너무 오래 절필한 것 같아 칼을 갈고 돌아왔습니다.</p><p>바로바로 Combine!</p><p>언젠가 공부하겠지~ 공부하겠지~ 하다가 이제야 공개할 수 있을 정도가 됐다고 판단되어 요렇게 올려봅니다.</p><p>그럼 같이 한번 달려보자구요!</p><h3>시작하기 전에…</h3><p>Combine에 대해 알아보기 전에 잠깐 Combine이 무엇인지 간략하게 소개하고 본격적으로 Combine의 구성요소들을 알아볼 때 헷갈릴만한 용어들에 대해서 확정하겠습니다.</p><h3>Combine과 비동기 프로그래밍 (그리고 RxSwift)</h3><p>Combine이 나온 2019년 이전에도 우리는 비동기 프로그래밍을 알고 (혹은 모르고) 사용하고 있었습니다.</p><p>대표적인 것들로는 Target(action), Notification Center, URLSession, Completion Handler 등등이요.</p><p>다양한 종류의 비동기처리 API가 있는것은 참 좋은 일이지만 아무리 그래도 한번에 이 모든것들을 관리해주는 주체가 있으면 더 좋을 것입니다.</p><p>그래서 RX프로그래밍을 Swift로 이식한 라이브러리로 RxSwift가 대두되고 많은 iOS개발자들의 사랑을 받았습니다! 그리고 여전히 수많은 프로젝트에서 활발하게 쓰이고 있죠.</p><p>Combine은 RxSwift와 마찬가지로 흩뿌려져 있는 비동기 API를 한데로 묶고 통합하여 사용하기 위한 API 입니다.</p><p>RxSwift와 많은 개념들이 유사하기 때문에 이에 익숙하다면 Combine 역시도 금방 이해하고 사용할 수 있어요!</p><p>RxSwift를 몰라도 괜찮아요! Combine은 개발자가 쉽고 능숙하게 비동기 프로그래밍을 익힐 수 있도록 도와주는 최고의 도구니까요. 걱정하지 말고 따라와주세요 😉</p><h3>작성원칙</h3><p>아래 원칙에 의거하여 작성하겠습니다.</p><ol><li>Publisher, Subscriber, Operator 등의 필수 요소에 대해서는 한글로 번역하여 서술하지 않습니다.</li><li>예를 들어, Publisher를 게시자(출판자, 방출자 …) 로 임의 번역하지 않습니다.</li><li>마찬가지로, Subscriber를 구독자로 임의 번역하지 않습니다.</li><li>publish는 “발행” subscribe는 “구독” method는 “메서드”로 작성합니다.</li><li>가독성이 높아진다고 판단 시 소괄호 안에 내용이 추가됩니다.</li><li>RxSwift, RxCocoa를 모르는 독자를 위해 Combine과 RX개념을 연관짓지 않습니다.</li></ol><h3>그리고…</h3><p>글을 살펴보다 모르는 용어가 나오면 좌절하지 마세요! 이런게 있구나~ 하고 넘어가면서 하나씩 읽어나가다 보면 다시 글을 살펴보았을때 자연스럽게 읽히게 될거에요.</p><blockquote><em>성공은 최종적이지 않고, 실패는 치명적이지 않습니다. 중요한 것은 계속하는 용기입니다. <br>Success is not final, failure is not fatal: it is the courage to continue that counts.</em></blockquote><blockquote>윈스턴 처칠</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f3dc9e197a6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Seoul iOS Meetup 발표 후기]]></title>
            <link>https://medium.com/@bbuyo/seoul-ios-meetup-%EB%B0%9C%ED%91%9C-%ED%9B%84%EA%B8%B0-8a484eb851d6?source=rss-3bb76b7aabf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/8a484eb851d6</guid>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[뿌요]]></dc:creator>
            <pubDate>Tue, 18 Jul 2023 15:06:46 GMT</pubDate>
            <atom:updated>2023-08-31T12:29:02.660Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3KVnobj3ySwyQlNykTzFbw.jpeg" /></figure><h4>발단</h4><p>매번 프로젝트를 만들 때 마다 Tuist를 세팅하기에 너무나도 귀찮았던 어느 날, 문득 Tuist를 자동으로 생성해주는 스크립트를 만들면 너무 편할 것 같았다.</p><p>그래서 TuistAutoGen이라는 유틸리티 라이브러리를 만들었는데 여기에서 스노우볼이 굴러갈 줄 꿈에도 몰랐다..</p><p>간단히 설명하자면 명령어 한 줄로 모듈화 된 프로젝트를 생성할 수 있도록 고안된 라이브러리이다.</p><p><a href="https://github.com/naldal/TuistAutoGen/blob/main/README.Ko.md">TuistAutoGen/README.Ko.md at main · naldal/TuistAutoGen</a></p><p>다 만들고나니 뭔가 나혼자 쓰기에는 아깝고! 아쉽고! 남들도 써줬으면 좋겠고! 하는 내면의 관종이 슬슬 움직이기 시작한 것이다;</p><p>그래서 이전에 참여했었던 Seoul iOS Meetup 슬랙에 공유를 했는데 Tuist에 관해서 발표해달라는 요청을 받게 되었다…!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zkXPE3MB1emDFg5AvQ9Qtw.png" /></figure><p>한국어로도 덜덜떨면서 발표하는 내가 영어로 발표한다는게 전혀 와닿지 않았다.. 그래도 발표까지 3주 남았으니까 어떻게든 되겠지 하는 마음으로 수락해따!</p><p>그리고 Tuist 공식에서 왠지모르게 이 사실을 알게되었다..</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/591/1*jszbPb0RQAK6r-6QNaaLog.png" /></figure><p>사실 발표 자체는 별로 부담이 없었는데 이때부터 엄청난 긴장감이 느껴오기 시작했다… 🫠</p><h4>준비</h4><p>일단 Tuist에 대해서 개괄적인 설명을 할까 하다가 그렇게 하면 임팩트도 별로 없는거같구.. 받아들이는 입장에서도 별로 와닿지 않을 것 같아서 일단 Tuist를 사용한 샘플앱을 만들어서 이걸 토대로 Tuist를 설명하면 아주 탄탄한 발표가 될 것 같았다.</p><p>어떤 앱을 만들까 한창 고민을 했는데 “이 컨퍼런스는 한국인들과 외국인 모두 참여할 수 있으니까 번역기 만들면 뭔가 찰떡이네~” 하는 의식의 흐름대로 번역 어플리케이션을 만들기루 했다.</p><p>약 일주일에 걸쳐서 만든 결과 “토키 — 실시간 음성 번역&quot; 이름으로 무사히 출시했다!</p><p><a href="https://apps.apple.com/kr/app/%ED%86%A0%ED%82%A4-%EC%8B%A4%EC%8B%9C%EA%B0%84-%EC%9D%8C%EC%84%B1-%EB%B2%88%EC%97%AD/id6450802019">‎토키 - 실시간 음성 번역</a></p><p>요건 깃헙</p><p><a href="https://github.com/naldal/Talky">GitHub - naldal/Talky</a></p><p>다음 스텝으로 발표자료를 준비하는데, 만들면 만들수록 맘에 안들고 뭔가 부족한거 같고.. 스크립트에 익숙해질 새도 없이 무한 수정 지옥에 빠져들게 되었다.</p><p>더욱이 직접 Tuist 기본 프로젝트와 만들었던 앱의 Tuist 구조 설명하는 것까지 발표에 넣다보니 마무리 될 때 쯤 처음 29장이었던 슬라이드가 46장으로 늘어났다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*baScDSy4dRG0bcx8rvBqGw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1011/1*a7x4IsGGmtE09dM4-m74fw.png" /><figcaption>그와중에 개그욕심부리기</figcaption></figure><p>그렇게 시간가는줄 모르고 발표준비를 하다보니 어느새 디데이가 되고 말았다..!!!</p><h4>발표</h4><p>발표는 강남 모두의캠퍼스에서 진행됐다. 강남역에 내리자마자 정말 엄청나게 떨려서 약국에서 우황청심환 한 개를 클리어.</p><p>우여곡절 끝에 발표를 시작했는데 발표를 어떻게 했는지 기억도 잘 안날 정도로 시간이 순식간에 지나간것 같다.</p><p>중간에 시연하는 과정이 있었는데 이때 원래 스크립트를 보면서 할 계획이었지만 스크립트가 정리된 노션을 어디다 놨는지 몰라서 그냥 프리토킹으로 했다.. 이때가 정말 고비였던듯.</p><p>조금 떠듬떠듬거렸지만 나쁘지 않다고 생각..하기로 했다</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uD52muI7n6m_NETsCt_2Og.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h-2wGZGVEvfN0x-DSz4RdQ.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QwYSEE1pQjbE8cOZEJbhrw.jpeg" /></figure><h4>후기</h4><p>3주간의 준비 후 발표를 끝내고 나니 정말 후련해지고 삶의 여유가 생겼다.. 준비하면서도 내가 이걸 왜한다고했지.. 후회막심을 하루에도 세번씩 했지만 돌이켜보니 정말 특별했던 경험이 되어준 것 같다.</p><p>특히 Tuist에 대해서 거의 몰랐던 내가 발표 뿐만 아니라 직접 만든 라이브러리까지 소개했다는 사실에 사실에 스스로 자랑스러웠다.</p><p>다음에도 발표할 기회가 있으면 또 주저없.. ? 이..? 한 5시간 정도 고민하다가 수락할 거 같다! ㅎㅎ</p><p>어떻게 끝맺음을 해야할지 모르겠어서 Seoul iOS Meetup 참여링크 올리고 갑니다 총총</p><p><a href="https://www.meetup.com/ko-KR/seoul-ios-meetup/">Seoul iOS Meetup | Meetup</a></p><p>많은 관심 부탁드립니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/380/1*VzjBlOjpwslIbSO_-fO0hA.png" /></figure><h3>추가</h3><p>Tuist 공식 깃헙에서 참고자료를 모아두는 awesome-tuist의 Talks 섹션에 등재됐다!</p><p><a href="https://github.com/tuist/awesome-tuist">GitHub - tuist/awesome-tuist: A community-driven collection of Tuist related posts, plugins, talks, and much more.</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/684/1*7B7A9fLLhpIM4YJhnqg2Bw.png" /></figure><p>거기에 TuistAutoGen까지 등재됐네요??</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/1*ENpT--Y4fs5MYCG2x0gvbg.png" /></figure><p>으와앙..</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8a484eb851d6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[클린 아키텍처 1. 객체지향 설계를 위한 SOLID 원칙: SRP]]></title>
            <link>https://medium.com/@bbuyo/%ED%81%B4%EB%A6%B0-%EC%95%84%ED%82%A4%ED%85%8D%EC%B2%98-1-%EA%B0%9D%EC%B2%B4%EC%A7%80%ED%96%A5-%EC%84%A4%EA%B3%84%EB%A5%BC-%EC%9C%84%ED%95%9C-solid-%EC%9B%90%EC%B9%99-srp-527387db05b1?source=rss-3bb76b7aabf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/527387db05b1</guid>
            <category><![CDATA[solid]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[뿌요]]></dc:creator>
            <pubDate>Sat, 20 May 2023 13:42:14 GMT</pubDate>
            <atom:updated>2023-05-20T16:56:19.873Z</atom:updated>
            <content:encoded><![CDATA[<h3>들어가며</h3><p>소프트웨어의 가장 근본적인 특징은 바로 변화입니다. 하드웨어와는 다르게 소프트웨어는 다양한 요구사항에 발맞추어 계속해서 수정, 보완되어야 합니다.</p><p>하지만 요구사항의 변경은 언제나 소프트웨어에 직접적인 <strong>위험과 충격</strong>을 가하게 됩니다.</p><p>따라서 좋은 설계의 목표는 이러한 위험과 충격에 대응하기 위한 코드의 유연성과 확장성을 확보하는 것 입니다.</p><p>그러나 많은 소프트웨어 개발에서는 초기 설계 단계에서부터 필요 이상으로 복잡하고 의존성이 높은 구조를 만들어내는 경우가 많습니다. 이러한 설계는 앞으로의 개발 과정에서 큰 문제를 일으키며, 코드의 유지보수와 확장성을 크게 해치게 됩니다.</p><p>클린 아키텍처는 이러한 문제를 해결하기 위한 설계 철학으로써, 객체간의 적절한 구조화와 유지 관리, 확장성에 초점을 맞추어 소프트웨어의 품질과 확장성을 개선하고 코드를 더욱 유연하고 이해하기 쉽게 만듭니다.</p><h3>클린 아키텍처와 객체지향 설계</h3><p>클린 아키텍처와 객체지향 설계는 모두 소프트웨어 엔지니어링 패러다임에서 <strong>유지보수성</strong>, <strong>확장성</strong>, <strong>가독성</strong> 등을 높이기 위한 방법론입니다. 이들은 서로 밀접하게 관련되어 있으며, 구체적으로는 다음과 같은 공통된 목표를 가지고 있습니다.</p><ol><li>코드 품질과 유지관리</li><li>캡슐화와 관심사 분리</li><li>응집도와 결합도 관리</li><li>코드 재사용 및 모듈화</li><li>테스트 용이성</li></ol><p>클린 아키텍처는 이처럼 객체지향 설계의 기본원칙들 위에 세워진 설계 방법론이므로 객체지향에 대한 높은 이해도 없이는 클린 아키텍처를 적용하기 어렵습니다.</p><p>이 포스팅에서부터 클린 아키텍처의 근간이 되는 SOLID 원칙들에 대해서 살펴보고 예시를 통한 적용까지 해보는 것을 목표로 하겠습니다.</p><p>이 장에서는 SOLID 원칙 중 가장 먼저 SRP에 대해서 살펴보겠습니다.</p><h4>단일 책임 원칙 (Single Responsibility Principle, SRP)</h4><p>이 원칙은 소프트웨어 구성 요소(클래스, 모듈, 함수 등)가 하나의 책임만을 가지도록 설계하는 것을 권장합니다. 즉, 각 구성 요소는 하나의 분명한 목적을 가져야 하며, 이 목적에만 집중해야 합니다.</p><p>SRP의 핵심은 코드의 견고성, 가독성, 유지 관리성을 높이기 위해 각 구성 요소가 변화에 필요한 이유가 단 한 가지 뿐이어야 한다는 것입니다. 이 원칙의 장점은 다음과 같습니다.</p><p><strong>1. 유지 관리성 향상</strong>: 하나의 책임만을 가진 소프트웨어 구성 요소는 수정이 필요한 경우 변경할 부분이 명확하고 작업이 용이하게 됩니다. 따라서 유지 관리가 간편해집니다.</p><p><strong>2. 가독성 향상</strong>: 각 구성 요소가 명확한 책임과 목적을 가지고 있으면 코드를 읽고 이해하기가 쉽습니다. 이로 인해 코드의 가독성이 향상되며 특히 다른 팀 구성원이 코드를 파악하기에 더욱 효과적입니다.</p><p><strong>3. 재사용성 향상</strong>: 단일 책임 원칙에 따라 설계된 구성 요소는 독립성과 추상화가 높아져 재사용 가능성이 높아집니다. 이렇게 재사용 가능한 구성 요소들은 다른 프로젝트나 컨텍스트에서도 이용할 수 있어 개발 생산성이 향상됩니다.</p><p><strong>4. 테스트 용이성</strong>: 하나의 책임만을 가진 구성 요소는 테스트하기 쉽습니다. 책임이 명확하고 독립적인 구성 요소에 대한 유닛 테스트 작성이 간편하며, 오류 발생 가능성을 낮추고 테스트의 품질을 향상시킬 수 있습니다.</p><p><strong>5. 응집도 향상 및 결합도 감소:</strong> 단일 책임 원칙에 따라 설계된 구성 요소는 높은 응집도와 낮은 결합도를 가집니다. 이를 통해 시스템의 안정성과 유연성이 향상되며, 변화에 대응하기 용이해집니다.</p><p>SRP를 지키기 위해서는 다음과 같은 사항을 고려해야 합니다.</p><ul><li>각 클래스, 모듈, 함수의 목적과 책임을 명확하게 한다.</li><li>코드를 작성하거나 수정할 때 변화의 이유를 확인하여 책임이 여러 개인 곳을 발견할 경우 분리한다.</li><li>각 구성 요소의 크기를 작게 유지하여 가능한 단순하게 한다.</li></ul><p>단일 책임 원칙은 소프트웨어 개발에서 중요한 원칙 중 하나로, 이를 적용하여 프로젝트의 유지 관리성, 가독성, 확장성 등의 품질을 높일 수 있습니다. 이 원칙을 지키는 것은 클린 코드 및 클린 아키텍처의 핵심이기도 하므로, 소프트웨어 설계와 구현에 있어 꼭 고려해야 합니다.</p><p>다음은 SRP 를 위반한 사례를 들어보고 SRP를 위배할 시 개발에 있어 어떠한 실질적 위험이 발생하는지 보겠습니다.</p><pre>class UserInformation {<br>    var name: String<br>    var age: Int<br>    <br>    init(name: String, age: Int) {<br>        self.name = name<br>        self.age = age<br>    }<br>    <br>    func saveToDatabase() {<br>        // 사용자 정보를 데이터베이스에 저장하는 작업<br>        // ...<br>    }<br>    <br>    func sendEmail() {<br>        // 사용자에게 이메일을 보내는 작업<br>        // ...<br>    }<br>    <br>    func generateReport() {<br>        // 사용자 정보를 기반으로 보고서를 생성하는 작업<br>        // ...<br>    }<br>    <br>    func validateData() -&gt; Bool {<br>        // 사용자 정보의 유효성을 검사하는 작업<br>        // ...<br>        return isValid<br>    }<br><br><br>    ...<br>}</pre><p>위의 예시에서 UserInformation 클래스는 사용자 정보를 담고 있는 객체로, 여러 가지 책임을 가지고 있습니다.</p><ol><li>saveToDatabase: 사용자 정보를 데이터베이스에 저장하는 작업을 수행합니다.</li><li>sendEmail: 사용자에게 이메일을 보내는 작업을 수행합니다.</li><li>generateReport: 사용자 정보를 기반으로 보고서를 생성하는 작업을 수행합니다.</li><li>validateData: 사용자 정보의 유효성을 검사하는 작업을 수행합니다.</li></ol><p>이렇게 한 클래스가 다양한 책임을 가지고 있다면, 변경이 발생할 때 한 책임의 수정이 다른 책임에 영향을 줄 수 있습니다. 또한, 클래스의 크기가 커지고 관리가 어려워지는 문제가 발생할 수 있습니다.</p><p>이렇게 한 객체에 여러가지 책임이 몰려있으면 어떠한 위험이 있는지 위에서 설명한 SRP의 5가지 장점에 들어 설명해보겠습니다.</p><h4>유지 관리성 향상</h4><blockquote>하나의 책임만을 가진 소프트웨어 구성 요소는 수정이 필요한 경우 변경할 부분이 명확하고 작업이 용이하게 됩니다. 따라서 유지 관리가 간편해집니다.</blockquote><p>어느날, 당신의 상사로부터 이메일 전송 로직을 수정하라는 요구사항이 들어왔습니다. 하지만 당신은 이메일 전송 로직이 UserInformation 에 있다는 사실을 인지하는 것에서부터 난항을 겪게 됩니다.</p><p>물론 UserInformation을 구현할 당시에는 개발자 스스로가 UserInformation에 어떠한 책임을 가지고 있는지 파악하겠지만, 시간이 지나고 관리해야 하는 코드량이 증가하게 되면서 UserInformation에 대한 인식 역시 흐려지게 될 가능성이 매우 높아집니다.</p><p>가까스로 UserInformation을 수정해야 한다는 사실을 알게 되더라도 UserInformation 이 가지고 있는 메서드를 <strong>하나하나 확인</strong>하며 이메일 전송 로직이 무엇인지 확인해야만 했습니다.</p><p>이러한 수정작업은 개발자의 집중력과 시간을 필연적으로 요구하므로 결과적으로 유지 관리성을 저해하고, 이러한 SRP위반 사례가 많아질수록 코드의 복잡성이 증가하게 됩니다.</p><h4>가독성 향상</h4><blockquote>각 구성 요소가 명확한 책임과 목적을 가지고 있으면 코드를 읽고 이해하기가 쉽습니다. 이로 인해 코드의 가독성이 향상되며 특히 다른 팀 구성원이 코드를 파악하기에 더욱 효과적입니다.</blockquote><p>이제 당신의 팀에 새로운 개발자가 들어왔습니다. 그는 UserInformation을 보고 보고서를 생성하는 로직을 여기에 감히 넣어뒀으리라 생각하지 못합니다.</p><p>몇일 후 그는 상사의 요청으로 보고서를 생성하는 로직을 최적화 시키는 작업을 진행하게 되었습니다. 하지만 UserInformation 에 generateReport 메서드가 있다는 사실을 뒤늦게 알았지만 이미 많은 시간이 허비되었습니다…</p><p>겨우겨우 작업을 시작했지만 그동안 당신이 추가한 (그리고 SRP 를 위반한) 로직들 사이에서 보고서를 작성하는 로직을 수정할 때 UserInformation에 어떠한 사이드이펙트가 발생할 수 있는지 알 수 없었고, 결국 버그가 생기고 말았답니다 ~끝~</p><p>이러한 시나리오가 일어날 가능성은 분명히, 그리고 꽤 높은 확률로 존재하기 때문에 가독성 향상을 위해 SRP는 반드시 지켜야 합니다.</p><h4><strong>재사용성 향상</strong></h4><blockquote>단일 책임 원칙에 따라 설계된 구성 요소는 독립성과 추상화가 높아져 재사용 가능성이 높아집니다. 이렇게 재사용 가능한 구성 요소들은 다른 프로젝트나 컨텍스트에서도 이용할 수 있어 개발 생산성이 향상됩니다.</blockquote><p>이제 회사에서는 새로운 앱을 만들고 싶어합니다. 다행히도 새로운 앱 역시 사용자 정보를 데이터베이스에 저장하는 요구사항은 동일하며 당신은 쉽사리 이를 해낼 것이라 자신합니다.</p><p>그래서 열심히 만들었던 데이터베이스 저장로직을 <strong>처음부터 다시</strong> 작성하기 시작합니다. 정말 열심히 일했지만.. 만들었던 로직이 정상적으로 작동하지 않습니다! 어쩔수 없이, UserInformation에 만들었던 사용자 정보 저장로직을 <strong>복사 붙혀넣기 </strong>할 수밖에 없었습니다.</p><p>이러한 시나리오를 방지하기 위해서는 <strong>“모듈&quot;</strong>이 필요합니다. 다시 말해 사용자 정보를 데이터베이스에 저장하는 역할을 맡은 <strong>모듈</strong>을 만들어야, 다른 프로젝트나 컨텍스트에서도 재사용이 가능해집니다.</p><h4><strong>테스트 용이성</strong></h4><blockquote>하나의 책임만을 가진 구성 요소는 테스트하기 쉽습니다. 책임이 명확하고 독립적인 구성 요소에 대한 유닛 테스트 작성이 간편하며, 오류 발생 가능성을 낮추고 테스트의 품질을 향상시킬 수 있습니다.</blockquote><p>당신은 UserInformation에 대한 테스트 코드를 짜기 시작합니다.</p><p>다음과 같이 말이죠</p><pre>import Quick<br>import Nimble<br><br>class UserInformationSpec: QuickSpec {<br>    override func spec() {<br>        describe(&quot;UserInformation&quot;) {<br>            var userInformation: UserInformation!<br>            <br>            beforeEach {<br>                userInformation = UserInformation(name: &quot;John Doe&quot;, age: 25)<br>            }<br>            <br>            context(&quot;데이터 저장&quot;) {<br>                it(&quot;사용자 정보를 데이터베이스에 저장해야 한다&quot;) {<br>                    userInformation.saveToDatabase()<br>                    let isSaved = checkUserSavedInDatabase(name: userInformation.name)<br>                    expect(isSaved).to(beTrue())<br>                }<br>            }<br>            <br>            context(&quot;이메일 전송&quot;) {<br>                it(&quot;사용자에게 이메일을 보내야 한다&quot;) {<br>                    userInformation.sendEmail()<br>                    let isEmailSent = checkEmailSent(userInformation: userInformation)<br>                    expect(isEmailSent).to(beTrue())<br>                }<br>            }<br>            <br>            context(&quot;보고서 생성&quot;) {<br>                it(&quot;사용자 정보를 기반으로 보고서를 생성해야 한다&quot;) {<br>                    userInformation.generateReport()<br>                    let isReportGenerated = checkReportGenerated(userInformation: userInformation)<br>                    expect(isReportGenerated).to(beTrue())<br>                }<br>            }<br>            <br>            context(&quot;데이터 유효성 검사&quot;) {<br>                it(&quot;사용자 정보의 유효성을 검사해야 한다&quot;) {<br>                    let isValid = userInformation.validateData()<br>                    expect(isValid).to(beTrue())<br>                }<br>            }<br>        }<br>    }<br>    <br>    func checkUserSavedInDatabase(name: String) -&gt; Bool {<br>        // 데이터베이스에서 사용자 정보를 확인하는 로직<br>        // ...<br>        return isSaved<br>    }<br>    <br>    func checkEmailSent(userInformation: UserInformation) -&gt; Bool {<br>        // 이메일을 보냈는지 확인하는 로직<br>        // ...<br>        return isEmailSent<br>    }<br>    <br>    func checkReportGenerated(userInformation: UserInformation) -&gt; Bool {<br>        // 보고서 생성 여부를 확인하는 로직<br>        // ...<br>        return isReportGenerated<br>    }<br>}</pre><p>UserInformation 에 대한 테스트코드를 작성한다 하더라도, 테스트 케이스가 여러 책임을 다루기 때문에 테스트의 관점과 목적이 혼란스러워지고, 테스트 코드의 복잡도가 증가합니다.</p><p>예를 들어, saveToDatabase 메서드를 테스트할 때 해당 메서드가 사용자 정보를 데이터베이스에 저장하는지 검증하는 것은 적절합니다. 그러나 동시에 이메일 전송이나 보고서 생성, 데이터 유효성 검사를 테스트하는 것은 테스트 코드의 의도가 분명하지 않고, 테스트 데이터를 준비하고 정리하는 부분도 복잡해집니다.</p><p>SRP를 준수하도록 코드를 재구성하면, 각 책임에 맞는 작은 단위의 클래스가 생성되기 때문에 테스트 코드도 단순하고 명확해집니다. 또한, 테스트의 목적이 분명해지고 테스트 코드를 작성하기 쉬워집니다.</p><h4><strong>응집도 향상 및 결합도 감소</strong></h4><blockquote>단일 책임 원칙에 따라 설계된 구성 요소는 높은 응집도와 낮은 결합도를 가집니다. 이를 통해 시스템의 안정성과 유연성이 향상되며, 변화에 대응하기 용이해집니다.</blockquote><p>객체지향 설계에서는 응집도를 높이고 결합도를 낮추는 것이 중요합니다. 높은 응집도와 낮은 결합도를 가진 모듈들은 유지 보수성과 확장성이 우수하며, 코드의 가독성과 재사용성을 향상시킵니다.</p><p>UserInformation은 모듈들 간의 상호 의존성이 높아 결합도가 높아진 모습입니다. 모듈 간에 직접적인 호출이나 데이터 공유가 많이 발생하며, 변경이 다른 모듈에 큰 영향을 줄 수 있습니다.</p><p>응집도 측면에서도 UserInformation의 구성 요소들이 서로 관련성이 적거나 명확하지 않습니다. 이는 유지 보수를 어렵게 만들 수 있습니다.</p><p>추가로 높은 응집도는 다음과 같은 수준으로 분류할 수 있습니다.</p><ol><li>기능적 응집도(Functional Cohesion): 모듈 내부의 구성 요소들이 동일한 기능을 수행하는 경우입니다. 이는 응집도가 가장 높은 수준이며, 모듈이 하나의 목적에 집중되어 있는 것을 나타냅니다.</li><li>순차적 응집도(Sequential Cohesion): 모듈 내부의 구성 요소들이 연속적인 순서로 동작하는 경우입니다. 예를 들어, 한 구성 요소의 출력이 다음 구성 요소의 입력으로 사용되는 경우입니다.</li><li>통신적 응집도(Communicational Cohesion): 모듈 내부의 구성 요소들이 동일한 데이터나 정보를 공유하는 경우입니다. 이는 주로 데이터 구조를 기반으로 동작하는 경우입니다.</li><li>절차적 응집도(Procedural Cohesion): 모듈 내부의 구성 요소들이 서로 다른 연산을 수행하지만 전체적인 절차에 따라 동작하는 경우입니다. 이는 관련 기능들이 논리적으로 그룹화되어 있는 것을 나타냅니다.</li></ol><h3>마치며</h3><p>이번 포스팅에서는 클린 아키텍처를 이해하기 위한 SOLID 원칙 중 SRP를 설명했습니다. 다음 포스팅에서는 OCP (개방폐쇄 원칙) 에 대해서 설명하고 실제 사례를 들어 이해해 보도록 하겠습니다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=527387db05b1" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>