[Dart 언어강좌] 023. Dart에서의 에러 처리, try-catch-finally 구문

들어가며

Dart는 현대적인 객체 지향 프로그래밍 언어로서, 코드의 안전성을 높이기 위한 다양한 기능을 제공합니다.
그중 하나는 에러 처리입니다. 에러를 효율적으로 처리하는 것은 안정적인 애플리케이션 개발에 필수적입니다.
에러 처리를 통해 개발자는 예상치 못한 상황에서도 프로그램이 비정상적으로 종료되는 것을 방지할 수 있습니다.
이번 글에서는 Dart에서 에러를 처리하는 방법, 특히 try-catch-finally 구문에 대해 살펴보겠습니다.

1. Dart의 에러 처리 개념

Dart에서 에러는 런타임 중에 발생할 수 있는 문제입니다.
예를 들어, 파일을 읽으려고 할 때 해당 파일이 존재하지 않을 수 있습니다.
이처럼 프로그램의 흐름을 방해하는 다양한 상황이 있습니다.
Dart는 이를 처리하기 위해 try, catch, finally 구문을 제공합니다.

2. try-catch 구문

try 블록 내의 코드는 정상적으로 실행될 경우 에러가 발생하지 않습니다.
그러나 에러가 발생하면, 해당 블록의 실행이 중단되고 catch 블록으로 넘어갑니다.
catch 블록에서는 발생한 에러를 처리할 수 있습니다.
다음은 간단한 예제입니다.


void main() {
    try {
        int result = 10 ~/ 0;  // 0으로 나누기 시도
        print(result);
    } catch (e) {
        print('에러 발생: $e');
    }
}
        

위의 예제에서 ~/ 연산자는 정수 나누기를 수행합니다.
0으로 나누기를 시도할 때, 프로그램은 에러를 발생시키고, catch 블록이 실행됩니다.
결과적으로 “에러 발생: IntegerDivisionByZeroException”이라는 메시지가 출력됩니다.

3. 특정 에러 처리

catch 블록에서는 특정 타입의 에러를 처리할 수도 있습니다.
이를 통해 보다 구체적인 에러 처리 로직을 구현할 수 있습니다.
다음은 그러한 예제입니다.


void main() {
    try {
        int result = 10 ~/ 0;  // 0으로 나누기 시도
        print(result);
    } on IntegerDivisionByZeroException catch (e) {
        print('0으로 나누지 마세요: $e');
    } catch (e) {
        print('다른 에러 발생: $e');
    }
}
        

위의 코드에서는 먼저 IntegerDivisionByZeroException 타입의 에러를 처리하고,
그 외의 다른 에러는 일반적인 catch 블록으로 처리합니다.
이렇게 특정 에러를 분리하여 처리하는 것이 가능한 점이 Dart의 장점 중 하나입니다.

4. finally 구문

finally 블록에서는 trycatch 블록의 실행 여부와 상관없이 항상 실행되는 코드를 작성할 수 있습니다.
주로 리소스를 정리하는 데 사용됩니다. 아래는 finally 블록의 예제입니다.


void main() {
    try {
        int result = 10 ~/ 0;  // 0으로 나누기 시도
        print(result);
    } catch (e) {
        print('에러 발생: $e');
    } finally {
        print('리소스 정리 작업 실행.');
    }
}
        

여기서 “리소스 정리 작업 실행.” 메시지는 에러 발생 여부에 관계없이 항상 출력됩니다.
이는 파일 핸들링, 데이터베이스 연결 등을 종료하는 데 유용합니다.

5. 여러 개의 catch 블록 사용하기

Dart에서는 여러 개의 catch 블록을 사용하여 다양한 에러 타입을 처리할 수 있습니다.
다음은 이러한 예제를 보여줍니다.


void main() {
    try {
        int result = 10 ~/ 0;  // 0으로 나누기 시도
        print(result);
    } on FormatException catch (e) {
        print('형식 오류: $e');
    } on IntegerDivisionByZeroException catch (e) {
        print('0으로 나누기: $e');
    } catch (e) {
        print('일반적인 에러 발생: $e');
    } finally {
        print('작업 완료');
    }
}
        

