Google 移动端基建踩坑：GCP 与 Firebase 项目关系

Thu, 26 Feb 2026 09:59:33 +0800

接入 Google 登录、Firebase Analytics、Crashlytics、FCM 等能力时，经常会遇到一个割裂感：有些配置在 GCP，有些配置在 Firebase，包名和 SHA-1 又会触发全局唯一性冲突。

这篇复盘的重点是理清 GCP 与 Firebase 的项目关系，避免以后重复踩坑。

问题现象

常见表现：

已经在 GCP 创建 OAuth Client，Firebase 再添加 Android 应用时报冲突；
Firebase Analytics 正常，但 Google 登录失败；
Debug / Release SHA-1 配置不完整，导致某个构建变体不可用；
google-services.json 下载了，但 Web Client ID 和预期不一致；
同一个包名 + SHA-1 被绑定到另一个 Google 项目。

根因

Firebase 项目底层一定绑定一个 Google Cloud 项目。

可以理解成：

Firebase Console
 -> 更面向移动端开发者的入口
 -> 底层绑定 GCP Project
 -> 间接创建 OAuth Client / API 配置

Google Cloud Console
 -> 更底层的云资源入口
 -> 管理 API、OAuth、服务账号、权限

问题通常出在：一开始直接在 GCP 创建了项目和 OAuth Client，后来又在 Firebase 创建了另一个项目。此时同一个 Android 应用的包名和 SHA-1 已经被前一个项目占用，Firebase 再注册就会冲突。

排查清单

遇到登录或 Firebase 配置异常时，按这个顺序看：

当前 applicationId 是否和 Firebase 里注册的一致；
Debug/Release 使用的 keystore 是否都配置了 SHA-1；
google-services.json 是否来自当前 Firebase 项目；
GCP OAuth Client 是否属于同一个底层 GCP 项目；
是否存在另一个历史项目占用了相同包名和 SHA-1；
Google Sign-In 使用的 Web Client ID 是否正确。

迁移建议

如果已经出现项目分裂：

先确认线上正在使用哪个 Firebase/GCP 项目；
不要直接删除历史 OAuth Client；
记录所有 Debug/Release keystore 指纹；
统一到一个 Firebase 项目；
必要时在 GCP 中清理旧 Client 或重新绑定；
重新下载并替换 google-services.json。

回看清单

Firebase 项目底层绑定 GCP 项目。
同一个包名 + SHA-1 不应该分散注册到多个项目。
接入移动端 Google 能力时，优先从 Firebase 创建项目。
高级 API 再进入 Firebase 绑定的 GCP 项目开启。
google-services.json、OAuth Client 和 SHA-1 必须属于同一套项目关系。

一次 Gson 解析导致 NPE 的排查

Wed, 05 Nov 2025 13:20:21 +0800

这是一篇问题复盘。核心问题不是 Gson “解析失败”，而是它成功创建了对象，却让 Kotlin 非空字段处在不可信状态，最终在业务代码里触发 NPE。

核心结论

Kotlin 的非空类型主要是编译期约束，反射/反序列化框架可能绕过构造函数。
Gson 可以在不调用主构造函数的情况下创建对象，因此默认值和 init 逻辑不一定执行。
修复不能只靠业务层判空，应该在反序列化边界处理异常数据。
自定义 TypeAdapter 或替换序列化方案时，要关注 Factory 注册顺序。
数据模型越靠近外部输入，越应该显式表达可空和默认值。

问题描述

使用Gson库解析出Kotlin对象时，其中的非空变量在使用时意外的出现了NPE。

问题定位

Gson为了性能，使用了Unsafe.allocateInstance()直接分配内存创建对象，绕过了构造函数。而Kotlin的非空检查是在构造函数里做的，所以非空检查被绕过了。

解决思路

给DataClass的所有字段加默认值，使其具备默认构造函数
或者自定义TypeAdapterFactory

Gson的核心架构

整体流程

JSON字符串
↓
JsonReader (逐个读取token)
↓
TypeAdapter (解析并构造对象)
↓
Java/Kotlin对象

Gson的三层架构

// 1. Gson - 入口
Gson gson = new Gson();
User user = gson.fromJson(json, User.class);

// 2. TypeAdapter - 具体的序列化/反序列化逻辑
TypeAdapter<User> adapter = gson.getAdapter(User.class);
User user = adapter.read(jsonReader);

// 3. TypeAdapterFactory - 创建TypeAdapter的工厂
TypeAdapterFactory factory = new MyTypeAdapterFactory();
TypeAdapter<User> adapter = factory.create(gson, TypeToken.get(User.class));

TypeAdapter的核心方法

public abstract class TypeAdapter<T> {

 /**
 * 从JSON读取,构造对象(反序列化)
 */
 public abstract T read(JsonReader in) throws IOException;

 /**
 * 将对象写入JSON(序列化)
 */
 public abstract void write(JsonWriter out, T value) throws IOException;

 /**
 * 从JSON字符串反序列化
 */
 public final T fromJson(String json) {
 return read(new JsonReader(new StringReader(json)));
 }

 /**
 * 序列化为JSON字符串
 */
 public final String toJson(T value) {
 StringWriter writer = new StringWriter();
 write(new JsonWriter(writer), value);
 return writer.toString();
 }
}

Gson的反序列化流程

先尝试无参构造函数
失败后用Unsafe.allocateInstance()直接分配内存
通过反射设置字段值

