refactor: 优化对实体事件的支持

hsweb-commons/hsweb-commons-crud/src/main/java/org/hswebframework/web/crud/configuration/JdbcSqlExecutorConfiguration.java

@@ -20,14 +20,14 @@
 public class JdbcSqlExecutorConfiguration {
     @Bean
     @ConditionalOnMissingBean
-    public SyncSqlExecutor syncSqlExecutor() {
-        return new DefaultJdbcExecutor();
+    public SyncSqlExecutor syncSqlExecutor(DataSource dataSource) {
+        return new DefaultJdbcExecutor(dataSource);
     }
 
     @Bean
     @ConditionalOnMissingBean
-    public ReactiveSqlExecutor reactiveSqlExecutor() {
-        return new DefaultJdbcReactiveExecutor();
+    public ReactiveSqlExecutor reactiveSqlExecutor(DataSource dataSource) {
+        return new DefaultJdbcReactiveExecutor(dataSource);
     }
 
 }

hsweb-commons/hsweb-commons-crud/src/main/java/org/hswebframework/web/crud/events/ValidateEventListener.java

@@ -34,21 +34,22 @@ public void onEvent(EventType type, EventContext context) {
 
         if (resultHolder.isPresent()) {
             resultHolder
-                    .ifPresent(holder -> holder
-                            .invoke(LocaleUtils
-                                            .doInReactive(() -> {
-                                                tryValidate(type, context);
-                                                return null;
-                                            })
-                            ));
+                .ifPresent(holder -> holder
+                    .invoke(LocaleUtils
+                                .doInReactive(() -> {
+                                    tryValidate(type, context);
+                                    return null;
+                                })
+                    ));
         } else {
             tryValidate(type, context);
         }
     }
 
     @SuppressWarnings("all")
     public void tryValidate(EventType type, EventContext context) {
-        if (type == MappingEventTypes.insert_before || type == MappingEventTypes.save_before) {
+        if (type == MappingEventTypes.insert_before
+            || type == MappingEventTypes.save_before) {
 
             boolean single = context.get(MappingContextKeys.type).map("single"::equals).orElse(false);
             if (single) {
@@ -60,10 +61,11 @@ public void tryValidate(EventType type, EventContext context) {
                 context.get(MappingContextKeys.instance)
                        .filter(List.class::isInstance)
                        .map(List.class::cast)
-                       .ifPresent(lst -> lst.stream()
-                                            .filter(Entity.class::isInstance)
-                                            .map(Entity.class::cast)
-                                            .forEach(e -> ((Entity) e).tryValidate(CreateGroup.class))
+                       .ifPresent(lst -> lst
+                           .stream()
+                           .filter(Entity.class::isInstance)
+                           .map(Entity.class::cast)
+                           .forEach(e -> ((Entity) e).tryValidate(CreateGroup.class))
                        );
             }
 

hsweb-commons/hsweb-commons-crud/src/main/java/org/hswebframework/web/crud/service/CrudService.java

@@ -1,5 +1,6 @@
 package org.hswebframework.web.crud.service;
 
+import lombok.SneakyThrows;
 import org.apache.commons.collections4.CollectionUtils;
 import org.hswebframework.ezorm.core.param.QueryParam;
 import org.hswebframework.ezorm.rdb.mapping.SyncDelete;
@@ -12,6 +13,7 @@
 import org.hswebframework.web.api.crud.entity.TransactionManagers;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.sql.SQLException;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -32,13 +34,15 @@ default SyncDelete createDelete() {
         return getRepository().createDelete();
     }
 
-    @Transactional(readOnly = true, transactionManager = TransactionManagers.jdbcTransactionManager)
+    @Transactional( readOnly = true, transactionManager = TransactionManagers.jdbcTransactionManager)
+    @SneakyThrows
     default Optional<E> findById(K id) {
         return getRepository()
                 .findById(id);
     }
 
     @Transactional(readOnly = true, transactionManager = TransactionManagers.jdbcTransactionManager)
+    @SneakyThrows
     default List<E> findById(Collection<K> id) {
         if (CollectionUtils.isEmpty(id)) {
             return Collections.emptyList();
@@ -48,70 +52,78 @@ default List<E> findById(Collection<K> id) {
                 .findById(id);
     }
 
-    @Transactional(transactionManager = TransactionManagers.jdbcTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,transactionManager = TransactionManagers.jdbcTransactionManager)
+    @SneakyThrows
     default SaveResult save(Collection<E> entityArr) {
         return getRepository()
                 .save(entityArr);
     }
 
-    @Transactional(transactionManager = TransactionManagers.jdbcTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,transactionManager = TransactionManagers.jdbcTransactionManager)
+    @SneakyThrows
     default int insert(Collection<E> entityArr) {
         return getRepository()
                 .insertBatch(entityArr);
     }
 
-    @Transactional(transactionManager = TransactionManagers.jdbcTransactionManager)
-    default void insert(E entityArr) {
-        getRepository()
-                .insert(entityArr);
+    @Transactional(rollbackFor = Throwable.class, transactionManager = TransactionManagers.jdbcTransactionManager)
+    default void insert(E entityArr){
+        getRepository().insert(entityArr);
     }
 
-    @Transactional(transactionManager = TransactionManagers.jdbcTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,transactionManager = TransactionManagers.jdbcTransactionManager)
+    @SneakyThrows
     default int updateById(K id, E entityArr) {
-        return getRepository()
-                .updateById(id, entityArr);
+        return getRepository().updateById(id, entityArr);
     }
 
-    @Transactional(transactionManager = TransactionManagers.jdbcTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,transactionManager = TransactionManagers.jdbcTransactionManager)
+    @SneakyThrows
     default SaveResult save(E entity) {
         return getRepository()
                 .save(Collections.singletonList(entity));
     }
 
-    @Transactional(transactionManager = TransactionManagers.jdbcTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,transactionManager = TransactionManagers.jdbcTransactionManager)
+    @SneakyThrows
     default SaveResult save(List<E> entities) {
         return getRepository()
                 .save(entities);
     }
 
-    @Transactional(transactionManager = TransactionManagers.jdbcTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,transactionManager = TransactionManagers.jdbcTransactionManager)
+    @SneakyThrows
     default int deleteById(Collection<K> idArr) {
         return getRepository().deleteById(idArr);
     }
 
-    @Transactional(transactionManager = TransactionManagers.jdbcTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,transactionManager = TransactionManagers.jdbcTransactionManager)
+    @SneakyThrows
     default int deleteById(K idArr) {
         return deleteById(Collections.singletonList(idArr));
     }
 
     @Transactional(readOnly = true, transactionManager = TransactionManagers.jdbcTransactionManager)
+    @SneakyThrows
     default List<E> query(QueryParamEntity queryParam) {
         return createQuery().setParam(queryParam).fetch();
     }
 
     @Transactional(readOnly = true, transactionManager = TransactionManagers.jdbcTransactionManager)
+    @SneakyThrows
     default PagerResult<E> queryPager(QueryParamEntity param) {
 
         int count = param.getTotal() == null ? count(param) : param.getTotal();
         if (count == 0) {
-            return PagerResult.empty();
+            return PagerResult.of(0,Collections.emptyList(),param);
         }
         param.rePaging(count);
 
         return PagerResult.of(count, query(param), param);
     }
 
     @Transactional(readOnly = true, transactionManager = TransactionManagers.jdbcTransactionManager)
+    @SneakyThrows
     default int count(QueryParam param) {
         return getRepository()
                 .createQuery()

hsweb-commons/hsweb-commons-crud/src/main/java/org/hswebframework/web/crud/service/EnableCacheReactiveCrudService.java

@@ -34,48 +34,55 @@ default Mono<E> findById(Mono<K> publisher) {
     }
 
     @Override
-    @Transactional(transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> updateById(K id, E data) {
         return updateById(id, Mono.just(data));
     }
 
     @Override
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> updateById(K id, Mono<E> entityPublisher) {
         return registerClearCache(Collections.singleton("id:" + id))
                 .then(ReactiveCrudService.super.updateById(id, entityPublisher));
     }
 
     @Override
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<SaveResult> save(Collection<E> collection) {
         return registerClearCache()
                 .then(ReactiveCrudService.super.save(collection));
     }
 
     @Override
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<SaveResult> save(E data) {
         return registerClearCache()
                 .then(ReactiveCrudService.super.save(data));
     }
 
     @Override
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<SaveResult> save(Publisher<E> entityPublisher) {
         return registerClearCache()
                 .then(ReactiveCrudService.super.save(entityPublisher));
     }
 
     @Override
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> insert(E data) {
         return registerClearCache()
                 .then(ReactiveCrudService.super.insert(data));
     }
 
     @Override
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> insert(Publisher<E> entityPublisher) {
         return registerClearCache()
                 .then(ReactiveCrudService.super.insert(entityPublisher));
     }
 
     @Override
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> insertBatch(Publisher<? extends Collection<E>> entityPublisher) {
         return registerClearCache()
                 .then(ReactiveCrudService.super.insertBatch(entityPublisher));
@@ -106,12 +113,13 @@ public Mono<Void> afterCommit() {
 
 
     @Override
-    @Transactional(transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class, transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> deleteById(K id) {
         return deleteById(Mono.just(id));
     }
 
     @Override
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> deleteById(Publisher<K> idPublisher) {
         Flux<K> cache = Flux.from(idPublisher).cache();
         return cache

hsweb-commons/hsweb-commons-crud/src/main/java/org/hswebframework/web/crud/service/GenericCrudService.java

@@ -1,7 +1,9 @@
 package org.hswebframework.web.crud.service;
 
 import org.hswebframework.ezorm.rdb.mapping.SyncRepository;
+import org.hswebframework.web.api.crud.entity.TransactionManagers;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
 
 public abstract class GenericCrudService<E,K> implements CrudService<E,K> {
 

hsweb-commons/hsweb-commons-crud/src/main/java/org/hswebframework/web/crud/service/ReactiveCrudService.java

@@ -90,13 +90,13 @@ default ReactiveDelete createDelete() {
     }
 
 
-    @Transactional(readOnly = true, transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<E> findById(K id) {
         return getRepository()
                 .findById(id);
     }
 
-    @Transactional(readOnly = true, transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Flux<E> findById(Collection<K> publisher) {
         return getRepository()
                 .findById(publisher);
@@ -114,61 +114,61 @@ default Flux<E> findById(Flux<K> publisher) {
                 .findById(publisher);
     }
 
-    @Transactional(transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<SaveResult> save(Publisher<E> entityPublisher) {
         return getRepository()
                 .save(entityPublisher);
     }
 
-    @Transactional(transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<SaveResult> save(E data) {
         return getRepository()
                 .save(data);
     }
 
-    @Transactional(transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<SaveResult> save(Collection<E> collection) {
         return getRepository()
                 .save(collection);
     }
 
-    @Transactional(transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> updateById(K id, Mono<E> entityPublisher) {
         return getRepository()
                 .updateById(id, entityPublisher);
     }
 
-    @Transactional(transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> updateById(K id, E data) {
         return getRepository()
                 .updateById(id, Mono.just(data));
     }
 
-    @Transactional(transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> insertBatch(Publisher<? extends Collection<E>> entityPublisher) {
         return getRepository()
                 .insertBatch(entityPublisher);
     }
 
-    @Transactional(transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> insert(Publisher<E> entityPublisher) {
         return getRepository()
                 .insert(entityPublisher);
     }
 
-    @Transactional(transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> insert(E data) {
         return getRepository()
                 .insert(Mono.just(data));
     }
 
-    @Transactional(transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> deleteById(Publisher<K> idPublisher) {
         return getRepository()
                 .deleteById(idPublisher);
     }
 
-    @Transactional(transactionManager = TransactionManagers.reactiveTransactionManager)
+    @Transactional(rollbackFor = Throwable.class,  transactionManager = TransactionManagers.reactiveTransactionManager)
     default Mono<Integer> deleteById(K id) {
         return getRepository()
                 .deleteById(Mono.just(id));