여기서는 FormatExceptionIntegerDivisionByZeroException을 각각 특정적으로 처리하고 있습니다.
다른 모든 에러는 마지막의 일반적 catch 블록으로 처리됩니다.

6. 사용자 정의 에러 만들기

Dart에서는 사용자 정의 에러 클래스를 만들어 특정한 조건에 대한 에러를 발생시킬 수 있습니다.
다음 예제를 통해 알아보겠습니다.


class CustomError extends Error {
    final String message;
    CustomError(this.message);
}

void checkValue(int value) {
    if (value < 0) {
        throw CustomError('값은 0보다 커야 합니다.');
    }
}

void main() {
    try {
        checkValue(-10);
    } catch (e) {
        print('사용자 정의 에러 발생: $e');
    }
}
        

위의 예제에서 checkValue 함수는 매개변수로 받은 값이 0보다 작을 경우
CustomError를 발생시킵니다.
catch 블록에서 이 사용자 정의 에러를 처리합니다.

7. 비동기 에러 처리

Dart에서는 비동기 프로그래밍을 지원하며, 여기에 대한 에러 처리 또한 가능합니다.
Futureasync/await를 사용할 때의 에러 처리 방법을 살펴보겠습니다.


Future main() async {
    try {
        await futureWithError();
    } catch (e) {
        print('비동기 에러 발생: $e');
    }
}

Future futureWithError() async {
    throw Exception('비동기 작업 중 에러 발생');
}
        

위의 코드에서는 비동기 함수 futureWithError가 에러를 발생시키고,
이를 main 함수에서 try-catch로 처리합니다.
비동기 작업에서도 에러 처리는 동일한 방식으로 진행됩니다.

결론

Dart에서 에러 처리는 코드의 안정성을 보장하는 데 필수적인 요소입니다.
try-catch-finally 구문을 통해 에러를 효율적으로 처리할 수 있으며,
다양한 상황에 맞춰 사용자 정의 에러, 비동기 에러 처리 방법까지 지원합니다.
이를 통해 개발자는 더욱 견고한 애플리케이션을 개발할 수 있습니다.

이번 글을 통해 Dart에서의 에러 처리 방법에 대해 이해하고 활용할 수 있기를 바랍니다.
에러 처리를 통해 프로그램의 신뢰성을 높이고, 사용자에게 더 나은 경험을 제공하는 개발자가 되시길 바랍니다.

[Dart 언어강좌] 024. Dart에서의 에러 처리, 사용자 정의 예외 만들기

1. Dart에서 에러 처리의 중요성

에러 처리는 어떤 프로그래밍 언어든지 중요한 개념입니다. Dart 언어는 개발자에게 코드의 안정성과 신뢰성을 보장하기 위해 다양한 에러 처리 메커니즘을 제공합니다. 에러 처리란 예상치 못한 상황에서 프로그램이 중단되지 않고, 적절한 조치를 취할 수 있게 하는 프로세스를 의미합니다. Dart에서는 예외(Exception)와 오류(Error)를 구분하여 처리합니다. 이 두 가지는 모두 프로그램 실행 중 발생할 수 있는 문제를 나타내지만, 그 처리 방식이 다릅니다.

2. Dart의 기본적인 에러 처리

Dart에서 에러를 처리하는 가장 기본적인 방법은 try-catch 문을 사용하는 것입니다. try 블록 안에서 코드 실행 중에 발생할 수 있는 예외를 처리하고, catch 블록에서는 실제로 에러를 처리하는 로직을 작성합니다. 다음은 기본적인 예제입니다:

void main() {
                try {
                    var result = 10 ~/ 0; // 0으로 나누기, 예외 발생
                    print(result);
                } catch (e) {
                    print('예외 발생: $e');
                }
            }

