将json转为bean

蔚落 2023-06-23 13:13 1阅读 0赞

## 1.使用JedisUtils工具类 ##

package com.nari.iot.tools;
    
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.core.type.TypeReference;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.IOException;
    import java.util.List;
    import java.util.Map;
    
    /**
     * @create: 2018-04-24 17:20
     **/
    public class JsonUtils {
    
        public static final ObjectMapper mapper = new ObjectMapper();
    
        private static final Logger logger = LoggerFactory.getLogger(JsonUtils.class);
    
        public static String toString(Object obj) {
            if (obj == null) {
                return null;
            }
            if (obj.getClass() == String.class) {
                return (String) obj;
            }
            try {
                return mapper.writeValueAsString(obj);
            } catch (JsonProcessingException e) {
                logger.error("json序列化出错：" + obj, e);
                return null;
            }
        }
    
        public static <T> T toBean(String json, Class<T> tClass) {
            try {
                return mapper.readValue(json, tClass);
            } catch (IOException e) {
                logger.error("json解析出错：" + json, e);
                return null;
            }
        }
    
        public static <E> List<E> toList(String json, Class<E> eClass) {
            try {
                return mapper.readValue(json, mapper.getTypeFactory().constructCollectionType(List.class, eClass));
            } catch (IOException e) {
                logger.error("json解析出错：" + json, e);
                return null;
            }
        }
    
        public static <K, V> Map<K, V> toMap(String json, Class<K> kClass, Class<V> vClass) {
            try {
                return mapper.readValue(json, mapper.getTypeFactory().constructMapType(Map.class, kClass, vClass));
            } catch (IOException e) {
                logger.error("json解析出错：" + json, e);
                return null;
            }
        }
    
        public static <T> T nativeRead(String json, TypeReference<T> type) {
            try {
                return mapper.readValue(json, type);
            } catch (IOException e) {
                logger.error("json解析出错：" + json, e);
                return null;
            }
        }
    }

## 2.添加实体类 ##

