Spring Integration

Spring Data MongoDB를 코어 의존성으로 끌어오지 않고 ReactiveMongoTemplate의 mapping, collection naming과 reactive lifecycle을 MongoExecutionContext adapter로 연결합니다.

Spring Data MongoDB는 애플리케이션에서 유지합니다

build.gradle

text

dependencies {
  implementation("com.byeolnaerim:reactive-mongo-dsl:1.0.0")
  implementation("org.springframework.boot:spring-boot-starter-data-mongodb-reactive")
}

코어 라이브러리는 Spring Data MongoDB에 직접 의존하지 않습니다. 기존 Spring 애플리케이션의 ReactiveMongoTemplate 설정을 사용하려면 application layer에서 MongoExecutionContext adapter를 제공합니다.

SpringReactiveMongoExecutionContext adapter

SpringReactiveMongoExecutionContext.java

java

public class SpringReactiveMongoExecutionContext implements MongoExecutionContext {

  private final ReactiveMongoTemplate reactiveMongoTemplate;
  private final MongoClient mongoClient;
  private final MongoConverter mongoConverter;
  private final ReactiveEntityCallbacks entityCallbacks;

  public SpringReactiveMongoExecutionContext(
      ReactiveMongoTemplate reactiveMongoTemplate,
      MongoClient mongoClient,
      ReactiveEntityCallbacks entityCallbacks
  ) {
    this.reactiveMongoTemplate = Objects.requireNonNull(reactiveMongoTemplate);
    this.mongoClient = Objects.requireNonNull(mongoClient);
    this.mongoConverter = reactiveMongoTemplate.getConverter();
    this.entityCallbacks = Objects.requireNonNull(entityCallbacks);
  }

  @Override
  public Mono<MongoDatabase> getDatabase() {
    return reactiveMongoTemplate.getMongoDatabase();
  }

  @Override
  public Mono<ClientSession> startSession() {
    return Mono.from(mongoClient.startSession());
  }

  @Override
  public String getCollectionName(Class<?> entityClass) {
    return reactiveMongoTemplate.getCollectionName(entityClass);
  }

  @Override
  public Document write(Object source) {
    Document document = new Document();
    mongoConverter.write(source, document);
    return document;
  }

  @Override
  public <T> T read(Class<T> targetType, Document source) {
    return mongoConverter.read(targetType, source);
  }

  @Override
  public Object getId(Object entity) {
    MongoPersistentEntity<?> persistentEntity =
        mongoConverter.getMappingContext().getPersistentEntity(entity.getClass());

    if (persistentEntity == null || !persistentEntity.hasIdProperty()) {
      return null;
    }

    Object id = persistentEntity.getIdentifierAccessor(entity).getIdentifier();
    if (id == null) return null;

    Document document = new Document();
    mongoConverter.write(entity, document);
    return document.get("_id");
  }

  @Override
  @SuppressWarnings({ "rawtypes", "unchecked" })
  public void setId(Object entity, Object id) {
    MongoPersistentEntity persistentEntity =
        mongoConverter.getMappingContext().getPersistentEntity(entity.getClass());

    if (persistentEntity == null || !persistentEntity.hasIdProperty()) return;

    MongoPersistentProperty idProperty =
        (MongoPersistentProperty) persistentEntity.getRequiredIdProperty();

    Object targetId = id;
    if (id instanceof ObjectId objectId && idProperty.getType() == String.class) {
      targetId = objectId.toHexString();
    } else if (
        id != null
            && !idProperty.getType().isInstance(id)
            && mongoConverter.getConversionService()
                .canConvert(id.getClass(), idProperty.getType())
    ) {
      targetId = mongoConverter.getConversionService()
          .convert(id, idProperty.getType());
    }

    PersistentPropertyAccessor accessor = persistentEntity.getPropertyAccessor(entity);
    accessor.setProperty(idProperty, targetId);
  }

  @Override
  public <T> Mono<T> beforePersist(T entity, String collectionName) {
    return entityCallbacks.callback(
        ReactiveBeforeConvertCallback.class,
        entity,
        collectionName
    );
  }

  @Override
  public <T> Mono<T> afterPersist(
      T entity,
      Document document,
      String collectionName
  ) {
    return entityCallbacks.callback(
        ReactiveAfterSaveCallback.class,
        entity,
        document,
        collectionName
    );
  }

