UseCase
๊ฐ๋
์ฃผ๋ก ์์ฑ์์ ์คํ ํจ์ 1๊ฐ๋ง ๊ฐ์ง ํด๋์ค์ ๋๋ค.
๋ฐ์ ๋ฐ์ดํฐ์ ๋ํด ๋ถ์์ฉ(side effect)๋ฅผ ๊ฐํ์ง ์๋ ํด๋์ค์ ๋๋ค.
์ ์ ํจ์๋ก ๋ง๋ค ์๋ ์์ง๋ง DI์์ ๊ถํฉ์ด ์ข๊ธฐ ๋๋ฌธ์ ์ผ๋ฐ ํด๋์ค๋ก ๋ถ๋ฅํ์ต๋๋ค.
์ธ์ UseCase๋ฅผ ์ฌ์ฉํ๋์?
ํต์ ์ฒ๋ฆฌ
๊ณตํต ์ฒ๋ฆฌ๋ก ์ฌ๋ฌ ํ๋ฉด์์ ์ฌ์ฉ๋๋ ์ฒ๋ฆฌ
Lifecycle๋ก ์์ฑํ๋ฉด ๋น๋ํ๋์ด ๊ฐ๋ ์ฑ์ด ๋จ์ด์ง๋ ๊ฒฝ์ฐ
ํนํ ํต์ ์ฒ๋ฆฌ๋ ์ฌ๋ฌ ํ๋ฉด์์ ํธ์ถ๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง๊ณ , ์ฒ๋ฆฌ ๋ด์ฉ๋ ๋น๋ํด์ง๊ธฐ ์ฝ๊ธฐ ๋๋ฌธ์ UseCase๋ก ๋ถ๋ฅํด์ ์ฌ์ฉํฉ๋๋ค.
์ด๋ด ๋ UseCase๋ฅผ ์ฌ์ฉํ๋๋ก ํ์ธ์.
์๋ฅผ ๋ค์ด ์บ๋ฆญํฐ ์ ๋ณด ํ๋ ํต์ ์ ์ธ๊ฒ์ ์ ํ ์, ํธ์ฑ ํ๋ฉด, ๊ฐํ ํ๋ฉด ๋ฑ ์ฌ๋ฌ ํ๋ฉด์์ ํธ์ถ๋ฉ๋๋ค. ๊ฐ์ ์ฒ๋ฆฌ๋ฅผ ์ฌ๋ฌ๊ณณ์์ ํ๊ฒ๋๋ฏ๋ก UseCase๋ก ๋ฌถ์ด ํ๋์ ํด๋์ค๋ก ๊ด๋ฆฌํ๋๋ก ํฉ๋๋ค.
Lifecycle ๋์ ์ ๋ถ๋ค UseCase๋ก ์ฒ๋ฆฌํ๋ฉด ์๋๋์?
ํต์ ์ด์ธ์๋ ๋ชจ๋ ์ฒ๋ฆฌ๋ฅผ UseCaseํ ํ ์๋ ์์ง๋ง, ํ ๋ฒ๋ง ์ฌ์ฉํ๋ ์ผํ์ฑ UseCase๊ฐ ๊ณ์ ๋์ด๋๊ฒ ๋ฉ๋๋ค. ์ด๋ ๊ฒ ๋๋ฉด ๊ฐ๋ ์ฑ์ด ๋จ์ด์ง๊ณ ๊ฐ๋ฐ ํจ์จ๋ ๋จ์ด์ง ์ ์์ต๋๋ค.
๋ค๋ฅธ ๊ณตํต์ ์ธ ์ฒ๋ฆฌ์์ 2~3ํ ์ด์ ์ค๋ณต ์ฌ์ฉ๋๋ ๊ฒ์ด ํ์ธ๋๋ฉด ๊ทธ ๋ ๋ง๋ค UseCaseํ ํ์ฌ ์ ๋ฆฌํ๋๋ก ํ๋ ๋ฐฉ์์ ์ถ๊ตฌํฉ๋๋ค.
์์ ์ฝ๋
์๋๋ ํต์ ์ UseCase ์ํ์ ๋๋ค. ํต์ ์ ํ๊ณ ๊ฒฐ๊ณผ๋ ๋ฐ๋ ๊ฒ ๋ฟ๋ง ์๋๋ผ, ํต์ ์ค UI ํ์, ์๋ฌ ์ฒ๋ฆฌ ๋ฑ๋ ํฌํจํด์ ์์ฑํฉ๋๋ค. ์ฌ์ฉ์(Lifecycle ๋ฑ)๋ DoConnect๋ฅผ ํธ์ถํ๋ ๊ฒ๋ง์ผ๋ก ์ค๋ฅ ์ฒ๋ฆฌ๊น์ง ํฌํจํ ํต์ ์ฒ๋ฆฌ๋ฅผ ํ ์ ์์ต๋๋ค.
public class TestUseCase
{
private readonly IHttpClient _httpClient; // ํต์ ์คํ ํด๋์ค
private readonly NetworkErrorUseCase _networkErrorUseCase; // ํต์ ์ค๋ฅ์ ๋ฐ๋ฅธ ํ๋ฉด ์ ํ ๋ฑ์ ์ค๋ฅ ๋์ฑ
private readonly NetworkLoadingController _loadingController; // ํต์ ์ค ํ์
[Inject]
public HomePageUseCase(IHttpClient httpClient, NetworkErrorUseCase networkErrorUseCase, NetworkLoadingController loadingController)
{
_httpClient = httpClient;
_networkErrorUseCase = networkErrorUseCase;
_loadingController = loadingController;
}
// DoConnect๋ฅผ ํธ์ถํ๊ณ ์คํํ๊ธฐ
public async UniTask<TestPageLifecycle.NetworkParameter> DoConnect(CancellationToken cancellationToken) => await DoConnectInternal(cancellationToken, 0);
// DoConnect ๋ด๋ถ ์ฒ๋ฆฌ
// ์ค๋ฅ ๋ฐ์ ์ ์ด์ ๊น์ง์ ์ฌ์๋ ํ์๋ฅผ ๋ฐ์ ์ฌ๊ท ์ฒ๋ฆฌํ๋ค.
private async UniTask<TestPageLifecycle.NetworkParameter> DoConnectInternal(CancellationToken cancellationToken, int retryCount)
{
// ํต์ ์ค... ์ UI๋ฅผ ํ์ํ๊ณ ํต์ ์ ์์ํฉ๋๋ค.
_loadingController.Activate();
var connection = await _httpClient.Call<TestConnectResponse>(new TestConnectRequest(), cancellationToken);
_loadingController.InActivate();
// ์คํจ ์ ์ฒ๋ฆฌ
if (!connection.result.IsSuccess())
{
// ์๋ฅผ ๋ค์ด, ์ ์ง๋ณด์ ์ค์๋ ์ ์ง๋ณด์ ํ์๋ฅผ ํ๊ณ ์ ๋ชฉ์ผ๋ก ๋๋๋ฆฝ๋๋ค.
if (connection.response?.status.IsInMaintenanceMode ?? false)
{
await _networkErrorUseCase.ShowMaintenanceToTitle(connection.response?.status.error);
return null;
}
// ์ค๋ฅ ๋ฐ์ ์ ์ฌ์๋ ์ฌ๋ถ๋ฅผ ์ ํํ๊ฒ ํ๋ค.
// ์ฌ์๋์๋ ์ต๋ ํ์๊ฐ ์ค์ ๋์ด ์์ผ๋ฉฐ, ์ด๋ฅผ ์ด๊ณผํ๋ฉด ๊ฐ์ ๋ก ํ์ดํ์ ๋๋๋ฆด ์ ์๋ค.
var isRetry = await _networkErrorUseCase.ShowErrorWithRetry(retryCount);
if (isRetry)
{
retryCount++;
return await DoConnectInternal(cancellationToken, retryCount);
}
return null;
}
// ํต์ ์ ์ฑ๊ณตํ๋ฉด ์๋ต์ ๋ฐํํฉ๋๋ค.
return new TestPageLifecycle.NetworkParameter()
{
TestConnectResponse = result.response
};
}
}
Last updated