Spring Mongodb入門

安裝Spring for Mongodb

Spring項目爲方便對Mongodb的操做,創建了spring-data的子項目,地址在:java

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

Spring Mongodb的配置mongodb

目前,能夠有兩種方式對Spring mongodb進行配置。第一種是使用Spring 3中的註解,另一種是使用傳統的XML配置。下面分別進行講解:數據庫

使用Spring 3中的註解ide

首先在配置類中,要繼承AbstractMongoConfiguration類,代碼以下:spa

package com.mkyong.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.document.mongodb.MongoTemplate;
import org.springframework.data.document.mongodb.config.AbstractMongoConfiguration;
import com.mongodb.Mongo;
/**
* Spring MongoDB configuration file
*
*/
@Configuration
public class SpringMongoConfig extends AbstractMongoConfiguration {
    @Override
    
public @Bean Mongo mongo() throws Exception {
        
return new Mongo( " localhost " );
    }
    @Override
    
public @Bean MongoTemplate mongoTemplate() throws Exception {
        
return new MongoTemplate(mongo(), " yourdb " , " yourCollection " );
    }
}

這裏,引入了MongoTemplate模版類,而且使用對鏈接數據庫的地址,數據庫名和collection進行了初始化。xml

在調用Spring Mongodb配置時,只須要在須要使用的類中調用AnnotationConfigApplicationContext,傳入剛纔配置好的SpringMongoConfig類便可。以下代碼所示:對象

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

當得到了mongoOperation對象的實例後,便可進行對mongodb的相關操做。繼承

使用XML配置文件ip

使用XML配置文件的方法以下:

<? xml version="1.0" encoding="UTF-8" ?>
< beans xmlns ="http://www.springframework.org/schema/beans"
    xmlns:xsi
="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context
="http://www.springframework.org/schema/context"
    xmlns:mongo
="http://www.springframework.org/schema/data/mongo"
    xsi:schemaLocation
="http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/data/mongo
          http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd
          http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
>
    
<!-- Default bean name is 'mongo' -->
    
< mongo:mongo host ="localhost" port ="27017" />
    
< bean id ="mongoTemplate"
                 class
="org.springframework.data.document.mongodb.MongoTemplate" >
        
< constructor-arg ref ="mongo" />
        
< constructor-arg name ="databaseName" value ="yourdb" />
        
< constructor-arg name ="defaultCollectionName" value ="yourCollection" />
    
</ bean >
    
<!-- To translate any MongoExceptions thrown in @Repository annotated classes -->
    
< context:annotation-config />
</ beans >

 

注意這裏引用相關的命名空間xmlns:mongo="http://www.springframework.org/schema/data/mongo"
,而且在名爲mongoTemplate中注入相關的數據庫地址,數據庫名便可,使用方法以下:

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

使用Spring Mongodb實現增刪改查操做

下面經過實例講解如何使用Spring Mongodb實現增刪改查操做,假設咱們如今有一個實

體類user以下:

package com.mkyong.user;
public class User {
private String id;
private String firstname;
private String lastname;
private int age;
// getter and setter methods
}

接下來,咱們看具體的操做代碼,以下,這裏假設要將user類保存到名爲userprofile的數據集中。

