最近比較忙，忙的都沒空理csdn了，今天我繼續邁著魔鬼般的步伐，摩擦摩擦……總結下最近學到的MongoDB的知識。

1.認識Spring Data MongoDB

Spring Data 包含多個子專案：

• Commons - 提供共享的基礎框架，適合各個子專案使用，支援跨資料庫持久化

• Hadoop - 基於 Spring 的 Hadoop 作業配置和一個 POJO 程式設計模型的 MapReduce 作業

• Key-Value  - 集成了 Redis 和 Riak ，提供多個常用場景下的簡單封裝

• Document - 整合文件資料庫：CouchDB 和 MongoDB 並提供基本的配置對映和資料庫支援

• Graph - 整合 Neo4j 提供強大的基於 POJO 的程式設計模型

• Graph Roo AddOn - Roo support for Neo4j

• JDBC Extensions - 支援 Oracle RAD、高階佇列和高階資料型別

• JPA - 簡化建立 JPA 資料訪問層和跨儲存的持久層功能

• Mapping - 基於 Grails 的提供物件對映框架，支援不同的資料庫

• Examples - 示例程式、文件和圖資料庫

• Guidance - 高階文件

2. HelloWorld

2.1 配置依賴

<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.jastar</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>demo</name>
	<url>http://www.jastar-wang.tech</url>

	<!-- 版本配置 -->
	<properties>
		<spring.version>4.1.4.RELEASE</spring.version>
		<spring.data.version>1.7.0.RELEASE</spring.data.version>
		<log4j.version>1.2.17</log4j.version>
	</properties>

	<dependencies>
		<!-- 單元測試包 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.10</version>
			<scope>test</scope>
		</dependency>

		<!-- spring核心包 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- 關係型資料庫整合時需配置 如hibernate jpa等 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- spring aop 關聯 -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.8.7</version>
		</dependency>

		<!-- log4j -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>${log4j.version}</version>
		</dependency>

		<!-- spring整合MongoDB -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-mongodb</artifactId>
			<version>${spring.data.version}</version>
		</dependency>

	</dependencies>

	<repositories>
		<repository>
			<id>spring-milestone</id>
			<name>Spring Maven MILESTONE Repository</name>
			<url>http://repo.spring.io/libs-milestone</url>
		</repository>
	</repositories>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.7</source>
					<target>1.7</target>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

2.2 對映實體類

package com.jastar.demo.entity;

import java.io.Serializable;
import java.sql.Timestamp;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.IndexDirection;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

/**
 * 使用者實體類
 * <p>
 * ClassName: UserInfo
 * </p>
 * <p>
 * Description:本類用來展示MongoDB實體類對映的使用
 * </p>
 * <p>
 * Copyright: (c)2017 Jastar·Wang,All rights reserved.
 * </p>
 * 
 * @author Jastar·Wang
 * @date 2017年4月12日
 */
@Document(collection = "coll_user")
public class UserInfo implements Serializable {

	/** serialVersionUID */
	private static final long serialVersionUID = 1L;

	// 主鍵使用此註解
	@Id
	private String id;

	// 欄位使用此註解
	@Field
	private String name;

	// 欄位還可以用自定義名稱
	@Field("myage")
	private int age;

	// 還可以生成索引
	@Indexed(name = "index_birth", direction = IndexDirection.DESCENDING)
	@Field
	private Timestamp birth;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	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 Timestamp getBirth() {
		return birth;
	}

	public void setBirth(Timestamp birth) {
		this.birth = birth;
	}

}

• @Id - 用於欄位級別，標記這個欄位是一個主鍵，預設生成的名稱是“_id”

• @Document - 用於類，以表示這個類需要對映到資料庫，您也可以指定對映到資料庫的集合名稱

• @DBRef - 用於欄位，以表示它將使用com.mongodb.DBRef進行儲存。

• @Indexed - 用於欄位，表示該欄位需要如何建立索引

• @CompoundIndex - 用於類，以聲明覆合索引

• @GeoSpatialIndexed - 用於欄位，進行地理位置索引

• @TextIndexed - 用於欄位，標記該欄位要包含在文字索引中

• @Language - 用於欄位，以設定文字索引的語言覆蓋屬性。

• @Transient - 預設情況下，所有私有欄位都對映到文件，此註解將會去除此欄位的對映

• @PersistenceConstructor - 標記一個給定的建構函式，即使是一個protected修飾的，在從資料庫例項化物件時使用。建構函式引數通過名稱對映到檢索的DBObject中的鍵值。

• @Value - 這個註解是Spring框架的一部分。在對映框架內，它可以應用於建構函式引數。這允許您使用Spring表示式語言語句來轉換在資料庫中檢索的鍵值，然後再用它來構造一個域物件。為了引用給定文件的屬性，必須使用以下表達式：@Value("#root.myProperty")，root要指向給定文件的根。

