数据采集器之数据解析

原创 2016年06月01日 19:10:59

数据分发

前一篇文章已经说了数据采集器的背景以及设计原理,接下将说明数据采集的数据分发思想
        

     核心实现

        RouterMonitor 方法 doRouter(),对数据进行分发处理并返回处理结果,体现了类的单一职责
        接下来就对这个方法的核心实现进行分析
package com.glufine.common;

import java.util.Map;

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

import com.glufine.service.RouterBeanDefination;

/**
 * 路由控制器
 * 
 * @author syj
 *
 */
@Component("routerMonitor")
public class RouterMonitor {
	@Autowired
	private RouterFactory routerFactory;

	/**
	 * 执行分发工作
	 */
	public String doRouter(String value, byte[] sourceByte, Map<String, Object> session) {
		// 获取指定的routerKey
		RouterKey routerKey = routerFactory.fetchRouterKey(value, sourceByte);
		if (routerKey == null) {
			return "error";
		}
		RouterBeanDefination bean = findBeanDefination(routerKey);
		if (bean != null) {
			return bean.doWork(routerKey, session);
		}
		return "error";
	};

	/**
	 * 获取到对应的beanDefination 只获取第一个,接下的有用户自己去操作
	 * 规则:查询当前key,如果不存在,查询nextKey,如果不存在,返回null
	 * 
	 * @param routerKey
	 *            路由➹
	 * @return
	 */
	private RouterBeanDefination findBeanDefination(RouterKey routerKey) {
		// spring 命名规则
		String beanId = creatSpringBeanId(routerKey.getRouterKeyName(), routerKey.getCurrentKey().getSpiltKey());
		RouterBeanDefination bean = routerFactory.fetchRouterBeanDefination(beanId);
		while (bean == null) {
			RouterSplitDefination cuurentStep = routerKey.moveNextKey();
			String splitKey = cuurentStep != null ? cuurentStep.getSpiltKey() : null;
			if (splitKey == null) {
				break;
			}
			beanId = creatSpringBeanId(routerKey.getRouterKeyName(), splitKey);
			bean = routerFactory.fetchRouterBeanDefination(beanId);
		}
		return bean;
	}

	private String creatSpringBeanId(String id1, String id2) {
		return id1 + id2;
	}

}


        1获取数据封装的 RouterKey ,那么RouterKey 是干什么的,就是对RouterKeyDefination+数据 进行实现,一个RouterKey中存储的是一条完整的指令数据
package com.glufine.common;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 路由➹
 * @author syj
 *
 */
public class RouterKey {
    
    private RouterKeyDefination routerKeyDefination;
    //要处理的字符串
    private String sourceValue;
    
    private String routerKeyName;
    
    private Map<String, Object> dataMap;
    
    private byte[] sourceByte;
    
    //routerkey的结果集
    private  List<RouterSplitDefination> keyValues = new ArrayList<RouterSplitDefination>();

    private volatile int currentStep = 0;
    
    public RouterKey(RouterKeyDefination routerKeyDefination, String sourceValue,byte[] sourceByte) {
        super();
        this.routerKeyDefination = routerKeyDefination;
        this.sourceValue = sourceValue;
        this.routerKeyName = routerKeyDefination.getKeyName();
        this.sourceByte = sourceByte;
        cloneSplitDefination(routerKeyDefination.getKeyDefinations());
        generateKeyValues(sourceValue);
    }
    
    private void cloneSplitDefination(List<RouterSplitDefination> keys){
        for(RouterSplitDefination key:keys){
            keyValues.add(key.clone());
        }
    }
    /**
     * 获取当前路由器名次
     * @return
     */
    public String getRouterKeyName() {
        return routerKeyName;
    }

    //当前routerkey
    public RouterSplitDefination getCurrentKey(){
        return keyValues.get(currentStep);
    }
    
    public RouterSplitDefination getFirstKey(){
        return keyValues.get(0);
    }
    //下一个routerkey
    public RouterSplitDefination getNextKey(){
        return keyValues.get(currentStep+1);
    }
    /**
     * 返回下一个表达式,游标向下移动
     *  如果不存在,则返回空,游标不动
     * @return
     */
    public RouterSplitDefination moveNextKey(){
        currentStep += 1;
        if(currentStep >= keyValues.size()){
            currentStep -- ;
            return null;
        }
        return keyValues.get(currentStep);
    }
    private void generateKeyValues( String sourceValue){
        for(RouterSplitDefination keyDefination :keyValues){
            keyDefination.genarateSplitVale(sourceValue);
        }
    }
    public RouterKeyDefination getRouterKeyDefination() {
        return routerKeyDefination;
    }
    public String getSourceValue() {
        return sourceValue;
    }
    public int getCurrentStep() {
        return currentStep;
    }
    public List<RouterSplitDefination> getKeyValues() {
        return keyValues;
    }
    
    
    public byte[] getSourceByte() {
		return sourceByte;
	}

