Fatal编程技术网
  • apache-camel/
  • Apache camel 通过映射列表使用Apache Camel将CSV文件转换为JSON文件

Apache camel 通过映射列表使用Apache Camel将CSV文件转换为JSON文件

apache-camel

Apache camel 通过映射列表使用Apache Camel将CSV文件转换为JSON文件,apache-camel,Apache Camel,目标是学习如何将CSV读入映射列表，然后如何将其封送到JSON 一旦我了解了怎么做，我就会知道如何定义更有用的路由 我使用XML定义路由，另一个限制是不创建任何转换bean，而只使用现有组件 我的理解显然缺乏一些概念。我知道你必须作为消费者提供一个bean，然后你可以把它传下去；但是文档中说csv数据格式使用的地图列表有什么问题 <dataFormats> <json id="jack" library="Jackson"/> </d

目标是学习如何将CSV读入映射列表，然后如何将其封送到JSON

一旦我了解了怎么做，我就会知道如何定义更有用的路由

我使用XML定义路由，另一个限制是不创建任何转换bean，而只使用现有组件

我的理解显然缺乏一些概念。我知道你必须作为消费者提供一个bean，然后你可以把它传下去；但是文档中说csv数据格式使用的地图列表有什么问题

    <dataFormats>
        <json id="jack" library="Jackson"/>
    </dataFormats>  

    <route>
        <from uri="file:///C:/tries/collApp/exchange/in?fileName=registerSampleSmaller.csv"/>
        <unmarshal>
            <csv />
        </unmarshal>            
        <marshal ref="jack">                
        </marshal>
        <to uri="file:///C:/tries/collApp/exchange/out?fileName=out.json"/>          
    </route>
默默地什么也不做。我只能看到锁文件是如何出现和消失的

谢谢

ps/我期待着创建两条路径，第一条路径将读取csv，将其转换为我的持久bean的扁平特性，然后将其传递给我的bean。第二个将把我的bean保存为json，这似乎是一个简单的部分；但我首先需要这样做才能理解它是如何工作的请看一下这个DataFormat页面[1] 您可以使用这些封送DSL将对象转换为具有所需格式的字符串。
[1]

为什么要地图列表？为什么不列一份清单呢

  • 使用Bindy将CSV解组到POJO列表
  • 使用带注释的类或标准jackson代码将列表封送到JSON
    • 如果您需要代码示例，请告诉我。但是主要的想法是在解开csv后始终检查主体。您很可能会得到pojo的列表。然后迭代列表，对于每个pojo，获取“getter”并设置json标记的值。

    我在前面提供了一个答案

    我在正确的轨道上，只是有一些小错误。其中一个是由Jérémie B在对原始问题的评论中注意到的

    由于我没有启用日志记录，所以它以静默方式失败，我通过在pom.xml中添加slf4j实现了这一点：

        <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${slf4j-version}</version>
    </dependency>    
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-jdk14</artifactId>
        <version>${slf4j-version}</version>
    </dependency>    
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>jcl-over-slf4j</artifactId>
        <version>${slf4j-version}</version>
    </dependency>    

    
org.slf4j
)
    
虽然我前进了，但可能现在我绕过了有缺陷的Camel的IOConverter，目前我正处于这一阶段（这不是对问题的回答，只是为了说明Camel有多方便）：
    

    
${body.size（）}==1
#{
{
lastName:body[0][“LAST_NAME”]，
firstName:body[0]['FIRST_NAME']，
赞助人：主体[0][“赞助人”]，
注释：正文[0]['COMMENT6']
}
}

    
我必须编写自己的CSV拆分器（关于所有Unicode代码点等），它基本上是将第一行添加到所有后续行中，但现在我能够以流线型的方式将CSV拆分为一组JSON，或者以不同的方式处理对象，而不是编组
    
**更新-CSVSPLITER代码**
    