위 코드에서 10을 0으로 나누려는 시도는 IntegerDivisionByZeroException을 발생시킵니다. 이를 catch 블록에서 잡아내어 ‘예외 발생’ 메시지를 출력하게 됩니다.

3. Dart의 에러와 예외

Dart에서는 ErrorException을 구분합니다. Error는 보통 치명적인 문제로, 애플리케이션이 이를 회복할 수 없다는 것을 의미합니다. 반면, Exception은 프로그램이 예측 가능한 예외 상황으로, 이에 대한 처리가 가능합니다. 예를 들어, 파일을 열거나 네트워크 요청을 하는 경우가 예외로 처리될 수 있습니다.

에러와 예외를 구분하는 것은 오류를 정교하게 다루고, 애플리케이션의 신뢰성을 높이는 데 매우 중요합니다.

4. 사용자 정의 예외 만들기

때때로 기본 제공되는 예외로는 충분하지 않은 경우가 있습니다. 이럴 때는 사용자 정의 예외를 만들어 사용할 수 있습니다. 사용자 정의 예외는 일반적으로 Exception 클래스를 상속하여 만듭니다. 다음은 사용자 정의 예외 클래스를 만드는 예제입니다:

class MyCustomException implements Exception {
                String cause;
                MyCustomException(this.cause);
            }

            void main() {
                try {
                    throw MyCustomException('사용자 정의 예외 발생');
                } catch (e) {
                    print('예외: ${e.cause}');
                }
            }

위 코드에서 MyCustomException이라는 사용자 정의 예외 클래스를 만들었습니다. main 함수에서 이를 던지면 catch 블록에서 해당 예외의 원인을 출력할 수 있습니다.

5. 예외 발생 시 사용자 정의 정보 추가하기

사용자 정의 예외 클래스에 추가적인 정보를 담기 위해 속성을 추가할 수 있습니다. 예를 들어, 에러 코드나 발생한 메서드의 이름을 추가해주면, 나중에 오류를 추적하는 데 유용합니다.

class MyCustomException implements Exception {
                String cause;
                int errorCode;
                MyCustomException(this.cause, {this.errorCode = 0});
            }

            void main() {
                try {
                    throw MyCustomException('사용자 정의 예외 발생', errorCode: 404);
                } catch (e) {
                    print('예외: ${e.cause}, 에러 코드: ${e.errorCode}');
                }
            }

위의 코드에서는 errorCode 속성을 추가하여 예외에 대한 추가 정보를 제공하고 있습니다. 이처럼 사용자 정의 예외를 통하여 다양한 정보를 포함시킬 수 있습니다.

6. 다중 예외 처리

상황에 따라 여러 종류의 예외가 발생할 수 있습니다. Dart에서는 catch 문을 여러 번 사용하여 다양한 예외를 처리할 수 있습니다. 이는 예외의 유형을 구분하여 보다 세밀하게 제어하는 데 유용합니다.

void main() {
                try {
                    var result = 10 ~/ 0; // 예외 발생
                } catch (e) {
                    if (e is IntegerDivisionByZeroException) {
                        print('0으로 나누는 이 예외를 처리했습니다: $e');
                    } else {
                        print('다른 예외: $e');
                    }
                }
            }

위의 예제에서는 발생한 예외가 IntegerDivisionByZeroException인지 체크하여 각각의 경우에 따른 처리를 다르게 하고 있습니다.

7. 비동기 예외 처리

Dart는 비동기 프로그래밍을 지원하기 위해 Futureasync/await 구문을 제공합니다. 비동기 코드에서 예외가 발생할 경우, try-catch 블록을 사용하여 예외를 처리할 수 있습니다. 다음은 비동기 프로그래밍에서의 예외 처리 예시입니다:

Future fetchData() async {
                throw Exception('비동기 예외 발생');
            }

            void main() async {
                try {
                    await fetchData();
                } catch (e) {
                    print('비동기 예외: $e');
                }
            }

