org.hswebframework.web.crud.service

接口 ReactiveCrudService<E,K>

类型参数:

E - 实体类类型

K - 主键类型

所有已知子接口:

EnableCacheReactiveCrudService<E,K>, ReactiveTreeSortEntityService<E,K>

所有已知实现类:

GenericReactiveCacheSupportCrudService, GenericReactiveCrudService, GenericReactiveTreeSupportCrudService

public interface ReactiveCrudService<E,K>

响应式增删改查通用服务类,增删改查,实现此接口. 利用ReactiveRepository来实现.

另请参阅:

ReactiveRepository, GenericReactiveCrudService, GenericReactiveTreeSupportCrudService, EnableCacheReactiveCrudService

方法概要

限定符和类型	方法和说明
default reactor.core.publisher.Mono<Integer>	count(reactor.core.publisher.Mono<? extends QueryParamEntity> queryParamMono)
default reactor.core.publisher.Mono<Integer>	count(QueryParamEntity queryParam)
default org.hswebframework.ezorm.rdb.mapping.ReactiveDelete	createDelete() 创建一个DSL动态删除接口,可使用DSL方式进行链式调用来构造动态删除条件.例如: Mono<Integer> result = service .createDelete() .where(MyEntity::getName,name) .in(MyEntity::getState,state1,state2) .execute()
default org.hswebframework.ezorm.rdb.mapping.ReactiveQuery<E>	createQuery() 创建一个DSL的动态查询接口,可使用DSL方式进行链式调用来构造动态查询条件.例如: Flux<MyEntity> flux = service .createQuery() .where(MyEntity::getName,name) .in(MyEntity::getState,state1,state2) .fetch()
default org.hswebframework.ezorm.rdb.mapping.ReactiveUpdate<E>	createUpdate() 创建一个DSL动态更新接口,可使用DSL方式进行链式调用来构造动态更新条件.例如: Mono<Integer> result = service .createUpdate() .set(entity::getState) .where(MyEntity::getName,name) .in(MyEntity::getState,state1,state2) .execute()
default reactor.core.publisher.Mono<Integer>	deleteById(K id)
default reactor.core.publisher.Mono<Integer>	deleteById(org.reactivestreams.Publisher<K> idPublisher)
default reactor.core.publisher.Flux<E>	findById(Collection<K> publisher)
default reactor.core.publisher.Flux<E>	findById(reactor.core.publisher.Flux<K> publisher)
default reactor.core.publisher.Mono<E>	findById(K id)
default reactor.core.publisher.Mono<E>	findById(reactor.core.publisher.Mono<K> publisher)
org.hswebframework.ezorm.rdb.mapping.ReactiveRepository<E,K>	getRepository()
default reactor.core.publisher.Mono<Integer>	insert(E data)
default reactor.core.publisher.Mono<Integer>	insert(org.reactivestreams.Publisher<E> entityPublisher)
default reactor.core.publisher.Mono<Integer>	insertBatch(org.reactivestreams.Publisher<? extends Collection<E>> entityPublisher)
default reactor.core.publisher.Flux<E>	query(reactor.core.publisher.Mono<? extends QueryParamEntity> queryParamMono)
default reactor.core.publisher.Flux<E>	query(QueryParamEntity param)
default reactor.core.publisher.Mono<PagerResult<E>>	queryPager(reactor.core.publisher.Mono<? extends QueryParamEntity> queryParamMono)
default <T> reactor.core.publisher.Mono<PagerResult<T>>	queryPager(reactor.core.publisher.Mono<? extends QueryParamEntity> queryParamMono, java.util.function.Function<E,T> mapper)
default reactor.core.publisher.Mono<PagerResult<E>>	queryPager(QueryParamEntity queryParamMono)
default <T> reactor.core.publisher.Mono<PagerResult<T>>	queryPager(QueryParamEntity query, java.util.function.Function<E,T> mapper)
default reactor.core.publisher.Mono<org.hswebframework.ezorm.rdb.mapping.defaults.SaveResult>	save(Collection<E> collection)
default reactor.core.publisher.Mono<org.hswebframework.ezorm.rdb.mapping.defaults.SaveResult>	save(E data)
default reactor.core.publisher.Mono<org.hswebframework.ezorm.rdb.mapping.defaults.SaveResult>	save(org.reactivestreams.Publisher<E> entityPublisher)
default reactor.core.publisher.Mono<Integer>	updateById(K id, E data)
default reactor.core.publisher.Mono<Integer>	updateById(K id, reactor.core.publisher.Mono<E> entityPublisher)

方法详细资料

getRepository

