GET /api/users/123 HTTP/1.1
Host: api.example.com
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
Accept: application/json
User-Agent: MyMobileApp/1.0

HTTP/1.1 200 OK
Content-Type: application/json
Cache-Control: max-age=3600

{
  "id": 123,
  "username": "jaenung_user",
  "email": "user@jaenung.net",
  "name": "김재능",
  "profile_image": "https://cdn.example.com/profiles/123.jpg",
  "created_at": "2023-01-15T09:30:00Z",
  "followers_count": 1250,
  "following_count": 340
}

query {
  user(id: "123") {
    name
    email
    posts {
      title
      createdAt
      comments {
        content
        author {
          name
        }
      }
    }
  }
}

mutation {
  createPost(input: {
    title: "GraphQL 완전정복"
    content: "GraphQL은 정말 강력한 도구입니다!"
    authorId: "123"
  }) {
    id
    title
    createdAt
  }
}

subscription {
  newMessage(chatRoomId: "room-456") {
    id
    content
    sender {
      name
      avatar
    }
    timestamp
  }
}

type User {
  id: ID!
  name: String!
  email: String!
  age: Int
  posts: [Post!]!
  followers: [User!]!
}

type Post {
  id: ID!
  title: String!
  content: String!
  author: User!
  comments: [Comment!]!
  createdAt: DateTime!
  likes: Int!
}

type Comment {
  id: ID!
  content: String!
  author: User!
  post: Post!
  createdAt: DateTime!
}

type Query {
  user(id: ID!): User
  users(limit: Int, offset: Int): [User!]!
  post(id: ID!): Post
  posts(authorId: ID): [Post!]!
}

type Mutation {
  createUser(input: CreateUserInput!): User!
  updateUser(id: ID!, input: UpdateUserInput!): User!
  deleteUser(id: ID!): Boolean!
  createPost(input: CreatePostInput!): Post!
}

import Foundation

struct User: Codable {
    let id: Int
    let name: String
    let email: String
}

class APIService {
    static let shared = APIService()
    private let baseURL = "https://api.example.com"
    
    func fetchUser(id: Int, completion: @escaping (Result<User, Error>) -> Void) {
        guard let url = URL(string: "\(baseURL)/users/\(id)") else {
            completion(.failure(NSError(domain: "Invalid URL", code: -1)))
            return
        }
        
        var request = URLRequest(url: url)
        request.httpMethod = "GET"
        request.setValue("application/json", forHTTPHeaderField: "Accept")
        request.setValue("Bearer YOUR_TOKEN", forHTTPHeaderField: "Authorization")
        
        URLSession.shared.dataTask(with: request) { data, response, error in
            if let error = error {
                completion(.failure(error))
                return
            }
            
            guard let data = data else {
                completion(.failure(NSError(domain: "No data", code: -1)))
                return
            }
            
            do {
                let user = try JSONDecoder().decode(User.self, from: data)
                completion(.success(user))
            } catch {
                completion(.failure(error))
            }
        }.resume()
    }
}

// 사용 예시
APIService.shared.fetchUser(id: 123) { result in
    switch result {
    case .success(let user):
        print("사용자 이름: \(user.name)")
    case .failure(let error):
        print("에러 발생: \(error.localizedDescription)")
    }
}

struct CreateUserRequest: Codable {
    let name: String
    let email: String
    let password: String
}

func createUser(request: CreateUserRequest, completion: @escaping (Result<User, Error>) -> Void) {
    guard let url = URL(string: "\(baseURL)/users") else {
        completion(.failure(NSError(domain: "Invalid URL", code: -1)))
        return
    }
    
    var urlRequest = URLRequest(url: url)
    urlRequest.httpMethod = "POST"
    urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
    
    do {
        urlRequest.httpBody = try JSONEncoder().encode(request)
    } catch {
        completion(.failure(error))
        return
    }
    
    URLSession.shared.dataTask(with: urlRequest) { data, response, error in
        // 응답 처리 (위와 동일)
    }.resume()
}

// build.gradle (Module)
dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    implementation 'com.squareup.okhttp3:logging-interceptor:4.9.0'
}

// API 인터페이스 정의
interface ApiService {
    @GET("users/{id}")
    suspend fun getUser(@Path("id") userId: Int): Response<User>
    
    @GET("users")
    suspend fun getUsers(
        @Query("limit") limit: Int,
        @Query("offset") offset: Int
    ): Response<List<User>>
    
    @POST("users")
    suspend fun createUser(@Body request: CreateUserRequest): Response<User>
    
    @PUT("users/{id}")
    suspend fun updateUser(
        @Path("id") userId: Int,
        @Body request: UpdateUserRequest
    ): Response<User>
    
    @DELETE("users/{id}")
    suspend fun deleteUser(@Path("id") userId: Int): Response<Unit>
}

// Retrofit 인스턴스 생성
object RetrofitClient {
    private const val BASE_URL = "https://api.example.com/"
    
