Java 如何添加或&；在单个查询对象Mongodb Spring数据中包含的和条件子句_Java_Spring_Mongodb_Spring Data Mongodb

Java 如何添加或&；在单个查询对象Mongodb Spring数据中包含的和条件子句

java spring mongodb

Java 如何添加或&；在单个查询对象Mongodb Spring数据中包含的和条件子句,java,spring,mongodb,spring-data-mongodb,Java,Spring,Mongodb,Spring Data Mongodb,我想同时向我的查询对象添加or&and子句，但我一直得到下面的错误提示由于com.mongodb.BasicDBObject的限制，您不能添加第二个“null”条件吗比如说 query.addCriteria(new Criteria().orOperator(Some Critera); query.addCriteria(new Criteria().andOperator(Some Critera); 有人能帮我吗详细信息：实际上，我正在尝试解析以下json，并基于解析后的

我想同时向我的查询对象添加or&and子句，但我一直得到下面的错误提示

由于com.mongodb.BasicDBObject的限制，您不能添加第二个“null”条件吗

比如说

query.addCriteria(new Criteria().orOperator(Some Critera);


 query.addCriteria(new Criteria().andOperator(Some Critera);

有人能帮我吗

详细信息：

实际上，我正在尝试解析以下json，并基于解析后的json构建动态查询

{
  "query":{

    "where":[{

              "or":[
              {
                 "fieldName":"address1","fieldValue":"Dummy address1",

                 "operator":"equal"
              }

            ],
            "and":[{
                  "fieldName":"version","fieldValue":"1",

                 "operator":"equal"

             }]
           }
        ]
   }
}

所以您可以建议我使用mongoTemplate spring数据将json解析为Mongodb查询的其他方法

这是我的解析代码

if(null != eventSearch.getQuery())
        {

            if(null != eventSearch.getQuery().getWhere() && eventSearch.getQuery().getWhere().size() > 0)
            {

                for (Where whereClause : eventSearch.getQuery().getWhere()) {

                      if(null != whereClause.getOr() && whereClause.getOr().size() > 0){

                          List<org.springframework.data.mongodb.core.query.Criteria> orCriterias = new ArrayList<org.springframework.data.mongodb.core.query.Criteria>(whereClause.getOr().size());

                          for (Field field: whereClause.getOr()) {

                              if(field.getOperator().equalsIgnoreCase(QueryOperator.IS))
                              {
                                orCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).is(field.getFieldValue()));

                              }else if(field.getOperator().equalsIgnoreCase(QueryOperator.LT)){

                                orCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).lt(field.getFieldValue()));
                              } 
                              else if(field.getOperator().equalsIgnoreCase(QueryOperator.GT)){

                                  orCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).gt(field.getFieldValue()));
                              } 
                              else if(field.getOperator().equalsIgnoreCase(QueryOperator.LTE)){

                                  orCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).lte(field.getFieldValue()));
                               }
                              else if(field.getOperator().equalsIgnoreCase(QueryOperator.GTE)){

                                  orCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).gte(field.getFieldValue()));
                               }
                          } 

                          query.addCriteria(new org.springframework.data.mongodb.core.query.Criteria().orOperator(orCriterias.toArray(new org.springframework.data.mongodb.core.query.Criteria[whereClause.getOr().size()])));
                      }

                      if(null != whereClause.getAnd() && whereClause.getAnd().size() > 0){

                          List<org.springframework.data.mongodb.core.query.Criteria> andCriterias = new ArrayList<org.springframework.data.mongodb.core.query.Criteria>(whereClause.getAnd().size());

                          for (Field field: whereClause.getAnd()) {

                              if(field.getOperator().equalsIgnoreCase(QueryOperator.IS))
                              {
                                  andCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).is(field.getFieldValue()));

                              }else if(field.getOperator().equalsIgnoreCase(QueryOperator.LT)){

                                  andCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).lt(field.getFieldValue()));
                              } 
                              else if(field.getOperator().equalsIgnoreCase(QueryOperator.GT)){

                                  andCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).gt(field.getFieldValue()));
                              } 
                              else if(field.getOperator().equalsIgnoreCase(QueryOperator.LTE)){

                                  andCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).lte(field.getFieldValue()));
                               }
                              else if(field.getOperator().equalsIgnoreCase(QueryOperator.GTE)){

                                  andCriterias.add(org.springframework.data.mongodb.core.query.Criteria.where(field.getFieldName()).gte(field.getFieldValue()));
                               }
                          } 
                          //Getting exception at this line
                          query.addCriteria(new org.springframework.data.mongodb.core.query.Criteria().andOperator(andCriterias.toArray(new org.springframework.data.mongodb.core.query.Criteria[whereClause.getAnd().size()])));
                      }
}}

