- 所需Jar包
mongo-java-driver-3.3.0.jar spring-data-mongodb-1.10.15.RELEASE.jar - 配置mongodb.properties
mongo.hostport=127.0.0.1:27017 mongo.connectionsPerHost=8 mongo.threadsAllowedToBlockForConnectionMultiplier=4 mongo.connectTimeout=3000 mongo.maxWaitTime=1500 mongo.socketKeepAlive=true mongo.socketTimeout=30000 mongo.authDB=admin # 认证的数据库 mongo.username=admin mongo.password=123456 mongo.connectDB=project # 需要操作的数据库 - 配置mongodb.xml
<?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.xsd http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo-1.8.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <context:property-placeholder location="classpath:mongodb.properties" ignore-unresolvable="true" /> <mongo:mongo-client id="mongo" replica-set="${mongo.hostport}" credentials="${mongo.username}:${mongo.password}@${mongo.authDB}"> <mongo:client-options connections-per-host="${mongo.connectionsPerHost}" threads-allowed-to-block-for-connection-multiplier="${mongo.threadsAllowedToBlockForConnectionMultiplier}" connect-timeout="${mongo.connectTimeout}" max-wait-time="${mongo.maxWaitTime}" socket-keep-alive="${mongo.socketKeepAlive}" socket-timeout="${mongo.socketTimeout}" /> </mongo:mongo-client> <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate"> <constructor-arg ref="mongo" /> <constructor-arg name="databaseName" value="${mongo.connectDB}" /> </bean> </beans>
封装MongoTemplate常用方法
package com.sys.core.server;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.mongodb.core.CollectionOptions;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
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.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.WriteResult;
@Service
public class MongoService {
@Autowired
private MongoTemplate mongoTemplate;
/**
* =================================== db/Collection info
**/
/**
* 获取数据库信息
*
* @return
*/
public DB getDb() {
return mongoTemplate.getDb();
}
/**
* 获取数据库全部集合名称
*
* @return
*/
public Set<String> getCollectionNames() {
return mongoTemplate.getCollectionNames();
}
/**
* 获取数据库指定名称集合
*
* @param collectionName 集合名称
* @return
*/
public DBCollection getCollection(String collectionName) {
return mongoTemplate.getCollection(collectionName);
}
/**
* 获取数据库指定名称集合
*
* @param entityClass 集合映射实体
* @return
*/
public <T> DBCollection getCollection(Class<T> entityClass) {
String collectionName = mongoTemplate.getCollectionName(entityClass);
return mongoTemplate.getCollection(collectionName);
}
/**
* =================================== createCollection
**/
/**
* 创建集合
*
* @param <T>
* @param entityClass 集合映射实体
*/
public <T> DBCollection createCollection(Class<T> entityClass) {
return mongoTemplate.createCollection(entityClass);
}
/**
* 创建集合
*
* @param <T>
* @param entityClass 集合映射实体
* @param collectionOptions 指定有关内存大小及索引的选项
*/
public <T> DBCollection createCollection(Class<T> entityClass, CollectionOptions collectionOptions) {
DBCollection dbCollection = null;
if (ObjectUtils.isEmpty(collectionOptions)) {
dbCollection = mongoTemplate.createCollection(entityClass);
} else {
dbCollection = mongoTemplate.createCollection(entityClass, collectionOptions);
}
return dbCollection;
}
/**
* 创建集合
*
* @param <T>
* @param collectionName 集合名称
*/
public DBCollection createCollection(String collectionName) {
return mongoTemplate.createCollection(collectionName);
}
/**
* 创建集合
*
* @param <T>
* @param collectionName 集合名称
* @param collectionOptions 指定有关内存大小及索引的选项
*/
public <T> DBCollection createCollection(String collectionName, CollectionOptions collectionOptions) {
DBCollection collection = null;
if (ObjectUtils.isEmpty(collectionOptions)) {
collection = mongoTemplate.createCollection(collectionName);
} else {
collection = mongoTemplate.createCollection(collectionName, collectionOptions);
}
return collection;
}
/**
* =================================== removeCollection
**/
/**
* 删除集合
*
* @param entityClass 集合映射实体
*/
public <T> void removeCollection(Class<T> entityClass) {
mongoTemplate.dropCollection(entityClass);
}
/**
* 删除集合
*
* @param collectionName 集合名称
*/
public <T> void removeCollection(String collectionName) {
mongoTemplate.dropCollection(collectionName);
}
/**
* =================================== insert/save
**/
/**
* 新增
*
* @param obj 数据对象
*/
public void insert(Object obj) {
mongoTemplate.insert(obj);
}
/**
* 批量新增
*
* @param objectsToSave 数据对象集合
*/
public void insertAll(Collection<? extends Object> objectsToSave) {
mongoTemplate.insertAll(objectsToSave);
}
/**
* 保存数据对象
*
* @param obj 数据对象
*/
public void save(Object obj) {
mongoTemplate.save(obj);
}
/**
* 指定集合保存数据对象
*
* @param obj 数据对象
* @param collectionName 集合名
*/
public void save(Object obj, String collectionName) {
mongoTemplate.save(obj, collectionName);
}
/**
* =================================== update
**/
/**
* 指定集合 修改数据，且仅修改找到的第一条数据
*
* @param according 修改条件
* @param updateMap 修改内容
* @param collectionName 集合名
*/
public int updateFirst(Map<String, Object> according, Map<String, Object> updateMap, String collectionName) {
return update(according, updateMap, collectionName, false);
}
/**
* 指定集合 修改数据，且修改所找到的所有数据
*
* @param according 修改条件
* @param updateMap 修改内容
* @param collectionName 集合名
*/
public int updateMulti(Map<String, Object> according, Map<String, Object> updateMap, String collectionName) {
return update(according, updateMap, collectionName, true);
}
/**
* 指定集合 修改数据
*
* @param according 修改条件
* @param updateMap 修改内容
* @param collectionName 集合名
* @param multi 是否更新全部
*/
public int update(Map<String, Object> according, Map<String, Object> updateMap, String collectionName,
boolean multi) {
Query query = Query.query(criteriaDefinition(according));
Update update = new Update();
for (Map.Entry<String, Object> e : updateMap.entrySet()) {
update.set(e.getKey(), e.getValue());
}
WriteResult writeResult = update(query, update, collectionName, multi);
return writeResult.getN();
}
/**
* 指定集合 修改数据
*
* @param query 修改条件
* @param update 修改内容
* @param collectionName 集合名
* @param multi 是否更新全部
*/
public WriteResult update(Query query, Update update, String collectionName, boolean multi) {
WriteResult writeResult = null;
if (multi) {
writeResult = mongoTemplate.updateMulti(query, update, collectionName);
} else {
writeResult = mongoTemplate.updateFirst(query, update, collectionName);
}
return writeResult;
}
/**
* 指定集合 修改数据，且仅修改找到的第一条数据
*
* @param according 修改条件
* @param updateMap 修改内容
* @param entityClass 集合映射对象
*/
public <T> int updateFirst(Map<String, Object> according, Map<String, Object> updateMap, Class<T> entityClass) {
return update(according, updateMap, entityClass, false);
}
/**
* 指定集合 修改数据，且修改所找到的所有数据
*
* @param according 修改条件
* @param updateMap 修改内容
* @param entityClass 集合映射对象
*/
public <T> int updateMulti(Map<String, Object> according, Map<String, Object> updateMap, Class<T> entityClass) {
return update(according, updateMap, entityClass, true);
}
/**
* 指定集合 修改数据
*
* @param according 修改条件
* @param updateMap 修改内容
* @param entityClass 集合映射对象
* @param multi 是否更新全部
* @return
*/
public <T> int update(Map<String, Object> according, Map<String, Object> updateMap, Class<T> entityClass,
boolean multi) {
Query query = Query.query(criteriaDefinition(according));
Update update = new Update();
for (Map.Entry<String, Object> e : updateMap.entrySet()) {
update.set(e.getKey(), e.getValue());
}
WriteResult writeResult = update(query, update, entityClass, multi);
return writeResult.getN();
}
/**
* 指定集合 修改数据
*
* @param query 修改条件
* @param update 修改内容
* @param entityClass 集合映射对象
* @param multi 是否更新全部
*/
public <T> WriteResult update(Query query, Update update, Class<T> entityClass, boolean multi) {
WriteResult writeResult = null;
if (multi) {
writeResult = mongoTemplate.updateMulti(query, update, entityClass);
} else {
writeResult = mongoTemplate.updateFirst(query, update, entityClass);
}
return writeResult;
}
/**
* =================================== remove
**/
/**
* 根据数据对象中的id删除数据
*
* @param obj 数据对象
*/
public int remove(Object obj) {
WriteResult writeResult = mongoTemplate.remove(obj);
return writeResult.getN();
}
/**
* 指定集合 根据数据对象中的id删除数据
*
* @param obj 数据对象
* @param collectionName 集合名
*/
public int remove(Object obj, String collectionName) {
WriteResult writeResult = mongoTemplate.remove(obj, collectionName);
return writeResult.getN();
}
/**
* 根据key，value到指定集合删除数据
*
* @param according 删除条件
* @param collectionName 集合名
*/
public int remove(Map<String, Object> according, String collectionName) {
Query query = Query.query(criteriaDefinition(according));
WriteResult writeResult = mongoTemplate.remove(query, collectionName);
return writeResult.getN();
}
/**
* 根据key，value到指定集合删除数据
*
* @param query 删除条件
* @param collectionName 集合名
*/
public WriteResult remove(Query query, String collectionName) {
return mongoTemplate.remove(query, collectionName);
}
/**
* 根据key，value到指定集合删除数据
*
* @param according 删除条件
* @param entityClass 集合映射实体
*/
public <T> int remove(Map<String, Object> according, Class<T> entityClass) {
Query query = Query.query(criteriaDefinition(according));
WriteResult writeResult = mongoTemplate.remove(query, entityClass);
return writeResult.getN();
}
/**
* 根据key，value到指定集合删除数据
*
* @param query 删除条件
* @param entityClass 集合映射实体
*/
public <T> WriteResult remove(Query query, Class<T> entityClass) {
return mongoTemplate.remove(query, entityClass);
}
/**
* =================================== find
**/
/**
* 根据条件查询出所有结果集
*
* @param <T>
* @param according 查询条件
* @param entityClass 集合映射实体
* @return
*/
public <T> List<T> find(Map<String, Object> according, Class<T> entityClass) {
Query query = Query.query(criteriaDefinition(according));
return mongoTemplate.find(query, entityClass);
}
/**
* 根据条件分页查询出所有结果集，降序
*
* @param <T>
* @param according 查询条件
* @param pageIndex 当前页
* @param pageSize 每页显示
* @param sort 排序字段
* @param entityClass 集合映射实体
* @return
*/
public <T> List<T> find(Map<String, Object> according, int pageIndex, int pageSize, String sort,
Class<T> entityClass) {
Query query = Query.query(criteriaDefinition(according));
query.skip((pageIndex - 1) * pageSize);
query.limit(pageSize);
if (!StringUtils.isEmpty(sort)) {
query.with(new Sort(Direction.DESC, sort));
}
return mongoTemplate.find(query, entityClass);
}
/**
* 根据条件查询出所有结果集
*
* @param <T>
* @param query 查询条件
* @param entityClass 集合映射实体
* @return
*/
public <T> List<T> find(Query query, Class<T> entityClass) {
return mongoTemplate.find(query, entityClass);
}
/**
* 根据条件查询出所有结果集进行排序
*
* @param <T>
* @param according 查询条件
* @param entityClass 集合映射实体
* @param sort 排序字段
* @param direction 排序方式
* @return
*/
public <T> List<T> find(Map<String, Object> according, String sort, String direction, Class<T> entityClass) {
Query query = Query.query(criteriaDefinition(according));
if ("DESC".equalsIgnoreCase(direction)) {
query.with(new Sort(Direction.DESC, sort));
} else {
query.with(new Sort(Direction.ASC, sort));
}
return mongoTemplate.find(query, entityClass);
}
/**
* 根据条件查询出第一条数据
*
* @param <T>
* @param according 查询条件
* @param entityClass 集合映射实体
* @return
*/
public <T> T findOne(Map<String, Object> according, Class<T> entityClass) {
Query query = Query.query(criteriaDefinition(according));
return mongoTemplate.findOne(query, entityClass);
}
/**
* 根据条件查询出第一条数据
*
* @param <T>
* @param query 查询条件
* @param entityClass 集合映射实体
* @return
*/
public <T> T findOne(Query query, Class<T> entityClass) {
return mongoTemplate.findOne(query, entityClass);
}
/**
* 查询出所有结果集
*
* @param entityClass 数据对象
* @return
*/
public <T> List<T> findAll(Class<T> entityClass) {
return mongoTemplate.findAll(entityClass);
}
/**
* 根据id查询数据
*
* @param <T>
* @param id 查询id
* @param entityClass 集合映射实体
* @return
*/
public <T> T findById(Object id, Class<T> entityClass) {
return mongoTemplate.findById(id, entityClass);
}
/**
* =================================== count
**/
/**
* 根据指定条件统计数量
*
* @param according 条件
* @param entityClass 集合映射实体
* @return
*/
public <T> long count(Map<String, Object> according, Class<T> entityClass) {
Query query = Query.query(criteriaDefinition(according));
return mongoTemplate.count(query, entityClass);
}
/**
* 根据指定条件统计数量
*
* @param query 条件
* @param entityClass 集合映射实体
* @return
*/
public <T> long count(Query query, Class<T> entityClass) {
return mongoTemplate.count(query, entityClass);
}
/**
* 根据指定条件统计数量
*
* @param according 条件
* @param collectionName 集合名称
* @return
*/
public <T> long count(Map<String, Object> according, String collectionName) {
Query query = Query.query(criteriaDefinition(according));
return mongoTemplate.count(query, collectionName);
}
/**
* 根据指定条件统计数量
*
* @param query 条件
* @param collectionName 集合名称
* @return
*/
public <T> long count(Query query, String collectionName) {
return mongoTemplate.count(query, collectionName);
}
/**
* =================================== aggregation
**/
/**
* 聚合查询
*
* @param <T>
* @param aggregation 聚合
* @param collectionName 集合名称
* @param outputType 集合映射实体
* @return
*/
public <T> AggregationResults<T> aggregation(Aggregation aggregation, String collectionName, Class<T> outputType) {
AggregationResults<T> results = mongoTemplate.aggregate(aggregation, collectionName, outputType);
return results;
}
/**
* 聚合查询
*
* @param <T>
* @param aggregation 聚合
* @param outputType 集合映射实体
* @return
*/
public <T> AggregationResults<T> aggregation(Aggregation aggregation, Class<T> outputType) {
return mongoTemplate.aggregate(aggregation, outputType, outputType);
}
/**
* 条件定义
*
* @param according 条件
* @return
*/
public Criteria criteriaDefinition(Map<String, Object> according) {
if (CollectionUtils.isEmpty(according)) {
return null;
}
int i = 0;
Criteria criteria = null;
for (Map.Entry<String, Object> e : according.entrySet()) {
if (i == 0) {
criteria = Criteria.where(e.getKey()).is(e.getValue());
i++;
} else {
criteria.and(e.getKey()).is(e.getValue());
}
}
return criteria;
}
}
来源：oschina
链接：https://my.oschina.net/u/4057956/blog/4305414