[Java] Retrofit2에서 Annotation을 사용하는 방법 살피기

출처

• https://github.com/square/retrofit

GitHub - square/retrofit: A type-safe HTTP client for Android and the JVM

• ChatGPT

목표

커스텀 Annotation 활용법을 Retrofit을 통해서 배운다. 어떻게 기능을 구현하는지 살핀다.

상세한 Annotation 사용 및 구현 사항까지는... 🙈 부담스러워요.

---

Retrofit에서 Annotation을 처리하는 방식의 장점

코드의 가독성 향상

Annotation을 통해 복잡한 HTTP 요청 로직을 인터페이스 수전에서 간단하게 정의할 수 있다.

유연성

Retrofit은 다양한 HTTP 요청 방식과 파라미터 전송 방식을 Annotation을 통해 유연하게 지원한다.

캡슐화

Annotation을 사용해 HTTP 요청을 세부 사항을 캡슐화함으로써 클라이언트 코드가 단순해지고 유지보수가 쉬워진다.

 

Retrofit에서 사용하는 Annotation 선언 코드들

https://github.com/square/retrofit/tree/trunk/retrofit/src/main/java/retrofit2/http

retrofit/retrofit/src/main/java/retrofit2/http at trunk · square/retrofit

 

Retrofit에서 Annotation 처리 흐름 따라가기

ChatGPT에게 부탁해서 Retrofit을 사용하는 예제 코드를 얻었다.

0. Retrofit 예제 코드 : GitHub API 호출 (Kotlin)

import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.Call
import retrofit2.http.GET
import retrofit2.http.Path

// 1. API 인터페이스 정의
interface GitHubService {
    @GET("users/{user}/repos")
    fun listRepos(@Path("user") user: String): Call<List<Repo>>
}

// 2. 데이터 모델 클래스 정의
data class Repo(
    val id: Int,
    val name: String,
    val full_name: String
)

// 3. Retrofit 객체 생성 및 사용
fun main() {
    // Retrofit 객체 생성
    val retrofit = Retrofit.Builder()
        .baseUrl("https://api.github.com/")  // GitHub API의 기본 URL
        .addConverterFactory(GsonConverterFactory.create())  // JSON 응답을 객체로 변환
        .build()

    // GitHubService 인터페이스의 구현체 생성
    val service = retrofit.create(GitHubService::class.java)

    // API 호출
    val repos = service.listRepos("octocat")  // "octocat" 사용자의 저장소 목록을 요청
    repos.enqueue(object : retrofit2.Callback<List<Repo>> {
        override fun onResponse(call: Call<List<Repo>>, response: retrofit2.Response<List<Repo>>) {
            if (response.isSuccessful) {
                // 성공 시 저장소 목록 출력
                response.body()?.forEach { repo ->
                    println("Repository: ${repo.name}, Full name: ${repo.full_name}")
                }
            }
        }

        override fun onFailure(call: Call<List<Repo>>, t: Throwable) {
            println("Error: ${t.message}")
        }
    })
}

 예제 설명

1. API 인터페이스 정의

• GitHubService 인터페이스는 @GET Annotation을 사용해 GitHub API의 사용자 저장소 목록을 요청하는 메소드르 정의한다.
• @Path("user")는 동적으로 URL 경로에 사용자 이름을 삽입한다.

2. 데이터 모델 클래스

• GitHub API의 응답 데이터를 객체로 매핑하기 위해 Repo 데이터 클래스를 정의한다. 이 클래스는 JSON 응답 필드와 매핑된다.

3. Retrofit 객체 생성

• Retrofit.Builder()를 사용해 Retrofit 인스턴스를 생성하고, baseUrl() 메소드로 GitHub API의 기본 URL을 설정한다.
• GsonConverterFactory를 추가해 JSON 응답을 자동으로 Kotlin 객체로 변환할 수 있다록 설정한다.

4. Retrofit의 create()