org.hswebframework.ezorm.rdb.mapping.ReactiveRepository<E,K> getRepository()

返回:

响应式实体操作仓库

createQuery

default org.hswebframework.ezorm.rdb.mapping.ReactiveQuery<E> createQuery()

创建一个DSL的动态查询接口,可使用DSL方式进行链式调用来构造动态查询条件.例如:

 Flux<MyEntity> flux = service
     .createQuery()
     .where(MyEntity::getName,name)
     .in(MyEntity::getState,state1,state2)
     .fetch()
 
 

返回:

动态查询接口

createUpdate

default org.hswebframework.ezorm.rdb.mapping.ReactiveUpdate<E> createUpdate()

创建一个DSL动态更新接口,可使用DSL方式进行链式调用来构造动态更新条件.例如:

 Mono<Integer> result = service
     .createUpdate()
     .set(entity::getState)
     .where(MyEntity::getName,name)
     .in(MyEntity::getState,state1,state2)
     .execute()
     
 

返回:

动态更新接口

createDelete

default org.hswebframework.ezorm.rdb.mapping.ReactiveDelete createDelete()

创建一个DSL动态删除接口,可使用DSL方式进行链式调用来构造动态删除条件.例如:

 Mono<Integer> result = service
     .createDelete()
     .where(MyEntity::getName,name)
     .in(MyEntity::getState,state1,state2)
     .execute()
 
 

返回:

动态更新接口

findById

@Transactional(readOnly=true,
               transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<E> findById(K id)

findById

@Transactional(readOnly=true,
               transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Flux<E> findById(Collection<K> publisher)

findById

@Transactional(readOnly=true,
               transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<E> findById(reactor.core.publisher.Mono<K> publisher)

findById

@Transactional(readOnly=true,
               transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Flux<E> findById(reactor.core.publisher.Flux<K> publisher)

save

@Transactional(transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<org.hswebframework.ezorm.rdb.mapping.defaults.SaveResult> save(org.reactivestreams.Publisher<E> entityPublisher)

save

@Transactional(transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<org.hswebframework.ezorm.rdb.mapping.defaults.SaveResult> save(E data)

save

@Transactional(transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<org.hswebframework.ezorm.rdb.mapping.defaults.SaveResult> save(Collection<E> collection)

updateById

@Transactional(transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<Integer> updateById(K id,
                                                                                                                                 reactor.core.publisher.Mono<E> entityPublisher)

updateById

@Transactional(transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<Integer> updateById(K id,
                                                                                                                                 E data)

insertBatch

@Transactional(transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<Integer> insertBatch(org.reactivestreams.Publisher<? extends Collection<E>> entityPublisher)

insert

@Transactional(transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<Integer> insert(org.reactivestreams.Publisher<E> entityPublisher)

insert

@Transactional(transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<Integer> insert(E data)

deleteById

@Transactional(transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<Integer> deleteById(org.reactivestreams.Publisher<K> idPublisher)

deleteById

@Transactional(transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<Integer> deleteById(K id)

query

@Transactional(readOnly=true,
               transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Flux<E> query(reactor.core.publisher.Mono<? extends QueryParamEntity> queryParamMono)

query

@Transactional(readOnly=true,
               transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Flux<E> query(QueryParamEntity param)

queryPager

@Transactional(readOnly=true,
               transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<PagerResult<E>> queryPager(QueryParamEntity queryParamMono)

queryPager

@Transactional(readOnly=true,
               transactionManager="connectionFactoryTransactionManager")
default <T> reactor.core.publisher.Mono<PagerResult<T>> queryPager(QueryParamEntity query,
                                                                                                                                                                          java.util.function.Function<E,T> mapper)

queryPager

@Transactional(readOnly=true,
               transactionManager="connectionFactoryTransactionManager")
default <T> reactor.core.publisher.Mono<PagerResult<T>> queryPager(reactor.core.publisher.Mono<? extends QueryParamEntity> queryParamMono,
                                                                                                                                                                          java.util.function.Function<E,T> mapper)

queryPager

@Transactional(readOnly=true,
               transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<PagerResult<E>> queryPager(reactor.core.publisher.Mono<? extends QueryParamEntity> queryParamMono)

count

@Transactional(readOnly=true,
               transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<Integer> count(QueryParamEntity queryParam)

count

@Transactional(readOnly=true,
               transactionManager="connectionFactoryTransactionManager")
default reactor.core.publisher.Mono<Integer> count(reactor.core.publisher.Mono<? extends QueryParamEntity> queryParamMono)