package com.mkyong.core;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;
import org.springframework.data.document.mongodb.MongoOperations;
import org.springframework.data.document.mongodb.query.Criteria;
import org.springframework.data.document.mongodb.query.Query;
import org.springframework.data.document.mongodb.query.Update;
import com.mkyong.config.SpringMongoConfig;
import com.mkyong.user.User;
public class App
{
public static void main( String[] args )
{
ApplicationContext ctx
= new AnnotationConfigApplicationContext(SpringMongoConfig. class );
MongoOperations mongoOperation
= (MongoOperations)ctx.getBean( " mongoTemplate " );
User user
= new User( " 1001 " , " yong " , " mook kim " , 30 );
// 保存
mongoOperation.save( " userprofile " ,user);
// 查找
User savedUser = mongoOperation.findOne( " userprofile " ,
new Query(Criteria.where( " id " ).is( " 1001 " )),
User.
class );
System.out.println(
" savedUser : " + savedUser);
// 更新
mongoOperation.updateFirst( " userprofile " ,
new Query(Criteria.where( " firstname " ).is( " yong " )),
Update.update(
" lastname " , " new lastname " ));
User updatedUser
= mongoOperation.findOne( " userprofile " ,
new Query(Criteria.where( " id " ).is( " 1001 " )),
User.
class );
System.out.println(
" updatedUser : " + updatedUser);
// 刪除
mongoOperation.remove( " userprofile " ,
new Query(Criteria.where( " id " ).is( " 1001 " )),
User.
class );
// 顯示當前列表
List < User > listUser =
mongoOperation.getCollection(
" userprofile " , User. class );
System.out.println(
" Number of user = " + listUser.size());
}
}

 

輸出結果以下:

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

Spring mongodb插入數據

下面詳細講解如何使用spring mongodb插入數據。在spring mongodb中,插入數據到

mongodb有以下幾種方法:

User user = new User( " ... " );
// 將user對象保存到"user"這個collection中
mongoOperation.save(user);
// 將user對象保存到"new collection"這個collection中
mongoOperation.save( " new collection " ,user);
// 將user對象保存到"user"這個collection中
mongoOperation.insert(user);
// 將user對象保存到"new collection"這個collection中
mongoOperation.insert(
" new collection " , user);
// 將user的對象列表(List)保存到"user"collection中去
mongoOperation.insertList(userInList);
// 將user的對象列表(List)保存到"new collection"collection中去
mongoOperation.insertList( " new collection " , userInList);

要注意的是,Spring mongodb中,當沒有指定collection時,就會把對象保存到以對象命名的collection中。好比上例中的mongoOperation.insert(user),因爲沒指定collection的名稱,因此會把user對象保存到user這個新創建的collection中。

另外請注意其中的save和insert的區別。它們的區別爲:

1)save意思是,當記錄不存在時插入,或者是當記錄已存在是更新,實際上就是saveorupdate的意思。

2) insert的意思是:當記錄不存在時插入,而若是記錄存在時則忽略,繼續插入。

下面舉例子說明:

package com.mkyong.core;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.data.document.mongodb.MongoOperations;
import org.springframework.data.document.mongodb.query.Criteria;
import org.springframework.data.document.mongodb.query.Query;
import com.mkyong.config.SpringMongoConfig;
import com.mkyong.user.User;
public class App {
public static void main(String[] args) {
ApplicationContext ctx
= new AnnotationConfigApplicationContext(
SpringMongoConfig.
class );
MongoOperations mongoOperation
= (MongoOperations) ctx
.getBean(
" mongoTemplate " );
// 新增一個user對象,並把它放到"ABC"這個collection中
System.out.println( " Case 1... " );
User userA
= new User( " 1111 " , " user " , " A " , 99 );
mongoOperation.save(
" ABC " , userA);
// 查找剛插入的user對象
User userA1 = mongoOperation.findOne( " ABC " ,
new Query(Criteria.where( " id " ).is( " 1111 " )), User. class );
System.out.println(userA1);
// 插入新的user,放到userB這個collection中去
System.out.println( " Case 2... " );
User userB
= new User( " 2222 " , " user " , " B " , 99 );
mongoOperation.save(userB);
// 查找
User userB1 = mongoOperation.findOne(
new Query(Criteria.where( " id " ).is( " 2222 " )), User. class );
System.out.println(userB1);
// 插入對象列表,放到arraylist中
System.out.println( " Case 3... " );
User userC
= new User( " 3333 " , " user " , " C " , 99 );
User userD
= new User( " 4444 " , " user " , " D " , 99 );
User userE
= new User( " 5555 " , " user " , " E " , 99 );
List
< User > userList = new ArrayList < User > ();
userList.add(userC);
userList.add(userD);
userList.add(userE);
mongoOperation.insertList(
" ABC-List " , userList);
List
< User > users = mongoOperation.find( " ABC-List " , new Query(Criteria
.where(
" firstname " ).is( " user " )), User. class );
for (User temp : users) {
System.out.println(temp);
}
}
}

 

