Parsing em aplicativos móveis: essência, formatos de dados e processo

O que é parsing?

Parsing (análise sintática) é o processo de converter uma sequência de caracteres em uma representação estruturada adequada para processamento programático. No contexto do desenvolvimento móvel, parsing refere-se ao processamento de respostas do servidor, arquivos de configuração, cache local e arquivos de recursos. Cada formato requer sua própria abordagem: JSON — leve e integrado ao SDK, XML — rigoroso com validação de esquema XSD, CSV — minimalista para dados tabulares, Protobuf — binário com esquema rígido.

Etapas da análise sintática

Qualquer parser, independentemente do formato, passa por três etapas. Análise léxica divide o texto bruto em tokens: chaves, strings, números, delimitadores e comentários. Análise sintática verifica a correção gramatical — equilíbrio de colchetes em JSON, aninhamento correto de tags em XML. Construção da estrutura de saída forma uma representação de objeto: JSONObject, Map ou um fluxo de tokens para processamento posterior. Segundo Apple (2026), o parser Foundation integrado no iOS usa análise preguiçosa — ele valida apenas o início do JSON, economizando recursos.

Parsing manual vs bibliotecas automatizadas

Parsing manual (JSONSerialization, XmlPullParser) dá controle total sobre o processo e é útil para formatos não padronizados ou quando é necessária validação personalizada de cada campo. Bibliotecas automatizadas (JSONDecoder, Moshi, kotlinx.serialization) aceleram o desenvolvimento, mas ocultam detalhes de tratamento de erros. A escolha depende dos requisitos: se a estrutura de dados for dinâmica ou desconhecida antecipadamente — o parsing manual é preferível. Se o esquema for fixo — a desserialização automatizada reduz o código em 60-70%.

Como o parsing difere da desserialização

Parsing é uma operação mais ampla: pode ser feita em modo streaming e não cria necessariamente um objeto tipado. Desserialização é um caso específico de parsing cujo resultado é sempre uma instância de uma classe conhecida com tipos de propriedades específicos. Um parser JSON divide um documento em Map ou JsonElement, enquanto um desserializador transforma o mesmo JSON em um objeto User, Order ou Product com campos e tipos conhecidos.

Parsing em streaming é a principal vantagem do parsing sobre a desserialização. XmlPullParser no Android analisa XML à medida que lê, sem carregar o documento inteiro na RAM. Isso é crítico para respostas de API grandes, análise de feeds RSS com centenas de itens ou processamento de arrays de milhares de objetos JSON de um dump de servidor. Um parser em streaming lê token por token, consumindo uma quantidade constante de memória independentemente do tamanho do documento.

Parsing JSON em aplicativos móveis

JSON é o formato dominante de troca de dados. No iOS, o JSONSerialization integrado analisa JSON em Any, enquanto o JSONDecoder analisa diretamente em uma estrutura Codable. No Android, o org.json padrão fornece JSONObject e JSONArray para análise manual. Gson e Moshi adicionam conversão automática. Escolher entre abordagens manuais e automatizadas é a primeira decisão arquitetural da camada de rede.

val jsonString = """{"users":[{"id":1,"name":"Alice"}]}"""
val jsonObject = JSONObject(jsonString)
val usersArray = jsonObject.getJSONArray("users")

for (i in 0 until usersArray.length()) {
    val item = usersArray.getJSONObject(i)
    val id = item.getInt("id")
    val name = item.getString("name")
    // processamento de usuário
}

Parsing manual via org.json é útil quando a estrutura da resposta é desconhecida antecipadamente ou varia muito. Essa abordagem dá controle total sobre o tratamento de erros e campos anuláveis, mas requer mais código boilerplate em comparação com a desserialização automatizada. Para projetos pequenos ou protótipos é aceitável, mas em produção, Moshi ou kotlinx.serialization é preferível.

JsonReader para parsing em streaming

JsonReader da biblioteca Moshi é uma ferramenta poderosa para parsing JSON em streaming. Ele lê o documento token por token usando métodos como beginObject, nextName, nextString, nextInt e endObject. Essa abordagem permite processar documentos de qualquer tamanho com consumo constante de memória. Segundo Google (2026), o parsing em streaming via JsonReader é 2-3 vezes mais rápido que carregar o documento inteiro em um JsonObject e consome até 80% menos memória.

