spring data mongodb基础篇

学习阶段能够安装一个windows版本的mongodb，尽快把mongodb服务跑起来，让程序连上。mongodb的安装、运行、基础命令的知识，能够参考 菜鸟教程mongodb

spring mongodb 依赖版本：spring版本是4.0.9.RELEASE

<dependency>
	<groupId>org.springframework.data</groupId>
	<artifactId>spring-data-mongodb</artifactId>
	<version>1.7.2.RELEASE</version>
</dependency>

spring mongodb的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mongo="http://www.springframework.org/schema/data/mongo"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-3.2.xsd
	http://www.springframework.org/schema/data/mongo
    http://www.springframework.org/schema/data/mongo/spring-mongo-1.7.xsd  ">

	<context:component-scan base-package="com.wss.lsl.pay.demo">
		<context:exclude-filter type="annotation"
			expression="org.springframework.stereotype.Controller" />
	</context:component-scan>
	
	<!-- mongo config start -->
	<bean id="mongo" class="org.springframework.data.mongodb.core.MongoFactoryBean">
	    <property name="host" value="192.168.1.134" />
	    <property name="port" value="27017" />
	</bean>
	<bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
	    <constructor-arg name="mongo" ref="mongo" />
	    <constructor-arg name="databaseName" value="test" />
	</bean>
	<bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>
	<mongo:repositories base-package="com.wss.lsl.pay.demo.dao" mongo-template-ref="mongoTemplate" />	
	<!-- mongo config end -->	
</beans>

领域对象：model实体

package com.wss.lsl.pay.demo.model;

import java.io.Serializable;

import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.Transient;
import org.springframework.data.mongodb.core.index.CompoundIndex;
import org.springframework.data.mongodb.core.index.CompoundIndexes;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.DBRef;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

import com.mysema.query.annotations.QueryEntity;
import com.wss.lsl.pay.demo.common.annotation.CascadeSave;

// 复合索引
@CompoundIndexes({ @CompoundIndex(name = "name_1_age_1", def = "{'name': 1, 'age': 1}") })
@Document(collection = "user")
public class User implements Serializable {

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

	@Id
	private String id;

	private String name;

	@Field("age") // 保存在数据库的别名
	private int age;

	@Indexed // 单字段索引
	private Integer yearOfBirth;

	@Transient // 不持久化在数据库
	private String password;
	
	// getter/setter
}

dao写法

package com.wss.lsl.pay.demo.dao;

import java.util.List;

import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;
import org.springframework.data.querydsl.QueryDslPredicateExecutor;

import com.wss.lsl.pay.demo.model.User;

public interface UserRepository extends MongoRepository<User, String>, QueryDslPredicateExecutor<User> {
	
	// 根据名字查询用户列表	
	List<User> findByName(String name);
	
	// 查询名字以什么开头的用户列表	
	List<User> findByNameStartingWith(String regexp);
	
	//查询名字以什么结尾的用户列表	 
	List<User> findByNameEndingWith(String regexp);
	
	// 查询年龄区间的用户列表
	// ageLt < age < ageGt	 
	List<User> findByAgeBetween(int ageLt, int ageGt);
	
	// 查询名字包含。全模糊查询 
	List<User> findByNameLike(String name);
	
	// 多条件组合查询
	// 查询名字包含<br>
	// 结果集按age升序排
	List<User> findByNameLikeOrderByAgeAsc(String name);
	
	// 注解方式查询。按名字查询用户
	// ?0表示第一个参数
	@Query("{'name': ?0}")
	List<User> findUsersByName(String name);
	
	// 根据用户名字的正则表达式查询$regex
	@Query("{'name':{$regex: ?0}}")
	List<User> findUsersByRegexpName(String regexp);
	
	// 根据年龄区间查询	
	@Query("{'age':{$gt:?0, $lt: ?1}}")
	List<User> findUsersByAgeBetween(int ageGT, int ageLT);	
}

单元测试

package com.wss.lsl.pay.demo.dao;

import java.util.List;

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.index.Index;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.mysema.query.types.Predicate;
import com.wss.lsl.pay.demo.model.Card;
import com.wss.lsl.pay.demo.model.QUser;
import com.wss.lsl.pay.demo.model.User;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:/META-INF/spring/applicationContext.xml"})
public class UserRepositoryTest {