위 코드에서는 fetchData라는 비동기 함수에서 예외를 던지며, 이를 main 함수에서 처리하고 있습니다. 비동기 처리에서는 항상 await 키워드를 사용하여 예외를 잡을 수 있도록 해야 합니다.

8. 마지막 정리

Dart에서의 예외 처리는 코드의 안정성과 신뢰성을 높이는 데 큰 역할을 합니다. 사용자 정의 예외를 활용하면 애플리케이션의 특정 요구사항을 충족하는 보다 세밀한 에러 처리가 가능합니다. 예외를 처리하는 방법과 관련하여 우리의 코드가 예측 가능한 경로를 따라 안전하게 실행될 수 있도록 만들어주는 것이 바로 에러 처리의 핵심입니다. 항상 올바른 예외 처리를 통해 개발의 질을 높이고, 사용자에게 좋은 경험을 제공해야 합니다.

[Dart 언어강좌] 025. Dart 코드의 성능 최적화, 메모리 관리 및 성능 개선 기법

작성자: 조광형 | 날짜: [날짜]

1. 소개

Dart는 Google에서 개발한 프로그래밍 언어로, 특히 모바일, 웹 및 서버 측 개발에 많이 사용됩니다. Dart의 성능을 극대화하기 위해서는 코드 최적화, 메모리 관리 및 전반적인 성능 개선 기법을 이해하는 것이 중요합니다. 이 글에서는 Dart 코드의 성능 최적화와 효율적인 메모리 관리를 위한 다양한 기법을 살펴보겠습니다.

2. 성능 최적화 기법

2.1. 불필요한 객체 생성 최소화

Dart에서는 객체를 생성할 때마다 메모리를 할당하게 됩니다. 따라서 불필요한 객체 생성을 피하는 것은 성능 최적화의 중요한 기법입니다.


void main() {
    List numbers = List.generate(1000000, (index) => index);
    print(squaredSum(numbers));
}

int squaredSum(List numbers) {
    int sum = 0;
    for (var number in numbers) {
        sum += number * number;
    }
    return sum;
}
            

위 코드에서는 List를 사용해 100만 개의 숫자를 생성하고 제곱의 합을 계산합니다. 이 경우, List의 모든 요소를 반복하는 대신, 필요할 때마다 요소를 생성하도록 최적화할 수 있습니다.

2.2. 지연 초기화 (Lazy Initialization)

지연 초기화는 객체나 변수를 사용할 시점까지 초기화를 미룰 수 있는 기법입니다. 이를 통해 메모리 사용을 효율적으로 관리할 수 있습니다.


class LazyValue {
    int? _value;

    int get value {
        if (_value == null) {
            _value = expensiveComputation();
        }
        return _value!;
    }

    int expensiveComputation() {
        // 복잡한 계산 처리
        return 42;
    }
}
            

여기서 value 접근자는 _value가 null일 때만 costly한 메소드를 호출하여 값을 초기화합니다. 이렇게 하면 불필요한 메모리 사용을 줄일 수 있습니다.

2.3. 컬렉션 사용의 최적화

Dart는 다양한 종류의 컬렉션을 제공합니다. 알맞은 컬렉션을 선택하는 것은 성능에 직접적인 영향을 미칩니다.


void main() {
    List items = [];
    for (var i = 0; i < 100000; i++) {
        items.add('Item $i');
    }
    print(items.length);
}
            

List, Set, Map 등 각각의 컬렉션 타입을 적절히 사용하여 성능을 최적화할 수 있습니다. 예를 들어, 중복을 허용하지 않는 경우 Set을 사용하면 성능을 향상시킬 수 있습니다.

3. 메모리 관리 기법

3.1. 가비지 컬렉션 이해하기

Dart는 자동으로 메모리를 관리하는 가비지 컬렉션을 제공하므로, 개발자는 메모리에 대한 많은 걱정 없이 코딩할 수 있습니다. 그러나 가비지 컬렉션이 언제 발생하는지 이해하는 것은 성능 개선에 필수적입니다.

3.2. 메모리 프로파일링

