Spirng中Mongodb中配置实战

pom.xml

<java.version>1.8</java.version>
<rabbitMQ.version>3.5.1</rabbitMQ.version>
<spring.version>4.1.7.RELEASE</spring.version>
<mongodb.version>1.8.0.RELEASE</mongodb.version>

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-mongodb</artifactId>
    <version>${mongodb.version}</version>
</dependency>
<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongo-java-driver</artifactId>
    <version>3.1.0</version>
</dependency>

spring-mongodb.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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.xsd
        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.xsd
    ">

    <!-- 获取配置资源 -->
    <mongo:mongo-client id="mongoClient"  host="${mongo.host}" port="${mongo.port}">
        <mongo:client-options
                connections-per-host="${mongo.connectionsPerHost}"
                min-connections-per-host="${mongo.minConnectionsPerHost}"
                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}"
                description="${mongo.description}"
                max-connection-idle-time="${mongo.maxConnectionIdleTime}"
                max-connection-life-time="${mongo.maxConnectionLifeTime}"
                heartbeat-socket-timeout="${mongo.heartbeatSocketTimeout}"
                heartbeat-connect-timeout="${mongo.heartbeatConnectTimeout}"
                min-heartbeat-frequency="${mongo.minHeartbeatFrequency}"
                heartbeat-frequency="${mongo.heartbeatFrequency}"

                />
    </mongo:mongo-client>

    <mongo:db-factory id="mongoDbFactory"
                      dbname="${mongo.defaultDbName}"
                      mongo-ref="mongoClient"
                      write-concern="NORMAL" />
    <!-- 1.Spring提供的mongodb操作模板-->
    <!--首先列一下WriteConcern的几种抛出异常的级别参数：
  WriteConcern.NONE:没有异常抛出
  WriteConcern.NORMAL:仅抛出网络错误异常，没有服务器错误异常
  WriteConcern.SAFE:抛出网络错误异常、服务器错误异常；并等待服务器完成写操作。
  WriteConcern.MAJORITY: 抛出网络错误异常、服务器错误异常；并等待一个主服务器完成写操作。
  WriteConcern.FSYNC_SAFE: 抛出网络错误异常、服务器错误异常；写操作等待服务器将数据刷新到磁盘。
  WriteConcern.JOURNAL_SAFE:抛出网络错误异常、服务器错误异常；写操作等待服务器提交到磁盘的日志文件。
  WriteConcern.REPLICAS_SAFE:抛出网络错误异常、服务器错误异常；等待至少2台服务器完成写操作。 -->
    <mongo:template id="mongoTemplate" db-factory-ref="mongoDbFactory" write-concern="NORMAL" ></mongo:template>

    <!-- MongoDB GridFS Template 支持，操作mongodb存放的文件 -->
    <!--<mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory" base-package="com.mongodb"/>-->
    <!--<mongo:gridFsTemplate id="gridFsTemplcate" db-factory-ref="mongoDbFactory" converter-ref="converter" />-->
    <!-- mongodb bean的仓库目录，会自动扫描扩展了MongoRepository接口的接口进行注入 -->
    <mongo:repositories base-package="com.mongo" />
</beans>

mongodb.properties

#mongoDB连接配置
mongo.host=192.168.2.201
mongo.port=27017
mongo.defaultDbName=log
mongo.user=root
mongo.pwd=123456
mongo.connectionsPerHost=10
mongo.threadsAllowedToBlockForConnectionMultiplier=5
mongo.minConnectionsPerHost=5
#连接超时时间
mongo.connectTimeout=10000
#等待时间
mongo.maxWaitTime=120000
#Socket超时时间
mongo.socketTimeout=10000
mongo.socketKeepAlive=true

mongo.description=test mongodb database
mongo.maxConnectionIdleTime=1500
mongo.maxConnectionLifeTime=0
#mongo slave
mongo.heartbeatSocketTimeout=1000
mongo.heartbeatConnectTimeout=1500
mongo.minHeartbeatFrequency=5
mongo.heartbeatFrequency=10

实现接口

public interface MongoBase<T> {
    //添加 不用save ,id都是自动生成
    void insert(T object, String collectionName);


}

增删改查接口

public interface MongoDBSensorDataDao extends MongoBase<SensorData> {


    SensorDataMonth findOneSensorDataMonthById(String familyId, String uid, String deviceId,String month, String collectionName);

    int UpdateSensorDataMonthById(SensorDataMonth bean,String collectionName);