• retrofit.create(GitHubService::class.java)를 호출해 GitHubService 인터페이스의 구현체를 생성한다. 이 구현체는 런타임에 동적으로 생성된 프록시 객체로, listRepos() 호출 시 HTTP 요청을 보낸다.

• 관련 글 -> [용어] 프록시 객체

5. API 호출

• service.listRepos("actocat")을 호출해 GitHub의 "octocat" 사용자의 저장소 목록을 가져온다.
• enqueue() 메소드를 사용해 비동기 호출을 실행하고, 응답이 성공적으로 도착하면 저장소 목록을 출력한다.

 

1. Retrofit.create()

예제 코드 부분

val service = retrofit.create(GitHubService::class.java)

 

소스 코드 부분

  @SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety.
  public <T> T create(final Class<T> service) {
    validateServiceInterface(service);
    return (T)
        Proxy.newProxyInstance(
            service.getClassLoader(),
            new Class<?>[] {service},
            new InvocationHandler() {
              private final Object[] emptyArgs = new Object[0];

              @Override
              public @Nullable Object invoke(Object proxy, Method method, @Nullable Object[] args)
                  throws Throwable {
                // If the method is a method from Object then defer to normal invocation.
                if (method.getDeclaringClass() == Object.class) {
                  return method.invoke(this, args);
                }
                args = args != null ? args : emptyArgs;
                Reflection reflection = Platform.reflection;
                return reflection.isDefaultMethod(method)
                    ? reflection.invokeDefaultMethod(method, service, proxy, args)
                    : loadServiceMethod(service, method).invoke(proxy, args);
              }
            });
  }

 

주요 흐름 분석

1. validateServiceInterface(service)

• API 인터페이스가 적절하게 정의되었는지 검증하는 메소드

2. Proxy.newProxyInstance()

• 프록시 패턴을 이용해 service 인터페이스의 동적 구현체를 생성하고, 호출되는 메서드를 InvocationHandler가 가로채 처리한다.

3. loadServiceMethod(service, method)

API 인터페이스의 메소드에 정의된 Retrofit Annotation을 기반으로 ServiceMethod를 생성한다. 이 ServiceMethod는 HTTP 요청의 세부 사항을 포함하고 있으며, 해당 메소드가 실제로 어떻게 요청될지를 정의한다. 

 

동작 예시

interface GitHubService {
    @GET("users/{user}/repos")
    fun listRepos(@Path("user") user: String): Call<List<Repo>>
}

 

1. create(GitHubService.class) 호출

• create() 메소드가 호출되면 GitHubService 인터페이스에 대한 프록시 객체가 생성된다.

2. 메소드 호출

• servide.listRepos("octocat")을 호출하면, 실제로는 프록시 객체가 이 메소드 호출을 가로채게 된다.

3. InvocataionHandler.invoke() 실행

• 프록시 객체는 listRepos() 메소드 호출을 invoke() 메소드로 전달한다. 이때, method는 listRepos() 메소드 객체가 되고, args는 {"octocat"}이 된다.

4. ServiceMethod 생성 및 실행

• loadServiceMethod()에서 Annotation(@GET, @Path)을 분석해 HTTP 요청의 세부 사항을 설정한 ServiceMethod를 생성한다.
• 생성된 ServiceMethod는 invoke()를 통해 실제로 HTTP 요청을 서버로 보내고, 서버의 응답을 받아 처리한다.

 

2. Retrofit.loadService(Class<?> service, Method method)