if（null！=eventSearch.getQuery（））
{
if（null！=eventSearch.getQuery（）.getWhere（）&&eventSearch.getQuery（）.getWhere（）.size（）>0）
{
for（Where Where子句：eventSearch.getQuery（）.getWhere（））{
if（null！=whereClause.getOr（）&&whereClause.getOr（）.size（）>0）{
List或riterias=newarraylist（whereClause.getOr（）.size（））；
for（字段：whereClause.getOr（））{
if（field.getOperator（）.equalsIgnoreCase（QueryOperator.IS））
{
添加（org.springframework.data.mongodb.core.query.criterias.where（field.getFieldName（））.is（field.getFieldValue（））；
}else if（field.getOperator（）.equalsIgnoreCase（QueryOperator.LT））{
添加（org.springframework.data.mongodb.core.query.criterias.where（field.getFieldName（））.lt（field.getFieldValue（））；
} 
else if（field.getOperator（）.equalsIgnoreCase（QueryOperator.GT））{
添加（org.springframework.data.mongodb.core.query.criterias.where（field.getFieldName（））.gt（field.getFieldValue（））；
} 
else if（field.getOperator（）.equalsIgnoreCase（QueryOperator.LTE））{
添加（org.springframework.data.mongodb.core.query.criterias.where（field.getFieldName（））.lte（field.getFieldValue（））；
}
else if（field.getOperator（）.equalsIgnoreCase（QueryOperator.GTE））{
添加（org.springframework.data.mongodb.core.query.criterias.where（field.getFieldName（））.gte（field.getFieldValue（））；
}
} 
query.addCriteria（new org.springframework.data.mongodb.core.query.criterias（）.orOperator（orCriterias.toArray（new org.springframework.data.mongodb.core.query.Criteria[where子句.getOr（）.size（）]）；
}
if（null！=whereClause.getAnd（）&&whereClause.getAnd（）.size（）>0）{
List和criterias=newarraylist（whereClause.getAnd（）.size（））；
for（字段：whereClause.getAnd（））{
if（field.getOperator（）.equalsIgnoreCase（QueryOperator.IS））
{
andCriterias.add（org.springframework.data.mongodb.core.query.Criteria.where（field.getFieldName（））.is（field.getFieldValue（））；
}else if（field.getOperator（）.equalsIgnoreCase（QueryOperator.LT））{
add（org.springframework.data.mongodb.core.query.criterias.where（field.getFieldName（））.lt（field.getFieldValue（））；
} 
else if（field.getOperator（）.equalsIgnoreCase（QueryOperator.GT））{
andCriterias.add（org.springframework.data.mongodb.core.query.Criteria.where（field.getFieldName（））.gt（field.getFieldValue（））；
} 
else if（field.getOperator（）.equalsIgnoreCase（QueryOperator.LTE））{
andCriterias.add（org.springframework.data.mongodb.core.query.Criteria.where（field.getFieldName（））.lte（field.getFieldValue（））；
}
else if（field.getOperator（）.equalsIgnoreCase（QueryOperator.GTE））{
andCriterias.add（org.springframework.data.mongodb.core.query.Criteria.where（field.getFieldName（））.gte（field.getFieldValue（））；
}
} 
//这一行出现异常
query.addCriteria（new org.springframework.data.mongodb.core.query.Criteria（）.andOperator（andCriterias.toArray（new org.springframework.data.mongodb.core.query.Criteria[whereClause.getAnd（）.size（）]）；
}
}}

我无法真正帮助您解析代码，但您可以使用

DBObject conditions = new BasicDBObject("field1",val1).append("field2",val2)...;

然后用链子把它们连在一起

DBObject query = new BasicDBObject("$or",conditions);

及

你的代码太长了，我临时用

条件替换了org.springframework.data.mongodb.core.query.Criteria

    // added
    Query query = new Query();

    if(null != eventSearch.getQuery())
    {

        if(null != eventSearch.getQuery().getWhere() && eventSearch.getQuery().getWhere().size() > 0)
        {
            // added
            List<Criteria> wheres = new ArrayList<>();

            for (Where whereClause : eventSearch.getQuery().getWhere()) {

                // added
                Criteria where = new Criteria();

                  if(null != whereClause.getOr() && whereClause.getOr().size() > 0){

                      List<Criteria> orCriterias = new ArrayList<Criteria>(whereClause.getOr().size());

                      for (Field field: whereClause.getOr()) {

                          if(field.getOperator().equalsIgnoreCase(QueryOperator.IS))
                          {
                            orCriterias.add(Criteria.where(field.getFieldName()).is(field.getFieldValue()));

                          }else if(field.getOperator().equalsIgnoreCase(QueryOperator.LT)){

                            orCriterias.add(Criteria.where(field.getFieldName()).lt(field.getFieldValue()));
                          } 
                          else if(field.getOperator().equalsIgnoreCase(QueryOperator.GT)){

                              orCriterias.add(Criteria.where(field.getFieldName()).gt(field.getFieldValue()));
                          } 
                          else if(field.getOperator().equalsIgnoreCase(QueryOperator.LTE)){

                              orCriterias.add(Criteria.where(field.getFieldName()).lte(field.getFieldValue()));
                           }
                          else if(field.getOperator().equalsIgnoreCase(QueryOperator.GTE)){

                              orCriterias.add(Criteria.where(field.getFieldName()).gte(field.getFieldValue()));
                           }
                      } 

                      // comment out
                      // query.addCriteria(new Criteria().orOperator(orCriterias.toArray(new Criteria[whereClause.getOr().size()])));

                      // replaced with
                      if (orCriterias.size() > 0) {
                          where.orOperator(orCriterias.toArray(new Criteria[0]));
                      }
                  }

                  if(null != whereClause.getAnd() && whereClause.getAnd().size() > 0){

                      List<Criteria> andCriterias = new ArrayList<Criteria>(whereClause.getAnd().size());

                      for (Field field: whereClause.getAnd()) {

                          if(field.getOperator().equalsIgnoreCase(QueryOperator.IS))
                          {
                              andCriterias.add(Criteria.where(field.getFieldName()).is(field.getFieldValue()));

                          }else if(field.getOperator().equalsIgnoreCase(QueryOperator.LT)){

                              andCriterias.add(Criteria.where(field.getFieldName()).lt(field.getFieldValue()));
                          } 
                          else if(field.getOperator().equalsIgnoreCase(QueryOperator.GT)){

                              andCriterias.add(Criteria.where(field.getFieldName()).gt(field.getFieldValue()));
                          } 
                          else if(field.getOperator().equalsIgnoreCase(QueryOperator.LTE)){

                              andCriterias.add(Criteria.where(field.getFieldName()).lte(field.getFieldValue()));
                           }
                          else if(field.getOperator().equalsIgnoreCase(QueryOperator.GTE)){

                              andCriterias.add(Criteria.where(field.getFieldName()).gte(field.getFieldValue()));
                           }
                      } 

                      // comment out
                      // //Getting exception at this line
                      // query.addCriteria(new Criteria().andOperator(andCriterias.toArray(new Criteria[whereClause.getAnd().size()])));

                      // replaced with
                      if (andCriterias.size() > 0) {
                          where.andOperator(andCriterias.toArray(new Criteria[0]));
                      }

                  }

                  // added
                  wheres.add(where);
                }
                // added
                if (wheres.size() > 0) {
                    query.addCriteria(new Criteria().andOperator(wheres.toArray(new Criteria[0])));
                }
            }
    }

然后，可以这样编写部分代码：
{
  "query":{

    "where":[{

              "or":[
              {
                 "fieldName":"address1","fieldValue":"Dummy address1",

                 "operator":"equal"
              },
              {
                 "fieldName":"address1","fieldValue":"Dummy address2",

                 "operator":"$gt" // added: greater than
              },
              {
                 "fieldName":"address1","fieldValue":"Dummy address3",

                 "operator":"$ne" // added: not equal
              }

            ],
            "and":[{
                  "fieldName":"version","fieldValue":"1",

                 "operator":"equal"

             }]
           }
        ]
   }
}

  for (Field field: whereClause.getAnd()) {

      if(field.getOperator().equalsIgnoreCase(QueryOperator.IS))
      {
          andCriterias.add(Criteria.where(field.getFieldName()).is(field.getFieldValue()));

      } else {
          andCriterias.add(Criteria.where(field.getOperator()).is(new BasicDBObject(field.getFieldName(), field.getFieldValue())));
      }
  }

whereClause.getOr（）
类似于whereClause.getAnd（）
，然后你可以在一个循环中组合它们来缩短代码，如果你想的话。谢谢你的效果！请看我更新的问题！@Ramzan Zafar，这对你很有帮助。我添加了一些东西，也许它可以帮助优化代码。
  for (Field field: whereClause.getAnd()) {

      if(field.getOperator().equalsIgnoreCase(QueryOperator.IS))
      {
          andCriterias.add(Criteria.where(field.getFieldName()).is(field.getFieldValue()));

      } else {
          andCriterias.add(Criteria.where(field.getOperator()).is(new BasicDBObject(field.getFieldName(), field.getFieldValue())));
      }
  }