Neues von Spring Data

interface CrudRepository<T, ID> extends Repository<T, ID> {
    S save(S entity);
    Iterable<S> saveAll(Iterable<S> entities)
    Optional<T> findById(ID id);
    boolean existsById(ID id);
    Iterable<T> findAllById(Iterable<ID> ids);
    void deleteById(ID id);
    void delete(T entity);
    void deleteAll(Iterable<? extends T> entities);
}

interface MyRepository
    extends CrudRepository,
            ARepo, BRepo {...}

class ARepoImpl implements ARepo {...}
class BRepoImpl implements BRepo {...}

Query query =
  new BasicQuery(new Document());

List<SWCharacter> all =
  ops.find(
    query,
    SWCharacter.class,
    "star-wars"
  );

List<SWCharacter> all = ops
  .find(SWCharacter.class)
  .inCollection("star-wars")
  .all();

@GetMapping("/people")
Flux<String> namesByLastname(
  @RequestParam Mono<String> lastname) {

  Flux<Person> result =
    repository.findByLastname(lastname);

  return result
    .map(it -> it.getFullName());
}

Aggregation filter =
  newAggregation(
    User.class,
    match(where("age").gte(38));

Flux<ChangeStreamEvent<User>> flux =
  reactiveTemplate.changeStream(
    filter,
    User.class,
    ChangeStreamOptions.empty());

@Bean
MongoTransactionManager transactionManager(
        MongoDbFactory dbFactory
) {
    return new MongoTransactionManager(dbFactory);
}

@Query("SELECT * FROM Person
    WHERE name  < :upper and name > :lower")
List<Person> findByNamedRange(
    @Param("lower") String lower,
    @Param("upper") String upper
);

@Modifying
@Query("DELETE FROM Person WHERE name = :name")
boolean deleteByName(@Param("name") String name);

@Bean
ApplicationListener<BeforeDelete> softDeleteListener() {

  return event -> {

    DummyEntity entity = (DummyEntity) event.getOptionalEntity()
        .orElseThrow(AssertionFailedError::new);

    entity.deleted = true;
    List<DbAction> actions = event.getChange().getActions();
    actions.clear();
    actions.add(DbAction.update(entity, null, null));
  };
}