	public void setSourceByte(byte[] sourceByte) {
		this.sourceByte = sourceByte;
	}

	public void setSourceValue(String sourceValue) {
		this.sourceValue = sourceValue;
	}

	/**
     * 将数据包装成map集合
     * @return
     */
    public Map<String,Object> generateDataMap(){
        if(dataMap == null){
            dataMap = new HashMap<String,Object>();
            for(RouterSplitDefination bean:keyValues){
                dataMap.put(bean.getSpiltKey(), bean.getSplitValue());
            }
        }
        return dataMap;
    }
}
那么RouterKey 怎么获的呢,需要 routerFactory.fetchRouterKey(value, sourceByte);
  在这个过程中,需要先去获取该指令的指令配置文件,然后把该指令的配置文件解析成RouterKeyDefination,然后根据RouterKeyDefination的配置内容,进行字符串分割,并将key-value保存到数据集合中
package com.glufine.common;

import java.util.Map;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import com.glufine.service.RouterBeanDefination;
@Component("routerFactory")
public class RouterFactory implements ApplicationContextAware {
    
    private ApplicationContext applicationContext;
    /**
     * 获取RouterKey
     * @param value
     * @return
     */
    public RouterKey fetchRouterKey(String value,byte[] sourceByte){
        RouterTable.newInstence();
        Map<String,String> routerMapper =  RouterTable.getRouterMapperMap();
        Map<String,RouterKeyDefination> router = RouterTable.getRouterMap();
        //获取一级路由分发器
        RouterKeyDefination baseRouterKey = router.get("driverMapper");
        RouterKey baseRouter = new RouterKey(baseRouterKey,value,sourceByte);
        RouterSplitDefination baseRouterSplitDefination= baseRouter.getFirstKey();
        String routerMapperValue = routerMapper.get(baseRouterSplitDefination.getSpiltKey()+baseRouterSplitDefination.getSplitValue());
        //根据value获取指定的路由分发器
        RouterKeyDefination routerkey = router.get(routerMapperValue);
        if(routerkey==null){
            return null;
        }
        RouterKey resultRouter = new RouterKey(routerkey,value,sourceByte);
        return resultRouter; 
    }
    
    public RouterBeanDefination fetchRouterBeanDefination(String beanId){
        try {
            return (RouterBeanDefination) applicationContext.getBean(beanId); 
        } catch (Exception e) {
//            e.printStackTrace();
            return null;
        }
    }
    
    public static void main(String[] args) {
//        RouterFactory factory = new RouterFactory();
//        factory.fetchRouterKey("5A18000000100000000111806607316020216250053");
        System.out.println("5A18000000100000000111806607316020216250053".length());
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}
为了方便RouterKeyDefination的获取,将多个指令集合进行抽象,抽象成RouterTable作为RouterKeyDefination的缓存
package com.glufine.common;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import com.glufine.util.PropertiesUtil;
/**
 * 路由表
 * @author syj
 *
 */
public class RouterTable {
    
    public static  RouterTable table = null;
    
    public static RouterTable newInstence(){
        if(table == null){
            table = new RouterTable();
        }
        return table;
    }
    //
    private static Map<String,String> routerMapperMap = new HashMap<String,String>();
    
    private static Map<String,RouterKeyDefination> routerMap =  new HashMap<String,RouterKeyDefination>();
    
    private RouterTable() {
        super();
        //路由匹配规则
        PropertiesUtil baseMapper = new PropertiesUtil("routeBaseMapper.properties");
        generateRouterMapperMap(baseMapper.getAllProperty());
        //路由key
        PropertiesUtil router = new PropertiesUtil("route.properties");
        generateRouterMap(router.getAllProperty());
    }
    /**
     * 获取如有分发解析集合
     *  规定特定的数据向分发到特定路由器
     * @return
     */
    public static Map<String, String> getRouterMapperMap() {
        return routerMapperMap;
    }
    /**
     * 获取所有的路由分发器
     * @return
     */
    public static Map<String, RouterKeyDefination> getRouterMap() {
        return routerMap;
    }
    
    private void generateRouterMap(Map<String,String> maps){
        Set<String> set = maps.keySet();
        for(String key:set){
            String value = maps.get(key);
            String[] splitvalues = value.split(";");
            RouterKeyDefination keyDefination = new RouterKeyDefination(key);
            for(String splitvalue : splitvalues){
                String[] result = splitvalue.split(",");
                RouterSplitDefination bean = new RouterSplitDefination(result[0],
                    Integer.parseInt(result[1]),Integer.parseInt(result[2]));
                keyDefination.putKey(bean);
            }
            routerMap.put(key, keyDefination);
        }
    };

