cs

fengxiang

2017-10-25 50c85d94f82c0abad7b828e079ec8ba313a53f6a

 src/main/java/com/moral/monitor/listener/Listener.java

@@ -1,287 +1,28 @@
package com.moral.monitor.listener;



import com.moral.monitor.dao.TaskDao;

import com.moral.monitor.entity.*;

import com.moral.monitor.listener.message.Tomq;

import net.sf.json.JSONObject;

import org.apache.commons.lang3.StringUtils;

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 javax.annotation.Resource;

import java.io.UnsupportedEncodingException;

import java.math.BigDecimal;

import java.text.SimpleDateFormat;

import java.util.*;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;



import com.moral.monitor.dao.TaskDao;



/*不报警版本*/

@Component

public class Listener implements MessageListener {

    @Resource

    @Autowired

    RabbitTemplate rabbitTemplate;

    @Resource

    TaskDao taskDao;

//    @Autowired

//    Lo

    private Logger logger = LoggerFactory.getLogger(Listener.class);

    public void onMessage(Message message) {



        logger.warn("正在运行的线程名称=" + Thread.currentThread().getName());



        String receiveMsg = null;

        try {

            receiveMsg = new String(message.getBody(), "utf-8");

        } catch (UnsupportedEncodingException e) {

            logger.warn(e.getMessage());

        }



        logger.warn(receiveMsg);

        Map<String, String> receiveMsgMap = toMap(receiveMsg);

        String mac = receiveMsgMap.remove("mac");

        String ver = receiveMsgMap.remove("ver");

        String rtime = receiveMsgMap.remove("time");

        String win = receiveMsgMap.remove("win");

        removeNotNumber(receiveMsgMap);

        String date = getDate(); //logger，noticelog使用

        Equipment equipment = taskDao.selectFromequipment(mac);

        if (equipment==null) {

            logger.warn("设备" + mac + "不在设备表中");

            return;

        }

        //设置设备在线状态4

        if (equipment.getState()==0) {

            taskDao.updateequipmentstate(4, mac);

        }

        //eX和传感器的映射关系,根据设备版本号动态产生

        Map<String, String> exsensorMap = exSensortoMap(ver);

        taskDao.insertTologger(mac, receiveMsg, date);

        //获取设备已绑定的传感器

        Map<String, String> bindsensor = macBindSensor(mac);

        if (bindsensor.size()<=0) {

            logger.warn("设备" + mac + "没有绑定任何传感器");

            return;

        }else {

            removeNotBind(receiveMsgMap,exsensorMap,bindsensor);

        }





        //为绑定传感器产生历史和即时数据

        List<State> states = taskDao.findstateBymac(mac);

        updateOrinsertstate(receiveMsgMap, mac, exsensorMap);

        if (states.size()==0){

            insertTohistory(receiveMsgMap, mac, exsensorMap);

        } else {

            insertTohistoryDistinct(receiveMsgMap,mac,exsensorMap,states);

        }





        //查找临界值表

        List<Critical> criticals = taskDao.findcritical();

        LinkedHashMap<String, Critical> sensor_criticals = new LinkedHashMap<String, Critical>();

        for (Critical c:criticals){

            String sensor = c.getSensor();

            sensor_criticals.put(sensor,c);

        }



        //查找此设备已绑定的传感器，超标判断

        //维护设备报警级别

        List<Integer> level = new ArrayList<Integer>();

        Set<Map.Entry<String, String>> entries = receiveMsgMap.entrySet();

        Iterator<Map.Entry<String, String>> iterator = entries.iterator();

        while (iterator.hasNext()){

            Map.Entry<String, String> next = iterator.next();

            String mac_key = next.getKey();

            String mac_value = next.getValue();

            String sensor = exsensorMap.get(mac_key);

            double value =Double.parseDouble(mac_value);

            //取出此传感器的 临界值对象

            Critical critical = sensor_criticals.get(sensor);



            int sensor_level = 0;

            if (value >= critical.getFirst()) {

                level.add(1);

                sensor_level =1;

            } else if (value >= critical.getSecond()) {

                level.add(2);

                sensor_level = 2;

            } else if (value >= critical.getThird()) {

                level.add(3);

                sensor_level = 3;

            }



            if(sensor_level!=0){

                String alarmMsg = "{\"mac\":\"" + mac + "\",\"" +mac_key + "\":" + value + ",\"level\":" + sensor_level + "}";

                Tomq tomq = new Tomq(rabbitTemplate, alarmMsg);

                tomq.run();

            }



        }



        //更新设备状态

        if (!(level.size() > 0)) {

            taskDao.updateequipmentstate(4, mac);//用户角度没有报警就是正常

            return;

        }



        Integer maxlevel = Collections.max(level);

        taskDao.updateequipmentstate(maxlevel, mac);

        
    }









    private String getDate() {

        Date d = new Date();

        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        return formatter.format(d);

    }



    private void saveNotice(Equipment equipment, User u, AlarmSensor sensor, String alarm_content, String noticetype, int sensor_level, String date) {

        taskDao.insertTonoticelog(u.getId(), u.getName(), noticetype, equipment.getMac(), equipment.getName(), alarm_content, sensor.getSensor(), equipment.getAddress(), sensor_level, date);

    }



