MongoDB学习心得2——web项目

最近公司要做一个电子书的项目，由于电子书章节内容一般不会去修改，删除这些操作，但是会经常查询，所以选择把章节存放在MongoDB数据库中。

1.在pom文件中引入jar包

<!-- mondb包 -->
		<dependency>
			<groupId>org.mongodb</groupId>
			<artifactId>mongo-java-driver</artifactId>
			<version>3.2.2</version>
		</dependency>
		
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-mongodb</artifactId>
			<version>1.8.6.RELEASE</version>
		</dependency>

2.在spring-mybatis中加入配置文件

<!-- spring连接mongodb数据库的配置 -->  
	<!-- 定义mongo对象，对应的是mongodb官方jar包中的Mongo，replica-set设置集群副本的ip地址和端口 -->
    <mongo:mongo-client id="mongo-client" replica-set="${mongo.hostport}"  credentials="${mongo.username}:${mongo.password}@${mongo.dbname}">
		<mongo:client-options 
		    connections-per-host="${mongo.connectionsPerHost}" 
			threads-allowed-to-block-for-connection-multiplier="${mongo.threadsAllowedToBlockForConnectionMultiplier}"
		    socket-keep-alive="${mongo.socketKeepAlive}"
		    heartbeat-frequency="${mongo.heartbeatFrequency}"
		    max-wait-time="${mongo.maxWaitTime}"
			connect-timeout="${mongo.connectTimeout}"
			socket-timeout="${mongo.socketTimeout}"
			read-preference="${mongo.readPreference}" />
	</mongo:mongo-client>
	
	<mongo:db-factory id="mongo-factory" mongo-ref="mongo-client" dbname="${mongo.dbname}"/>
	<bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
		<constructor-arg name="mongoDbFactory" ref="mongo-factory" />
	</bean>
	
	<!-- 实例化mongoDB -->
	<bean id="mongoDb" class="com.panshi.book.util.MongoDBUtil">
		<property name="mongoTemplate" ref="mongoTemplate"/>
	</bean>

3.配置文件

#mongo config
mongo.dbname=数据库名
mongo.username=用户名
mongo.password=密码
mongo.hostport=ip:端口号
mongo.connectionsPerHost=10
mongo.threadsAllowedToBlockForConnectionMultiplier=5
mongo.connectTimeout=10000
mongo.maxWaitTime=15000
mongo.heartbeatFrequency=10
mongo.socketKeepAlive=false
mongo.socketTimeout=10000
mongo.readPreference=secondaryPreferred

4.MongoDBUtil用来对mongo对象增删改查

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.mapping.Document;
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 com.panshi.book.entity.mongodb.MongoBaseModel;
import com.panshi.book.entity.mongodb.annotation.Sharding;
public class MongoDBUtil {
	
	private static MongoTemplate mongoTemplate;
	
	private static final Logger LOG = LoggerFactory.getLogger(MongoDBUtil.class);
	
	/**
	 * 插入单条数据
	 * 
	 * @param model
	 */
	public static void insert(MongoBaseModel model) {
		try {
			if (model == null) {
				return;
			}
			mongoTemplate.insert(model, getCollectionName(model.getClass(), model.getCreateTime()));
		} catch (Exception e) {
			if (!(e instanceof DuplicateKeyException)) {
				LOG.error("mongo insert error.", e);
			}
		}
	}
    
	
	/**
	 * 根据bookId和页数查询集合数据
	 * 
	 * @param stxtime
	 * @param clazz
	 * @return
	 */
	public static <T> List<T> findByBookId(int bookId,int start,int pageNo, Class<T> clazz) {
		return mongoTemplate.find(new Query(Criteria.where("bookId").is(bookId)).skip(start).limit(pageNo)
				.with(new Sort(Direction.ASC, "sort")), clazz, getCollectionName(clazz, ""));
	}
	
	/**
	 * 根据bookId和页数查询集合数据的总数
	 * 
	 * @param stxtime
	 * @param clazz
	 * @return
	 */
	public static <T> long findCountByBookId(int bookId,int start,int pageNo, Class<T> clazz) {
		return mongoTemplate.count(new Query(Criteria.where("bookId").is(bookId)), clazz, getCollectionName(clazz, ""));
	}
	
	/**
	 * 根据Id删除章节
	 * 
	 * @param stxtime
	 * @param clazz
	 * @return
	 */
	public static <T> void deleteChapter(int id, Class<T> clazz) {
			mongoTemplate.remove(new Query(Criteria.where("id").is(id)), clazz);
	}
	
	/**
	 * 更新数据
	 * 
	 * @param txId
	 * @param ustat
	 * @param clazz
	 */
	public static void updateMongoByTxid(String txId, Integer ustat, Class clazz) {
		Query query = new Query();
		query.addCriteria(new Criteria("txid").is(txId));
		Update update = new Update();
		update.set("ustat", ustat);
		mongoTemplate.updateFirst(query, update, getCollectionName(clazz, ""));  
	}
	
	public static void updataMsisdnByTxid(String txId, String msisdn, Class clazz) {
		Query query = new Query();
		query.addCriteria(new Criteria("txid").is(txId));
		Update update = new Update();
		update.set("uid", msisdn);
		mongoTemplate.updateFirst(query, update, getCollectionName(clazz, ""));  
	}
	
	/**
	 * 获取集合名
	 * 
	 * @return
	 */
	public static String getCollectionName(Class<?> clazz, String dateTime) {
		String collectionName = "";
		boolean hasDocument = clazz.isAnnotationPresent(Document.class);
		boolean hasSharding = clazz.isAnnotationPresent(Sharding.class);
		if (hasDocument) {
			collectionName = clazz.getAnnotation(Document.class).collection();
		}
		if (hasSharding && StringUtils.isNotBlank(dateTime)) {
			String strategy = clazz.getAnnotation(Sharding.class).strategy();
			if ("D".equals(strategy)) {
				String key = DateUtil.formatyyMMdd(dateTime);
				collectionName += key;
			} else {
				String key = DateUtil.formatyyMM(dateTime);
				collectionName += key;
			}
		}
		return collectionName;
	}

	public static MongoTemplate getMongoTemplate() {
		return mongoTemplate;
	}

	public static void setMongoTemplate(MongoTemplate mongoTemplate) {
		MongoDBUtil.mongoTemplate = mongoTemplate;
	}
}  

5.Mongo对象

import java.io.Serializable;
import java.util.Date;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Field;
import com.panshi.book.util.DateUtil;
/**
 * MongoDB实体基类
 * 
 * @author GMP
 *
 */
public class MongoBaseModel implements Serializable {

	private static final long serialVersionUID = 5280357071541783216L;

	@Id
	private String id;
	
	// 系统交易时间
	@Field("createTime")
	private String createTime = DateUtil.formatyyyyMMddHHmmss(new Date());

	public String getId() {
		return id;
	}

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

	public String getCreateTime() {
		return createTime;
	}

	public void setCreateTime(String createTime) {
		this.createTime = createTime;
	}

	
}

import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

@SuppressWarnings("serial")
@Document(collection="t_chapter")
public class MongoChapterEntity extends MongoBaseModel{
	
	
	@Field("bookId")
	private String bookId;
	@Field("title")
	private String title;
	@Field("content")
	private String content;
	@Field("sort")
	private String sort;
	
	public String getBookId() {
		return bookId;
	}
	public void setBookId(String bookId) {
		this.bookId = bookId;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getContent() {
		return content;
	}
	public void setContent(String content) {
		this.content = content;
	}
	public String getSort() {
		return sort;
	}
	public void setSort(String sort) {
		this.sort = sort;
	}
	
	
}