2. 程式人生 > >spring data 整合mongoDB基礎篇

spring data 整合mongoDB基礎篇

阿新 • • 發佈：2019-01-16

最近幾天一直再看這個mongoDB，按照Master的說法是先看看，後期會用這個做資料庫。所以這幾天完成從未接觸到會用springdata 來操作mongodb資料庫。後面如果在專案完成後或許會有更深的理解，到時會再更新總結。
實際網上的入門的百度一下很多了，但是很多資料已經過時了，在按照原來的做法就行不通，而剩下的大都缺少類，不是很系統全面。這裡才感覺有必要來總結出自己的一套學習流程來，供大家參考。

1.mongodb的個人學習流程。

先去菜鳥教程上先按照說明安裝好服務端和客戶端（這倆在一塊，和tomcat，redis很類似,服務端，客戶端程式都是在bin目錄中），後學習了前面的mongodb的sql語法，除了後面的分片，備份和監控，感覺開發也用不到就沒看，直接跳過看最後的Mongodb java.
然後熟悉完就看spring data 整合mongodb，這部分是邊做邊學的，即按照部落格上的步驟比葫蘆畫瓢完成，當然過程不是很順利，因為資料確實不完整，試了好幾次才搞定。

2.學習參考資料

mongodb的安裝和入門級系統學習：菜鳥教程。下載安裝在下圖的箭頭章節處。

這裡寫圖片描述

解壓下載的壓縮包，就是下面的樣子：
這裡寫圖片描述
執行時有幾個要知道：
1.mongod.exe 是服務端應用。mongo.exe是客戶端應用。
2.一旦執行成功mongod.exe,即使你關了這個命令視窗，並不會退出這個服務，這個服務成了system系統程式，你只要開機，服務就會自動開啟。
如果想用客戶端圖形介面來直觀感受，可以到這裡下載。點選download，我們選擇exe這個安裝就行了。
這裡寫圖片描述

然後是初級進階springdata 整合mongodb，這個可以看我這篇下面的介紹自己執行一遍就可以瞭解個差不多。我們知道spring,spring mvc,springboot，這有來個spring data，這些叫法怎麼來的，有為啥這樣叫？下面我們來說道說道。

3. spring XX 的由來

個人理解：所有的這些spring XX都是spring提供針對不同方向起的，比如spring mvc針對web層。spring則針對後臺業務管理物件，注入等問題的解決。spring data則是針對持久層的spring子專案，目的在於簡化資料庫操作，減少資料訪問層 (DAO) 的開發量。spring cloud針對微服務的。他們並沒有嚴格上的分割線，而主要區別點就是從核心jar包來區分命名或許也是一種可能性。但是持久層由於面對的資料庫的不同，也產生了不同的springdata子專案。通過下面這張圖來了解一下大致分成了多少種。
這裡寫圖片描述
今天我們的mongodb就是非關係型的整合文件資料庫。

4.spring data整合mongodb

這裡我用的是maven工程，引入依賴方便。實驗專案整體結構如下：
這裡寫圖片描述

4.1 引入springdata 整合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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.gaofei</groupId>
    <artifactId>MongoDemo</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>MongoDemo Maven Webapp</name>
    <url>http://maven.apache.org</url>


    <dependencies>
        <!-- spring 整合junit需要的兩個依賴 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.10.RELEASE</version>
            <scope>test</scope>
        </dependency>
        <!-- spring 整合junit需要的兩個依賴 -->
        <!-- mongodb資料庫驅動 -->
        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver</artifactId>
            <version>3.4.3</version>
        </dependency>
        <!-- mongodb資料庫驅動 -->
        <!-- springdata整合mongodb -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-mongodb</artifactId>
            <version>1.10.6.RELEASE</version>
        </dependency>
        <!-- springdata整合mongodb -->
    </dependencies>
    <repositories>
        <repository>
            <id>spring-libs-release</id>
            <name>Spring Releases</name>
            <url>https://repo.spring.io/libs-release</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
    <build>
        <finalName>MongoDemo</finalName>
    </build>
</project>

4.2 配置檔案有兩個，主要是資料來源的配置。