Dart DevTools를 사용하여 메모리 프로파일링을 수행할 수 있습니다. 어떤 객체가 얼마나 메모리를 사용하는지 모니터링하면 메모리 리소스를 최적화하는 데 유용합니다.

DevTools에서 메모리 탭을 열고, 할당된 객체와 메모리 사용량을 분석하여 효율적으로 메모리를 관리할 수 있게 됩니다.

4. 성능 개선 기법

4.1. JIT(Just-In-Time) 및 AOT(Ahead-Of-Time) 컴파일 이해하기

Dart는 JIT 및 AOT 컴파일 방식을 제공합니다. JIT는 프로그램을 실행할 때 실행되며, 개발 단계에서 유용합니다. 반면 AOT는 정적인 실행 파일을 생성하여 성능을 극대화합니다.

4.2. async와 await의 적절한 사용

Dart는 비동기 프로그래밍을 위한 강력한 기능을 제공합니다. async와 await 키워드를 적절히 사용하여 비동기 작업의 성능을 최적화할 수 있습니다.


Future fetchData() async {
    var response = await http.get(Uri.parse('https://api.example.com/data'));
    if (response.statusCode == 200) {
        print('데이터 로드 완료');
    }
}
            

비동기 처리를 통해 UI가 응답성을 잃지 않도록 하여 사용자 경험을 향상할 수 있습니다.

5. 결론

Dart 언어의 성능 최적화는 여러 가지 기법을 통해 달성할 수 있습니다.해당 기법들—불필요한 객체 생성 최소화, 지연 초기화, 그리고 효과적인 메모리 관리—은 더욱 효율적인 Dart 애플리케이션을 만드는 데 기여할 것입니다.

이 글이 Dart 개발자들에게 도움이 되기를 바라며, 성능 최적화 과정에서 유용한 기법들을 통하여 더 나은 코드 품질을 유지할 수 있기를 바랍니다.

[Dart 언어강좌] 021. Dart로 API 통신하기, REST API 연동 예제

Dart는 현대 웹과 모바일 애플리케이션 개발을 위한 강력한 언어로, Google이 개발했습니다. 이 블로그 글에서는 Dart를 사용하여 REST API와 통신하는 방법을 깊이 있게 살펴보겠습니다. API(Application Programming Interface)는 다양한 소프트웨어 애플리케이션 간의 상호작용을 가능하게 하며, REST(Representational State Transfer)는 API 설계를 위한 아키텍처 스타일입니다.

1. REST API란 무엇인가?

REST는 웹 서비스를 설계할 때 활용되는 아키텍처 스타일로, 다음과 같은 원칙을 따릅니다:

  • 클라이언트-서버 구조: 클라이언트(프론트엔드)와 서버(백엔드)가 서로 독립적으로 개발 및 배포될 수 있습니다.
  • 무상태성: 각 요청은 독립적이어야 하며, 서버는 클라이언트의 상태를 저장하지 않습니다.
  • 캐시 처리: 클라이언트 요청의 응답은 캐시 가능해야 할 수 있습니다.
  • 계층화 시스템: 클라이언트는 서버 응답을 통해 서비스 레이어를 설정할 수 있습니다.

2. Dart에서 HTTP 패키지 사용하기

Dart에서는 HTTP 통신을 위해 http 패키지를 사용합니다. 이 패키지를 통해 GET, POST, PUT, DELETE와 같은 다양한 HTTP 메소드를 쉽게 사용할 수 있습니다. 이 패키지를 사용하기 위해서는 먼저 프로젝트에 추가해야 합니다:

dependencies:
  http: ^0.13.3

이와 같이 pubspec.yaml 파일에 추가한 후, 프로젝트의 패키지를 업데이트합니다:

flutter pub get

3. GET 요청 예제

이제 REST API에 GET 요청을 보내어 데이터를 받아오는 간단한 예제를 살펴보겠습니다. 우선 JSONPlaceholder라는 가상의 REST API를 사용할 것입니다. 이 API는 테스트 및 프로토타이핑을 위해 제공되는 무료 API입니다.