读取器标记器-读取器周围的迭代器：
    

    public class ReaderTokenizer implements Iterator<String> {

private String _curString = null;
private boolean _endReached = false;
private final Reader _reader;
private char[] _token;

public ReaderTokenizer(Reader reader, String token) {
    setToken(token);
    _reader = reader;
}

public final void setToken(String token){
    _token = token.toCharArray();
    if(_token.length==0){
        throw new IllegalArgumentException("Can't tokenize with the empty string");
    }
}

private void _readNextToken() throws IOException {

    int curCharInt;
    char previousChar = (char) -1;
    int tokenPos = 0;
    StringBuilder sb = new StringBuilder(255);

    while (true) {
        curCharInt = _reader.read();
        if (curCharInt == -1) {
            _endReached = true;
            _reader.close();
            break;
        }
        if (curCharInt == _token[tokenPos]) {

            if (tokenPos != 0 || !Character.isHighSurrogate(previousChar)) {
                tokenPos++;

                if (tokenPos >= _token.length) {
                    tokenPos = 0;
                    previousChar = (char) curCharInt;
                    sb.append(previousChar);
                    break;
                }
            }
        }

        previousChar = (char) curCharInt;
        sb.append(previousChar);
    }
    _curString = sb.toString();
}

@Override
public boolean hasNext() {
    if (_curString == null) {
        if (_endReached) {
            return false;
        }
        try {
            _readNextToken();
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }

        if (_curString != null) {
            return true;
        }

        if (_endReached) {
            return false;
        }

        throw new RuntimeException("Someting wrong");

    } else {
        return true;
    }
}

@Override
public String next() {
    if (_curString != null) {
        String ret = _curString;
        _curString = null;
        return ret;
    }
    if (_endReached) {
        throw new NoSuchElementException();
    }

    try {
        _readNextToken();
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }

    if (_curString != null) {
        String ret = _curString;
        _curString = null;
        return ret;
    }

    throw new RuntimeException("Someting wrong");
}

@Override
public void remove() {
    throw new UnsupportedOperationException("Not supported.");
}

}

    

    公共类ReaderTokenizer实现迭代器{
私有字符串_curString=null；
私有布尔值_endreach=false；
私人最终读取器(u读取器);；
私有字符[]_令牌；
公共读卡器（读卡器，字符串标记）{
setToken（token）；
_读取器=读取器；
}
公共最终无效集合令牌（字符串令牌）{
_token=token.toCharArray（）；
如果（_token.length==0）{
抛出新的IllegalArgumentException（“不能用空字符串标记”）；
}
}
私有void\u readNextToken（）引发IOException{
int curCharInt；
char-previousChar=（char）-1；
int-tokenPos=0；
StringBuilder sb=新的StringBuilder（255）；
while（true）{
curCharInt=_reader.read（）；
如果（curCharInt==-1）{
_endreach=true；
_reader.close（）；
打破
}
if（curCharInt==\u令牌[tokenPos]）{
if（tokenPos！=0 | |！Character.ishighsrogate（previousChar））{
tokenPos++；
if（tokenPos>=\u token.length）{
tokenPos=0；
previousChar=（char）curCharInt；
某人附加（先前的字符）；
打破
}
}
}
previousChar=（char）curCharInt；
某人附加（先前的字符）；
}
_curString=sb.toString（）；
}
@凌驾
公共布尔hasNext（）{
if（_curString==null）{
如果（_endreach）{
返回false；
}
试一试{
_readNextToken（）；
}捕获（IOEX异常）{
抛出新的运行时异常（ex）；
}
如果（_curString！=null）{
返回true；
}
如果（_endreach）{
返回false；
}
抛出新的RuntimeException（“出错”）；
}否则{
返回true；
}
}
@凌驾
公共字符串next（）{
如果（_curString！=null）{
字符串ret=\u curString；
_curString=null；
返回ret；
}
如果（_endreach）{
抛出新的NoTouchElementException（）；
}
试一试{
_readNextToken（）；
}捕获（IOEX异常）{
抛出新的运行时异常（ex）；
}
如果（_curString！=null）{
字符串ret=\u curString；
_curString=null；
返回ret；
}
抛出新的RuntimeException（“出错”）；
}
@凌驾
公共空间删除（）{
抛出新的UnsupportedOperationException（“不受支持”）；
}
}

    
拆分器本身：
    

    public class CamelReaderSplitter {

private final String _token;
private final int _headerLinesNumber;

public CamelReaderSplitter(String token, int headerLinesNumber) {
    _token = token;
    _headerLinesNumber = headerLinesNumber;
}

public CamelReaderSplitter(String token) {
    _token = token;
    _headerLinesNumber = 1;
}

public CamelReaderSplitter(int headerLinesNumber) {
    _token = "\r\n";
    _headerLinesNumber = headerLinesNumber;
}

public CamelReaderSplitter() {
    _token = "\r\n";
    _headerLinesNumber = 1;
}

public Iterator<String> tokenizeReader(final Reader reader) throws IOException {

    Iterator<String> ret = new ReaderTokenizer(reader, _token) {

        private final String _firstLines;

        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < _headerLinesNumber; i++) {
                if (super.hasNext()) {
                    sb.append(super.next());
                }
            }
            _firstLines = sb.toString();
        }

        @Override
        public String next() {
            return _firstLines + super.next();
        }

    };

    return ret;

}

}

    

    公共类camelReaderSpliter{
私有最终字符串\u标记；
私人最终国际校长行成员；
公共CamelReaderSpliter（字符串标记，i

    public class ReaderTokenizer implements Iterator<String> {

private String _curString = null;
private boolean _endReached = false;
private final Reader _reader;
private char[] _token;

public ReaderTokenizer(Reader reader, String token) {
    setToken(token);
    _reader = reader;
}

public final void setToken(String token){
    _token = token.toCharArray();
    if(_token.length==0){
        throw new IllegalArgumentException("Can't tokenize with the empty string");
    }
}

private void _readNextToken() throws IOException {

    int curCharInt;
    char previousChar = (char) -1;
    int tokenPos = 0;
    StringBuilder sb = new StringBuilder(255);

    while (true) {
        curCharInt = _reader.read();
        if (curCharInt == -1) {
            _endReached = true;
            _reader.close();
            break;
        }
        if (curCharInt == _token[tokenPos]) {

            if (tokenPos != 0 || !Character.isHighSurrogate(previousChar)) {
                tokenPos++;

                if (tokenPos >= _token.length) {
                    tokenPos = 0;
                    previousChar = (char) curCharInt;
                    sb.append(previousChar);
                    break;
                }
            }
        }

        previousChar = (char) curCharInt;
        sb.append(previousChar);
    }
    _curString = sb.toString();
}

@Override
public boolean hasNext() {
    if (_curString == null) {
        if (_endReached) {
            return false;
        }
        try {
            _readNextToken();
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }

        if (_curString != null) {
            return true;
        }

        if (_endReached) {
            return false;
        }

        throw new RuntimeException("Someting wrong");

    } else {
        return true;
    }
}

@Override
public String next() {
    if (_curString != null) {
        String ret = _curString;
        _curString = null;
        return ret;
    }
    if (_endReached) {
        throw new NoSuchElementException();
    }

    try {
        _readNextToken();
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }

    if (_curString != null) {
        String ret = _curString;
        _curString = null;
        return ret;
    }

    throw new RuntimeException("Someting wrong");
}

@Override
public void remove() {
    throw new UnsupportedOperationException("Not supported.");
}

}

    

    public class CamelReaderSplitter {

private final String _token;
private final int _headerLinesNumber;

public CamelReaderSplitter(String token, int headerLinesNumber) {
    _token = token;
    _headerLinesNumber = headerLinesNumber;
}

public CamelReaderSplitter(String token) {
    _token = token;
    _headerLinesNumber = 1;
}

public CamelReaderSplitter(int headerLinesNumber) {
    _token = "\r\n";
    _headerLinesNumber = headerLinesNumber;
}

public CamelReaderSplitter() {
    _token = "\r\n";
    _headerLinesNumber = 1;
}

public Iterator<String> tokenizeReader(final Reader reader) throws IOException {

    Iterator<String> ret = new ReaderTokenizer(reader, _token) {

        private final String _firstLines;

        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < _headerLinesNumber; i++) {
                if (super.hasNext()) {
                    sb.append(super.next());
                }
            }
            _firstLines = sb.toString();
        }

        @Override
        public String next() {
            return _firstLines + super.next();
        }

    };

    return ret;

}

}