• @Field - 用於欄位，並描述欄位的名稱，因為它將在MongoDB BSON文件中表示，允許名稱與該類的欄位名不同。

• @Version - 用於欄位鎖定，儲存操作時檢查修改。初始值是0，每次更新時自動觸發。

2.3 整合配置

###---The mongodb settings---
mongo.dbname=demo
mongo.host=localhost
mongo.port=27017
mongo.connectionsPerHost=8
mongo.threadsAllowedToBlockForConnectionMultiplier=4
mongo.connectTimeout=1000
mongo.maxWaitTime=1500
mongo.autoConnectRetry=true
mongo.socketKeepAlive=true
mongo.socketTimeout=1500
mongo.slaveOk=true
mongo.writeNumber=1
mongo.writeTimeout=0
mongo.writeFsync=true

<?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">

	<!-- 讀取屬性檔案 -->
	<context:property-placeholder location="classpath:db.properties" />

	<!-- 啟用註解支援 -->
	<context:annotation-config />

	<!-- 掃描元件包 -->
	<context:component-scan base-package="com.jastar.demo" />

	<!-- SpringData型別轉換器 -->
	<mongo:mapping-converter id="mongoConverter">
		<mongo:custom-converters>
			<mongo:converter>
				<bean class="com.jastar.demo.converter.TimestampConverter" />
			</mongo:converter>
		</mongo:custom-converters>
	</mongo:mapping-converter>

	<!-- 
		MongoDB配置部分 
		1.mongo：連線配置 
		2.db-factory：相當於sessionFactory 
		3.mongoTemplate：與資料庫介面互動的主要實現類 
	-->
	<mongo:mongo host="${mongo.host}" port="${mongo.port}">
		<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="${mongo.writeNumber}" 
			write-timeout="${mongo.writeTimeout}"
			write-fsync="${mongo.writeFsync}" />
	</mongo:mongo>

	<mongo:db-factory id="mongoDbFactory" dbname="${mongo.dbname}" mongo-ref="mongo" />

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

</beans>

2.4 Dao層參考實現

【BaseDaoImpl.java】

package com.jastar.demo.dao.impl;

import static org.springframework.data.mongodb.core.query.Criteria.where;

import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.annotation.Id;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;

import com.jastar.demo.dao.IBaseDao;
import com.jastar.demo.util.EmptyUtil;
import com.jastar.demo.util.PageModel;

/**
 * 基本操作介面MongoDB資料庫實現類
 * <p>
 * ClassName: BaseDaoImpl
 * </p>
 * <p>
 * Description:本實現類適用於MongoDB資料庫，以下程式碼僅供參考，本人水平有限，可能會存在些許問題（如有更好方案可告知我，一定虛心學習），
 * 再次提醒，僅供參考！！
 * </p>
 * <p>
 * Copyright: (c)2017 Jastar·Wang,All rights reserved.
 * </p>
 * 
 * @author Jastar·Wang
 * @date 2017年4月12日
 */
public abstract class BaseDaoImpl<T> implements IBaseDao<T> {

	protected abstract Class<T> getEntityClass();

	@Autowired
	protected MongoTemplate mgt;

	@Override
	public void save(T entity) {
		mgt.save(entity);
	}

	@Override
	public void update(T entity) {

		// 反向解析物件
		Map<String, Object> map = null;
		try {
			map = parseEntity(entity);
		} catch (Exception e) {
			e.printStackTrace();
		}

		// ID欄位
		String idName = null;
		Object idValue = null;

		// 生成引數
		Update update = new Update();
		if (EmptyUtil.isNotEmpty(map)) {
			for (String key : map.keySet()) {
				if (key.indexOf("{") != -1) {
					// 設定ID
					idName = key.substring(key.indexOf("{") + 1, key.indexOf("}"));
					idValue = map.get(key);
				} else {
					update.set(key, map.get(key));
				}
			}
		}
		mgt.updateFirst(new Query().addCriteria(where(idName).is(idValue)), update, getEntityClass());
	}

	@Override
	public void delete(Serializable... ids) {
		if (EmptyUtil.isNotEmpty(ids)) {
			for (Serializable id : ids) {
				mgt.remove(mgt.findById(id, getEntityClass()));
			}
		}

	}

	@Override
	public T find(Serializable id) {
		return mgt.findById(id, getEntityClass());
	}

	@Override
	public List<T> findAll() {
		return mgt.findAll(getEntityClass());
	}

	@Override
	public List<T> findAll(String order) {
		List<Order> orderList = parseOrder(order);
		if (EmptyUtil.isEmpty(orderList)) {
			return findAll();
		}
		return mgt.find(new Query().with(new Sort(orderList)), getEntityClass());
	}

