Spring Data MongoDB Five: Advanced document query (paging, Morphia) (ii)

Spring Data MongoDB III: Basic document Queries (query, basicquery) (i)

Learn MongoDB Six: MongoDB query (cursor action, cursor information) (iii)

A. Introduction

Springdata MongoDB provides a org.springframework.data.mongodb.core.MongoTemplate to MongoDB's find operation, we introduced a basic document query, we introduce a paging query today, a paged query is returned to the matching document cursor, The ability to modify query restrictions, jumps, and sort orders is optional.

We are querying when find () Method accepts the query type with Org.springframework.data.mongodb.core.query and Org.springframework.data.mongodb.core.query.BasicQuery

The query class provides methods with the ability to limit, skip, sort query restrictions, jumps, and sort order, and Basicquery inherits the query class.

Query	Mongodb	Description
Query limit (int limit)	Limit	method is to limit the number of results returned by the cursor
Query Skip (int skip)	Skip	The method can skip the number of bars of the specified value, return the result of the remaining number of bars, and can be combined with the limit () method to achieve pagination effect
Sort sort () is obsolete Now it's using query.with (sort)	Sort	method to sort the data, according to the specified field, and using 1 or-one to specify whether the sort is ascending or descending, similar to SQL's order by.

two. Basic Paging

The query class provides methods with limit, skip, sort query restrictions, jumps, and sort order functions, and we implement query paging

First step: Implement the Paging tool class

/** * Pagination * @author zhengcy * * @param <T> */public classpagemodel<t>{//result set privatelist<t> datas;    Number of query records privateintrowcount;   How many data privateintpagesize=20 per page;   The first few pages of privateintpageno=1;    Skip a few numbers privateintskip=0;    /** * Total pages * @return */publicintgettotalpages () {return (rowcount+pagesize-1)/pagesize;   } public List<t>getdatas () {return datas;   } public void Setdatas (list<t>datas) {this.datas = datas;   } public int GetRowCount () {return rowCount;   } public void Setrowcount (int rowCount) {this.rowcount = RowCount;   } public int getpagesize () {return pageSize;   } public void SetPageSize (int pageSize) {this.pagesize = pageSize;      } public int Getskip () {skip= (pageNo-1) *pagesize;   return skip;   } public void Setskip (int skip) {This.skip = skip;   } public int Getpageno () {return pageno; } public void Setpageno (int pageno){This.pageno = PageNo; }         }

Step Two: Implementing Paging

     

   @Override public   pagemodel<orders>getorders (pagemodel<orders> page, DBObject Queryobject, Stringcollectionname) {      queryquery=newbasicquery (queryobject);      Total Queries      int count= (int) mongotemplate.count (query,orders.class);      Page.setrowcount (count);           Sort         Query.with (new sort (DIRECTION.ASC, "Onumber"));        Query.skip (Page.getskip ()). Limit (Page.getpagesize ());      List<orders>datas=mongotemplate.find (query,orders.class);      Page.setdatas (datas);      return page;   }

Description

Sort:sort () is obsolete, it is now used with query.with (sort), the with parameter is the sort class

The sort provides several constructors

Description of the method

(1) Sorting of a field

For example Onumber Word orderby order

Query.with (New Sort (DIRECTION.ASC, "Onumber"));

(2) If multiple fields are in ascending or descending order

Sort

Query.with (New Sort (DIRECTION.ASC, "a", "B", "C"));

(3) Different fields are sorted according to different

       List<sort.order>orders=new arraylist<sort.order> ();       Orders.add (Newsort.order (DIRECTION.ASC, "a"));       Orders.add (Newsort.order (Direction.desc, "B"));       Query.with (Newsort (orders));

a ascending in descending order B

Step three: Test class

       @Test public      void Testlist () throws ParseException      {        pagemodel<orders>page=newpagemodel< Orders> ();        Page.setpageno (1);        Page=ordersdao.getorders (page, New Basicdbobject ("CNAME", "Zcy"), CollectionName);        System.out.println ("Total:" +page.getrowcount ());        System.out.println ("Number of returned bars:" +page.getdatas (). Size ());        System.out.println (Jsonarray.fromobject (Page.getdatas ()));      }

Query condition is cname=zcy

The Skip method is to skip the number of bars, and is a single skip, if the collection is larger (such as a lot of pages) skip will be more and more slow, need more processor (CPU), which will affect performance.

third, advanced query paging

To return to the cursor of the matching document, you can modify the query restrictions, jumps, and sort order functions, and we will use the Morphia framework for the results returned by the pointer.

Morphia is an open source object-relational mapping framework for the MONGODB Database Java Edition drive A very lightweight object encapsulation. We need to convert the DBObject obtained by DBCUROSR into our corresponding entity objects, so that we can manipulate the entities.

DBCUROSR is the object returned by the Find method of Dbcollection, you can set the skip, limit, Sot and other properties to perform paged queries

The first step: The entity ID to be annotated @id

Importcom.google.code.morphia.annotations.Id;

@Id

Privatestring ID;

@Id comment indicates morphia which field is used as the document Id

If not added, there will be such a mistake.

... More

caused by: com.google.code.morphia.mapping.validation.ConstraintViolationException : Number of violations:1

Noid complained Aboutcom.mongo.model.Orders. : No field is annotated with @Id; But it is required

atcom.google.code.morphia.mapping.validation.MappingValidator.validate (mappingvalidator.java:66 )

atcom.google.code.morphia.mapping.validation.MappingValidator.validate (mappingvalidator.java:155 )

atcom.google.code.morphia.mapping.MappedClass.validate (mappedclass.java:259)

Atcom.google.code.morphia.mapping.Mapper.addMappedClass (mapper.java:154)

Atcom.google.code.morphia.mapping.Mapper.addMappedClass (mapper.java:142)

Atcom.google.code.morphia.Morphia.map (morphia.java:55)

atcom.mongo.dao.impl.ordersdaoimpl.<init> (ordersdaoimpl.java:37)

Atsun.reflect.NativeConstructorAccessorImpl.newInstance0 (Native Method)

Atsun.reflect.NativeConstructorAccessorImpl.newInstance (Unknown Source)

Atsun.reflect.DelegatingConstructorAccessorImpl.newInstance (Unknown Source)

Atjava.lang.reflect.Constructor.newInstance (Unknown Source)

Atorg.springframework.beans.BeanUtils.instantiateClass (beanutils.java:148)

... 29more

Step Two: Implement:

   Privatemorphia Morphia;      Public Ordersdaoimpl () {morphia= new Morphia ();   Morphia.map (Orders.class); } @Override Public Pagemodel<orders>getorders (pagemodel<orders> page, DBObject Queryobject,      Stringcollectionname) {dbobjectfilterdbobject=newbasicdbobject ();      Filterdbobject.put ("_id", 0);      Filterdbobject.put ("CNAME", 1);             Filterdbobject.put ("Onumber", 1);           Dbcursordbcursor=mongotemplate.getcollection (CollectionName). Find (Queryobject,filterdbobject);      Sort Dbobjectsortdbobject=newbasicdbobject ();      Sortdbobject.put ("Onumber", 1);      Dbcursor.sort (Sortdbobject);           Paged Query Dbcursor.skip (Page.getskip ()). Limit (Page.getpagesize ());      Total int count=dbcursor.count ();      Circular pointer list<orders>datas=newarraylist<orders> ();      while (Dbcursor.hasnext ()) {Datas.add (Morphia.fromdbobject (Orders.class, Dbcursor.next ()));      } page.setrowcount (count); Page.setdAtas (datas); return page;}

when we start executing DAO, we first initialize the Morphia and add the entity class that we need to convert.

Morphia=new morphia ();

Morphia. Map (Orders. Class);

Dbcursor.hasnext () to determine if there is a next document (dbobject), dbcursor.next () gets dbobject, we pass Morphia DBObject the corresponding entity class.

Return the required fields through Filterdbobject settings at query time

      MongoDB query result returned by server cursor.hasnext () mongodb bulk size does not exceed the maximum of bson document size However for most queries, the first batch returns 101 document or enough files more than 1 MB 4 MB 101 hasnext

Four. Other methods of querying

mongotemplate . FindAll Query Collection All documents are equivalent to MongoDB's Db.collect.find ().

mongotemplate . FindByID queries the document according to the document _ID.

mongotemplate . Findandremove according to the query criteria, the query matches the document returned and deleted from the database.

When we query, this side of the default is to use the index, for the data volume of the document, need to establish a suitable index, speed up the query efficiency.

Copyright NOTICE: This article for Bo Master original article, without Bo Master permission not reproduced.

Spring Data MongoDB Five: Advanced document query (paging, Morphia) (ii)