1.開發(fā)環(huán)境

IDEA、Maven、SpringBoot2.0.4、Jdk1.8、MongoDB4.0、MongoDB Compass Community、PostMan

2.MongoDB

MongoDB（來自于英文單詞“Humongous”，中文含義為“龐大”）是可以應(yīng)用于各種規(guī)模的企業(yè)、各個(gè)行業(yè)以及各類應(yīng)用程序的開源數(shù)據(jù)庫?；诜植际轿募鎯?chǔ)的數(shù)據(jù)庫。由C++語言編寫。旨在為WEB應(yīng)用提供可擴(kuò)展的高性能數(shù)據(jù)存儲(chǔ)解決方案。MongoDB是一個(gè)高性能，開源，無模式的文檔型數(shù)據(jù)庫，是當(dāng)前NoSql數(shù)據(jù)庫中比較熱門的一種。

MongoDB是一個(gè)介于關(guān)系數(shù)據(jù)庫和非關(guān)系數(shù)據(jù)庫之間的產(chǎn)品，是非關(guān)系數(shù)據(jù)庫當(dāng)中功能最豐富，最像關(guān)系數(shù)據(jù)庫的。他支持的數(shù)據(jù)結(jié)構(gòu)非常松散，是類似json的bjson格式，因此可以存儲(chǔ)比較復(fù)雜的數(shù)據(jù)類型。Mongo最大的特點(diǎn)是他支持的查詢語言非常強(qiáng)大，其語法有點(diǎn)類似于面向?qū)ο蟮牟樵冋Z言，幾乎可以實(shí)現(xiàn)類似關(guān)系數(shù)據(jù)庫單表查詢的絕大部分功能，而且還支持對(duì)數(shù)據(jù)建立索引。

傳統(tǒng)的關(guān)系數(shù)據(jù)庫一般由數(shù)據(jù)庫（database）、表（table）、記錄（record）三個(gè)層次概念組成，MongoDB是由數(shù)據(jù)庫（database）、集合（collection）、文檔對(duì)象（document）三個(gè)層次組成。MongoDB對(duì)于關(guān)系型數(shù)據(jù)庫里的表，但是集合中沒有列、行和關(guān)系概念，這體現(xiàn)了模式自由的特點(diǎn)。

3.配置開始

3.1 Maven 相關(guān)配置

在pox.xml文件中添加spring-boot-starter-data-mongodb引用

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

3.2 資源文件yml配置

筆者這里使用yml配置方式，配置時(shí)要注意縮進(jìn)！?。。?/p>

server:
  port: 8031

spring:
  application:
    name: spirng-boot-mongodb
  data:
    mongodb:
      host: localhost   #同127.0.0.1
      port: 27017
      database: test    #指定操作的數(shù)據(jù)庫

3.3 創(chuàng)建實(shí)體類

import org.springframework.data.annotation.Id;
import java.util.Date;

/**
 * @author: huangyibo
 * @Date: 2019/1/30 23:33
 * @Description:圖書實(shí)體類
 */
public class Book {
    @Id
    private String id;
    //價(jià)格
    private Integer price;
    //書名
    private String name;
    //簡介
    private String info;
    //出版社
    private String publish;
    //創(chuàng)建時(shí)間
    private Date createTime;
    //修改時(shí)間
    private Date updateTime;

    //Getter、Setter省略....

3.4 創(chuàng)建service類

Service中主要來實(shí)現(xiàn)CURD的操作
此處需要說明的是Mongodb的修改操作大致有3種：

mongoTemplate.updateFirst操作：修改第一條
mongoTemplate.updateMulti操作：修改符合條件的所有
this.mongoTemplate.upsert操作：修改時(shí)如果不存在則添加.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
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.Service;

import java.util.Date;
import java.util.List;

/**
 * @author: huangyibo
 * @Date: 2019/1/30 23:33
 * @Description: mongo
 */

@Service
public class MongoDbService {
    private static final Logger logger = LoggerFactory.getLogger(MongoDbService.class);

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 保存對(duì)象
     *
     * @param book
     * @return
     */
    public String saveObj(Book book) {
        logger.info("--------------------->[MongoDB save start]");
        book.setCreateTime(new Date());
        book.setUpdateTime(new Date());
        mongoTemplate.save(book);
        return "添加成功";
    }


