Spring Data之MongoDB配置_org.springframework.data.mongodb.repository.suppor

一、重写基类扩展功能

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