1. java
  2. android
  3. c#
  4. .net
  5. javascript
  6. php
  7. jquery
  8. html
  9. sql

Parse JSON para TXT

Olá Galera,

Estou em um projeto aqui na empresa para transformar arquivos JSON oriundos da API Oracle cloud em arquivos TXT. O problema é que os arquivos JSON retornado na chamada da API tem estruturas dinamicas ou seja, a cada chamada da API um arquivo como mais ou menos campos será retornado.

Preciso criar um solução em JAVA para ler as estruturas variaveis do JSON E gravar um arquivo texto.

Pensei em um arquivo de configuração, como um mapa indicando quais campos procurar dentro da estrutura JSON.

Eu apliquei essa solução em PHP mas PHP não serve para o projeto e agora preciso criar em java uma solução equivalente.

Você já lidaram com um problema assim ? Poderia me ajudar ?

veja o código PHP que resolve o problema:

JSON2TXT:

<?php

class Json2TXT {

    private $confs;
    private $json;
    private $output;
    private $log;

    public function __construct($json, $confs) {
        $this->json = $json;
        $this->confs = $confs;
    }

    public function setLog($logObject) {
        $this->log = $logObject;
    }

    public function convert($outputFile) {
        $this->log('Iniciando conversao do arquivo ' . $this->confs->get('fileName'));

        $this->output = fopen($outputFile, 'w');
        if($this->output === false) {
            $this->log('Sem permissao para escrever no arquivo de saida: ' . $outputFile . ' abortando a conversao');
            return;
        }

        // realiza toda magica da conversao
        $this->processLevel($this->json);

        fclose($this->output);
        $this->log('Fim da conversao do arquivo ' . $this->confs->get('fileName'));
    }

    private function processLevel($data, $currentLevel = 0, $parentLineInfo = []) {
        $config = $this->confs->get('layout.elements');
        $path = $config[$currentLevel]->path;
        $columns = isset($config[$currentLevel]->columns) ? $config[$currentLevel]->columns : false;
        $itemDataLoop = $data->get($path);

        // if there's no element or the element is not a array, I create a empty array
        if(!$itemDataLoop && !is_array($itemDataLoop)) {
            $this->log('Elemento ' . $path . ' nao encontrado, assumindo valor vazio para o campo');
            $itemDataLoop = array([null]);
        }

        $isLastLevel = ($currentLevel == count($config)-1);
        foreach($itemDataLoop as $itemData) {
            $itemData = Json::create($itemData);
            $lineInfo = $parentLineInfo;

            if($columns) {
                foreach($columns as $column) {

                    if(!$itemData->has($column)) {
                        $this->log('Nao encontrado a coluna ' . $column . ' no elemento ' . $path . '. Atribuindo valor vazio para o texto');
                        $text = '';
                    } else {
                        $text = $itemData->get($column);    
                    }

                    // if result is a array or a element, set the text to empty string
                    if(is_array($text) || is_object($text)) {
                        $this->log('A coluna '. $column .' do elemento ' . $path . ' contem um array ou objeto. Atribuindo valor vazio para o texto');
                        $text = '';
                    }

                    array_push($lineInfo, $text);
                }
            } else {
                $text = '';
                if(!is_array($itemData))
                    $text = $itemData;
                array_push($lineInfo, $text);
            }

            if($isLastLevel) {
                $this->write($lineInfo);
            } else {
                $this->processLevel($itemData, $currentLevel + 1, $lineInfo);            
            }

        }
    }

    private function log($info) {
        if($this->log)
            $this->log->write($info);
    }

    private function write($lineInfo) {
        fwrite($this->output, join($this->confs->get('layout.separator', '|'), $lineInfo) . PHP_EOL);
    }

}

JSON:

<?php

class Json {

    private $jsonContent;

    public function __construct($content) {        
        if(is_string($content) && file_exists($content))
            $this->jsonContent = json_decode(file_get_contents($content));
        elseif (is_string($content))
            $this->jsonContent = json_decode($content);
        elseif (is_object($content))
            $this->jsonContent = $content;
    }

    public static function create($content) {
        return new static($content);
    }

    public function get($entry = '', $defaultValue = '') {
        try {
            $value = $this->getEntry($entry);
        } catch(Exception $e) {
            if($e->getMessage() == 'ENTRY_NOT_FOUND')
                return $defaultValue;
        }
        return $value;
    }

    public function has($entry) {
        try {
            $this->getEntry($entry);
        } catch(Exception $e) {
            if($e->getMessage() == 'ENTRY_NOT_FOUND')
                return false;
        }
        return true;
    }