    /**
     * 查詢所有
     *
     * @return
     */
    public List<Book> findAll() {
        logger.info("--------------------->[MongoDB find start]");
        return mongoTemplate.findAll(Book.class);
    }


    /***
     * 根據(jù)id查詢
     * @param id
     * @return
     */
    public Book getBookById(String id) {
        logger.info("--------------------->[MongoDB find start]");
        Query query = new Query(Criteria.where("_id").is(id));
        return mongoTemplate.findOne(query, Book.class);
    }

    /**
     * 根據(jù)名稱查詢
     *
     * @param name
     * @return
     */
    public Book getBookByName(String name) {
        logger.info("--------------------->[MongoDB find start]");
        Query query = new Query(Criteria.where("name").is(name));
        return mongoTemplate.findOne(query, Book.class);
    }

    /**
     * 更新對(duì)象
     *
     * @param book
     * @return
     */
    public String updateBook(Book book) {
        logger.info("--------------------->[MongoDB update start]");
        Query query = new Query(Criteria.where("_id").is(book.getId()));
        Update update = new Update().set("publish", book.getPublish())
                .set("info", book.getInfo())
                .set("updateTime", new Date());
        //updateFirst 更新查詢返回結(jié)果集的第一條
        mongoTemplate.updateFirst(query, update, Book.class);
        //updateMulti 更新查詢返回結(jié)果集的全部
//        mongoTemplate.updateMulti(query,update,Book.class);
        //upsert 更新對(duì)象不存在則去添加
//        mongoTemplate.upsert(query,update,Book.class);
        return "success";
    }

    /***
     * 刪除對(duì)象
     * @param book
     * @return
     */
    public String deleteBook(Book book) {
        logger.info("--------------------->[MongoDB delete start]");
        mongoTemplate.remove(book);
        return "success";
    }

    /**
     * 根據(jù)id刪除
     *
     * @param id
     * @return
     */
    public String deleteBookById(String id) {
        logger.info("--------------------->[MongoDB delete start]");
        //findOne
        Book book = getBookById(id);
        //delete
        deleteBook(book);
        return "success";
    }
}

3.5 controller

import com.example.mqdemo.mongo.Book;
import com.example.mqdemo.mongo.MongoDbService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;


/**
 * @author: huangyibo
 * @Date: 2019/1/30 23:31
 * @Description:
 */
@RestController
public class BaseController {

    @Autowired
    private MongoDbService mongoDbService;

    @PostMapping("/mongo/save")
    public String saveObj(@RequestBody Book book) {return mongoDbService.saveObj(book);}

    @GetMapping("/mongo/findAll")
    public List<Book> findAll() {return mongoDbService.findAll();}

    @GetMapping("/mongo/findOne")
    public Book findOne(@RequestParam String id) {return mongoDbService.getBookById(id);}

    @GetMapping("/mongo/findOneByName")
    public Book findOneByName(@RequestParam String name) {return mongoDbService.getBookByName(name);}

    @PostMapping("/mongo/update")
    public String update(@RequestBody Book book) {return mongoDbService.updateBook(book);}

    @PostMapping("/mongo/delOne")
    public String delOne(@RequestBody Book book) {return mongoDbService.deleteBook(book);}

    @GetMapping("/mongo/delById")
    public String delById(@RequestParam String id) {return mongoDbService.deleteBookById(id);}
}

3.6.運(yùn)行測(cè)試

啟動(dòng)項(xiàng)目，打開postman開始接口調(diào)試，可以看到成功添加book對(duì)象。返回添加成功。

image.png

打開MongoDB Compass Community，連接本地MongoDB，可以看到剛才添加的信息。

image.png

其他接口這里就不一一測(cè)試了。

優(yōu)化使用
完成以上配置，我們springBoot集成MongoDB環(huán)境基本已經(jīng)搭建好了。

但是在使用中會(huì)發(fā)現(xiàn)一個(gè)問題，假如要對(duì)數(shù)據(jù)庫操作多個(gè)對(duì)象，那豈不是每一個(gè)對(duì)象Service都需要寫一套增刪查改的方法。

為了解決這一問題我們可以封裝一個(gè)通用的操作類來提高效率。

創(chuàng)建MongoDbDao類如下：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
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 java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;

/**
 * @author: huangyibo
 * @Date: 2019/1/31 0:08
 * @Description: mongoDB基礎(chǔ)方法封裝
 */
public abstract class MongoDbDao<T> {

