Java Code Examples for reactor.core.publisher.Flux#fromIterable()

@Override
public Flux<Employee> readEmployeesByAscLastName() {
	Scheduler subWorker = Schedulers.newSingle("sub-thread");
	Scheduler pubWorker = Schedulers.newSingle("pub-thread");
	Supplier<Flux<Employee>> deferredTask = ()->{
		System.out.println("flux:defer task executor: " + Thread.currentThread().getName());
		System.out.println("flux:defer task executor login: " + SecurityContextHolder.getContext().getAuthentication().getPrincipal());
		return Flux.fromIterable(employeeDaoImpl.getEmployees());
	};
	Comparator<Employee> descLName = (e1, e2) -> {
		System.out.println("flux:sort task executor: " + Thread.currentThread().getName());
		System.out.println("flux:sort task executor login: " + SecurityContextHolder.getContext().getAuthentication().getPrincipal());
		return e1.getLastName().compareTo(e2.getLastName());
	};
	Flux<Employee> deferred = Flux.defer(deferredTask).sort(descLName).subscribeOn(subWorker).publishOn(pubWorker);
	return deferred;
}
 

@Test
public void publisherToReactivexFlowable() {
	List<Integer> sequence = Arrays.asList(1, 2, 3);
	Publisher<Integer> source = Flux.fromIterable(sequence);
	Object target = getAdapter(io.reactivex.Flowable.class).fromPublisher(source);
	assertTrue(target instanceof io.reactivex.Flowable);
	assertEquals(sequence, ((io.reactivex.Flowable<?>) target).toList().blockingGet());
}
 

@Override
public Flux<Route> getRoutes() {
	// TODO: sorting?
	// TODO: caching

	Collection<Route> routeCollection = routes.values();
	if (log.isDebugEnabled()) {
		log.debug("Found routes: " + routeCollection);
	}
	return Flux.fromIterable(routeCollection);
}
 

@Override
public Publisher<? extends Result> execute() {
  if (this.statementType == StatementType.DDL) {
    return this.client
        .executeDdl(
            this.config.getFullyQualifiedDatabaseName(),
            Collections.singletonList(this.sql),
            this.config.getDdlOperationTimeout(),
            this.config.getDdlOperationPollInterval())
        .map(operation -> new SpannerResult(Flux.empty(), Mono.just(0)));
  } else if (this.statementType == StatementType.DML && !this.ctx.isTransactionPartitionedDml()) {

    List<ExecuteBatchDmlRequest.Statement> dmlStatements =
        this.statementBindings.getBindings().stream()
            .map(struct ->
                ExecuteBatchDmlRequest.Statement.newBuilder()
                    .setSql(this.sql)
                    .setParams(struct)
                    .putAllParamTypes(this.statementBindings.getTypes())
                    .build())
            .collect(Collectors.toList());

    return this.client.executeBatchDml(this.ctx, dmlStatements)
        .map(partialResultSet -> Math.toIntExact(partialResultSet.getStats().getRowCountExact()))
        .map(rowCount -> new SpannerResult(Flux.empty(), Mono.just(rowCount)));
  }

  Flux<Struct> structFlux = Flux.fromIterable(this.statementBindings.getBindings());
  return structFlux.flatMap(this::runStreamingSql);
}
 

@Test
	public void fluxCanBeEnforcedToDispatchValuesHavingDistinctKeys() {
//		"A Flux can be enforced to dispatch values having distinct keys"
//		given: "a composable with values 1 to 4 with duplicate keys"
		Flux<Integer> s = Flux.fromIterable(Arrays.asList(1, 2, 3, 1, 2, 3, 4));

//		when: "the values are filtered and result is collected"
		MonoProcessor<List<Integer>> tap = s.distinct(it -> it % 3)
		                                    .collectList()
		                                    .toProcessor();
		tap.subscribe();

//		then: "collected should be without duplicates"
		assertThat(tap.block()).containsExactly(1, 2, 3);
	}
 

@Override
public Flux<InsertionId> failedIds(Group registeredGroup) {
    Preconditions.checkArgument(registeredGroup != null, REGISTERED_GROUP_CANNOT_BE_NULL);

    synchronized (deadLetters) {
        return Flux.fromIterable(ImmutableList.copyOf(deadLetters.row(registeredGroup).keySet()));
    }
}
 

/**
 * 获取所有用户
 *
 * @return
 */
@GetMapping("/list")
public Flux<User> getAll() {
    return Flux.fromIterable(users.entrySet().stream()
            .map(entry -> entry.getValue())
            .collect(Collectors.toList()));
}
 

private Function<String, Publisher<org.apache.curator.x.discovery.ServiceInstance<ZookeeperInstance>>> getInstancesFromZookeeper() {
	return service -> {
		try {
			return Flux.fromIterable(serviceDiscovery.queryForInstances(service));
		}
		catch (Exception e) {
			logger.error("Error getting instances from zookeeper. Possibly, no service has registered.", e);
			return Flux.empty();
		}
	};
}
 

Flux<Post> findAll() {
    return Flux.fromIterable(data.values());
}
 

@GetMapping("/fluxJpaEmps")
public Flux<Employee> exposeJpaEmps() {
	return Flux.fromIterable(employeeServiceImpl.findAllEmps());
}
 

protected Flux<?> extract(Object input) {
	if (!isSingleInput(this.getFunction(), input)) {
		return Flux.fromIterable((Iterable<?>) input);
	}
	return Flux.just(input);
}
 

private Flux<BatchJobTask> observeTasks(int count) {
    return Flux.fromIterable(batchTasksGenerator.batch(count).getValue());
}
 

public Flux<Movie> getAll() {
    return Flux.fromIterable(repository.findAll());
//    return repository.findAll();
  }
 

@Override
public Flux<Group> groupsWithFailedEvents() {
    synchronized (deadLetters) {
        return Flux.fromIterable(ImmutableList.copyOf(deadLetters.rowKeySet()));
    }
}
 

@GetMapping("/fluxJpaUsers")
public Flux<UserDetails> exposeJpaUsers() {
	return Flux.fromIterable(userdetailsServiceImpl.findAllUserdetails());
}
 

@Override
public Flux<Subscription> getSubscriptions() {
    return Flux.fromIterable(subscriptions.values());
}
 

/**
 * Get a flux of previously logged messages.
 */
@GetMapping(produces = TEXT_EVENT_STREAM_VALUE)
public Flux<String> getMessages() {
    return Flux.fromIterable(log.getMessages());
}
 

public Mono<ServerResponse> loginDetailsList(ServerRequest req) {
	Flux<LoginDetails> flux = Flux.fromIterable(logindetailsServiceImpl.findAllLogindetails());
	return ok().contentType(MediaType.APPLICATION_STREAM_JSON).body(flux, LoginDetails.class);
}
 

public Flux<City> findAllCity() {
    return Flux.fromIterable(cityRepository.findAll());
}
 

/**
 * Get a flux of previously logged messages.
 */
@GetMapping(produces = TEXT_EVENT_STREAM_VALUE)
public Flux<String> getMessages() {
    return Flux.fromIterable(log.getMessages());
}