spring使用mongodb数据库

一、spring配置mongo

<?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:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:p="http://www.springframework.org/schema/p"   
    xmlns:mongo="http://www.springframework.org/schema/data/mongo"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
            http://www.springframework.org/schema/beans/spring-beans-4.0.xsd 
            http://www.springframework.org/schema/tx 
            http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context-4.0.xsd
            http://www.springframework.org/schema/data/mongo  
            http://www.springframework.org/schema/data/mongo/spring-mongo.xsd"> 
    <!-- 引入定义JDBC连接的属性文件 -->
    <context:property-placeholder location="classpath:config/db.properties" ignore-unresolvable="true"/>

    <!-- 定义mongo对象，对应的是mongodb官方jar包中的Mongo，replica-set设置集群副本的ip地址和端口 -->
    <mongo:mongo id="mongo" replica-set="${mongo.hostport}">
        <!-- 一些连接属性的设置 -->
        <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 id="mongoDbFactory" mongo-ref="mongo" dbname="${mongo.databaseName}" /> 

    <!-- MongoDB GridFS Template 支持，操作mongodb存放的文件 -->
    <mongo:mapping-converter id="mongoConverter" db-factory-ref="mongoDbFactory"/>
    <bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate">
        <constructor-arg ref="mongoDbFactory"/>
        <constructor-arg ref="mongoConverter"/>
        <!-- 表名 <constructor-arg value="****" index="2" /> -->
    </bean>

    <!-- mongo模板操作对象 -->
    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory"/>
    </bean>

</beans>

二、数据库基本操作AbstractMongoDao

import java.io.InputStream;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import org.bson.types.ObjectId;
import org.springframework.beans.factory.annotation.Autowired;
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.data.mongodb.gridfs.GridFsTemplate;
import com.chhuang.mongo.core.bean.QueryBean;
import com.mongodb.gridfs.GridFSDBFile;
import com.mongodb.gridfs.GridFSFile;
public abstract class AbstractMongoDao<T> {

    public static final String KEY = "KeY";
    public static final String LIKE = ".*?KeY.*";
    public static final String NOT_EQUAL = "(?!KeY$).*";
    public static final String NOT_LIKE = "((?!KeY).)*";
    public static final String IGNORE_CASE = "i";
    public static final String ID = "_id";
    private Class<T> entityClass;
    protected Class<T> getEntityClass() {
        return entityClass;
    }
    /**
     * 通过反射获取子类确定的泛型类
     */
    @SuppressWarnings("unchecked")
    public AbstractMongoDao() {
        Type genType = getClass().getGenericSuperclass();
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
        entityClass = (Class<T>) params[0];
    }
    @Autowired
    protected MongoTemplate mongoTemplate;
    @Autowired
    protected GridFsTemplate gridFsTemplate;
    /**
     * 保存
     * 
     * @param entity
     * @return
     */
    public void save(T entity) {
        mongoTemplate.insert(entity);
    }
    /**
     * 保存或修改
     * 
     * @param entity
     * @return
     */
    public void saveOrUpdate(T entity) {
        mongoTemplate.save(entity);
    }
    /**
     * 根据id删除一条数据
     * 
     * @param id
     * @return
     */
    public boolean deleteById(ObjectId id) {
        Query query = new Query();
        query.addCriteria(Criteria.where(ID).is(id));
        return !mongoTemplate.remove(query, entityClass).isUpdateOfExisting();
    }
    /**
     * 删除一条数据
     * 
     * @param id
     * @return
     */
    public boolean delete(T t) {
        return !mongoTemplate.remove(t).isUpdateOfExisting();
    }

    /**
     * 删除满足条件的所有记录
     * 
     * @param query
     * @return
     */
    public boolean delete(Query query) {
        return !mongoTemplate.remove(query, entityClass).isUpdateOfExisting();
    }

