mongodb和spring集成中MongoTemplate的总结是使用方法

来源:转载


  1. 基础实体类


@Document(collection="person")
class Person{
   
    String id;
   
    String name;
   
    int age;
   
    public String getId() {
       returnid;
    }
    public void setId(String id) {
       this.id = id;
    }
    public String getName() {
       returnname;
    }
    public void setName(String name) {
       this.name = name;
    }
    public int getAge() {
       returnage;
    }
    public void setAge(int age) {
       this.age = age;
    }
}

 
 
 
 
 
 
 
         /**
          * The collection name used for the specifiedclass by this template.
          *
          * @param entityClass must not be {@literalnull}.
          * @return
          */

       StringgetCollectionName(Class<?> entityClass);


String personName=mongoTemplate.getCollectionName(Person.class);

 
 
 
         /**
          * Execute the a MongoDB command expressed as aJSON string. This will call the method JSON.parse that is part of the
          * MongoDB driver to convert the JSON string toa DBObject. Any errors that result from executing this command will be
          * converted into Spring's DAO exceptionhierarchy.
          *
          * @param jsonCommand a MongoDB commandexpressed as a JSON string.
          */

       CommandResultexecuteCommand(String jsonCommand);


 

    String jsonSql="{distinct:'person', key:'name'}";
       CommandResult  commandResult=mongoTemplate.executeCommand(jsonSql);
       System.out.println();
        BasicDBList list = (BasicDBList)commandResult.get("values"); 
            for (int i = 0; i < list.size(); i ++) { 
                System.out.println(list.get(i)); 
            } 
       System.out.println();

 
 
         /**
          * Execute a MongoDB command. Any errors thatresult from executing this command will be converted into Spring's DAO
          * exception hierarchy.
          *
          * @param command a MongoDB command
          */

       CommandResultexecuteCommand(DBObject command);


    String jsonSql="{distinct:'person', key:'name'}";
       CommandResult  commandResult=mongoTemplate.executeCommand((DBObject) JSON.parse(jsonSql));
       System.out.println();
        BasicDBList list = (BasicDBList)commandResult.get("values"); 
            for (int i = 0; i < list.size(); i ++) { 
                System.out.println(list.get(i)); 
            } 
       System.out.println();

 
 
 
         /**
          * Execute a MongoDB command. Any errors thatresult from executing this command will be converted into Spring's DAO
          * exception hierarchy.
          *
          * @param command a MongoDB command
          * @param options query options to use
          */

       CommandResultexecuteCommand(DBObject command, int options);


    String jsonSql="{distinct:'person', key:'name'}";
       CommandResult  commandResult=mongoTemplate.executeCommand((DBObject) JSON.parse(jsonSql),Bytes.QUERYOPTION_NOTIMEOUT);
       System.out.println();
        BasicDBList list = (BasicDBList)commandResult.get("values"); 
            for (int i = 0; i < list.size(); i ++) { 
                System.out.println(list.get(i)); 
            } 
       System.out.println();

 
         /**
          * Execute a MongoDB query and iterate over thequery results on a per-document basis with a DocumentCallbackHandler.
          *
          * @param query the query class that specifiesthe criteria used to find a record and also an optional fields
          *         specification
          * @param collectionName name of the collectionto retrieve the objects from
          * @param dch the handler that will extractresults, one document at a time
          */

       void executeQuery(Queryquery, String collectionName, DocumentCallbackHandler dch);


final Query query =new Query();
       Criteria criteria =new Criteria();
       criteria.and("name").is("zhangsan");
       mongoTemplate.executeQuery(query,"person",new DocumentCallbackHandler() {
           //处理自己的逻辑,这种为了有特殊需要功能的留的开放接口命令模式
           public void processDocument(DBObject dbObject) throws MongoException,
                  DataAccessException {
              mongoTemplate.updateFirst(query, Update.update("name","houchangren"),"person");
           }
        });

 
         /**
          * Executes a {@link DbCallback} translatingany exceptions as necessary.
          * <p/>
          * Allows for returning a result object, thatis a domain object or a collection of domain objects.
          *
          * @param <T> return type
          * @param action callback object that specifiesthe MongoDB actions to perform on the passed in DB instance.
          * @return a result object returned by theaction or <tt>null</tt>
          */

       <T> Texecute(DbCallback<T> action);


Person person=mongoTemplate.execute(new DbCallback<Person>() {
           public Person doInDB(DB db)throws MongoException, DataAccessException {
              Person p=new Person();
              //自己写逻辑和查询处理
//            p.setAge(age);
              return p;
           }
       });

 
         /**
          * Executes the given {@linkCollectionCallback} on the entity collection of the specified class.
          * <p/>
          * Allows for returning a result object, thatis a domain object or a collection of domain objects.
          *
          * @param entityClass class that determines thecollection to use
          * @param <T> return type
          * @param action callback object that specifiesthe MongoDB action
          * @return a result object returned by theaction or <tt>null</tt>
          */

       <T> Texecute(Class<?> entityClass, CollectionCallback<T> action);