    protected Logger logger = LoggerFactory.getLogger(MongoDbDao.class);

    /**
     * 反射獲取泛型類型
     *
     * @return
     */
    protected abstract Class<T> getEntityClass();

    @Autowired
    private MongoTemplate mongoTemplate;

    /***
     * 保存一個(gè)對(duì)象
     * @param t
     */
    public void save(T t) {
        logger.info("-------------->MongoDB save start");
        this.mongoTemplate.save(t);
    }

    /***
     * 根據(jù)id從幾何中查詢對(duì)象
     * @param id
     * @return
     */
    public T queryById(Integer id) {
        Query query = new Query(Criteria.where("_id").is(id));
        logger.info("-------------->MongoDB find start");
        return this.mongoTemplate.findOne(query, this.getEntityClass());
    }

    /**
     * 根據(jù)條件查詢集合
     *
     * @param object
     * @return
     */
    public List<T> queryList(T object) {
        Query query = getQueryByObject(object);
        logger.info("-------------->MongoDB find start");
        return mongoTemplate.find(query, this.getEntityClass());
    }

    /**
     * 根據(jù)條件查詢只返回一個(gè)文檔
     *
     * @param object
     * @return
     */
    public T queryOne(T object) {
        Query query = getQueryByObject(object);
        logger.info("-------------->MongoDB find start");
        return mongoTemplate.findOne(query, this.getEntityClass());
    }

    /***
     * 根據(jù)條件分頁查詢
     * @param object
     * @param start 查詢起始值
     * @param size  查詢大小
     * @return
     */
    public List<T> getPage(T object, int start, int size) {
        Query query = getQueryByObject(object);
        query.skip(start);
        query.limit(size);
        logger.info("-------------->MongoDB queryPage start");
        return this.mongoTemplate.find(query, this.getEntityClass());
    }

    /***
     * 根據(jù)條件查詢庫中符合條件的記錄數(shù)量
     * @param object
     * @return
     */
    public Long getCount(T object) {
        Query query = getQueryByObject(object);
        logger.info("-------------->MongoDB Count start");
        return this.mongoTemplate.count(query, this.getEntityClass());
    }

    /***
     * 刪除對(duì)象
     * @param t
     * @return
     */
    public int delete(T t) {
        logger.info("-------------->MongoDB delete start");
        return (int) this.mongoTemplate.remove(t).getDeletedCount();
    }

    /**
     * 根據(jù)id刪除
     *
     * @param id
     */
    public void deleteById(Integer id) {
        Criteria criteria = Criteria.where("_id").is(id);
        if (null != criteria) {
            Query query = new Query(criteria);
            T obj = this.mongoTemplate.findOne(query, this.getEntityClass());
            logger.info("-------------->MongoDB deleteById start");
            if (obj != null) {
                this.delete(obj);
            }
        }
    }

    /*MongoDB中更新操作分為三種
    * 1：updateFirst     修改第一條
    * 2：updateMulti     修改所有匹配的記錄
    * 3：upsert  修改時(shí)如果不存在則進(jìn)行添加操作
    * */

    /**
     * 修改匹配到的第一條記錄
     * @param srcObj
     * @param targetObj
     */
    public void updateFirst(T srcObj, T targetObj){
        Query query = getQueryByObject(srcObj);
        Update update = getUpdateByObject(targetObj);
        logger.info("-------------->MongoDB updateFirst start");
        this.mongoTemplate.updateFirst(query,update,this.getEntityClass());
    }

    /***
     * 修改匹配到的所有記錄
     * @param srcObj
     * @param targetObj
     */
    public void updateMulti(T srcObj, T targetObj){
        Query query = getQueryByObject(srcObj);
        Update update = getUpdateByObject(targetObj);
        logger.info("-------------->MongoDB updateFirst start");
        this.mongoTemplate.updateMulti(query,update,this.getEntityClass());
    }

    /***
     * 修改匹配到的記錄，若不存在該記錄則進(jìn)行添加
     * @param srcObj
     * @param targetObj
     */
    public void updateInsert(T srcObj, T targetObj){
        Query query = getQueryByObject(srcObj);
        Update update = getUpdateByObject(targetObj);
        logger.info("-------------->MongoDB updateInsert start");
        this.mongoTemplate.upsert(query,update,this.getEntityClass());
    }