mongodb.xml，這個配置檔案網上的大都老舊了，主要是配置資料來源這塊的<mongo:client-options。。。如果還是<mongo:options就會報錯，錯誤資訊：
Usage of ‘mongo-options’ is no longer supported for MongoDB Java driver version 3 and above. Please use ‘mongo-client-options’ and refer to chapter ‘MongoDB 3.0 Support’ for details
mongodb 3.0開始需要定義mongo:mongo-client，而不是mongo:mongo 

<?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:mongo="http://www.springframework.org/schema/data/mongo"
    xmlns:repository="http://www.springframework.org/schema/data/repository"
    xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                    http://www.springframework.org/schema/context 
                    http://www.springframework.org/schema/context/spring-context-4.3.xsd
                    http://www.springframework.org/schema/data/mongo 
                    http://www.springframework.org/schema/data/mongo/spring-mongo-1.8.xsd
                    http://www.springframework.org/schema/data/repository 
                    http://www.springframework.org/schema/data/repository/spring-repository-1.5.xsd">

    <!-- 載入mongodb的配置屬性檔案 -->
<context:property-placeholder location="classpath:property/mongodb.properties" />
<context:component-scan base-package="com.mongo"/>
<mongo:mongo-client host="${mongo.host}" port="${mongo.port}" id="mongo">
    <mongo:client-options 
        write-concern="${mongo.writeconcern}"
        connect-timeout="${mongo.connectTimeout}" 
        socket-keep-alive="${mongo.socketKeepAlive}" />
</mongo:mongo-client>

<!-- mongo:db-factory dbname="database" mongo-ref="mongo" / -->
<!--這裡的dbname就是自己的資料庫/collection的名字-->
<mongo:db-factory id="mongoDbFactory" dbname="zhanglfDatabase" mongo-ref="mongo" />

<bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
    <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
</bean>

</beans>

mongodb.properties中是資料庫的基本配置資訊

mongo.host=127.0.0.1
mongo.port=27017
mongo.connectionsPerHost=8
mongo.threadsAllowedToBlockForConnectionMultiplier=4
#連線超時時間
mongo.connectTimeout=1000
#等待時間
mongo.maxWaitTime=1500
mongo.autoConnectRetry=true
mongo.socketKeepAlive=true
#socket超時時間
mongo.socketTimeout=1500
mongo.slaveOK=true
mongo.writeconcern=safe

完成以上步驟，框架就搭建完成了。幾乎沒啥可說的。下面是程式碼測試，應用的程式碼。看如何用java來操作mongodb資料庫。

4.3首先是bo實體類，承載著庫-java類的對應關係。

這裡寫圖片描述
上圖的客戶端影象介面很重要，有助於理解實體類是如何儲存在表中的。
1.資料庫的表名為：zhanglfDatabase,與配置檔案中指明的資料庫名要一致。注意，如果資料庫中不存在這個表，則會新建這個zhanglfDatabase庫。
2.Collections儲存著很多個物件等資料型別。並且可以看到每條資料中的_class對應的為工程對應結構目錄錄下的bo名UserBo。這點可以清除明白對映關係是有的，並且存在表名為userBo。注意這裡的表名和類名是對應的，首字母表名為小寫。並且這個表是java程式碼執行插入時生成的。所以注意這個對映規則，不只是表名對應類名，裡面的表字段和類屬性也要一致，資料型別也要一直（這個還沒考證）。這樣才能對映成功。

UserBo.java

package com.mongo.bo;

import java.io.Serializable;

public class UserBo implements Serializable{

    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    private String address;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

}

page.java 這個類是用來分頁使用的實體類。

package com.mongo.bo;

import java.io.Serializable;
import java.util.List;

public class Page<T> implements Serializable {
    private static final long serialVersionUID = 5760097915453738435L;
    public static final int DEFAULT_PAGE_SIZE = 10;
    /**
     * 每頁顯示個數
     */
    private int pageSize;
    /**
     * 當前頁數
     */
    private int currentPage;
    /**
     * 總頁數
     */
    private int totalPage;
    /**
     * 總記錄數
     */
    private int totalCount;
    /**
     * 結果列表
     */
    private List<T> rows;