Person person=mongoTemplate.execute(Person.class,new CollectionCallback<Person>() {
 
           public Person doInCollection(DBCollection collection)
                  throws MongoException, DataAccessException {
              Person p=new Person();
              //自己取值然后处理返回对应的处理  collection.find();
              return  p;
           }
       });

 
 
         /**
          * Executes the given {@linkCollectionCallback} on the collection of the given name.
          * <p/>
          * Allows for returning a result object, thatis a domain object or a collection of domain objects.
          *
          * @param <T> return type
          * @param collectionName the name of thecollection that specifies which DBCollection instance will be passed into
          * @param action callback object that specifiesthe MongoDB action the callback action.
          * @return a result object returned by theaction or <tt>null</tt>
          */

       <T> Texecute(String collectionName, CollectionCallback<T> action);


Person person=mongoTemplate.execute(“person”,new CollectionCallback<Person>() {
 
           public Person doInCollection(DBCollection collection)
                  throws MongoException, DataAccessException {
               Person p=new Person();
              //自己取值然后处理返回对应的处理  collection.find();
              return  p;
           }
       });

 
         /**
          * Executes the given {@link DbCallback} withinthe same connection to the database so as to ensure consistency in a
          * write heavy environment where you may readthe data that you wrote. See the comments on {@see <a
          *href=http://www.mongodb.org/display/DOCS/Java+Driver+Concurrency>Java DriverConcurrency</a>}
          * <p/>
          * Allows for returning a result object, thatis a domain object or a collection of domain objects.
          *
          * @param <T> return type
          * @param action callback that specified theMongoDB actions to perform on the DB instance
          * @return a result object returned by theaction or <tt>null</tt>
          */

       <T> T executeInSession(DbCallback<T>action);


Person person=mongoTemplate.executeInSession(new DbCallback<Person>() {
           public Person doInDB(DB db)throws MongoException, DataAccessException {
              //处理..
              return null;
           }
       });

 
         /**
          * Create an uncapped collection with a namebased on the provided entity class.
          *
          * @param entityClass class that determines thecollection to create
          * @return the created collection
          */

       <T>DBCollection createCollection(Class<T> entityClass);


 
 
 
         /**
          * Create a collect with a name based on theprovided entity class using the options.
          *
          * @param entityClass class that determines thecollection to create
          * @param collectionOptions options to use whencreating the collection.
          * @return the created collection
          */

       <T>DBCollection createCollection(Class<T> entityClass, CollectionOptionscollectionOptions);


 
创建高级特性集合(指定大小,层级等属性)
 
         /**
          * Create an uncapped collection with theprovided name.
          *
          * @param collectionName name of the collection
          * @return the created collection
          */

       DBCollectioncreateCollection(String collectionName);


 
         /**
          * Create a collect with the provided name andoptions.
          *
          * @param collectionName name of the collection
          * @param collectionOptions options to use whencreating the collection.
          * @return the created collection
          */

       DBCollectioncreateCollection(String collectionName, CollectionOptions collectionOptions);


 
         /**
          * A set of collection names.
          *
          * @return list of collection names
          */

       Set<String>getCollectionNames();


Set<String> collectionNames=mongoTemplate.getCollectionNames();

 
         /**
          * Get a collection by name, creating it if itdoesn't exist.
          * <p/>
          * Translate any exceptions as necessary.
          *
          * @param collectionName name of the collection
          * @return an existing collection or a newlycreated one.
          */

       DBCollectiongetCollection(String collectionName);


 

    DBCollection collection=mongoTemplate.getCollection("person");

 
 
         /**
          * Check to see if a collection with a nameindicated by the entity class exists.
          * <p/>
          * Translate any exceptions as necessary.
          *
          * @param entityClass class that determines thename of the collection
          * @return true if a collection with the givenname is found, false otherwise.
          */

       <T>boolean collectionExists(Class<T> entityClass);


 
省略…
 
 
         /**
          * Check to see if a collection with a givenname exists.
          * <p/>
          * Translate any exceptions as necessary.
          *
          * @param collectionName name of the collection
          * @return true if a collection with the givenname is found, false otherwise.
          */

       booleancollectionExists(String collectionName);


 
 
省略…
 
 
         /**
          * Drop the collection with the name indicatedby the entity class.
          * <p/>
          * Translate any exceptions as necessary.
          *
          * @param entityClass class that determines thecollection to drop/delete.
          */

       <T> voiddropCollection(Class<T> entityClass);


删除集合
         /**
          * Drop the collection with the given name.
          * <p/>
          * Translate any exceptions as necessary.
          *
          * @param collectionName name of the collectionto drop/delete.
          */

       voiddropCollection(String collectionName);


 