	@Autowired
	private UserRepository userRepository;
	@Autowired
	private MongoTemplate mongoTemplate;

	@Before
	public void setUp() {
		userRepository.deleteAll(); // 清空数据，为测试用例准备前提条件
	}

	@After
	public void after() {
	}

	private void saveUser(String name, int age) {
		User user = new User(name, age);
		userRepository.insert(user);
	}

	private User getLongNameUser() {
		return new User("张三32323rtyuioghjklsadas范德", 20);
	}

	// 测试插入
	@Test
	public void testInsert() throws InterruptedException {
		int count = 100;
		for (int i = 0; i < count; i++) {
			User user = getLongNameUser();
			userRepository.insert(user);
		}

		// 校验插入的数据数量
		long totalCount = userRepository.count();
		Assert.assertEquals(count, totalCount);
	}

	// 测试查询
	@Test
	public void testQuery() {
		User user = new User("张三", 20);
		userRepository.insert(user);

		user = new User("李四", 20);
		userRepository.insert(user);

		// page 从0开始
		Pageable page = new PageRequest(0, 2, Direction.ASC, "name");
		Page<User> list = userRepository.findAll(page);
		List<User> users = list.getContent();
		User zhangsan = users.get(0);
		User lisi = users.get(1);

		Assert.assertEquals("张三", zhangsan.getName());
		Assert.assertEquals("李四", lisi.getName());

		// 按名字查询
		Query query = new Query();
		query.addCriteria(Criteria.where("name").is("张三"));
		users = mongoTemplate.find(query, User.class);
		Assert.assertEquals(1, users.size());

		query = new Query();
		query.addCriteria(Criteria.where("name").is("李四"));
		users = mongoTemplate.find(query, User.class);
		Assert.assertEquals(1, users.size());
	}

	// 测试更新
	@Test
	public void testUpdate() {
		long count = userRepository.count();
		Assert.assertEquals(0, count);

		User user = new User("张三", 20);
		userRepository.save(user); // 没有先插入
		// 校验
		count = userRepository.count();
		Assert.assertEquals(1, count);
		user = userRepository.findOne(user.getId());
		Assert.assertEquals("张三", user.getName());

		// 更新操做
		user.setName("张三2");
		userRepository.save(user);
		// 校验
		count = userRepository.count();
		Assert.assertEquals(1, count);
		user = userRepository.findOne(user.getId());
		Assert.assertEquals("张三2", user.getName());
	}

	// 测试删除操做
	@Test
	public void testDelete() {
		User user = new User("张三", 20);
		userRepository.insert(user);

		user = new User("李四", 30);
		userRepository.insert(user);

		// 删除了“李四”
		mongoTemplate.remove(user, "user");

		// 校验只有“张三”
		List<User> users = mongoTemplate.findAll(User.class);
		Assert.assertEquals(1, users.size());
		Assert.assertEquals("张三", users.get(0).getName());
	}

	// 测试between查询
	@Test
	public void testBetween() {
		saveUser("张三", 20);
		saveUser("李四", 25);
		saveUser("王五", 31);

		List<User> users = userRepository.findByAgeBetween(20, 30);
		Assert.assertEquals(1, users.size());
		Assert.assertEquals("李四", users.get(0).getName());
	}

	// 测试like
	@Test
	public void testLike() {
		saveUser("三张", 20);
		saveUser("李五四三", 30);
		saveUser("王三五", 31);

		List<User> users = userRepository.findByNameLike("三");
		Assert.assertEquals(3, users.size());
		for (User user : users) {
			Assert.assertTrue(user.getName().contains("三"));
		}
	}

	// 测试排序：按年龄排序
	@Test
	public void testSort() {
		saveUser("三张", 20);
		saveUser("王三五", 31);
		saveUser("李五四三", 30);
		saveUser("李五四三", 10);
		saveUser("李五四三", 30);

		List<User> users = userRepository.findByNameLikeOrderByAgeAsc("三");
		Assert.assertEquals(5, users.size());
		Assert.assertEquals(10, users.get(0).getAge());
		Assert.assertEquals(20, users.get(1).getAge());
		Assert.assertEquals(30, users.get(2).getAge());
		Assert.assertEquals(30, users.get(3).getAge());
		Assert.assertEquals(31, users.get(4).getAge());
	}		
}