diff --git a/mongo-plus-boot-starter/src/main/java/com/anwen/mongo/config/MongoPlusAutoConfiguration.java b/mongo-plus-boot-starter/src/main/java/com/anwen/mongo/config/MongoPlusAutoConfiguration.java index 83ba7dd54f39af5b41c9b3fac45955cb25fc62bf..f00a3bdbfbdf2dab948a04100bcdfcc4014f9f88 100644 --- a/mongo-plus-boot-starter/src/main/java/com/anwen/mongo/config/MongoPlusAutoConfiguration.java +++ b/mongo-plus-boot-starter/src/main/java/com/anwen/mongo/config/MongoPlusAutoConfiguration.java @@ -1,5 +1,6 @@ package com.anwen.mongo.config; +import com.anwen.mongo.aware.Aware; import com.anwen.mongo.cache.global.*; import com.anwen.mongo.domain.MongoPlusConvertException; import com.anwen.mongo.handlers.CollectionNameHandler; @@ -17,6 +18,7 @@ import com.anwen.mongo.listener.business.BlockAttackInnerListener; import com.anwen.mongo.listener.business.LogListener; import com.anwen.mongo.logging.Log; import com.anwen.mongo.logging.LogFactory; +import com.anwen.mongo.logic.LogicNamespaceAware; import com.anwen.mongo.mapper.BaseMapper; import com.anwen.mongo.property.MongoDBCollectionProperty; import com.anwen.mongo.property.MongoDBLogProperty; @@ -80,6 +82,7 @@ public class MongoPlusAutoConfiguration implements InitializingBean { setTenantHandler(); setDynamicCollectionHandler(); setDataChangeRecorderInterceptor(); + setAware(applicationContext); } @Override @@ -89,6 +92,21 @@ public class MongoPlusAutoConfiguration implements InitializingBean { setLogicFiled(values.stream().map(IService::getGenericityClass).toArray(Class[]::new)); } + /** + * 设置感知类 + * + * @author loser + */ + public void setAware(ApplicationContext applicationContext) { + + Configuration builder = Configuration.builder(); + builder.aware(new LogicNamespaceAware()); + for (Aware aware : applicationContext.getBeansOfType(Aware.class).values()) { + builder.aware(aware); + } + + } + /** * 配置逻辑删除 * diff --git a/mongo-plus-core/src/main/java/com/anwen/mongo/aware/Aware.java b/mongo-plus-core/src/main/java/com/anwen/mongo/aware/Aware.java new file mode 100644 index 0000000000000000000000000000000000000000..8ed3b6e16954dcaac415eaf0b832c678bea6aef3 --- /dev/null +++ b/mongo-plus-core/src/main/java/com/anwen/mongo/aware/Aware.java @@ -0,0 +1,10 @@ +package com.anwen.mongo.aware; + +/** + * 通用感知类 + * + * @author loser + * @date 2024/6/29 + */ +public interface Aware { +} diff --git a/mongo-plus-core/src/main/java/com/anwen/mongo/aware/MongoAwareUtils.java b/mongo-plus-core/src/main/java/com/anwen/mongo/aware/MongoAwareUtils.java new file mode 100644 index 0000000000000000000000000000000000000000..41bf320e2fb7beb66e1ed5b22f4bccdf6e32380d --- /dev/null +++ b/mongo-plus-core/src/main/java/com/anwen/mongo/aware/MongoAwareUtils.java @@ -0,0 +1,22 @@ +package com.anwen.mongo.aware; + +import com.anwen.mongo.cache.global.AwareHandlerCache; + +import java.util.List; + +/** + * 感知工具类 获取对应的 class 处理类 + * + * @author loser + * @date 2024/6/29 + */ +public class MongoAwareUtils { + + private MongoAwareUtils() { + } + + public static List listHandlers(Class clazz) { + return AwareHandlerCache.listHandlers(clazz); + } + +} diff --git a/mongo-plus-core/src/main/java/com/anwen/mongo/aware/impl/NamespaceAware.java b/mongo-plus-core/src/main/java/com/anwen/mongo/aware/impl/NamespaceAware.java new file mode 100644 index 0000000000000000000000000000000000000000..8fc40787bb92cae968a4ebd61fdea3cdb5e41012 --- /dev/null +++ b/mongo-plus-core/src/main/java/com/anwen/mongo/aware/impl/NamespaceAware.java @@ -0,0 +1,77 @@ +package com.anwen.mongo.aware.impl; + +import com.anwen.mongo.aware.Aware; + +public interface NamespaceAware extends Aware { + + void nameSpaceAware(Namespace namespace); + + class NamespaceBuild { + + private final Namespace namespace = new Namespace(); + + private NamespaceBuild() { + } + + public static NamespaceBuild builder() { + return new NamespaceBuild(); + } + + public NamespaceBuild dataBase(String dataBase) { + namespace.setDataBase(dataBase); + return this; + } + + public NamespaceBuild collectionName(String collectionName) { + namespace.setCollectionName(collectionName); + return this; + } + + public NamespaceBuild entityClass(Class entityClass) { + namespace.setEntityClass(entityClass); + return this; + } + + public Namespace build() { + return this.namespace; + } + + } + + class Namespace { + + private String dataBase; + + private String collectionName; + + private Class entityClass; + + private Namespace() { + } + + public String getDataBase() { + return dataBase; + } + + public void setDataBase(String dataBase) { + this.dataBase = dataBase; + } + + public String getCollectionName() { + return collectionName; + } + + public void setCollectionName(String collectionName) { + this.collectionName = collectionName; + } + + public Class getEntityClass() { + return entityClass; + } + + public void setEntityClass(Class entityClass) { + this.entityClass = entityClass; + } + } + +} diff --git a/mongo-plus-core/src/main/java/com/anwen/mongo/cache/global/AwareHandlerCache.java b/mongo-plus-core/src/main/java/com/anwen/mongo/cache/global/AwareHandlerCache.java new file mode 100644 index 0000000000000000000000000000000000000000..e3e100df6413276cd069431bfde20fb78208941a --- /dev/null +++ b/mongo-plus-core/src/main/java/com/anwen/mongo/cache/global/AwareHandlerCache.java @@ -0,0 +1,73 @@ +package com.anwen.mongo.cache.global; + +import com.anwen.mongo.aware.Aware; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.concurrent.ConcurrentHashMap; + +/** + * 感知处理类缓存 + * + * @author loser + * @date 2024/6/29 + */ +public class AwareHandlerCache { + + private final Map, List> handlerMap = new ConcurrentHashMap<>(); + + private static final AwareHandlerCache instant = new AwareHandlerCache(); + + private AwareHandlerCache() { + } + + public static AwareHandlerCache getInstance() { + return instant; + } + + /** + * 获取感知类下的所有处理器 + * + * @param clazz 感知类 + * @param 感知类 + * @return 感知处理器集合 + */ + public static List listHandlers(Class clazz) { + + Object o = getInstance().handlerMap.get(clazz); + if (Objects.isNull(o)) { + return Collections.emptyList(); + } + return (List) o; + + } + + /** + * 将感知类添加到缓存 + * + * @param aware 感知类 + * @param 感知类型 + */ + public static synchronized void putAware(T aware) { + + Class[] interfaces = aware.getClass().getInterfaces(); + for (Class anInterface : interfaces) { + if (Aware.class.isAssignableFrom(anInterface)) { + List handlers; + Object o = getInstance().handlerMap.get(anInterface); + if (Objects.nonNull(o)) { + handlers = (List) o; + } else { + handlers = new ArrayList<>(); + getInstance().handlerMap.put(anInterface, handlers); + } + handlers.add(aware); + } + } + + } + +} diff --git a/mongo-plus-core/src/main/java/com/anwen/mongo/config/Configuration.java b/mongo-plus-core/src/main/java/com/anwen/mongo/config/Configuration.java index 1f50229a9468bb37469decb977e2e24ed8067eed..a4667a0f48786b0c49764b967e1e13c716680a33 100644 --- a/mongo-plus-core/src/main/java/com/anwen/mongo/config/Configuration.java +++ b/mongo-plus-core/src/main/java/com/anwen/mongo/config/Configuration.java @@ -2,7 +2,15 @@ package com.anwen.mongo.config; import com.anwen.mongo.annotation.collection.CollectionField; import com.anwen.mongo.annotation.collection.CollectionLogic; -import com.anwen.mongo.cache.global.*; +import com.anwen.mongo.aware.Aware; +import com.anwen.mongo.cache.global.AwareHandlerCache; +import com.anwen.mongo.cache.global.CollectionLogicDeleteCache; +import com.anwen.mongo.cache.global.ConversionCache; +import com.anwen.mongo.cache.global.ExecutorReplacerCache; +import com.anwen.mongo.cache.global.HandlerCache; +import com.anwen.mongo.cache.global.InterceptorCache; +import com.anwen.mongo.cache.global.ListenerCache; +import com.anwen.mongo.cache.global.MongoPlusClientCache; import com.anwen.mongo.conn.CollectionManager; import com.anwen.mongo.constant.DataSourceConstant; import com.anwen.mongo.convert.CollectionNameConvert; @@ -49,7 +57,13 @@ import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; import java.util.concurrent.ConcurrentHashMap; import java.util.stream.Collectors; @@ -281,10 +295,11 @@ public class Configuration { /** * 设置多租户处理器 + * * @author anwen * @date 2024/6/27 下午12:47 */ - public Configuration tenantHandler(TenantHandler tenantHandler){ + public Configuration tenantHandler(TenantHandler tenantHandler) { InterceptorCache.interceptors.add(new TenantInterceptor(tenantHandler)); return this; } @@ -383,7 +398,7 @@ public class Configuration { * @date 2024/3/19 18:39 */ public BaseMapper getBaseMapper() { - return new DefaultBaseMapperImpl(getMongoPlusClient(), new MappingMongoConverter(getMongoPlusClient(),new SimpleTypeHolder())); + return new DefaultBaseMapperImpl(getMongoPlusClient(), new MappingMongoConverter(getMongoPlusClient(), new SimpleTypeHolder())); } public BaseMapper getBaseMapper(MongoConverter mongoConverter) { @@ -391,7 +406,7 @@ public class Configuration { } public MongoPlusMapMapper getMongoPlusMapMapper() { - return new MongoPlusMapMapper(getMongoPlusClient(), new MappingMongoConverter(getMongoPlusClient(),new SimpleTypeHolder())); + return new MongoPlusMapMapper(getMongoPlusClient(), new MappingMongoConverter(getMongoPlusClient(), new SimpleTypeHolder())); } public MongoPlusMapMapper getMongoPlusMapMapper(MongoConverter mongoConverter) { @@ -491,4 +506,12 @@ public class Configuration { } + /** + * 设置感知类 + */ + public Configuration aware(Aware aware) { + AwareHandlerCache.putAware(aware); + return this; + } + } diff --git a/mongo-plus-core/src/main/java/com/anwen/mongo/conn/CollectionManager.java b/mongo-plus-core/src/main/java/com/anwen/mongo/conn/CollectionManager.java index 4aafdc48ef2cb26e484b6987a1da8ce32bd318f5..bd63734c31e5fe0b4383eff9be5e9c96a44234b4 100644 --- a/mongo-plus-core/src/main/java/com/anwen/mongo/conn/CollectionManager.java +++ b/mongo-plus-core/src/main/java/com/anwen/mongo/conn/CollectionManager.java @@ -50,9 +50,7 @@ public class CollectionManager { public MongoCollection getCollection(Class clazz) { String collectionName = this.collectionNameConvert.convert(clazz); - MongoCollection collection = getCollection(collectionName); - CollectionLogicDeleteCache.mapperClassByCollection(collection.getNamespace().getFullName(), clazz); - return collection; + return getCollection(collectionName); } public MongoCollection getCollection(String collectionName) { diff --git a/mongo-plus-core/src/main/java/com/anwen/mongo/logic/LogicDeleteHandler.java b/mongo-plus-core/src/main/java/com/anwen/mongo/logic/LogicDeleteHandler.java index b64385dba0812c75736a6eb2983f09d9063c36ff..52fbaa67718d05b2b0ae2952dcdc3407e45f7a1d 100644 --- a/mongo-plus-core/src/main/java/com/anwen/mongo/logic/LogicDeleteHandler.java +++ b/mongo-plus-core/src/main/java/com/anwen/mongo/logic/LogicDeleteHandler.java @@ -28,6 +28,13 @@ import java.util.Objects; */ public interface LogicDeleteHandler { + /** + * 判断这个链接对象是否可以忽略逻辑删除功能 + */ + static boolean close(MongoCollection collection) { + return close() || Objects.isNull(mapper().get(getBeanClass(collection))); + } + /** * 是否关闭逻辑删除功能 */ diff --git a/mongo-plus-core/src/main/java/com/anwen/mongo/logic/LogicNamespaceAware.java b/mongo-plus-core/src/main/java/com/anwen/mongo/logic/LogicNamespaceAware.java new file mode 100644 index 0000000000000000000000000000000000000000..7fdffd0829ec30b39d40d2c82394a0ac4a407111 --- /dev/null +++ b/mongo-plus-core/src/main/java/com/anwen/mongo/logic/LogicNamespaceAware.java @@ -0,0 +1,20 @@ +package com.anwen.mongo.logic; + +import com.anwen.mongo.aware.impl.NamespaceAware; +import com.anwen.mongo.cache.global.CollectionLogicDeleteCache; + +/** + * 逻辑删除链接命名空间感知类 + * + * @author loser + * @date 2024/6/29 + */ +public class LogicNamespaceAware implements NamespaceAware { + + @Override + public void nameSpaceAware(Namespace namespace) { + String fullName = namespace.getDataBase() + "." + namespace.getCollectionName(); + CollectionLogicDeleteCache.mapperClassByCollection(fullName, namespace.getEntityClass()); + } + +} diff --git a/mongo-plus-core/src/main/java/com/anwen/mongo/mapper/AbstractBaseMapper.java b/mongo-plus-core/src/main/java/com/anwen/mongo/mapper/AbstractBaseMapper.java index 374aea2a4e31cffd8cef084d15df5699ae1a8cb4..736ddc5b6bffa527890e72f88e67ffcd85dde102 100644 --- a/mongo-plus-core/src/main/java/com/anwen/mongo/mapper/AbstractBaseMapper.java +++ b/mongo-plus-core/src/main/java/com/anwen/mongo/mapper/AbstractBaseMapper.java @@ -1,7 +1,6 @@ package com.anwen.mongo.mapper; import com.anwen.mongo.aggregate.Aggregate; -import com.anwen.mongo.cache.global.CollectionLogicDeleteCache; import com.anwen.mongo.cache.global.InterceptorCache; import com.anwen.mongo.cache.global.TenantCache; import com.anwen.mongo.conditions.BuildCondition; @@ -20,22 +19,41 @@ import com.anwen.mongo.logic.LogicDeleteHandler; import com.anwen.mongo.manager.MongoPlusClient; import com.anwen.mongo.mapping.MongoConverter; import com.anwen.mongo.mapping.TypeReference; -import com.anwen.mongo.model.*; +import com.anwen.mongo.model.AggregateBasicDBObject; +import com.anwen.mongo.model.BaseAggregate; +import com.anwen.mongo.model.BaseLambdaQueryResult; +import com.anwen.mongo.model.MutablePair; +import com.anwen.mongo.model.PageParam; +import com.anwen.mongo.model.PageResult; +import com.anwen.mongo.toolkit.AggregateUtil; +import com.anwen.mongo.toolkit.CollUtil; +import com.anwen.mongo.toolkit.ConditionUtil; import com.anwen.mongo.toolkit.Filters; -import com.anwen.mongo.toolkit.*; +import com.anwen.mongo.toolkit.LambdaOperate; +import com.anwen.mongo.toolkit.Wrappers; import com.mongodb.BasicDBObject; import com.mongodb.bulk.BulkWriteResult; import com.mongodb.client.AggregateIterable; import com.mongodb.client.FindIterable; import com.mongodb.client.MongoCollection; -import com.mongodb.client.model.*; +import com.mongodb.client.model.CountOptions; +import com.mongodb.client.model.CreateIndexOptions; +import com.mongodb.client.model.DropIndexOptions; +import com.mongodb.client.model.IndexModel; +import com.mongodb.client.model.IndexOptions; +import com.mongodb.client.model.WriteModel; import com.mongodb.client.result.InsertManyResult; import org.bson.Document; import org.bson.conversions.Bson; import org.bson.types.ObjectId; import java.io.Serializable; -import java.util.*; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.Objects; import java.util.stream.Collectors; /** @@ -174,18 +192,26 @@ public abstract class AbstractBaseMapper implements BaseMapper { Execute execute = factory.getExecute(); MongoCollection collection = mongoPlusClient.getCollection(database, collectionName); long line; - if (!(CollectionLogicDeleteCache.open && - Objects.nonNull(LogicDeleteHandler.mapper().get(LogicDeleteHandler.getBeanClass(collection)))) && - CollUtil.isEmpty(queryChainWrapper.getCompareList()) && - (TenantCache.getIgnoreTenant() != null || - InterceptorCache.getTenant() == null)){ + if (canEstimatedDocumentCount(collection, queryChainWrapper)) { line = execute.estimatedDocumentCount(collection); } else { - line = execute.executeCount(BuildCondition.buildQueryCondition(queryChainWrapper.getCompareList()),null,collection); + line = execute.executeCount(BuildCondition.buildQueryCondition(queryChainWrapper.getCompareList()), null, collection); } return line; } + /** + * 判断是否可以使用 mongo 快速估计文档数量 + */ + private boolean canEstimatedDocumentCount(MongoCollection collection, QueryChainWrapper queryChainWrapper) { + + // 忽略逻辑删除 + 条件为空 + 忽略多租户 + return LogicDeleteHandler.close(collection) + && (Objects.isNull(queryChainWrapper) || CollUtil.isEmpty(queryChainWrapper.getCompareList())) + && (TenantCache.getIgnoreTenant() != null || InterceptorCache.getTenant() == null); + + } + @Override public long recentPageCount(String database, String collectionName, List compareConditionList, Integer pageNum, Integer pageSize, Integer recentPageNum) { if (recentPageNum == null || !(recentPageNum <= 50 && recentPageNum >= 5)) { @@ -286,14 +312,10 @@ public abstract class AbstractBaseMapper implements BaseMapper { BaseLambdaQueryResult baseLambdaQuery = lambdaOperate.baseLambdaQuery(queryChainWrapper.getCompareList(),queryChainWrapper.getOrderList(),queryChainWrapper.getProjectionList(),queryChainWrapper.getBasicDBObjectList()); MongoCollection collection = mongoPlusClient.getCollection(database, collectionName); long count; - if (!(CollectionLogicDeleteCache.open && - Objects.nonNull(LogicDeleteHandler.mapper().get(LogicDeleteHandler.getBeanClass(collection)))) && - CollUtil.isEmpty(queryChainWrapper.getCompareList()) && - (TenantCache.getIgnoreTenant() != null || - InterceptorCache.getTenant() == null)){ + if (canEstimatedDocumentCount(collection, queryChainWrapper)) { count = factory.getExecute().estimatedDocumentCount(collection); - }else { - count = count(database,collectionName,queryChainWrapper); + } else { + count = count(database, collectionName, queryChainWrapper); } FindIterable iterable = factory.getExecute().executeQuery(baseLambdaQuery.getCondition(), baseLambdaQuery.getProjection(), baseLambdaQuery.getSort(), Document.class, collection); return lambdaOperate.getLambdaQueryResultPage(iterable, count, new PageParam(pageNum, pageSize), typeReference, mongoConverter); @@ -321,14 +343,10 @@ public abstract class AbstractBaseMapper implements BaseMapper { BaseLambdaQueryResult baseLambdaQuery = lambdaOperate.baseLambdaQuery(queryChainWrapper.getCompareList(),queryChainWrapper.getOrderList(),queryChainWrapper.getProjectionList(),queryChainWrapper.getBasicDBObjectList()); MongoCollection collection = mongoPlusClient.getCollection(database, collectionName); long count; - if (!(CollectionLogicDeleteCache.open && - Objects.nonNull(LogicDeleteHandler.mapper().get(LogicDeleteHandler.getBeanClass(collection)))) && - CollUtil.isEmpty(queryChainWrapper.getCompareList()) && - (TenantCache.getIgnoreTenant() != null || - InterceptorCache.getTenant() == null)){ + if (canEstimatedDocumentCount(collection, queryChainWrapper)) { count = factory.getExecute().estimatedDocumentCount(collection); - }else { - count = recentPageCount(database,collectionName,queryChainWrapper.getCompareList(), pageNum, pageSize, recentPageNum); + } else { + count = recentPageCount(database, collectionName, queryChainWrapper.getCompareList(), pageNum, pageSize, recentPageNum); } FindIterable iterable = factory.getExecute().executeQuery(baseLambdaQuery.getCondition(), baseLambdaQuery.getProjection(), baseLambdaQuery.getSort(), Document.class, collection); return lambdaOperate.getLambdaQueryResultPage(iterable, count,new PageParam(pageNum,pageSize),typeReference,mongoConverter); @@ -385,10 +403,7 @@ public abstract class AbstractBaseMapper implements BaseMapper { MongoCollection collection = mongoPlusClient.getCollection(database, collectionName); Execute execute = factory.getExecute(); long line; - if (!(CollectionLogicDeleteCache.open && - Objects.nonNull(LogicDeleteHandler.mapper().get(LogicDeleteHandler.getBeanClass(collection)))) && - (TenantCache.getIgnoreTenant() != null || - InterceptorCache.getTenant() == null)){ + if (canEstimatedDocumentCount(collection, null)){ line = execute.estimatedDocumentCount(collection); } else { line = execute.executeCount(null,null,collection); diff --git a/mongo-plus-core/src/main/java/com/anwen/mongo/mapper/DefaultBaseMapperImpl.java b/mongo-plus-core/src/main/java/com/anwen/mongo/mapper/DefaultBaseMapperImpl.java index d7c9976ffa8109203627d0c662d7880c09e4762c..ac68d929190e4e435dfbcec9bfd95388cdcabe0a 100644 --- a/mongo-plus-core/src/main/java/com/anwen/mongo/mapper/DefaultBaseMapperImpl.java +++ b/mongo-plus-core/src/main/java/com/anwen/mongo/mapper/DefaultBaseMapperImpl.java @@ -1,6 +1,8 @@ package com.anwen.mongo.mapper; import com.anwen.mongo.aggregate.Aggregate; +import com.anwen.mongo.aware.MongoAwareUtils; +import com.anwen.mongo.aware.impl.NamespaceAware; import com.anwen.mongo.conditions.aggregate.AggregateChainWrapper; import com.anwen.mongo.conditions.interfaces.condition.CompareCondition; import com.anwen.mongo.conditions.query.QueryChainWrapper; @@ -11,7 +13,11 @@ import com.anwen.mongo.mapping.MongoConverter; import com.anwen.mongo.mapping.TypeReference; import com.anwen.mongo.model.MutablePair; import com.anwen.mongo.model.PageResult; -import com.mongodb.client.model.*; +import com.mongodb.client.model.CreateIndexOptions; +import com.mongodb.client.model.DropIndexOptions; +import com.mongodb.client.model.IndexModel; +import com.mongodb.client.model.IndexOptions; +import com.mongodb.client.model.WriteModel; import org.bson.Document; import org.bson.conversions.Bson; @@ -30,286 +36,340 @@ public class DefaultBaseMapperImpl extends AbstractBaseMapper { private final MongoPlusClient mongoPlusClient; - public DefaultBaseMapperImpl(MongoPlusClient mongoPlusClient,MongoConverter mongoConverter) { - super(mongoPlusClient,mongoConverter,new ExecutorFactory()); + public DefaultBaseMapperImpl(MongoPlusClient mongoPlusClient, MongoConverter mongoConverter) { + super(mongoPlusClient, mongoConverter, new ExecutorFactory()); this.mongoPlusClient = mongoPlusClient; } - public DefaultBaseMapperImpl(MongoPlusClient mongoPlusClient,MongoConverter mongoConverter,ExecutorFactory factory) { - super(mongoPlusClient,mongoConverter,factory); + public DefaultBaseMapperImpl(MongoPlusClient mongoPlusClient, MongoConverter mongoConverter, ExecutorFactory factory) { + super(mongoPlusClient, mongoConverter, factory); this.mongoPlusClient = mongoPlusClient; } @Override - public boolean save(T entity){ - return save(getDateBase(entity.getClass()),getCollectionName(entity.getClass()),entity); + public boolean save(T entity) { + MutablePair namespace = getNamespace(entity.getClass()); + return save(namespace.left, namespace.right, entity); } @Override public Boolean saveBatch(Collection entityList) { Class clazz = entityList.iterator().next().getClass(); - return saveBatch(getDateBase(clazz),getCollectionName(clazz),entityList); + MutablePair namespace = getNamespace(clazz); + return saveBatch(namespace.left, namespace.right, entityList); } @Override public Long update(Bson queryBasic, Bson updateBasic, Class clazz) { - return update(getDateBase(clazz),getCollectionName(clazz),queryBasic,updateBasic); + MutablePair namespace = getNamespace(clazz); + return update(namespace.left, namespace.right, queryBasic, updateBasic); } @Override public Integer bulkWrite(List> writeModelList, Class clazz) { - return bulkWrite(getDateBase(clazz),getCollectionName(clazz),writeModelList); + MutablePair namespace = getNamespace(clazz); + return bulkWrite(namespace.left, namespace.right, writeModelList); } @Override - public Boolean update(T entity,QueryChainWrapper queryChainWrapper){ - return update(getDateBase(entity.getClass()),getCollectionName(entity.getClass()),entity,queryChainWrapper); + public Boolean update(T entity, QueryChainWrapper queryChainWrapper) { + MutablePair namespace = getNamespace(entity.getClass()); + return update(namespace.left, namespace.right, entity, queryChainWrapper); } /** * 查询所有 - * @param clazz 操作的class + * + * @param clazz 操作的class * @param rClazz 返回的class * @return {@link List } * @author anwen * @date 2024/5/4 下午1:24 */ @Override - public List list(Class clazz,Class rClazz) { - return list(getDateBase(clazz),getCollectionName(clazz),rClazz); + public List list(Class clazz, Class rClazz) { + MutablePair namespace = getNamespace(clazz); + return list(namespace.left, namespace.right, rClazz); } @Override public List list(Class clazz, TypeReference typeReference) { - return list(getDateBase(clazz),getCollectionName(clazz),typeReference); + MutablePair namespace = getNamespace(clazz); + return list(namespace.left, namespace.right, typeReference); } @Override - public List list(QueryChainWrapper queryChainWrapper, Class clazz,Class rClazz) { - return list(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper,rClazz); + public List list(QueryChainWrapper queryChainWrapper, Class clazz, Class rClazz) { + MutablePair namespace = getNamespace(clazz); + return list(namespace.left, namespace.right, queryChainWrapper, rClazz); } @Override public List list(QueryChainWrapper queryChainWrapper, Class clazz, TypeReference typeReference) { - return list(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper,typeReference); + MutablePair namespace = getNamespace(clazz); + return list(namespace.left, namespace.right, queryChainWrapper, typeReference); } @Override - public List aggregateList(AggregateChainWrapper queryChainWrapper, Class clazz,Class rClazz){ - return aggregateList(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper,rClazz); + public List aggregateList(AggregateChainWrapper queryChainWrapper, Class clazz, Class rClazz) { + MutablePair namespace = getNamespace(clazz); + return aggregateList(namespace.left, namespace.right, queryChainWrapper, rClazz); } @Override public List aggregateList(AggregateChainWrapper queryChainWrapper, Class clazz, TypeReference typeReference) { - return aggregateList(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper,typeReference); + MutablePair namespace = getNamespace(clazz); + return aggregateList(namespace.left, namespace.right, queryChainWrapper, typeReference); } @Override public List aggregateList(Aggregate aggregate, Class clazz, Class rClazz) { - return aggregateList(getDateBase(clazz),getCollectionName(clazz),aggregate,rClazz); + MutablePair namespace = getNamespace(clazz); + return aggregateList(namespace.left, namespace.right, aggregate, rClazz); } @Override public List aggregateList(Aggregate aggregate, Class clazz, TypeReference typeReference) { - return aggregateList(getDateBase(clazz),getCollectionName(clazz),aggregate,typeReference); + MutablePair namespace = getNamespace(clazz); + return aggregateList(namespace.left, namespace.right, aggregate, typeReference); } @Override - public R one(QueryChainWrapper queryChainWrapper,Class clazz,Class rClazz) { - return one(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper,rClazz); + public R one(QueryChainWrapper queryChainWrapper, Class clazz, Class rClazz) { + MutablePair namespace = getNamespace(clazz); + return one(namespace.left, namespace.right, queryChainWrapper, rClazz); } @Override public R one(QueryChainWrapper queryChainWrapper, Class clazz, TypeReference typeReference) { - return one(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper,typeReference); + MutablePair namespace = getNamespace(clazz); + return one(namespace.left, namespace.right, queryChainWrapper, typeReference); } @Override - public PageResult page(QueryChainWrapper queryChainWrapper, Integer pageNum, Integer pageSize,Class clazz,Class rClazz) { - return page(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper,pageNum,pageSize,rClazz); + public PageResult page(QueryChainWrapper queryChainWrapper, Integer pageNum, Integer pageSize, Class clazz, Class rClazz) { + MutablePair namespace = getNamespace(clazz); + return page(namespace.left, namespace.right, queryChainWrapper, pageNum, pageSize, rClazz); } @Override public PageResult page(QueryChainWrapper queryChainWrapper, Integer pageNum, Integer pageSize, Class clazz, TypeReference typeReference) { - return page(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper,pageNum,pageSize,typeReference); + MutablePair namespace = getNamespace(clazz); + return page(namespace.left, namespace.right, queryChainWrapper, pageNum, pageSize, typeReference); } @Override - public List pageList(QueryChainWrapper queryChainWrapper, Integer pageNum, Integer pageSize, Class clazz,Class rClazz) { - return pageList(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper,pageNum,pageSize,rClazz); + public List pageList(QueryChainWrapper queryChainWrapper, Integer pageNum, Integer pageSize, Class clazz, Class rClazz) { + MutablePair namespace = getNamespace(clazz); + return pageList(namespace.left, namespace.right, queryChainWrapper, pageNum, pageSize, rClazz); } @Override public List pageList(QueryChainWrapper queryChainWrapper, Integer pageNum, Integer pageSize, Class clazz, TypeReference typeReference) { - return pageList(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper,pageNum,pageSize,typeReference); + MutablePair namespace = getNamespace(clazz); + return pageList(namespace.left, namespace.right, queryChainWrapper, pageNum, pageSize, typeReference); } @Override - public PageResult page(QueryChainWrapper queryChainWrapper, Integer pageNum, Integer pageSize, Integer recentPageNum, Class clazz,Class rClazz) { - return page(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper,pageNum,pageSize,recentPageNum,rClazz); + public PageResult page(QueryChainWrapper queryChainWrapper, Integer pageNum, Integer pageSize, Integer recentPageNum, Class clazz, Class rClazz) { + MutablePair namespace = getNamespace(clazz); + return page(namespace.left, namespace.right, queryChainWrapper, pageNum, pageSize, recentPageNum, rClazz); } @Override public PageResult page(QueryChainWrapper queryChainWrapper, Integer pageNum, Integer pageSize, Integer recentPageNum, Class clazz, TypeReference typeReference) { - return page(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper,pageNum,pageSize,recentPageNum,typeReference); + MutablePair namespace = getNamespace(clazz); + return page(namespace.left, namespace.right, queryChainWrapper, pageNum, pageSize, recentPageNum, typeReference); } @Override - public R getById(Serializable id,Class clazz,Class rClazz) { - return getById(getDateBase(clazz),getCollectionName(clazz),id,rClazz); + public R getById(Serializable id, Class clazz, Class rClazz) { + MutablePair namespace = getNamespace(clazz); + return getById(namespace.left, namespace.right, id, rClazz); } @Override public R getById(Serializable id, Class clazz, TypeReference typeReference) { - return getById(getDateBase(clazz),getCollectionName(clazz),id,typeReference); + MutablePair namespace = getNamespace(clazz); + return getById(namespace.left, namespace.right, id, typeReference); } @Override - public boolean isExist(Serializable id,Class clazz){ - return isExist(getDateBase(clazz),getCollectionName(clazz),id); + public boolean isExist(Serializable id, Class clazz) { + MutablePair namespace = getNamespace(clazz); + return isExist(namespace.left, namespace.right, id); } @Override - public boolean isExist(QueryChainWrapper queryChainWrapper,Class clazz){ - return isExist(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper); + public boolean isExist(QueryChainWrapper queryChainWrapper, Class clazz) { + MutablePair namespace = getNamespace(clazz); + return isExist(namespace.left, namespace.right, queryChainWrapper); } @Override - public List getByIds(Collection ids,Class clazz,Class rClazz) { - return getByIds(getDateBase(clazz),getCollectionName(clazz),ids,rClazz); + public List getByIds(Collection ids, Class clazz, Class rClazz) { + MutablePair namespace = getNamespace(clazz); + return getByIds(namespace.left, namespace.right, ids, rClazz); } @Override public List getByIds(Collection ids, Class clazz, TypeReference typeReference) { - return getByIds(getDateBase(clazz),getCollectionName(clazz),ids,typeReference); + MutablePair namespace = getNamespace(clazz); + return getByIds(namespace.left, namespace.right, ids, typeReference); } @Override - public Boolean update(UpdateChainWrapper updateChainWrapper,Class clazz) { - return update(getDateBase(clazz),getCollectionName(clazz),updateChainWrapper); + public Boolean update(UpdateChainWrapper updateChainWrapper, Class clazz) { + MutablePair namespace = getNamespace(clazz); + return update(namespace.left, namespace.right, updateChainWrapper); } @Override public Boolean remove(UpdateChainWrapper updateChainWrapper, Class clazz) { - return remove(getDateBase(clazz),getCollectionName(clazz),updateChainWrapper); + MutablePair namespace = getNamespace(clazz); + return remove(namespace.left, namespace.right, updateChainWrapper); } @Override public Long remove(Bson filter, Class clazz) { - return remove(getDateBase(clazz),getCollectionName(clazz),filter); + MutablePair namespace = getNamespace(clazz); + return remove(namespace.left, namespace.right, filter); } @Override - public long count(QueryChainWrapper queryChainWrapper,Class clazz){ - return count(getDateBase(clazz),getCollectionName(clazz),queryChainWrapper); + public long count(QueryChainWrapper queryChainWrapper, Class clazz) { + MutablePair namespace = getNamespace(clazz); + return count(namespace.left, namespace.right, queryChainWrapper); } /** * 分页查询 查询总条数 + * * @param compareConditionList 条件集合 - * @param clazz result class - * @param pageNum 当前页 - * @param pageSize 每页显示行数 - * @param recentPageNum 查询最近n页的数据 {参数=null 表示仅查询当前页数据} {参数取值[5-50] 表示查询最近[5-50]页的数据 建议recentPageNum等于10 参考 百度分页检索} + * @param clazz result class + * @param pageNum 当前页 + * @param pageSize 每页显示行数 + * @param recentPageNum 查询最近n页的数据 {参数=null 表示仅查询当前页数据} {参数取值[5-50] 表示查询最近[5-50]页的数据 建议recentPageNum等于10 参考 百度分页检索} * @return long */ @Override - public long recentPageCount(List compareConditionList,Class clazz, Integer pageNum, Integer pageSize, Integer recentPageNum){ - return recentPageCount(getDateBase(clazz),getCollectionName(clazz),compareConditionList,pageNum,pageSize,recentPageNum); + public long recentPageCount(List compareConditionList, Class clazz, Integer pageNum, Integer pageSize, Integer recentPageNum) { + MutablePair namespace = getNamespace(clazz); + return recentPageCount(namespace.left, namespace.right, compareConditionList, pageNum, pageSize, recentPageNum); } @Override - public long count(Class clazz){ - return count(getDateBase(clazz),getCollectionName(clazz)); + public long count(Class clazz) { + MutablePair namespace = getNamespace(clazz); + return count(namespace.left, namespace.right); } @Override - public List queryCommand(String command,Class clazz,Class rClazz){ - return queryCommand(getDateBase(clazz),getCollectionName(clazz),command,rClazz); + public List queryCommand(String command, Class clazz, Class rClazz) { + MutablePair namespace = getNamespace(clazz); + return queryCommand(namespace.left, namespace.right, command, rClazz); } @Override public List queryCommand(String command, Class clazz, TypeReference typeReference) { - return queryCommand(getDateBase(clazz),getCollectionName(clazz),command,typeReference); + MutablePair namespace = getNamespace(clazz); + return queryCommand(namespace.left, namespace.right, command, typeReference); } @Override - public List getByColumn(String column,Object value,Class clazz,Class rClazz){ - return getByColumn(getDateBase(clazz),getCollectionName(clazz),column,value,rClazz); + public List getByColumn(String column, Object value, Class clazz, Class rClazz) { + MutablePair namespace = getNamespace(clazz); + return getByColumn(namespace.left, namespace.right, column, value, rClazz); } @Override public List getByColumn(String column, Object value, Class clazz, TypeReference typeReference) { - return getByColumn(getDateBase(clazz),getCollectionName(clazz),column,value,typeReference); + MutablePair namespace = getNamespace(clazz); + return getByColumn(namespace.left, namespace.right, column, value, typeReference); } @Override - public String createIndex(Bson bson,Class clazz){ - return createIndex(getDateBase(clazz),getCollectionName(clazz),bson); + public String createIndex(Bson bson, Class clazz) { + MutablePair namespace = getNamespace(clazz); + return createIndex(namespace.left, namespace.right, bson); } @Override - public String createIndex(Bson bson, IndexOptions indexOptions, Class clazz){ - return createIndex(getDateBase(clazz),getCollectionName(clazz),bson,indexOptions); + public String createIndex(Bson bson, IndexOptions indexOptions, Class clazz) { + MutablePair namespace = getNamespace(clazz); + return createIndex(namespace.left, namespace.right, bson, indexOptions); } @Override - public List createIndexes(List indexes,Class clazz){ - return createIndexes(getDateBase(clazz),getCollectionName(clazz),indexes); + public List createIndexes(List indexes, Class clazz) { + MutablePair namespace = getNamespace(clazz); + return createIndexes(namespace.left, namespace.right, indexes); } @Override - public List createIndexes(List indexes, CreateIndexOptions createIndexOptions,Class clazz){ - return createIndexes(getDateBase(clazz),getCollectionName(clazz),indexes,createIndexOptions); + public List createIndexes(List indexes, CreateIndexOptions createIndexOptions, Class clazz) { + MutablePair namespace = getNamespace(clazz); + return createIndexes(namespace.left, namespace.right, indexes, createIndexOptions); } @Override - public List listIndexes(Class clazz){ - return listIndexes(getDateBase(clazz),getCollectionName(clazz)); + public List listIndexes(Class clazz) { + MutablePair namespace = getNamespace(clazz); + return listIndexes(namespace.left, namespace.right); } @Override - public void dropIndex(String indexName,Class clazz){ - dropIndex(getDateBase(clazz),getCollectionName(clazz),indexName); + public void dropIndex(String indexName, Class clazz) { + MutablePair namespace = getNamespace(clazz); + dropIndex(namespace.left, namespace.right, indexName); } @Override - public void dropIndex(String indexName,DropIndexOptions dropIndexOptions,Class clazz){ - dropIndex(getDateBase(clazz),getCollectionName(clazz),indexName,dropIndexOptions); + public void dropIndex(String indexName, DropIndexOptions dropIndexOptions, Class clazz) { + MutablePair namespace = getNamespace(clazz); + dropIndex(namespace.left, namespace.right, indexName, dropIndexOptions); } @Override - public void dropIndex(Bson keys,Class clazz){ - dropIndex(getDateBase(clazz),getCollectionName(clazz),keys); + public void dropIndex(Bson keys, Class clazz) { + MutablePair namespace = getNamespace(clazz); + dropIndex(namespace.left, namespace.right, keys); } @Override - public void dropIndex(Bson keys,DropIndexOptions dropIndexOptions,Class clazz){ - dropIndex(getDateBase(clazz),getCollectionName(clazz),keys,dropIndexOptions); + public void dropIndex(Bson keys, DropIndexOptions dropIndexOptions, Class clazz) { + MutablePair namespace = getNamespace(clazz); + dropIndex(namespace.left, namespace.right, keys, dropIndexOptions); } @Override - public void dropIndexes(Class clazz){ - dropIndexes(getDateBase(clazz),getCollectionName(clazz)); + public void dropIndexes(Class clazz) { + MutablePair namespace = getNamespace(clazz); + dropIndexes(namespace.left, namespace.right); } @Override - public void dropIndexes(DropIndexOptions dropIndexOptions,Class clazz){ - dropIndexes(getDateBase(clazz),getCollectionName(clazz),dropIndexOptions); + public void dropIndexes(DropIndexOptions dropIndexOptions, Class clazz) { + MutablePair namespace = getNamespace(clazz); + dropIndexes(namespace.left, namespace.right, dropIndexOptions); } - protected MutablePair getNamespace(Class clazz){ + protected MutablePair getNamespace(Class clazz) { + String database = mongoPlusClient.getDatabase(clazz); - String collectionName = getCollectionName(clazz); - return new MutablePair<>(database,collectionName); - } + String collectionName = mongoPlusClient.getCollectionName(clazz); - protected String getDateBase(Class clazz){ - return mongoPlusClient.getDatabase(clazz); - } + // 发布感知事件 + NamespaceAware.Namespace namespace = NamespaceAware.NamespaceBuild.builder() + .dataBase(database).collectionName(collectionName).entityClass(clazz) + .build(); + List handlers = MongoAwareUtils.listHandlers(NamespaceAware.class); + for (NamespaceAware aware : handlers) { + aware.nameSpaceAware(namespace); + } + + return new MutablePair<>(database, collectionName); - protected String getCollectionName(Class clazz){ - return mongoPlusClient.getCollectionName(clazz); } }