	@Override
	public List<T> findByProp(String propName, Object propValue) {
		return findByProp(propName, propValue, null);
	}

	@Override
	public List<T> findByProp(String propName, Object propValue, String order) {
		Query query = new Query();
		// 引數
		query.addCriteria(where(propName).is(propValue));
		// 排序
		List<Order> orderList = parseOrder(order);
		if (EmptyUtil.isNotEmpty(orderList)) {
			query.with(new Sort(orderList));
		}
		return mgt.find(query, getEntityClass());
	}

	@Override
	public List<T> findByProps(String[] propName, Object[] propValue) {
		return findByProps(propName, propValue, null);
	}

	@Override
	public List<T> findByProps(String[] propName, Object[] propValue, String order) {
		Query query = createQuery(propName, propValue, order);
		return mgt.find(query, getEntityClass());
	}

	@Override
	public T uniqueByProp(String propName, Object propValue) {
		return mgt.findOne(new Query(where(propName).is(propValue)), getEntityClass());
	}

	@Override
	public T uniqueByProps(String[] propName, Object[] propValue) {
		Query query = createQuery(propName, propValue, null);
		return mgt.findOne(query, getEntityClass());
	}

	@Override
	public PageModel<T> pageAll(int pageNo, int pageSize) {
		return pageAll(pageNo, pageSize, null);
	}

	@Override
	public PageModel<T> pageAll(int pageNo, int pageSize, String order) {
		return pageByProp(pageNo, pageSize, null, null, order);
	}

	@Override
	public PageModel<T> pageByProp(int pageNo, int pageSize, String param, Object value) {
		return pageByProp(pageNo, pageSize, param, value, null);
	}

	@Override
	public PageModel<T> pageByProp(int pageNo, int pageSize, String param, Object value, String order) {
		String[] params = null;
		Object[] values = null;
		if (EmptyUtil.isNotEmpty(param)) {
			params = new String[] { param };
			values = new Object[] { value };
		}
		return pageByProps(pageNo, pageSize, params, values, order);
	}

	@Override
	public PageModel<T> pageByProps(int pageNo, int pageSize, String[] params, Object[] values) {
		return pageByProps(pageNo, pageSize, params, values, null);
	}

	@Override
	public PageModel<T> pageByProps(int pageNo, int pageSize, String[] params, Object[] values, String order) {
		// 建立分頁模型物件
		PageModel<T> page = new PageModel<>(pageNo, pageSize);

		// 查詢總記錄數
		int count = countByCondition(params, values);
		page.setTotalCount(count);

		// 查詢資料列表
		Query query = createQuery(params, values, order);

		// 設定分頁資訊
		query.skip(page.getFirstResult());
		query.limit(page.getPageSize());

		// 封裝結果資料
		page.setList(mgt.find(query, getEntityClass()));

		return page;
	}

	@Override
	public int countByCondition(String[] params, Object[] values) {
		Query query = createQuery(params, values, null);
		Long count = mgt.count(query, getEntityClass());
		return count.intValue();
	}

	/**
	 * 建立帶有where條件（只支援等值）和排序的Query物件
	 * 
	 * @param params
	 *            引數陣列
	 * @param values
	 *            引數值陣列
	 * @param order
	 *            排序
	 * @return Query物件
	 */
	protected Query createQuery(String[] params, Object[] values, String order) {
		Query query = new Query();

		// where 條件
		if (EmptyUtil.isNotEmpty(params) && EmptyUtil.isNotEmpty(values)) {
			for (int i = 0; i < params.length; i++) {
				query.addCriteria(where(params[i]).is(values[i]));
			}
		}

		// 排序
		List<Order> orderList = parseOrder(order);
		if (EmptyUtil.isNotEmpty(orderList)) {
			query.with(new Sort(orderList));
		}

		return query;
	}

	/**
	 * 解析Order字串為所需引數
	 * 
	 * @param order
	 *            排序引數，如[id]、[id asc]、[id asc,name desc]
	 * @return Order物件集合
	 */
	protected List<Order> parseOrder(String order) {
		List<Order> list = null;
		if (EmptyUtil.isNotEmpty(order)) {
			list = new ArrayList<Order>();
			// 共有幾組排序欄位
			String[] fields = order.split(",");
			Order o = null;
			String[] item = null;
			for (int i = 0; i < fields.length; i++) {
				if (EmptyUtil.isEmpty(fields[i])) {
					continue;
				}
				item = fields[i].split(" ");
				if (item.length == 1) {
					o = new Order(Direction.ASC, item[0]);
				} else if (item.length == 2) {
					o = new Order("desc".equalsIgnoreCase(item[1]) ? Direction.DESC : Direction.ASC, item[0]);
				} else {
					throw new RuntimeException("排序欄位引數解析出錯");
				}
				list.add(o);
			}
		}
		return list;
	}