自定义TypeAdapter

TypeAdapterFactory

class NullSafeTypeAdapterFactory : TypeAdapterFactory {

 override fun <T> create(gson: Gson, type: TypeToken<T>): TypeAdapter<T>? {
 val rawType = type.rawType

 // 只处理Kotlin的Data Class
 if (!rawType.isKotlinClass()) {
 return null
 }

 // 获取Gson的默认Adapter
 val delegateAdapter = gson.getDelegateAdapter(this, type)

 // 包装一层,处理null值
 return NullSafeTypeAdapter(delegateAdapter, rawType)
 }
}

class NullSafeTypeAdapter<T>(
 private val delegate: TypeAdapter<T>,
 private val rawType: Class<*>
) : TypeAdapter<T>() {

 override fun read(reader: JsonReader): T {
 // 先用代理Adapter读取
 val result = delegate.read(reader)

 // 检查非空字段
 if (result != null) {
 checkNonNullFields(result)
 }

 return result
 }

 override fun write(writer: JsonWriter, value: T?) {
 delegate.write(writer, value)
 }

 /**
 * 检查非空字段是否真的非空
 */
 private fun checkNonNullFields(obj: Any) {
 val kClass = rawType.kotlin

 // 获取所有构造函数参数(Data Class的属性)
 val constructor = kClass.primaryConstructor ?: return

 for (param in constructor.parameters) {
 // 检查是否非空类型
 if (!param.type.isMarkedNullable) {
 // 获取字段值
 val field = rawType.getDeclaredField(param.name)
 field.isAccessible = true
 val value = field.get(obj)

 // 如果是null,抛异常或设置默认值
 if (value == null) {
 // 方案1:抛异常
 throw JsonParseException(
 "Non-null field '${param.name}' was null in ${rawType.simpleName}"
 )

 // 方案2:设置默认值(需要反射改字段)
 // field.set(obj, getDefaultValue(param.type))
 }
 }
 }
 }
}

// 扩展函数:判断是否Kotlin类
fun Class<*>.isKotlinClass(): Boolean {
 return this.declaredAnnotations.any {
 it.annotationClass.qualifiedName == "kotlin.Metadata"
 }
}

注册Factory

val gson = GsonBuilder()
 .registerTypeAdapterFactory(NullSafeTypeAdapterFactory())
 .create()

// 所有Data Class都会被自动处理
val user = gson.fromJson(json, User::class.java)
val product = gson.fromJson(json, Product::class.java)

Gson如何选择TypeAdapter

完整流程

// 用户调用
gson.fromJson(json, User.class)

// Gson内部
public <T> T fromJson(String json, Class<T> classOfT) {
 // 1. 包装成TypeToken
 TypeToken<T> typeToken = TypeToken.get(classOfT);

 // 2. 获取TypeAdapter
 TypeAdapter<T> adapter = getAdapter(typeToken);

 // 3. 反序列化
 return adapter.fromJson(json);
}

getAdapter的逻辑

// Gson.java (简化版)
public class Gson {

 // 所有注册的Factory,按顺序排列
 private final List<TypeAdapterFactory> factories;

 // TypeAdapter缓存
 private final Map<TypeToken<?>, TypeAdapter<?>> typeTokenCache =
 new ConcurrentHashMap<>();

 public <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {
 // 1. 先从缓存取
 TypeAdapter<T> cached = (TypeAdapter<T>) typeTokenCache.get(type);
 if (cached != null) {
 return cached;
 }

 // 2. 遍历所有Factory,找到第一个能处理的
 for (TypeAdapterFactory factory : factories) {
 TypeAdapter<T> adapter = factory.create(this, type);

 if (adapter != null) {
 // 3. 找到了,缓存起来
 typeTokenCache.put(type, adapter);
 return adapter;
 }
 }

 // 4. 都找不到,抛异常
 throw new IllegalArgumentException("Cannot handle " + type);
 }
}

Factory的注册顺序

// GsonBuilder.java
public Gson create() {
 List<TypeAdapterFactory> factories = new ArrayList<>();

 // 1. 用户自定义的Factory (最高优先级!)
 factories.addAll(this.factories);

 // 2. 用户通过registerTypeAdapter注册的
 factories.add(new TypeAdapters.newFactory(type, adapter));

 // 3. Gson内置的基础类型Factory
 factories.add(TypeAdapters.STRING_FACTORY); // String
 factories.add(TypeAdapters.INTEGER_FACTORY); // Integer
 factories.add(TypeAdapters.BOOLEAN_FACTORY); // Boolean
 // ... 其他基础类型

 // 4. Collection类型
 factories.add(new CollectionTypeAdapterFactory());

 // 5. Map类型 
 factories.add(new MapTypeAdapterFactory());

 // 6. 数组类型
 factories.add(new ArrayTypeAdapterFactory());

 // 7. Enum类型
 factories.add(new EnumTypeAdapterFactory());

 // 8. 反射类型 (最低优先级,兜底方案!)
 factories.add(new ReflectiveTypeAdapterFactory());

 return new Gson(factories);
}

关键:

你自定义的Factory优先级最高
ReflectiveTypeAdapterFactory是兜底,处理所有普通Java/Kotlin对象
调用getDelegateAdapter,让后面的Factory处理,可以做到增强factory

Troubleshooting on zed的博客