springboot集成 mongodb以及mongodb简单工具类

前言

springboot集成 mongodb 有开箱即用的starter 因此集成还是很方便的

集成

添加依赖

  <!--mongodb-->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency>

添加配置

spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=mydatabase

使用

直接注入

@Autowiredprivate MongoTemplate mongoTemplate;

封装的简单工具类

public interface MongoRepository {MongoOperations getMongoTemplate();/*** 获取集合** @param collectionName 集合* @return MongoCollection*/MongoCollection<Document> getCollection(String collectionName);MongoCollection<Document> getCollection(Query query, String collectionName);/*** 插入** @param collectionName collectionName* @param doc            doc*/void insert(String collectionName, Document doc);/*** 更新文档** @param collectionName collectionName* @param filter         filter* @param updateDoc      文档* @return long*/long update(String collectionName, Bson filter, Document updateDoc);/*** 统计** @param collectionName collectionName* @param filter         filter* @return long*/long count(String collectionName, Bson filter);/*** 统计** @param collectionName collectionName* @param filter         filter* @return long*/long countByLimit(String collectionName, Integer limit, Bson filter);/*** 去重** @param collectionName collectionName* @param filter         filter* @param fieldName      fieldName* @return long*/long distinctCount(String collectionName, Bson filter, String fieldName);/*** 根据指定的管道聚合文档** @param collectionName collectionName* @param pipeline       pipeline* @return AggregateIterable*/AggregateIterable<Document> aggregate(String collectionName, List<Bson> pipeline);/*** 查找** @param collectionName collectionName* @param filter         filter* @return FindIterable*/FindIterable<Document> find(String collectionName, Bson filter);/*** 获取实体类对应的集合名称** @param entityClass entityClass* @return String*/String getCollectionName(Class<?> entityClass);//新增api /*** Insert the object into the collection for the entity type of the object to save.* <br />* The object is converted to the MongoDB native representation using an instance of {@see MongoConverter}.* <br />* If your object has an "Id' property, it will be set with the generated Id from MongoDB. If your Id property is a* String then MongoDB ObjectId will be used to populate that string. Otherwise, the conversion from ObjectId to your* property type will be handled by Spring's BeanWrapper class that leverages Type Conversion API. See* <a href="https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#validation" > Spring's* Type Conversion"</a> for more details.* <br />* Insert is used to initially store the object into the database. To update an existing object use the save method.* <br />* The {@code objectToSave} must not be collection-like.** @param objectToSave the object to store in the collection. Must not be {@literal null}.* @return the inserted object.* @throws IllegalArgumentException                          in case the {@code objectToSave} is collection-like.* @throws org.springframework.data.mapping.MappingException if the target collection name cannot be*                                                           {@link org.springframework.data.mongodb.core.MongoOperations#getCollectionName(java.lang.Class)} from the given object type.*/<T> T insert(T objectToSave);/*** Insert the object into the specified collection.* <br />* The object is converted to the MongoDB native representation using an instance of {@see MongoConverter}. Unless* configured otherwise, an instance of {@link MappingMongoConverter} will be used.* <br />* Insert is used to initially store the object into the database. To update an existing object use the save method.* <br />* The {@code objectToSave} must not be collection-like.** @param objectToSave   the object to store in the collection. Must not be {@literal null}.* @param collectionName name of the collection to store the object in. Must not be {@literal null}.* @return the inserted object.* @throws IllegalArgumentException in case the {@code objectToSave} is collection-like.*/<T> T insert(T objectToSave, String collectionName);/*** Insert a Collection of objects into a collection in a single batch write to the database.** @param batchToSave the batch of objects to save. Must not be {@literal null}.* @param entityClass class that determines the collection to use. Must not be {@literal null}.* @return the inserted objects that.* @throws org.springframework.data.mapping.MappingException if the target collection name cannot be*                                                           {@link org.springframework.data.mongodb.core.MongoOperations#getCollectionName(java.lang.Class)} from the given type.*/<T> Collection<T> insert(Collection<? extends T> batchToSave, Class<?> entityClass);/*** Insert a batch of objects into the specified collection in a single batch write to the database.** @param batchToSave    the list of objects to save. Must not be {@literal null}.* @param collectionName name of the collection to store the object in. Must not be {@literal null}.* @return the inserted objects that.*/<T> Collection<T> insert(Collection<? extends T> batchToSave, String collectionName);/*** Insert a mixed Collection of objects into a database collection determining the collection name to use based on the* class.** @param objectsToSave the list of objects to save. Must not be {@literal null}.* @return the inserted objects.* @throws org.springframework.data.mapping.MappingException if the target collection name cannot be*                                                           {@link org.springframework.data.mongodb.core.MongoOperations#getCollectionName(java.lang.Class)} for the given objects.*/<T> Collection<T> insertAll(Collection<? extends T> objectsToSave);/*** Save the object to the collection for the entity type of the object to save. This will perform an insert if the* object is not already present, that is an 'upsert'.* <br />* The object is converted to the MongoDB native representation using an instance of {@see MongoConverter}. Unless* configured otherwise, an instance of {@link MappingMongoConverter} will be used.* <br />* If your object has an "Id' property, it will be set with the generated Id from MongoDB. If your Id property is a* String then MongoDB ObjectId will be used to populate that string. Otherwise, the conversion from ObjectId to your* property type will be handled by Spring's BeanWrapper class that leverages Type Conversion API. See* <a href="https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#validation" > Spring's* Type Conversion"</a> for more details.* <br />* The {@code objectToSave} must not be collection-like.** @param objectToSave the object to store in the collection. Must not be {@literal null}.* @return the saved object.* @throws IllegalArgumentException                          in case the {@code objectToSave} is collection-like.* @throws org.springframework.data.mapping.MappingException if the target collection name cannot be*                                                           {@link org.springframework.data.mongodb.core.MongoOperations#getCollectionName(java.lang.Class)} from the given object type.*/<T> T save(T objectToSave);/*** Save the object to the specified collection. This will perform an insert if the object is not already present, that* is an 'upsert'.* <br />* The object is converted to the MongoDB native representation using an instance of {@see MongoConverter}. Unless* configured otherwise, an instance of {@link MappingMongoConverter} will be used.* <br />* If your object has an "Id' property, it will be set with the generated Id from MongoDB. If your Id property is a* String then MongoDB ObjectId will be used to populate that string. Otherwise, the conversion from ObjectId to your* property type will be handled by Spring's BeanWrapper class that leverages Type Conversion API.* See <a href="https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#validation">Spring's Type Conversion</a> for more details.* <br />* The {@code objectToSave} must not be collection-like.** @param objectToSave   the object to store in the collection. Must not be {@literal null}.* @param collectionName name of the collection to store the object in. Must not be {@literal null}.* @return the saved object.* @throws IllegalArgumentException in case the {@code objectToSave} is collection-like.*/<T> T save(T objectToSave, String collectionName);/*** Map the results of an ad-hoc query on the collection for the entity class to a single instance of an object of the* specified type.* <br />* The object is converted from the MongoDB native representation using an instance of {@see MongoConverter}. Unless* configured otherwise, an instance of {@link MappingMongoConverter} will be used.* <br />* The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more* feature rich {@link Query}.** @param query       the query class that specifies the criteria used to find a record and also an optional fields*                    specification.* @param entityClass the parametrized type of the returned list.* @return the converted object.*/@Nullable<T> T findOne(Query query, Class<T> entityClass);/*** Map the results of an ad-hoc query on the specified collection to a single instance of an object of the specified* type.* <br />* The object is converted from the MongoDB native representation using an instance of {@see MongoConverter}. Unless* configured otherwise, an instance of {@link MappingMongoConverter} will be used.* <br />* The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more* feature rich {@link Query}.** @param query          the query class that specifies the criteria used to find a record and also an optional fields*                       specification.* @param entityClass    the parametrized type of the returned list.* @param collectionName name of the collection to retrieve the objects from.* @return the converted object.*/@Nullable<T> T findOne(Query query, Class<T> entityClass, String collectionName);/*** Determine result of given {@link Query} contains at least one element. <br />* <strong>NOTE:</strong> Any additional support for query/field mapping, etc. is not available due to the lack of* domain type information. Use {@link #exists(Query, Class, String)} to get full type specific support.** @param query          the {@link Query} class that specifies the criteria used to find a record.* @param collectionName name of the collection to check for objects.* @return {@literal true} if the query yields a result.*/boolean exists(Query query, String collectionName);/*** Determine result of given {@link Query} contains at least one element.** @param query       the {@link Query} class that specifies the criteria used to find a record.* @param entityClass the parametrized type.* @return {@literal true} if the query yields a result.*/boolean exists(Query query, Class<?> entityClass);/*** Determine result of given {@link Query} contains at least one element.** @param query          the {@link Query} class that specifies the criteria used to find a record.* @param entityClass    the parametrized type. Can be {@literal null}.* @param collectionName name of the collection to check for objects.* @return {@literal true} if the query yields a result.*/boolean exists(Query query, @Nullable Class<?> entityClass, String collectionName);/*** Map the results of an ad-hoc query on the collection for the entity class to a List of the specified type.* <br />* The object is converted from the MongoDB native representation using an instance of {@see MongoConverter}. Unless* configured otherwise, an instance of {@link MappingMongoConverter} will be used.* <br />* The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more* feature rich {@link Query}.** @param query       the query class that specifies the criteria used to find a record and also an optional fields*                    specification. Must not be {@literal null}.* @param entityClass the parametrized type of the returned list. Must not be {@literal null}.* @return the List of converted objects.*/<T> List<T> find(Query query, Class<T> entityClass);/*** Map the results of an ad-hoc query on the specified collection to a List of the specified type.* <br />* The object is converted from the MongoDB native representation using an instance of {@see MongoConverter}. Unless* configured otherwise, an instance of {@link MappingMongoConverter} will be used.* <br />* The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more* feature rich {@link Query}.** @param query          the query class that specifies the criteria used to find a record and also an optional fields*                       specification. Must not be {@literal null}.* @param entityClass    the parametrized type of the returned list. Must not be {@literal null}.* @param collectionName name of the collection to retrieve the objects from. Must not be {@literal null}.* @return the List of converted objects.*/<T> List<T> find(Query query, Class<T> entityClass, String collectionName);/*** Returns a document with the given id mapped onto the given class. The collection the query is ran against will be* derived from the given target class as well.** @param id          the id of the document to return. Must not be {@literal null}.* @param entityClass the type the document shall be converted into. Must not be {@literal null}.* @return the document with the given id mapped onto the given target class.*/@Nullable<T> T findById(Object id, Class<T> entityClass);/*** Returns the document with the given id from the given collection mapped onto the given target class.** @param id             the id of the document to return.* @param entityClass    the type to convert the document to.* @param collectionName the collection to query for the document.* @return he converted object or {@literal null} if document does not exist.*/@Nullable<T> T findById(Object id, Class<T> entityClass, String collectionName);/*** Finds the distinct values for a specified {@literal field} across a single {@link MongoCollection} or view and* returns the results in a {@link List}.** @param field       the name of the field to inspect for distinct values. Must not be {@literal null}.* @param entityClass the domain type used for determining the actual {@link MongoCollection}. Must not be*                    {@literal null}.* @param resultClass the result type. Must not be {@literal null}.* @return never {@literal null}.* @since 2.1*/default <T> List<T> findDistinct(String field, Class<?> entityClass, Class<T> resultClass) {return findDistinct(new Query(), field, entityClass, resultClass);}/*** Finds the distinct values for a specified {@literal field} across a single {@link MongoCollection} or view and* returns the results in a {@link List}.** @param query       filter {@link Query} to restrict search. Must not be {@literal null}.* @param field       the name of the field to inspect for distinct values. Must not be {@literal null}.* @param entityClass the domain type used for determining the actual {@link MongoCollection} and mapping the*                    {@link Query} to the domain type fields. Must not be {@literal null}.* @param resultClass the result type. Must not be {@literal null}.* @return never {@literal null}.* @since 2.1*/<T> List<T> findDistinct(Query query, String field, Class<?> entityClass, Class<T> resultClass);/*** Finds the distinct values for a specified {@literal field} across a single {@link MongoCollection} or view and* returns the results in a {@link List}.** @param query          filter {@link Query} to restrict search. Must not be {@literal null}.* @param field          the name of the field to inspect for distinct values. Must not be {@literal null}.* @param collectionName the explicit name of the actual {@link MongoCollection}. Must not be {@literal null}.* @param entityClass    the domain type used for mapping the {@link Query} to the domain type fields.* @param resultClass    the result type. Must not be {@literal null}.* @return never {@literal null}.* @since 2.1*/<T> List<T> findDistinct(Query query, String field, String collectionName, Class<?> entityClass,Class<T> resultClass);/*** Finds the distinct values for a specified {@literal field} across a single {@link MongoCollection} or view and* returns the results in a {@link List}.** @param query       filter {@link Query} to restrict search. Must not be {@literal null}.* @param field       the name of the field to inspect for distinct values. Must not be {@literal null}.* @param collection  the explicit name of the actual {@link MongoCollection}. Must not be {@literal null}.* @param resultClass the result type. Must not be {@literal null}.* @return never {@literal null}.* @since 2.1*/default <T> List<T> findDistinct(Query query, String field, String collection, Class<T> resultClass) {return findDistinct(query, field, collection, Object.class, resultClass);}/*** Returns the number of documents for the given {@link Query} by querying the collection of the given entity class.* <br />* <strong>NOTE:</strong> Query {@link Query#getSkip() offset} and {@link Query#getLimit() limit} can have direct* influence on the resulting number of documents found as those values are passed on to the server and potentially* limit the range and order within which the server performs the count operation. Use an {@literal unpaged} query to* count all matches.* <br />* This method uses an* {@link com.mongodb.client.MongoCollection#countDocuments(org.bson.conversions.Bson, com.mongodb.client.model.CountOptions)* aggregation execution} even for empty {@link Query queries} which may have an impact on performance, but guarantees* shard, session and transaction compliance. In case an inaccurate count satisfies the applications needs use* {@link MongoOperations#estimatedCount(Class)} for empty queries instead.** @param query       the {@link Query} class that specifies the criteria used to find documents. Must not be*                    {@literal null}.* @param entityClass class that determines the collection to use. Must not be {@literal null}.* @return the count of matching documents.* @throws org.springframework.data.mapping.MappingException if the collection name cannot be*                                                           {@link org.springframework.data.mongodb.core.MongoOperations#getCollectionName(java.lang.Class)} from the given type.*/long count(Query query, Class<?> entityClass);/*** Returns the number of documents for the given {@link Query} querying the given collection. The given {@link Query}* must solely consist of document field references as we lack type information to map potential property references* onto document fields. Use {@link MongoOperations#count(Query, Class, String)} to get full type specific support. <br />* <strong>NOTE:</strong> Query {@link Query#getSkip() offset} and {@link Query#getLimit() limit} can have direct* influence on the resulting number of documents found as those values are passed on to the server and potentially* limit the range and order within which the server performs the count operation. Use an {@literal unpaged} query to* count all matches.* <br />* This method uses an* {@link com.mongodb.client.MongoCollection#countDocuments(org.bson.conversions.Bson, com.mongodb.client.model.CountOptions)* aggregation execution} even for empty {@link Query queries} which may have an impact on performance, but guarantees* shard, session and transaction compliance. In case an inaccurate count satisfies the applications needs use* {@link MongoOperations#estimatedCount(String)} for empty queries instead.** @param query          the {@link Query} class that specifies the criteria used to find documents.* @param collectionName must not be {@literal null} or empty.* @return the count of matching documents.* @see MongoOperations#count(Query, Class, String)*/long count(Query query, String collectionName);/*** 更新插入* Performs an upsert. If no document is found that matches the query, a new document is created and inserted by* combining the query document and the update document. <br />* <strong>NOTE:</strong> {@link Query#getSortObject() sorting} is not supported by {@code db.collection.updateOne}.* Use {@link MongoOperations#findAndModify(Query, UpdateDefinition, FindAndModifyOptions, Class, String)} instead.** @param query       the query document that specifies the criteria used to select a record to be upserted. Must not be*                    {@literal null}.* @param update      the {@link UpdateDefinition} that contains the updated object or {@code $} operators to manipulate*                    the existing object. Must not be {@literal null}.* @param entityClass class that determines the collection to use. Must not be {@literal null}.* @return the {@link UpdateResult} which lets you access the results of the previous write.* @throws org.springframework.data.mapping.MappingException if the target collection name cannot be*                                                           {@link MongoOperations#getCollectionName(Class) derived} from the given type.* @see Update* @see AggregationUpdate* @since 3.0*/UpdateResult upsert(Query query, UpdateDefinition update, Class<?> entityClass);/*** 更新插入* Performs an upsert. If no document is found that matches the query, a new document is created and inserted by* combining the query document and the update document. <br />* <strong>NOTE:</strong> Any additional support for field mapping, versions, etc. is not available due to the lack of* domain type information. Use {@link #upsert(Query, UpdateDefinition, Class, String)} to get full type specific* support. <br />* <strong>NOTE:</strong> {@link Query#getSortObject() sorting} is not supported by {@code db.collection.updateOne}.* Use {@link MongoOperations#findAndModify(Query, UpdateDefinition, FindAndModifyOptions, Class, String)} instead.** @param query          the query document that specifies the criteria used to select a record to be upserted. Must not be*                       {@literal null}.* @param update         the {@link UpdateDefinition} that contains the updated object or {@code $} operators to manipulate*                       the existing object. Must not be {@literal null}.* @param collectionName name of the collection to update the object in.* @return the {@link UpdateResult} which lets you access the results of the previous write.* @see Update* @see AggregationUpdate* @since 3.0*/UpdateResult upsert(Query query, UpdateDefinition update, String collectionName);/*** 更新插入* Performs an upsert. If no document is found that matches the query, a new document is created and inserted by* combining the query document and the update document.** @param query          the query document that specifies the criteria used to select a record to be upserted. Must not be*                       {@literal null}.* @param update         the {@link UpdateDefinition} that contains the updated object or {@code $} operators to manipulate*                       the existing object. Must not be {@literal null}.* @param entityClass    class of the pojo to be operated on. Must not be {@literal null}.* @param collectionName name of the collection to update the object in. Must not be {@literal null}.* @return the {@link UpdateResult} which lets you access the results of the previous write.* @see Update* @see AggregationUpdate* @since 3.0*/UpdateResult upsert(Query query, UpdateDefinition update, Class<?> entityClass, String collectionName);/*** Updates the first object that is found in the collection of the entity class that matches the query document with* the provided update document.** @param query       the query document that specifies the criteria used to select a record to be updated. Must not be*                    {@literal null}.* @param update      the {@link UpdateDefinition} that contains the updated object or {@code $} operators to manipulate*                    the existing. Must not be {@literal null}.* @param entityClass class that determines the collection to use.* @return the {@link UpdateResult} which lets you access the results of the previous write.* @throws org.springframework.data.mapping.MappingException if the target collection name cannot be*                                                           {@link MongoOperations#getCollectionName(Class) derived} from the given type.* @see Update* @see AggregationUpdate* @since 3.0*/UpdateResult updateFirst(Query query, UpdateDefinition update, Class<?> entityClass);/*** Updates the first object that is found in the specified collection that matches the query document criteria with* the provided updated document. <br />* <strong>NOTE:</strong> Any additional support for field mapping, versions, etc. is not available due to the lack of* domain type information. Use {@link #updateFirst(Query, UpdateDefinition, Class, String)} to get full type specific* support. <br />* <strong>NOTE:</strong> {@link Query#getSortObject() sorting} is not supported by {@code db.collection.updateOne}.* Use {@link MongoOperations#findAndModify(Query, UpdateDefinition, Class, String)} instead.** @param query          the query document that specifies the criteria used to select a record to be updated. Must not be*                       {@literal null}.* @param update         the {@link UpdateDefinition} that contains the updated object or {@code $} operators to manipulate*                       the existing. Must not be {@literal null}.* @param collectionName name of the collection to update the object in. Must not be {@literal null}.* @return the {@link UpdateResult} which lets you access the results of the previous write.* @see Update* @see AggregationUpdate* @since 3.0*/UpdateResult updateFirst(Query query, UpdateDefinition update, String collectionName);/*** Updates the first object that is found in the specified collection that matches the query document criteria with* the provided updated document. <br />** @param query          the query document that specifies the criteria used to select a record to be updated. Must not be*                       {@literal null}.* @param update         the {@link UpdateDefinition} that contains the updated object or {@code $} operators to manipulate*                       the existing. Must not be {@literal null}.* @param entityClass    class of the pojo to be operated on. Must not be {@literal null}.* @param collectionName name of the collection to update the object in. Must not be {@literal null}.* @return the {@link UpdateResult} which lets you access the results of the previous write.* @see Update* @see AggregationUpdate* @since 3.0*/UpdateResult updateFirst(Query query, UpdateDefinition update, Class<?> entityClass, String collectionName);/*** Updates all objects that are found in the collection for the entity class that matches the query document criteria* with the provided updated document.** @param query       the query document that specifies the criteria used to select a record to be updated. Must not be*                    {@literal null}.* @param update      the {@link UpdateDefinition} that contains the updated object or {@code $} operators to manipulate*                    the existing. Must not be {@literal null}.* @param entityClass class of the pojo to be operated on. Must not be {@literal null}.* @return the {@link UpdateResult} which lets you access the results of the previous write.* @throws org.springframework.data.mapping.MappingException if the target collection name cannot be*                                                           {@link MongoOperations#getCollectionName(Class) derived} from the given type.* @see Update* @see AggregationUpdate* @since 3.0*/UpdateResult updateMulti(Query query, UpdateDefinition update, Class<?> entityClass);/*** Updates all objects that are found in the specified collection that matches the query document criteria with the* provided updated document. <br />* <strong>NOTE:</strong> Any additional support for field mapping, versions, etc. is not available due to the lack of* domain type information. Use {@link #updateMulti(Query, UpdateDefinition, Class, String)} to get full type specific* support.** @param query          the query document that specifies the criteria used to select a record to be updated. Must not be*                       {@literal null}.* @param update         the {@link UpdateDefinition} that contains the updated object or {@code $} operators to manipulate*                       the existing. Must not be {@literal null}.* @param collectionName name of the collection to update the object in. Must not be {@literal null}.* @return the {@link UpdateResult} which lets you access the results of the previous write.* @see Update* @see AggregationUpdate* @since 3.0*/UpdateResult updateMulti(Query query, UpdateDefinition update, String collectionName);/*** Updates all objects that are found in the collection for the entity class that matches the query document criteria* with the provided updated document.** @param query          the query document that specifies the criteria used to select a record to be updated. Must not be*                       {@literal null}.* @param update         the {@link UpdateDefinition} that contains the updated object or {@code $} operators to manipulate*                       the existing. Must not be {@literal null}.* @param entityClass    class of the pojo to be operated on. Must not be {@literal null}.* @param collectionName name of the collection to update the object in. Must not be {@literal null}.* @return the {@link UpdateResult} which lets you access the results of the previous write.* @see Update* @see AggregationUpdate* @since 3.0*/UpdateResult updateMulti(Query query, UpdateDefinition update, Class<?> entityClass, String collectionName);/*** Remove the given object from the collection by {@literal id} and (if applicable) its* {@link org.springframework.data.annotation.Version}. <br />* Use {@link DeleteResult#getDeletedCount()} for insight whether an {@link DeleteResult#wasAcknowledged()* acknowledged} remove operation was successful or not.** @param object must not be {@literal null}.* @return the {@link DeleteResult} which lets you access the results of the previous delete.* @throws org.springframework.data.mapping.MappingException if the target collection name cannot be*                                                           {@link MongoOperations#getCollectionName(Class) derived} from the given object type.*/DeleteResult remove(Object object);/*** Removes the given object from the given collection by {@literal id} and (if applicable) its* {@link org.springframework.data.annotation.Version}. <br />* Use {@link DeleteResult#getDeletedCount()} for insight whether an {@link DeleteResult#wasAcknowledged()* acknowledged} remove operation was successful or not.** @param object         must not be {@literal null}.* @param collectionName name of the collection where the objects will removed, must not be {@literal null} or empty.* @return the {@link DeleteResult} which lets you access the results of the previous delete.*/DeleteResult remove(Object object, String collectionName);/*** Remove all documents that match the provided query document criteria from the the collection used to store the* entityClass. The Class parameter is also used to help convert the Id of the object if it is present in the query.** @param query       the query document that specifies the criteria used to remove a record.* @param entityClass class that determines the collection to use.* @return the {@link DeleteResult} which lets you access the results of the previous delete.* @throws IllegalArgumentException                          when {@literal query} or {@literal entityClass} is {@literal null}.* @throws org.springframework.data.mapping.MappingException if the target collection name cannot be*                                                           {@link MongoOperations#getCollectionName(Class) derived} from the given type.*/DeleteResult remove(Query query, Class<?> entityClass);/*** Remove all documents that match the provided query document criteria from the the collection used to store the* entityClass. The Class parameter is also used to help convert the Id of the object if it is present in the query.** @param query          the query document that specifies the criteria used to remove a record.* @param entityClass    class of the pojo to be operated on. Can be {@literal null}.* @param collectionName name of the collection where the objects will removed, must not be {@literal null} or empty.* @return the {@link DeleteResult} which lets you access the results of the previous delete.* @throws IllegalArgumentException when {@literal query}, {@literal entityClass} or {@literal collectionName} is*                                  {@literal null}.*/DeleteResult remove(Query query, Class<?> entityClass, String collectionName);/*** Remove all documents from the specified collection that match the provided query document criteria. There is no* conversion/mapping done for any criteria using the id field. <br />* <strong>NOTE:</strong> Any additional support for field mapping is not available due to the lack of domain type* information. Use {@link #remove(Query, Class, String)} to get full type specific support.** @param query          the query document that specifies the criteria used to remove a record.* @param collectionName name of the collection where the objects will removed, must not be {@literal null} or empty.* @return the {@link DeleteResult} which lets you access the results of the previous delete.* @throws IllegalArgumentException when {@literal query} or {@literal collectionName} is {@literal null}.*/DeleteResult remove(Query query, String collectionName);}

实现类

@Repository
public class MongoRepositoryImpl implements MongoRepository {@Autowiredprivate MongoTemplate mongoTemplate;@Overridepublic MongoOperations getMongoTemplate() {return mongoTemplate;}@Overridepublic MongoCollection<Document> getCollection(String collectionName) {return mongoTemplate.getCollection(collectionName);}@Overridepublic MongoCollection<Document> getCollection(Query query, String collectionName) {mongoTemplate.count(query, collectionName);return mongoTemplate.getCollection(collectionName);}@Overridepublic void insert(String collectionName, Document doc) {MongoCollection<Document> collection = getCollection(collectionName);collection.insertOne(doc);}@Overridepublic long count(String collectionName, Bson filter) {MongoCollection<Document> collection = getCollection(collectionName);return collection.countDocuments(filter);}@Overridepublic long countByLimit(String collectionName, Integer limit, Bson filter) {MongoCollection<Document> collection = getCollection(collectionName);CountOptions countOptions = new CountOptions();countOptions.limit(limit);return collection.countDocuments(filter, countOptions);}@Overridepublic long distinctCount(String collectionName, Bson filter, String fieldName) {MongoCollection<Document> collection = getCollection(collectionName);long count = 0;if (StringUtils.isEmpty(fieldName)) {return 0L;}for (BsonValue ignored : collection.distinct(fieldName, filter, BsonValue.class)) {count++;}return count;}@Overridepublic AggregateIterable<Document> aggregate(String collectionName, List<Bson> pipeline) {MongoCollection<Document> collection = getCollection(collectionName);return collection.aggregate(pipeline);}@Overridepublic FindIterable<Document> find(String collectionName, Bson filter) {MongoCollection<Document> collection = getCollection(collectionName);return collection.find(filter);}@Overridepublic long update(String collectionName, Bson filter, Document updateDoc) {MongoCollection<Document> collection = getCollection(collectionName);return collection.updateOne(filter, updateDoc).getModifiedCount();}@Overridepublic String getCollectionName(Class<?> entityClass) {return mongoTemplate.getCollectionName(entityClass);}@Overridepublic <T> T insert(T objectToSave) {return mongoTemplate.insert(objectToSave);}@Overridepublic <T> T insert(T objectToSave, String collectionName) {return mongoTemplate.insert(objectToSave, collectionName);}@Overridepublic <T> Collection<T> insert(Collection<? extends T> batchToSave, Class<?> entityClass) {return mongoTemplate.insert(batchToSave, entityClass);}@Overridepublic <T> Collection<T> insert(Collection<? extends T> batchToSave, String collectionName) {return mongoTemplate.insert(batchToSave, collectionName);}@Overridepublic <T> Collection<T> insertAll(Collection<? extends T> objectsToSave) {return mongoTemplate.insertAll(objectsToSave);}@Overridepublic <T> T save(T objectToSave) {return mongoTemplate.save(objectToSave);}@Overridepublic <T> T save(T objectToSave, String collectionName) {return mongoTemplate.save(objectToSave, collectionName);}@Overridepublic <T> T findOne(Query query, Class<T> entityClass) {return mongoTemplate.findOne(query, entityClass);}@Overridepublic <T> T findOne(Query query, Class<T> entityClass, String collectionName) {return mongoTemplate.findOne(query, entityClass, collectionName);}@Overridepublic boolean exists(Query query, String collectionName) {return mongoTemplate.exists(query, collectionName);}@Overridepublic boolean exists(Query query, Class<?> entityClass) {return mongoTemplate.exists(query, entityClass);}@Overridepublic boolean exists(Query query, Class<?> entityClass, String collectionName) {return mongoTemplate.exists(query, entityClass);}@Overridepublic <T> List<T> find(Query query, Class<T> entityClass) {return mongoTemplate.find(query, entityClass);}@Overridepublic <T> List<T> find(Query query, Class<T> entityClass, String collectionName) {return mongoTemplate.find(query, entityClass, collectionName);}@Overridepublic <T> T findById(Object id, Class<T> entityClass) {return mongoTemplate.findById(id, entityClass);}@Overridepublic <T> T findById(Object id, Class<T> entityClass, String collectionName) {return mongoTemplate.findById(id, entityClass, collectionName);}@Overridepublic <T> List<T> findDistinct(String field, Class<?> entityClass, Class<T> resultClass) {return mongoTemplate.findDistinct(field, entityClass, resultClass);}@Overridepublic <T> List<T> findDistinct(Query query, String field, Class<?> entityClass, Class<T> resultClass) {return mongoTemplate.findDistinct(query, field, entityClass, resultClass);}@Overridepublic <T> List<T> findDistinct(Query query, String field, String collectionName, Class<?> entityClass, Class<T> resultClass) {return mongoTemplate.findDistinct(query, field, collectionName, entityClass, resultClass);}@Overridepublic <T> List<T> findDistinct(Query query, String field, String collection, Class<T> resultClass) {return mongoTemplate.findDistinct(query, field, collection, resultClass);}@Overridepublic long count(Query query, Class<?> entityClass) {return mongoTemplate.count(query, entityClass);}@Overridepublic long count(Query query, String collectionName) {return mongoTemplate.count(query, collectionName);}@Overridepublic UpdateResult upsert(Query query, UpdateDefinition update, Class<?> entityClass) {return mongoTemplate.upsert(query, update, entityClass);}@Overridepublic UpdateResult upsert(Query query, UpdateDefinition update, String collectionName) {return mongoTemplate.upsert(query, update, collectionName);}@Overridepublic UpdateResult upsert(Query query, UpdateDefinition update, Class<?> entityClass, String collectionName) {return mongoTemplate.upsert(query, update, entityClass, collectionName);}@Overridepublic UpdateResult updateFirst(Query query, UpdateDefinition update, Class<?> entityClass) {return mongoTemplate.updateFirst(query, update, entityClass);}@Overridepublic UpdateResult updateFirst(Query query, UpdateDefinition update, String collectionName) {return mongoTemplate.updateFirst(query, update, collectionName);}@Overridepublic UpdateResult updateFirst(Query query, UpdateDefinition update, Class<?> entityClass, String collectionName) {return mongoTemplate.updateFirst(query, update, entityClass, collectionName);}@Overridepublic UpdateResult updateMulti(Query query, UpdateDefinition update, Class<?> entityClass) {return mongoTemplate.updateMulti(query, update, entityClass);}@Overridepublic UpdateResult updateMulti(Query query, UpdateDefinition update, String collectionName) {return mongoTemplate.updateMulti(query, update, collectionName);}@Overridepublic UpdateResult updateMulti(Query query, UpdateDefinition update, Class<?> entityClass, String collectionName) {return mongoTemplate.updateMulti(query, update, entityClass, collectionName);}@Overridepublic DeleteResult remove(Object object) {return mongoTemplate.remove(object);}@Overridepublic DeleteResult remove(Object object, String collectionName) {return mongoTemplate.remove(object, collectionName);}@Overridepublic DeleteResult remove(Query query, Class<?> entityClass) {return mongoTemplate.remove(query, entityClass);}@Overridepublic DeleteResult remove(Query query, Class<?> entityClass, String collectionName) {return mongoTemplate.remove(query, entityClass, collectionName);}@Overridepublic DeleteResult remove(Query query, String collectionName) {return mongoTemplate.remove(query, collectionName);}
}

后续直接使用仓库类即可
测试类

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
public class ProcessTest {@Autowiredprivate MongoRepository mongoRepository;@Testpublic void test() {String collectionName = mongoGateway.getCollectionName(User.class);System.out.println(collectionName);User user = new User();user.setId(1L);user.setUser_id(1111L);user.setAge(10);User user1 = mongoRepository.save(user, "user");System.out.println("新增user: " + JSON.toJSONString(user1));Query query = new Query();Criteria criteria = new Criteria(TableInfoEnum.USER.getUniqueFieldName());criteria.is(user.getUser_id());query.addCriteria(criteria);user.setAge(18);Update update = new Update();setUpdate(update, user);mongoRepository.updateMulti(query, update, User.class, "user");User one = mongoRepository.findOne(query, User.class, "user");System.out.println("one: " + JSON.toJSONString(one));}public void setUpdate(Update update, Object object) {if (null == object) {return;}Class<?> clazz = object.getClass();BeanInfo beanInfo;try {beanInfo = Introspector.getBeanInfo(clazz);PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {String name = propertyDescriptor.getName();if (!"class".equalsIgnoreCase(name)) {Method readMethod = propertyDescriptor.getReadMethod();readMethod.setAccessible(true);Object invoke = readMethod.invoke(object, null);if (null != invoke) {update.set(name, invoke);System.out.println("name: " + name + " invoke: " + invoke);}}}} catch (IntrospectionException | InvocationTargetException | IllegalAccessException e) {log.error("setUpdate属性失败,错误日志: {[]}", e);}}
}