소스 코드 부분

  ServiceMethod<?> loadServiceMethod(Class<?> service, Method method) {
    while (true) {
      // Note: Once we are minSdk 24 this whole method can be replaced by computeIfAbsent.
      Object lookup = serviceMethodCache.get(method);

      if (lookup instanceof ServiceMethod<?>) {
        // Happy path: method is already parsed into the model.
        return (ServiceMethod<?>) lookup;
      }

      if (lookup == null) {
        // Map does not contain any value. Try to put in a lock for this method. We MUST synchronize
        // on the lock before it is visible to others via the map to signal we are doing the work.
        Object lock = new Object();
        synchronized (lock) {
          lookup = serviceMethodCache.putIfAbsent(method, lock);
          if (lookup == null) {
            // On successful lock insertion, perform the work and update the map before releasing.
            // Other threads may be waiting on lock now and will expect the parsed model.
            ServiceMethod<Object> result;
            try {
              result = ServiceMethod.parseAnnotations(this, service, method);
            } catch (Throwable e) {
              // Remove the lock on failure. Any other locked threads will retry as a result.
              serviceMethodCache.remove(method);
              throw e;
            }
            serviceMethodCache.put(method, result);
            return result;
          }
        }
      }

      // Either the initial lookup or the attempt to put our lock in the map has returned someone
      // else's lock. This means they are doing the parsing, and will update the map before
      // releasing
      // the lock. Once we can take the lock, the map is guaranteed to contain the model or null.
      // Note: There's a chance that our effort to put a lock into the map has actually returned a
      // finished model instead of a lock. In that case this code will perform a pointless lock and
      // redundant lookup in the map of the same instance. This is rare, and ultimately harmless.
      synchronized (lookup) {
        Object result = serviceMethodCache.get(method);
        if (result == null) {
          // The other thread failed its parsing. We will retry (and probably also fail).
          continue;
        }
        return (ServiceMethod<?>) result;
      }
    }
  }

 

주요 흐름 분석

1. serviceMethodCache

• serviceMethodCache에서 캐시된 ServiceMethod 객체를 찾는다. 객체가 있을 경우 바로 반환한다.

2. ServiceMethod.parseAnnotations()

• 캐시가 비어 있으면 ServiceMethod.parseAnnotations()를 호출해 Annotation을 분석하고 이를 기반으로  새로운 ServiceMethod 객체를 생성한다.
• 이 과정에서 @GET, @POST, @Query 등의 Annotation을 읽어 HTTP 요청 정보를 정의한 ServiceMethod 객체를 생성한 후 캐시에 저장한다. 

동작 예시

1. API 메소드 호출

@GET("users/{user}/repos")
fun listRepos(@Path("user") user: String): Call<List<Repo>>

 

2. 첫 번째 호출

• loadServiceMethod()가 호출되면 serviceMethodCache에서 listRepos() 메소드의 캐시된 ServiceMethod 객체를 찾는다
• 캐시가 비어있으므로, serviceMethod.parseAnnotations()를 호출해 Annotation을 분석하고, HTTP 요청 정보를 정의한 ServiceMethod 객체를 캐시에 저장한다.

3. 두 번째 호출

• listRepos() 메소드가 다시 호출되면, loadServiceMethod()는 이번에는 캐시에서 바로 ServiceMethod 객체를 반환한다. 따라서 Annotation을 다시 분석할 필요가 없다.

 

3. ServiceMethod.parseAnnotations()

소스 코드 부분

  static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Class<?> service, Method method) {
    RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, service, method);

    Type returnType = method.getGenericReturnType();
    if (Utils.hasUnresolvableType(returnType)) {
      throw methodError(
          method,
          "Method return type must not include a type variable or wildcard: %s",
          returnType);
    }
    if (returnType == void.class) {
      throw methodError(method, "Service methods cannot return void.");
    }

    return HttpServiceMethod.parseAnnotations(retrofit, method, requestFactory);
  }

 

parseAnnotations() 흐름

1. Annotation 파싱

• API 인터페이스에 선언된 메소드와 해당 Annotation을 분석하고, 이를 통해 HTTP 요청의 구성을 정의한다. 이때 RequestFactory가 Annotation을 파싱해 요청의 메소드 타입(GET, POST), 경로, 쿼리 파라미터 등을 정리한다. -> 4번 내용

2. 리턴 타입 검증

• API 메소드가 올바른 리턴 타입을 갖고 있는지 확인한다. 예를 들어, 리턴 타입에 타입 변수나 와일드 카드가 포함된 경우, 그 타입을 해석할 수 없으므로 예외를 발생시킨다. 또한 void 리턴 타입은 허용되지 않는다.