    SensorDataWeek findOneSensorDataWeekById(String familyId,String uid,String deviceId, String week,String collectionName);

    /**
     * 通过bean中familyId,  uid,  deviceId, week，更新
     * @param bean
     * @param collectionName
     * @return
     */
    int UpdateSensorDataWeekById(SensorDataWeek bean,String collectionName);
    /**
     * 执行SensorData 定时任务
     * @param from >=
     * @param to <=
     * @param collectionName
     */
    void executeSensorDataByDiffDay(Date from, Date to,String collectionName);

    Page<SensorDataDay> headsensorDataDayList(SensorDataParam bean, String collectionName);

    Page<SensorDataWeek> headsensorDataWeekList(SensorDataParam bean, String collectionName);

    Page<SensorDataMonth> headsensorDataMonthList(SensorDataParam bean, String collectionName);

}

实现类

package com.mongo.dao.impl;

import com.common.Logging;
import com.constants.MongConstants;
import com.mongo.dao.MongoDBSensorDataDao;
import com.mongo.entity.*;
import com.mongodb.WriteConcern;
import com.mongodb.WriteResult;
import com.param.SensorDataParam;
import com.utils.DateUtil;
import com.utils.Tools;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.domain.*;
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.Repository;

import javax.annotation.Resource;
import java.util.Date;
import java.util.UUID;

/**
 * Created by admin on 2018/3/6.
 */

@Repository
public  class MongoDBSensorDataDaoImpl extends Logging implements MongoDBSensorDataDao {

    @Resource
    @Qualifier("mongoTemplate")
    private MongoTemplate mongoTemplate;

    @Override
    public void insert(SensorData object, String collectionName) {
        mongoTemplate.insert(object, collectionName);
    }


    @Override
    public SensorDataMonth findOneSensorDataMonthById(String familyId, String uid, String deviceId, String month, String collectionName) {
        Query query = new Query();
        Criteria criteria =  Criteria.where("familyId").is(familyId).and("uid").is(uid).and("deviceId").is(deviceId).and("month").is(month);
        query.addCriteria(criteria);

        logger.info("======criteria========{}", criteria.getCriteriaObject());
        return mongoTemplate.findOne(query, SensorDataMonth.class, collectionName);
    }

    @Override
    public int UpdateSensorDataMonthById(SensorDataMonth bean, String collectionName) {
        Query query = new Query();
        Criteria criteria =  Criteria.where("familyId").is(bean.getFamilyId()).and("uid").is(bean.getUid()).and("deviceId").is(bean.getDeviceId()).and("month").is(bean.getMonth());
        query.addCriteria(criteria);

        Update update = new Update();
        update.set("maxCO", bean.getMaxCO())
                .set("minCO", bean.getMinCO())
                .set("avgCO",bean.getAvgCO())
                .set("maxHCHO", bean.getMaxHCHO())
                .set("minHCHO",bean.getMinHCHO())
                .set("avgHCHO",bean.getAvgHCHO())
                .set("maxTemp",bean.getMaxTemp())
                .set("minTemp",bean.getMinTemp())
                .set("avgTemp",bean.getAvgTemp())
                .set("maxHumidity",bean.getMaxHumidity())
                .set("minHumidity",bean.getMinHumidity())
                .set("avgHumidity", bean.getAvgHumidity());

        logger.info("======UpdateSensorDataMonthById========{}", criteria.getCriteriaObject());
        mongoTemplate.setWriteConcern(WriteConcern.ACKNOWLEDGED);//返回回调值
        WriteResult writeResult = mongoTemplate.updateMulti(query, update, SensorDataMonth.class, collectionName);
        return writeResult.getN();
    }

    @Override
    public SensorDataWeek findOneSensorDataWeekById(String familyId, String uid, String deviceId,String week, String collectionName) {
        Query query = new Query();
        Criteria criteria =  Criteria.where("familyId").is(familyId).and("uid").is(uid).and("deviceId").is(deviceId).and("week").is(week);
        query.addCriteria(criteria);

        logger.info("======criteria========{}", criteria.getCriteriaObject());
        return mongoTemplate.findOne(query, SensorDataWeek.class, collectionName);
    }

