카페24로 모바일 앱과 쇼핑몰 연동하기 🚀

안녕, 친구들! 오늘은 정말 흥미진진한 주제로 찾아왔어. 바로 카페24를 이용해서 모바일 앱과 쇼핑몰을 연동하는 방법에 대해 알아볼 거야. 😎 이 주제는 요즘 온라인 비즈니스를 하는 사람들에게 정말 중요한 내용이지. 왜냐고? 모바일 쇼핑이 대세가 된 지금, 앱과 쇼핑몰의 연동은 선택이 아닌 필수가 되었거든!

우리가 살펴볼 내용들은 프로그램 개발 카테고리 중에서도 쇼핑몰 관련 개발에 속하는 내용이야. 그러니까 기술적인 부분도 있겠지만, 비즈니스적인 측면에서도 많은 도움이 될 거야. 자, 그럼 시작해볼까?

카페24란 뭐야? 🤔

자, 먼저 카페24가 뭔지부터 알아보자. 카페24는 온라인 쇼핑몰을 만들고 운영할 수 있게 해주는 플랫폼이야. 쉽게 말해서, 너가 온라인에서 물건을 팔고 싶은데 어떻게 시작해야 할지 모르겠다면, 카페24가 그 해답이 될 수 있어!

카페24의 장점은 뭐냐고? 음... 한마디로 말하면 '올인원(All-in-One) 솔루션'이라고 할 수 있어. 쇼핑몰 디자인부터 상품 관리, 결제 시스템, 고객 관리까지 온라인 쇼핑몰 운영에 필요한 거의 모든 기능을 제공하거든. 게다가 초보자도 쉽게 사용할 수 있도록 직관적인 인터페이스를 제공한다는 것도 큰 장점이지.

왜 모바일 앱과 쇼핑몰 연동이 중요할까? 📱💼

자, 이제 왜 모바일 앱과 쇼핑몰을 연동해야 하는지 알아보자. 요즘 사람들 보면 스마트폰 없이는 못 살 것 같지 않아? 그만큼 모바일이 우리 생활에 깊숙이 들어와 있다는 거야. 쇼핑도 마찬가지야. 많은 사람들이 모바일로 쇼핑을 즐기고 있어. 그래서 모바일 앱과 쇼핑몰을 연동하는 게 정말 중요해진 거지.

구체적으로 어떤 점에서 중요할까? 몇 가지만 살펴보자:

• 📈 매출 증대: 모바일 앱을 통해 더 많은 고객에게 접근할 수 있어. 푸시 알림으로 특별 할인 정보나 신상품 소식을 바로 전달할 수 있으니까 매출 증대에 도움이 되지.
• 🔄 실시간 동기화: 앱과 쇼핑몰이 연동되면 재고나 주문 정보가 실시간으로 동기화돼. 이건 재고 관리나 고객 서비스 측면에서 정말 중요해.
• 👥 고객 경험 개선: 앱을 통해 더 개인화된 서비스를 제공할 수 있어. 예를 들어, 고객의 구매 이력을 바탕으로 맞춤 상품을 추천한다든지 하는 거지.
• 🔒 보안 강화: 앱을 통한 로그인은 웹보다 더 안전할 수 있어. 생체 인증 같은 추가적인 보안 기능을 적용할 수 있거든.

이렇게 보면 모바일 앱과 쇼핑몰 연동이 왜 중요한지 이해가 갈 거야. 이제 어떻게 연동하는지 자세히 알아보자!

카페24와 모바일 앱 연동하기: 단계별 가이드 🛠️

자, 이제 본격적으로 카페24와 모바일 앱을 어떻게 연동하는지 알아보자. 이 과정이 조금 복잡해 보일 수 있지만, 차근차근 따라오면 충분히 할 수 있을 거야. 준비됐니? 그럼 시작해볼까!

1단계: API 키 발급받기 🔑

가장 먼저 해야 할 일은 카페24에서 API 키를 발급받는 거야. API가 뭐냐고? 쉽게 말해서 앱과 쇼핑몰이 서로 대화할 수 있게 해주는 '통역사' 같은 거라고 생각하면 돼.

