package com.moral.monitor.listener;
|
|
import java.io.IOException;
|
import java.io.InputStreamReader;
|
import java.io.UnsupportedEncodingException;
|
import java.math.BigDecimal;
|
import java.text.SimpleDateFormat;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import javax.annotation.Resource;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.amqp.core.Message;
|
import org.springframework.amqp.core.MessageListener;
|
import org.springframework.amqp.rabbit.core.RabbitTemplate;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.core.io.ClassPathResource;
|
import org.springframework.data.mongodb.core.MongoTemplate;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.util.StringUtils;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONReader;
|
import com.alibaba.fastjson.TypeReference;
|
import com.moral.monitor.dao.JobDao;
|
import com.moral.monitor.dao.TaskDao;
|
import com.moral.monitor.entity.History;
|
import com.moral.monitor.entity.Sensor;
|
import com.moral.monitor.util.RedisUtil;
|
|
public class TaskListener implements MessageListener {
|
|
@Resource
|
RabbitTemplate rabbitTemplate;
|
|
@Resource
|
JobDao jobDao;
|
|
@Resource
|
TaskDao taskDao;
|
|
@Resource
|
RedisTemplate<String, String> redisTemplate;
|
|
@Resource
|
protected MongoTemplate mongoTemplate;
|
|
private Logger logger = LoggerFactory.getLogger(TaskListener.class);
|
|
@Override
|
public void onMessage(Message msg) {
|
|
String message = null;
|
try {
|
message = new String(msg.getBody(), "utf-8");
|
} catch (UnsupportedEncodingException e) {
|
logger.warn(e.getMessage());
|
}
|
|
Map<String, String> msgData = JSON.parseObject(message, new TypeReference<Map<String, String>>() {});
|
String mac = msgData.get("mac");
|
String ver = msgData.get("ver");
|
|
if(StringUtils.isEmpty(ver) || StringUtils.isEmpty(mac)) {
|
return;
|
}
|
|
Map<String, Float> adjustMap;
|
String adjust_key = "adjust_" + mac;
|
if(RedisUtil.hasKey(redisTemplate, adjust_key)) {
|
adjustMap = JSON.parseObject(RedisUtil.get(redisTemplate, adjust_key), new TypeReference<Map<String, Float>>() {});
|
} else {
|
adjustMap = getAdjustData(mac);
|
RedisUtil.set(redisTemplate, adjust_key, JSON.toJSONString(adjustMap));
|
}
|
|
if(!adjustMap.isEmpty()) {
|
for (Map.Entry<String, Float> entry : adjustMap.entrySet()) {
|
String key = entry.getKey();
|
if(msgData.containsKey(key)) {
|
Float value = entry.getValue();
|
Float dataValue = Float.valueOf(msgData.get(key)) ;
|
msgData.put(key, String.valueOf(dataValue + value));
|
}
|
}
|
}
|
|
// System.out.println(message);
|
// System.out.println(JSON.toJSONString(msgData));
|
|
rabbitTemplate.convertAndSend("monitors_data2", "", JSON.toJSONString(msgData).getBytes());
|
// rabbitTemplate.send("monitors_data_3", "", new Message(JSON.toJSONString(msgData).getBytes(), new MessageProperties()));
|
|
// int state = (new Random()).nextInt(4) % 5; //TODO
|
int state = detEquState(msgData);
|
// rabbitTemplate.convertAndSend("monitors_alarm", "", "{\"mac\": \"" + mac + "\", \"state\": " + state + "}");
|
|
//更新设备状态
|
jobDao.updateStateByMac(mac, state);
|
|
// //保存原始数据
|
// taskDao.insertTologger(mac, message, getDate());
|
mongoTemplate.insert(message, "logger");
|
|
//保存历史记录
|
List<History> histories = new ArrayList<History>();
|
List<Sensor> sensorList = taskDao.selectFromsensorByver(ver);
|
for (Sensor sensor : sensorList) {
|
String key = sensor.getMac_key();
|
if(msgData.containsKey(key)) {
|
//taskDao.insertTohistory(mac, sensor.getSensor(), key, msgData.get(key));
|
History history = new History();
|
history.setMac(mac);
|
history.setMac_key(key);
|
history.setTime(new Date(Long.parseLong(msgData.get("time"))));
|
history.setSensor(sensor.getSensor());
|
history.setMac_value(Double.valueOf(msgData.get(key)));
|
histories.add(history);
|
|
mongoTemplate.insert(JSON.toJSONString(history), "data");
|
}
|
}
|
jobDao.batchInsertHistory(histories);
|
|
//mongoTemplate.insert(JSON.toJSONString(histories), "data");
|
}
|
|
private Map<String, Float> getAdjustData(String mac) {
|
List<Map<String, String>> adjusts = jobDao.findAdjustByMac(mac);
|
Map<String, Float> dataMap = new HashMap<String, Float>();
|
for (int i = 0; i < adjusts.size(); i++) {
|
Map adjust = adjusts.get(i);
|
if(adjust.get("value") != null) {
|
String key = String.valueOf(adjust.get("key"));
|
String data = String.valueOf(adjust.get("value"));
|
BigDecimal value = new BigDecimal(data);
|
value.setScale(3, BigDecimal.ROUND_HALF_UP);
|
dataMap.put(key, value.floatValue());
|
}
|
}
|
return dataMap;
|
}
|
//三级警报值阀值
|
private static Map<String,Double[]> alarmLevles =new HashMap<String, Double[]>();
|
/*
|
* 设置三级警报阀值,把map数据结构转换成数组结构
|
*/
|
@Value(value= "system/alarmLevels.json")
|
public void setAlarmLevles(String path) throws IOException {
|
org.springframework.core.io.Resource resource = new ClassPathResource(path);
|
InputStreamReader reader=new InputStreamReader(resource.getInputStream());
|
JSONReader jsonReader = new JSONReader(reader);
|
//三级警报值阀值
|
Map<String,Map<String,Double>> alarmLevleMap= jsonReader.readObject(new TypeReference<Map<String,Map<String,Double>>>(){});
|
//将map转换成数组
|
for(String key:alarmLevleMap.keySet()) {
|
Map<String,Double> levels = alarmLevleMap.get(key);
|
double level1 = levels.get("level1");
|
double level2 = levels.get("level2");
|
double level3 = levels.get("level3");
|
//当三个值都为零时，不加入阀值
|
if(levels.get("enable")!=null&&levels.get("enable")==1) {
|
//三级警报数组
|
Double arr[] = {0.0,level1,level2,level3};
|
alarmLevles.put(key, arr);
|
}
|
}
|
}
|
//根据三级警报阀值，确定设备状态
|
private int detEquState(Map<String,String> data) {
|
int state = 0;
|
if(data!=null) {
|
for(String key:alarmLevles.keySet()) {
|
String value = data.get(key);
|
if(!StringUtils.isEmpty(value)) {
|
double val = Double.parseDouble(value);
|
//获取三级警报阀值
|
Double[] arr = alarmLevles.get(key);
|
for(int index = arr.length-1;index>0;index--) {
|
if(val>=arr[index]) {
|
//如果当前状态级别更高就取当前状态。否则保持之前状态
|
state = (index>state)?index:state;
|
break;
|
}
|
}
|
//当前状态到达最大级别不再遍历，跳出循环
|
if(state == (arr.length-1)) {
|
break;
|
}
|
}
|
}
|
}
|
return state;
|
}
|
private String getDate() {
|
Date d = new Date();
|
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
return formatter.format(d);
|
}
|
}
|
