MongoDB学习笔记(十三)：SpringData-Mongodb

最完整原版教程：http://docs.spring.io/spring-data/data-mongo/docs/1.4.0.RELEASE/reference/html/mongo.core.html 
范例中的MetaDBMongoFactory是我自己写的，你也可以通过Spring配置文件获得。如下 
http://www.blogjava.net/wangxinsh55/archive/2012/03/29/372987.html 

1.单表增删查改 
@Id - 文档的唯一标识，在mongodb中为ObjectId，它是唯一的，通过时间戳+机器标识+进程ID+自增计数器（确保同一秒内产生的Id不会冲突）构成。 
@Document - 把一个java类声明为mongodb的文档，可以通过collection参数指定这个类对应的文档。 
@DBRef - 声明类似于关系数据库的关联关系。ps：暂不支持级联的保存功能，当你在本实例中修改了DERef对象里面的值时，单独保存本实例并不能保存DERef引用的对象，它要另外保存，如下面例子的Person和Account。 
@Indexed - 声明该字段需要索引，建索引可以大大的提高查询效率。 
@CompoundIndex - 复合索引的声明，建复合索引可以有效地提高多字段的查询效率。 
@GeoSpatialIndexed - 声明该字段为地理信息的索引。 
@Transient - 映射忽略的字段，该字段不会保存到mongodb。 
@PersistenceConstructor - 声明构造函数，作用是把从数据库取出的数据实例化为对象。该构造函数传入的值为从DBObject中取出的数据。 
文档版本: @Version （建议用Long） 

范例： 
新建实体：

01. public class User

02. {

03. @Id  

04. private ObjectId id;  

05. @Indexed(unique = true)  

06. private String ssn;

07. @Indexed  

08. private String userName;  

09. private String password;

10. private Integer age;  

11. @Transient  

12. private Integer accountTotal;  

13. //其它set,get略......

14. }

增删查改

01. public void testCurd()

02. {

03. MongoTemplate template = MetaDBMongoFactory.getInstance().getMongoTemplate();

04. User user = new User();        

05. user.setSsn(...);//唯一性内容

06. user.setPassword("123456");

07. user.setUsername("张三");

08.  

09. //增加

10. template.save(user);

11. System.out.println("1. user : " + user);

12.  

13. //查询

14. Query searchUserQuery = new Query(Criteria.where("username").is("张三"));

15. User savedUser = template.findOne(searchUserQuery, User.class);

16. System.out.println("2. find - savedUser : " + savedUser);

17.  

18. //修改

19. template.updateFirst(searchUserQuery, Update.update("password", "45678"), User.class);

20. User updatedUser = template.findOne(searchUserQuery, User.class);

21. System.out.println("3. updatedUser : " + updatedUser);

22.  

23. //删除

24. template.remove(searchUserQuery, User.class);

25. List<User> listUser = template.findAll(User.class);

26. System.out.println("4. Number of user = " + listUser.size());

27. }

在看个更多功能的实体类

01. @Document(collection="person")  

02. @CompoundIndexes({  //组合索引

03. @CompoundIndex(name = "age_idx", def = "{'lastName': 1, 'age': -1}")  

04. })  

05. public class sample {  

06.  

07. @Id  

08. private String id;  

09. @Indexed(unique = true)  

10. private Integer ssn;  

11. private String firstName;  

12. @Indexed  

13. private String lastName;  

14. private Integer age;  

15. @Transient  

16. private Integer accountTotal;  

17. @DBRef  

18. private List<Account> accounts;  

19.  

20. .....set and get

21. }

 

2.关联方式1：DBRef 一对一，一对多 
多对多就是对方表也放个list一起保存呗 

User.java

01. public class User

02. {

03. @Id

04. private ObjectId id;

05. @Indexed

06. private String name;

07. private Integer age;

08. @DBRef

09. private Weapon weapon;//一对一

10. @DBRef

11. private List<Item> items;//一对多

12. //set,get略......

13. }

Weapon.java

1. public class Weapon

2. {

3. @Id

4. private ObjectId id;

5. private String name;

6. private int power;

7. //set,get略......

8. }

Item.java

1. public class Item

2. {

3. @Id

4. private ObjectId id;

5. private String name;

6. private String desc;

7. //set,get略......

8. }

添加：

01. private voidsave()

02. {

03. MongoTemplate template = MetaDBMongoFactory.getInstance().getMongoTemplate();

04.  

05. User user = new User();

06. user.setName("张三");

07. user.setAge(30);

08.  

09. List<Item> items = new ArrayList<Item>();

10. for (int i = 0; i < 10; i++)

11. {

12. Item item = new Item();

13. item.setName("道具" + i);

14. item.setDesc("描述");

15. template.save(item);

16. items.add(item);

17. }

18.  

19. Weapon weapon = new Weapon();

20. weapon.setName("武器");

21. weapon.setPower(99);

22. template.save(weapon);

23.  

24. user.setWeapon(weapon);

25. user.setItems(items);

26. template.save(user);

27. }

查询 
一对多的对象会全部拿出来，所以如果关联的对象特别多超过几千，请用lazy=true的方式，懒惰加载

1. User user = template.findOne(new Query(Criteria.where("id").is(id)), User.class);

DBRef查询

1. ObjectId id = user.getId();Weapon myWeapon = template.findOne(new Query(Criteria.where("name").is("武器1")),Weapon.class);

2. Query query = new Query(Criteria.where("id").is(id).and("myWeapon").is(myWeapon));

3. User queryResult = template.findOne(query, User.class);

DBRef原生查询

1. Query query = new BasicQuery("{'id':'"+id.toString()+"', 'weapon' : {'$ref':'weapon','$id':{'$oid':'52e9affffad134ac3ee2e02a'}} }");

2. User queryResult = template.findOne(query, User.class);

排序

1. Query query = new Query(Criteria.where("id").is(id));

2. query.with(new Sort(Sort.Direction.DESC, "name"));

3. ......

分页，表示每页最多10条，从第3页开始

1. Query query = new Query(Criteria.where("id").is(id));

2. query.limit(10);

3. query.skip(20);

懒惰加载（1.4.0新功能，棒极了，大大提高效率）

1. @DBRef(lazy = true)

2. private List<Item> myItems;//一对多

 

3.关联方式2：集合属性 
比起DBRef模式的好处在于通过elemMatch能查询过滤。但缺点就是数据冗余。 
表字段性除了基本属性，还可以是任何对象，Map，List，这点是关系数据库做不到的。 

范例是获取用户信息，并且只取出名字是道具1的道具，如果道具特别多，这种写法可以有效加强性能

01. public class User

02. {

03. @Id

04. private ObjectId id;

05. @Indexed

06. private String name;

07. private Integer age;

08. private List<Item> items;

09. }

查询：

1. Query query = new Query(Criteria.where("id").is(id));

2. query.fields().include("items").include("name").elemMatch("items",Criteria.where("name").is("道具1"));

3. User user = template.findOne(query, User.class);

.include("items").include("name")表示查询结果集只需要这2列数据，这种做法可以减少读取的io字节大小 
elemMatch是过滤返回的items是一部分而不需要全部

 

4.聚合查询 

1).分组Group

1. GroupByResults<XObject> results =  template.group("user", GroupBy.key("age").initialDocument("{ count: 0 }").reduceFunction("function(doc, prev) { prev.count += 1 }"), XObject.class);

最后结果集里，比如看到，但最多只能处理2万条数据 
"retval":[{"age":13.0,"count":2.0},{"age":14.0,"count":1.0},{"age":30.0,"count":33.0}],"count":36.0 


2).MapReduce统计

1. MapReduceResults<User> asd = template.mapReduce("user", "function(){emit( this.id , { count : 1 } )}",

2. "function(key, values){var total=0;values.forEach(function(val){total += val.count;});return {count : total};}", User.class);

3).Aggregation 
范例是统计User每个用户多少条记录，类似于oracle的group

1. class UserStats {

2. String id;

3. Integer totalCount;

4. //其它set get

5. }

1. import static org.springframework.data.mongodb.core.aggregation.Aggregation.*;

2. Aggregation agg = newAggregation(

3. User.class,

4. group("name").count().as("totalCount"),

5. sort(Sort.Direction.ASC, previousOperation(), "totalCount"),

6. match(new Criteria(.....))//过滤条件

7. );

8. AggregationResults<UserStats> aggregateResult = template.aggregate(agg, "user", UserStats.class);

结果集： 
"mappedResults":[{"id":"方佳玮","totalCount":12}]

 

5.副本集群模式下，读写分离 

统一配置：

1. template.setReadPreference(ReadPreference.nearest());

2. Weapon myWeapon = template.findOne(new Query(Criteria.where("name").is("武器1"))

原生Api

1. DBObject dbObject = coll.findOne(object, null , preference);

说明： 
primary:默认参数，只从主节点上进行读取操作； 
primaryPreferred:大部分从主节点上读取数据,只有主节点不可用时从secondary节点读取数据。 
secondary:只从secondary节点上进行读取操作，存在的问题是secondary节点的数据会比primary节点数据“旧”。 
secondaryPreferred:优先从secondary节点进行读取操作，secondary节点不可用时从主节点读取数据； 
nearest:不管是主节点、secondary节点，从网络延迟最低的节点上读取数据。

 

 

 

6.文件读写（Gridfs）

 

01. public void save(File file, String fileName) throws FileNotFoundException

02. {

03. GridFsTemplate gridFsTemplate = MetaDBMongoFactory.getInstance().getGridFsTemplate();

04. MongoTemplate template = MetaDBMongoFactory.getInstance().getMongoTemplate();

05. SinitekFiles sinitekFiles = new SinitekFiles();

06. sinitekFiles.setDesc("描述");

07. gridFsTemplate.store(new FileInputStream(file), fileName,sinitekFiles);

08. }

09.  

10. public GridFSDBFile query(String fileName) throws FileNotFoundException

11. {

12. GridFsTemplate gridFsTemplate = MetaDBMongoFactory.getInstance().getGridFsTemplate();

13. return gridFsTemplate.findOne(Query.query(Criteria.where("filename").is(fileName)));

14. }

下面是原生api方式

1. DB db = mongoDbFactory.getDb();  

保存文件（其中FS_NAME相当于gridfs文件系统的表名，可以有多个）

01. public boolean saveFile(File file, String fileName, String contentType,

02. DBObject metaData) {

03.  

04. GridFSInputFile gfsInput;

05. try {   

06. gfsInput = new GridFS(db, FS_NAME).createFile(file);

07. gfsInput.setFilename(fileName);

08. gfsInput.setContentType(contentType);

09. gfsInput.setMetaData(metaData);

10. gfsInput.save();

11. } catch (IOException e) {

12. log.error(e, e);

13. return false;

14. }

15. return true;

16. }

通过文件名读取文件

01. public GridFSDBFile findFileByName(String fileName){

02. GridFSDBFile gfsFile ;

03. try {      

04. gfsFile = new GridFS(db, FS_NAME).findOne(fileName);

05. } catch (Exception e) {

06. log.error(e, e);

07. return null;

08. }

09. return gfsFile;

10. }

通过id读取文件

01. public GridFSDBFile findFileById(String id){

02. GridFSDBFile gfsFile ;

03. try {      

04. gfsFile = new GridFS(db, FS_NAME).find(new ObjectId(id));

05. } catch (Exception e) {

06. log.error(e, e);

07. return null;

08. }

09. return gfsFile;

10. }

输出文件到OutputStream

查看

打印 ?

01. private boolean writeToOutputStream(OutputStream out, GridFSDBFile gfsFile) {

02. try {     

03. gfsFile.writeTo(out);

04. } catch (IOException e) {

05. log.error(e, e);

06. return false;

07. }

08. return true;

09. }

 

 

 

 

 

7.文件读写（Document）

 

我偷懒范例选自网络，用的原生api，估计spring momgodb也差不多  

保存：

01. public static void main(String[] args) {

02. try {

03. Mongo mongo = new Mongo();

04. DB db = mongo.getDB("company");

05. DBCollection collection = db.getCollection("userinfo");

06. BasicDBObject employees = new BasicDBObject();

07. File file = new File("d://shuimohua01.jpg");

08. FileInputStream input = new FileInputStream(file);

09. byte[] files = new byte[input.available()];

10. while (input.read(files)>0) {

11. input.read(files);

12. }

13. input.close();

14. employees.put("no", "1015");

15. collection.remove(employees);

16. employees.put("member", files);

17. employees.put("filename", file.getName());

18. System.out.println(files.length);

19. collection.insert(employees);

20. } catch (UnknownHostException e) {

21. // TODO Auto-generated catch block

22. e.printStackTrace();

23. } catch (MongoException e) {

24. // TODO Auto-generated catch block

25. e.printStackTrace();

26. } catch (FileNotFoundException e) {

27. // TODO Auto-generated catch block

28. e.printStackTrace();

29. } catch (IOException e) {

30. // TODO Auto-generated catch block

31. e.printStackTrace();

32. }

33. }

34. }

读取：

查看

打印 ?

01. public static void main(String[] args) {

02. try {

03. Mongo mongo = new Mongo();

04. DB db = mongo.getDB("company");

05. DBCollection collection = db.getCollection("userinfo");

06. DBObject employees = new BasicDBObject();

07. employees.put("no", "1015");

08. employees = collection.findOne(employees);

09. byte[] files = (byte[]) employees.get("member");

10. ByteArrayInputStream input = new ByteArrayInputStream(files);

11. File f = new File("e://" + employees.get("filename"));

12. FileOutputStream output = new FileOutputStream(f);

13. byte[] b=new byte[input.available()];

14. while (input.read(b)>0) {

15. input.read(b);

16. output.write(files);

17. }

18. input.close();

19. output.close();

20. } catch (UnknownHostException e) {

21. // TODO Auto-generated catch block

22. e.printStackTrace();

23. } catch (MongoException e) {

24. // TODO Auto-generated catch block

25. e.printStackTrace();

26. } catch (IOException e) {

27. // TODO Auto-generated catch block

28. e.printStackTrace();

29. }

30. }

31. }