MongoDB与Spring、Maven整合

最新推荐文章于 2023-07-18 09:22:25 发布

暗里着迷86

最新推荐文章于 2023-07-18 09:22:25 发布

阅读量4k

点赞数

分类专栏： mangoDB 文章标签： spring mongodb 数据库 nosql mysql

本文链接：https://blog.csdn.net/u011486068/article/details/51095254

版权

mangoDB 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

最近在研究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的数据库中脱颖而出，能在互联网的大潮中蓬勃发展，必然有它的众多有点，值得我们深入的学习。

暗里着迷86

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
1
评论
MongoDB与Spring、Maven整合

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

扫一扫