Spring 集成mongodb maven

mongoDB 介绍（特点、优点、原理）

介绍：MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。

特点：高性能、易部署、易使用，存储数据非常方便。

主要功能特性有：

Ø 面向集合存储，易存储对象类型的数据

Ø 模式自由

Ø 支持动态查询

Ø 支持完全索引，包含内部对象

Ø 支持查询

Ø 支持复制和故障恢复

Ø 使用高效的二进制数据存储，包括大型对象（如视频等）

Ø 自动处理碎片，以支持云计算层次的扩展性

Ø 支持RUBY，PYTHON，JAVA，C++，PHP等多种语言

Ø 文件存储格式为BSON（一种JSON的扩展）

Ø 可通过网络访问

使用原理

所谓“面向集合”（Collenction-Oriented），意思是数据被分组存储在数据集中，被称为一个集合（Collenction)。每个集合在数据库中都有一个唯一的标识名，并且可以包含无限数目的文档。集合的概念类似关系型数据库（RDBMS）里的表（table），不同的是它不需要定义任何模式（schema)。

模式自由（schema-free)，意味着对于存储在mongodb数据库中的文件，我们不需要知道它的任何结构定义。如果需要的话，你完全可以把不同结构的文件存储在同一个数据库里。

存储在集合中的文档，被存储为键-值对的形式。键用于唯一标识一个文档，为字符串类型，而值则可以是各种复杂的文件类型。我们称这种存储形式为BSON（Binary JSON）。

集成前重要的几个jar包

pom.xml

<span style="white-space:pre">		</span><dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-mongodb</artifactId>
			<version>1.8.2.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-commons</artifactId>
			<version>1.10.0.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.mongodb</groupId>
			<artifactId>mongo-java-driver</artifactId>
			<version>2.13.0-rc2</version>
		</dependency>

Spring 集成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-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">

	<mongo:mongo host="${mongo.host}" port="${mongo.port}">
		<!-- 连接池配置详细查看http://api.mongodb.org/java/2.7.2/com/mongodb/MongoOptions.html#connectionsPerHost 
			或者http://www.cnblogs.com/huangfox/archive/2012/04/01/2428947.html -->
		<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="${mongo.database}" username="${mongo.username}"
		password="${mongo.password}" mongo-ref="mongo" />

	<!-- Spring提供的mongodb操作模板 -->
	<bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
		<constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
		<constructor-arg name="mongoConverter" ref="mappingMongoConverter" />
	</bean>

	<bean id="mappingContext"
		class="org.springframework.data.mongodb.core.mapping.MongoMappingContext" />

	<bean id="mappingMongoConverter"
		class="org.springframework.data.mongodb.core.convert.MappingMongoConverter">
		<constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
		<constructor-arg name="mappingContext" ref="mappingContext" />
		<property name="typeMapper" ref="defaultMongoTypeMapper" />
	</bean>

	<!-- 默认Mongodb类型映射 -->
	<bean id="defaultMongoTypeMapper"
		class="org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper">
		<constructor-arg name="typeKey">
			<!-- 这里设置为空,可以把 spring data mongodb 多余保存的_class字段去掉 -->
			<null />
		</constructor-arg>
	</bean>


	<context:annotation-config />
	<context:component-scan base-package="com.cl.*.mongo">
		<context:exclude-filter type="annotation"
			expression="org.springframework.context.annotation.Configuration" />
	</context:component-scan>
	<context:annotation-config />

	<mongo:repositories base-package="com.cl.*.mongo.*.dao" />

	<context:component-scan base-package="com.cl.*.mongo.service" />
</beans>

properties配置

mongo.host=192.168.1.215
mongo.port=27017
mongo.database=cl
mongo.username=cl
mongo.password=cl
 
mongo.connectionsPerHost=8
mongo.threadsAllowedToBlockForConnectionMultiplier=4
mongo.connectTimeout=1500
mongo.maxWaitTime=1500
mongo.autoConnectRetry=true
mongo.socketKeepAlive=true
mongo.socketTimeout=10000
mongo.slaveOk=true

mongodbBaseDao

public abstract class MongodbBaseDao<T> {

	/**
	 * spring mongodb　集成操作类　
	 */
	protected MongoTemplate mongoTemplate;

	/**
	 * 通过条件查询实体(集合)
	 * 
	 * @param query
	 */
	public List<T> find(Query query) {
		return mongoTemplate.find(query, this.getEntityClass());
	}

