&有梦想的咸鱼&

Android Retrofit 框架注解定义与解析模块深度剖析(一)

一、引言

在现代 Android 和 Java 开发中，网络请求是不可或缺的一部分。Retrofit 作为 Square 公司开源的一款强大的类型安全的 HTTP 客户端，凭借其简洁易用的 API 和高效的性能，在开发者社区中广受欢迎。Retrofit 的核心特性之一便是通过注解来定义 HTTP 请求，这种方式使得代码更加清晰、易读且易于维护。本文将深入 Retrofit 框架的源码，对其注解定义与解析模块进行全面且细致的分析，揭示其背后的实现原理。

二、Retrofit 框架概述

2.1 Retrofit 的基本工作流程

Retrofit 的主要工作流程可以概括为以下几个步骤：

定义服务接口：开发者使用注解定义一个接口，该接口包含了各种 HTTP 请求方法。
创建 Retrofit 实例：通过 Retrofit.Builder 构建 Retrofit 实例，配置请求的基础 URL、转换器工厂、调用适配器工厂等。
创建服务代理对象：使用 Retrofit 实例创建服务接口的代理对象。
发起请求：调用服务代理对象的方法发起 HTTP 请求，并处理响应结果。

2.2 注解在 Retrofit 中的作用

注解在 Retrofit 中扮演着至关重要的角色，它们用于描述 HTTP 请求的各个方面，包括请求方法（如 GET、POST 等）、请求路径、请求参数、请求头、请求体等。通过注解，开发者可以以一种声明式的方式定义请求，而无需编写繁琐的网络请求代码。

三、Retrofit 注解的定义

3.1 HTTP 请求方法注解

3.1.1 `@GET` 注解

java

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 表示 HTTP GET 请求的注解
 */
@Documented
// 该注解只能应用于方法上
@Target(ElementType.METHOD)
// 该注解在运行时保留，以便通过反射获取
@Retention(RetentionPolicy.RUNTIME)
public @interface GET {
    /**
     * 指定请求的相对路径
     * @return 请求的相对路径，默认为空字符串
     */
    String value() default "";
}

@GET 注解用于标记一个方法为 HTTP GET 请求，value 属性用于指定请求的相对路径。例如：

java

public interface ApiService {
    @GET("users/{id}")
    Call<User> getUser(@Path("id") int userId);
}

3.1.2 其他 HTTP 请求方法注解

除了 @GET 注解，Retrofit 还提供了 @POST、@PUT、@DELETE、@HEAD、@OPTIONS 和 @PATCH 等注解，它们的定义方式与 @GET 注解类似，只是用于不同的 HTTP 请求方法。

3.2 请求路径与参数注解

3.2.1 `@Path` 注解

java

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于替换 URL 中占位符的注解
 */
@Documented
// 该注解只能应用于方法的参数上
@Target(ElementType.PARAMETER)
// 该注解在运行时保留
@Retention(RetentionPolicy.RUNTIME)
public @interface Path {
    /**
     * 指定 URL 中的占位符名称
     * @return 占位符名称
     */
    String value();

    /**
     * 指定是否对参数进行 URL 编码，默认为 false
     * @return 是否进行 URL 编码
     */
    boolean encoded() default false;
}

@Path 注解用于替换 URL 中的占位符，例如在上面的 getUser 方法中，@Path("id") 表示将 userId 参数的值替换到 URL 中的 {id} 占位符处。

3.2.2 `@Query` 和 `@QueryMap` 注解

java

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于添加查询参数到 URL 中的注解
 */
@Documented
// 该注解只能应用于方法的参数上
@Target(ElementType.PARAMETER)
// 该注解在运行时保留
@Retention(RetentionPolicy.RUNTIME)
public @interface Query {
    /**
     * 指定查询参数的名称
     * @return 查询参数的名称
     */
    String value();

    /**
     * 指定是否对参数进行 URL 编码，默认为 false
     * @return 是否进行 URL 编码
     */
    boolean encoded() default false;
}

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于添加多个查询参数到 URL 中的注解
 */
@Documented
// 该注解只能应用于方法的参数上
@Target(ElementType.PARAMETER)
// 该注解在运行时保留
@Retention(RetentionPolicy.RUNTIME)
public @interface QueryMap {
    /**
     * 指定是否对参数进行 URL 编码，默认为 false
     * @return 是否进行 URL 编码
     */
    boolean encoded() default false;
}

@Query 注解用于添加单个查询参数到 URL 中，@QueryMap 注解用于添加多个查询参数。例如：

java

public interface ApiService {
    @GET("search")
    Call<List<Item>> search(@Query("keyword") String keyword, @Query("page") int page);

    @GET("search")
    Call<List<Item>> searchWithMap(@QueryMap Map<String, String> queryParams);
}

3.2.3 `@Header` 和 `@HeaderMap` 注解

java

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于添加请求头的注解
 */
@Documented
// 该注解只能应用于方法的参数上
@Target(ElementType.PARAMETER)
// 该注解在运行时保留
@Retention(RetentionPolicy.RUNTIME)
public @interface Header {
    /**
     * 指定请求头的名称
     * @return 请求头的名称
     */
    String value();
}

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于添加多个请求头的注解
 */
@Documented
// 该注解只能应用于方法的参数上
@Target(ElementType.PARAMETER)
// 该注解在运行时保留
@Retention(RetentionPolicy.RUNTIME)
public @interface HeaderMap {
}

@Header 注解用于添加单个请求头，@HeaderMap 注解用于添加多个请求头。例如：

java

public interface ApiService {
    @GET("data")
    Call<Data> getData(@Header("Authorization") String token);

    @GET("data")
    Call<Data> getDataWithMap(@HeaderMap Map<String, String> headers);
}

3.2.4 `@Body` 注解

java

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于指定请求体的注解
 */
@Documented
// 该注解只能应用于方法的参数上
@Target(ElementType.PARAMETER)
// 该注解在运行时保留
@Retention(RetentionPolicy.RUNTIME)
public @interface Body {
}

@Body 注解用于指定请求体，通常用于 POST、PUT 等请求。例如：

java

public interface ApiService {
    @POST("users")
    Call<User> createUser(@Body User user);
}

3.2.5 `@FormUrlEncoded`、`@Field` 和 `@FieldMap` 注解

java

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于标记表单编码请求的注解
 */
@Documented
// 该注解只能应用于方法上
@Target(ElementType.METHOD)
// 该注解在运行时保留
@Retention(RetentionPolicy.RUNTIME)
public @interface FormUrlEncoded {
}

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于添加表单字段的注解
 */
@Documented
// 该注解只能应用于方法的参数上
@Target(ElementType.PARAMETER)
// 该注解在运行时保留
@Retention(RetentionPolicy.RUNTIME)
public @interface Field {
    /**
     * 指定表单字段的名称
     * @return 表单字段的名称
     */
    String value();

    /**
     * 指定是否对参数进行 URL 编码，默认为 false
     * @return 是否进行 URL 编码
     */
    boolean encoded() default false;
}

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于添加多个表单字段的注解
 */
@Documented
// 该注解只能应用于方法的参数上
@Target(ElementType.PARAMETER)
// 该注解在运行时保留
@Retention(RetentionPolicy.RUNTIME)
public @interface FieldMap {
    /**
     * 指定是否对参数进行 URL 编码，默认为 false
     * @return 是否进行 URL 编码
     */
    boolean encoded() default false;
}

@FormUrlEncoded 注解用于标记一个方法为表单编码请求，@Field 注解用于添加单个表单字段，@FieldMap 注解用于添加多个表单字段。例如：

java

public interface ApiService {
    @FormUrlEncoded
    @POST("login")
    Call<LoginResponse> login(@Field("username") String username, @Field("password") String password);

    @FormUrlEncoded
    @POST("login")
    Call<LoginResponse> loginWithMap(@FieldMap Map<String, String> fields);
}

3.2.6 `@Multipart`、`@Part` 和 `@PartMap` 注解

java

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于标记多部分请求的注解
 */
@Documented
// 该注解只能应用于方法上
@Target(ElementType.METHOD)
// 该注解在运行时保留
@Retention(RetentionPolicy.RUNTIME)
public @interface Multipart {
}

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于添加多部分请求中的一个部分的注解
 */
@Documented
// 该注解只能应用于方法的参数上
@Target(ElementType.PARAMETER)
// 该注解在运行时保留
@Retention(RetentionPolicy.RUNTIME)
public @interface Part {
    /**
     * 指定部分的名称
     * @return 部分的名称
     */
    String value() default "";
}

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于添加多部分请求中的多个部分的注解
 */
@Documented
// 该注解只能应用于方法的参数上
@Target(ElementType.PARAMETER)
// 该注解在运行时保留
@Retention(RetentionPolicy.RUNTIME)
public @interface PartMap {
}

@Multipart 注解用于标记一个方法为多部分请求，@Part 注解用于添加多部分请求中的一个部分，@PartMap 注解用于添加多部分请求中的多个部分。多部分请求常用于文件上传等场景。例如：

java

public interface ApiService {
    @Multipart
    @POST("upload")
    Call<UploadResponse> uploadFile(@Part("file"; filename="image.jpg"") RequestBody file);

    @Multipart
    @POST("upload")
    Call<UploadResponse> uploadFiles(@PartMap Map<String, RequestBody> files);
}

3.3 其他注解

3.3.1 `@Headers` 注解

java

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用于添加多个请求头的注解
 */
@Documented
// 该注解只能应用于方法上
@Target(ElementType.METHOD)
// 该注解在运行时保留
@Retention(RetentionPolicy.RUNTIME)
public @interface Headers {
    /**
     * 指定请求头的数组
     * @return 请求头的数组
     */
    String[] value();
}

@Headers 注解用于在方法上添加多个请求头。例如：

java

public interface ApiService {
    @Headers({
        "Content-Type: application/json",
        "Authorization: Bearer token123"
    })
    @GET("data")
    Call<Data> getData();
}

四、Retrofit 注解的解析

4.1 解析入口：`ServiceMethod` 类

ServiceMethod 是 Retrofit 中解析注解的核心类，它负责将接口方法上的注解信息解析为实际的 HTTP 请求信息。以下是 ServiceMethod 类的部分源码：

java

abstract class ServiceMethod<T> {
    /**
     * 解析接口方法上的注解，创建 ServiceMethod 实例
     * @param retrofit Retrofit 实例
     * @param method 接口方法
     * @param  响应类型
     * @return ServiceMethod 实例
     */
    static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
        // 创建 RequestFactory.Builder 实例，用于构建 RequestFactory
        RequestFactory.Builder requestFactoryBuilder = new RequestFactory.Builder(retrofit, method);
        // 解析请求方法和路径相关的注解
        requestFactoryBuilder.parseMethodAnnotation(method.getAnnotations());

        // 获取方法的参数类型
        Type[] parameterTypes = method.getGenericParameterTypes();
        // 获取方法的参数注解
        Annotation[][] parameterAnnotationsArray = method.getParameterAnnotations();
        // 遍历方法的每个参数
        for (int p = 0; p < parameterTypes.length; p++) {
            // 解析参数的注解
            requestFactoryBuilder.parseParameter(p, parameterTypes[p], parameterAnnotationsArray[p]);
        }
        // 构建 RequestFactory 实例
        RequestFactory requestFactory = requestFactoryBuilder.build();

        // 获取方法的返回类型
        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.");
        }

        // 创建 CallAdapter 实例，用于将 Call 对象转换为其他类型
        CallAdapter<T, ?> callAdapter = createCallAdapter(retrofit, method, returnType, requestFactory);
        // 获取响应类型
        Type responseType = callAdapter.responseType();
        if (Utils.hasUnresolvableType(responseType)) {
            throw methodError(method, "Call return type must not include a type variable or wildcard: %s", returnType);
        }

        // 创建 Converter 实例，用于将响应数据转换为指定类型
        Converter<ResponseBody, T> responseConverter =
                createResponseConverter(retrofit, method, responseType);

        // 获取 OkHttpClient 实例
        okhttp3.Call.Factory callFactory = retrofit.callFactory();
        // 创建 ServiceMethod 实例
        return new HttpServiceMethod<>(callFactory, requestFactory, callAdapter, responseConverter);
    }

    /**
     * 创建 CallAdapter 实例
     * @param retrofit Retrofit 实例
     * @param method 接口方法
     * @param returnType 方法的返回类型
     * @param requestFactory 请求工厂
     * @param  响应类型
     * @return CallAdapter 实例
     */
    private static <T> CallAdapter<T, ?> createCallAdapter(
            Retrofit retrofit, Method method, Type returnType, RequestFactory requestFactory) {
        try {
            // 通过 Retrofit 实例获取 CallAdapter.Factory 列表，并调用其 get 方法创建 CallAdapter 实例
            return (CallAdapter<T, ?>) retrofit.callAdapter(returnType, method.getAnnotations());
        } catch (RuntimeException e) {
            throw methodError(method, e, "Unable to create call adapter for %s", returnType);
        }
    }

    /**
     * 创建响应转换器实例
     * @param retrofit Retrofit 实例
     * @param method 接口方法
     * @param responseType 响应类型
     * @param  响应类型
     * @return 响应转换器实例
     */
    private static <T> Converter<ResponseBody, T> createResponseConverter(
            Retrofit retrofit, Method method, Type responseType) {
        try {
            // 通过 Retrofit 实例获取 Converter.Factory 列表，并调用其 responseBodyConverter 方法创建响应转换器实例
            return retrofit.responseBodyConverter(responseType, method.getAnnotations());
        } catch (RuntimeException e) {
            throw methodError(method, e, "Unable to create converter for %s", responseType);
        }
    }

    /**
     * 抽象方法，用于执行请求
     * @param args 方法参数
     * @return 响应结果
     */
    abstract @Nullable T invoke(Object[] args);
}

parseAnnotations 方法是解析的入口，它接收 Retrofit 实例和 Method 实例作为参数，通过以下步骤完成注解解析：

创建 RequestFactory.Builder 实例，用于构建 RequestFactory。
调用 requestFactoryBuilder.parseMethodAnnotation 方法解析请求方法和路径相关的注解。
遍历方法的每个参数，调用 requestFactoryBuilder.parseParameter 方法解析参数的注解。
构建 RequestFactory 实例。
获取方法的返回类型，并创建 CallAdapter 实例，用于将 Call 对象转换为其他类型。
获取响应类型，并创建 Converter 实例，用于将响应数据转换为指定类型。
获取 OkHttpClient 实例，并创建 ServiceMethod 实例。

4.2 解析请求方法和路径注解：`RequestFactory.Builder.parseMethodAnnotation` 方法

java

static final class Builder {
    // 存储请求方法（如 GET、POST 等）
    private String httpMethod;
    // 存储请求是否需要请求体
    private boolean hasBody;
    // 存储请求的相对路径
    private String relativeUrl;
    // 存储请求的请求头
    private okhttp3.Headers headers;
    // 存储路径中的占位符名称
    private List<String> relativeUrlParamNames;
    // 标记是否为多部分请求
    private boolean isMultipart;
    // 标记是否为表单编码请求
    private boolean isFormEncoded;

    /**
     * 解析请求方法和路径相关的注解
     * @param annotations 方法上的注解数组
     */
    void parseMethodAnnotation(Annotation[] annotations) {
        for (Annotation annotation : annotations) {
            if (annotation instanceof HttpMethod) {
                // 如果注解是 HttpMethod 类型（如 @GET、@POST 等）
                HttpMethod httpMethodAnnotation = (HttpMethod) annotation;
                // 获取请求方法
                this.httpMethod = httpMethodAnnotation.value();
                // 判断是否需要请求体
                this.hasBody = httpMethodAnnotation.hasBody();

                String path = httpMethodAnnotation.path();
                if (!path.isEmpty()) {
                    // 检查路径是否以 / 开头
                    if (path.startsWith("/")) {
                        throw methodError(method, "@%s path must not start with /: %s",
                                httpMethodAnnotation.annotationType().getSimpleName(), path);
                    }
                    this.relativeUrl = path;
                    // 解析路径中的占位符
                    this.relativeUrlParamNames = parsePathParameters(path);
                }
            } else if (annotation instanceof Headers) {
                // 如果注解是 Headers 类型
                String[] headersToParse = ((Headers) annotation).value();
                if (headersToParse.length == 0) {
                    throw methodError(method, "@Headers annotation is empty.");
                }
                // 解析请求头
                this.headers = parseHeaders(headersToParse);
            } else if (annotation instanceof Multipart) {
                // 如果注解是 Multipart 类型
                if (this.hasBody) {
                    throw methodError(method, "Only one encoding annotation is allowed.");
                }
                this.isMultipart = true;
                this.hasBody = true;
            } else if (annotation instanceof FormUrlEncoded) {
                // 如果注解是 FormUrlEncoded 类型
                if (this.hasBody) {
                    throw methodError(method, "Only one encoding annotation is allowed.");
                }
                this.isFormEncoded = true;
                this.hasBody = true;
            }
        }

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

    /**
     * 解析路径中的占位符
     * @param path 请求路径
     * @return 占位符名称列表
     */
    private static List<String> parsePathParameters(String path) {
        // 定义正则表达式，用于匹配路径中的占位符
        Matcher m = PARAM_URL_REGEX.matcher(path);
        List<String> patterns = new ArrayList<>();
        while (m.find()) {
            String name = m.group(1);
            if (name == null) {
                continue;
            }
            if (patterns.contains(name)) {
                throw new IllegalArgumentException("URL path "" + path + "" has duplicate param "" + name + "".");
            }
            patterns.add(name);
        }
        return patterns;
    }

    /**
     * 解析请求头
     * @param headers 请求头数组
     * @return OkHttp 的 Headers 实例
     */
    private static okhttp3.Headers parseHeaders(String[] headers) {
        okhttp3.Headers.Builder builder = new okhttp3.Headers.Builder();
        for (String header : headers) {
            int colon = header.indexOf(':');
            if (colon == -1 || colon == 0 || colon == header.length() - 1) {
                throw new IllegalArgumentException("Headers value must be in the form "Name: Value". Found: "" + header + """);
            }
            String name = header.substring(0, colon).trim();
            String value = header.substring(colon + 1).trim();
            builder.add(name, value);
        }
        return builder.build();
    }
}

parseMethodAnnotation 方法遍历方法上的所有注解，根据注解的类型进行不同的处理：

如果注解是 HttpMethod 类型（如 @GET、@POST 等），获取请求方法、判断是否需要请求体，并解析路径中的占位符。
如果注解是 Headers 类型，解析请求头。
如果注解是 Multipart 类型，标记为多部分请求。
如果注解是 FormUrlEncoded 类型，标记为表单编码请求。

4.3 解析参数注解：`RequestFactory.Builder.parseParameter` 方法

java

static final class Builder {
    // 存储参数处理器数组
    private ParameterHandler<?>[] parameterHandlers;

    /**
     * 解析方法参数的注解
     * @param p 参数索引
     * @param parameterType 参数类型
     * @param annotations 参数上的注解数组
     */
    void parseParameter(
            int p, Type parameterType, @Nullable Annotation[] annotations) {
        if (annotations == null) {
            throw parameterError(method, p, "No Retrofit annotation found.");
        }

        ParameterHandler<?> result = 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) {
            throw parameterError(method, p, "No Retrofit annotation found.");
        }

        // 将参数处理器添加到参数处理器数组中
        parameterHandlers[p] = result;
    }

    /**
     * 解析单个参数注解
     * @param p 参数索引
     * @param type 参数类型
     * @param annotations 参数上的注解数组
     * @param annotation 当前要解析的注解
     * @return 参数处理器
     */
    private @Nullable ParameterHandler<?> parseParameterAnnotation(
            int p, Type type, Annotation[] annotations, Annotation annotation) {
        if (annotation instanceof Path) {
            // 如果注解

4.3 解析参数注解：`RequestFactory.Builder.parseParameter` 方法（续）

java

static final class Builder {
    // 存储参数处理器数组
    private ParameterHandler<?>[] parameterHandlers;

    /**
     * 解析方法参数的注解
     * @param p 参数索引
     * @param parameterType 参数类型
     * @param annotations 参数上的注解数组
     */
    void parseParameter(
            int p, Type parameterType, @Nullable Annotation[] annotations) {
        if (annotations == null) {
            throw parameterError(method, p, "No Retrofit annotation found.");
        }

        ParameterHandler<?> result = 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) {
            throw parameterError(method, p, "No Retrofit annotation found.");
        }

        // 将参数处理器添加到参数处理器数组中
        parameterHandlers[p] = result;
    }

    /**
     * 解析单个参数注解
     * @param p 参数索引
     * @param type 参数类型
     * @param annotations 参数上的注解数组
     * @param annotation 当前要解析的注解
     * @return 参数处理器
     */
    private @Nullable ParameterHandler<?> parseParameterAnnotation(
            int p, Type type, Annotation[] annotations, Annotation annotation) {
        if (annotation instanceof Path) {
            // 如果注解是 Path 类型
            Path path = (Path) annotation;
            // 检查路径中是否包含该占位符
            if (!relativeUrlParamNames.contains(path.value())) {
                throw parameterError(method, p, "@Path parameter "" + path.value()
                        + "" not found in relative URL "" + relativeUrl + """);
            }
            // 检查参数类型是否为基本类型或字符串
            if (Utils.hasUnresolvableType(type)) {
                throw parameterError(method, p,
                        "@Path parameter type must not include a type variable or wildcard: %s", type);
            }
            // 创建 PathParameterHandler 实例
            return new ParameterHandler.Path<>(path.value(), path.encoded(),
                    converterFactory.stringConverter(type, annotations, retrofit));
        } else if (annotation instanceof Query) {
            // 如果注解是 Query 类型
            Query query = (Query) annotation;
            // 检查参数类型是否为基本类型或字符串
            if (Utils.hasUnresolvableType(type)) {
                throw parameterError(method, p,
                        "@Query parameter type must not include a type variable or wildcard: %s", type);
            }
            // 创建 QueryParameterHandler 实例
            return new ParameterHandler.Query<>(query.value(), query.encoded(),
                    converterFactory.stringConverter(type, annotations, retrofit));
        } else if (annotation instanceof QueryMap) {
            // 如果注解是 QueryMap 类型
            if (!Map.class.isAssignableFrom(Utils.getRawType(type))) {
                throw parameterError(method, p, "@QueryMap parameter type must be Map.");
            }
            Type keyType = Utils.getSupertype(type, Map.class, String.class);
            if (keyType != String.class) {
                throw parameterError(method, p, "@QueryMap keys must be of type String: %s", type);
            }
            Type valueType = Utils.getSupertype(type, Map.class, Object.class);
            // 创建 QueryMapParameterHandler 实例
            return new ParameterHandler.QueryMap<>(
                    converterFactory.stringConverter(valueType, annotations, retrofit));
        } else if (annotation instanceof Header) {
            // 如果注解是 Header 类型
            Header header = (Header) annotation;
            // 检查参数类型是否为基本类型或字符串
            if (Utils.hasUnresolvableType(type)) {
                throw parameterError(method, p,
                        "@Header parameter type must not include a type variable or wildcard: %s", type);
            }
            // 创建 HeaderParameterHandler 实例
            return new ParameterHandler.Header<>(header.value(),
                    converterFactory.stringConverter(type, annotations, retrofit));
        } else if (annotation instanceof HeaderMap) {
            // 如果注解是 HeaderMap 类型
            if (!Map.class.isAssignableFrom(Utils.getRawType(type))) {
                throw parameterError(method, p, "@HeaderMap parameter type must be Map.");
            }
            Type keyType = Utils.getSupertype(type, Map.class, String.class);
            if (keyType != String.class) {
                throw parameterError(method, p, "@HeaderMap keys must be of type String: %s", type);
            }
            Type valueType = Utils.getSupertype(type, Map.class, Object.class);
            // 创建 HeaderMapParameterHandler 实例
            return new ParameterHandler.HeaderMap<>(
                    converterFactory.stringConverter(valueType, annotations, retrofit));
        } else if (annotation instanceof Body) {
            // 如果注解是 Body 类型
            if (isFormEncoded || isMultipart) {
                throw parameterError(method, p,
                        "@Body parameters cannot be used with form or multi - part encoding.");
            }
            // 创建 BodyParameterHandler 实例
            return new ParameterHandler.Body<>(
                    converterFactory.requestBodyConverter(type, annotations, methodAnnotations, retrofit));
        } else if (annotation instanceof Field) {
            // 如果注解是 Field 类型
            if (!isFormEncoded) {
                throw parameterError(method, p, "@Field parameters can only be used with form encoding.");
            }
            Field field = (Field) annotation;
            // 检查参数类型是否为基本类型或字符串
            if (Utils.hasUnresolvableType(type)) {
                throw parameterError(method, p,
                        "@Field parameter type must not include a type variable or wildcard: %s", type);
            }
            // 创建 FieldParameterHandler 实例
            return new ParameterHandler.Field<>(field.value(), field.encoded(),
                    converterFactory.stringConverter(type, annotations, retrofit));
        } else if (annotation instanceof FieldMap) {
            // 如果注解是 FieldMap 类型
            if (!isFormEncoded) {
                throw parameterError(method, p, "@FieldMap parameters can only be used with form encoding.");
            }
            if (!Map.class.isAssignableFrom(Utils.getRawType(type))) {
                throw parameterError(method, p, "@FieldMap parameter type must be Map.");
            }
            Type keyType = Utils.getSupertype(type, Map.class, String.class);
            if (keyType != String.class) {
                throw parameterError(method, p, "@FieldMap keys must be of type String: %s", type);
            }
            Type valueType = Utils.getSupertype(type, Map.class, Object.class);
            // 创建 FieldMapParameterHandler 实例
            return new ParameterHandler.FieldMap<>(
                    converterFactory.stringConverter(valueType, annotations, retrofit));
        } else if (annotation instanceof Part) {
            // 如果注解是 Part 类型
            if (!isMultipart) {
                throw parameterError(method, p, "@Part parameters can only be used with multipart encoding.");
            }
            Part part = (Part) annotation;
            String partName = part.value();
            if (!"".equals(partName) && !partName.endsWith(";")) {
                partName = partName + ";";
            }
            // 创建 PartParameterHandler 实例
            return new ParameterHandler.Part<>(partName,
                    converterFactory.requestBodyConverter(type, annotations, methodAnnotations, retrofit));
        } else if (annotation instanceof PartMap) {
            // 如果注解是 PartMap 类型
            if (!isMultipart) {
                throw parameterError(method, p, "@PartMap parameters can only be used with multipart encoding.");
            }
            if (!Map.class.isAssignableFrom(Utils.getRawType(type))) {
                throw parameterError(method, p, "@PartMap parameter type must be Map.");
            }
            Type keyType = Utils.getSupertype(type, Map.class, String.class);
            if (keyType != String.class) {
                throw parameterError(method, p, "@PartMap keys must be of type String: %s", type);
            }
            Type valueType = Utils.getSupertype(type, Map.class, Object.class);
            // 创建 PartMapParameterHandler 实例
            return new ParameterHandler.PartMap<>(
                    converterFactory.requestBodyConverter(valueType, annotations, methodAnnotations, retrofit));
        }

        return null;
    }
}

4.3.1 详细解析逻辑

@Path 注解解析：
- 首先，从 Path 注解中获取占位符名称，检查该占位符是否存在于之前解析得到的 relativeUrlParamNames 列表中。如果不存在，会抛出异常，确保路径占位符的正确性。
- 接着，检查参数类型是否包含不可解析的类型变量或通配符。如果存在，也会抛出异常，因为 @Path 参数类型应该是基本类型或字符串。
- 最后，创建 ParameterHandler.Path 实例，该实例负责处理路径占位符的替换。converterFactory.stringConverter 方法用于创建一个将参数类型转换为字符串的转换器，以便将参数值正确地替换到路径中。
@Query 注解解析：
- 对于 Query 注解，同样会检查参数类型是否包含不可解析的类型变量或通配符。
- 然后创建 ParameterHandler.Query 实例，该实例会将参数值作为查询参数添加到 URL 中。converterFactory.stringConverter 用于将参数值转换为字符串形式。
@QueryMap 注解解析：
- 先检查参数类型是否为 Map 类型，如果不是会抛出异常。
- 接着检查 Map 的键类型是否为 String 类型，若不是也会抛出异常。
- 最后创建 ParameterHandler.QueryMap 实例，该实例会将 Map 中的键值对作为查询参数添加到 URL 中。converterFactory.stringConverter 用于将 Map 的值转换为字符串。
@Header 注解解析：
- 检查参数类型是否包含不可解析的类型变量或通配符。
- 创建 ParameterHandler.Header 实例，该实例会将参数值作为请求头添加到请求中。converterFactory.stringConverter 用于将参数值转换为字符串形式的请求头值。
@HeaderMap 注解解析：
- 检查参数类型是否为 Map 类型，以及 Map 的键类型是否为 String 类型。
- 创建 ParameterHandler.HeaderMap 实例，该实例会将 Map 中的键值对作为请求头添加到请求中。converterFactory.stringConverter 用于将 Map 的值转换为字符串形式的请求头值。
@Body 注解解析：
- 检查当前请求是否为表单编码或多部分请求，如果是则抛出异常，因为 @Body 参数不能与表单或多部分编码同时使用。
- 创建 ParameterHandler.Body 实例，该实例会将参数作为请求体发送。converterFactory.requestBodyConverter 用于将参数类型转换为 RequestBody 类型，以便进行网络传输。
@Field 注解解析：
- 检查当前请求是否为表单编码请求，如果不是则抛出异常，因为 @Field 参数只能用于表单编码请求。
- 检查参数类型是否包含不可解析的类型变量或通配符。
- 创建 ParameterHandler.Field 实例，该实例会将参数值作为表单字段添加到请求体中。converterFactory.stringConverter 用于将参数值转换为字符串形式的表单字段值。
@FieldMap 注解解析：
- 检查当前请求是否为表单编码请求，以及参数类型是否为 Map 类型，Map 的键类型是否为 String 类型。
- 创建 ParameterHandler.FieldMap 实例，该实例会将 Map 中的键值对作为表单字段添加到请求体中。converterFactory.stringConverter 用于将 Map 的值转换为字符串形式的表单字段值。
@Part 注解解析：
- 检查当前请求是否为多部分请求，如果不是则抛出异常，因为 @Part 参数只能用于多部分请求。
- 处理 Part 注解的 value 属性，确保其格式正确。
- 创建 ParameterHandler.Part 实例，该实例会将参数作为多部分请求的一部分添加到请求体中。converterFactory.requestBodyConverter 用于将参数类型转换为 RequestBody 类型。
@PartMap 注解解析：
- 检查当前请求是否为多部分请求，以及参数类型是否为 Map 类型，Map 的键类型是否为 String 类型。
- 创建 ParameterHandler.PartMap 实例，该实例会将 Map 中的键值对作为多部分请求的多个部分添加到请求体中。converterFactory.requestBodyConverter 用于将 Map 的值转换为 RequestBody 类型。

4.4 创建 `RequestFactory` 实例

在完成所有参数注解的解析后，会调用 RequestFactory.Builder 的 build 方法来构建 RequestFactory 实例：

java

RequestFactory build() {
    return new RequestFactory(this);
}

RequestFactory 类封装了所有解析得到的请求信息，包括请求方法、请求路径、请求头、请求体等，后续会根据这些信息创建实际的 Request 对象。

4.5 创建 `CallAdapter` 和 `Converter` 实例

在 ServiceMethod.parseAnnotations 方法中，还会创建 CallAdapter 和 Converter 实例：

java

// 创建 CallAdapter 实例，用于将 Call 对象转换为其他类型
CallAdapter<T, ?> callAdapter = createCallAdapter(retrofit, method, returnType, requestFactory);
// 获取响应类型
Type responseType = callAdapter.responseType();
if (Utils.hasUnresolvableType(responseType)) {
    throw methodError(method, "Call return type must not include a type variable or wildcard: %s", returnType);
}

// 创建 Converter 实例，用于将响应数据转换为指定类型
Converter<ResponseBody, T> responseConverter =
        createResponseConverter(retrofit, method, responseType);

4.5.1 `CallAdapter` 实例创建

createCallAdapter 方法通过 Retrofit 实例的 callAdapter 方法从 CallAdapter.Factory 列表中查找合适的 CallAdapter.Factory，并调用其 get 方法创建 CallAdapter 实例。CallAdapter 的作用是将 Call 对象转换为其他类型，例如将 Call 转换为 Observable 等，以支持不同的异步编程模型。

4.5.2 `Converter` 实例创建

createResponseConverter 方法通过 Retrofit 实例的 responseBodyConverter 方法从 Converter.Factory 列表中查找合适的 Converter.Factory，并调用其 responseBodyConverter 方法创建 Converter 实例。Converter 的作用是将 ResponseBody 转换为指定的响应类型，例如将 JSON 数据转换为 Java 对象。

4.6 创建 `ServiceMethod` 实例

最后，根据前面解析得到的信息，创建 ServiceMethod 实例：

java

// 获取 OkHttpClient 实例
okhttp3.Call.Factory callFactory = retrofit.callFactory();
// 创建 ServiceMethod 实例
return new HttpServiceMethod<>(callFactory, requestFactory, callAdapter, responseConverter);

HttpServiceMethod 是 ServiceMethod 的具体实现类，它负责执行实际的 HTTP 请求，并处理响应结果。在 invoke 方法中，会根据 RequestFactory 创建 Request 对象，使用 OkHttpClient 发送请求，然后通过 CallAdapter 和 Converter 处理响应。

java

final class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
    private final okhttp3.Call.Factory callFactory;
    private final RequestFactory requestFactory;
    private final CallAdapter<ResponseT, ReturnT> callAdapter;
    private final Converter<ResponseBody, ResponseT> responseConverter;

    HttpServiceMethod(okhttp3.Call.Factory callFactory, RequestFactory requestFactory,
                      CallAdapter<ResponseT, ReturnT> callAdapter,
                      Converter<ResponseBody, ResponseT> responseConverter) {
        this.callFactory = callFactory;
        this.requestFactory = requestFactory;
        this.callAdapter = callAdapter;
        this.responseConverter = responseConverter;
    }

    @Override
    @Nullable ReturnT invoke(Object[] args) {
        // 创建 OkHttp 的 Request 对象
        Request request = requestFactory.create(args);
        // 创建 OkHttp 的 Call 对象
        okhttp3.Call call = callFactory.newCall(request);
        // 调用 CallAdapter 的 adapt 方法将 Call 对象转换为指定类型
        return callAdapter.adapt(new OkHttpCall<>(request, callFactory, responseConverter));
    }
}

五、注解解析后的使用

当 ServiceMethod 实例创建完成后，就可以使用它来发起 HTTP 请求了。在调用服务接口的方法时，实际上是调用 ServiceMethod 的 invoke 方法：

java

public interface ApiService {
    @GET("users/{id}")
    Call<User> getUser(@Path("id") int userId);
}

// 创建 Retrofit 实例
Retrofit retrofit = new Retrofit.Builder()
      .baseUrl("https://api.example.com/")
      .addConverterFactory(GsonConverterFactory.create())
      .build();

// 创建服务代理对象
ApiService apiService = retrofit.create(ApiService.class);

// 发起请求
Call<User> call = apiService.getUser(1);
call.enqueue(new Callback<User>() {
    @Override
    public void onResponse(Call<User> call, Response<User> response) {
        if (response.isSuccessful()) {
            User user = response.body();
            // 处理响应数据
        } else {
            // 处理请求失败
        }
    }

    @Override
    public void onFailure(Call<User> call, Throwable t) {
        // 处理请求异常
    }
});

在上述代码中，apiService.getUser(1) 实际上调用了 ServiceMethod 的 invoke 方法，该方法会根据之前解析得到的注解信息创建 Request 对象，使用 OkHttpClient 发送请求，并通过 CallAdapter 和 Converter 处理响应结果。

六、总结

Retrofit 的注解定义与解析模块是其核心功能之一，通过使用注解，开发者可以以一种简洁、声明式的方式定义 HTTP 请求。在解析过程中，Retrofit 利用 Java 的反射机制，在运行时获取方法和参数上的注解信息，并根据注解类型进行相应的处理。具体步骤包括解析请求方法和路径注解、解析参数注解、创建 RequestFactory、CallAdapter 和 Converter 实例，最终创建 ServiceMethod 实例来执行实际的 HTTP 请求。这种设计使得 Retrofit 具有高度的灵活性和可扩展性，开发者可以通过自定义 CallAdapter.Factory 和 Converter.Factory 来满足不同的需求。同时，注解的使用也使得代码更加清晰、易读和易于维护，提高了开发效率。

你可能感兴趣的:(Android,Retrofit原理,android,retrofit)

SpringMVC执行流程（原理），通俗易懂国服冰 SpringMVC spring mvc
SpringMVC执行流程（原理），通俗易懂一、图解SpringMVC流程二、进一步理解Springmvc的执行流程1、导入依赖2、建立展示的视图3、web.xml4、spring配置文件springmvc-servlet5、Controller6、tomcat配置7、访问的url8、视图页面一、图解SpringMVC流程图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提
深入解析JVM工作原理：从字节码到机器指令的全过程
一、JVM概述Java虚拟机(JVM)是Java平台的核心组件，它实现了Java"一次编写，到处运行"的理念。JVM是一个抽象的计算机器，它有自己的指令集和运行时内存管理机制。JVM的主要职责：加载：读取.class文件并验证其正确性存储：管理内存分配和垃圾回收执行：解释或编译字节码为机器指令安全：提供沙箱环境限制恶意代码二、JVM架构详解JVM由三个主要子系统组成：1.类加载子系统类加载过程分为
Spring进阶 - SpringMVC实现原理之DispatcherServlet处理请求的过程倾听铃的声后端 spring java mvc 开发语言分布式
前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第二篇：DispatcherServlet处理请求的过程的源码解析。@pdaiSpring进阶-SpringMVC实现原理之DispatcherServlet处理请求的
2019-06-05 第十七把巴鲁克
今天去实验田里实习，见到了福寿螺真的可怕且牛皮，六级也快来了，说实话还是害怕。我昨天考了环工原理，真的太难了，太烦了，理工科真的难，烦。实验报告还是没写，要抓紧速度抓紧时间，还是应该学会努力学习，远离一些不上进的事物。
SpringMVC的执行流程
1、什么是MVCMVC是一种设计模式。MVC的原理图如下所示M-Model模型（完成业务逻辑：有javaBean构成，service+dao+entity）V-View视图（做界面的展示jsp，html……）C-Controller控制器（接收请求—>调用模型—>根据结果派发页面2、SpringMVC是什么SpringMVC是一个MVC的开源框架，SpringMVC=Struts2+Spring，
企业级区块链平台Hyperchain核心原理剖析 boyedu 区块链区块链企业级区块链平台 Hyperchain
Hyperchain作为国产自主可控的企业级联盟区块链平台，其核心原理围绕高性能共识、隐私保护、智能合约引擎及可扩展架构展开，通过多模块协同实现企业级区块链网络的高效部署与安全运行。以下从核心架构、关键技术、性能优化、安全机制、应用场景五个维度展开剖析：一、核心架构：分层解耦与模块化设计Hyperchain采用分层架构，将区块链功能解耦为独立模块，支持灵活组合与扩展：P2P网络层由验证节点（VP）
EasyPlayer播放器系列开发计划2025 xiejiashu EasyPlayer EasyPlayer EasyPlayer播放器 RTSP播放器 js播放器 Web播放器
EasyPlayer系列产品发展至今，已经超过10年，从最早的EasyPlayerRTSP播放器，到如今维护的3条线：EasyPlayer-RTSP播放器：Windows、Android、iOS；EasyPlayerPro播放器：Windows、Android、iOS；EasyPlayer.js播放器：H5；这3个播放器各有各的应用场景，用户量也是巨大，像RTSP版本的播放器，到今天依然还有很多低
编程算法：技术创新的引擎与业务增长的核心驱动力
在数字经济时代，算法已成为推动技术创新与业务增长的隐形引擎。从存内计算突破冯·诺依曼瓶颈，到动态规划优化万亿级金融交易，编程算法正在重塑产业竞争格局。一、存内计算：突破冯·诺依曼瓶颈的算法革命1.1存内计算的基本原理传统计算架构中90%的能耗消耗在数据搬运上。存内计算（Processing-in-Memory）通过直接在存储单元执行计算，实现能效10-100倍提升：#传统计算vs存内计算能耗模型i
Android 应用权限管理详解
文章目录1.权限类型2.权限请求机制3.权限组和分级4.权限管理的演进5.权限监控和SELinux强制访问控制6.应用权限审核和GooglePlayProtect7.开发者最佳实践8.用户权限管理9.Android应用沙箱模型10.ScopedStorage（分区存储）11.背景位置权限（BackgroundLocationAccess）12.权限回收和自动清理13.权限请求的用户体验设计14.G
元宇宙中的视觉技术：虚拟化身与场景生成 xcLeigh 计算机视觉CV 元宇宙虚拟化身场景生成 AIGC 数字孪生
元宇宙中的视觉技术：虚拟化身与场景生成前言一、元宇宙与视觉技术的深度关联1.1元宇宙概念深度剖析1.2视觉技术：元宇宙的“灵魂之窗”二、虚拟化身：数字世界的“第二自我”2.1虚拟化身技术的深度解析2.1.1核心技术构成2.1.2技术实现原理与流程2.2虚拟化身的应用领域及案例展示2.2.1游戏娱乐领域2.2.2教育培训领域三、场景生成：构建元宇宙的虚拟天地3.1场景生成技术全景透视3.1.1关键技
深入理解 Tomcat Wrapper 原理北漂老男人 Tomcat tomcat java
深入理解TomcatWrapper原理一、引言在Tomcat的分层容器架构中，Wrapper作为最底层的容器，专门负责管理单个Servlet的生命周期及请求分发。每一个Servlet（包括JSP、Filter等）都对应一个Wrapper。Wrapper是Servlet规范与Tomcat容器实现之间的桥梁，直接关系到请求的分发效率、Servlet的加载与重用、安全隔离等。本文将系统剖析Wrapper
Deepseek技术深化：驱动大数据时代颠覆性变革的未来引擎荣华富贵8 spring boot 搜索引擎后端缓存 redis
在大数据时代，信息爆炸和数据驱动的决策逐渐重塑各行各业。作为一项前沿技术，Deepseek正在引领新一轮技术革新，颠覆传统数据处理与分析方式。本文将从理论原理、应用场景和前沿代码实践三个层面，深入剖析Deepseek技术如何为大数据时代提供颠覆性变革的解决方案。一、技术背景与核心思想1.1大数据挑战与机遇在数据量呈指数级增长的背景下，传统数据处理方法面临数据存储、计算效率和信息提取精度的诸多挑战。
分布式链路追踪系统架构设计：从理论到企业级实践 ma451152002 java 分布式系统架构
分布式链路追踪系统架构设计：从理论到企业级实践本文深入探讨分布式链路追踪系统的架构设计原理、关键技术实现和企业级应用实践，为P7架构师提供完整的技术方案参考。目录引言：分布式链路追踪的重要性核心概念与技术原理系统架构设计数据模型与协议标准核心组件架构设计性能优化与扩展性设计企业级实施策略技术选型与对比分析监控与运维体系未来发展趋势P7架构师面试要点引言：分布式链路追踪的重要性微服务架构下的挑战在现
Android 基础知识：Android 应用权限详解流水mpc android
这篇文章为大家系统的梳理一下Android权限相关的知识，在日常开发中，我们都用过权限，但是对于权限的一些细节我们可能掌握的还不够全面，这篇文章会全面的为大家介绍权限相关的知识。当然，本篇文章依然是参考了Google的官方文档：应用权限。本文目录一、认识Android权限（一）Android系统为什么需要权限？Android系统设置权限的目的是保护Android用户的隐私。对于用户的敏感数据And
面试必考题：Android Binder 机制详解大模型大数据攻城狮 android binder 面试 react native kotlin dalvik retrofit
目录第一章：Binder的基本概念什么是Binder？多角度解读Binder第二章：Binder的工作机制Binder的整体流程服务注册：从零到有的第一步服务查询：找到目标的“地图”服务调用：请求与响应的旅程Binder驱动的幕后功劳为什么Binder这么快？第三章：Binder在系统架构中的角色Activity：界面背后的通信枢纽Binder的角色实例分析Service：后台任务的跨进程支柱Bi
Android GreenDao介绍和Generator生成表对象代码
目录(?)[-]介绍创建工程转载请注明：http://blog.csdn.net/sinat_30276961/article/details/50052109最近无意中发现了GreenDao，然后查看了一些资料后，发现这个数据库框架很适合用，于是乎，查看了官网的api，并自己写了一个小应用总结一下它的使用方法。介绍按照国际惯例，在开篇，总要先介绍一下什么是GreenDao吧。首先需要说明的是Gr
Android 媒体播放开发完全指南安卓开发者 Android Jetpack android 媒体 python
引言在当今移动应用生态中，媒体播放功能已成为许多应用的核心组成部分。无论是音乐流媒体应用、视频平台、播客客户端还是游戏应用，都需要强大的媒体播放能力。Android平台提供了丰富的API来支持各种媒体播放场景。本文将全面介绍Android媒体播放的开发技术，从基础到高级功能实现。一、Android媒体播放基础1.1支持的媒体格式Android原生支持多种媒体格式：音频：MP3、AAC、FLAC、W
Android通知(Notification)全面解析：从基础到高级应用
一、Android通知概述通知(Notification)是Android系统中用于在应用之外向用户传递信息的重要机制。当应用需要告知用户某些事件或信息时，可以通过通知在状态栏显示图标，用户下拉通知栏即可查看详细信息。这种机制几乎被所有现代应用采用，用于推送新闻、消息、广告等内容3。与Toast相比，Notification的优势在于：可以长时间停留在通知栏，适合内容较多且需要持久展示的信息支持丰
Android Slices：让应用功能在系统级交互中触手可及安卓开发者 Android Jetpack android 交互 gitee
引言在当今移动应用生态中，用户每天要面对数十个甚至上百个应用的选择，如何让自己的应用在关键时刻触达用户，成为开发者面临的重要挑战。Google在Android9Pie中引入的Slices技术，正是为了解决这一痛点而生。本文将全面介绍AndroidSlices的概念、实现方法、应用场景以及最佳实践，帮助开发者掌握这一提升用户参与度的强大工具。什么是AndroidSlices？AndroidSlice
Flutter权限插件详解：permission_handler使用指南 AI移动开发前沿 AI移动端开发宝典 flutter ai
Flutter权限插件详解：permission_handler使用指南关键词：Flutter、权限插件、permission_handler、权限管理、移动开发摘要：本文围绕Flutter开发中常用的权限插件permission_handler展开详细介绍。首先阐述了在Flutter应用开发中处理权限的背景和重要性，接着深入解析permission_handler的核心概念、架构以及工作原理，通
神经形态计算如何突破冯·诺依曼架构限制？ AI算力网络与通信 AI人工智能与大数据技术 AI算力网络与通信原理 AI人工智能大数据架构架构 ai
神经形态计算如何突破冯·诺依曼架构限制？关键词：神经形态计算、冯·诺依曼架构、内存墙、存算一体、脉冲神经网络、类脑芯片、低功耗计算摘要：本文将从“冯·诺依曼架构的前世今生”讲起，用“图书馆管理员搬书”的生活案例类比其核心矛盾，再通过“人脑神经元工作模式”的比喻引入神经形态计算的核心原理。我们将一步步拆解冯·诺依曼架构的三大限制（内存墙、高功耗、非结构化数据处理弱），并对应解析神经形态计算的三大突破
AIGC内容生成实战：如何用ChatGPT+DALL·E打造高转化内容 AI大模型应用工坊 AI大模型开发实战 AIGC chatgpt ai
AIGC内容生成实战：如何用ChatGPT+DALL·E打造高转化内容关键词：AIGC、ChatGPT、DALL·E、内容生成、高转化营销、多模态协同、提示词工程摘要：随着AIGC（人工智能生成内容）技术的爆发式发展，ChatGPT（文本生成）与DALL·E（图像生成）的组合已成为内容创作领域的“黄金搭档”。本文将深度解析二者的协同原理，结合实战案例演示从需求分析到内容落地的全流程，并揭示提升内容
数据分析领域中AI人工智能的发展前景展望 AI大模型应用工坊 AI大模型开发实战数据分析人工智能数据挖掘 ai
数据分析领域中AI人工智能的发展前景展望关键词：数据分析、人工智能、机器学习、深度学习、数据挖掘、预测分析、自动化摘要：本文深入探讨了人工智能在数据分析领域的发展现状和未来趋势。我们将从核心技术原理出发，分析AI如何改变传统数据分析范式，详细讲解机器学习算法在数据分析中的应用，并通过实际案例展示AI驱动的数据分析解决方案。文章还将探讨行业应用场景、工具生态以及未来发展面临的挑战和机遇，为数据分析师
深入理解卷积神经网络（CNN）与循环神经网络（RNN） CodeJourney. cnn rnn 人工智能
在当今的人工智能领域，神经网络无疑是最为璀璨的明珠之一。而卷积神经网络（ConvolutionalNeuralNetworks，CNN）和循环神经网络（RecurrentNeuralNetworks，RNN）作为神经网络家族中的重要成员，各自有着独特的架构和强大的功能，广泛应用于众多领域。本文将深入探讨这两种神经网络的原理、特点以及应用场景，为对深度学习感兴趣的读者提供全面的知识讲解。一、卷积神经
Redis 分布式锁深度解析：过期时间与自动续期机制爱恨交织围巾分布式事务 redis 分布式数据库微服务学习 go
Redis分布式锁深度解析：过期时间与自动续期机制在分布式系统中，Redis分布式锁的可靠性很大程度上依赖于对锁生命周期的管理。上一篇文章我们探讨了分布式锁的基本原理，今天我们将聚焦于一个关键话题：如何通过合理设置过期时间和实现自动续期机制，来解决分布式锁中的死锁与锁提前释放问题。一、为什么过期时间是分布式锁的生命线？你的笔记中提到"服务挂掉时未删除锁可能导致死锁"，这正是过期时间要解决的核心问题
.net平台的跨平台桌面应用开发的技术方案总结对比 yuanpan .net
目前，.NET平台提供了多种跨平台桌面应用开发的技术方案，主要包括.NETMAUI、AvaloniaUI、UnoPlatform、Eto.Forms等。以下是它们的核心特点及优缺点对比：1..NETMAUI（.NETMulti-platformAppUI）支持平台：Windows、macOS、iOS、Android核心特点：微软官方维护，继承自Xamarin.Forms，支持XAML和C#开发。提
从零到一：基于差分隐私决策树的客户购买预测系统实战开发笙囧同学决策树算法机器学习
作者简介：笙囧同学，中科院计算机大模型方向硕士，全栈开发爱好者联系方式：[email protected]各大平台账号：笙囧同学座右铭：偷懒是人生进步的阶梯文章导航快速导航前言-项目背景与价值项目概览-系统架构与功能技术深度解析-核心算法原理️系统实现详解-工程实践细节性能评估与分析-实验结果分析Web系统开发-前后端开发部署与运维-DevOps实践完整复现指南-手把手教程️实践案例与故障排除-问
零数学基础理解AI核心概念：梯度下降可视化实战九章云极AladdinEdu 人工智能 gpu算力深度学习 pytorch python 语言模型 opencv
点击“AladdinEdu，同学们用得起的【H卡】算力平台”，H卡级别算力，按量计费，灵活弹性，顶级配置，学生专属优惠。用Python动画演示损失函数优化过程，数学公式具象化读者收获：直观理解模型训练本质，破除"数学恐惧症"当盲人登山者摸索下山路径时，他本能地运用了梯度下降算法。本文将用动态可视化技术，让你像感受重力一样理解AI训练的核心原理——无需任何数学公式推导。一、梯度下降：AI世界的"万有
大数据精准获客并实现高转化的核心思路和实现方法 2401_88470328 大数据精准获客数据分析数据挖掘大数据需求分析 big data
大数据精准获客并实现高转化的核心思路和实现方法大数据精准获客并实现高转化的核心思路和实现方法在当今信息爆炸的时代，企业如何通过海量的数据精准获取潜在客户，并提高转化率，已经成为营销策略中的关键环节。大数据精准获客的核心思路在于数据驱动、多渠道触达以及优化转化路径，从而实现高效的市场推广和客户转化。数据驱动原理和机制数据驱动的核心在于通过分析用户行为数据，挖掘潜在客户的需求和喜好，从而制定更加精准的
分布式全局唯一ID生成：雪花算法 vs Redis Increment，怎么选？
雪花算法vsRedisIncrement：分布式全局唯一ID生成方案深度对比在分布式系统开发中，“全局唯一ID”是绕不开的核心问题。无论是分库分表的数据库设计、订单编号的唯一性保证，还是日志追踪的链路标识，都需要一套可靠的ID生成方案。今天我们就来聊聊两种主流方案——雪花算法（Snowflake）和RedisIncrement，并从原理、特性到适用场景，帮你理清如何选择。同时，我们还将对比其他常见
[黑洞与暗粒子]没有光的世界 comsci
无论是相对论还是其它现代物理学,都显然有个缺陷,那就是必须有光才能够计算但是,我相信,在我们的世界和宇宙平面中,肯定存在没有光的世界.... 那么,在没有光的世界,光子和其它粒子的规律无法被应用和考察,那么以光速为核心的 &nbs
jQuery Lazy Load 图片延迟加载 aijuans jquery
基于 jQuery 的图片延迟加载插件，在用户滚动页面到图片之后才进行加载。对于有较多的图片的网页，使用图片延迟加载，能有效的提高页面加载速度。版本： jQuery v1.4.4+ jQuery Lazy Load v1.7.2 注意事项：需要真正实现图片延迟加载，必须将真实图片地址写在 data-original 属性中。若 src
使用Jodd的优点 Kai_Ge jodd
1. 简化和统一 controller ，抛弃 extends SimpleFormController ，统一使用 implements Controller 的方式。 2. 简化 JSP 页面的 bind, 不需要一个字段一个字段的绑定。 3. 对 bean 没有任何要求，可以使用任意的 bean 做为 formBean。使用方法简介
jpa Query转hibernate Query 120153216 Hibernate
public List<Map> getMapList(String hql, Map map) { org.hibernate.Query jpaQuery = entityManager.createQuery(hql); if (null != map) { for (String parameter : map.keySet()) { jp
Django_Python3添加MySQL/MariaDB支持 2002wmj mariaDB
现状首先，[email protected] 中默认的引擎为 django.db.backends.mysql 。但是在Python3中如果这样写的话，会发现 django.db.backends.mysql 依赖 MySQLdb[5] ，而 MySQLdb 又不兼容 Python3 于是要找一种新的方式来继续使用MySQL。 MySQL官方的方案首先据MySQL文档[3]说，自从MySQL
在SQLSERVER中查找消耗IO最多的SQL 357029540 SQL Server
返回做IO数目最多的50条语句以及它们的执行计划。 select top 50 (total_logical_reads/execution_count) as avg_logical_reads, (total_logical_writes/execution_count) as avg_logical_writes, (tot
spring UnChecked 异常官方定义！ 7454103 spring
如果你接触过spring的事物管理！那么你必须明白 spring的非捕获异常！即 unchecked 异常！因为 spring 默认这类异常事物自动回滚！！ public static boolean isCheckedException(Throwable ex) { return !(ex instanceof RuntimeExcep
mongoDB 入门指南、示例 adminjun java mongodb 操作
一、准备工作 1、下载mongoDB 下载地址：http://www.mongodb.org/downloads 选择合适你的版本相关文档：http://www.mongodb.org/display/DOCS/Tutorial 2、安装mongoDB A、不解压模式：将下载下来的mongoDB-xxx.zip打开，找到bin目录，运行mongod.exe就可以启动服务，默
CUDA 5 Release Candidate Now Available aijuans CUDA
The CUDA 5 Release Candidate is now available at http://developer.nvidia.com/<wbr></wbr>cuda/cuda-pre-production. Now applicable to a broader set of algorithms, CUDA 5 has advanced fe
Essential Studio for WinRT网格控件测评 Axiba JavaScript html5
Essential Studio for WinRT界面控件包含了商业平板应用程序开发中所需的所有控件，如市场上运行速度最快的grid 和chart、地图、RDL报表查看器、丰富的文本查看器及图表等等。同时，该控件还包含了一组独特的库，用于从WinRT应用程序中生成Excel、Word以及PDF格式的文件。此文将对其另外一个强大的控件——网格控件进行专门的测评详述。网格控件功能 1、
java 获取windows系统安装的证书或证书链 bewithme windows
有时需要获取windows系统安装的证书或证书链，比如说你要通过证书来创建java的密钥库。有关证书链的解释可以查看此处。 public static void main(String[] args) { SunMSCAPI providerMSCAPI = new SunMSCAPI(); S
NoSQL数据库之Redis数据库管理(set类型和zset类型) bijian1013 redis 数据库 NoSQL
4.sets类型 Set是集合，它是string类型的无序集合。set是通过hash table实现的，添加、删除和查找的复杂度都是O(1)。对集合我们可以取并集、交集、差集。通过这些操作我们可以实现sns中的好友推荐和blog的tag功能。 sadd：向名称为key的set中添加元
异常捕获何时用Exception，何时用Throwable bingyingao
用Exception的情况 try { //可能发生空指针、数组溢出等异常 } catch (Exception e) {
【Kafka四】Kakfa伪分布式安装 bit1129 kafka
在http://bit1129.iteye.com/blog/2174791一文中，实现了单Kafka服务器的安装，在Kafka中，每个Kafka服务器称为一个broker。本文简单介绍下，在单机环境下Kafka的伪分布式安装和测试验证 1. 安装步骤 Kafka伪分布式安装的思路跟Zookeeper的伪分布式安装思路完全一样，不过比Zookeeper稍微简单些(不
Project Euler bookjovi haskell
Project Euler是个数学问题求解网站，网站设计的很有意思，有很多problem，在未提交正确答案前不能查看problem的overview，也不能查看关于problem的discussion thread，只能看到现在problem已经被多少人解决了，人数越多往往代表问题越容易。看看problem 1吧： Add all the natural num
Java-Collections Framework学习与总结-ArrayDeque BrokenDreams Collections
表、栈和队列是三种基本的数据结构，前面总结的ArrayList和LinkedList可以作为任意一种数据结构来使用，当然由于实现方式的不同，操作的效率也会不同。这篇要看一下java.util.ArrayDeque。从命名上看
读《研磨设计模式》-代码笔记-装饰模式-Decorator bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.io.BufferedOutputStream; import java.io.DataOutputStream; import java.io.FileOutputStream; import java.io.Fi
Maven学习(一) chenyu19891124 Maven私服
学习一门技术和工具总得花费一段时间，5月底6月初自己学习了一些工具，maven+Hudson+nexus的搭建，对于maven以前只是听说，顺便再自己的电脑上搭建了一个maven环境，但是完全不了解maven这一强大的构建工具，还有ant也是一个构建工具，但ant就没有maven那么的简单方便，其实简单点说maven是一个运用命令行就能完成构建，测试，打包，发布一系列功
[原创]JWFD工作流引擎设计----节点匹配搜索算法(用于初步解决条件异步汇聚问题) 补充 comsci 算法工作 PHP 搜索引擎嵌入式
本文主要介绍在JWFD工作流引擎设计中遇到的一个实际问题的解决方案，请参考我的博文"带条件选择的并行汇聚路由问题"中图例A2描述的情况(http://comsci.iteye.com/blog/339756),我现在把我对图例A2的一个解决方案公布出来，请大家多指点节点匹配搜索算法(用于解决标准对称流程图条件汇聚点运行控制参数的算法) 需要解决的问题：已知分支
Linux中用shell获取昨天、明天或多天前的日期 daizj linux shell 上几年昨天获取上几个月
在Linux中可以通过date命令获取昨天、明天、上个月、下个月、上一年和下一年 # 获取昨天 date -d 'yesterday' # 或 date -d 'last day' # 获取明天 date -d 'tomorrow' # 或 date -d 'next day' # 获取上个月 date -d 'last month' #
我所理解的云计算 dongwei_6688 云计算
在刚开始接触到一个概念时，人们往往都会去探寻这个概念的含义，以达到对其有一个感性的认知，在Wikipedia上关于“云计算”是这么定义的，它说： Cloud computing is a phrase used to describe a variety of computing co
YII CMenu配置 dcj3sjt126com yii
Adding id and class names to CMenu We use the id and htmlOptions to accomplish this. Watch. //in your view $this->widget('zii.widgets.CMenu', array( 'id'=>'myMenu', 'items'=>$this-&g
设计模式之静态代理与动态代理 come_for_dream 设计模式
静态代理与动态代理代理模式是java开发中用到的相对比较多的设计模式，其中的思想就是主业务和相关业务分离。所谓的代理设计就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如我们在进行删除操作的时候需要检验一下用户是否登陆，我们可以删除看成主业务，而把检验用户是否登陆看成其相关业务
【转】理解Javascript 系列 gcc2ge JavaScript
理解Javascript_13_执行模型详解摘要: 在《理解Javascript_12_执行模型浅析》一文中,我们初步的了解了执行上下文与作用域的概念，那么这一篇将深入分析执行上下文的构建过程，了解执行上下文、函数对象、作用域三者之间的关系。函数执行环境简单的代码:当调用say方法时，第一步是创建其执行环境，在创建执行环境的过程中，会按照定义的先后顺序完成一系列操作:1.首先会创建一个
Subsets II hcx2013 set
Given a collection of integers that might contain duplicates, nums, return all possible subsets. Note: Elements in a subset must be in non-descending order. The solution set must not conta
Spring4.1新特性——Spring缓存框架增强 jinnianshilongnian spring4
目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
shell嵌套expect执行命令 liyonghui160com
一直都想把expect的操作写到bash脚本里,这样就不用我再写两个脚本来执行了,搞了一下午终于有点小成就,给大家看看吧. 系统:centos 5.x 1.先安装expect yum -y install expect 2.脚本内容: cat auto_svn.sh #!/bin/bash
Linux实用命令整理 pda158 linux
0. 基本命令　　linux 基本命令整理　　1. 压缩解压　　tar -zcvf a.tar.gz a #把a压缩成a.tar.gz 　　tar -zxvf a.tar.gz #把a.tar.gz解压成a 　　2. vim小结　　2.1 vim替换　　:m,ns/word_1/word_2/gc
独立开发人员通向成功的29个小贴士 shoothao 独立开发
概述：本文收集了关于独立开发人员通向成功需要注意的一些东西,对于具体的每个贴士的注解有兴趣的朋友可以查看下面标注的原文地址。明白你从事独立开发的原因和目的。保持坚持制定计划的好习惯。万事开头难，第一份订单是关键。培养多元化业务技能。提供卓越的服务和品质。谨小慎微。营销是必备技能。学会组织，有条理的工作才是最有效率的。 “独立
JAVA中堆栈和内存分配原理 uule java
1、栈、堆 1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）3. 堆：存放所有new出来的对象。4. 静态域：存放静态成员（static定义的）5. 常量池：存放字符串常量和基本类型常量（public static f

Android Retrofit 框架注解定义与解析模块深度剖析(一)

一、引言

二、Retrofit 框架概述

2.1 Retrofit 的基本工作流程

2.2 注解在 Retrofit 中的作用

三、Retrofit 注解的定义

3.1 HTTP 请求方法注解

3.1.1 @GET 注解

3.1.2 其他 HTTP 请求方法注解

3.2 请求路径与参数注解

3.2.1 @Path 注解

3.2.2 @Query 和 @QueryMap 注解

3.2.3 @Header 和 @HeaderMap 注解

3.2.4 @Body 注解

3.2.5 @FormUrlEncoded、@Field 和 @FieldMap 注解

3.2.6 @Multipart、@Part 和 @PartMap 注解

3.3 其他注解

3.3.1 @Headers 注解

四、Retrofit 注解的解析

4.1 解析入口：ServiceMethod 类

4.2 解析请求方法和路径注解：RequestFactory.Builder.parseMethodAnnotation 方法

4.3 解析参数注解：RequestFactory.Builder.parseParameter 方法

4.3 解析参数注解：RequestFactory.Builder.parseParameter 方法（续）

4.3.1 详细解析逻辑

4.4 创建 RequestFactory 实例

4.5 创建 CallAdapter 和 Converter 实例

4.5.1 CallAdapter 实例创建

4.5.2 Converter 实例创建

4.6 创建 ServiceMethod 实例

五、注解解析后的使用

六、总结

你可能感兴趣的:(Android,Retrofit原理,android,retrofit)

3.1.1 `@GET` 注解

3.2.1 `@Path` 注解

3.2.2 `@Query` 和 `@QueryMap` 注解

3.2.3 `@Header` 和 `@HeaderMap` 注解

3.2.4 `@Body` 注解

3.2.5 `@FormUrlEncoded`、`@Field` 和 `@FieldMap` 注解

3.2.6 `@Multipart`、`@Part` 和 `@PartMap` 注解

3.3.1 `@Headers` 注解

4.1 解析入口：`ServiceMethod` 类

4.2 解析请求方法和路径注解：`RequestFactory.Builder.parseMethodAnnotation` 方法

4.3 解析参数注解：`RequestFactory.Builder.parseParameter` 方法

4.3 解析参数注解：`RequestFactory.Builder.parseParameter` 方法（续）

4.4 创建 `RequestFactory` 实例

4.5 创建 `CallAdapter` 和 `Converter` 实例

4.5.1 `CallAdapter` 实例创建

4.5.2 `Converter` 实例创建

4.6 创建 `ServiceMethod` 实例