    private function getEntry($entry) {
        if($entry == '')
            return $this->jsonContent;        
        $path = explode('.', $entry);
        $json = $this->jsonContent;
        foreach($path as $item) {
            if(is_numeric($item) && strlen($json[$item]) > 0) {
                $json = $json[$item];
                continue;
            }
            if(!isset($json->{$item}))
                throw new Exception('ENTRY_NOT_FOUND');
            $json = $json->{$item};
        }
        return $json;
    }

}

App:

<?php

require_once('Json.php');
require_once('Json2TXT2.php');
require_once('Log.php');

require_once('API_Curl.php');

$url = 'http://localhost:9999';
$app = new App($url, 'l_PAINEL_DE_COTAS_01.json');
$app->run();

class App {

    private $url;
    private $confs;
    private $log;
    private $outputDir;

    public function __construct($url, $confFile) {
        $this->log = new Log();
        $this->url = $url;
        if(!$confFile || !file_exists($confFile)) {
            $this->log->write('Arquivo de configuracao ' . $confFile . ' nao encontrado');
            die;
        }

        $this->confs = new Json($confFile);

        // Define o diretorio de saida do arquivo
        $outputDir = $this->confs->get('outputDir');
        if(!$outputDir || !is_writable($outputDir)) {
            $this->log->write('Diretorio informado para saida dos arquivos é invalido');
            die;            
        }
        $this->outputDir = $outputDir;        
    }

    public function run() {
        $this->log->write('Inicio da execução do JOB');        

        // Obtendo as informacoes via api
        $api = new API_Curl($this->url, $this->confs);
        $api->setLog($this->log);
        $json = new Json($api->get());
        if(!is_object($json->get())) {
            $this->log->write('Arquivo JSON de retorno inválido ou vazio');
            return;
        }

        // Realizando a conversao do JSON em TXT
        $json2TXT = new Json2TXT($json, $this->confs);
        $outputFile =  $this->getOutputFile();
        $json2TXT->convert($outputFile);

        $this->log->write('Conversao do arquivo executada com sucesso em ' . $outputFile);
        $this->log->write('Fim da execução do JOB');
    }

    private function getOutputFile() {
        $dir = $this->outputDir;
        if(substr($dir, -1) == '/')
            $dir = substr($dir, 0, strlen($dir) -1);
        return $dir . '/' . date('YmdHis') . '_' . $this->confs->get('fileName') . '.TXT';
    }    
}

Config File:

{
    "fileName": "USUARIOS",
    "logFile": "output-usuarios.log",
    "exitCodes": {
        "error": 1,
        "fileEmpty": 2,
        "fileNotFound": 3
    },
    "layout": {
        "records": "data.items",
        "separator": "|",
        "showColumnNames": 1,
        "columns": [
            {
                "name": "nome usuario",
                "path": "nome"
            },
            {
                "name": "endereco",
                "path": "endereco"
            },
            {
                "name": "telefone",
                "path": "telefone"
            },
            {
                "name": "data_arquivo",
                "path": "parent:data-arquivo"
            },
            {
                "name": "idade",
                "path": "info.idade"
            },
            {
                "name": "nome do arquivo",
                "path": "parent:parent:nome-arquivo"
            }
        ]
    }
}

Exemplo JSON:

{    
    "nome-arquivo": "arquivo-do-juliano.txt",
    "data" : {
        "data-arquivo": "2018-10-04",
        "items": [
            {
                "nome": "juliano ribeiro",
                "endereco": "avenida 1, 58",
                "telefone": "976147220",
                "info": {
                    "idade": 10
                }
            },
            {
                "nome": "roberto",
                "endereco": "rua do amparo, 58",
                "telefone": "12345678",
                "info": {
                    "idade": 32
                }
            },
            {
                "nome": "marcela",
                "endereco": "av. conceicao, 3158",
                "telefone": "987654321",
                "info": {
                    "idade": 17
                }
            }    
        ]
    }
}
  1. Você vai ver essas setas em qualquer página de pergunta. Com elas, você pode dizer se uma pergunta ou uma resposta foram relevantes ou não.
  2. Edite sua pergunta ou resposta caso queira alterar ou adicionar detalhes.
  3. Caso haja alguma dúvida sobre a pergunta, adicione um comentário. O espaço de respostas deve ser utilizado apenas para responder a pergunta.
  4. Se o autor da pergunta marcar uma resposta como solucionada, esta marca aparecerá.
  5. Clique aqui para mais detalhes sobre o funcionamento do GUJ!

0 resposta

Não é a resposta que estava procurando? Procure outras perguntas com as tags java json php ou faça a sua própria pergunta.