问使用spring-data-mongodb资源持久化路径对象
EN

Stack Overflow用户

提问于 2021-09-22 03:53:34

回答 1查看 285关注 0票数 0

在一个项目中，我使用spring-boot-starter-data-mongodb:2.5.3，因此使用spring-data-mongodb:3.2.3，并有一个简化的实体类如下所示：

@Document
public class Task {
  @Id
  private final String id;
  private final Path taskDir;
  ...

  // constructor, getters, setters
}

使用默认的Spring MongoDB存储库，允许通过其id检索任务。

Mongo配置看起来是这样的：

@Configuration
@EnableMongoRepositories(basePackages = {
    "path.to.repository"
}, mongoTemplateRef = MongoConfig.MONGO_TEMPLATE_REF)
@EnableConfigurationProperties(MongoSettings.class)
public class MongoConfig extends MongoConfigurationSupport {

  private static final Logger LOG = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
  public static final String MONGO_TEMPLATE_REF = "mongoAlTemplate";

  private final MongoSettings mongoSettings;

  @Autowired
  public MongoConfig(final MongoSettings mongoSettings) {
    this.mongoSettings = mongoSettings;
  }

  @Bean(name = "ourMongo", destroyMethod = "close")
  public MongoClient ourMongoClient() {
    MongoCredential credential =
        MongoCredential.createCredential(mongoSettings.getUser(),
                                         mongoSettings.getDb(),
                                         mongoSettings.getPassword());
    MongoClientSettings clientSettings = MongoClientSettings.builder()
        .readPreference(ReadPreference.primary())
        // enable optimistic locking for @Version and eTag usage
        .writeConcern(WriteConcern.ACKNOWLEDGED)
        .credential(credential)
        .applyToSocketSettings(
            builder -> builder.connectTimeout(15, TimeUnit.SECONDS)
                .readTimeout(1, TimeUnit.MINUTES))
        .applyToConnectionPoolSettings(
            builder -> builder.maxConnectionIdleTime(10, TimeUnit.MINUTES)
                .minSize(5).maxSize(20))
//        .applyToClusterSettings(
//            builder -> builder.requiredClusterType(ClusterType.REPLICA_SET)
//                .hosts(Arrays.asList(new ServerAddress("host1", 27017),
//                                     new ServerAddress("host2", 27017)))
//                .build())
        .build();
    return MongoClients.create(clientSettings);
  }

  @Override
  @Nonnull
  protected String getDatabaseName() {
    return mongoSettings.getDb();
  }

  @Bean(name = MONGO_TEMPLATE_REF)
  public MongoTemplate ourMongoTemplate() throws Exception {
    return new MongoTemplate(ourMongoClient(), getDatabaseName());
  }
}

如果试图通过taskRepository.save(task)保存任务，StackOverflowError就会结束

java.lang.StackOverflowError
    at java.lang.ThreadLocal.get(ThreadLocal.java:160)
    at java.util.concurrent.locks.ReentrantReadWriteLock$Sync.tryReleaseShared(ReentrantReadWriteLock.java:423)
    at java.util.concurrent.locks.AbstractQueuedSynchronizer.releaseShared(AbstractQueuedSynchronizer.java:1341)
    at java.util.concurrent.locks.ReentrantReadWriteLock$ReadLock.unlock(ReentrantReadWriteLock.java:881)
    at org.springframework.data.mapping.context.AbstractMappingContext.getPersistentEntity(AbstractMappingContext.java:239)
    at org.springframework.data.mapping.context.AbstractMappingContext.getPersistentEntity(AbstractMappingContext.java:201)
    at org.springframework.data.mapping.context.AbstractMappingContext.getPersistentEntity(AbstractMappingContext.java:87)
    at org.springframework.data.mapping.context.MappingContext.getRequiredPersistentEntity(MappingContext.java:73)
    at org.springframework.data.mongodb.core.convert.MappingMongoConverter.writePropertyInternal(MappingMongoConverter.java:740)
    at org.springframework.data.mongodb.core.convert.MappingMongoConverter.writeProperties(MappingMongoConverter.java:657)
    at org.springframework.data.mongodb.core.convert.MappingMongoConverter.writeInternal(MappingMongoConverter.java:633)
    at org.springframework.data.mongodb.core.convert.MappingMongoConverter.writePropertyInternal(MappingMongoConverter.java:746)
    at org.springframework.data.mongodb.core.convert.MappingMongoConverter.writeProperties(MappingMongoConverter.java:657)
    at org.springframework.data.mongodb.core.convert.MappingMongoConverter.writeInternal(MappingMongoConverter.java:633)
    ...