    private val loggingInterceptor = HttpLoggingInterceptor().apply {
        level = HttpLoggingInterceptor.Level.BODY
    }
    
    private val client = OkHttpClient.Builder()
        .addInterceptor(loggingInterceptor)
        .addInterceptor { chain ->
            val request = chain.request().newBuilder()
                .addHeader("Authorization", "Bearer YOUR_TOKEN")
                .build()
            chain.proceed(request)
        }
        .build()
    
    val apiService: ApiService by lazy {
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .client(client)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(ApiService::class.java)
    }
}

class UserViewModel : ViewModel() {
    private val _user = MutableLiveData<User>()
    val user: LiveData<User> = _user
    
    private val _error = MutableLiveData<String>()
    val error: LiveData<String> = _error
    
    fun fetchUser(userId: Int) {
        viewModelScope.launch {
            try {
                val response = RetrofitClient.apiService.getUser(userId)
                if (response.isSuccessful) {
                    _user.value = response.body()
                } else {
                    _error.value = "에러: ${response.code()}"
                }
            } catch (e: Exception) {
                _error.value = "네트워크 에러: ${e.message}"
            }
        }
    }
    
    fun createUser(name: String, email: String, password: String) {
        viewModelScope.launch {
            try {
                val request = CreateUserRequest(name, email, password)
                val response = RetrofitClient.apiService.createUser(request)
                if (response.isSuccessful) {
                    _user.value = response.body()
                } else {
                    _error.value = "생성 실패: ${response.code()}"
                }
            } catch (e: Exception) {
                _error.value = "에러: ${e.message}"
            }
        }
    }
}

// 설치
// npm install axios

import axios from 'axios';

// API 클라이언트 설정
const apiClient = axios.create({
  baseURL: 'https://api.example.com',
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json',
  },
});

// 인터셉터로 토큰 자동 추가
apiClient.interceptors.request.use(
  async (config) => {
    const token = await AsyncStorage.getItem('authToken');
    if (token) {
      config.headers.Authorization = `Bearer ${token}`;
    }
    return config;
  },
  (error) => {
    return Promise.reject(error);
  }
);

// 응답 인터셉터로 에러 처리
apiClient.interceptors.response.use(
  (response) => response,
  (error) => {
    if (error.response?.status === 401) {
      // 토큰 만료 처리
      // 로그인 화면으로 이동
    }
    return Promise.reject(error);
  }
);

// API 함수들
export const userAPI = {
  getUser: async (userId) => {
    try {
      const response = await apiClient.get(`/users/${userId}`);
      return response.data;
    } catch (error) {
      throw error;
    }
  },
  
  createUser: async (userData) => {
    try {
      const response = await apiClient.post('/users', userData);
      return response.data;
    } catch (error) {
      throw error;
    }
  },
  
  updateUser: async (userId, userData) => {
    try {
      const response = await apiClient.put(`/users/${userId}`, userData);
      return response.data;
    } catch (error) {
      throw error;
    }
  },
  
  deleteUser: async (userId) => {
    try {
      await apiClient.delete(`/users/${userId}`);
    } catch (error) {
      throw error;
    }
  },
};

// React 컴포넌트에서 사용
import React, { useState, useEffect } from 'react';
import { View, Text, ActivityIndicator } from 'react-native';

const UserProfile = ({ userId }) => {
  const [user, setUser] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  
  useEffect(() => {
    fetchUser();
  }, [userId]);
  
  const fetchUser = async () => {
    try {
      setLoading(true);
      const userData = await userAPI.getUser(userId);
      setUser(userData);
    } catch (err) {
      setError(err.message);
    } finally {
      setLoading(false);
    }
  };
  
  if (loading) return <ActivityIndicator />;
  if (error) return <Text>에러: {error}</Text>;
  
  return (
    <View>
      <Text>{user.name}</Text>
      <Text>{user.email}</Text>
    </View>
  );
};

// 서버에서 권한 체크
if (user.role !== 'admin' && post.authorId !== user.id) {
  return res.status(403).json({ error: '권한이 없습니다' });
}

Cache-Control: max-age=3600  // 1시간 동안 캐시
ETag: "33a64df551425fcc55e4d42a148795d9f25f89d4"  // 리소스 버전

If-None-Match: "33a64df551425fcc55e4d42a148795d9f25f89d4"
// 서버: 변경 없으면 304 Not Modified 응답

// 요청 헤더
Accept-Encoding: gzip, deflate

// 응답 헤더
Content-Encoding: gzip
Content-Length: 1234  // 압축된 크기

// 모든 필드 (비효율적)
GET /users/123
{
  "id": 123,
  "username": "jaenung_user",
  "email": "user@example.com",
  "bio": "...",
  "avatar": "...",
  "followers_count": 1250,
  "following_count": 340,
  "posts_count": 89,
  "created_at": "...",
  "updated_at": "...",
  // ... 더 많은 필드들
}