	/**
	 * 將物件的欄位及值反射解析為Map物件<br>
	 * 這裡使用Java反射機制手動解析，並且可以識別註解為主鍵的欄位，以達到根據id進行更新實體的目的<br>
	 * key：欄位名稱，value：欄位對應的值
	 * 
	 * @param t
	 *            要修改的物件
	 * @return Map物件，注意：id欄位的key封裝為“{id欄位名稱}”，以供後續識別
	 * @throws Exception
	 */
	protected Map<String, Object> parseEntity(T t) throws Exception {
		Map<String, Object> map = new HashMap<String, Object>();
		/*
		 * 解析ID
		 */
		String idName = "";
		Field[] declaredFields = getEntityClass().getDeclaredFields();
		for (Field field : declaredFields) {
			if (field.isAnnotationPresent(Id.class)) {
				field.setAccessible(true);
				map.put("{" + field.getName() + "}", field.get(t));
				idName = field.getName();
				break;
			}
		}
		/*
		 * 解析其他屬性
		 */
		Method[] methods = getEntityClass().getDeclaredMethods();
		if (EmptyUtil.isNotEmpty(methods)) {
			for (Method method : methods) {
				if (method.getName().startsWith("get") && method.getModifiers() == Modifier.PUBLIC) {
					String fieldName = parse2FieldName(method.getName());
					if (!fieldName.equals(idName)) {
						map.put(fieldName, method.invoke(t));
					}
				}
			}
		}

		return map;
	}

	/**
	 * 將get方法名轉換為對應的欄位名稱
	 * 
	 * @param methodName
	 *            如：getName
	 * @return 如：name
	 */
	private String parse2FieldName(String methodName) {
		String name = methodName.replace("get", "");
		name = name.substring(0, 1).toLowerCase() + name.substring(1);
		return name;
	}

}

說明：

        以上實現僅供參考某些實現點，mongoTemplate如何使用還要自己去詳細的摸索，我也沒辦法，畢竟我也這樣過來的，大多數方法都已經提供了，只是update方法不像關係型資料庫那樣，給個實體類就能更新，需要自己去想辦法搞定。

【TestUseService.java】

package com.jastar.test;

import java.sql.Timestamp;
import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.jastar.demo.entity.UserInfo;
import com.jastar.demo.service.UserService;
import com.jastar.demo.util.PageModel;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-mgo.xml")
public class TestUserService {

	@Autowired
	private UserService service;

	@Test
	public void save() {
		UserInfo user = new UserInfo();
		user.setName("張三");
		user.setAge(25);
		user.setBirth(Timestamp.valueOf("2017-4-12 16:52:00"));
		service.save(user);
		System.out.println("已生成ID:" + user.getId());
	}

	@Test
	public void find() {
		UserInfo user = service.find("58edf1b26f033406394a8a61");
		System.out.println(user.getName());
	}

	@Test
	public void update() {
		UserInfo user = service.find("58edf1b26f033406394a8a61");
		user.setAge(18);
		service.update(user);
	}

	@Test
	public void delete() {
		service.delete("58edef886f03c7b0fdba51b9");
	}

	@Test
	public void findAll() {
		List<UserInfo> list = service.findAll("age desc");
		for (UserInfo u : list) {
			System.out.println(u.getName());
		}
	}

	@Test
	public void findByProp() {
		List<UserInfo> list = service.findByProp("name", "張三");
		for (UserInfo u : list) {
			System.out.println(u.getName());
		}
	}

	@Test
	public void findByProps() {
		List<UserInfo> list = service.findByProps(new String[] { "name", "age" }, new Object[] { "張三", 18 });
		for (UserInfo u : list) {
			System.out.println(u.getName());
		}
	}

	@Test
	public void pageAll() {
		PageModel<UserInfo> page = service.pageAll(1, 10);
		System.out.println("總記錄：" + page.getTotalCount() + "，總頁數：" + page.getTotalPage());
		for (UserInfo u : page.getList()) {
			System.out.println(u.getName());
		}
	}

	@Test
	public void pageByProp() {
		PageModel<UserInfo> page = service.pageByProp(1, 10, "name", "張三");
		System.out.println("總記錄：" + page.getTotalCount() + "，總頁數：" + page.getTotalPage());
		for (UserInfo u : page.getList()) {
			System.out.println(u.getName());
		}
	}

}

更多知識，請參考官方文件：戳我戳我

更多程式碼，請參考本專案Git 地址：戳我戳我