val reader = JsonReader(StringReader(json))
reader.beginObject()
while (reader.hasNext()) {
    val name = reader.nextName()
    when (name) {
        "id" -> val id = reader.nextInt()
        "name" -> val name = reader.nextString()
        "email" -> val email = reader.nextString()
        else -> reader.skipValue()
    }
}
reader.endObject()

O exemplo mostra JsonReader analisando JSON em modo streaming. Cada chamada a nextName() e nextInt() avança o cursor para o próximo token. skipValue() pula campos desnecessários sem analisá-los — especialmente útil quando JSON contém 50 campos, mas apenas 3 são necessários. O resultado é consumo mínimo de memória e velocidade máxima.

Parsing XML e CSV

XML continua sendo usado em projetos Android para recursos e em serviços SOAP de aplicações empresariais. No Android, o XmlPullParser integrado fornece análise em streaming com consumo mínimo de memória — ele não carrega uma árvore DOM, mas gera eventos START_TAG, TEXT, END_TAG. O iOS usa XMLParser com uma abordagem de delegate: os métodos parser(didStartElement:) e parser(foundCharacters:) manipulam os elementos sequencialmente.

CSV no desenvolvimento móvel

CSV é o formato mais simples para exportar e importar dados tabulares. Em aplicativos móveis, CSV é usado para exportação de relatórios, carregamento de dados de referência (listas de países, moedas, códigos) e sincronização de dados offline. Bibliotecas de streaming são adequadas para parsing CSV: Apache Commons CSV e OpenCSV processam arquivos linha por linha, escapando aspas e vírgulas dentro dos valores. No iOS, o parsing CSV pode ser implementado através do método delimitador NSString.components(separatedBy:) com tratamento de casos extremos.

class CSVParser: NSObject, XMLParserDelegate {
    private var currentItem: [String: String] = [:]
    private var currentElement: String = ""

    func parser(
        _ parser: XMLParser,
        didStartElement elementName: String,
        namespaceURI: String?,
        qualifiedName qName: String?,
        attributes attributeDict: [String: String]
    ) {
        currentElement = elementName
        if elementName == "item" {
            currentItem = [:]
        }
    }

    func parser(_ parser: XMLParser,
                foundCharacters string: String) {
        currentItem[currentElement] = string
    }
}

Exemplo de um delegate XMLParser no iOS para analisar um feed RSS. O método didStartElement é chamado em cada tag de abertura, foundCharacters retorna o conteúdo textual entre tags e didEndElement completa o elemento. Essa arquitetura baseada em eventos permite processar XML de qualquer tamanho sem carregar uma árvore DOM na memória — crítico para recursos limitados em dispositivos móveis.

Comparação de bibliotecas CSV para Android

No Android, a escolha do parser CSV depende do volume de dados. OpenCSV suporta API fluente, anotações para mapeamento POJO e delimitadores personalizados. Apache Commons CSV é de nível mais baixo, mas mais rápido em arquivos grandes. Para casos simples (1-2 colunas), o parsing manual via String.split(",") com tratamento de escape é suficiente. Para projetos de produção com arquivos CSV grandes, o OpenCSV é recomendado.

Protobuf e parsing em streaming

Protocol Buffers do Google é um formato de serialização binária que supera JSON em velocidade e compacidade. Uma mensagem Protobuf ocupa 3-6 vezes menos espaço que o JSON equivalente e é analisada 4-10 vezes mais rápido graças ao seu formato binário e esquema rígido. As principais desvantagens são a falta de legibilidade humana e a necessidade de gerar código a partir de arquivos .proto através do compilador protoc.

Parsing em streaming de Protobuf é implementado via CodedInputStream — o cliente lê os campos à medida que chegam sem carregar a mensagem inteira. Cada campo tem uma tag (número + tipo), e o parser pode pular campos desconhecidos. Segundo Google (2026), o parsing em streaming de Protobuf consome até 90% menos memória ao processar mensagens a partir de 1 MB, o que é crítico para dispositivos móveis com RAM limitada. Protobuf-lite é uma versão especial para Android, otimizada para tamanho de código gerado.