省略…
 
 
         /**
          * Returns the operations that can be performedon indexes
          *
          * @return index operations on the namedcollection
          */

       IndexOperationsindexOps(String collectionName);


    IndexOperations io=mongoTemplate.indexOps("person");
       //io.dropIndex("");
       Index index =new Index();
       index.on("name",Order.ASCENDING); //为name属性加上 索引
       index.unique();//唯一索引
       io.ensureIndex(index);

 
         /**
          * Returns the operations that can be performedon indexes
          *
          * @return index operations on the namedcollection associated with the given entity class
          */

       IndexOperationsindexOps(Class<?> entityClass);


 

    IndexOperations io=mongoTemplate.indexOps(Person.class);
       io.dropIndex("name_1");//删除索引
//     Index index =new Index();
//     index.on("name",Order.ASCENDING);
//     index.unique();
//     index.named("name_1");
//     io.ensureIndex(index);
      

 
 
         /**
          * Query for a list of objects of type T fromthe collection used by the entity class.
          * <p/>
          * The object is converted from the MongoDBnative representation using an instance of {@see MongoConverter}. Unless
          * configured otherwise, an instance of SimpleMongoConverterwill be used.
          * <p/>
          * If your collection does not contain ahomogeneous collection of types, this operation will not be an efficient way
          * to map objects since the test for class typeis done in the client and not on the server.
          *
          * @param entityClass the parameterized type ofthe returned list
          * @return the converted collection
          */

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


    mongoTemplate.findAll(Person.class);
       mongoTemplate.findAll(Person.class,"person");

 
         /**
          * Query for a list of objects of type T fromthe specified collection.
          * <p/>
          * The object is converted from the MongoDBnative representation using an instance of {@see MongoConverter}. Unless
          * configured otherwise, an instance ofSimpleMongoConverter will be used.
          * <p/>
          * If your collection does not contain ahomogeneous collection of types, this operation will not be an efficient way
          * to map objects since the test for class typeis done in the client and not on the server.
          *
          * @param entityClass the parameterized type ofthe returned list.
          * @param collectionName name of the collectionto retrieve the objects from
          * @return the converted collection
          */

       <T>List<T> findAll(Class<T> entityClass, String collectionName);


    mongoTemplate.findAll(Person.class);
       mongoTemplate.findAll(Person.class,"person");

 
         /**
          * Execute a group operation over the entirecollection. The group operation entity class should match the 'shape' of
          * the returned object that takes int accountthe initial document structure as well as any finalize functions.
          *
          * @param criteria The criteria that restrictsthe row that are considered for grouping. If not specified all rows are
          *         considered.
          * @param inputCollectionName the collectionwhere the group operation will read from
          * @param groupBy the conditions under whichthe group operation will be performed, e.g. keys, initial document,
          *         reduce function.
          * @param entityClass The parameterized type ofthe returned list
          * @return The results of the group operation
          */

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


//处理所有相同名字的人有几个? 
          GroupBy groupBy = GroupBy.key("name").initialDocument("{allAgeTotal:0,count:0}") 
            .reduceFunction("function(key, values){values.count+=1;}");
          //values.allAgeTotal+=values.age;
          //.reduceFunction("function(key, values){var x=0;values.forEach(function(v){x+=v;});return x;}"); 
     
            GroupByResults<Person> r = mongoTemplate.group("person", groupBy, Person.class); 
            BasicDBList list = (BasicDBList)r.getRawResults().get("retval"); 
            for (int i = 0; i < list.size(); i ++) { 
                BasicDBObject obj = (BasicDBObject)list.get(i); 
                System.out.println("[LOG]姓名:"+obj.get("name")+"数量:"+obj.get("count"));
            } 
            System.out.println(r); 
 
 
 
 
 
 
 
结果:
 
[LOG]姓名:houchangren数量:1.0
[LOG]姓名:zhangsan数量:8.0
 
 
 
 
 
 
          //查询年龄总和是多少,和数量是是多少?
            GroupBy groupBy = GroupBy.key("age").initialDocument("{allAgeTotal:0,count:0,avg:0}") 
            .reduceFunction("function(doc, prev){if(prev.age>=16){prev.allAgeTotal+=prev.age;prev.count+=1;}}");
//          .finalizeFunction("function(prev){prev.avg=prev.allAgeTotal/prev.count;}");
            GroupByResults<Person> r = mongoTemplate.group("person", groupBy, Person.class);
            BasicDBList list = (BasicDBList)r.getRawResults().get("retval"); 
            for (int i = 0; i < list.size(); i ++) { 
                BasicDBObject obj = (BasicDBObject)list.get(i); 
                System.out.println("[LOG]年龄为:"+obj.get("age")+",数量:"+obj.get("count")+"年龄总和:"+obj.get("allAgeTotal"));
               
            } 
 
 
 