  @Override
  public Object getSessionScope() {
    return mongoClient;
  }

  @Override
  public Object getNative() {
    return reactiveMongoTemplate;
  }

  @Override
  public <T> T getNative(Class<T> nativeType) {
    if (nativeType.isInstance(reactiveMongoTemplate)) {
      return nativeType.cast(reactiveMongoTemplate);
    }
    if (nativeType.isInstance(mongoClient)) {
      return nativeType.cast(mongoClient);
    }
    return MongoExecutionContext.super.getNative(nativeType);
  }
}

실제 구현에서는 위 클래스에 필요한 Spring/MongoDB import를 추가합니다. 핵심은 entity read/write를 MongoConverter, collection 이름을 ReactiveMongoTemplate, session 시작을 대응하는 MongoClient에 연결하는 것입니다.

Resolver와 DSL Bean 등록

MongoTemplateNameResolver.java

java

@Component
public class MongoTemplateNameResolver
    implements MongoTemplateResolver<MongoTemplateName> {

  private final MongoExecutionContext frontExecutionContext;
  private final MongoExecutionContext backExecutionContext;

  public MongoTemplateNameResolver(
      @Qualifier("frontMongoTemplate") ReactiveMongoTemplate frontTemplate,
      @Qualifier("frontMongoClient") MongoClient frontMongoClient,
      @Qualifier("backMongoTemplate") ReactiveMongoTemplate backTemplate,
      @Qualifier("backMongoClient") MongoClient backMongoClient,
      ApplicationContext applicationContext
  ) {
    ReactiveEntityCallbacks callbacks =
        ReactiveEntityCallbacks.create(applicationContext);

    this.frontExecutionContext = new SpringReactiveMongoExecutionContext(
        frontTemplate, frontMongoClient, callbacks
    );
    this.backExecutionContext = new SpringReactiveMongoExecutionContext(
        backTemplate, backMongoClient, callbacks
    );
  }

  @Override
  public MongoExecutionContext getTemplate(MongoTemplateName key) {
    return switch (key) {
      case FRONT -> frontExecutionContext;
      case BACK -> backExecutionContext;
    };
  }
}

ReactiveMongoDslConfiguration.java

java

@Bean
public ReactiveMongoDsl<MongoTemplateName> reactiveMongoDsl(
    MongoTemplateResolver<MongoTemplateName> resolver
) {
  return new ReactiveMongoDsl<>(resolver);
}

Adapter에서 연결되는 범위

@Document / collection name

ReactiveMongoTemplate#getCollectionName(...)을 사용합니다.

@Id / @Field / custom conversions

entity ↔ Document 변환에 MongoConverter를 사용합니다.

Reactive auditing

beforePersist(...)를 ReactiveBeforeConvertCallback에 연결하면 save() 계열에서 reactive auditing callback이 적용됩니다.

ReactiveAfterSaveCallback

write 성공 뒤 afterPersist(...)에서 호출할 수 있습니다.

Spring QueryMapper

적용되지 않습니다. DSL String field path는 실제 MongoDB document field 이름 기준입니다.

Spring DataAccessException

자동 변환하지 않습니다. 실제 operation은 Reactive Streams Driver가 수행합니다.

@Field를 사용하는 경우

java

@Field("user_name")
private String userName;

// MongoDB document field 이름을 사용
.fields(pair("user_name", "kim"))

entity 저장/조회 conversion에는 Spring mapping이 적용되지만, DSL 조건의 String path는 Spring QueryMapper를 거치지 않습니다. 단 정확한 id path segment는 DSL 자체 규칙으로 _id로 정규화됩니다.

Spring transaction과 DSL transaction은 별도입니다

@Transactional에 자동 참여한다고 가정하지 않습니다

Spring의 @Transactional/TransactionalOperator는 Spring Data가 관리하는 session이고, ReactiveMongoDsl#getTxJob(...)은 자체 ClientSession을 Reactor Context로 전달합니다. 두 경계를 자동으로 같은 transaction으로 취급하지 않습니다.

Transactions

getTxJob의 session propagation과 Spring transaction 경계를 자세히 확인합니다.