3. HTTP 요청 처리

• HttpServiceMethod는 구체적인 HTTP 요청 처리 방식을 정의하며, ServiceMethod 클래스는 그 기반을 제공한다. -> 10번 내용

 

4. RequestFactory.parseAnnotations(retrofit, service, method)

소스 코드 부분

static RequestFactory parseAnnotations(Retrofit retrofit, Class<?> service, Method method) {
    return new Builder(retrofit, service, method).build();
}

 

분석

• new Builder(retrofit, service, method) : 여기서 Builder 객체가 생성되며, API 메소드에 포함된 Annotation 정보를 기반으로 RequestFactory 객체를 생성하기 위한 초기 설정이 진행된다.
• build() : 최종적으로 RequestFactory 객체를 반환하는 부분이다. 이때 API 메소드에 대한 모든 정보가 설정된 ReqeustFactory가 만들어진다.

 

5. RequestFactory.Builder(retrofit, service, method), RequestFactory.Builder.build()

소스 코드 부분

    Builder(Retrofit retrofit, Class<?> service, Method method) {
      this.retrofit = retrofit;
      this.service = service;
      this.method = method;
      this.methodAnnotations = method.getAnnotations();
      this.parameterTypes = method.getGenericParameterTypes();
      this.parameterAnnotationsArray = method.getParameterAnnotations();
    }
    
    Builder(Retrofit retrofit, Class<?> service, Method method) {
      this.retrofit = retrofit;
      this.service = service;
      this.method = method;
      this.methodAnnotations = method.getAnnotations();
      this.parameterTypes = method.getGenericParameterTypes();
      this.parameterAnnotationsArray = method.getParameterAnnotations();
    }

    RequestFactory build() {
      for (Annotation annotation : methodAnnotations) {
        parseMethodAnnotation(annotation);
      }

      if (httpMethod == null) {
        throw methodError(method, "HTTP method annotation is required (e.g., @GET, @POST, etc.).");
      }

      if (!hasBody) {
        if (isMultipart) {
          throw methodError(
              method,
              "Multipart can only be specified on HTTP methods with request body (e.g., @POST).");
        }
        if (isFormEncoded) {
          throw methodError(
              method,
              "FormUrlEncoded can only be specified on HTTP methods with "
                  + "request body (e.g., @POST).");
        }
      }

      int parameterCount = parameterAnnotationsArray.length;
      parameterHandlers = new ParameterHandler<?>[parameterCount];
      for (int p = 0, lastParameter = parameterCount - 1; p < parameterCount; p++) {
        parameterHandlers[p] =
            parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p], p == lastParameter);
      }

      if (relativeUrl == null && !gotUrl) {
        throw methodError(method, "Missing either @%s URL or @Url parameter.", httpMethod);
      }
      if (!isFormEncoded && !isMultipart && !hasBody && gotBody) {
        throw methodError(method, "Non-body HTTP method cannot contain @Body.");
      }
      if (isFormEncoded && !gotField) {
        throw methodError(method, "Form-encoded method must contain at least one @Field.");
      }
      if (isMultipart && !gotPart) {
        throw methodError(method, "Multipart method must contain at least one @Part.");
      }

      return new RequestFactory(this);
    }

 

build() 분석

• 모든 Annotation을 파싱하고 최종적으로 RequestFactory 객체를 반환한다.
  • parseMethodAnnotation() 메소드 -> 6번 내용
  • parseParameter() 메소드 -> 8번 내용
• 메소드가 제대로 구성되지 않았을 경우, 예를 들어 HTTP 메소드가 누락되거나 URL이 잘못된 경우 오류를 발생시킨다.
• ParameterHandler : 메서드 파라미터에 해당하는 처리를 담당한다. @Query, @Path, @Body와 같은 Annotation이 있는 파라미터를 처리하는 역할을 한다.

 

6. RequestFactory.Builder.parseMethodAnnotation() 

