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);  

相关推荐