package com.nari.iot.bean;
    
    import lombok.Data;
    
    import java.sql.Timestamp;
    import java.util.List;
    
    
    @Data
    public class Info_Ai{
        private String key;
        private String name;
        private String value;
        private String ref_time;
    
        public String getKey() {
            return key;
        }
    
        public void setKey(String key) {
            this.key = key;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getValue() {
            return value;
        }
    
        public void setValue(String value) {
            this.value = value;
        }
    
        public String getRef_time() {
            return ref_time;
        }
    
        public void setRef_time(String ref_time) {
            this.ref_time = ref_time;
        }
    
    }

package com.nari.iot.bean;
    
    import lombok.Data;
    
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import javax.persistence.Table;
    import java.math.BigDecimal;
    import java.util.Date;
    
    @Table(name = "T_IOT_AIR_INFO")
    @Data
    public class IotAirInfo {
        @Id
        @GeneratedValue(generator = "JDBC")
        private String uuid;
        private String airFloor;
        private String airRoom;
        private BigDecimal measureVal;
        private BigDecimal makeVal;
        private BigDecimal errorCode;
        private Date collectTime;
        private Date startTime;
        private Date endTime;
        public String getUuid() {
            return uuid;
        }
    
        public void setUuid(String uuid) {
            this.uuid = uuid == null ? null : uuid.trim();
        }
    
        public String getAirFloor() {
            return airFloor;
        }
    
        public void setAirFloor(String airFloor) {
            this.airFloor = airFloor == null ? null : airFloor.trim();
        }
    
        public String getAirRoom() {
            return airRoom;
        }
    
        public void setAirRoom(String airRoom) {
            this.airRoom = airRoom == null ? null : airRoom.trim();
        }
    
        public BigDecimal getMeasureVal() {
            return measureVal;
        }
    
        public void setMeasureVal(BigDecimal measureVal) {
            this.measureVal = measureVal;
        }
    
        public BigDecimal getMakeVal() {
            return makeVal;
        }
    
        public void setMakeVal(BigDecimal makeVal) {
            this.makeVal = makeVal;
        }
    
        public BigDecimal getErrorCode() {
            return errorCode;
        }
    
        public void setErrorCode(BigDecimal errorCode) {
            this.errorCode = errorCode;
        }
    
        public Date getCollectTime() {
            return collectTime;
        }
    
        public void setCollectTime(Date collectTime) {
            this.collectTime = collectTime;
        }
    }

此处有省略

## 3.进行转换 ##

public void analyMessage(String type){
            //获取redis缓存的消息，并且将json映射成bean
            String message = JedisUtils.get(type);
            Message messageIns = JsonUtils.toBean(message, Message.class);
            if(messageIns == null){
                return;
            }
            //循环ai消息，封装空调消息实体类
            List<Info_Ai> infoAiList = messageIns.getInfo_ai();
            if(Common.CS_IOT_MESSAGE_INFO.equals(type)){
                saveAirInfo(infoAiList);
            }else if(Common.CS_IOT_MESSAGE_ELEC.equals(type)){
                saveElecInfo(infoAiList);
            }else if(Common.CS_IOT_MESSAGE_MIX.equals(type)){
    
                List<Info_Ai>  infoList = new ArrayList<Info_Ai>();
                List<Info_Ai> elecList = new ArrayList<Info_Ai>();
                for(int i = 0; i < infoAiList.size(); i++){
                    Info_Ai infoAi = infoAiList.get(i);
                    String key = infoAi.getKey();
                    if(key.indexOf("pi") != -1){
                        elecList.add(infoAi);
                    }else{
                        infoList.add(infoAi);
                    }
                }
                saveAirInfo(infoList);
                saveElecInfo(elecList);
            }
    
        }

public void saveAirInfo(List<Info_Ai> infoAiList){
    
            if(infoAiList != null && infoAiList.size() > 0){
                List<IotAirInfo> infoList = new ArrayList<IotAirInfo>();
                Map<String, IotAirInfo> infoMap = new HashMap<String, IotAirInfo>();
                for(int i = 0; i< infoAiList.size(); i++){
                    //获得消息AI实体
                    Info_Ai infoAi = infoAiList.get(i);
                    String key = infoAi.getKey();
                    String name = infoAi.getName();
                    String value = infoAi.getValue().trim();
                    String ref_time = infoAi.getRef_time();
                    //解析AI消息
                    String[] split = key.split("-"); // m1   1_ai_0
                    String[] split1 = split[1].split("_"); //1  ai  0
                    String floor = split[0].substring(1);
                    String room = split1[0];
                    String flag = split1[2];
    
                    String[] collectArr = key.split("_");
                    IotAirInfo iotAirInfo = null;
                    if(infoMap.containsKey(collectArr[0])){
                        iotAirInfo = infoMap.get(collectArr[0]);
                    }else{
                        iotAirInfo = new IotAirInfo();
                        //封装空调信息实体
                        iotAirInfo.setUuid(Common.getUUID());
                        iotAirInfo.setAirFloor(floor);
                        iotAirInfo.setAirRoom(room);
                        infoMap.put(collectArr[0], iotAirInfo);
                    }
                    if(Integer.parseInt(flag) == 0){
                        //设置温度值
                        iotAirInfo.setMakeVal(new BigDecimal(value));
                    }else if(Integer.parseInt(flag) == 1){
                        //测量温度值
                        iotAirInfo.setMeasureVal(new BigDecimal(value));
                    }else{
                        //错误代码值
                        iotAirInfo.setErrorCode(new BigDecimal(value));
                    }
    
                    //转换时间格式
    //                ref_time = ref_time.replace("Z", " UTC");//注意是空格+UTC
    //                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss Z");//注意格式化的表达式
    //                Date d = null;
    //                try {
    //                    d = format.parse(ref_time);
    //                } catch (ParseException e) {
    //                    e.printStackTrace();
    //                }
                    ref_time = ref_time.replace("Z", "").replace("T", " ");//注意是空格+UTC
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    Date parse = null;
                    try {
                        parse = sdf.parse(ref_time);
                    } catch (ParseException e) {
                        e.printStackTrace();
                    }
                    iotAirInfo.setCollectTime(parse);
                }
                for(String key: infoMap.keySet()){
                    IotAirInfo iotAirInfo = infoMap.get(key);
                    if(iotAirInfo.getMeasureVal() == null || iotAirInfo.getMeasureVal().compareTo(BigDecimal.ZERO) == 0
                            || iotAirInfo.getMakeVal() == null || iotAirInfo.getMakeVal().compareTo(BigDecimal.ZERO) == 0){
                        continue;
                    }
                    infoList.add(iotAirInfo);
                }
    
                if(infoList.size() > 0){
                    iotAirInfoService.insertInfoBatch(infoList);
                }
            }
        }