輸出結果以下:

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()方法來進行更新,下面

是相關的例子

public class App {
public static void main(String[] args) {
ApplicationContext ctx
= new AnnotationConfigApplicationContext(
SpringMongoConfig.
class );
MongoOperations mongoOperation
= (MongoOperations) ctx
.getBean(
" mongoTemplate " );
User user
= new User( " 1000 " , " user-first " , " user-last " , 17 );
System.out.println(
" Case 1...by save() " );
mongoOperation.save(user);
User userPrint1
= mongoOperation.findOne( new Query(Criteria.where( " id " ).is( " 1000 " )), User. class );
System.out.println(userPrint1);
// 修改user對象的lastname
user.setLastname( " new last name " );
// 更新user對象
mongoOperation.save(user);
User userPrint2
= mongoOperation.findOne( new Query(Criteria.where( " id " )
.is(
" 1000 " )), User. class );
System.out.println(userPrint2);
// Case 2 ... update firstname field, $set
System.out.println( " Case 2...by updateFirst() - $set " );
// 將id爲1000的user對象的firstname屬性的值更新爲」new firstname」
mongoOperation.updateFirst( " user " ,
new Query(Criteria.where( " _id " ).is( " 1000 " )),
Update.update(
" firstname " , " new first name " ));
User userPrint3
= mongoOperation.findOne( new Query(Criteria.where( " id " )
.is(
" 1000 " )), User. class );
System.out.println(userPrint3);
// 對id爲1000的user的age加上10
System.out.println( " Case 3...by updateFirst() - $inc " );
Update updateAge
= new Update();
updateAge.inc(
" age " , 10 );
mongoOperation.updateFirst(
" user " ,
new Query(Criteria.where( " _id " ).is( " 1000 " )), updateAge);
User userPrint4
= mongoOperation.findOne( new Query(Criteria
.where(
" _id " ).is( " 1000 " )), User. class );
System.out.println(userPrint4);
}
}

結果爲:

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

 

此外,還支持使用updateMulti,updateMulti是將全部的對象進行更新,好比:

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

表示將全部firstname爲yong的user對象的age屬性所有更新爲40。

查詢Document

在spring mongodb中,可使用findOne(),find()和getCollection()去查詢mongodb,常見的用法以下:

User user = new User( " ... " );
// 找到第一個id=1001的user對象
User user = mongoOperation.findOne( " test " , new Query(Criteria
.where(
" id " ).is( " 1001 " )), User. class );
// 從test集合中得到全部id<=1000而且age=21的user對象
List < User > users = mongoOperation.find( " test " , new Query(Criteria
.where(
" id " ).lte( " 2001 " ).and( " age " ).is( 21 )), User. class );
// 從test 集合中得到全部的user對象列表
List < User > users = mongoOperation.getCollection( " test " , User. class );

刪除document

在spring mongodb中, 刪除document使用remove方法,示例以下:

在spring mongodb中, 刪除document使用remove方法,示例以下:
User user
= new User( " ... " );
// 刪除user集合中的user對象
mongoOperation.remove(user);
// 刪除test集合下的id=2的user對象
mongoOperation.remove( " test " , new Query(Criteria
.where(
" id " ).is( " 2 " )));
// 刪除test集合下的,id=3的user對象,最後而且返回這個被刪除的對象
User deletedUser = mongoOperation.findAndRemove( " test " ,
new Query(Criteria.where( " id " ).is( " 3 " )), User. class );
相關文章
相關標籤/搜索