org.springframework.data.mongodb.core.ReactiveMongoOperations Java Examples

/**
 * Application runner to initialize a capped collection for {@link Event}s and insert a new {@link Event} every two
 * seconds.
 * 
 * @param operations
 * @param reactiveOperations
 * @return
 */
@Bean
ApplicationRunner onStart(MongoOperations operations, ReactiveMongoOperations reactiveOperations) {

	return args -> {

		CollectionOptions options = CollectionOptions.empty() //
				.capped() //
				.size(2048) //
				.maxDocuments(1000);

		operations.dropCollection(Event.class);
		operations.createCollection(Event.class, options);

		Flux.interval(Duration.ofSeconds(2)) //
				.map(counter -> new Event(LocalDateTime.now())) //
				.flatMap(reactiveOperations::save) //
				.log() //
				.subscribe();
	};
}
 

public WarnLogsCounter(ReactiveMongoOperations template) {
    Flux<Log> stream = template.tail(query(where(LEVEL_FIELD_NAME).is(LogLevel.WARN)), Log.class);
    subscription = stream.subscribe(logEntity -> {
      log.warn("WARN log received: " + logEntity);
      counter.incrementAndGet();
    });
}
 

/**
 * Creates a new {@link AbstractMongoQuery} from the given {@link MongoQueryMethod} and {@link MongoOperations}.
 *
 * @param method must not be {@literal null}.
 * @param projectionFactory - the projection factory
 */
@Autowired
public ReactiveAggregateMongoQuery(Method method, RepositoryMetadata metadata, ReactiveMongoOperations mongoOperations,
                                   ProjectionFactory projectionFactory, MongoQueryExecutor queryExecutor) {
  super(new ReactiveMongoQueryMethod(method, metadata, projectionFactory,
                                     mongoOperations.getConverter().getMappingContext()),
        mongoOperations,
        new SpelExpressionParser(),
        CONTEXT_PROVIDER);
  this.mongoOperations = mongoOperations;
  this.method = method;
  this.queryExecutor = queryExecutor;
}
 

public MongodbProcessorConfiguration(
	MongodbProcessorProperties properties,
	ReactiveMongoOperations mongoTemplate,
	BeanFactory beanFactory
) {
	this.properties = properties;
	this.mongoTemplate = mongoTemplate;
	this.evaluationContext = ExpressionUtils.createStandardEvaluationContext(beanFactory);
}
 

/**
 * Creates a new {@link MongoRepositoryFactory} with the given {@link MongoOperations}.
 *
 * @param mongoOperations must not be {@literal null}
 * @param queryExecutor - the query executor
 */
public ReactiveAggregateQuerySupportingRepositoryFactory(ReactiveMongoOperations mongoOperations,
                                                         MongoQueryExecutor queryExecutor) {
  super(mongoOperations);
  this.mongoOperations = mongoOperations;
  this.queryExecutor = queryExecutor;
}
 

@Override
protected RepositoryFactorySupport getFactoryInstance(ReactiveMongoOperations operations) {
  Assert.notNull(queryExecutor, "Query executor cannot be null");
  return new ReactiveAggregateQuerySupportingRepositoryFactory(operations, queryExecutor);
}
 

Mono<Process> start(ReactiveMongoOperations operations, Process process) {

		return operations.update(Process.class).matching(Query.query(Criteria.where("id").is(process.getId())))
				.apply(Update.update("state", State.ACTIVE).inc("transitionCount", 1)).first() //
				.then(Mono.just(process));
	}
 

private Mono<Process> finish(ReactiveMongoOperations operations, Process process) {

		return operations.update(Process.class).matching(Query.query(Criteria.where("id").is(process.getId())))
				.apply(Update.update("state", State.DONE).inc("transitionCount", 1)).first() //
				.then(Mono.just(process));
	}
 

Mono<Process> start(ReactiveMongoOperations operations, Process process) {

		return operations.update(Process.class).matching(Query.query(Criteria.where("id").is(process.getId())))
				.apply(Update.update("state", State.ACTIVE).inc("transitionCount", 1)).first() //
				.then(Mono.just(process));
	}
 

private Mono<Process> finish(ReactiveMongoOperations operations, Process process) {

		return operations.update(Process.class).matching(Query.query(Criteria.where("id").is(process.getId())))
				.apply(Update.update("state", State.DONE).inc("transitionCount", 1)).first() //
				.then(Mono.just(process));
	}
 

@Bean
public MongoQueryExecutor queryExecutor(ReactiveMongoOperations mongoOperations) {
  return new ReactiveMongoNativeJavaDriverQueryExecutor(mongoOperations);
}
 

@Bean
public ReactiveMongoOperations reactiveMongoOperations(MongoClient mongoClient, String dbName) {
  return new ReactiveMongoTemplate(mongoClient, dbName);
}
 

private void initialize(ReactiveMongoOperations mongoOperations) {
  Document result = mongoOperations.executeCommand("{buildinfo:1}").block();
  this.isMongo360OrLater = ((String)result.get("version")).startsWith(MONGO_V3_6_VERSION);
}
 

public ReactiveMongoNativeJavaDriverQueryExecutor(ReactiveMongoOperations mongoOperations, ObjectMapper objectMapper) {
  super(mongoOperations, objectMapper);
  initialize(mongoOperations);
}
 

public ReactiveMongoNativeJavaDriverQueryExecutor(ReactiveMongoOperations mongoOperations) {
  super(mongoOperations);
  initialize(mongoOperations);
}
 

public DataInitializer(ReactiveMongoOperations mongoTemplate) {
    this.mongoTemplate = mongoTemplate;
}
 

@Autowired
DefaultUserRepository(ReactiveMongoOperations mongoOperations) {
    this.mongoOperations = mongoOperations;
}