MongoDB组件util

标签：

MongonDB组件开发，封装成一个util，便于统一调用、管理。

 一、引入POM

<projectxmlns="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.my.mongodb</groupId>

<artifactId>my-mongodb</artifactId>

<version>1.0-SNAPSHOT</version>

<packaging>jar</packaging>

<name>my-mongodb</name>

<url>http://maven.apache.org</url>

<properties>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

</properties>

<dependencies>

<dependency>

<groupId>org.mongodb</groupId>

<artifactId>mongo-java-driver</artifactId>

<version>3.1.0</version>

</dependency>

<dependency>

<groupId>org.mongodb</groupId>

<artifactId>bson</artifactId>

<version>3.1.0</version>

</dependency>

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>3.8.1</version>

<scope>test</scope>

</dependency>

</dependencies>

</project>

 二、配置mongoDB的数据库配置

（2）文件内容如下：

#服务器地址mongodb://开头   服务器地址为mongodb的服务器地址  注意端口及ip是否和你环境一致
mongo.uri=mongodb://127.0.0.1:27017
#每个主机答应的连接数（每个主机的连接池大小），当连接池被用光时，会被阻塞住 ，默以为10 --int
mongo.connectionsPerHost=50
#数据库名   
mongo.databaseName=mymongo    

三、mongoDB组件java类开发

   定义包含初始化数据库、CRUD等功能基础类

package com.my.mongodb.dao;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;

import org.bson.Document;
import org.bson.conversions.Bson;
import org.bson.types.ObjectId;

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoClientOptions.Builder;
import com.mongodb.MongoClientURI;
import com.mongodb.WriteConcern;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.model.Filters;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import com.my.mongodb.enums.MongoOperation;

/**
 * @Title MongoDbDao.java
 * @Description MongoDb Dao层服务类
 * @author night
 * @date 2015年12月30日 上午10:51:06
 * @version V1.0
 */
public enum MongoDbDao {
	/**
	 * 定义一个枚举的元素，它代表此类的一个实例
	 */
	INSTANCE;

	private MongoClient mongoClient;
	/**
	 * 指定默认数据库
	 */
	private static String DEFAULTDBNAME;
	/**
	 * 获取tomcat路径
	 */
	private static String LOADPATH = "catalina.home";
	/**
	 * mongodb配置文件相对路径
	 */
	private static String CONFIG_PATH = "commoncfg/dbconf/mongodb.properties";// tomcat 环境地址 catalina.home 值/Users/night/Documents/apache-tomcat-7.0
	