//
[LOG]年龄为:16.0,数量:1.0年龄总和:16.0
[LOG]年龄为:15.0,数量:0.0年龄总和:0.0
[LOG]年龄为:25.0,数量:6.0年龄总和:150.0

 
         /**
          * Execute a group operation restricting therows to those which match the provided Criteria. The group operation
          * entity class should match the 'shape' of thereturned object that takes int account the initial document structure
          * as well as any finalize functions.
          *
          * @param criteria The criteria that restrictsthe row that are considered for grouping. If not specified all rows are
          *         considered.
          * @param inputCollectionName the collectionwhere the group operation will read from
          * @param groupBy the conditions under whichthe group operation will be performed, e.g. keys, initial document,
          *         reduce function.
          * @param entityClass The parameterized type ofthe returned list
          * @return The results of the group operation
          */

       <T>GroupByResults<T> group(Criteria criteria, String inputCollectionName,GroupBy groupBy, Class<T> entityClass);


 
 

//        //大于16以上的查询年龄总和是多少,和数量是是多少?
        GroupBy groupBy = GroupBy.key("age").initialDocument("{allAgeTotal:0,count:0,avg:0}") 
        .reduceFunction("function(doc, prev){if(prev.age>=16){prev.allAgeTotal+=prev.age;prev.count+=1;}}");
//        .finalizeFunction("function(prev){prev.avg=prev.allAgeTotal/prev.count;}");
        Criteria criteria =new Criteria();
        criteria.and("age").gt(16);
        GroupByResults<Person> r = mongoTemplate.group(criteria,"person", groupBy, Person.class);
        BasicDBList list = (BasicDBList)r.getRawResults().get("retval"); 
        for (int i = 0; i < list.size(); i ++) { 
            BasicDBObject obj = (BasicDBObject)list.get(i); 
            System.out.println("[LOG]年龄为:"+obj.get("age")+",数量:"+obj.get("count")+"年龄总和:"+obj.get("allAgeTotal"));
           
        } 

 
 
         /**
          * Execute a map-reduce operation. Themap-reduce operation will be formed with an output type of INLINE
          *
          * @param inputCollectionName the collectionwhere the map-reduce will read from
          * @param mapFunction The JavaScript mapfunction
          * @param reduceFunction The JavaScript reducefunction
          * @param mapReduceOptions Options that specifydetailed map-reduce behavior
          * @param entityClass The parameterized type ofthe returned list
          * @return The results of the map reduceoperation
          */

       <T>MapReduceResults<T> mapReduce(String inputCollectionName, StringmapFunction, String reduceFunction,       Class<T>entityClass);


      
       String mapFunction="function(){" +
              "emit(this.age,{'name':this.name});" +
              "}";
       String reduceFunction="function(key, values)" +
              "{var sum = 0;" +
              "var test='';" +
              "for(i in values){" +
              "test+=i;" +
              "}" +
              "" +
              "values.forEach(function(doc){" +
              "sum += 1; }); " +
              "return {persons:sum,test:test,values:values};" +
              "};";
       //在此之前用的sping -data-mongodb 1.0.1.release版本,存在BUG,现在1.1.0.release没有问题
//         Criteria criteria =new Criteria();
//          criteria.and("age").gt(16);
//          Query query  =new Query(criteria);
       MapReduceResults<Person> mapReduce = mongoTemplate.mapReduce("person", mapFunction, reduceFunction, Person.class);
       BasicDBList list = (BasicDBList)mapReduce.getRawResults().get("results"); 
      for (int i = 0; i < list.size(); i ++) { 
          BasicDBObject obj = (BasicDBObject)list.get(i);
          System.out.println(obj.toString());
      } 

 
         /**
          * Execute a map-reduce operation that takesadditional map-reduce options.
          *
          * @param inputCollectionName the collectionwhere the map-reduce will read from
          * @param mapFunction The JavaScript mapfunction
          * @param reduceFunction The JavaScript reducefunction
          * @param mapReduceOptions Options that specifydetailed map-reduce behavior
          * @param entityClass The parameterized type ofthe returned list
          * @return The results of the map reduceoperation
          */

       <T>MapReduceResults<T> mapReduce(String inputCollectionName, StringmapFunction, String reduceFunction,       MapReduceOptionsmapReduceOptions, Class<T> entityClass);


 
 

 
       String mapFunction = "function(){"
              + "emit(this.age,{'name':this.name});" +"}";
       String reduceFunction = "function(key, values)" +"{var sum = 0;"
              + "var test='';" +"for(i in values){" +"test+=i;" + "}" +""
              + "values.forEach(function(doc){" +"sum += 1; }); "
              + "return {persons:sum,test:test,values:values};" +"};";
       // 在此之前用的sping -data-mongodb 1.0.1.release版本,存在BUG,现在1.1.0.release没有问题
        Criteria criteria =new Criteria();
        criteria.and("age").gt(16);
        Query query =new Query(criteria);
        MapReduceOptions mrO=new MapReduceOptions();
        mrO.outputCollection("person_result");//指定到输出表中,不指定输出的选项会把执行结果返回到result中
       MapReduceResults<Person> mapReduce = mongoTemplate.mapReduce("person",
              mapFunction, reduceFunction,mrO,Person.class);
