log4j.logger.org.springframework.data.mongodb.core=DEBUG, mongodb

log4j.appender.mongodb=org.apache.log4j.ConsoleAppender

log4j.appender.mongodb.Target=System.out

log4j.appender.mongodb.Threshold=DEBUG

log4j.appender.mongodb.ImmediateFlush=true

log4j.appender.mongodb.layout=org.apache.log4j.PatternLayout

log4j.appender.mongodb.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %X{RequestId} - %m%n

public <T> T findOne(Query query, Class<T> entityClass)

public boolean exists(Query query, Class<?> entityClass)

public <T> List<T> find(Query query, Class<T> entityClass)

public <T> T findById(Object id, Class<T> entityClass)

public <T> T findAndModify(Query query, Update update, Class<T> entityClass)

public <T> T findAndModify(Query query, Update update, FindAndModifyOptions options, Class<T> entityClass)

public class FindAndModifyOptions {

<strong><span style="white-space:pre">    </span>boolean returnNew;   // 是否返回更新后的值

<span style="white-space:pre">    </span>boolean upsert;      // 没有找到是否插入 

<span style="white-space:pre">    </span>boolean remove;      // 找到是否删除</strong>

}

public <T> T findAndRemove(Query query, Class<T> entityClass)

public long count(Query query, Class<?> entityClass) 

public void insert(Object objectToSave)

public void insert(Collection<? extends Object> batchToSave, Class<?> entityClass)

public void insertAll(Collection<? extends Object> objectsToSave)

public void save(Object objectToSave)

public WriteResult upsert(Query query, Update update, Class<?> entityClass)

public WriteResult updateFirst(Query query, Update update, Class<?> entityClass)

public WriteResult updateMulti(Query query, Update update, Class<?> entityClass)

public WriteResult remove(Object object)

public WriteResult remove(Query query, String collectionName)

public <T> List<T> findAll(Class<T> entityClass)

public <T> List<T> findAllAndRemove(Query query, Class<T> entityClass) 

public DB getDb()

public String getCollectionName(Class<?> entityClass)

public <T> MapReduceResults<T> mapReduce(String inputCollectionName, String mapFunction, String reduceFunction, Class<T> entityClass)

public <T> MapReduceResults<T> mapReduce(String inputCollectionName, String mapFunction, String reduceFunction,MapReduceOptions mapReduceOptions, Class<T> entityClass) 

public <T> GroupByResults<T> group(String inputCollectionName, GroupBy groupBy, Class<T> entityClass)

public <O> AggregationResults<O> aggregate(TypedAggregation<?> aggregation, Class<O> outputType)

public <O> AggregationResults<O> aggregate(Aggregation aggregation, Class<?> inputType, Class<O> outputType)

1 一个方法名查询中同一个属性不能出现2次  可以创意@Query方法查询

2 @Query：

     value  查询语句

     count  作为统计的查询 返回int值

     delete 作为删除语句并返回删除后的文档集合

     fields 返回哪些字段

  示例：

    @Query(count = true, value = "{'$and':[{'tenant':?3},{'reportStatus':?0}," +

            " {'dealTime':{'$gte':?1}}, {'dealTime':{'$lte':?2}}]}")

    int countByStatusAndDealTimeBetween

            (ReportStatus status, Date begin, Date end, long tenant);

private final List<Order> orders;

public Sort and(Sort sort) {

        if (sort == null) {

            return this;

        }

        ArrayList<Order> these = new ArrayList<Order>(this.orders);

        for (Order order : sort) {

            these.add(order);

        }

        return new Sort(these);

    }

private Sort sort;

    private int skip;

    private int limit;

    public Query skip(int skip) {

        this.skip = skip;

        return this;

    }

    public Query limit(int limit) {

        this.limit = limit;

        return this;

    }

        public Query with(Pageable pageable) {

        if (pageable == null) {

            return this;

        }

        this.limit = pageable.getPageSize();

        this.skip = pageable.getOffset();

        return with(pageable.getSort());

    }

    public Query with(Sort sort) {

        if (sort == null) {

            return this;

        }

        for (Order order : sort) {

            if (order.isIgnoreCase()) {

                throw new IllegalArgumentException(String.format("Gven sort contained an Order for %s with ignore case! "

                        + "MongoDB does not support sorting ignoreing case currently!", order.getProperty()));

            }

        }

        if (this.sort == null) {

            this.sort = sort;

        } else {

            this.sort = this.sort.and(sort);

        }

        return this;

    }

private final Map<String, CriteriaDefinition> criteria = new LinkedHashMap<String, CriteriaDefinition>();

    public static Query query(CriteriaDefinition criteriaDefinition) {

        return new Query(criteriaDefinition);

    }

    public Query() {}

    public Query(CriteriaDefinition criteriaDefinition) {

        addCriteria(criteriaDefinition);

    }

    public Query addCriteria(CriteriaDefinition criteriaDefinition) {

        CriteriaDefinition existing = this.criteria.get(criteriaDefinition.getKey());

        String key = criteriaDefinition.getKey();

        if (existing == null) {

            this.criteria.put(key, criteriaDefinition);

        } else {

            throw new InvalidMongoDbApiUsageException("Due to limitations of the com.mongodb.BasicDBObject, "

                    + "you can't add a second '" + key + "' criteria. " + "Query already contains '"

                    + existing.getCriteriaObject() + "'.");

        }

        return this;

    }

private String key;

    private List<Criteria> criteriaChain;

    private LinkedHashMap<String, Object> criteria = new LinkedHashMap<String, Object>();

    private Object isValue = NOT_SET;

        public static Criteria where(String key) {

        return new Criteria(key);

    }

    /**

     * Static factory method to create a Criteria using the provided key

     *

     * @return

     */

    public Criteria and(String key) {

        return new Criteria(this.criteriaChain, key);

    }

andOperator

is ne lt lte gt gte in nin mod all size exits type not regex

/**

         * db.videos.aggregate(

            [

               { $match: { "frags.isnew" : true } },

               { $unwind: "$frags" },

               { $match: { "frags.isnew" : true } },

               { $group: {

                           _id: {cat1:"$cat1"},

                           count: { $sum: 1 },

                           publishdate2: { $max: "$publishdate"}

                         }

               } 

            ]

            )

         */

        Aggregation agg = newAggregation(

                project("frags","cat1","publishdate"),//挑选所需的字段

                match(

                        Criteria.where("frags.isnew").is(Boolean.TRUE)

                        .and("cat1").in(importantCat1List)

                     ),//筛选符合条件的记录

                unwind("frags"),//如果有MASTER-ITEM关系的表，需同时JOIN这两张表的，展开子项LIST，且是内链接，即如果父和子的关联ID没有的就不会输出

                match(Criteria.where("frags.isnew").is(Boolean.TRUE)),

                group("cat1")//设置分组字段

                    .count().as("updateCount")//增加COUNT为分组后输出的字段

                    .last("publishdate").as("publishDate"),//增加publishDate为分组后输出的字段

                project("publishDate","cat1","updateCount")//重新挑选字段

                    .and("cat1").previousOperation()//为前一操作所产生的ID FIELD建立别名

            );