1. 카페24 관리자 페이지에 로그인해.
2. 상단 메뉴에서 '앱스토어' → 'API 키 관리'로 들어가.
3. 'API 키 생성' 버튼을 클릭해서 새로운 키를 만들어.
4. 필요한 권한을 선택하고 (예: 상품 조회, 주문 관리 등) 키를 생성해.

2단계: 앱 개발 환경 설정하기 💻

API 키를 받았다면 이제 앱을 개발할 환경을 설정해야 해. 여기서는 안드로이드와 iOS 두 가지 경우를 모두 살펴볼 거야.

안드로이드 개발 환경 설정:

1. 안드로이드 스튜디오를 설치해. 공식 사이트에서 다운로드 받을 수 있어.
2. 새 프로젝트를 생성하고, 프로젝트 이름과 패키지 이름을 설정해.
3. build.gradle 파일에 필요한 라이브러리를 추가해. 예를 들면 Retrofit이나 OkHttp 같은 네트워크 라이브러리를 사용하면 좋아.

dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    implementation 'com.squareup.okhttp3:okhttp:4.9.0'
}

iOS 개발 환경 설정:

1. Xcode를 설치해. Mac App Store에서 무료로 다운로드 받을 수 있어.
2. 새 프로젝트를 생성하고, 앱 이름과 번들 ID를 설정해.
3. 필요한 라이브러리를 추가해. CocoaPods나 Swift Package Manager를 사용하면 편리해.

// Podfile 예시
pod 'Alamofire'
pod 'SwiftyJSON'

이렇게 개발 환경을 설정했다면, 이제 본격적으로 앱과 카페24를 연동할 준비가 된 거야!

3단계: API 연동하기 🔗

자, 이제 진짜 중요한 부분이야. API를 통해 앱과 카페24 쇼핑몰을 연동할 거야. 이 과정은 조금 복잡할 수 있지만, 천천히 따라와 봐.

API 엔드포인트 설정:

카페24 API는 여러 엔드포인트를 제공해. 주요 엔드포인트는 다음과 같아:

• 상품 조회: GET /api/v2/products
• 주문 조회: GET /api/v2/orders
• 회원 정보 조회: GET /api/v2/customers

이런 엔드포인트를 사용해서 앱에서 필요한 데이터를 가져올 수 있어.

안드로이드에서 API 호출하기:

안드로이드에서는 Retrofit 라이브러리를 사용해서 API를 호출할 거야. 먼저 인터페이스를 정의해야 해:

interface Cafe24Api {
    @GET("products")
    fun getProducts(@Header("Authorization") token: String): Call<ProductResponse>

    @GET("orders")
    fun getOrders(@Header("Authorization") token: String): Call<OrderResponse>
}

그리고 이 인터페이스를 사용해서 API를 호출할 수 있어:

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.cafe24.com/api/v2/")
    .addConverterFactory(GsonConverterFactory.create())
    .build()

val api = retrofit.create(Cafe24Api::class.java)

api.getProducts("Bearer YOUR_API_KEY").enqueue(object : Callback<ProductResponse> {
    override fun onResponse(call: Call<ProductResponse>, response: Response<ProductResponse>) {
        if (response.isSuccessful) {
            val products = response.body()?.products
            // 여기서 상품 정보를 처리해
        }
    }

    override fun onFailure(call: Call<ProductResponse>, t: Throwable) {
        // 에러 처리
    }
})

iOS에서 API 호출하기:

iOS에서는 Alamofire 라이브러리를 사용해서 API를 호출할 수 있어. 먼저 API 호출 함수를 만들어 보자:

import Alamofire

func getProducts(completion: @escaping ([Product]?, Error?) -> Void) {
    let headers: HTTPHeaders = [
        "Authorization": "Bearer YOUR_API_KEY"
    ]
    
    AF.request("https://api.cafe24.com/api/v2/products", headers: headers).responseDecodable(of: ProductResponse.self) { response in
        switch response.result {
        case .success(let productResponse):
            completion(productResponse.products, nil)
        case .failure(let error):
            completion(nil, error)
        }
    }
}

