MongoDB与Spring、Maven整合

最近在研究mongoDB的在项目中使用的优缺点，也一直在思考，作为nosql的经典之作的mongoDB ，能不能在一个项目中完全取代成熟优秀的关系数据库的杰出代表mysql,作为数据存储的介质；或者，需要将两者结合起来使用，才能发挥他们最大的威力。

Spring与各种关系数据库的ORM框架（如Hibernate/MyBatis）的整合方案非常成熟，也是我们在项目开发中最为常用的方式。本文介绍的是在Spring中如何使用spring-data-mongodb来简化mongoDB数据库的访问工作。

新建maven项目，并引入spring-data-mongodb的依赖包，这里我把我项目pom.xml文件列出来。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion>
<groupId>com.laizs</groupId>
<artifactId>dubbo-project</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
<name>dubbo-project</name>
<modules>
<module>dubbo-project-model</module>
<module>dubbo-project-core</module>
<module>dubbo-project-rpc</module>
<module>dubbo-project-web</module>
</modules>
<properties>
<org.springframework-version>3.2.4.RELEASE</org.springframework-version>
<org.springframework.sercurity-version>3.1.4.RELEASE</org.springframework.sercurity-version>
<org.hibernate-version>3.6.10.Final</org.hibernate-version>
<org.aspectj-version>1.6.10</org.aspectj-version>
<org.slf4j-version>1.6.6</org.slf4j-version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<hibernate.connection.url>jdbc:mysql://localhost:3306/activity68</hibernate.connection.url>
<hibernate.connection.username>sample</hibernate.connection.username>
<hibernate.connection.password>sample</hibernate.connection.password>
<redis.ip>localhost</redis.ip>
<redis.port>6379</redis.port>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>