    public Page() {
        this.currentPage = 1;
        this.pageSize = DEFAULT_PAGE_SIZE;
    }

    public Page(int currentPage, int pageSize) {
        this.currentPage = currentPage <= 0 ? 1 : currentPage;
        this.pageSize = pageSize <= 0 ? 1 : pageSize;
    }

    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    public int getCurrentPage() {
        return currentPage;
    }

    public void setCurrentPage(int currentPage) {
        this.currentPage = currentPage;
    }

    public int getTotalPage() {
        return totalPage;
    }

    public void setTotalPage(int totalPage) {
        this.totalPage = totalPage;
    }

    public int getTotalCount() {
        return totalCount;
    }

    public void setTotalCount(int totalCount) {
        this.totalCount = totalCount;
    }

    /**
     * 設定結果 及總頁數
     * 
     * @param list
     */
    public void build(List<T> rows) {
        this.setRows(rows);
        int count = this.getTotalCount();
        int divisor = count / this.getPageSize();
        int remainder = count % this.getPageSize();
        this.setTotalPage(remainder == 0 ? divisor == 0 ? 1 : divisor
                : divisor + 1);
    }

    public List<T> getRows() {
        return rows;
    }

    public void setRows(List<T> rows) {
        this.rows = rows;
    }
}

4.4 dao層介面和實現類。這裡我只是用了最基本的curd操作。更多介面可以百度。

package com.mongo.dao;

import java.util.List;

import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;

import com.mongo.bo.Page;
import com.mongodb.WriteResult;

public interface IMongoDao<T> {
     /**   
     * 根據條件查詢   
     */    
    public List<T> find(Query query);    

    /**   
     * 根據條件查詢一個   
     */    
    public T findOne(Query query);    

    /**   
     * 插入   
     */    
    public void save(T entity); 
    /**   
     * 根據條件 更新   
     */    
    public WriteResult update(Query query, Update update);

    /**   
     * 獲得所有該型別記錄,並且指定了集合名(表的意思)   
     */    
    public List<T> findAll(String collectionName);

    /**   
     * 根據條件 獲得總數   
     */    
    public long count(Query query);  
    /**   
     * 根據條件 刪除   
     *    
     * @param query   
     */    
    public void remove(Query query); 
    /**   
     * 分頁查詢   
     */    
    public Page<T> findPage(Page<T> page, Query query); 
}

實現類，注意掃描包的配置<context:component-scan base-package="com.mongo"/>和此處的註解。這樣才能注入成功。

package com.mongo.dao.impl;

import java.util.List;

import javax.annotation.Resource;

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 org.springframework.stereotype.Repository;

import com.mongo.bo.Page;
import com.mongo.bo.UserBo;
import com.mongo.dao.IMongoDao;
import com.mongodb.WriteResult;

@Repository
public class MongoDaoImpl implements IMongoDao<UserBo> {

    @Resource
    private MongoTemplate template;

    @Override
    public List<UserBo> find(Query query) {
        List<UserBo> userList = template.find(query, UserBo.class);
        return userList;
    }

    @Override
    public UserBo findOne(Query query) {
        UserBo userBo = template.findOne(query, UserBo.class);
        return userBo;
    }

    @Override
    public void save(UserBo entity) {
        template.save(entity);
    }

    @Override
    public WriteResult update(Query query, Update update) {
         if (update==null) {    
                return null;    
            }   
         WriteResult writeResult = template.updateMulti(query, update, UserBo.class);
        return writeResult;
    }

    @Override
    public List<UserBo> findAll(String collectionName) {
        return template.findAll(UserBo.class, collectionName);
    }

    @Override
    public long count(Query query) {
        long count = template.count(query, "userBo");
        return count;
    }

    @Override
    public void remove(Query query) {
        Query query1 = new Query(Criteria.where("name").is("土豆丁233"));
        WriteResult remove = template.remove(query1, "userBo");
    }