    @Override
    public int UpdateSensorDataWeekById(SensorDataWeek bean, String collectionName) {
        Query query = new Query();
        Criteria criteria =  Criteria.where("familyId").is(bean.getFamilyId()).and("uid").is(bean.getUid()).and("deviceId").is(bean.getDeviceId()).and("week").is(bean.getWeek());
        query.addCriteria(criteria);

        Update update = new Update();
        update.set("maxCO", bean.getMaxCO())
                .set("minCO", bean.getMinCO())
                .set("avgCO",bean.getAvgCO())
                .set("maxHCHO", bean.getMaxHCHO())
                .set("minHCHO",bean.getMinHCHO())
                .set("avgHCHO",bean.getAvgHCHO())
                .set("maxTemp",bean.getMaxTemp())
                .set("minTemp",bean.getMinTemp())
                .set("avgTemp",bean.getAvgTemp())
                .set("maxHumidity",bean.getMaxHumidity())
                .set("minHumidity",bean.getMinHumidity())
                .set("avgHumidity", bean.getAvgHumidity());

        logger.info("======UpdateSensorDataWeekById========{}", criteria.getCriteriaObject());
        mongoTemplate.setWriteConcern(WriteConcern.ACKNOWLEDGED);
        WriteResult writeResult = mongoTemplate.updateMulti(query, update, SensorDataWeek.class, collectionName);
        return writeResult.getN();
    }

    @Override
    public void executeSensorDataByDiffDay(Date from, Date to,String collectionName) {

        Criteria criteria = Criteria.where("createTime").gte(from).andOperator(Criteria.where("createTime").lte(to));

        Aggregation agg = Aggregation.newAggregation(
                Aggregation.match(criteria),
                Aggregation.group("familyId", "uid", "deviceId")
                        .max("coConcentration").as("maxCO")
                        .min("coConcentration").as("minCO")
                        .avg("coConcentration").as("avgCO")
                        .max("hchoConcentration").as("maxHCHO")
                        .min("hchoConcentration").as("minHCHO")
                        .avg("hchoConcentration").as("avgHCHO")
                        .max("temperature").as("maxTemp")
                        .min("temperature").as("minTemp")
                        .avg("temperature").as("avgTemp")
                        .max("humidity").as("maxHumidity")
                        .min("humidity").as("minHumidity")
                        .avg("humidity").as("avgHumidity")

        );

        AggregationResults<SensorDataResult> aggRes = mongoTemplate.aggregate(agg, MongConstants.SENSORDATA_COL, SensorDataResult.class);
        aggRes.forEach(e -> {
            logger.info("resulet {}", e);

                SensorDataDay en = new SensorDataDay();
                en.setDeviceId(e.getDeviceId());
                en.setFamilyId(e.getFamilyId());
                en.setUid(e.getUid());

                en.setAvgCO(e.getAvgHCHO());
                en.setAvgHCHO(e.getAvgHCHO());
                en.setAvgHumidity(e.getAvgHumidity());
                en.setAvgTemp(e.getAvgTemp());
                en.setMaxCO(e.getMaxCO());
                en.setMaxHCHO(e.getMaxHCHO());
                en.setMaxHumidity(e.getMaxHumidity());
                en.setMaxTemp(e.getMaxTemp());
                en.setMinCO(e.getMinCO());
                en.setMinHCHO(e.getMinHCHO());
                en.setMinHumidity(e.getMinHumidity());
                en.setMinTemp(e.getMinTemp());

                en.setCreateTime(to);
                en.setDelFlag(0);
                en.setUpdateTime(to);
                en.setDay(DateUtil.getDatetoString(from, DateUtil.FORMAT_DATE_COMMON));
                en.setSensorDataDayId(Tools.getUUID());
                mongoTemplate.insert(e, collectionName);
            

        });
    }



    @Override
    public Page<SensorDataDay> headsensorDataDayList(SensorDataParam bean, String collectionName) {


        Sort sort = new Sort(Sort.Direction.DESC, "sequence");
        Pageable pageable = new PageRequest(bean.getPage(), bean.getSize(), sort);
        Query query = new Query();
        Criteria criteria = Criteria.where("familyId").is(bean.getFamilyId());

        if(bean.getMinSequence() != -1){
            criteria.and("sequence").gt(bean.getMinSequence());
        }
        if(bean.getMaxSequence() != -1){
            criteria.andOperator(Criteria.where("sequence").lt(bean.getMaxSequence()));
        }

        query.addCriteria(criteria);
        logger.info("criteria {}",criteria.getCriteriaObject());
        long total = mongoTemplate.count(query, SensorDataDay.class,collectionName);

        return new PageImpl(mongoTemplate.find(query.with(pageable), SensorDataDay.class,collectionName), pageable, total);

    }

  


}