//     BasicDBList list = (BasicDBList) mapReduce.getRawResults().get(
//            "results");
//     for (int i = 0; i < list.size(); i++) {
//         BasicDBObject obj = (BasicDBObject) list.get(i);
//         System.out.println(obj.toString());
//     }
       System.out.println("+++++++++++++++++++++++++++++++");
      
       //然后到输出的结果表中去查询
       List<DBObject>  person_results = mongoTemplate.execute("person_result",new CollectionCallback<List<DBObject> >() {
           public List<DBObject> doInCollection(DBCollection collection)
                  throws MongoException, DataAccessException {
           DBCursor dbCursor=collection.find();
           return dbCursor.toArray();
           }
       });
 
       for (DBObject dbObject : person_results) {
           System.out.println(dbObject.toString());
       }

 
 
         /**
          * Execute a map-reduce operation that takes aquery. The map-reduce operation will be formed with an output type of
          * INLINE
          *
          * @param query The query to use to select thedata for the map phase
          * @param inputCollectionName the collectionwhere the map-reduce will read from
          * @param mapFunction The JavaScript mapfunction
          * @param reduceFunction The JavaScript reducefunction
          * @param mapReduceOptions Options that specifydetailed map-reduce behavior
          * @param entityClass The parameterized type ofthe returned list
          * @return The results of the map reduceoperation
          */
         <T>MapReduceResults<T> mapReduce(Query query, String inputCollectionName,String mapFunction, String reduceFunction,
                            Class<T>entityClass);
 
         /**
          * Execute a map-reduce operation that takes aquery and additional map-reduce options
          *
          * @param query The query to use to select thedata for the map phase
          * @param inputCollectionName the collectionwhere the map-reduce will read from
          * @param mapFunction The JavaScript mapfunction
          * @param reduceFunction The JavaScript reducefunction
          * @param mapReduceOptions Options that specifydetailed map-reduce behavior
          * @param entityClass The parameterized type ofthe returned list
          * @return The results of the map reduceoperation
          */

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


同上,不过就是加了一个普通的query 作为查询条件之前的过滤
 
 
         /**
          * Returns {@link GeoResult} for all entitiesmatching the given {@link NearQuery}. Will consider entity mapping
          * information to determine the collection thequery is ran against.
          *
          * @param near must not be {@literal null}.
          * @param entityClass must not be {@literalnull}.
          * @return
          */

       <T>GeoResults<T> geoNear(NearQuery near, Class<T> entityClass);


 
 
 

 

 
 
         /**
          * Returns {@link GeoResult} for all entitiesmatching the given {@link NearQuery}.
          *
          * @param near must not be {@literal null}.
          * @param entityClass must not be {@literalnull}.
          * @param collectionName the collection totrigger the query against. If no collection name is given the entity class
          *         will be inspected.
          * @return
          */

 

       <T>GeoResults<T> geoNear(NearQuery near, Class<T> entityClass, StringcollectionName);


 
 

 
//     IndexOperations io=mongoTemplate.indexOps("person");
//     //io.dropIndex("");
//     GeospatialIndex index =new GeospatialIndex("address");
////       index.named("address_2d");
//     index.withBits(26);
//     index.withMax(900);
//     index.withMin(0);
//     io.ensureIndex(index);
 
       double x =12,y=32;
       Point point =new Point(x, y);
       NearQuery near =NearQuery.near(point);