	/**
	 * 通过一定的条件查询一个实体
	 * 
	 * @param query
	 * @return
	 */
	public T findOne(Query query) {
		return mongoTemplate.findOne(query, this.getEntityClass());
	}

	/**
	 * 查询出所有数据
	 * 
	 * @return
	 */
	public List<T> findAll() {
		return this.mongoTemplate.findAll(getEntityClass());
	}

	/**
	 * 查询并且修改记录
	 * 
	 * @param query
	 * @param update
	 * @return
	 */
	public T findAndModify(Query query, Update update) {
		return this.mongoTemplate.findAndModify(query, update, this.getEntityClass());
	}

	/**
	 * 按条件查询,并且删除记录
	 * 
	 * @param query
	 * @return
	 */
	public T findAndRemove(Query query) {
		return this.mongoTemplate.findAndRemove(query, this.getEntityClass());
	}

	/**
	 * 通过条件查询更新数据
	 * 
	 * @param query
	 * @param update
	 * @return
	 */
	public void updateFirst(Query query, Update update) {
		mongoTemplate.updateFirst(query, update, this.getEntityClass());
	}

	/**
	 * 保存一个对象到mongodb
	 * 
	 * @param bean
	 * @return
	 */
	public T save(T bean) {
		mongoTemplate.save(bean, this.getEntityClass().getSimpleName());
		return bean;
	}

	/**
	 * 通过ID获取记录
	 * 
	 * @param id
	 * @return
	 */
	public T findById(String id) {
		return mongoTemplate.findById(id, this.getEntityClass());
	}

	/**
	 * 通过ID获取记录,并且指定了集合名(表的意思)
	 * 
	 * @param id
	 * @param collectionName
	 *            集合名
	 * @return
	 */
	public T findById(String id, String collectionName) {
		return mongoTemplate.findById(id, this.getEntityClass(), collectionName);
	}

	/**
	 * 获取需要操作的实体类class
	 * 
	 * @return
	 */
	protected abstract Class<T> getEntityClass();

	

}

dao实例(增、删、改、查)

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.zhixian.common.mongo.dao.ITestDao;
import com.zhixian.common.mongo.entiy.Test;
import com.zhixian.common.tool.MongodbBaseDao;

@Repository
public class TestDao extends MongodbBaseDao<Test> implements ITestDao {

	@Autowired
	@Qualifier("mongoTemplate")
	public void setMongoTemplate(MongoTemplate mongoTemplate) {
		super.mongoTemplate = mongoTemplate;
	}

	public Test getTest(String testId) {
		Query query = new Query(Criteria.where("_id").is(testId));
		return mongoTemplate.findOne(query, getEntityClass());
	}

	@Override
	protected Class<Test> getEntityClass() {
		return Test.class;
	}

	@Override
	public void addTest(Test test) {
		mongoTemplate.save(test);
	}

	@Override
	public List<Test> findAllTestBySex(String sex) {
		Query query = new Query(Criteria.where("sex").is(sex));
		return mongoTemplate.find(query, getEntityClass());
	}

	@Override
	public void removeTestById(String testId) {
		Query query = new Query(Criteria.where("_id").is(testId));
		mongoTemplate.remove(query, getEntityClass());
	}

	@Override
	public void updateTest(Test test) {
		Query query = new Query(Criteria.where("_id").is(test.getId()));
		Update update = new Update();
		if (null != test.getName()) {
			update.set("name", test.getName());
		}
		if (null != test.getAge()) {
			update.set("age", test.getAge());
		}
		if (null != test.getSex()) {
			update.set("sex", test.getSex());
		}
		mongoTemplate.updateFirst(query, update, getEntityClass());

	}

}

测试

@RequestMapping(value = "/test", method = RequestMethod.GET, produces = "application/json;charset=utf-8")
	@ResponseBody
	public void test(HttpServletRequest request, HttpServletResponse response, String testId) throws InterruptedException {
		System.out.println("mongodb test");
		// 查询
		Test test = testService.verify("5767986fff005317e0ebfc24");
		test.setAge(21);
		test.setName("程序援");
		test.setSex("女");
		// 修改
		testService.updateTest(test);
		// 查询多个
		List<Test> list = testService.findAllTestBySex("男");
		for (Test t : list) {
			System.out.println(t.getName());
			System.out.println(t.getId());
		}
		// 删除
		testService.removeTestById(list.get(0).getId());
		// 添加
		Test t = new Test();
		t.setAge(24);
		t.setName("程序猿");

	}