优化curd

hsweb-commons/hsweb-commons-api/src/main/java/org/hswebframework/web/api/crud/entity/TransactionManagers.java

@@ -4,4 +4,6 @@ public interface TransactionManagers {
 
     String r2dbcTransactionManager = "connectionFactoryTransactionManager";// System.getProperty("");
 
+    String jdbcTransactionManager = "transactionManager";
+
 }

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

@@ -39,7 +39,7 @@ import java.util.Optional;
 @Configuration
 @EnableConfigurationProperties(EasyormProperties.class)
 @EnableEasyormRepository("org.hswebframework.web.**.entity")
-public class EasyOrmConfiguration {
+public class EasyormConfiguration {
 
     @Autowired
     private EasyormProperties properties;

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

@@ -34,9 +34,9 @@ import java.util.stream.Stream;
 @Slf4j
 public class EasyormRepositoryRegistrar implements ImportBeanDefinitionRegistrar {
 
-    private ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
+    private final ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
 
-    private MetadataReaderFactory metadataReaderFactory = new SimpleMetadataReaderFactory();
+    private final MetadataReaderFactory metadataReaderFactory = new SimpleMetadataReaderFactory();
 
     @Override
     @SneakyThrows

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

@@ -7,7 +7,6 @@ import org.hswebframework.web.crud.sql.DefaultJdbcReactiveExecutor;
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
 import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;

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

@@ -13,7 +13,7 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 @Configuration
-@AutoConfigureAfter(name = "org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryAutoConfiguration")
+@AutoConfigureAfter(name = "org.springframework.boot.autoconfigure.r2dbc.R2dbcAutoConfiguration")
 @ConditionalOnBean(ConnectionFactory.class)
 public class R2dbcSqlExecutorConfiguration {
     @Bean

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

@@ -8,6 +8,8 @@ import org.hswebframework.ezorm.rdb.mapping.SyncRepository;
 import org.hswebframework.ezorm.rdb.mapping.SyncUpdate;
 import org.hswebframework.ezorm.rdb.mapping.defaults.SaveResult;
 import org.hswebframework.web.api.crud.entity.PagerResult;
+import org.hswebframework.web.api.crud.entity.QueryParamEntity;
+import org.hswebframework.web.api.crud.entity.TransactionManagers;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.Collection;
@@ -30,52 +32,60 @@ public interface CrudService<E, K> {
         return getRepository().createDelete();
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.jdbcTransactionManager)
     default Optional<E> findById(K id) {
         return getRepository()
                 .findById(id);
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.jdbcTransactionManager)
     default List<E> findById(Collection<K> id) {
         if (CollectionUtils.isEmpty(id)) {
             return Collections.emptyList();
         }
-        return getRepository()
+        return this
+                .getRepository()
                 .findById(id);
     }
 
-    @Transactional
-    default SaveResult save(E... entityArr) {
+    @Transactional(transactionManager = TransactionManagers.jdbcTransactionManager)
+    default SaveResult save(Collection<E> entityArr) {
         return getRepository()
                 .save(entityArr);
     }
 
-    @Transactional
-    default SaveResult save(Collection<E> entityArr) {
+    @Transactional(transactionManager = TransactionManagers.jdbcTransactionManager)
+    default int insert(Collection<E> entityArr) {
         return getRepository()
-                .save(entityArr);
+                .insertBatch(entityArr);
     }
 
-    @Transactional
-    default int deleteById(K... idArr) {
-        return getRepository().deleteById(idArr);
+    @Transactional(transactionManager = TransactionManagers.jdbcTransactionManager)
+    default void insert(E entityArr) {
+        getRepository()
+                .insert(entityArr);
+    }
+
+    @Transactional(transactionManager = TransactionManagers.jdbcTransactionManager)
+    default int updateById(K id, E entityArr) {
+        return getRepository()
+                .updateById(id, entityArr);
     }
 
-    @Transactional
+    @Transactional(transactionManager = TransactionManagers.jdbcTransactionManager)
     default int deleteById(Collection<K> idArr) {
         return getRepository().deleteById(idArr);
     }
 
-    @Transactional(readOnly = true)
-    default List<E> query(QueryParam queryParam) {
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.jdbcTransactionManager)
+    default List<E> query(QueryParamEntity queryParam) {
         return createQuery().setParam(queryParam).fetch();
     }
 
-    @Transactional(readOnly = true)
-    default PagerResult<E> queryPager(QueryParam param) {
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.jdbcTransactionManager)
+    default PagerResult<E> queryPager(QueryParamEntity param) {
 
-        int count = count(param);
+        int count = param.getTotal() == null ? count(param) : param.getTotal();
         if (count == 0) {
             return PagerResult.empty();
         }
@@ -84,8 +94,8 @@ public interface CrudService<E, K> {
         return PagerResult.of(count, query(param), param);
     }
 
-    @Transactional(readOnly = true)
-    default Integer count(QueryParam param) {
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.jdbcTransactionManager)
+    default int count(QueryParam param) {
         return getRepository()
                 .createQuery()
                 .setParam(param)

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

@@ -1,6 +1,5 @@
 package org.hswebframework.web.crud.service;
 
-import org.hswebframework.ezorm.core.param.QueryParam;
 import org.hswebframework.ezorm.rdb.mapping.ReactiveDelete;
 import org.hswebframework.ezorm.rdb.mapping.ReactiveQuery;
 import org.hswebframework.ezorm.rdb.mapping.ReactiveRepository;
@@ -8,14 +7,13 @@ import org.hswebframework.ezorm.rdb.mapping.ReactiveUpdate;
 import org.hswebframework.ezorm.rdb.mapping.defaults.SaveResult;
 import org.hswebframework.web.api.crud.entity.PagerResult;
 import org.hswebframework.web.api.crud.entity.QueryParamEntity;
+import org.hswebframework.web.api.crud.entity.TransactionManagers;
 import org.reactivestreams.Publisher;
-import org.springframework.transaction.ReactiveTransactionManager;
 import org.springframework.transaction.annotation.Transactional;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import java.util.Collection;
-import java.util.Collections;
 import java.util.function.Function;
 
 public interface ReactiveCrudService<E, K> {
@@ -34,67 +32,67 @@ public interface ReactiveCrudService<E, K> {
         return getRepository().createDelete();
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Mono<E> findById(K id) {
         return getRepository()
                 .findById(id);
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Flux<E> findById(Collection<K> publisher) {
         return getRepository()
                 .findById(publisher);
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Mono<E> findById(Mono<K> publisher) {
         return getRepository()
                 .findById(publisher);
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Flux<E> findById(Flux<K> publisher) {
         return getRepository()
                 .findById(publisher);
     }
 
-    @Transactional
+    @Transactional(transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Mono<SaveResult> save(Publisher<E> entityPublisher) {
         return getRepository()
                 .save(entityPublisher);
     }
 
-    @Transactional
+    @Transactional(transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Mono<Integer> updateById(K id, Mono<E> entityPublisher) {
         return getRepository()
                 .updateById(id, entityPublisher);
     }
 
-    @Transactional
+    @Transactional(transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Mono<Integer> insertBatch(Publisher<? extends Collection<E>> entityPublisher) {
         return getRepository()
                 .insertBatch(entityPublisher);
     }
 
-    @Transactional
+    @Transactional(transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Mono<Integer> insert(Publisher<E> entityPublisher) {
         return getRepository()
                 .insert(entityPublisher);
     }
 
-    @Transactional
+    @Transactional(transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Mono<Integer> deleteById(Publisher<K> idPublisher) {
         return getRepository()
                 .deleteById(idPublisher);
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Flux<E> query(Mono<? extends QueryParamEntity> queryParamMono) {
         return queryParamMono
                 .flatMapMany(this::query);
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Flux<E> query(QueryParamEntity param) {
         return getRepository()
                 .createQuery()
@@ -102,12 +100,12 @@ public interface ReactiveCrudService<E, K> {
                 .fetch();
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Mono<PagerResult<E>> queryPager(QueryParamEntity queryParamMono) {
         return queryPager(queryParamMono, Function.identity());
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.r2dbcTransactionManager)
     default <T> Mono<PagerResult<T>> queryPager(QueryParamEntity query, Function<E, T> mapper) {
         if (query.getTotal() != null) {
             return getRepository()
@@ -133,19 +131,19 @@ public interface ReactiveCrudService<E, K> {
                 });
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.r2dbcTransactionManager)
     default <T> Mono<PagerResult<T>> queryPager(Mono<? extends QueryParamEntity> queryParamMono, Function<E, T> mapper) {
         return queryParamMono
                 .cast(QueryParamEntity.class)
                 .flatMap(param -> queryPager(param, mapper));
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Mono<PagerResult<E>> queryPager(Mono<? extends QueryParamEntity> queryParamMono) {
         return queryPager(queryParamMono, Function.identity());
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Mono<Integer> count(QueryParamEntity queryParam) {
         return getRepository()
                 .createQuery()
@@ -153,7 +151,7 @@ public interface ReactiveCrudService<E, K> {
                 .count();
     }
 
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.r2dbcTransactionManager)
     default Mono<Integer> count(Mono<? extends QueryParamEntity> queryParamMono) {
         return queryParamMono.flatMap(this::count);
     }

hsweb-commons/hsweb-commons-crud/src/main/java/org/hswebframework/web/crud/sql/DefaultJdbcExecutor.java

@@ -4,6 +4,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.hswebframework.ezorm.rdb.executor.SqlRequest;
 import org.hswebframework.ezorm.rdb.executor.jdbc.JdbcSyncSqlExecutor;
 import org.hswebframework.ezorm.rdb.executor.wrapper.ResultWrapper;
+import org.hswebframework.web.api.crud.entity.TransactionManagers;
 import org.hswebframework.web.datasource.DataSourceHolder;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.jdbc.datasource.DataSourceUtils;
@@ -63,19 +64,19 @@ public class DefaultJdbcExecutor extends JdbcSyncSqlExecutor {
     }
 
     @Override
-    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    @Transactional(propagation = Propagation.NOT_SUPPORTED, transactionManager = TransactionManagers.jdbcTransactionManager)
     public void execute(SqlRequest request) {
         super.execute(request);
     }
 
-    @Transactional(rollbackFor = Throwable.class)
+    @Transactional(rollbackFor = Throwable.class, transactionManager = TransactionManagers.jdbcTransactionManager)
     @Override
     public int update(SqlRequest request) {
         return super.update(request);
     }
 
     @Override
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.jdbcTransactionManager)
     public <T, R> R select(SqlRequest request, ResultWrapper<T, R> wrapper) {
         return super.select(request, wrapper);
     }

hsweb-commons/hsweb-commons-crud/src/main/java/org/hswebframework/web/crud/sql/DefaultR2dbcExecutor.java

@@ -7,13 +7,12 @@ import lombok.Setter;
 import org.hswebframework.ezorm.rdb.executor.SqlRequest;
 import org.hswebframework.ezorm.rdb.executor.reactive.r2dbc.R2dbcReactiveSqlExecutor;
 import org.hswebframework.ezorm.rdb.executor.wrapper.ResultWrapper;
-import org.hswebframework.web.crud.configuration.EasyormProperties;
+import org.hswebframework.web.api.crud.entity.TransactionManagers;
 import org.hswebframework.web.datasource.DataSourceHolder;
 import org.hswebframework.web.datasource.R2dbcDataSource;
 import org.reactivestreams.Publisher;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.r2dbc.connectionfactory.ConnectionFactoryUtils;
-import org.springframework.transaction.NoTransactionException;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 import reactor.core.publisher.Flux;
@@ -86,19 +85,19 @@ public class DefaultR2dbcExecutor extends R2dbcReactiveSqlExecutor {
     }
 
     @Override
-    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    @Transactional(propagation = Propagation.NOT_SUPPORTED, transactionManager = TransactionManagers.r2dbcTransactionManager)
     public Mono<Void> execute(Publisher<SqlRequest> request) {
         return super.execute(request);
     }
 
     @Override
-    @Transactional
+    @Transactional(transactionManager = TransactionManagers.r2dbcTransactionManager)
     public Mono<Integer> update(Publisher<SqlRequest> request) {
         return super.update(request);
     }
 
     @Override
-    @Transactional(readOnly = true)
+    @Transactional(readOnly = true, transactionManager = TransactionManagers.r2dbcTransactionManager)
     public <E> Flux<E> select(Publisher<SqlRequest> request, ResultWrapper<E, ?> wrapper) {
         return super.select(request, wrapper);
     }

hsweb-commons/hsweb-commons-crud/src/main/resources/META-INF/spring.factories

@@ -1,6 +1,6 @@
 # Auto Configure
 org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
-org.hswebframework.web.crud.configuration.EasyOrmConfiguration,\
+org.hswebframework.web.crud.configuration.EasyormConfiguration,\
 org.hswebframework.web.crud.configuration.JdbcSqlExecutorConfiguration,\
 org.hswebframework.web.crud.configuration.R2dbcSqlExecutorConfiguration,\
 org.hswebframework.web.crud.web.CommonWebFluxConfiguration

hsweb-system/hsweb-system-authorization/hsweb-system-authorization-default/src/main/java/org/hswebframework/web/system/authorization/defaults/service/DefaultUserService.java

@@ -1,144 +0,0 @@
-package org.hswebframework.web.system.authorization.defaults.service;
-
-import org.apache.commons.codec.digest.DigestUtils;
-import org.hswebframework.ezorm.core.param.QueryParam;
-import org.hswebframework.web.api.crud.entity.PagerResult;
-import org.hswebframework.web.crud.service.GenericCrudService;
-import org.hswebframework.web.exception.NotFoundException;
-import org.hswebframework.web.id.IDGenerator;
-import org.hswebframework.web.system.authorization.api.PasswordEncoder;
-import org.hswebframework.web.system.authorization.api.entity.UserEntity;
-import org.hswebframework.web.system.authorization.api.event.UserCreatedEvent;
-import org.hswebframework.web.system.authorization.api.event.UserModifiedEvent;
-import org.hswebframework.web.system.authorization.api.service.UserService;
-import org.hswebframework.web.validator.CreateGroup;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.transaction.annotation.Transactional;
-import org.springframework.util.StringUtils;
-import reactor.core.publisher.Mono;
-
-import javax.validation.ValidationException;
-import java.util.Collection;
-import java.util.List;
-import java.util.Optional;
-
-@Transactional(rollbackFor = Exception.class)
-public class DefaultUserService extends GenericCrudService<UserEntity, String> implements UserService {
-
-    @Autowired(required = false)
-    private PasswordEncoder passwordEncoder = (password, salt) -> DigestUtils.md5Hex(String.format("hsweb.%s.framework.%s", password, salt));
-
-    @Autowired
-    private ApplicationEventPublisher eventPublisher;
-
-    @Override
-    public boolean saveUser(UserEntity userEntity) {
-        if (StringUtils.isEmpty(userEntity.getId())) {
-            return doAdd(userEntity);
-        }
-        UserEntity old = findById(userEntity.getId()).orElse(null);
-        if (old == null) {
-            return doAdd(userEntity);
-        }
-
-        return doUpdate(userEntity);
-    }
-
-    protected boolean doAdd(UserEntity userEntity) {
-        userEntity.tryValidate(CreateGroup.class);
-        userEntity.setStatus((byte)1);
-
-        userEntity.setSalt(IDGenerator.RANDOM.generate());
-        userEntity.setPassword(passwordEncoder.encode(userEntity.getPassword(), userEntity.getSalt()));
-        if (createQuery()
-                .where(userEntity::getUsername)
-                .count() > 0) {
-            throw new ValidationException("用户名已存在");
-        }
-        getRepository().insert(userEntity);
-        eventPublisher.publishEvent(new UserCreatedEvent(userEntity));
-        return true;
-    }
-
-
-    protected boolean doUpdate(UserEntity userEntity) {
-        boolean passwordChanged = StringUtils.hasText(userEntity.getPassword());
-        if (passwordChanged) {
-            userEntity.setSalt(IDGenerator.RANDOM.generate());
-            userEntity.setPassword(passwordEncoder.encode(userEntity.getPassword(), userEntity.getSalt()));
-        }
-        getRepository()
-                .createUpdate()
-                .set(userEntity)
-                .where(userEntity::getId)
-                .execute();
-
-        eventPublisher.publishEvent(new UserModifiedEvent(userEntity, passwordChanged));
-        return true;
-    }
-
-    @Override
-    @Transactional(readOnly = true)
-    public List<UserEntity> findById(Collection<String> id) {
-        return super.findById(id);
-    }
-
-    @Override
-    @Transactional(readOnly = true)
-    public Optional<UserEntity> findById(String id) {
-        return super.findById(id);
-    }
-
-    @Override
-    @Transactional(readOnly = true)
-    public Optional<UserEntity> findByUsername(String username) {
-        return createQuery()
-                .where(UserEntity::getUsername, username)
-                .fetchOne();
-    }
-
-    @Override
-    @Transactional(readOnly = true)
-    public Optional<UserEntity> findByUsernameAndPassword(String username, String plainPassword) {
-        return findByUsername(username)
-                .filter(user -> passwordEncoder.encode(plainPassword, user.getSalt()).equals(user.getPassword()));
-    }
-
-    @Override
-    public boolean changeState(String userId, byte state) {
-        return createUpdate()
-                .where(UserEntity::getId, userId)
-                .set(UserEntity::getStatus, state)
-                .execute() > 0;
-    }
-
-    @Override
-    public void changePassword(String userId, String oldPassword, String newPassword) {
-        Mono.justOrEmpty(findById(userId))
-                .switchIfEmpty(Mono.error(NotFoundException::new))
-                .filter(user -> passwordEncoder.encode(oldPassword, user.getSalt()).equals(user.getPassword()))
-                .switchIfEmpty(Mono.error(() -> new ValidationException("密码错误")))
-                .map(user -> createUpdate()
-                        .set(UserEntity::getPassword, passwordEncoder.encode(newPassword, user.getSalt()))
-                        .where(user::getId).execute())
-                .block();
-    }
-
-    @Override
-    @Transactional(readOnly = true)
-    public List<UserEntity> findUser(QueryParam queryParam) {
-        return createQuery().setParam(queryParam).fetch();
-    }
-
-    @Override
-    @Transactional(readOnly = true)
-    public long countUser(QueryParam queryParam) {
-        return createQuery().setParam(queryParam).count();
-    }
-
-    @Override
-    public PagerResult<UserEntity> findUserPager(QueryParam param) {
-        return queryPager(param);
-    }
-}

hsweb-system/hsweb-system-authorization/hsweb-system-authorization-default/src/test/java/org/hswebframework/web/system/authorization/defaults/service/reactive/ReactiveTestApplication.java

@@ -4,8 +4,8 @@ import org.hswebframework.web.authorization.simple.DefaultAuthorizationAutoConfi
 import org.hswebframework.web.crud.configuration.JdbcSqlExecutorConfiguration;
 import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.data.r2dbc.R2dbcTransactionManagerAutoConfiguration;
 import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
-import org.springframework.boot.autoconfigure.transaction.reactive.ReactiveTransactionAutoConfiguration;
 
 @SpringBootApplication(exclude = {
          //TransactionAutoConfiguration.class,
@@ -13,7 +13,7 @@ import org.springframework.boot.autoconfigure.transaction.reactive.ReactiveTrans
         DataSourceAutoConfiguration.class
 })
 @ImportAutoConfiguration({
-        ReactiveTransactionAutoConfiguration.class,
+        R2dbcTransactionManagerAutoConfiguration.class,
         DefaultAuthorizationAutoConfiguration.class
 })
 public class ReactiveTestApplication {

hsweb-system/hsweb-system-authorization/hsweb-system-authorization-default/src/test/java/org/hswebframework/web/system/authorization/defaults/service/reactive/WebFluxPermissionControllerTest.java

@@ -1,10 +1,8 @@
 package org.hswebframework.web.system.authorization.defaults.service.reactive;
 
-import org.hswebframework.web.crud.annotation.EnableEasyormRepository;
-import org.hswebframework.web.crud.configuration.EasyOrmConfiguration;
+import org.hswebframework.web.crud.configuration.EasyormConfiguration;
 import org.hswebframework.web.crud.configuration.JdbcSqlExecutorConfiguration;
 import org.hswebframework.web.crud.configuration.R2dbcSqlExecutorConfiguration;
-import org.hswebframework.web.system.authorization.api.entity.PermissionEntity;
 import org.hswebframework.web.system.authorization.defaults.configuration.AuthorizationServiceAutoConfiguration;
 import org.hswebframework.web.system.authorization.defaults.configuration.AuthorizationWebAutoConfiguration;
 import org.hswebframework.web.system.authorization.defaults.webflux.WebFluxPermissionController;
@@ -14,30 +12,21 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
 import org.springframework.boot.autoconfigure.data.r2dbc.R2dbcTransactionManagerAutoConfiguration;
-import org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryAutoConfiguration;
+import org.springframework.boot.autoconfigure.r2dbc.R2dbcAutoConfiguration;
 import org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration;
-import org.springframework.boot.autoconfigure.transaction.reactive.ReactiveTransactionAutoConfiguration;
 import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.http.MediaType;
-import org.springframework.test.annotation.DirtiesContext;
 import org.springframework.test.context.junit4.SpringRunner;
 import org.springframework.test.web.reactive.server.WebTestClient;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-
-import java.util.function.Function;
 
 @RunWith(SpringRunner.class)
 @WebFluxTest(WebFluxPermissionController.class)
 @ImportAutoConfiguration(value = {
         AuthorizationWebAutoConfiguration.class,
         AuthorizationServiceAutoConfiguration.class,
-        EasyOrmConfiguration.class,
-        R2dbcSqlExecutorConfiguration.class, ConnectionFactoryAutoConfiguration.class,
-        R2dbcTransactionManagerAutoConfiguration.class,
-        ReactiveTransactionAutoConfiguration.class
+        EasyormConfiguration.class,
+        R2dbcSqlExecutorConfiguration.class, R2dbcAutoConfiguration.class,
+        R2dbcTransactionManagerAutoConfiguration.class
 },exclude = {
         JdbcSqlExecutorConfiguration.class,
         TransactionAutoConfiguration.class