	static {

		System.out.println("MongoDb初始化＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝Begin");
		// 获取系统变量
		Properties sysProperties = System.getProperties();
		// 获取MongoDb配置路径
		String uri = sysProperties.getProperty(LOADPATH) + File.separator + CONFIG_PATH;
		System.out.println(uri);
		// 加载配置路径
		Properties properties = new Properties();
//		InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(uri);//这种方式按上述路径无法加载到文件
		InputStream inputStream = null;
		
		try {
			inputStream = new FileInputStream(uri);
			System.out.println(inputStream);
			properties.load(inputStream);
			
			for(Iterator<Object> itr = properties.keySet().iterator();itr.hasNext();){  
	            String key = (String) itr.next();  
	            System.out.println(key + "=" + properties.get(key));  
	        }  
			
			/* 将配置文件中的配置进行对应设置 */

			DEFAULTDBNAME = properties.getProperty("mongo.databaseName");

			Builder builder = new MongoClientOptions.Builder();
			String perHost = properties.getProperty("mongo.connectionsPerHost");
			builder.connectionsPerHost(Integer.parseInt(perHost));
			builder.writeConcern(WriteConcern.SAFE);// WriteConcern.SAFE:抛出网络错误异常、服务器错误异常；并等待服务器完成写操作。

			String clientURI = properties.getProperty("mongo.uri");
			if (clientURI == null || "".equals(clientURI)) {
				throw new java.lang.IllegalArgumentException("mongo.uri 不能为空！");
			}

			MongoClientURI mongoClientURI = new MongoClientURI(clientURI,builder);
			INSTANCE.mongoClient = new MongoClient(mongoClientURI);
		} catch (Exception e) {
			throw new RuntimeException("load resource fail, uri:" + uri
					+ " errorMsg:" + e.getMessage(), e);
		} finally {
			if (inputStream != null) {
				try {
					inputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		System.out.println("MongoDb初始化＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝end");

	}

	/**
	 * 
	 * @Title getCollection
	 * @Description 获取指定数据库的指定表 
	 * @param dbName
	 *            数据库名称
	 * @param collName
	 *            表名称
	 * @return {@link }
	 * @since 2015年12月30日 下午3:13:37
	 */
	public MongoCollection<Document> getCollection(String dbName,String collName) {
		if (null == collName || "".equals(collName)) {
			return null;
		}
		if (null == dbName || "".equals(dbName)) {
			return null;
		}
		MongoCollection<Document> collection = mongoClient.getDatabase(dbName).getCollection(collName);
		return collection;
	}
	/**
	 * 
	 * @Title getDefaultCollection
	 * @Description 获取默认数据库表  
	 * @param collName	表名称
	 * @return 
	 * {@link }
	 * @since 2015年12月30日 下午4:08:40
	 */
	public MongoCollection<Document> getDefaultCollection(String collName) {
		if (null == collName || "".equals(collName)) {
			return null;
		}
		MongoCollection<Document> collection = mongoClient.getDatabase(DEFAULTDBNAME).getCollection(collName);
		return collection;
	}
	/**
	 * 
	 * @Title findById
	 * @Description 通过id查询  
	 * @param coll	表
	 * @param id	主键  mongodb默认主键名称为‘_id’ 无法修改
	 * @return 
	 * {@link }
	 * @since 2015年12月30日 下午3:25:39
	 */
	public Document findById(MongoCollection<Document> coll, String id) {
		ObjectId _idobj = null;
		try {
			_idobj = new ObjectId(id);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return coll.find(Filters.eq("_id", _idobj)).first();
	}
	/**
	 * 
	 * @Title find
	 * @Description 条件查询  
	 * @param coll	表
	 * @param filter	条件
	 * @return 
	 * {@link }
	 * @since 2015年12月30日 下午4:10:37
	 */
	public MongoCursor<Document> findByFilter(MongoCollection<Document> coll, Bson filter) {
        return coll.find(filter).iterator();
    }
	
	/**
	 * 
	 * @Title findByPage
	 * @Description 分页查询  
	 * @param coll	表
	 * @param filter	查询条件
	 * @param sort		排序条件  使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而-1是用于降序排列。
	 * @param pageNo	需要跳转页
	 * @param pageSize	每页大小
	 * @return 
	 * {@link }
	 * @since 2015年12月30日 下午5:52:43
	 */
	public MongoCursor<Document> findByPage(MongoCollection<Document> coll, Bson filter,Bson sort , int pageNo, int pageSize) {
		if(sort == null){
			sort = new BasicDBObject("_id", 1);
		}
        return coll.find(filter).sort(sort).skip((pageNo - 1) * pageSize).limit(pageSize).iterator();
    }
	
	/**
	 * 
	 * @Title getCount
	 * @Description 查询表中记录条数  
	 * @param coll	表
	 * @return 
	 * {@link }
	 * @since 2015年12月30日 下午4:44:47
	 */
    public int getCount(MongoCollection<Document> coll) {
        int count = (int) coll.count();
        return count;
    }
	
	/**
	 * 
	 * @Title deleteById
	 * @Description 通过id删除  
	 * @param coll	表
	 * @param id	mongodb 默认主键 ‘_id’
	 * @return 被删除的条数
	 * {@link }
	 * @since 2015年12月30日 下午3:36:14
	 */
	public int deleteById(MongoCollection<Document> coll, String id) {
        ObjectId _id = null;
        try {
            _id = new ObjectId(id);
        } catch (Exception e) {
            return 0;
        }
        Bson filter = Filters.eq("_id", _id);
        DeleteResult deleteResult = coll.deleteOne(filter);
        return (int) deleteResult.getDeletedCount();
    }
	/**
	 * 
	 * @Title deleteByFilter
	 * @Description 按条件删除  
	 * @param coll	表
	 * @param filter	条件
	 * @return 
	 * {@link }
	 * @since 2015年12月30日 下午4:16:00
	 */
	public int deleteByFilter(MongoCollection<Document> coll, Bson filter){
		DeleteResult deleteResult = coll.deleteMany(filter);
		return (int) deleteResult.getDeletedCount();
	}
	/**
	 * 
	 * @Title updateById
	 * @Description 通过Id修改  
	 * @param coll	表名称
	 * @param id	mongodb默认主键 ‘_id’
	 * @param newdoc	被修改后的对象
	 * @return 返回被修改的条数
	 * {@link }
	 * @since 2015年12月30日 下午3:44:05
	 */
	public int updateById(MongoCollection<Document> coll, String id, Document newdoc) {
        ObjectId _idobj = null;
        try {
            _idobj = new ObjectId(id);
        } catch (Exception e) {
            return 0;
        }
        Bson filter = Filters.eq("_id", _idobj);
        UpdateResult updateResult =coll.updateOne(filter, new Document(MongoOperation.SET.getOperStr(), newdoc));
        return (int)updateResult.getModifiedCount();
    }
	/**
	 * 
	 * @Title updateByFilter
	 * @Description 按条件修改  
	 * @param coll	表
	 * @param filter	条件
	 * @param newdoc	被修改后的对象
	 * @return 被修改的条数
	 * {@link }
	 * @since 2015年12月30日 下午4:35:28
	 */
	public int updateByFilter(MongoCollection<Document> coll,  Bson filter, Document newdoc){
		UpdateResult updateResult =coll.updateMany(filter, new Document(MongoOperation.SET.getOperStr(), newdoc));
        return (int)updateResult.getModifiedCount();
	}
	
	/**
	 * 
	 * @Title insertOne
	 * @Description 新增一个  
	 * @param coll	表
	 * @param document 需新增对象  若没有设置'_id' 则mongodb自动生成
	 * {@link }
	 * @since 2015年12月30日 下午4:41:54
	 */
	public void insertOne(MongoCollection<Document> coll, Document document){
		coll.insertOne(document);
	}
	
	/**
	 * 
	 * @Title insertMany
	 * @Description 新增多个  若没有设置'_id' 则mongodb自动生成
	 * @param coll	表
	 * @param documents	需新增对象 
	 * {@link }
	 * @since 2015年12月30日 下午4:43:35
	 */
	public void insertMany(MongoCollection<Document> coll, List<Document> documents){
		coll.insertMany(documents);
	}
	
	
}

上面的属于DAO层，一般不对外提供服务。通过MongoDbUtils对外提供服务，代码如下：

package com.my.mongodb;

import java.util.List;

import org.bson.Document;
import org.bson.conversions.Bson;

import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.my.mongodb.dao.MongoDbDao;

/**
 * @Title MongoDbClient.java
 * @Description MongoDb组件对外服务类
 * @author night
 * @date 2015年12月30日 下午3:59:46
 * @version V1.0  
 */
public class MongoDbUtils {
	/**
	 * 
	 * @Title getCollection
	 * @Description 获取指定数据库的指定表 
	 * @param dbName
	 *            数据库名称
	 * @param collName
	 *            表名称
	 * @return {@link }
	 * @since 2015年12月30日 下午3:13:37
	 */
	public static MongoCollection<Document> getCollection(String dbName,String collName) {
		return MongoDbDao.INSTANCE.getCollection(dbName, collName);
	}
	/**
	 * 
	 * @Title getDefaultCollection
	 * @Description 获取默认数据库表  
	 * @param collName	表名称
	 * @return 
	 * {@link }
	 * @since 2015年12月30日 下午4:08:40
	 */
	public static MongoCollection<Document> getDefaultCollection(String collName) {
		return MongoDbDao.INSTANCE.getDefaultCollection(collName);
	}
	/**
	 * 
	 * @Title findById
	 * @Description 通过id查询  
	 * @param collName	表名
	 * @param id	主键  mongodb默认主键名称为‘_id’ 无法修改
	 * @return 
	 * {@link }
	 * @since 2015年12月30日 下午3:25:39
	 */
	public static Document findById(String collName, String id) {
		MongoCollection<Document> coll = getDefaultCollection(collName);
		return MongoDbDao.INSTANCE.findById(coll, id);
	}
	/**
	 * 
	 * @Title find
	 * @Description 条件查询  
	 * @param collName	表名
	 * @param filter	条件
	 * @return 
	 * {@link }
	 * @since 2015年12月30日 下午4:10:37
	 */
	public static MongoCursor<Document> findByFilter(String collName, Bson filter) {
		MongoCollection<Document> coll = getDefaultCollection(collName);
        return MongoDbDao.INSTANCE.findByFilter(coll, filter);
    }
	
	/**
	 * 
	 * @Title findByPage
	 * @Description 分页查询  
	 * @param collName	表名
	 * @param filter	查询条件
	 * @param sort		排序条件  使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而-1是用于降序排列。
	 * @param pageNo	需要跳转页
	 * @param pageSize	每页大小
	 * @return 
	 * {@link }
	 * @since 2015年12月30日 下午5:52:43
	 */
	public static MongoCursor<Document> findByPage(String collName, Bson filter,Bson sort , int pageNo, int pageSize) {
		MongoCollection<Document> coll = getDefaultCollection(collName);
        return MongoDbDao.INSTANCE.findByPage(coll, filter, sort, pageNo, pageSize);
    }
	
	/**
	 * 
	 * @Title getCount
	 * @Description 查询表中记录条数  
	 * @param collName	表名
	 * @return 
	 * {@link }
	 * @since 2015年12月30日 下午4:44:47
	 */
    public static int getCount(String collName) {
    	MongoCollection<Document> coll = getDefaultCollection(collName);
        return MongoDbDao.INSTANCE.getCount(coll);
    }
	
	/**
	 * 
	 * @Title deleteById
	 * @Description 通过id删除  
	 * @param collName	表名
	 * @param id	mongodb 默认主键 ‘_id’
	 * @return 被删除的条数
	 * {@link }
	 * @since 2015年12月30日 下午3:36:14
	 */
	public static int deleteById(String collName, String id) {
		MongoCollection<Document> coll = getDefaultCollection(collName);
        return MongoDbDao.INSTANCE.deleteById(coll, id);
    }
	/**
	 * 
	 * @Title deleteByFilter
	 * @Description 按条件删除  
	 * @param collName	表名
	 * @param filter	条件
	 * @return 
	 * {@link }
	 * @since 2015年12月30日 下午4:16:00
	 */
	public static int deleteByFilter(String collName, Bson filter){
		MongoCollection<Document> coll = getDefaultCollection(collName);
		return MongoDbDao.INSTANCE.deleteByFilter(coll, filter);
	}
	/**
	 * 
	 * @Title updateById
	 * @Description 通过Id修改  
	 * @param collName	表名称
	 * @param id	mongodb默认主键 ‘_id’
	 * @param newdoc	被修改后的对象
	 * @return 返回被修改的条数
	 * {@link }
	 * @since 2015年12月30日 下午3:44:05
	 */
	public static int updateById(String collName, String id, Document newdoc) {
		MongoCollection<Document> coll = getDefaultCollection(collName);
        return MongoDbDao.INSTANCE.updateById(coll, id, newdoc);
    }
	/**
	 * 
	 * @Title updateByFilter
	 * @Description 按条件修改  
	 * @param collName	表名称
	 * @param filter	条件
	 * @param newdoc	被修改后的对象
	 * @return 被修改的条数
	 * {@link }
	 * @since 2015年12月30日 下午4:35:28
	 */
	public static int updateByFilter(String collName,  Bson filter, Document newdoc){
		MongoCollection<Document> coll = getDefaultCollection(collName);
        return MongoDbDao.INSTANCE.updateByFilter(coll, filter, newdoc);
	}
	
	/**
	 * 
	 * @Title insertOne
	 * @Description 新增一个  
	 * @param collName	表名称
	 * @param document 需新增对象  若没有设置'_id' 则mongodb自动生成
	 * {@link }
	 * @since 2015年12月30日 下午4:41:54
	 */
	public static void insertOne(String collName, Document document){
		MongoCollection<Document> coll = getDefaultCollection(collName);
		MongoDbDao.INSTANCE.insertOne(coll, document);;
	}
	
	/**
	 * 
	 * @Title insertMany
	 * @Description 新增多个  若没有设置'_id' 则mongodb自动生成
	 * @param collName	表名
	 * @param documents	需新增对象 
	 * {@link }
	 * @since 2015年12月30日 下午4:43:35
	 */
	public static void insertMany(String collName, List<Document> documents){
		MongoCollection<Document> coll = getDefaultCollection(collName);
		MongoDbDao.INSTANCE.insertMany(coll, documents);
	}
}

定义MongbDB操作符及查询符

package com.my.mongodb.enums;
/**
 * 
 * @Title MongoOperation.java
 * @Description MongoDb操作符
 * @author night
 * @date 2015年12月30日 下午4:32:05
 * @version V1.0
 */
public enum MongoOperation {

	INC("$inc","增加或插入"),
	SET("$set","设置或新建"),
	UNSET("$unset","$set的反操作"),
	PUSH("$push","元素追加数组末尾"),
	PUSHALL("$pushAll","$push的批量操作版"),
	ADDTOSET("$addToSet","同$push,但会过滤重复元素"),
	POP("$pop","{$pop : {key : 1}}——从数组末尾移除元素 {$pop : {key : -1}}——从数组开头移除元素"),
	PULL("$pull","从数组中移除所有匹配的元素"),
	PULLALL("$pullALL","$pull的批量操作版本"),
	RENAME("$rename","修改指定键的键名"),
	BIT("$bit","对整形的键值执行位操作‘与’，‘或’等");
	
	
	private String operStr;
	private String mean;
	
	private MongoOperation(String operStr,String mean){
		this.operStr=operStr;
		this.mean=mean;
	}

	public String getOperStr() {
		return operStr;
	}

	public void setOperStr(String operStr) {
		this.operStr = operStr;
	}

	public String getMean() {
		return mean;
	}

	public void setMean(String mean) {
		this.mean = mean;
	}
	
}

package com.my.mongodb.enums;
/**
 * 
 * @Title Seach.java
 * @Description 查询操作符  可参考https://docs.mongodb.org/v3.0/reference/operator/query/
 * @author night
 * @date 2016年1月12日 下午3:29:55
 * @version V1.0
 */
public enum Seach {
	LT("$lt","小于-->{ a : { $gt: value } }"),
	LTE("$lte","小于等于"),
	GT("$gt","大于"),
	GTE("$gte","大于等于"),
	ALL("$all","数组中的元素是否完全匹配-->{ a: { $all: [ 2, 3 ] } }"),
	EXISTS("$exists","可选:true,false-->{ a : { $exists : true } }"),
	MOD("$mod","取模:a % 10 == 1 -->{ a : { $mod : [ 10 , 1 ] } }"),
	NE("$ne","取反:即not equals -->{ x : { $ne : 3 } }"),
	EQ("$eq","类似equals-->db.inventory.find( { qty: { $eq: 20 } } )"),
	IN("$in","类似于SQL的IN操作-->{j:{$in: [2,4,6]}}"),
	NIN("$nin","$in的反操作,即SQL的 NOT IN-->{j:{$nin: [2,4,6]}}"),
	NOR("$nor","$or的反操作,即不匹配(a或b)-->{ name : 'bob' , $nor : [ { a : 1 } , { b : 2 } ] }"),
	OR("$or","Or子句,注意$or不能嵌套使用-->{ name : 'bob' , $or : [ { a : 1 } , { b : 2 } ] }"),
	SIZE("$size","匹配数组长度-->{ a : { $size: 1 } }"),
	TYPE("$type","匹配子键的数据类型-->{ a : { $type : 2 } }"),
	NOT("$not","$not执行逻辑NOT运算，选择出不能匹配表达式的文档 ，包括没有指定键的文档-->{ amount: { $not: { $gt: 50 } } }");

	private String operStr;
	private String mean;
	
	private Seach(String operStr,String mean){
		this.operStr=operStr;
		this.mean=mean;
	}

	public String getOperStr() {
		return operStr;
	}

	public void setOperStr(String operStr) {
		this.operStr = operStr;
	}

	public String getMean() {
		return mean;
	}

	public void setMean(String mean) {
		this.mean = mean;
	}
}

四、使用说明

（1) 假设RequestData为需要存入的对象   对实体bean要求如下

package com.mongdb.entity;

import java.util.Date;

import org.bson.Document;
import org.bson.types.ObjectId;

/**
 * @Title RequestData.java
 * @Description TODO
 * @author night
 * @date 2015年12月29日 下午4:06:14
 * @version V1.0  
 */
public class RequestData {
	/**
	 * Mongodb主键  id类型不可改
	 */
	
	private ObjectId id;
	
	private String cardNo;
	
	private String cardPwd;
	
	private Date firstDate;
	//转换为toDocument 在新增和修改时都需要转换  新增和修改的对象都是Document
	
	public Document toDocument(RequestData requestData){
		Document document =  new Document();
		document.put("cardNo", requestData.getCardNo());
		document.put("cardPwd", requestData.getCardPwd());
		document.put("firstDate", requestData.getFirstDate());
		return document;
	}
	//转换为实体bean  查询结果为Document  若想用该bean则需要转换
	public void toRequestData(Document document){
		this.setId(document.getObjectId("_id"));
		this.setCardNo(document.getString("cardNo"));
		this.setCardPwd(document.getString("cardPwd"));
		this.setFirstDate(document.getDate("firstDate"));
	}

	/**
	 * @return the id
	 */
	public ObjectId getId() {
		return id;
	}

	/**
	 * @param id the id to set
	 */
	public void setId(ObjectId id) {
		this.id = id;
	}

	/**
	 * @return the cardNo
	 */
	public String getCardNo() {
		return cardNo;
	}

	/**
	 * @param cardNo the cardNo to set
	 */
	public void setCardNo(String cardNo) {
		this.cardNo = cardNo;
	}

	/**
	 * @return the cardPwd
	 */
	public String getCardPwd() {
		return cardPwd;
	}

	/**
	 * @param cardPwd the cardPwd to set
	 */
	public void setCardPwd(String cardPwd) {
		this.cardPwd = cardPwd;
	}

	/**
	 * @return the firstDate
	 */
	public Date getFirstDate() {
		return firstDate;
	}

	/**
	 * @param firstDate the firstDate to set
	 */
	public void setFirstDate(Date firstDate) {
		this.firstDate = firstDate;
	}
	
	
	
}

（2）增删改查：(mongodb.properties配置中的数据库若不存在，则会自动创建，下面所有“student” 为表名称，若表不存在，也会自动创建)  直接使用MongoDbUtils.XXX进行调用即可

 新增：

     新增方法如下：

     void insertOne(String collName, Document document)；//新增单条 collName 表名   document需要保存的对象

       void insertMany(String collName, List<Document> documents)；//入库多条  

具体示例如下：

public String add(@ModelAttribute RequestData data){

//入库之前需先转换为document

Document document = data.toDocument(data);

MongoDbUtils.insertOne("student", document);//入库单条   

//Bson filter = Filters.ne("_id", "-12");不等于

//Bson filter = Filters.eq("_id", "-12");等于

//String[] items = {"1","3","4"};

//Bson filter = Filters.in("cardNo", items);查询卡号分别为 1，3 ，4的数据

//查询当前五分钟之内的数据   firstDate在mongodb中是直接以Date类型存储的   此处注意Filters.and的用法  可以同时包含多个条件

Date date = new Date();

date.setMinutes(-5);

Bson filter = Filters.and(Filters.lte("firstDate", new Date()),Filters.gte("firstDate", date));

MongoCursor<Document> result = MongoDbUtils.findByFilter("student", filter);//条件查询

List<RequestData> listData = new ArrayList<RequestData>();

while (result.hasNext()) {

Document document=result.next();

RequestData requestData=new RequestData();

requestData.toRequestData(document);//将查询结果Document转换为实体bean 

listData.add(requestData);

}

modelMap.put("listData", listData);

return "result";

}

@RequestMapping(value = "/del")

public String del(String id){

int delCount  = MongoDbUtils.deleteById("student", id);

System.out.println("删除条数：" + delCount);

return "redirect:/queryAll";

@RequestMapping(value="/modify")

public String modify(@ModelAttribute RequestData data,ModelMap model){

System.out.println("要修改的数据id：" + data.getId());

data.setFirstDate(new Date());//设置最后修改时间

Document newDocument = data.toDocument(data);//将bean转换为 Document

int updateCount = MongoDbUtils.updateById("student", data.getId().toString(), newDocument);//按id修改

System.out.println("修改条数：" + updateCount);

return "redirect:/queryAll";

}

或者直接看我测试的的Controller类 类似于Strus2的action

package com.mongdb.controller;

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

import org.bson.Document;
import org.bson.conversions.Bson;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;

import com.mongdb.entity.RequestData;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.model.Filters;
import com.my.mongodb.MongoDbUtils;
import com.my.mongodb.dao.MongoDbDao;

/**
 * @Title MongdbController.java
 * @Description TODO
 * @author night
 * @date 2015年12月29日 下午3:39:37
 * @version V1.0  
 */
@Controller
public class MongdbController {
	private int pageSize = 2;
	
	@RequestMapping(value = "/add")
	public String add(@ModelAttribute RequestData data){
//		 Map<String, String> map = System.getenv();  
//	        for(Iterator<String> itr = map.keySet().iterator();itr.hasNext();){  
//	            String key = itr.next();  
//	            System.out.println(key + "=" + map.get(key));  
//	        }     
//	        
//	    System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"); 
//	    Properties p =  System.getProperties();
//	    for(Iterator<Object> itr = p.keySet().iterator();itr.hasNext();){  
//            String key = (String) itr.next();  
//            System.out.println(key + "=" + p.get(key));  
//        }  
		data.setFirstDate(new Date());
		Document document = data.toDocument(data);
		MongoDbUtils.insertOne("student", document);
		return "redirect:/queryAll";
	}
	@RequestMapping(value = "/queryAll")
	public String queryAll(ModelMap modelMap){
//一种查询方式		
//		Document filter =new Document();
//		filter.append(Seach.NE.getOperStr(), "-12");
//		Document seachDocument=new Document();
//		seachDocument.put("_id", filter);

		//另一种查询方式
		//Bson filter = Filters.ne("_id", "-12");不等于
		//Bson filter = Filters.eq("_id", "-12");等于
		//查询卡号分别为 1，3 ，4的数据
		//String[] items = {"1","3","4"};
		//Bson filter = Filters.in("cardNo", items);
		//查询当前五分钟之内的数据   firstDate在mongodb中是直接以Date类型存储的
		Date date = new Date();
		date.setMinutes(-5);
		System.out.println(date.toLocaleString());
		Bson filter = Filters.and(Filters.lte("firstDate", new Date()),Filters.gte("firstDate", date));
		MongoCursor<Document> result = MongoDbUtils.findByFilter("student", filter);
		List<RequestData> listData = new ArrayList<RequestData>();
		int count = 0;
		System.out.println("--》第" + count +"条");
		while (result.hasNext()) {
			count++;
			System.out.println("第" + count +"条");
			Document document=result.next();
			RequestData requestData=new RequestData();
			requestData.toRequestData(document);
			listData.add(requestData);
		}
		modelMap.put("listData", listData);
		return "result";
	}
	
	@RequestMapping(value = "/del")
	public String del(String id){
		System.out.println("需要删除数据id:" + id);
		
		
		int delCount  = MongoDbUtils.deleteById("student", id);
		System.out.println("删除条数：" + delCount);
		return "redirect:/queryAll";
	}
	
	@RequestMapping(value="/update")
	public String update(String id,ModelMap model){
		System.out.println("要修改的数据id：" + id);
		Document document = MongoDbUtils.findById("student", id);
		RequestData data = new RequestData();
		data.toRequestData(document);
		model.put("data", data);
		return "update";
	}
	
	@RequestMapping(value="/modify")
	public String modify(@ModelAttribute RequestData data,ModelMap model){
		System.out.println("要修改的数据id：" + data.getId());
		data.setFirstDate(new Date());
		Document newDocument = data.toDocument(data);
		int updateCount = MongoDbUtils.updateById("student", data.getId().toString(), newDocument);
		System.out.println("修改条数：" + updateCount);
		return "redirect:/queryAll";
	}
	
	@RequestMapping(value = "/query")
	public String query(int pageNo,ModelMap modelMap){
		System.out.println("去的页数：" + pageNo);
		Bson filter = Filters.ne("_id", "-12");
		MongoCursor<Document> result = MongoDbUtils.findByPage("student", filter, null, pageNo, pageSize);
		List<RequestData> listData = new ArrayList<RequestData>();
		int count = 0;
		System.out.println("--》第" + count +"条");
		while (result.hasNext()) {
			count++;
			System.out.println("第" + count +"条");
			Document document=result.next();
			RequestData requestData=new RequestData();
			requestData.toRequestData(document);
			listData.add(requestData);
		}
		modelMap.put("listData", listData);
		return "result";
	}
   	
}

MongoDB组件util

标签：

原文地址：http://blog.csdn.net/a355586533/article/details/51751040