import 'dart:convert';
import 'package:http/http.dart' as http;

Future fetchPosts() async {
  final response = await http.get(Uri.parse('https://jsonplaceholder.typicode.com/posts'));

  if (response.statusCode == 200) {
    List posts = jsonDecode(response.body);
    for (var post in posts) {
      print('Post ID: ${post['id']}, Title: ${post['title']}');
    }
  } else {
    throw Exception('Failed to load posts');
  }
}

void main() {
  fetchPosts();
}

위의 코드에서는 http.get 메소드를 사용하여 POST 리소스의 목록을 요청합니다. 요청이 성공하면 응답의 상태 코드가 200이 되며, 응답 본문을 jsonDecode 함수를 사용하여 JSON 형식으로 파싱합니다.

4. POST 요청 예제

다음으로 POST 요청을 사용하여 데이터를 서버에 전송하는 방법을 살펴보겠습니다. 이번에는 새 게시물을 추가하는 예제를 보겠습니다.

Future createPost(String title, String body) async {
  final response = await http.post(
    Uri.parse('https://jsonplaceholder.typicode.com/posts'),
    headers: {
      'Content-Type': 'application/json; charset=UTF-8',
    },
    body: jsonEncode({
      'title': title,
      'body': body,
      'userId': '1',
    }),
  );

  if (response.statusCode == 201) {
    print('Post created: ${response.body}');
  } else {
    throw Exception('Failed to create post');
  }
}

void main() {
  createPost('Dart Tutorial', 'This post explains how to use Dart for API communication.');
}

위의 예제에서는 http.post 메소드를 사용하여 JSON 형식으로 새 게시물 데이터를 전송합니다. JSONPlaceholder API는 POST 요청에 대해 새 게시물을 생성한 후 응답을 반환합니다.

5. PUT 요청 예제

PUT 요청을 사용하여 기존 데이터를 수정할 수도 있습니다. 아래의 예제에서는 특정 게시물을 수정하는 방법을 설명합니다.

Future updatePost(int postId, String title, String body) async {
  final response = await http.put(
    Uri.parse('https://jsonplaceholder.typicode.com/posts/$postId'),
    headers: {
      'Content-Type': 'application/json; charset=UTF-8',
    },
    body: jsonEncode({
      'title': title,
      'body': body,
      'userId': '1',
    }),
  );

  if (response.statusCode == 200) {
    print('Post updated: ${response.body}');
  } else {
    throw Exception('Failed to update post');
  }
}

void main() {
  updatePost(1, 'Updated Title', 'This body has been updated.');
}

위의 코드에서는 http.put 메소드를 사용하여 특정 ID를 가진 게시물을 수정합니다. URI에 게시물 ID를 포함하여 요청을 보냈습니다.

6. DELETE 요청 예제

마지막으로, DELETE 요청을 통해 서버에서 데이터를 삭제하는 방법을 보여드리겠습니다.

Future deletePost(int postId) async {
  final response = await http.delete(
    Uri.parse('https://jsonplaceholder.typicode.com/posts/$postId'),
  );

  if (response.statusCode == 200) {
    print('Post deleted successfully');
  } else {
    throw Exception('Failed to delete post');
  }
}

void main() {
  deletePost(1);
}

여기서는 http.delete 메소드를 사용하여 특정 게시물을 삭제하는 과정을 보여줍니다. 삭제 요청을 보내면 서버는 해당 게시물을 삭제하고 응답합니다.

7. 에러 처리

API 통신을 할 때는 반드시 에러 처리를 고려해야 합니다. 네트워크 오류나 서버 오류 등의 상황을 미리 예외 처리하여 사용자에게 유용한 피드백을 줄 수 있습니다. Dart의 try-catch 문을 사용하여 에러 처리를 구현해보겠습니다.

Future fetchPostsSafe() async {
  try {
    await fetchPosts();
  } catch (e) {
    print('An error occurred: $e');
  }
}