소스 코드 부분

    private void parseMethodAnnotation(Annotation annotation) {
      if (annotation instanceof DELETE) {
        parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
      } else if (annotation instanceof GET) {
        parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
      } else if (annotation instanceof HEAD) {
        parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
      } else if (annotation instanceof PATCH) {
        parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
      } else if (annotation instanceof POST) {
        parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
      } else if (annotation instanceof PUT) {
        parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
      } else if (annotation instanceof OPTIONS) {
        parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
      } else if (annotation instanceof HTTP) {
        HTTP http = (HTTP) annotation;
        parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
      } else if (annotation instanceof retrofit2.http.Headers) {
        retrofit2.http.Headers headers = (retrofit2.http.Headers) annotation;
        String[] headersToParse = headers.value();
        if (headersToParse.length == 0) {
          throw methodError(method, "@Headers annotation is empty.");
        }
        this.headers = parseHeaders(headersToParse, headers.allowUnsafeNonAsciiValues());
      } else if (annotation instanceof Multipart) {
        if (isFormEncoded) {
          throw methodError(method, "Only one encoding annotation is allowed.");
        }
        isMultipart = true;
      } else if (annotation instanceof FormUrlEncoded) {
        if (isMultipart) {
          throw methodError(method, "Only one encoding annotation is allowed.");
        }
        isFormEncoded = true;
      }
    }

 

분석

• 이 메소드는 메소드에 선언된 HTTP 메소드 Annotation(예: @GET, @POST)과 기타 Annotation을 처리한다.
• 각 Annotation이 무엇을 의미하는 지 해석하고, HTTP 메소드나 헤더 정보, 본문 형식 등을 설정한다. -> 7번 내용

 

7.RequestFactory.Builder.parseHttpMethodAndPath()

소스 코드 부분

    private void parseHttpMethodAndPath(String httpMethod, String value, boolean hasBody) {
      if (this.httpMethod != null) {
        throw methodError(
            method,
            "Only one HTTP method is allowed. Found: %s and %s.",
            this.httpMethod,
            httpMethod);
      }
      this.httpMethod = httpMethod;
      this.hasBody = hasBody;

      if (value.isEmpty()) {
        return;
      }

      // Get the relative URL path and existing query string, if present.
      int question = value.indexOf('?');
      if (question != -1 && question < value.length() - 1) {
        // Ensure the query string does not have any named parameters.
        String queryParams = value.substring(question + 1);
        Matcher queryParamMatcher = PARAM_URL_REGEX.matcher(queryParams);
        if (queryParamMatcher.find()) {
          throw methodError(
              method,
              "URL query string \"%s\" must not have replace block. "
                  + "For dynamic query parameters use @Query.",
              queryParams);
        }
      }

      this.relativeUrl = value;
      this.relativeUrlParamNames = parsePathParameters(value);
    }

 

분석

• HTTP 메소드와 URL 경로를 처리한다. 예를 들어, @GET("users/{user}/repos")와 같은 Annotation을 파싱해 URL 경로와 파라미터를 처리한다.
• URL 경로에 동적으로 파라미터를 삽입할 수 있도록 경로 매개변수를 설정한다.

 

8. RequestFactory.Builder.parseParameter() 

소스 코드 부분

    private @Nullable ParameterHandler<?> parseParameter(
        int p, Type parameterType, @Nullable Annotation[] annotations, boolean allowContinuation) {
      ParameterHandler<?> result = null;
      if (annotations != null) {
        for (Annotation annotation : annotations) {
          ParameterHandler<?> annotationAction =
              parseParameterAnnotation(p, parameterType, annotations, annotation);

          if (annotationAction == null) {
            continue;
          }

          if (result != null) {
            throw parameterError(
                method, p, "Multiple Retrofit annotations found, only one allowed.");
          }

          result = annotationAction;
        }
      }

      if (result == null) {
        if (allowContinuation) {
          try {
            if (Utils.getRawType(parameterType) == Continuation.class) {
              isKotlinSuspendFunction = true;
              return null;
            }
          } catch (NoClassDefFoundError ignored) {
            // Ignored
          }
        }
        throw parameterError(method, p, "No Retrofit annotation found.");
      }

      return result;
    }

 