    @Override
    public Page<UserBo> findPage(Page<UserBo> page, Query query) {
         query=query==null?new Query(Criteria.where("_id").exists(true)):query;    
            long count = this.count(query);    
            // 總數    
            page.setTotalCount((int) count);    
            int currentPage = page.getCurrentPage();    
            int pageSize = page.getPageSize();    
            query.skip((currentPage - 1) * pageSize).limit(pageSize);    
            List<UserBo> rows = this.find(query);    
            page.build(rows);    
            return page;    

    }

}

下面是測試類，測試類用springtest實現註解注入。而沒有用初始化@BeforeInit 注入

package com.test;

import java.util.List;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
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.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.mongo.bo.UserBo;
import com.mongo.dao.IMongoDao;
import com.mongodb.WriteResult;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:mongodb/mongoDB.xml")
public class MongoTest {
        @Resource
        private IMongoDao MongoDaoImpl;

        @Test
        public void test1(){
            UserBo ub=new UserBo();
            ub.setAddress("北京市海淀區");
            ub.setAge(26);
            ub.setName("土豆丁");
            MongoDaoImpl.save(ub);
            System.out.println("插入成功！");
        }

        @Test
        public void test2(){
//          Query query = new Query(Criteria.where("name").is("蘿蔔頭"));
            Query query = new Query(Criteria.where("age").lte(26));
            List<UserBo> list = MongoDaoImpl.find(query);
            for (UserBo bu : list) {
                System.out.println(bu.getName()+"的地址："+bu.getAddress());
            }

            UserBo ub = (UserBo) MongoDaoImpl.findOne(query);
            System.out.println(ub.getName());
        }

        @Test
        public void test3(){
            Query query=new Query(Criteria.where("name").is("土豆丁233"));
            Update update=new Update();
            update.set("address", "河南鄭州市");
            WriteResult writeResult = MongoDaoImpl.update(query, update);
            System.out.println(writeResult.isUpdateOfExisting());
        }

        @Test
        public void test4(){
            List<UserBo> findAll = MongoDaoImpl.findAll("userBo");
            for (UserBo userBo : findAll) {
                System.out.println("姓名："+userBo.getName()+",地址："+userBo.getAddress());
            }
        }

        @Test
        public void test5(){
            Query query=new Query();
            long count = MongoDaoImpl.count(query);
            System.out.println("總條數："+count);
        }

        @Test
        public void test6(){
            Query query=new Query(Criteria.where("name").is("蘿蔔頭"));
            MongoDaoImpl.remove(query);
        }

        public void test7(){
//          MongoDaoImpl.findPage(page, query);
        }

}

挨個單元測試就可以了。一般先插入幾條在進行後續的別的操作。

相關推薦

spring data 整合mongoDB基礎篇

最近幾天一直再看這個mongoDB，按照Master的說法是先看看，後期會用這個做資料庫。所以這幾天完成從未接觸到會用springdata 來操作mongodb資料庫。後面如果在專案完成後或許會有更深的理解，到時會再更新總結。 實際網上的入門的百度一

spring data 整合mongodb

maven依賴 <dependency> <groupId>org.springframework.data</groupId> <artifactId>sprin

Spring Data 與MongoDB 整合五:操作篇（分頁）

一．簡介      SpringData  MongoDB提供了org.springframework.data.mongodb.core.MongoTemplate對MongoDB的find的操作，我們上一篇介紹了基本文件的查詢，我們今天介紹分頁查詢，分頁查詢

Spring Data 與MongoDB 整合四:操作篇（查詢）

一．簡介      spring Data  MongoDB提供了org.springframework.data.mongodb.core.MongoTemplate對MongoDB的CRUD的操作，上一篇我們介紹了對MongoDB的新增和刪除， 今天

Spring.NET教程（十八）整合NHibernate(基礎篇)

uil com red port log4net odbc con 其它 get Spring.net對NHibernate提供了很好的支持與封裝。Spring.Data.NHibernate.Generic.Support和Spring.Data.NHibernate.S

spring data整合elasticsearch的applicationContext.xml文件模板

col ext sch host sca pre can -s xsd <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/

MongoDB基礎篇1：安裝和服務配置