    /**
     * 將查詢條件對(duì)象轉(zhuǎn)換為query
     *
     * @param object
     * @return
     * @author Jason
     */
    private Query getQueryByObject(T object) {
        Query query = new Query();
        String[] fileds = getFiledName(object);
        Criteria criteria = new Criteria();
        for (int i = 0; i < fileds.length; i++) {
            String filedName = (String) fileds[i];
            Object filedValue = getFieldValueByName(filedName, object);
            if (filedValue != null) {
                criteria.and(filedName).is(filedValue);
            }
        }
        query.addCriteria(criteria);
        return query;
    }

    /**
     * 將查詢條件對(duì)象轉(zhuǎn)換為update
     *
     * @param object
     * @return
     * @author Jason
     */
    private Update getUpdateByObject(T object) {
        Update update = new Update();
        String[] fileds = getFiledName(object);
        for (int i = 0; i < fileds.length; i++) {
            String filedName = (String) fileds[i];
            Object filedValue =getFieldValueByName(filedName, object);
            if (filedValue != null) {
                update.set(filedName, filedValue);
            }
        }
        return update;
    }

    /***
     * 獲取對(duì)象屬性返回字符串?dāng)?shù)組
     * @param o
     * @return
     */
    private static String[] getFiledName(Object o) {
        Field[] fields = o.getClass().getDeclaredFields();
        String[] fieldNames = new String[fields.length];

        for (int i = 0; i < fields.length; ++i) {
            fieldNames[i] = fields[i].getName();
        }

        return fieldNames;
    }

    /***
     * 根據(jù)屬性獲取對(duì)象屬性值
     * @param fieldName
     * @param o
     * @return
     */
    private static Object getFieldValueByName(String fieldName, Object o) {
        try {
            String e = fieldName.substring(0, 1).toUpperCase();
            String getter = "get" + e + fieldName.substring(1);
            Method method = o.getClass().getMethod(getter, new Class[0]);
            return method.invoke(o, new Object[0]);
        } catch (Exception var6) {
            return null;
        }
    }
}

我們將mongoDB常用的CURD操作封裝為通用的父類，然后在不同的業(yè)務(wù)場(chǎng)景下繼承該類，通過泛型和反射獲取到正在操作的實(shí)體類。

比如我們可以將之前的Book實(shí)體類的CURD類進(jìn)行改造

創(chuàng)建BookMongoDbDao類繼承MongoDbDao

import org.springframework.stereotype.Repository;

/**
 * @author: huangyibo
 * @Date: 2019/1/31 0:12
 * @Description:
 */
@Repository
public class BookMongoDbDao extends MongoDbDao<Book> {
    @Override
    protected Class<Book> getEntityClass() {
        return Book.class;
    }
}

接下來我們可以改造Book的Service類
原始版本：

@Service
public class BookMongoDbService {
    private static final Logger logger = LoggerFactory.getLogger(BookMongoDbService.class);

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 保存對(duì)象
     *
     * @param book
     * @return
     */
    public String saveObj(Book book) {
        logger.info("--------------------->[MongoDB save start]");
        book.setCreateTime(new Date());
        book.setUpdateTime(new Date());
        mongoTemplate.save(book);
        return "添加成功";
    }

    //其他操作方法......
}

改造后：

@Service
public class BookMongoDbService {
    private static final Logger logger = LoggerFactory.getLogger(BookMongoDbService.class);

    //注入新的CURD操作類
    @Autowired
    private BookMongoDbDao bookMongoDbDao;

    /**
     * 保存對(duì)象
     *
     * @param book
     * @return
     */
    public String saveObj2(Book book) {
        book.setCreateTime(new Date());
        book.setUpdateTime(new Date()); 
        //調(diào)用bookMongoDbDao父類中的添加方法
        bookMongoDbDao.save(book);
        return "添加成功";
    }
}

改造后的saveObj2方法的效果與以前的一致，但是大大的提高了開發(fā)效率。不需要重復(fù)的編寫CURD的方法。

總結(jié)
通過以上的配置已經(jīng)完成springboot與mongoDB集成環(huán)境的初步搭建，當(dāng)然了MongoDB在springboot中的使用不僅于此，還有更多的功能和更優(yōu)雅的使用方式等待著我們?nèi)グl(fā)掘。

原文出處：https://blog.csdn.net/qq_33619378/article/details/81544711