    public String digit(double num, int digit) {

        BigDecimal y = new BigDecimal(num);

        double b = y.setScale(digit, BigDecimal.ROUND_HALF_UP).doubleValue();

        double c = b - (int) b;

        if (c == 0) {

            return String.valueOf((int) b);

        } else {

            return String.valueOf(b);

        }

    }



    private void updateOrinsertstate(Map<String, String> receiveMsgMap, String mac, Map<String, String> exsensorMap) {

        Set<Map.Entry<String, String>> entries = receiveMsgMap.entrySet();

        Iterator<Map.Entry<String, String>> iterator = entries.iterator();

        while (iterator.hasNext()) {

            Map.Entry<String, String> next = iterator.next();

            String mac_key = next.getKey();

            String mac_value = next.getValue();

            String sensor = exsensorMap.get(mac_key);

                List<State> states = taskDao.selectFromstate(mac, mac_key);//防止并发时一个传感器会有多条

                if (states.size() == 0) {

                    taskDao.insertTostate(mac, sensor, mac_key, mac_value);

                } else if (states.size() == 1) {

                    taskDao.updatestate(mac_value, mac, mac_key);

                } else if (states.size() >= 2) {

                    taskDao.deleteFromstateBymacandmackey(mac, mac_key);

                    taskDao.insertTostate(mac, sensor, mac_key, mac_value);

                }



        }

    }







    private void insertTohistoryDistinct(Map<String, String> receiveMsgMap, String mac, Map<String, String> exsensorMap,List<State> states){

        LinkedHashMap<String, Double> state_kv = new LinkedHashMap<String, Double>();

        for(State s:states){

            state_kv.put(s.getMac_key(),s.getMac_value());

        }

        Set<Map.Entry<String, String>> entries = receiveMsgMap.entrySet();

        Iterator<Map.Entry<String, String>> iterator = entries.iterator();

        while(iterator.hasNext()){

            Map.Entry<String, String> next = iterator.next();

            String  mac_key = next.getKey();

            String  mac_value = next.getValue();

            double value =Double.parseDouble(mac_value);

            String  sensor = exsensorMap.get(mac_key);

            Double statevalue = state_kv.get(mac_key);

                if(value!=statevalue){

                    taskDao.insertTohistory(mac, sensor, mac_key,mac_value);

                }

        }





    }







    private void insertTohistory(Map<String, String> receiveMsgMap, String mac, Map<String, String> exsensorMap) {

        Set<Map.Entry<String, String>> entries = receiveMsgMap.entrySet();

        Iterator<Map.Entry<String, String>> iterator = entries.iterator();

        while (iterator.hasNext()) {

            Map.Entry<String, String> next = iterator.next();

            String mac_key = next.getKey();

            String mac_value = next.getValue();

            String sensor = exsensorMap.get(mac_key);

            taskDao.insertTohistory(mac, sensor, mac_key, mac_value);



        }

    }



    private Map<String, String> macBindSensor(String mac) {

        Map<String, String> bindsensor = new LinkedHashMap<String, String>();

        List<AlarmSensor> alarmSensors = taskDao.selectFrommacBymac(mac);

        for (AlarmSensor sensor : alarmSensors) {

            String sensorname = sensor.getSensor();

            if (StringUtils.isNotBlank(sensorname)) {

                bindsensor.put(sensorname, sensorname);//value没用到

            }

        }

        return bindsensor;

    }



    private Map<String, String> exSensortoMap(String ver) {

        List<Sensor> sensors = taskDao.selectFromsensorByver(ver);

        Map<String, String> ex_sensorMap = new LinkedHashMap<String, String>();

        for (Sensor sensor : sensors) {

            ex_sensorMap.put(sensor.getMac_key(), sensor.getSensor());

        }

        return ex_sensorMap;

    }









    private  void removeNotBind(Map<String, String> receiveMsgMap,Map<String, String> exsensorMap,Map<String, String> bindsensor){

        Set<Map.Entry<String, String>> entries = receiveMsgMap.entrySet();

        Iterator<Map.Entry<String, String>> iterator = entries.iterator();

        while (iterator.hasNext()) {

            Map.Entry<String, String> next = iterator.next();

            String mac_key = next.getKey();

            String sensor = exsensorMap.get(mac_key);

            if(!bindsensor.containsKey(sensor)){

                iterator.remove();

            }

        }

    }





      private  void removeNotNumber(Map<String, String> receiveMsgMap){

          Set<Map.Entry<String, String>> entries = receiveMsgMap.entrySet();

          Iterator<Map.Entry<String, String>> iterator = entries.iterator();

          while (iterator.hasNext()) {

              Map.Entry<String, String> next = iterator.next();

              String mac_value = next.getValue();

              boolean str2Num = isStr2Num(mac_value);

              if (!str2Num) {

                  iterator.remove();

              }

          }

      }





    private boolean  isStr2Num(String str) {

        try {

            Double.parseDouble(str);

            return true;

        } catch (NumberFormatException e) {

            return false;

        }

    }





    private Map<String, String> toMap(String receiveMsg) {

        Map<String, String> receiveMsgMap = new LinkedHashMap<String, String>();

        JSONObject jsonObject = JSONObject.fromObject(receiveMsg);

        Iterator it = jsonObject.keys();

        while (it.hasNext()) {

            String key = it.next().toString();

            String value = jsonObject.get(key).toString();

            receiveMsgMap.put(key, value);

        }

        return receiveMsgMap;

    }



}