AD gap window server load 執行 顯示 mmu 配置環境 一、下載 請前往官網下載community版本MongoDB，我當前可見最新版本是3.6.4 https://www.mongodb.com/download-center#community

spring-boot整合mongodb的案例

  1.簡介 MongoDB 是一個基於分散式檔案儲存的資料庫。由 C++ 語言編寫。旨在為 WEB 應用提供可擴充套件的高效能資料儲存解決方案。 MongoDB 是一個介於關係資料庫和非關係資料庫之間的產品，是非關係資料庫當中功能最豐富，最像關係資料庫的。 2.執行環境

Spring boot整合Mongodb

最近的專案用了Mongodb，網上的用法大多都是七零八落的沒有一個統一性，自己大概整理了下，專案中的相關配置就不敘述了，由於spring boot的快捷開發方式，所以spring boot專案中要使用Mongodb，只需要新增依賴和配置application.properties檔案即可。整和方式一共有兩種，

初步學習MongoDB(基礎篇)

一、基礎篇 建立資料庫database  à  use database 刪除資料庫 database à  db.dropDatabase() 建立集合collection   à db.createCollection(<name>, { capped:

Spring Boot 整合MongoDB

一：新增jar依賴 <!--MongoDB依賴--> <dependency> <groupId>org.springframework.boot</groupId> <a

spring boot整合mongodb使用簡單介紹 spring整合mongo使用簡單介紹 spring整合mongoDB使用簡單介紹

最近在專案中使用到了mongodb，第一次用，各種百度加問大佬，簡單記錄下自己的理解，一是希望能幫助到同樣要學習mongo的同學，另外就是以後可以看一下複習複習。 簡單理解 第一步匯入mongo的依賴 <!--mongodb--> <dependen

spring boot整合mongodb最簡單版

作者:flystarfly 通過spring tools suite新建一個spring project。帶maven的即可 pom.xml檔案配置 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http:/

MongoDB基礎篇：MongoDB Shell命令大全

要想能熟練操作MongoDB，首先先要熟練使用 MongoDB Shell， 再次要熟練使用驅動 mongodb-java-driver, 最後是spring-data-mongodb的使用 MongoDB 簡介： MongoDB採用Bson格式儲存

Spring Boot整合MongoDB實現增刪改查

MongoDB這兩年來是本人一直使用較多的，之前的使用大多通過封裝的工具類對資料庫進行操作，雖然也算穩定，但有了Spring Boot之前的工具類直接加到SpringBoot裡就沒那麼好使了，因此查閱資料後自己小試牛刀寫了個增刪改查，覺得也還不錯，所以分享給大家看看 1 p

使用spring data 對mongodb實現簡單分頁

//對某一書籍下的所有dxh按訪問量排序並分頁 public List<CKDXH> getPartitionDXHCKCountByBookIdandDes(Integer bookId,Integer start,Integer pagesize){

Spring Boot 入門之基礎篇（一）

一、前言 Spring Boot 是由 Pivotal 團隊提供的全新框架，其設計目的是用來簡化新 Spring 應用的初始搭建以及開發過程。該框架使用了特定的方式來進行配置，從而使開發人員不再需要定義樣板化的配置。 本系列以快速入門為主，可當作工具小手冊閱讀

mongoDB基礎篇——NoSQL特性及MongoDB資料查詢

 本文將進一步介紹MongoDB的特點，深入瞭解面向集合操作的資料庫增刪改查。 一、MongoDB特性 結合傳統關係型資料庫，我們從以下四個方面再度深入認識NoSQL資料庫，以MongoDB為

Spring Boot 學習之基礎篇（一）

該系列並非完全原創，官方文件、作者Spring Boot 是由 Pivotal 團隊提供的全新框架，其設計目的是用來簡化新 Spring 應用的初始搭建以及開發過程。該框架使用了特定的方式來進行配置，從而使開發人員不再需要定義樣板化的配置。一、環境搭建建立一個Maven專案，

spring boot整合mongodb在控制檯輸出nosql的日誌

   大家只需要在application.properties的配置檔案下增加以下的配置就可以了：   logging.level.org    logging.level.org .springframework.data.mongodb.core= DEBUG   這樣大