분석

• 메소드 파라미터에 대한 Annotatin을 처리한다. 각 파라미터에 대해 선언된 @Query, @Path, @Filed 등 Annotation을 해석해 적절한 위치에 파라미터를 추가한다. -> 9번 내용
• 파라미터에 복수의 Retrofit Annotation이 적용될 수 없으며, 만약 여러 개가 선언되면 오류를 발생시킨다.

 

9.RequestFactory.Builder.parseParameterAnnotation() 

소스 코드 부분

너무 길어서 중략한 부분이 많다. 중요한 건, Annotaion을 instanceof로 분기처리하고 있다는 것이다.

    private ParameterHandler<?> parseParameterAnnotation(
        int p, Type type, Annotation[] annotations, Annotation annotation) {
      if (annotation instanceof Url) {
        validateResolvableType(p, type);
		// ... 

        gotUrl = true;

        if (type == HttpUrl.class
            || type == String.class
            || type == URI.class
            || (type instanceof Class && "android.net.Uri".equals(((Class<?>) type).getName()))) {
          return new ParameterHandler.RelativeUrl(method, p);
        } else {
          throw parameterError(
              method,
              p,
              "@Url must be okhttp3.HttpUrl, String, java.net.URI, or android.net.Uri type.");
        }

      } else if (annotation instanceof Path) {
        validateResolvableType(p, type);
		
        // ...

        Path path = (Path) annotation;
        String name = path.value();
        validatePathName(p, name);

        Converter<?, String> converter = retrofit.stringConverter(type, annotations);
        return new ParameterHandler.Path<>(method, p, name, converter, path.encoded());

      } //...
		// ...
      } else if (annotation instanceof Tag) {
        validateResolvableType(p, type);

        Class<?> tagType = Utils.getRawType(type);
        for (int i = p - 1; i >= 0; i--) {
          ParameterHandler<?> otherHandler = parameterHandlers[i];
          if (otherHandler instanceof ParameterHandler.Tag
              && ((ParameterHandler.Tag) otherHandler).cls.equals(tagType)) {
            throw parameterError(
                method,
                p,
                "@Tag type "
                    + tagType.getName()
                    + " is duplicate of "
                    + Platform.reflection.describeMethodParameter(method, i)
                    + " and would always overwrite its value.");
          }
        }

        return new ParameterHandler.Tag<>(tagType);
      }

      return null; // Not a Retrofit annotation.
    }

 

개략적인 분석

• 메서드 파라미터에 선언된 Annotation을 분석해, 그 파라미터가 HTTP 요청의 어느 부분에 해당하는지 결정한다. @Path, @Query, @Header, @Body 등 다양한 Annotation을 처리하며, API 호출 시 적절한 위치에 파라미터를 연결하는 중요한 역할을 수행한다.
• ParameterHandler를 반환한다. 
  • ParameterHandler는 추상 클래스이고, 클래스 내부에 ParameterHandler의 서브 클래스들을 정의했다, 
  • HTTP 요청의 각 파라미터 Annotation을 처리해 담당하는 서브 클래스들이 있다. 

10. HttpServiceMethod.parseAnnotations()

소스 코드 부분

  static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(
      Retrofit retrofit, Method method, RequestFactory requestFactory) {
      // 1. 코루틴 처리 여부 확인
    boolean isKotlinSuspendFunction = requestFactory.isKotlinSuspendFunction;
    boolean continuationWantsResponse = false;
    boolean continuationBodyNullable = false;
    boolean continuationIsUnit = false;

    Annotation[] annotations = method.getAnnotations();
    Type adapterType;
    // 2. 코루틴 응답 타입 처리
    if (isKotlinSuspendFunction) {
      Type[] parameterTypes = method.getGenericParameterTypes();
      Type responseType =
          Utils.getParameterLowerBound(
              0, (ParameterizedType) parameterTypes[parameterTypes.length - 1]);
      if (getRawType(responseType) == Response.class && responseType instanceof ParameterizedType) {
        // Unwrap the actual body type from Response<T>.
        responseType = Utils.getParameterUpperBound(0, (ParameterizedType) responseType);
        continuationWantsResponse = true;
      } else {
      // 3. Kotlin suspend 함수에 대한 경고 처리
        if (getRawType(responseType) == Call.class) {
          throw methodError(
              method,
              "Suspend functions should not return Call, as they already execute asynchronously.\n"
                  + "Change its return type to %s",
              Utils.getParameterUpperBound(0, (ParameterizedType) responseType));
        }

        continuationIsUnit = Utils.isUnit(responseType);
        // TODO figure out if type is nullable or not
        // Metadata metadata = method.getDeclaringClass().getAnnotation(Metadata.class)
        // Find the entry for method
        // Determine if return type is nullable or not
      }

      adapterType = new Utils.ParameterizedTypeImpl(null, Call.class, responseType);
      annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
    } else {
    //4. 비코루틴 함수 처리
      adapterType = method.getGenericReturnType();
    }

    CallAdapter<ResponseT, ReturnT> callAdapter =
        createCallAdapter(retrofit, method, adapterType, annotations);
    Type responseType = callAdapter.responseType();
    if (responseType == okhttp3.Response.class) {
      throw methodError(
          method,
          "'"
              + getRawType(responseType).getName()
              + "' is not a valid response body type. Did you mean ResponseBody?");
    }
    // 5. 응답 타입 유효성 검사
    if (responseType == Response.class) {
      throw methodError(method, "Response must include generic type (e.g., Response<String>)");
    }
    if (requestFactory.httpMethod.equals("HEAD")
        && !Void.class.equals(responseType)
        && !Utils.isUnit(responseType)) {
      throw methodError(method, "HEAD method must use Void or Unit as response type.");
    }

	// 6. 응답 변환기 생성
    Converter<ResponseBody, ResponseT> responseConverter =
        createResponseConverter(retrofit, method, responseType);

    okhttp3.Call.Factory callFactory = retrofit.callFactory;
    // 7. 비코루틴과 코루틴 함수에 대한 처리
    if (!isKotlinSuspendFunction) {
      return new CallAdapted<>(requestFactory, callFactory, responseConverter, callAdapter);
    } else if (continuationWantsResponse) {
      //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
      return (HttpServiceMethod<ResponseT, ReturnT>)
          new SuspendForResponse<>(
              requestFactory,
              callFactory,
              responseConverter,
              (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter);
    } else {
      //noinspection unchecked Kotlin compiler guarantees ReturnT to be Object.
      return (HttpServiceMethod<ResponseT, ReturnT>)
          new SuspendForBody<>(
              requestFactory,
              callFactory,
              responseConverter,
              (CallAdapter<ResponseT, Call<ResponseT>>) callAdapter,
              continuationBodyNullable,
              continuationIsUnit);
    }
  }

 

Annotation 관련 클래스 

CallAdapter

• 비동기 요청의 응답 타입을 변환하는 역할을 한다. 예를 들어, Call<Response<T>>를 RxJava의 Observable<T>로 변환할 수 있다.
• Annotation을 통해 정의된 API 응답을 객체로 변환한다.

 

CalledAdapter

• 비코루틴 함수를 처리하는 클래스이다. 요청을 비동기적으로 실행하고, 결과를 지정된 리턴 타입으로 변환한다.
• Annotation으로 정의된 API 인터페이스에서 반환 타입을 동기적 또는 비동기적으로 변환하는 역할을 한다.

 

정리

Retrofit은 Reflection과 프록시 패턴을 활용해 Annotation을 이용해 동작을 실행한다.

프록시패턴으로 Service 인터페이스의 프록시객체를 구현하고, HTTP 요청 메소드 호출시 프록시객체가 이 호출을 가로채서 Annotation을 분석해 HTTP 요청 동작을 진행한다.