<!-- spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${org.springframework-version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework-version}</version>
<exclusions>
<!-- Exclude Commons Logging in favor of SLF4j -->
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- spring security -->
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-core</artifactId>
<version>${org.springframework.sercurity-version}</version>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-web</artifactId>
<version>${org.springframework.sercurity-version}</version>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-config</artifactId>
<version>${org.springframework.sercurity-version}</version>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-taglibs</artifactId>
<version>${org.springframework.sercurity-version}</version>
</dependency>
<!-- spring END -->
<!-- database access -->
<!-- hibernate -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${org.hibernate-version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.22</version>
</dependency>
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.17.1-GA</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-c3p0</artifactId>
<version>${org.hibernate-version}</version>
</dependency>
<!-- c3po -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>0.2.22</version>
</dependency>
<!-- database access end -->
<!-- commons -->
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.4</version>
</dependency>
<!-- javax -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
<version>1.4.2</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${org.slf4j-version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.16</version>
<scope>runtime</scope>
</dependency>
<!-- jackson -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.1.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.1.1</version>
</dependency>
<dependency>
<groupId>org.ow2.asm</groupId>
<version>4.0</version>
<artifactId>asm</artifactId>
</dependency>
<!-- freemarker -->
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
<version>2.3.16</version>
</dependency>
<dependency>
<groupId>org.ow2.asm</groupId>
<version>4.0</version>
<artifactId>asm</artifactId>
</dependency>
<!-- freemarker end -->
<!-- redis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.0.0</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.0.5.RELEASE</version>
</dependency>
<!-- redis end -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>dubbo</artifactId>
<version>2.5.3</version>
<exclusions>
<!-- 排除依赖的spring2.5.6 -->
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.4.6</version>
</dependency>
<dependency>
<groupId>com.github.sgroschupf</groupId>
<artifactId>zkclient</artifactId>
<version>0.1</version>
</dependency>

<!-- gson -->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.2.2</version>
</dependency>
<!-- gson end -->
<!-- 使用JSR303的验证 -->
<dependency>
<groupId>javax.validation</groupId>
<artifactId>validation-api</artifactId>
<version>1.1.0.Final</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>4.1.0.Final</version>
</dependency>
<!-- upload 专用 -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3</version>
</dependency>
<!-- mongoDB jar -->
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>2.12.4</version>
</dependency>
<!-- spring-data-mongodb -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-mongodb</artifactId>
<version>1.5.4.RELEASE</version>
</dependency>
</dependencies>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>

mangoDB的配置信息的配置文件mongodb.properties

#mongodb配置
mongo.hostport=192.168.244.100:27017
#每个主机答应的连接数（每个主机的连接池大小），当连接池被用光时，会被阻塞住 ，默以为10
mongo.connectionsPerHost=8
#当前所有的connection都在使用中，则每个connection上可以有N个线程排队等待
mongo.threadsAllowedToBlockForConnectionMultiplier=4
#在建立（打开）套接字连接时的超时时间（ms），默以为0
mongo.connectTimeout=1000
#被阻塞线程从连接池获取连接的最长等待时间（ms）
mongo.maxWaitTime=1500
#发生连接错误时是否重试 ，默以为false
mongo.autoConnectRetry=true
#是否维持socket的保活状态
mongo.socketKeepAlive=true
#套接字超时时间;该值会被传递给Socket.setSoTimeout(int)。默以为0(无穷)
mongo.socketTimeout=1500
#指明是否答应驱动从次要节点或者奴隶节点读取数据，默以为false
mongo.slaveOk=true

Spring的配置文件，整合spring-data-mongodb的配置

<?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.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.xsd"> <!-- 定义mongo对象，对应的是mongodb官方jar包中的Mongo，replica-set设置集群副本的ip地址和端口 -->
<mongo:mongo id="mongo" replica-set="${mongo.hostport}">
<!-- 一些连接属性的设置 -->
<mongo:options
connections-per-host="${mongo.connectionsPerHost}"
threads-allowed-to-block-for-connection-multiplier="${mongo.threadsAllowedToBlockForConnectionMultiplier}"
connect-timeout="${mongo.connectTimeout}"
max-wait-time="${mongo.maxWaitTime}"
auto-connect-retry="${mongo.autoConnectRetry}"
socket-keep-alive="${mongo.socketKeepAlive}"
socket-timeout="${mongo.socketTimeout}"
slave-ok="${mongo.slaveOk}"
write-number="1"
write-timeout="0"
write-fsync="true"/>
</mongo:mongo>
<mongo:db-factory dbname="database" mongo-ref="mongo" />
<!-- MongoTemplate -->
<bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
<constructor-arg ref="mongo" />
<constructor-arg name="databaseName" value="mydb" /><!-- 数据库的名称 -->
</bean>

</beans>

接下来，是我们的model类Member.java，对应的是mongoDB的集合是member；与关系数据库极大的差别是，我们无需预先创建数据库的表结构；对MongoDB的正删改查操作，会自动生成相应的集合，相应的集合名词是我们的model类的小写名字。

package com.laizs.project.po.mongodb;

import java.io.Serializable;
/**
* 会员信息
* @author laizs
* @time 2016年4月8日上午11:09:19
* @file Member.java
*/
public class Member implements Serializable{
private String id;
private String username;
private String password;
private String sex;
private String email;

public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "Member [id=" + id + ", username=" + username + ", password=" + password + ", sex=" + sex + ", email="
+ email + "]";
}

}

接下来是使用MongoTemplate访问数据库的基类MongoGenDao.java

package com.laizs.project.dao.mongodb;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;

import com.laizs.project.po.mongodb.Member;

/**
* mongodb数据库访问共有类
* @author laizs
* @time 2016年4月5日下午2:19:15
* @file MongoGenDao.java
*/
public abstract class MongoGenDao<T>{
private final static Logger logger=LoggerFactory.getLogger(MongoGenDao.class);
@Autowired
protected MongoTemplate mongoTemplate;
/**
* 为属性自动注入bean服务
* @param mongoTemplate
*/
public void setMongoTemplate(MongoTemplate mongoTemplate) {
this.mongoTemplate = mongoTemplate;
}
/**
* 保存一个对象
* @param t
*/
public void save(T t){
this.mongoTemplate.save(t);
logger.info("[mongo dao] save:"+t);
}
/**
* 根据id获取
* @param id
* @return
*/
public T queryById(String id){
Query query=new Query();
Criteria criteria=Criteria.where("_id").is(id);
query.addCriteria(criteria);
logger.info("[mongo dao] queryById:"+query);
return (T) this.mongoTemplate.findOne(query, getEntityClass());
}
/**
* 根据条件查询集合
* @param query
* @return
*/
public List<T> queryList(Query query){
logger.info("[mongo dao] queryList:"+query);
return this.mongoTemplate.find(query, getEntityClass());
}
/**
* 根据条件查询单个实体
* @param query
* @return
*/
public T queryOne(Query query){
logger.info("[mongo dao] queryOne:"+query);
return (T) this.mongoTemplate.findOne(query, getEntityClass());
}
/**
* 根据分页条件查询
* @param query
* @param start 查询起始值
* @param size 分页大小
* @return
*/
public List<T> getPage(Query query,int start,int size,Sort sort){
query.skip(start);
query.limit(size);
if(null!=sort){
query.with(sort);
}
logger.info("[Mongo Dao]queryPage:" + query + "(" + start +"," + size +")");
return this.mongoTemplate.find(query, getEntityClass());
}
/**
* 根据条件查询库中符合记录的总数,为分页查询服务
* @param query
* @return
*/
public Long getPageCount(Query query){
logger.info("[Mongo Dao]getPageCount:" + query );
return this.mongoTemplate.count(query, getEntityClass());
}
/**
* 根据id删除
* @param id
*/
public void deleteById(String id){
Criteria criteria=Criteria.where("_id").in(id);
if(null!=criteria){
Query query=new Query();
query.addCriteria(criteria);
logger.info("[Mongo Dao] deleteById:" + query );
if(null!=query && this.queryOne(query)!=null){
this.mongoTemplate.remove(query, getEntityClass());
}
}
}
/**
* 删除对象
* @param t
*/
public void delete(T t){
logger.info("[Mongo Dao] t:" + t );
this.mongoTemplate.remove(t);
}
/**
* 更新满足条件的第一个记录
* @param query
* @param update
*/
public void updateFirst(Query query,Update update){
logger.info("[Mongo Dao ]updateFirst:query(" + query + "),update(" + update + ")");
this.mongoTemplate.updateFirst(query, update, getEntityClass());
}
/**
* 修改满足条件的多条记录
* @param query
* @param update
*/
public void updateMulti(Query query,Update update){
logger.info("[Mongo Dao ]updateMulti:query(" + query + "),update(" + update + ")");
this.mongoTemplate.updateMulti(query, update, getEntityClass());
}
/**
* 修改,如果要修改的对象不存在则添加
* @param query
* @param update
*/
public void updateInser(Query query,Update update){
logger.info("[Mongo Dao ]updateInser:query(" + query + "),update(" + update + ")");
this.mongoTemplate.upsert(query, update, this.getEntityClass());
}
/**
* 钩子方法,由子类实现返回反射对象的类型
* @return
*/
protected  abstract Class getEntityClass();
}

会员信息访问的数据库类MemberDao，继承了公共基类MongoGenDao，并暴露了一些分页查询的方法

package com.laizs.project.dao.mongodb;

import java.util.List;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Repository;
import com.laizs.project.po.mongodb.Member;
/**
* 会员dao
* @author laizs
* @time 2016年4月5日下午3:02:08
* @file MemberDao.java
*/
@Repository
public class MemberDao extends MongoGenDao<Member> {
@Override
protected Class getEntityClass() {
return Member.class;
}
/**
* 分页查询
* @param member 查询条件
* @param page 第几页数据
* @param pageSize 每页数据的大小
* @return
*/
public List<Member> queryPage(Member member,int page,int pageSize,Sort sort){
Query query=new Query();
//此处可以增加分页查询条件Criteria.然后query.addCriteria(criteria);
if(null!=member){
if(StringUtils.isNotBlank(member.getId())){
query.addCriteria(Criteria.where("_id").is(member.getId()));
}
if(StringUtils.isNotBlank(member.getUsername())){
query.addCriteria(Criteria.where("username").is(member.getUsername()));
}
if(StringUtils.isNotBlank(member.getPassword())){
query.addCriteria(Criteria.where("password").is(member.getPassword()));
}
if(StringUtils.isNotBlank(member.getSex())){
query.addCriteria(Criteria.where("sex").is(member.getSex()));
}
if(StringUtils.isNotBlank(member.getEmail())){
query.addCriteria(Criteria.where("email").is(member.getEmail()));
}
}
if(null!=sort){
query.with(sort);
}
return getPage(query, (page-1)*pageSize, pageSize,sort);
}
/**
* 查询满足分页的记录总数
* @param member 查询的条件
* @return
*/
public Long queryPageCount(Member member){
Query query=new Query();
//此处可以增加分页查询条件Criteria.然后query.addCriteria(criteria);
return getPageCount(query);
}
/**
* 根据用户名
* @param usernameLike
* @param page
* @param pageSize
* @param sort
* @return
*/
public List<Member> queryPage(String usernameLike,int page,int pageSize,Sort sort){
Query query=new Query();
//此处可以增加分页查询条件Criteria.然后query.addCriteria(criteria);
if(StringUtils.isNotBlank(usernameLike)){
Pattern pattern = Pattern.compile("^.*"+usernameLike+".*$", Pattern.CASE_INSENSITIVE);//模糊匹配
//Pattern pattern = Pattern.compile("^"+usernameLike+".*$", Pattern.CASE_INSENSITIVE);//左匹配
//Pattern pattern = Pattern.compile("^.*"+usernameLike+"$", Pattern.CASE_INSENSITIVE);//右匹配
query.addCriteria(Criteria.where("username").regex(pattern));
}
if(null!=sort){
query.with(sort);
}
return getPage(query, (page-1)*pageSize, pageSize,sort);
}
/**
* 更新数据，更新满足条件的第一天记录
* @param member
*/
public void updateFirst(Member member){
Update update=new Update();
if(StringUtils.isBlank(member.getId())){
throw new RuntimeException("Update data Id is null ");
}
if(StringUtils.isNotBlank(member.getUsername())){
update.set("username", member.getUsername());
}
if(StringUtils.isNotBlank(member.getPassword())){
update.set("password", member.getPassword());
}
if(StringUtils.isNotBlank(member.getSex())){
update.set("sex", member.getSex());
}
if(StringUtils.isNotBlank(member.getEmail())){
update.set("email", member.getEmail());
}
updateFirst(Query.query(Criteria.where("_id").is(member.getId())), update);
}
/**
* 更新数据，更新满足条件的多条记录
* @param member
*/
public void updateMulti(Member member){
Update update=new Update();
if(StringUtils.isBlank(member.getId())){
throw new RuntimeException("Update data Id is null ");
}
if(StringUtils.isNotBlank(member.getUsername())){
update.set("username", member.getUsername());
}
if(StringUtils.isNotBlank(member.getPassword())){
update.set("password", member.getPassword());
}
if(StringUtils.isNotBlank(member.getSex())){
update.set("sex", member.getSex());
}
if(StringUtils.isNotBlank(member.getEmail())){
update.set("email", member.getEmail());
}
updateMulti(Query.query(Criteria.where("_id").is(member.getId())), update);
}
}

接下来，是Juint的测试类了

package com.laizs.project.dao.mongodb.test;

import static org.junit.Assert.*;

import java.util.List;
import java.util.Random;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.laizs.project.dao.mongodb.MemberDao;
import com.laizs.project.po.mongodb.Member;

/**
* MemberDao测试类
* @author laizs
* @time 2016年4月6日下午2:21:03
* @file MemberDaoTest.java
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath*:root-context.xml"})
public class MemberDaoTest {
@Autowired
private ApplicationContext ctx;
@Autowired
private MemberDao memberDao;
/**
* 测试保存
*/
@Test
public void saveTest(){
for(int i=0;i<100;i++){
Member member=new Member();
int j=new Random().nextInt(100);
member.setUsername("test"+j);
member.setSex(j%2==0?"男":"女");
j=new Random().nextInt(100);
member.setPassword(j+"");
member.setEmail(j+"@"+"qq.com");
memberDao.save(member);
System.out.println("member 保存成功："+member);
}

}
@Test
public void deleteTest(){
Member m=memberDao.queryById("1");
if(null!=m){
memberDao.delete(m);
System.out.println("删除member："+m);
}
}
@Test
public void updateFirstTest(){
Member m=memberDao.queryById("5704b88609a825017e751075");
if(null!=m){
m.setUsername("test");
this.memberDao.updateFirst(m);
}
}

@Test
public void queryPageCountTest(){
long l=memberDao.queryPageCount(null);
System.out.println("member 总数："+l);
}
@Test
public void queryPageTest(){
Member member=new Member();
//member.setId("5704b88609a825017e751073");
//member.setEmail("333");
//member.setUsername("赖兆世");
Sort sort=new Sort(Direction.DESC, "username");
List<Member> mList=this.memberDao.queryPage(member, 1, 20,sort);
System.out.println("############:"+mList.size());
for(Member m:mList){
System.out.println("member:"+m);
}
//assertEquals("6",mList.size()+"");
}
@Test
public void queryPageTest1(){
List<Member> mList =this.memberDao.queryPage("2", 1, 100, null);
System.out.println("############:"+mList.size());
for(Member m:mList){
System.out.println("member:"+m);
}
}
}

思考与总结：总体来说，使用Spring提供spring-data-mongodb来访问mongoDB确实十分地方便敏捷，基本能满足大部分项目的功能需求；但如果需要满足更灵活复杂的访问mongoDB的方式，恐怕还得回归到MongoDB原生的java驱动的访问方式。另一方面，使用spring-data-mongodb配置MongoTemplate实例时，只能指定一个DB，这极大的限制了MongoDB灵活及易扩展的特性之一：不同的数据集合能灵活的存储在不用的DB上。使用spring-data-mongodb访问mongoDB，让我们又回到了类似于访问关系型数据库的面向对象的思维方式；这种思维方式是否也禁锢了nosql的一些特性也不得而知，因为mongoDB本身就是利用灵活强大的json数据与数据库交互来实现数据结构的灵活性和高效性。MongoDB在众多nosql的数据库中脱颖而出，能在互联网的大潮中蓬勃发展，必然有它的众多有点，值得我们深入的学习。