Spring Data之MongoDB配置_org.springframework.data.mongodb.repository.suppor-CSDN博客

本文链接：https://blog.csdn.net/moakun/article/details/103547630

本文介绍了一种在Spring Boot应用中扩展MongoDB Repository的方法，通过创建自定义的IBaseRepository接口和BaseRepository类，实现了对MongoDB操作的增强，包括根据ID查询、按字段查询、聚合查询等功能，并展示了如何配置Spring Boot应用使用自定义的Repository基类。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、重写基类扩展功能

package com.mk.mongodb.repository;

import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.convert.MongoConverter;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.query.MongoEntityInformation;
import org.springframework.data.repository.NoRepositoryBean;
import java.util.Collection;
import java.util.List;

@NoRepositoryBean
public interface IBaseRepository<T, ID> extends MongoRepository<T, ID> {

    //根据id查询对象
    T find(ID id);

    T findOne(Criteria criteria);

    //查询对象id
    List<ID> findIdsByQuery(Query query);

    //根据字段名查询对象列表
    List<T> listAll();

    //根据id列表查询对象列表
    List<T> listByIds(Collection<ID> ids);

    //根据字段名查询对象列表
    List<T> listByField(String fieldName, Collection values);

    //根据字段名查询对象列表
    List<T> listByField(String fieldName, Object value);

    //根据字段名查询对象列表
    List<T> listByField(String fieldName1, Object value1, String fieldName2, Collection value2);

    //根据字段名查询对象列表
    List<T> listByField(String fieldName1, Object value1, String fieldName2, Object value2);

    //表名
    String getTableName();

    //id值
    ID getIdValue(T entity);

    //id属性名
    String getIdAttribute();

    //id列名
    String getIdColumn();

    //删除
    void deleteAll(Collection<ID> ids);

    //mongo操作对象
    MongoOperations getMongoOperations();

    //实体定义
    MongoEntityInformation<T, ID> getEntityInformation();

    //实体类
    Class<T> getEntityClass();

    //id类
    Class<ID> getIdClass();

    //mongo转换对象
    default MongoConverter getMongoConverter(){
        return getMongoOperations().getConverter();
    }

    //实例类base对象
    BaseRepository<T, ID> _baseThis();

    //查询数据
    List<T> find(Query query);

    //计算数量
    long count(Query query);

    //查询去重字段
    <F> List<F> findDistinct(Query query, String field, Class<F> clazz);

    //聚合
    <F> AggregationResults<F> aggregate(Aggregation aggregation, Class<F> clazz);
}

package com.mk.mongodb.repository;

import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.repository.query.MongoEntityInformation;
import org.springframework.data.mongodb.repository.support.SimpleMongoRepository;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

public class BaseRepository<T, ID> extends SimpleMongoRepository<T, ID> implements IBaseRepository<T, ID> {

    protected final MongoOperations mongoOperations;
    protected final MongoEntityInformation<T, ID> entityInformation;

    public BaseRepository(MongoEntityInformation<T, ID> metadata, MongoOperations mongoOperations) {
        super(metadata, mongoOperations);
        this.mongoOperations = mongoOperations;
        this.entityInformation = metadata;
    }

    @Override
    public T find(ID id) {
        return findById(id).orElse(null);
    }

    @Override
    public T findOne(Criteria criteria) {

        Query query = new Query(criteria);
        return this.mongoOperations.findOne(query, getEntityClass(), getTableName());
    }

    @Override
    public List<ID> findIdsByQuery(Query query) {

        return this.mongoOperations.findDistinct(query, this.getIdColumn(), getTableName(), getIdClass());
    }

    @Override
    public List<T> listAll() {
        return this.mongoOperations.findAll(getEntityClass(), getTableName());
    }

    @Override
    public List<T> listByIds(Collection<ID> ids) {

        Iterable<T> iterable =  findAllById(ids);
        if(iterable instanceof List){
            return (List<T>) iterable;
        }
        List<T> list = new LinkedList<>();
        iterable.forEach(list::add);
        return list;
    }