// 필요한 필드만 (효율적)
GET /users/123?fields=id,username,avatar
{
  "id": 123,
  "username": "jaenung_user",
  "avatar": "..."
}

POST /batch
{
  "requests": [
    { "method": "GET", "url": "/users/123" },
    { "method": "GET", "url": "/users/123/posts" },
    { "method": "GET", "url": "/users/123/followers" }
  ]
}

// 응답
{
  "responses": [
    { "status": 200, "body": { /* user data */ } },
    { "status": 200, "body": [ /* posts */ ] },
    { "status": 200, "body": [ /* followers */ ] }
  ]
}

{
  "error": {
    "code": "INVALID_EMAIL",
    "message": "이메일 형식이 올바르지 않습니다.",
    "details": {
      "field": "email",
      "value": "invalid-email",
      "constraint": "이메일은 '@'를 포함해야 합니다."
    },
    "timestamp": "2024-01-15T10:30:00Z",
    "request_id": "req_abc123"
  }
}

// 재시도 로직 예시 (JavaScript)
async function fetchWithRetry(url, options = {}, maxRetries = 3) {
  let lastError;
  
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await fetch(url, options);
      
      // 성공하면 바로 반환
      if (response.ok) {
        return response;
      }
      
      // 4xx 에러는 재시도 안 함 (클라이언트 문제)
      if (response.status >= 400 && response.status < 500) {
        throw new Error(`Client error: ${response.status}`);
      }
      
      // 5xx 에러는 재시도
      lastError = new Error(`Server error: ${response.status}`);
      
    } catch (error) {
      lastError = error;
    }
    
    // 마지막 시도가 아니면 대기
    if (i < maxRetries - 1) {
      const delay = Math.pow(2, i) * 1000; // 1초, 2초, 4초...
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
  
  throw lastError;
}

// 사용 예시
try {
  const response = await fetchWithRetry('https://api.example.com/data');
  const data = await response.json();
} catch (error) {
  console.error('모든 재시도 실패:', error);
}

# GET 요청
curl https://api.example.com/users/123

# POST 요청 (JSON)
curl -X POST https://api.example.com/users \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{"name":"김재능","email":"user@jaenung.net"}'

# 응답 헤더 보기
curl -i https://api.example.com/users/123

# 응답을 파일로 저장
curl -o response.json https://api.example.com/users/123

# 타임아웃 설정
curl --max-time 10 https://api.example.com/users/123

// api.test.js
const axios = require('axios');

describe('User API', () => {
  const baseURL = 'https://api.example.com';
  let authToken;
  let userId;
  
  // 테스트 전에 로그인
  beforeAll(async () => {
    const response = await axios.post(`${baseURL}/auth/login`, {
      email: 'test@example.com',
      password: 'password123'
    });
    authToken = response.data.token;
  });
  
  // 사용자 생성 테스트
  test('should create a new user', async () => {
    const response = await axios.post(
      `${baseURL}/users`,
      {
        name: '테스트 사용자',
        email: 'newuser@example.com',
        password: 'password123'
      },
      {
        headers: { Authorization: `Bearer ${authToken}` }
      }
    );
    
    expect(response.status).toBe(201);
    expect(response.data).toHaveProperty('id');
    expect(response.data.name).toBe('테스트 사용자');
    
    userId = response.data.id;
  });
  
  // 사용자 조회 테스트
  test('should get user by id', async () => {
    const response = await axios.get(`${baseURL}/users/${userId}`, {
      headers: { Authorization: `Bearer ${authToken}` }
    });
    
    expect(response.status).toBe(200);
    expect(response.data.id).toBe(userId);
  });
  
  // 사용자 수정 테스트
  test('should update user', async () => {
    const response = await axios.put(
      `${baseURL}/users/${userId}`,
      { name: '수정된 이름' },
      {
        headers: { Authorization: `Bearer ${authToken}` }
      }
    );
    
    expect(response.status).toBe(200);
    expect(response.data.name).toBe('수정된 이름');
  });
  
  // 권한 없는 접근 테스트
  test('should return 401 without token', async () => {
    try {
      await axios.get(`${baseURL}/users/${userId}`);
    } catch (error) {
      expect(error.response.status).toBe(401);
    }
  });
  
  // 사용자 삭제 테스트
  test('should delete user', async () => {
    const response = await axios.delete(`${baseURL}/users/${userId}`, {
      headers: { Authorization: `Bearer ${authToken}` }
    });
    
    expect(response.status).toBe(204);
  });
  
  // 삭제된 사용자 조회 시 404
  test('should return 404 for deleted user', async () => {
    try {
      await axios.get(`${baseURL}/users/${userId}`, {
        headers: { Authorization: `Bearer ${authToken}` }
      });
    } catch (error) {
      expect(error.response.status).toBe(404);
    }
  });
});