//     Query query =new Query();
//     query.limit(20);
//     near.query(query);
       near.maxDistance(10);
       GeoResults<Person>  geoResults = mongoTemplate.geoNear(near, Person.class);
       for (GeoResult<Person> geoResult : geoResults) {
           System.out.println(geoResult.getContent().toString());
       }

 
 
         /**
          * Map the results of an ad-hoc query on thecollection for the entity class to a single instance of an object of the
          * specified type.
          * <p/>
          * The object is converted from the MongoDBnative representation using an instance of {@see MongoConverter}. Unless
          * configured otherwise, an instance ofSimpleMongoConverter will be used.
          * <p/>
          * The query is specified as a {@link Query}which can be created either using the {@link BasicQuery} or the more
          * feature rich {@link Query}.
          *
          * @param query the query class that specifiesthe criteria used to find a record and also an optional fields
          *         specification
          * @param entityClass the parameterized type ofthe returned list.
          * @return the converted object
          */

       <T> TfindOne(Query query, Class<T> entityClass);


 
         /**
          * Map the results of an ad-hoc query on thespecified collection to a single instance of an object of the specified
          * type.
          * <p/>
          * The object is converted from the MongoDBnative representation using an instance of {@see MongoConverter}. Unless
          * configured otherwise, an instance ofSimpleMongoConverter will be used.
          * <p/>
          * The query is specified as a {@link Query}which can be created either using the {@link BasicQuery} or the more
          * feature rich {@link Query}.
          *
          * @param query the query class that specifiesthe criteria used to find a record and also an optional fields
          *         specification
          * @param entityClass the parameterized type ofthe returned list.
          * @param collectionName name of the collectionto retrieve the objects from
          *
          * @return the converted object
          */

       <T> T findOne(Queryquery, Class<T> entityClass, String collectionName);


 
         /**
          * Map the results of an ad-hoc query on thecollection for the entity class to a List of the specified type.
          * <p/>
          * The object is converted from the MongoDBnative representation using an instance of {@see MongoConverter}. Unless
          * configured otherwise, an instance ofSimpleMongoConverter will be used.
          * <p/>
          * The query is specified as a {@link Query}which can be created either using the {@link BasicQuery} or the more
          * feature rich {@link Query}.
          *
          * @param query the query class that specifiesthe criteria used to find a record and also an optional fields
          *         specification
          * @param entityClass the parameterized type ofthe returned list.
          * @return the List of converted objects
          */

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


 
         /**
          * Map the results of an ad-hoc query on thespecified collection to a List of the specified type.
          * <p/>
          * The object is converted from the MongoDBnative representation using an instance of {@see MongoConverter}. Unless
          * configured otherwise, an instance ofSimpleMongoConverter will be used.
          * <p/>
          * The query is specified as a {@link Query}which can be created either using the {@link BasicQuery} or the more
          * feature rich {@link Query}.
          *
          * @param query the query class that specifiesthe criteria used to find a record and also an optional fields
          *         specification
          * @param entityClass the parameterized type ofthe returned list.
          * @param collectionName name of the collectionto retrieve the objects from
          *
          * @return the List of converted objects
          */

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


 
         /**
          * Returns a document with the given id mappedonto the given class. The collection the query is ran against will be
          * derived from the given target class as well.
          *
          * @param <T>
          * @param id the id of the document to return.
          * @param entityClass the type the documentshall be converted into.
          * @return the document with the given idmapped onto the given target class.
          */

       <T> TfindById(Object id, Class<T> entityClass);


 
         /**
          * Returns the document with the given id fromthe given collection mapped onto the given target class.
          *
          * @param id the id of the document to return
          * @param entityClass the type to convert thedocument to
          * @param collectionName the collection toquery for the document
          *
          * @param <T>
          * @return
          */

       <T> TfindById(Object id, Class<T> entityClass, String collectionName);


 

       <T> TfindAndModify(Query query, Update update, Class<T> entityClass);


 

       <T> TfindAndModify(Query query, Update update, Class<T> entityClass, StringcollectionName);


 

       <T> TfindAndModify(Query query, Update update, FindAndModifyOptions options,Class<T> entityClass);


 

       <T> TfindAndModify(Query query, Update update, FindAndModifyOptions options,Class<T> entityClass,       StringcollectionName);


 
         /**
          * Map the results of an ad-hoc query on thecollection for the entity type to a single instance of an object of the
          * specified type. The first document thatmatches the query is returned and also removed from the collection in the
          * database.
          * <p/>
          * The object is converted from the MongoDBnative representation using an instance of {@see MongoConverter}.
          * <p/>
          * The query is specified as a {@link Query}which can be created either using the {@link BasicQuery} or the more
          * feature rich {@link Query}.
          *
          * @param query the query class that specifiesthe criteria used to find a record and also an optional fields
          *         specification
          * @param entityClass the parameterized type ofthe returned list.
          * @return the converted object
          */

       <T> TfindAndRemove(Query query, Class<T> entityClass);


 
         /**
          * Map the results of an ad-hoc query on thespecified collection to a single instance of an object of the specified
          * type. The first document that matches thequery is returned and also removed from the collection in the database.
          * <p/>
          * The object is converted from the MongoDBnative representation using an instance of {@see MongoConverter}. Unless
          * configured otherwise, an instance ofSimpleMongoConverter will be used.
          * <p/>
          * The query is specified as a {@link Query}which can be created either using the {@link BasicQuery} or the more
          * feature rich {@link Query}.
          *
          * @param query the query class that specifiesthe criteria used to find a record and also an optional fields
          *         specification
          * @param entityClass the parameterized type ofthe returned list.
          * @param collectionName name of the collectionto retrieve the objects from
          *
          * @return the converted object
          */

       <T> TfindAndRemove(Query query, Class<T> entityClass, String collectionName);


 
         /**
          * Returns the number of documents for thegiven {@link Query} by querying the collection of the given entity class.
          *
          * @param query
          * @param entityClass must not be {@literalnull}.
          * @return
          */
         longcount(Query query, Class<?> entityClass);
 
         /**
          * Returns the number of documents for thegiven {@link Query} querying the given collection.
          *
          * @param query
          * @param collectionName must not be {@literalnull} or empty.
          * @return
          */

       longcount(Query query, String collectionName);


 
         /**
          * Insert the object into the collection forthe entity type of the object to save.
          * <p/>
          * The object is converted to the MongoDBnative representation using an instance of {@see MongoConverter}.
          * <p/>
          * If you object has an "Id' property, itwill be set with the generated Id from MongoDB. If your Id property is a
          * String then MongoDB ObjectId will be used topopulate that string. Otherwise, the conversion from ObjectId to your
          * property type will be handled by Spring'sBeanWrapper class that leverages Spring 3.0's new Type Conversion API.
          * See <ahref="http://static.springsource.org/spring/docs/3.0.x/reference/validation.html#core-convert">Spring3 Type
          * Conversion"</a> for more details.
          * <p/>
          * <p/>
          * Insert is used to initially store the objectinto the database. To update an existing object use the save method.
          *
          * @param objectToSave the object to store inthe collection.
          */

       voidinsert(Object objectToSave);


       Person person =new Person();
       person.setAge(15);
       person.setName("zhangsan");
       mongoTemplate.insert(person);

 
         /**
          * Insert the object into the specifiedcollection.
          * <p/>
          * The object is converted to the MongoDBnative representation using an instance of {@see MongoConverter}. Unless
          * configured otherwise, an instance ofSimpleMongoConverter will be used.
          * <p/>
          * Insert is used to initially store the objectinto the database. To update an existing object use the save method.
          *
          * @param objectToSave the object to store inthe collection
          * @param collectionName name of the collectionto store the object in
          */

       voidinsert(Object objectToSave, String collectionName);


 
       Person person =new Person();
        person.setAge(15);
       person.setName("zhangsan");
       mongoTemplate.insert(person, "person");
 
 

 
         /**
          * Insert a Collection of objects into acollection in a single batch write to the database.
          *
          * @param batchToSave the list of objects tosave.
          * @param entityClass class that determines thecollection to use
          */

       voidinsert(Collection<? extends Object> batchToSave, Class<?>entityClass);


    Person person =new Person();
       person.setAge(15);
       person.setName("zhangsan");
       Person person2 =new Person();
       person2.setAge(16);
       person2.setName("lisi");
       List<Person> persons=new ArrayList<Person>();
       persons.add(person);
       persons.add(person2);
       mongoTemplate.insert(persons,Person.class);

 
         /**
          * Insert a list of objects into the specifiedcollection in a single batch write to the database.
          *
          * @param batchToSave the list of objects tosave.
          * @param collectionName name of the collectionto store the object in
          */

       voidinsert(Collection<? extends Object> batchToSave, String collectionName);


 

    Person person =new Person();
       person.setAge(15);
       person.setName("zhangsan");
       Person person2 =new Person();
       person2.setAge(16);
       person2.setName("lisi");
       List<Person> persons=new ArrayList<Person>();
       persons.add(person);
       persons.add(person2);
       mongoTemplate.insert(persons, "person");

 
 
         /**
          * Insert a mixed Collection of objects into adatabase collection determining the collection name to use based on the
          * class.
          *
          * @param collectionToSave the list of objectsto save.
          */

       voidinsertAll(Collection<? extends Object> objectsToSave);


       Person person =new Person();
       person.setAge(15);
       person.setName("zhangsan");
       Person person2 =new Person();
       person2.setAge(16);
       person2.setName("lisi");
       List<Person> persons=new ArrayList<Person>();
       persons.add(person);
       persons.add(person2);
       mongoTemplate.insertAll(persons);

 
         /**
          * Save the object to the collection for theentity type of the object to save. This will perform an insert if the
          * object is not already present, that is an'upsert'.
          * <p/>
          * The object is converted to the MongoDBnative representation using an instance of {@see MongoConverter}. Unless
          * configured otherwise, an instance ofSimpleMongoConverter will be used.
          * <p/>
          * If you object has an "Id' property, itwill be set with the generated Id from MongoDB. If your Id property is a
          * String then MongoDB ObjectId will be used topopulate that string. Otherwise, the conversion from ObjectId to your
          * property type will be handled by Spring'sBeanWrapper class that leverages Spring 3.0's new Type Conversion API.
          * See <ahref="http://static.springsource.org/spring/docs/3.0.x/reference/validation.html#core-convert">Spring3 Type
          * Conversion"</a> for more details.
          *
          * @param objectToSave the object to store inthe collection
          */

       voidsave(Object objectToSave);