在用taskDir对Task类中的path对象@Transient进行注释时，我能够持久化任务，因此问题似乎与Java/Spring/MongoDB无法直接处理Path对象有关。

我的下一个尝试是在MongoConfig类中配置一个自定义转换器，以便在Path和String表示之间进行转换：

@Override
protected void configureConverters(
  MongoCustomConversions.MongoConverterConfigurationAdapter converterConfigurationAdapter) {
  LOG.info("configuring converters");
  converterConfigurationAdapter.registerConverter(new Converter<Path, String>() {
    @Override
    public String convert(@Nonnull Path path) {
      return path.normalize().toAbsolutePath().toString();
    }
  });
  converterConfigurationAdapter.registerConverter(new Converter<String, Path>() {
    @Override
    public Path convert(@Nonnull String path) {
      return Paths.get(path);
    }
  });
}

尽管错误依然存在。然后，我定义了Task对象和DBObject之间的直接转换，如在这个指南中所示。

@Override
protected void configureConverters(
  MongoCustomConversions.MongoConverterConfigurationAdapter converterConfigurationAdapter) {
  LOG.info("configuring converters");
  converterConfigurationAdapter.registerConverter(new Converter<Task, DBObject>() {
    @Override
    public DBObject convert(@Nonnull Task source) {
    DBObject dbObject = new BasicDBObject();
      if (source.getTaskDirectory() != null) {
        dbObject.put("taskDir", source.getTaskDirectory().normalize().toAbsolutePath().toString());
      }
      ...
      return dbObject;
    }
  });
}

我还得到了StackOverflowError作为回报。通过我添加的log语句，我看到Spring调用了configureConverters方法，因此应该已经注册了自定义转换器。

为什么我还能拿到StackOverflowError呢？如何告诉Spring在持久化和读取时将Path对象视为String对象，将String值再次转换为Path对象？

更新：

现在，我遵循了正式文件中给出的示例，并将转换器重构为自己的类

import org.bson.Document;
import org.springframework.core.convert.converter.Converter;
import org.springframework.data.convert.WritingConverter;

import javax.annotation.Nonnull;

@WritingConverter
public class TaskWriteConverter implements Converter<Task, Document> {

  @Override
  public Document convert(@Nonnull Task source) {
    Document document = new Document();
    document.put("_id", source.getId());
    if (source.getTaskDir() != null) {
      document.put("taskDir", source.getTaskDir().normalize().toAbsolutePath().toString());
    }
    return document;
  }
}

MongoConfig类中的配置现在如下所示：

  @Override
  protected void configureConverters(
      MongoCustomConversions.MongoConverterConfigurationAdapter adapter) {
    LOG.info("configuring converters");
    adapter.registerConverter(new TaskWriteConverter());
    adapter.registerConverter(new TaskReadConverter());
    adapter.registerConverter(new Converter<Path, String>() {
      @Override
      public String convert(@Nonnull Path path) {
        return path.normalize().toAbsolutePath().toString();
      }
    });
    adapter.registerConverter(new Converter<String, Path>() {
      @Override
      public Path convert(@Nonnull String path) {
        return Paths.get(path);
      }
    });
  }

在将org.springframework.data的日志记录级别更改为debug之后，我在日志中看到，这些转换器也被选中：

2021-09-23 14:09:20.469 [INFO ] [           main] MongoConfig                              configuring converters 
2021-09-23 14:09:20.480 [DEBUG] [           main] CustomConversions                        Adding user defined converter from class com.acme.Task to class org.bson.Document as writing converter. 
2021-09-23 14:09:20.480 [DEBUG] [           main] CustomConversions                        Adding user defined converter from class org.bson.Document to class com.acme.Task as reading converter. 
2021-09-23 14:09:20.481 [DEBUG] [           main] CustomConversions                        Adding user defined converter from interface java.nio.file.Path to class java.lang.String as writing converter. 
2021-09-23 14:09:20.481 [DEBUG] [           main] CustomConversions                        Adding user defined converter from class java.lang.String to interface java.nio.file.Path as reading converter.

但是，我看到大多数转换器都是多次添加的，也就是说，在应用程序访问存储库上的Adding converter from class java.lang.Character to class java.lang.String as writing converter.方法之前，我实际上已经为save找到了4次日志。由于我的自定义转换器仅在所有这些转换器第三次出现在日志中时才被添加，因此我感觉它们在某种程度上被改写为上次“迭代”中的日志--不包括我的自定义转换器。

再现该问题的测试用例如下：

@ŚpringBootTest
@AutoConfigureMockMvc
@PropertySource("classpath:application-test.properties")
public class SomeIT {
  
  @Autowired
  private TaskRepository taskRepository;
  ...


  @Test
  public void testTaskPersistence() throws Exception {
    Task task = new Task("1234", Paths.get("/home/roman"));
    taskRepository.save(task);
  }

   ...
}

测试方法只用于调查当前的持久性问题，在正常情况下根本不应该存在，因为集成测试一个大文件的上传、它的预处理等等。但是，由于Spring无法存储包含Path对象的实体，这个集成测试失败了。

请注意，对于简单的实体，我在使用概述的设置来持久化它们方面没有问题，而且我也在被文档化的MongoDB中看到了它们。

我还没有时间深入研究为什么Spring在Path对象中会出现这样的问题，或者为什么我的自定义转换器在CustomConversions日志输出的最后一次迭代中突然消失了。

java

spring-data-mongodb

云点播特惠1元起

提供制作上传、存储、转码、媒体处理、媒体 AI、加速分发播放、版权保护等一体化的高品质媒体服务

回答 1

Stack Overflow用户

回答已采纳

发布于 2021-09-24 05:28:30

事实证明，配置mongoTemplate的方式会“覆盖”任何指定的自定义转换器，因此Spring无法使用这些转换器并将Path转换为String，反之亦然。

在将MongoConfig更改为下面的一个之后，我终于能够使用我的自定义转换器，从而按预期持久化实体：

@Configuration
@EnableMongoRepositories(basePackages = {
    "path.to.repository"
}, mongoTemplateRef = MongoConfig.MONGO_TEMPLATE_REF)
@EnableConfigurationProperties(MongoSettings.class)
public class MongoConfig extends MongoConfigurationSupport {

  private static final Logger LOG = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
  public static final String MONGO_TEMPLATE_REF = "mongoAlTemplate";

  private final MongoSettings mongoSettings;

  @Autowired
  public MongoConfig(final MongoSettings mongoSettings) {
    this.mongoSettings = mongoSettings;
  }

  @Bean(name = "ourMongo", destroyMethod = "close")
  public MongoClient ourMongoClient() {
    MongoCredential credential =
        MongoCredential.createCredential(mongoSettings.getUser(),
                                         mongoSettings.getDb(),
                                         mongoSettings.getPassword());
    MongoClientSettings clientSettings = MongoClientSettings.builder()
        .readPreference(ReadPreference.primary())
        // enable optimistic locking for @Version and eTag usage
        .writeConcern(WriteConcern.ACKNOWLEDGED)
        .credential(credential)
        .applyToSocketSettings(
            builder -> builder.connectTimeout(15, TimeUnit.SECONDS)
                .readTimeout(1, TimeUnit.MINUTES))
        .applyToConnectionPoolSettings(
            builder -> builder.maxConnectionIdleTime(10, TimeUnit.MINUTES)
                .minSize(5).maxSize(20))
//        .applyToClusterSettings(
//            builder -> builder.requiredClusterType(ClusterType.REPLICA_SET)
//                .hosts(Arrays.asList(new ServerAddress("host1", 27017),
//                                     new ServerAddress("host2", 27017)))
//                .build())
        .build();
    LOG.info("Mongo client initialized. Connecting with user {} to DB {}",
             mongoSettings.getUser(), mongoSettings.getDb());
    return MongoClients.create(clientSettings);
  }

  @Override
  @Nonnull
  protected String getDatabaseName() {
    return mongoSettings.getDb();
  }

  @Bean
  public MongoDatabaseFactory ourMongoDBFactory() {
    return new SimpleMongoClientDatabaseFactory(ourMongoClient(), getDatabaseName());
  }

  @Bean(name = MONGO_TEMPLATE_REF)
  public MongoTemplate ourMongoTemplate() throws Exception {
    return new MongoTemplate(ourMongoDBFactory(), mappingMongoConverter());
  }

  @Bean
  public MappingMongoConverter mappingMongoConverter() throws Exception {
    DbRefResolver dbRefResolver = new DefaultDbRefResolver(ourMongoDBFactory());
    MongoCustomConversions customConversions = customConversions();
    MongoMappingContext context = mongoMappingContext(customConversions);
    MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, context);
    // this one is actually needed otherwise the StackOverflowError re-appears!
    converter.setCustomConversions(customConversions);
    return converter;
  }

  @Bean
  @Override
  @Nonnull
  public MongoCustomConversions customConversions() {
    return  new MongoCustomConversions(
        Arrays.asList(new PathWriteConverter(), new PathReadConverter())
    );
  }
}