Spring JPA映射实体时出现Scala集合替代Java集合问题

排查并排除不必要的Scala依赖 #

• 执行依赖树扫描命令，找出引入Scala类库的传递依赖：

  # Maven
  mvn dependency:tree
  # Gradle
  ./gradlew dependencies
  

• 确认非必需的依赖后，直接排除Scala相关包：

  <!-- Maven排除示例 -->
  <dependency>
    <groupId>第三方依赖groupId</groupId>
    <artifactId>第三方依赖artifactId</artifactId>
    <exclusions>
      <exclusion>
        <groupId>org.scala-lang</groupId>
        <artifactId>scala-library</artifactId>
      </exclusion>
    </exclusions>
  </dependency>
  

  // Gradle排除示例
  implementation('第三方依赖groupId:第三方依赖artifactId') {
      exclude group: 'org.scala-lang', module: 'scala-library'
  }
  

给Jackson添加Scala序列化支持 #

如果无法排除Scala依赖，直接扩展Jackson的序列化能力：

• 引入Jackson Scala模块依赖：

  <!-- Maven -->
  <dependency>
    <groupId>com.fasterxml.jackson.module</groupId>
    <artifactId>jackson-module-scala_2.13</artifactId>
  </dependency>
  

  // Gradle
  implementation 'com.fasterxml.jackson.module:jackson-module-scala_2.13'
  

• 注册模块到Spring的ObjectMapper：

  import com.fasterxml.jackson.module.scala.DefaultScalaModule;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
  
  @Configuration
  public class JacksonConfig {
      @Bean
      public Jackson2ObjectMapperBuilder jackson2ObjectMapperBuilder() {
          return new Jackson2ObjectMapperBuilder().modulesToInstall(DefaultScalaModule.class);
      }
  }
  

手动将Scala集合转为Java集合 #

在数据读取环节强制转换集合类型：

• 在Repository查询后或实体类setter中转换：

  import scala.collection.JavaConverters;
  import java.util.HashMap;
  import java.util.Map;
  
  // 转换示例
  scala.collection.immutable.Map<String, Object> scalaMap = ...;
  Map<String, Object> javaMap = new HashMap<>(JavaConverters.mapAsJavaMap(scalaMap));
  

• 自定义JPA属性转换器，自动完成转换：

  import jakarta.persistence.AttributeConverter;
  import jakarta.persistence.Converter;
  import com.fasterxml.jackson.databind.ObjectMapper;
  import com.fasterxml.jackson.core.type.TypeReference;
  import scala.collection.JavaConverters;
  import java.util.HashMap;
  import java.util.Map;
  
  @Converter(autoApply = true)
  public class ScalaMapConverter implements AttributeConverter<Map<String, Object>, String> {
      private final ObjectMapper objectMapper = new ObjectMapper();
  
      @Override
      public String convertToDatabaseColumn(Map<String, Object> attribute) {
          try {
              return objectMapper.writeValueAsString(attribute);
          } catch (Exception e) {
              throw new RuntimeException("序列化Map失败", e);
          }
      }
  
      @Override
      public Map<String, Object> convertToEntityAttribute(String dbData) {
          try {
              scala.collection.immutable.Map<String, Object> scalaMap = 
                  objectMapper.readValue(dbData, new TypeReference<>() {});
              return new HashMap<>(JavaConverters.mapAsJavaMap(scalaMap));
          } catch (Exception e) {
              throw new RuntimeException("反序列化JSON失败", e);
          }
      }
  }
  

  然后在实体类的JSON字段上添加注解：@Convert(converter = ScalaMapConverter.class)

锁定Jackson为默认JSON解析器 #

在配置文件中明确指定Spring Boot使用Jackson处理JSON，避免被第三方库替换：

spring:
  http:
    converters:
      preferred-json-mapper: jackson

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