    /**
     * 根据id更新一条记录
     * 
     * @param query
     * @param update
     */
    public boolean updateById(ObjectId id, Update update) {
        Query query = new Query();
        query.addCriteria(Criteria.where(ID).is(id));
        return mongoTemplate.updateFirst(query, update, entityClass).isUpdateOfExisting();
    }

    /**
     * 更新满足条件的第一个记录
     * 
     * @param query
     * @param update
     */
    public boolean updateFirst(Query query, Update update) {
        return mongoTemplate.updateFirst(query, update, entityClass).isUpdateOfExisting();
    }
    /**
     * 更新满足条件的所有记录
     * 
     * @param query
     * @param update
     */
    public boolean updateMulti(Query query, Update update) {
        return mongoTemplate.updateMulti(query, update, entityClass).isUpdateOfExisting();
    }
    /**
     * 查找更新,如果没有找到符合的记录,则将更新的记录插入库中
     * 
     * @param query
     * @param update
     */
    public boolean updateInser(Query query, Update update) {
        return mongoTemplate.upsert(query, update, entityClass).isUpdateOfExisting();
    }
    /**
     * 根据id查询一条数据
     * 
     * @param id
     * @return
     */
    public T findById(ObjectId id) {
        return mongoTemplate.findById(id, entityClass);
    }

    /**
     * 查找满足条件的第一条记录
     * 
     * @param query
     * @return
     */
    public T findOne(Query query) {
        return mongoTemplate.findOne(query, entityClass);
    }

    /**
     * 查找满足条件的集合
     * 
     * @param query
     * @return
     */
    public List<T> findList(Query query){
        return mongoTemplate.find(query, entityClass);
    }

    /**
     * 分页查询
     * 
     * @param query
     * @param start
     * @param size
     * @return
     */
    public List<T> pagination(Query query, int start, int size) {
        query.skip(start);
        query.limit(size);
        return mongoTemplate.find(query, entityClass);
    }

    /**
     * 统计数量
     * 
     * @param query
     * @return
     */
    public Long count(Query query) {
        return mongoTemplate.count(query, entityClass);
    }

    /**
     * 分页查询
     * 
     * @param queryBean
     * @return
     */
    public QueryBean<T> pagination(QueryBean<T> queryBean) {
        Query query = queryBean.getQuery();
        long count = count(query);
        queryBean.setItemCount(count);
        if(count>0){
            int start = 0 ,size = 0;
            if (queryBean.getPageNum() > 0 && queryBean.getPageSize() > 0) {
                start = (queryBean.getPageNum() - 1) * queryBean.getPageSize();
                size = queryBean.getPageSize();
                queryBean.setPageCount(count / size + (count % size > 0 ? 1 : 0));
            }
            queryBean.setResults(pagination(query, start, size));
        }
        return queryBean;
    }

    /**
     * 保存文件
     * 
     * @param content
     * @param filename
     * @return
     */
    public GridFSFile saveFile(InputStream content, String filename,
            String contentType) {
        return gridFsTemplate.store(content, filename, contentType);
    }

    /**
     * 根据id删除文件
     * 
     * @param query
     */
    public void deleteFileById(Object id){
        Query query = new Query();
        query.addCriteria(Criteria.where(ID).is(id));
        gridFsTemplate.delete(query);
    }

    /**
     * 删除满足条件的文件
     * 
     * @param query
     */
    public void deleteFile(Query query){
        gridFsTemplate.delete(query);
    }
    /**
     * 根据id查询文件
     * 
     * @param id
     * @return
     */
    public GridFSDBFile findFileById(Object id) {
        Query query = new Query();
        query.addCriteria(Criteria.where(ID).is(id));
        return gridFsTemplate.findOne(query);
    }

    /**
     * 查询满足条件的第一个文件
     * 
     * @param query
     * @return
     */
    public GridFSDBFile findOneFile(Query query){
        return gridFsTemplate.findOne(query);
    }

    /**
     * 查询满足条件的所有文件
     * 
     * @param query
     * @return
     */
    public List<GridFSDBFile> findFiles(Query query){
        return gridFsTemplate.find(query);
    }
}