    private void generateRouterMapperMap(Map<String,String> maps){
        Set<String> set = maps.keySet();
        for(String key:set){
            String value = maps.get(key);
            String[] splitvalues = value.split(";");
            for(String splitvalue : splitvalues){
                String[] result = splitvalue.split(",");
                routerMapperMap.put(result[0], result[1]);
            }
        }
    }
    
    public static void main(String[] args) {
        RouterTable.newInstence();
    }

}
RouterTable由于需要读取配置文件,所以采取单例的模式进行实现。这样则最大程度上减少IO消耗。
在这,实现了从基本数据到RouterKey的封装,接下来会有工厂+策略的模式实现RouterBeanDefination的获取。RouterBeanDefination其实就是对于每一个数据业务逻辑的解析,获取到了数据。已经获取到了数据,接下来就是对于具体数据的操作。


版权声明:本文为博主原创文章,未经博主允许不得转载。

数据采集器的三大分类

批处理数据采集器离线式工作,数据批量采集器后,通过USB线或串口数据线跟计算机进行通信。 数据采集器内装有一个嵌入式操作系统(各个生产厂家独立研制开发,互不兼容),应用程序需要在操作系统上独立开...
  • qq_38853684
  • qq_38853684
  • 2017年08月11日 17:21
  • 118

采集器数据解析(1)

Sorry! The page you want to visit is error! Please retry latter!
  • lishan1998
  • lishan1998
  • 2013年08月01日 14:50
  • 315

android学习二十三(解析json格式数据)

前面我们已经掌握了xml格式数据的解析方式,那么接下来我们学习下如何解析json格式的数据。比起xml,json的主要优势在于它体积更小,在网络上传输的时候可以更省流量。但缺点在于,它的语义性差,看起...
  • wj903829182
  • wj903829182
  • 2015年01月08日 10:41
  • 1238

DTU:TCP协议的串口数据流传输

数据传输系统DTU (Data Transfer unit)全称数据传输单元,是专门用于将串口数据转换为IP数据或将IP数据转换为串口数据通过无线通信 网络进行传送的无线终端设备。DTU硬件组成:DT...
  • mikewu_helloworld
  • mikewu_helloworld
  • 2016年10月14日 20:21
  • 2090

数据采集器-架构介绍

说点事说说数据采集的流程数据采集一般是一个从硬件设备收集到数据,然后对对数据进行解析处理,归类,入库,供查询使用。说说踩过的坑 坑1:java多线程并发数量以及tcp粘包问题 由于数据采集是通过tc...
  • qzshiyongjie123
  • qzshiyongjie123
  • 2017年01月11日 10:54
  • 1069

CASIO DT900/dt930数据采集器设置安装使用操作

 应用程序列表:pc端:c:/barapp/bar.lodc:/barapp/ASTART.HTSc:/barapp/PATCH001.LODc:/barapp/PATCH002.LODc:/bara...
  • kelvin_deng
  • kelvin_deng
  • 2009年04月15日 10:45
  • 7990

数据采集器

#include #include #include #include #include "C:/Compiler/INCLUDE/8000lib.h"#include "C:/Compiler/IN...
  • zhangxinghua
  • zhangxinghua
  • 2007年09月24日 19:02
  • 1474

数据采集器程序开发PDA软件开发定制盘点机条码采集系统软件

特点: 1:通过操作移动手持终端上的对接软件,开销售订单,进货单,退货单,验货单等单据,无线盘点,实时掌握库存变化,查看商品资料。 2:我们的手持移动PDA端有软件,可以无缝对接各种进...
  • haohantech
  • haohantech
  • 2017年07月24日 14:17
  • 349

GPS数据包解析

http://write.blog.csdn.net/postedit GPS数据包解析   很多朋友都不知道GPS数据包怎么解析,给大家分享一下,GPS上电后,每隔一定的时间就会返回一定格式...
  • harvey2008
  • harvey2008
  • 2014年08月12日 14:30
  • 1261

一款全新的网页数据采集工具:爬山虎采集器

特性爬山虎采集器是一款全新的网页数据采集工具。作为一款工具软件,我们:放弃了花哨的界面,换之以快速流畅的体验。放弃了复杂的规则配置,开发了智能的自动提取算法。在基于浏览器的可视化操作上,同时保留了快速...
  • guesttt
  • guesttt
  • 2018年01月17日 21:16
  • 114
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:数据采集器之数据解析
举报原因:
原因补充:

(最多只允许输入30个字)