이렇게 만든 함수를 사용해서 상품 정보를 가져올 수 있어:

getProducts { products, error in
    if let products = products {
        // 여기서 상품 정보를 처리해
    } else if let error = error {
        print("Error: \(error.localizedDescription)")
    }
}

4단계: 데이터 동기화 구현하기 🔄

API 연동이 끝났다면, 이제 앱과 쇼핑몰 사이의 데이터를 동기화해야 해. 이 과정은 실시간으로 이루어져야 하는데, 그래야 앱에서 보는 정보와 실제 쇼핑몰의 정보가 일치하니까.

실시간 데이터 동기화 방법:

1. 주기적인 폴링(Polling): 일정 시간 간격으로 서버에 데이터를 요청하는 방식이야. 간단하지만 서버에 부하를 줄 수 있어.
2. 웹소켓(WebSocket): 실시간 양방향 통신이 가능해. 데이터 변경이 있을 때마다 즉시 앱에 알려줄 수 있어.
3. 푸시 알림(Push Notification): 서버에서 중요한 변경사항이 있을 때 앱에 알림을 보내는 방식이야.

여기서는 주기적인 폴링 방식을 예로 들어볼게.

안드로이드에서 주기적인 데이터 동기화:

import kotlinx.coroutines.*

class DataSyncManager(private val api: Cafe24Api) {
    private val job = Job()
    private val scope = CoroutineScope(Dispatchers.IO + job)

    fun startSync(intervalMillis: Long = 60000) {  // 1분마다 동기화
        scope.launch {
            while(isActive) {
                try {
                    val products = api.getProducts("Bearer YOUR_API_KEY").execute().body()?.products
                    val orders = api.getOrders("Bearer YOUR_API_KEY").execute().body()?.orders
                    
                    // 여기서 가져온 데이터를 로컬 데이터베이스에 저장하거나 UI를 업데이트해
                    
                    delay(intervalMillis)
                } catch (e: Exception) {
                    // 에러 처리
                }
            }
        }
    }

    fun stopSync() {
        job.cancel()
    }
}

iOS에서 주기적인 데이터 동기화:

import Foundation

class DataSyncManager {
    private var timer: Timer?
    
    func startSync(interval: TimeInterval = 60) {  // 1분마다 동기화
        timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
            self?.syncData()
        }
    }
    
    private func syncData() {
        getProducts { products, error in
            if let products = products {
                // 상품 데이터 처리
            }
        }
        
        getOrders { orders, error in
            if let orders = orders {
                // 주문 데이터 처리
            }
        }
    }
    
    func stopSync() {
        timer?.invalidate()
        timer = nil
    }
}

이렇게 구현하면 주기적으로 데이터를 동기화할 수 있어. 하지만 실제 서비스에서는 더 복잡한 로직이 필요할 거야. 예를 들어, 네트워크 상태를 체크하거나, 배터리 소모를 줄이기 위해 백그라운드에서 동작하도록 만들어야 할 수도 있지.

5단계: 사용자 인터페이스(UI) 구현하기 🎨

자, 이제 데이터도 가져오고 동기화도 할 수 있게 됐어. 다음은 이 데이터를 사용자에게 보여줄 차례야. 사용자 인터페이스(UI)는 앱의 얼굴이라고 할 수 있어. 예쁘고 사용하기 쉬운 UI를 만들어야 사용자들이 앱을 즐겁게 사용할 수 있을 거야.

안드로이드 UI 구현:

안드로이드에서는 XML을 사용해 레이아웃을 만들고, Kotlin 코드로 동작을 구현해. 예를 들어, 상품 목록을 보여주는 RecyclerView를 만들어보자:

<!-- activity_product_list.xml -->
<androidx.recyclerview.widget.RecyclerView
    android:id="@+id/productRecyclerView"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

그리고 이 RecyclerView를 사용하는 Activity를 만들어:

class ProductListActivity : AppCompatActivity() {
    private lateinit var productAdapter: ProductAdapter
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_product_list)
        
        val recyclerView: RecyclerView = findViewById(R.id.productRecyclerView)
        productAdapter = ProductAdapter()
        recyclerView.adapter = productAdapter
        recyclerView.layoutManager = LinearLayoutManager(this)
        
        loadProducts()
    }
    
    private fun loadProducts() {
        // API를 통해 상품 정보를 가져와서 adapter에 설정
        api.getProducts("Bearer YOUR_API_KEY").enqueue(object : Callback<ProductResponse> {
            override fun onResponse(call: Call<ProductResponse>, response: Response<ProductResponse>) {
                if (response.isSuccessful) {
                    val products = response.body()?.products
                    productAdapter.submitList(products)
                }
            }

            override fun onFailure(call: Call<ProductResponse>, t: Throwable) {
                // 에러 처리
            }
        })
    }
}

iOS UI 구현:

iOS에서는 Storyboard나 SwiftUI를 사용해 UI를 만들 수 있어. 여기서는 UIKit을 사용한 예시를 들어볼게:

import UIKit

class ProductListViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
    @IBOutlet weak var tableView: UITableView!
    var products: [Product] = []
    
    override func viewDidLoad() {
        super.viewDidLoad()
        tableView.dataSource = self
        tableView.delegate = self
        loadProducts()
    }
    
    func loadProducts() {
        getProducts { [weak self] products, error in
            if let products = products {
                self?.products = products
                DispatchQueue.main.async {
                    self?.tableView.reloadData()
                }
            }
        }
    }
    
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return products.count
    }
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "ProductCell", for: indexPath)
        let product = products[indexPath.row]
        cell.textLabel?.text = product.name
        cell.detailTextLabel?.text = "\(product.price)원"
        return cell
    }
}

이렇게 하면 기본적인 상품 목록을 보여주는 UI가 완성돼. 하지만 실제 앱에서는 이보다 더 복잡하고 다양한 기능이 필요할 거야. 예를 들면 상품 상세 페이지, 장바구니, 결제 기능 등이 있겠지.

6단계: 결제 시스템 연동하기 💳

쇼핑몰 앱에서 가장 중요한 기능 중 하나가 바로 결제 시스템이야. 카페24는 다양한 결제 방식을 지원하고 있어. PG(Payment Gateway)사와 연동해서 신용카드, 계좌이체, 가상계좌 등 다양한 결제 수단을 제공할 수 있지.

결제 프로세스 구현하기:

1. 사용자가 상품을 선택하고 '구매하기' 버튼을 누르면 주문 정보를 서버로 전송해.
2. 서버에서는 주문 정보를 검증하고, 결제 금액을 계산해.
3. 계산된 금액과 주문 정보를 PG사의 결제 모듈로 전달해.
4. PG사의 결제 화면을 앱 내에서 웹뷰로 띄워 사용자가 결제를 진행할 수 있게 해.
5. 결제가 완료되면 그 결과를 서버로 전송하고, 서버에서는 주문 처리를 완료해.

이 과정을 코드로 구현해보자.

안드로이드에서의 결제 구현:

class PaymentActivity : AppCompatActivity() {
    private lateinit var webView: WebView
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_payment)
        
        webView = findViewById(R.id.paymentWebView)
        webView.settings.javaScriptEnabled = true
        webView.webViewClient = PaymentWebViewClient()
        
        // 결제 URL을 서버에서 받아와야 해
        val paymentUrl = "https://payment.example.com/pay?orderId=123"
        webView.loadUrl(paymentUrl)
    }
    
    inner class PaymentWebViewClient : WebViewClient() {
        override fun shouldOverrideUrlLoading(view: WebView?, url: String?): Boolean {
            // 결제 완료 URL인 경우 결제 완료 처리
            if (url?.startsWith("https://yourapp.com/payment_complete") == true) {
                handlePaymentComplete(url)
                return true
            }
            return false
        }
    }
    
    private fun handle  PaymentComplete(url: String) {
        // URL에서 결제 결과 정보를 파싱
        val resultCode = url.getQueryParameter("resultCode")
        val orderId = url.getQueryParameter("orderId")
        
        if (resultCode == "success") {
            // 결제 성공 처리
            completeOrder(orderId)
        } else {
            // 결제 실패 처리
            showPaymentFailureDialog()
        }
    }
    
    private fun completeOrder(orderId: String?) {
        // 서버에 결제 완료 정보 전송
        api.completeOrder(orderId).enqueue(object : Callback<orderresponse> {
            override fun onResponse(call: Call<orderresponse>, response: Response<orderresponse>) {
                if (response.isSuccessful) {
                    showOrderCompleteScreen()
                } else {
                    // 에러 처리
                }
            }

            override fun onFailure(call: Call<orderresponse>, t: Throwable) {
                // 네트워크 에러 처리
            }
        })
    }
    
    private fun showOrderCompleteScreen() {
        // 주문 완료 화면으로 이동
        val intent = Intent(this, OrderCompleteActivity::class.java)
        startActivity(intent)
        finish()
    }
    
    private fun showPaymentFailureDialog() {
        AlertDialog.Builder(this)
            .setTitle("결제 실패")
            .setMessage("결제에 실패했습니다. 다시 시도해주세요.")
            .setPositiveButton("확인") { dialog, _ -> dialog.dismiss() }
            .show()
    }
}
</orderresponse></orderresponse></orderresponse></orderresponse>

iOS에서의 결제 구현:

import UIKit
import WebKit

class PaymentViewController: UIViewController, WKNavigationDelegate {
    var webView: WKWebView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let webConfiguration = WKWebViewConfiguration()
        webView = WKWebView(frame: view.bounds, configuration: webConfiguration)
        webView.navigationDelegate = self
        view.addSubview(webView)
        
        // 결제 URL을 서버에서 받아와야 해
        if let paymentUrl = URL(string: "https://payment.example.com/pay?orderId=123") {
            webView.load(URLRequest(url: paymentUrl))
        }
    }
    
    func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
        if let url = navigationAction.request.url,
           url.absoluteString.starts(with: "https://yourapp.com/payment_complete") {
            handlePaymentComplete(url: url)
            decisionHandler(.cancel)
        } else {
            decisionHandler(.allow)
        }
    }
    
    func handlePaymentComplete(url: URL) {
        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: true),
              let resultCode = components.queryItems?.first(where: { $0.name == "resultCode" })?.value,
              let orderId = components.queryItems?.first(where: { $0.name == "orderId" })?.value else {
            showPaymentFailureAlert()
            return
        }
        
        if resultCode == "success" {
            completeOrder(orderId: orderId)
        } else {
            showPaymentFailureAlert()
        }
    }
    
    func completeOrder(orderId: String) {
        // 서버에 결제 완료 정보 전송
        APIClient.shared.completeOrder(orderId: orderId) { [weak self] result in
            DispatchQueue.main.async {
                switch result {
                case .success:
                    self?.showOrderCompleteScreen()
                case .failure:
                    self?.showPaymentFailureAlert()
                }
            }
        }
    }
    
    func showOrderCompleteScreen() {
        let orderCompleteVC = OrderCompleteViewController()
        navigationController?.pushViewController(orderCompleteVC, animated: true)
    }
    
    func showPaymentFailureAlert() {
        let alert = UIAlertController(title: "결제 실패", message: "결제에 실패했습니다. 다시 시도해주세요.", preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "확인", style: .default))
        present(alert, animated: true)
    }
}

이렇게 결제 시스템을 구현하면 사용자가 앱 내에서 직접 결제를 진행할 수 있어. 하지만 실제 서비스에서는 보안을 더욱 강화해야 해. 예를 들어, HTTPS를 사용하고, 결제 정보를 암호화하는 등의 추가적인 보안 조치가 필요해.

7단계: 테스트 및 디버깅 🐛

모든 기능을 구현했다면 이제 테스트를 해야 해. 테스트는 앱의 품질을 보장하는 중요한 과정이야. 여러 가지 시나리오를 만들어 앱이 제대로 작동하는지 확인해야 해.

테스트 항목:

• 상품 목록이 제대로 로드되는지
• 상품 상세 정보가 정확한지
• 장바구니 기능이 올바르게 작동하는지
• 결제 프로세스가 안전하고 정확한지
• 주문 내역이 제대로 저장되고 표시되는지
• 푸시 알림이 제대로 도착하는지
• 다양한 기기와 OS 버전에서 앱이 정상적으로 작동하는지

테스트 중에 발견된 버그는 즉시 수정하고, 다시 테스트해야 해. 이 과정을 반복하면서 앱의 완성도를 높여가는 거지.

자동화된 테스트 구현하기:

수동 테스트도 중요하지만, 자동화된 테스트를 구현하면 더 효율적으로 테스트를 할 수 있어. 안드로이드에서는 JUnit과 Espresso를, iOS에서는 XCTest를 사용해 자동화된 테스트를 구현할 수 있어.

안드로이드 자동화 테스트 예시:

@RunWith(AndroidJUnit4::class)
class ProductListActivityTest {
    @get:Rule
    val activityRule = ActivityScenarioRule(ProductListActivity::class.java)

    @Test
    fun testProductListLoading() {
        // 상품 목록이 로드되는지 확인
        onView(withId(R.id.productRecyclerView))
            .check(matches(isDisplayed()))
        
        // 첫 번째 상품 아이템이 표시되는지 확인
        onView(withText("상품1"))
            .check(matches(isDisplayed()))
    }
}

iOS 자동화 테스트 예시:

import XCTest
@testable import YourApp

class ProductListViewControllerTests: XCTestCase {
    var sut: ProductListViewController!

    override func setUp() {
        super.setUp()
        sut = ProductListViewController()
        sut.loadViewIfNeeded()
    }

    override func tearDown() {
        sut = nil
        super.tearDown()
    }

    func testProductListLoading() {
        // 상품 목록이 로드되는지 확인
        XCTAssertNotNil(sut.tableView)
        
        // 첫 번째 상품 아이템이 표시되는지 확인
        let cell = sut.tableView.cellForRow(at: IndexPath(row: 0, section: 0))
        XCTAssertEqual(cell?.textLabel?.text, "상품1")
    }
}

이런 자동화된 테스트를 구현하면, 코드를 변경할 때마다 빠르게 테스트를 실행해 문제를 조기에 발견할 수 있어.

마무리: 앱 출시 및 유지보수 🚀

드디어 모든 개발과 테스트가 끝났어! 이제 앱을 출시할 차례야. 하지만 앱 출시가 끝이 아니야. 오히려 진짜 시작이라고 할 수 있지.

앱 출시 과정:

1. 앱 스토어 등록: 안드로이드는 Google Play Console, iOS는 App Store Connect를 통해 앱을 등록해.
2. 심사 대기: 각 스토어의 심사 과정을 거쳐야 해. 이 과정에서 앱의 품질, 콘텐츠, 보안 등을 검토해.
3. 출시: 심사가 통과되면 드디어 앱을 출시할 수 있어!

유지보수 및 업데이트:

앱을 출시한 후에도 계속해서 관리해야 해. 사용자들의 피드백을 수집하고, 버그를 수정하고, 새로운 기능을 추가하는 등의 작업이 필요해. 정기적인 업데이트를 통해 앱을 계속 개선해 나가야 해.

자, 이렇게 해서 카페24로 모바일 앱과 쇼핑몰을 연동하는 전체 과정을 알아봤어. 처음에는 복잡해 보일 수 있지만, 차근차근 따라하다 보면 충분히 할 수 있을 거야. 중요한 건 사용자의 입장에서 생각하고, 계속해서 개선해 나가는 자세야.

앱 개발은 끊임없는 학습과 개선의 과정이야. 새로운 기술이 계속 나오고 있으니, 항상 최신 트렌드를 따라가려고 노력해야 해. 그리고 무엇보다 사용자들의 목소리에 귀 기울이는 게 중요해. 그들의 피드백이 앱을 더 좋게 만드는 원동력이 될 거야.

힘들 때도 있겠지만, 자신이 만든 앱으로 사람들이 편리하게 쇼핑을 즐기는 모습을 상상해봐. 그 기쁨이 모든 노력을 보상해줄 거야. 화이팅!