위 코드에서는 fetchPosts 함수에서 발생하는 모든 예외를 포착하고, 적절한 에러 메시지를 출력합니다. 이를 통해 사용자에게 안정적인 경험을 제공할 수 있습니다.

8. 결론

Dart를 사용하여 REST API와 통신하는 방법을 살펴보았습니다. GET, POST, PUT, DELETE 요청을 통해 간단한 CRUD(Create, Read, Update, Delete) 작업을 수행하는 방법을 배웠습니다. API와의 통신은 현대 애플리케이션에서 매우 중요한 요소이며, Dart의 http 패키지를 통해 간편하게 구현할 수 있습니다.

이 글을 통해 Dart로 API 통신을 구현하는 방법에 대한 기본적인 이해가 도움이 되었기를 바랍니다. 추가적인 학습을 통해 더 많은 기능들을 탐색하고, 여러분의 프로젝트에서 유용하게 활용해보세요!

[Dart 언어강좌] 022. Dart로 API 통신하기, JSON 데이터 처리 방법

022. Dart로 API 통신하기: JSON 데이터 처리 방법

Dart는 Google에서 개발한 현대적인 프로그래밍 언어로, 주로 Flutter 앱 개발에 쓰입니다. 하지만 Dart는 서버 사이드 개발에도 사용될 수 있으며, REST API와의 통신 또한 간단하게 처리할 수 있습니다. 이 글에서는 Dart를 사용하여 API와 통신하고 JSON 데이터를 처리하는 방법에 대해 자세히 설명하겠습니다.

1. Dart 환경 설정

Dart를 시작하기 위해서는 우선 Dart SDK를 설치해야 합니다. Dart SDK를 설치한 후, 기본 Dart 프로젝트를 생성합니다. Terminal 또는 Command Prompt를 열고 아래 명령어를 실행하세요.

dart create my_api_app

프로젝트를 생성한 후, my_api_app 디렉토리로 이동하여 pubspec.yaml 파일을 엽니다. API 통신과 JSON 처리를 위해 http 패키지를 추가해야 합니다.

dependencies:   http: ^0.14.0

패키지를 추가한 후, 프로젝트 루트 디렉토리에서 다음 명령어를 실행하여 종속성을 설치합니다.

dart pub get

2. HTTP 패키지를 사용한 API 통신

이제 우리는 http 패키지를 사용하여 API와 통신할 준비가 되었습니다. http 패키지를 사용하기 위해 먼저 패키지를 import 해야 합니다.

import 'package:http/http.dart' as http;

예를 들어, JSONPlaceholder라는 무료 API를 사용하여 사용자 정보를 가져오는 예제를 만들어보겠습니다. 해당 API는 가상의 사용자 데이터를 제공합니다. 아래와 같이 GET 요청을 수행하여 데이터를 가져올 수 있습니다.

Future fetchUsers() async { final response = await http.get(Uri.parse('https://jsonplaceholder.typicode.com/users')); if (response.statusCode == 200) { print('Users fetched successfully: ${response.body}'); } else { throw Exception('Failed to load users'); } }

3. JSON 데이터 처리

API에서 가져온 데이터는 JSON 형식입니다. Dart에서는 JSON 데이터를 쉽게 처리할 수 있도록 dart:convert 라이브러리를 제공합니다. JSON 데이터를 Dart 객체로 변환하기 위해 다음과 같이 jsonDecode 함수를 사용할 수 있습니다.

import 'dart:convert';

...

if (response.statusCode == 200) {
var users = jsonDecode(response.body);
print('Users: $users');
}

위 코드는 JSON 응답을 Dart의 Map 형태로 변환합니다. 이제 우리는 이 데이터를 Dart 객체로 매핑하여 사용해보겠습니다. 사용자 정보를 저장할 모델 클래스를 정의해보겠습니다.

class User {     final int id;     final String name;     final String email;

User({required this.id, required this.name, required this.email});

factory User.fromJson(Map json) {
return User(
id: json[‘id’],
name: json[‘name’],
email: json[’email’],
);
}
}