    @Override
    public List<T> listByField(String fieldName, Collection values) {

        Criteria criteria = new Criteria();
        criteria.and(fieldName).in(values);
        Query query = new Query(criteria);
        List<T> list = this.find(query);
        return list;
    }

    @Override
    public List<T> listByField(String fieldName, Object value) {

        Criteria criteria = new Criteria();
        criteria.and(fieldName).is(value);
        Query query = new Query(criteria);
        List<T> list = this.find(query);
        return list;
    }

    @Override
    public List<T> listByField(String fieldName1, Object value1, String fieldName2, Collection value2) {

        Criteria criteria = new Criteria();
        criteria.and(fieldName1).is(value1).and(fieldName2).in(value2);
        Query query = new Query(criteria);
        List<T> list = this.find(query);
        return list;
    }

    @Override
    public List<T> listByField(String fieldName1, Object value1, String fieldName2, Object value2) {

        Criteria criteria = new Criteria();
        criteria.and(fieldName1).is(value1).and(fieldName2).is(value2);
        Query query = new Query(criteria);
        List<T> list = this.find(query);
        return list;
    }


    @Override
    public String getTableName(){
        return entityInformation.getCollectionName();
    }

    @Override
    public ID getIdValue(T entity){
        return entityInformation.getId(entity);
    }

    @Override
    public String getIdAttribute(){
        return entityInformation.getIdAttribute();
    }

    @Override
    public String getIdColumn(){
        return "_id";
    }


    @Override
    public void deleteAll(Collection<ID> ids) {
        Criteria criteria = Criteria.where(this.getIdColumn()).in(ids);
        Query query = new Query(criteria);
        mongoOperations.remove(query, getTableName());
    }


    @Override
    public MongoOperations getMongoOperations() {
        return mongoOperations;
    }

    @Override
    public MongoEntityInformation<T, ID> getEntityInformation() {
        return entityInformation;
    }

    @Override
    public Class<T> getEntityClass() {
        return entityInformation.getJavaType();
    }

    @Override
    public Class<ID> getIdClass() {
        return entityInformation.getIdType();
    }

    @Override
    public BaseRepository<T, ID> _baseThis() {
        return this;
    }

    @Override
    public List<T> find(Query query) {
        return this.mongoOperations.find(query, getEntityClass(), getTableName());
    }

    @Override
    public long count(Query query) {
        return this.mongoOperations.count(query, getTableName());
    }

    @Override
    public <F> List<F> findDistinct(Query query, String field, Class<F> clazz) {
        return this.mongoOperations.findDistinct(query, field, getTableName(), clazz);
    }

    @Override
    public <F> AggregationResults<F> aggregate(Aggregation aggregation, Class<F> clazz) {
        return  this.mongoOperations.aggregate(aggregation, getTableName(), clazz);
    }

}

二、Repository继承新基类

package com.mk.mongodb.entity;

import org.bson.types.ObjectId;
import org.springframework.data.annotation.Id;

public class Config {
    @Id
    private ObjectId id;

    private String value;

    public ObjectId getId() {
        return id;
    }

    public void setId(ObjectId id) {
        this.id = id;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

}

package com.mk.mongodb.repository;

package com.mk.mongodb.entity.Config;
import org.bson.types.ObjectId;

@Repository
public interface ConfigRepository extends IBaseRepository<Config, ObjectId> {
   
}

三、配置MongoDB默认基类

package com.mk;

import com.mk.mongodb.repository.BaseRepository;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;

@SpringBootApplication
@EnableMongoRepositories(repositoryBaseClass = BaseRepository.class)
public class Application {

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}

}

数据库配置

spring:
   data:
      mongodb:
        uri: mongodb://username:password@192.168.1.2:40001,192.168.1.3:40001/configDb