xyz.erupt.mongodb.impl.EruptMongodbImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of erupt-mongodb Show documentation
EruptProcess mongodb impl
The newest version!
package xyz.erupt.mongodb.impl;

import lombok.SneakyThrows;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;
import xyz.erupt.annotation.query.Condition;
import xyz.erupt.core.exception.EruptFieldAnnotationException;
import xyz.erupt.core.invoke.DataProcessorManager;
import xyz.erupt.core.query.Column;
import xyz.erupt.core.query.EruptQuery;
import xyz.erupt.core.service.IEruptDataService;
import xyz.erupt.core.util.TypeUtil;
import xyz.erupt.core.view.EruptFieldModel;
import xyz.erupt.core.view.EruptModel;
import xyz.erupt.core.view.Page;

import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author YuePeng
 * date 2020-03-06.
 */
@Service
public class EruptMongodbImpl implements IEruptDataService, ApplicationRunner {

    public static final String MONGODB_PROCESS = "mongodb";

    @Resource
    private MongoTemplate mongoTemplate;

    private static final Map, Map> MODEL_CLASS_FIELD_MAPPING = new ConcurrentHashMap<>(16);

    @Override
    public Object findDataById(EruptModel eruptModel, Object id) {
        Query query = new Query(Criteria.where(eruptModel.getErupt().primaryKeyCol()).is(id));
        return mongoTemplate.findOne(query, eruptModel.getClazz());
    }

    @SneakyThrows
    @Override
    public Page queryList(EruptModel eruptModel, Page page, EruptQuery eruptQuery) {
        Query query = new Query();
        this.addQueryCondition(eruptModel, eruptQuery, query);
        page.setTotal(mongoTemplate.count(query, eruptModel.getClazz()));
        if (page.getTotal() > 0) {
            query.limit(page.getPageSize());
            query.skip((long) (page.getPageIndex() - 1) * page.getPageSize());
            if (StringUtils.isNotBlank(page.getSort())) {
                this.orderByTokenToQuery(eruptModel, query, page.getSort());
            } else if (!"".equals(eruptModel.getErupt().orderBy())) {
                this.orderByTokenToQuery(eruptModel, query, eruptModel.getErupt().orderBy());
            }
            List> newList = new ArrayList<>();
            for (Object obj : mongoTemplate.find(query, eruptModel.getClazz())) {
                newList.add(mongoObjectToMap(obj));
            }
            page.setList(newList);
        } else {
            page.setList(new ArrayList<>());
        }
        return page;
    }

    private void orderByTokenToQuery(EruptModel eruptModel, Query query, String orderByStr) {
        for (String s : orderByStr.split(",")) {
            String[] orderBy = s.split(" ");
            String orderByFieldName = orderBy[0];
            String mongoFieldName = this.populateMapping(eruptModel, orderByFieldName);
            if (orderBy.length > 1 && orderBy[1].contains("desc")) {
                query.with(Sort.by(Sort.Direction.DESC, mongoFieldName));
            } else {
                query.with(Sort.by(Sort.Direction.ASC, mongoFieldName));
            }
        }
    }

    public void addQueryCondition(EruptModel eruptModel, EruptQuery eruptQuery, Query query) {
        for (Condition condition : eruptQuery.getConditions()) {
            String conditionKey = condition.getKey();
            EruptFieldModel eruptFieldModel = eruptModel.getEruptFieldMap().get(conditionKey);
            String mongoFieldName = this.populateMapping(eruptModel, conditionKey);
            Optional.ofNullable(this.convertConditionValue(condition, eruptFieldModel)).ifPresent(value -> {
                switch (condition.getExpression()) {
                    case EQ:
                        query.addCriteria(Criteria.where(mongoFieldName).is(value));
                        break;
                    case LIKE:
                        query.addCriteria(Criteria.where(mongoFieldName).regex("^.*" + value + ".*$"));
                        break;
                    case RANGE:
                        List list = (List) value;
                        query.addCriteria(Criteria.where(mongoFieldName).gte(list.get(0)).lte(list.get(1)));
                        break;
                    case IN:
                        // 类型强制转换.
                        if (value instanceof Collection) {
                            query.addCriteria(Criteria.where(mongoFieldName).in((Collection) value));
                        } else {
                            query.addCriteria(Criteria.where(mongoFieldName).in(value));
                        }
                        break;
                }
            });
        }
    }

    /**
     * 由于mongodb类型检查严格
     * 根据{@link xyz.erupt.annotation.EruptField} 标注的字段类型 转换查询条件参数值类型
     */
    protected Object convertConditionValue(Condition condition, EruptFieldModel eruptFieldModel) {
        Object value = condition.getValue();
        if (condition.getValue() instanceof Collection) {
            Collection listValue = (Collection) value;
            List