Person person =new Person();
       person.setAge(15);
       person.setName("zhangsan");
       mongoTemplate.save(person);
      

 
         /**
          * Save the object to the specified collection.This will perform an insert if the object is not already present, that
          * is an 'upsert'.
          * <p/>
          * The object is converted to the MongoDBnative representation using an instance of {@see MongoConverter}. Unless
          * configured otherwise, an instance ofSimpleMongoConverter will be used.
          * <p/>
          * If you object has an "Id' property, itwill be set with the generated Id from MongoDB. If your Id property is a
          * String then MongoDB ObjectId will be used topopulate that string. Otherwise, the conversion from ObjectId to your
          * property type will be handled by Spring'sBeanWrapper class that leverages Spring 3.0's new Type Cobnversion API.
          * See <ahref="http://static.springsource.org/spring/docs/3.0.x/reference/validation.html#core-convert">Spring3 Type
          * Conversion"</a> for more details.
          *
          * @param objectToSave the object to store inthe collection
          * @param collectionName name of the collectionto store the object in
          */

       voidsave(Object objectToSave, String collectionName);


 

    Person person =new Person();
       person.setAge(15);
       person.setName("zhangsan");
       mongoTemplate.save(person,"person");

 
 
         /**
          * Performs an upsert. If no document is foundthat matches the query, a new document is created and inserted by
          * combining the query document and the updatedocument.
          *
          * @param query the query document thatspecifies the criteria used to select a record to be upserted
          * @param update the update document thatcontains the updated object or $ operators to manipulate the existing object
          * @param entityClass class that determines thecollection to use
          * @return the WriteResult which lets youaccess the results of the previous write.
          */
         WriteResultupsert(Query query, Update update, Class<?> entityClass);
 
         /**
          * Performs an upsert. If no document is foundthat matches the query, a new document is created and inserted by
          * combining the query document and the updatedocument.
          *
          * @param query the query document thatspecifies the criteria used to select a record to be updated
          * @param update the update document thatcontains the updated object or $ operators to manipulate the existing
          *         object.
          * @param collectionName name of the collectionto update the object in
          * @return the WriteResult which lets youaccess the results of the previous write.
          */

       WriteResultupsert(Query query, Update update, String collectionName);


 
         /**
          * Updates the first object that is found inthe collection of the entity class that matches the query document with
          * the provided update document.
          *
          * @param query the query document thatspecifies the criteria used to select a record to be updated
          * @param update the update document thatcontains the updated object or $ operators to manipulate the existing
          *         object.
          * @param entityClass class that determines thecollection to use
          * @return the WriteResult which lets youaccess the results of the previous write.
          */

       WriteResultupdateFirst(Query query, Update update, Class<?> entityClass);


 
         /**
          * Updates the first object that is found inthe specified collection that matches the query document criteria with
          * the provided updated document.
          *
          * @param query the query document thatspecifies the criteria used to select a record to be updated
          * @param update the update document thatcontains the updated object or $ operators to manipulate the existing
          *         object.
          * @param collectionName name of the collectionto update the object in
          * @return the WriteResult which lets youaccess the results of the previous write.
          */

       WriteResultupdateFirst(Query query, Update update, String collectionName);


 
         /**
          * Updates all objects that are found in thecollection for the entity class that matches the query document criteria
          * with the provided updated document.
          *
          * @param query the query document thatspecifies the criteria used to select a record to be updated
          * @param update the update document thatcontains the updated object or $ operators to manipulate the existing
          *         object.
          * @param entityClass class that determines thecollection to use
          * @return the WriteResult which lets youaccess the results of the previous write.
          */

       WriteResultupdateMulti(Query query, Update update, Class<?> entityClass);


 
         /**
          * Updates all objects that are found in thespecified collection that matches the query document criteria with the
          * provided updated document.
          *
          * @param query the query document thatspecifies the criteria used to select a record to be updated
          * @param update the update document thatcontains the updated object or $ operators to manipulate the existing
          *         object.
          * @param collectionName name of the collectionto update the object in
          * @return the WriteResult which lets youaccess the results of the previous write.
          */

       WriteResultupdateMulti(Query query, Update update, String collectionName);


 
         /**
          * Remove the given object from the collectionby id.
          *
          * @param object
          */

       voidremove(Object object);


 
         /**
          * Removes the given object from the givencollection.
          *
          * @param object
          * @param collection must not be {@literalnull} or empty.
          */

       voidremove(Object object, String collection);


 
         /**
          * Remove all documents that match the providedquery document criteria from the the collection used to store the
          * entityClass. The Class parameter is alsoused to help convert the Id of the object if it is present in the query.
          *
          * @param <T>
          * @param query
          * @param entityClass
          */

       <T> voidremove(Query query, Class<T> entityClass);


 
         /**
          * Remove all documents from the specifiedcollection that match the provided query document criteria. There is no
          * conversion/mapping done for any criteriausing the id field.
          *
          * @param query the query document thatspecifies the criteria used to remove a record
          * @param collectionName name of the collectionwhere the objects will removed
          */

       voidremove(Query query, String collectionName);


 
         /**
          * Returns the underlying {@linkMongoConverter}.
          *
          * @return
          */

       MongoConvertergetConverter();



分享给朋友:
您可能感兴趣的文章:
随机阅读: