Spring管理MongoDB

Spring管理MongoDB

安装Spring for Mongodb

Spring项目为方便对Mongodb的操作，建立了spring-data的子项目，地址在：

http://www.springsource.org/spring-data/mongodb，目前版本是1.0.0M2阶段，已支持对Mongodb的一系列基本操作。我们先从http://www.springsource.org/spring-data/mongodb中下载相关的包：spring-data-document-1.0.0.M2.zip，下载解压后，将解压后的四个JAR文件放到工程路径的lib库中，本文中还将使用Spring 3.0.4的版本，请读者自行下载配置。

Spring Mongodb的配置

目前，可以有两种方式对Spring mongodb进行配置。第一种是使用Spring 3中的注解，另外一种是使用传统的XML配置。下面分别进行讲解：

使用Spring 3中的注解

首先在配置类中，要继承AbstractMongoConfiguration类，代码如下：

1. packagecom.mkyong.config;  
2.  importorg.springframework.context.annotation.Bean;  
3.  importorg.springframework.context.annotation.Configuration;  
4.  importorg.springframework.data.document.mongodb.MongoTemplate;  
5.  importorg.springframework.data.document.mongodb.config.AbstractMongoConfiguration;  
6.  importcom.mongodb.Mongo;  
7.  /** 
8.  * Spring MongoDB configuration file 
9.  *  
10. */  
11.  @Configuration  
12.  publicclassSpringMongoConfig extendsAbstractMongoConfiguration {  
13.      @Override  
14.      public@Bean Mongo mongo() throwsException {  
15.          returnnewMongo("localhost");  
16.      }  
17.      @Override  
18.      public@Bean MongoTemplate mongoTemplate() throwsException {  
19.          returnnewMongoTemplate(mongo(),"yourdb","yourCollection");  
20.      }  
21.  }  

这里，引入了MongoTemplate模版类，并且使用对连接数据库的地址，数据库名和collection进行了初始化。

在调用Spring Mongodb配置时，只需要在需要使用的类中调用AnnotationConfigApplicationContext，传入刚才配置好的SpringMongoConfig类即可。如下代码所示：

  ApplicationContext
ctx =newAnnotationConfigApplicationContext(SpringMongoConfig.class);
MongoOperations
mongoOperation =(MongoOperations)ctx.getBean("mongoTemplate");

当获得了mongoOperation对象的实例后，即可进行对mongodb的相关操作。

使用XML配置文件

使用XML配置文件的方法如下：

1. <?xml version="1.0" encoding="UTF-8"?>  
2.  <beans xmlns="http://www.springframework.org/schema/beans"  
3.      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.      xmlns:context="http://www.springframework.org/schema/context"  
5.      xmlns:mongo="http://www.springframework.org/schema/data/mongo"  
6.      xsi:schemaLocation="http://www.springframework.org/schema/context  
7.            http://www.springframework.org/schema/context/spring-context-3.0.xsd  
8.            http://www.springframework.org/schema/data/mongo  
9.            http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd  
10.            http://www.springframework.org/schema/beans  
11.            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
12.      <!--Default bean name is 'mongo' -->  
13.      <mongo:mongo host="localhost"port="27017"/>  
14.      <bean id="mongoTemplate"  
15.                   class="org.springframework.data.document.mongodb.MongoTemplate">  
16.          <constructor-arg ref="mongo"/>  
17.          <constructor-arg name="databaseName"value="yourdb"/>  
18.          <constructor-arg name="defaultCollectionName"value="yourCollection"/>  
19.      </bean>  
20.      <!--To translate any MongoExceptions thrown in @Repository annotated classes -->  
21.      <context:annotation-config />  
22.  </beans>  

注意这里引用相关的命名空间xmlns:mongo="http://www.springframework.org/schema/data/mongo"
，并且在名为mongoTemplate中注入相关的数据库地址，数据库名即可，使用方法如下：

ApplicationContext ctx =newGenericXmlApplicationContext("mongo-config.xml");

使用Spring Mongodb实现增删改查操作

下面通过实例讲解如何使用Spring Mongodb实现增删改查操作，假设我们现在有一个实

体类user如下：

1. packagecom.mkyong.user;  
2.  publicclasSUSEr {  
3.  privateString id;  
4.  privateString firstname;  
5.  privateString lastname;  
6.  privateintage;  
7.  //getter and setter methods    
8. }  

接下来，我们看具体的操作代码，如下，这里假设要将user类保存到名为userprofile的数据集中。

1. packagecom.mkyong.core;  
2.    
3. importjava.util.List;  
4.    
5. importorg.springframework.context.ApplicationContext;  
6.  importorg.springframework.context.annotation.AnnotationConfigApplicationContext;  
7.  importorg.springframework.context.support.GenericXmlApplicationContext;  
8.  importorg.springframework.data.document.mongodb.MongoOperations;  
9.  importorg.springframework.data.document.mongodb.query.Criteria;  
10.  importorg.springframework.data.document.mongodb.query.Query;  
11.  importorg.springframework.data.document.mongodb.query.Update;  
12.  importcom.mkyong.config.SpringMongoConfig;  
13.  importcom.mkyong.user.User;  
14.  publicclassApp  
15.  {  
16.  publicstaticvoidmain( String[] args )  
17.  {  
18.  ApplicationContext ctx =newAnnotationConfigApplicationContext(SpringMongoConfig.class);  
19.  MongoOperations mongoOperation =(MongoOperations)ctx.getBean("mongoTemplate");  
20.  User user =newUser("1001", "yong", "mook kim", 30);  
21.  //保存   
22.  mongoOperation.save("userprofile",user);  
23.  //查找   
24.  User savedUser =mongoOperation.findOne("userprofile",  
25.  newQuery(Criteria.where("id").is("1001")),  
26.  User.class);  
27.  System.out.println("savedUser : "+savedUser);  
28.  //更新   
29.  mongoOperation.updateFirst("userprofile",  
30.  newQuery(Criteria.where("firstname").is("yong")),   
31. Update.update("lastname", "new lastname"));  
32.  User updatedUser =mongoOperation.findOne("userprofile",  
33.  newQuery(Criteria.where("id").is("1001")),  
34.  User.class);  
35.  System.out.println("updatedUser : "+updatedUser);  
36.  //删除   
37.  mongoOperation.remove("userprofile",  
38.  newQuery(Criteria.where("id").is("1001")),  
39.  User.class);  
40.  //显示当前列表   
41.  List<User>listUser =  
42.  mongoOperation.getCollection("userprofile", User.class);  
43.  System.out.println("Number of user = "+listUser.size());  
44.  }  
45.  }  

输出结果如下：

savedUser : User [id=1001, firstname=yong, lastname=mook kim, age=30]
updatedUser : User [id=1001, firstname=yong, lastname=newlastname, age=30]
Number of user =

Spring mongodb插入数据

下面详细讲解如何使用spring mongodb插入数据。在spring mongodb中，插入数据到

mongodb有如下几种方法：

1. User user =newUser("...");  
2.  //将user对象保存到"user"这个collection中   
3.  mongoOperation.save(user);  
4.  //将user对象保存到"new collection"这个collection中   
5.  mongoOperation.save("new collection",user);  
6.  //将user对象保存到"user"这个collection中   
7.  mongoOperation.insert(user);  
8.  //将user对象保存到"new collection"这个collection中   
9.  mongoOperation.insert("new collection", user);  
10.  //将user的对象列表(List)保存到"user"collection中去   
11.  mongoOperation.insertList(userInList);  
12.  //将user的对象列表(List)保存到"new collection"collection中去   
13.  mongoOperation.insertList("new collection", userInList);   

要注意的是,Spring mongodb中,当没有指定collection时,就会把对象保存到以对象命名的collection中。比如上例中的mongoOperation.insert(user)，由于没指定collection的名称，所以会把user对象保存到user这个新建立的collection中。

另外请注意其中的save和insert的区别。它们的区别为：

1)save意思是，当记录不存在时插入，或者是当记录已存在是更新，实际上就是saveorupdate的意思。

2) insert的意思是：当记录不存在时插入，而如果记录存在时则忽略，继续插入。

下面举例子说明：

1. packagecom.mkyong.core;  
2.  importjava.util.ArrayList;  
3.  importjava.util.List;  
4.  importorg.springframework.context.ApplicationContext;  
5.  importorg.springframework.context.annotation.AnnotationConfigApplicationContext;  
6.  importorg.springframework.data.document.mongodb.MongoOperations;  
7.  importorg.springframework.data.document.mongodb.query.Criteria;  
8.  importorg.springframework.data.document.mongodb.query.Query;  
9.  importcom.mkyong.config.SpringMongoConfig;  
10.  importcom.mkyong.user.User;  
11.  publicclassApp {  
12.  publicstaticvoidmain(String[] args) {  
13.  ApplicationContext ctx =newAnnotationConfigApplicationContext(  
14.  SpringMongoConfig.class);  
15.  MongoOperations mongoOperation =(MongoOperations) ctx  
16.  .getBean("mongoTemplate");  
17.  //新增一个user对象，并把它放到"ABC"这个collection中   
18.  System.out.println("Case 1...");  
19.  User userA =newUser("1111", "user", "A", 99);  
20.  mongoOperation.save("ABC", userA);  
21.  //查找刚插入的user对象   
22.  User userA1 =mongoOperation.findOne("ABC",  
23.  newQuery(Criteria.where("id").is("1111")), User.class);  
24.  System.out.println(userA1);  
25.  //插入新的user,放到userB这个collection中去   
26.  System.out.println("Case 2...");  
27.  User userB =newUser("2222", "user", "B", 99);  
28.  mongoOperation.save(userB);  
29.  //查找   
30.  User userB1 =mongoOperation.findOne(  
31.  newQuery(Criteria.where("id").is("2222")), User.class);  
32.  System.out.println(userB1);  
33.  //插入对象列表，放到arraylist中   
34.  System.out.println("Case 3...");  
35.  User userC =newUser("3333", "user", "C", 99);  
36.  User userD =newUser("4444", "user", "D", 99);  
37.  User userE =newUser("5555", "user", "E", 99);  
38.  List<User>userList =newArrayList<User>();  
39.  userList.add(userC);  
40.  userList.add(userD);  
41.  userList.add(userE);  
42.  mongoOperation.insertList("ABC-List", userList);  
43.  List<User>users =mongoOperation.find("ABC-List", newQuery(Criteria  
44.  .where("firstname").is("user")), User.class);  
45.  for(User temp : users) {  
46.  System.out.println(temp);  
47.  }  
48.  }  
49.  }  

输出结果如下：

Case 1...
User [id=1111, firstname=user, lastname=A, age=99]
Case 2...
User [id=2222, firstname=user, lastname=B, age=99]
Case 3...
User [id=3333, firstname=user, lastname=C, age=99]
User [id=4444, firstname=user, lastname=D, age=99]
User [id=5555, firstname=user, lastname=E, age=99]

更新Document

在mongodb中，可以使用save,updateFirst(),updateMulti()方法来进行更新，下面

是相关的例子

1. publicclassApp {  
2.  publicstaticvoidmain(String[] args) {  
3.  ApplicationContext ctx =newAnnotationConfigApplicationContext(  
4.  SpringMongoConfig.class);  
5.  MongoOperations mongoOperation =(MongoOperations) ctx  
6.  .getBean("mongoTemplate");  
7.  User user =newUser("1000", "user-first", "user-last", 17);  
8.  System.out.println("Case 1...by save()");  
9.  mongoOperation.save(user);  
10.  User userPrint1 =mongoOperation.findOne(newQuery(Criteria.where("id").is("1000")), User.class);  
11.  System.out.println(userPrint1);  
12.  //修改user对象的lastname   
13.  user.setLastname("new last name");  
14.  //更新user对象   
15.  mongoOperation.save(user);  
16.  User userPrint2 =mongoOperation.findOne(newQuery(Criteria.where("id")  
17.  .is("1000")), User.class);  
18.  System.out.println(userPrint2);  
19.  //Case 2 ... update firstname field, $set   
20.  System.out.println("Case 2...by updateFirst() - $set");  
21.  //将id为1000的user对象的firstname属性的值更新为”new firstname”   
22.  mongoOperation.updateFirst("user",  
23.  newQuery(Criteria.where("_id").is("1000")),  
24.  Update.update("firstname", "new first name"));  
25.  User userPrint3 =mongoOperation.findOne(newQuery(Criteria.where("id")  
26.  .is("1000")), User.class);  
27.  System.out.println(userPrint3);  
28.  //对id为1000的user的age加上10   
29.  System.out.println("Case 3...by updateFirst() - $inc");  
30.  Update updateAge =newUpdate();  
31.  updateAge.inc("age", 10);  
32.  mongoOperation.updateFirst("user",  
33.  newQuery(Criteria.where("_id").is("1000")), updateAge);  
34.  User userPrint4 =mongoOperation.findOne(newQuery(Criteria  
35.  .where("_id").is("1000")), User.class);  
36.  System.out.println(userPrint4);  
37.  }  
38.  }  

结果为：

Case 1...by save()
User [id=1000, firstname=user-first, lastname=user-last, age=17]
User [id=1000, firstname=user-first, lastname=newlast name, age=17]
Case 2...by updateFirst()-$set
User [id=1000, firstname=newfirst name, lastname=newlast name, age=17]
Case 3...by updateFirst()-$inc
User [id=1000, firstname=newfirst name, lastname=newlast name, age=27]

此外，还支持使用updateMulti，updateMulti是将所有的对象进行更新，比如：

mongoOperation.updateMulti("user",
newQuery(Criteria.where("firstname").is("yong")),
Update.update("age",40));

表示将所有firstname为yong的user对象的age属性全部更新为40。

查询Document

在spring mongodb中，可以使用findOne(),find()和getCollection()去查询mongodb，常见的用法如下：

1. User user =newUser("...");  
2.  //找到第一个id=1001的user对象   
3.  User user =mongoOperation.findOne("test", newQuery(Criteria  
4.  .where("id").is("1001")), User.class);  
5.  //从test集合中获得所有id<=1000并且age=21的user对象   
6.  List<User>users =mongoOperation.find("test", newQuery(Criteria  
7.  .where("id").lte("2001").and("age").is(21)), User.class);  
8.  //从test 集合中获得所有的user对象列表   
9.  List<User>users =mongoOperation.getCollection("test", User.class);   

删除document

在spring mongodb中， 删除document使用remove方法，示例如下：

1.  User user =newUser("...");  
2.  //删除user集合中的user对象   
3.  mongoOperation.remove(user);  
4.  //删除test集合下的id=2的user对象    
5. mongoOperation.remove("test", newQuery(Criteria  
6.  .where("id").is("2")));  
7.  //删除test集合下的，id=3的user对象，最后并且返回这个被删除的对象   
8.  User deletedUser =mongoOperation.findAndRemove("test",  
9.  newQuery(Criteria.where("id").is("3")), User.class);