使用Micronaut Serialization反序列化泛型，消除unchecked警告

要消除unchecked assignment警告，核心是让编译器能明确识别泛型类型的安全性，无需依赖@SuppressWarnings注解。以下是两种可行方案：

方案一：使用泛型化的Argument.of调用 #

直接指定Argument的泛型类型，让编译器知晓返回值的具体泛型信息：

import io.micronaut.context.annotation.Prototype;
import io.micronaut.core.type.Argument;
import io.micronaut.serde.ObjectMapper;
import jakarta.inject.Inject;
import java.io.IOException;
import java.util.Optional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.invoke.MethodHandles;

@Prototype
public class Scratch {
    private static final Logger LOG = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
    private final ObjectMapper objectMapper;

    @Inject
    public Scratch(ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }

    private Optional<CommonResponse<JobResponse>> getCommonResponse(final String entry) {
        try {
            // 明确指定Argument的泛型类型，让编译器识别返回值类型
            Argument<CommonResponse<JobResponse>> responseType = 
                Argument.<CommonResponse<JobResponse>>of(CommonResponse.class, JobResponse.class);
            return Optional.of(objectMapper.readValue(entry, responseType));
        } catch (IOException e) {
            LOG.warn("Could not deserialize, skipping entry: '{}'", entry, e);
        }
        return Optional.empty();
    }
}

方案二：使用ArgumentBuilder构建类型 #

通过ArgumentBuilder更清晰地声明泛型参数，同样能让编译器确认类型安全性：

import io.micronaut.context.annotation.Prototype;
import io.micronaut.core.type.Argument;
import io.micronaut.serde.ObjectMapper;
import jakarta.inject.Inject;
import java.io.IOException;
import java.util.Optional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.invoke.MethodHandles;

@Prototype
public class Scratch {
    private static final Logger LOG = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
    private final ObjectMapper objectMapper;

    @Inject
    public Scratch(ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }

    private Optional<CommonResponse<JobResponse>> getCommonResponse(final String entry) {
        try {
            // 用ArgumentBuilder明确指定泛型变量T的类型
            Argument<CommonResponse<JobResponse>> responseType = Argument.builder(CommonResponse.class)
                .typeVariable("T", JobResponse.class)
                .build();
            return Optional.of(objectMapper.readValue(entry, responseType));
        } catch (IOException e) {
            LOG.warn("Could not deserialize, skipping entry: '{}'", entry, e);
        }
        return Optional.empty();
    }
}

原理说明 #

原代码中Argument.of(CommonResponse.class, JobResponse.class)返回的是Argument<CommonResponse>（不带具体泛型参数），objectMapper.readValue会返回CommonResponse类型，强制转换为CommonResponse<JobResponse>时编译器无法验证泛型参数的安全性，因此抛出警告。通过明确指定Argument的泛型类型，让编译器能跟踪到泛型参数T的实际类型是JobResponse，从而消除unchecked警告。

内容的提问来源于stack exchange，提问作者jonas