이제 JSON 데이터를 User 객체 목록으로 변환할 수 있는 함수를 작성해보겠습니다.

List parseUsers(String responseBody) { final parsed = jsonDecode(responseBody).cast>(); return parsed.map((json) => User.fromJson(json)).toList(); }

이제 우리가 가져온 사용자 데이터를 fetchUsers 함수에서 사용할 수 있습니다.

Future fetchUsers() async { final response = await http.get(Uri.parse('https://jsonplaceholder.typicode.com/users')); if (response.statusCode == 200) { List users = parseUsers(response.body); users.forEach((user) { print('${user.name} - ${user.email}'); }); } else { throw Exception('Failed to load users'); } }

4. API 데이터 저장 및 업데이트

이제 API에서 데이터를 가져오는 방법을 배웠으니, 데이터를 업데이트하거나 추가하는 방법도 알아보겠습니다. PATCH 요청이나 POST 요청을 사용하여 서버에 데이터를 전송할 수 있습니다. 예를 들어, 사용자를 추가하려면 다음과 같이 POST 요청을 작성할 수 있습니다.

Future createUser(User user) async { final response = await http.post( Uri.parse('https://jsonplaceholder.typicode.com/users'), headers: { 'Content-Type': 'application/json; charset=UTF-8', }, body: jsonEncode({ 'name': user.name, 'email': user.email, }), ); if (response.statusCode == 201) { print('User created successfully: ${response.body}'); } else { throw Exception('Failed to create user'); } }

이와 같은 방식으로 API에 데이터를 POST하여 사용자 정보를 추가할 수 있습니다. 한편, 기존 사용자 정보를 수정하는 방법은 PATCH 요청을 사용하여 다음과 같이 처리할 수 있습니다.

Future updateUser(int id, User user) async { final response = await http.patch( Uri.parse('https://jsonplaceholder.typicode.com/users/$id'), headers: { 'Content-Type': 'application/json; charset=UTF-8', }, body: jsonEncode({ 'name': user.name, 'email': user.email, }), ); if (response.statusCode == 200) { print('User updated successfully: ${response.body}'); } else { throw Exception('Failed to update user'); } }

5. 오류 처리

API와의 통신에서 오류가 발생할 수 있기 때문에 오류 처리는 매우 중요합니다. 위의 코드 예제에서 throw Exception을 통해 발생한 오류를 던지게 되지만, 사용자가 보기 쉽게 처리하려면 적절한 오류 메시지 및 오류 유형을 정의하는 것이 필요합니다.

try {     await fetchUsers(); } catch (e) {     print('An error occurred: ${e.toString()}'); }

6. 테스트 및 검증

마지막으로, API 통신 기능을 테스트하는 것은 개발 과정에서 중요한 부분입니다. Dart의 test 패키지를 활용하여 작성한 함수들을 단위 테스트할 수 있습니다. 예를 들어, fetchUsers 함수를 테스트하는 샘플 코드는 다음과 같습니다.

import 'package:test/test.dart';

void main() {
test('fetchUsers returns a list of Users', () async {
final users = await fetchUsers();
expect(users, isA >());
});
}

테스트를 작성하고 실행하여 API 통신 로직이 예상대로 작동하는지 확인합니다.

결론

Dart를 사용하여 REST API와 통신하고 JSON 데이터를 처리하는 과정은 생각보다 간단합니다. HTTP 요청을 수행하고 받은 JSON 데이터를 Dart 객체로 변환하는 모든 과정은 httpdart:convert 라이브러리를 통해 쉽게 다룰 수 있습니다. 또한, 오류 처리 및 테스트를 통해 코드를 더욱 견고하게 만들 수 있습니다.

Dart 언어 자체의 장점과 Flutter 프레임워크의 힘을 빌려, 더 많은 애플리케이션에서 효율적으로 API를 활용할 수 있게 되길 바랍니다.