Java - JSONSlurper

O que é JsonSlurper ? #

JsonSlurper é uma classe do Groovy, usada para gerenciar arquivos ou strings em formato JSON. É parte da biblioteca de scriptings Groovy que fornece uma maneira fácil e rápida de lidar com dados JSON. JsonSlurper converte o conteúdo JSON em um estrutura de dados de Groovy, como mapas, listas e objetos, que podem ser manipulados e utilizados de forma semelhante a qualquer outro objeto.

O que é Groovy? #

Groovy]( https://groovy.apache.org/) é uma linguagem de programação geral baseada em Java. Foi desenvolvida como uma alternativa mais fácil e expressiva para Java, projetada para facilitar a automação de tarefas e integração com outras linguagens e plataformas. Groovy oferece um sintaxe mais clara e concisa do que Java, além de inúmeras funcionalidades programáticas dinâmicas como orientação a objetos, programação funcional e meta-programação. Além disso, Groovy pode ser executado no plataforma Java sem necessidade de compilação prévia, tornando-se ideal para tarefas scriptuais e automatizadas. Na minha opinião, se Java e Python tivessem um filho, isso provavelmente seria Groovy.

O que é JSON? #

JSON (JavaScript Object Notation) é um formato de texto leve e fácil de ler para troca de dados. É comumente usado para transmitir informações entre um aplicativo cliente e um servidor ou para transmitir dados entre aplicações. O JSON representa os dados em forma de objetos níveis e listas de objetos, e usa uma sintaxe clara e fácil de ler baseada em chaves { } para definir objetos e parênteses [ ] para definir listas.

{
  "name": "John Doe",
  "age": 35,
  "email": "john.doe@example.com"
}

Como o JSONSlurper funciona no JMeter? #

O JSONSlurper pode ser usado no Apache JMeter para analisar uma resposta JSON de uma solicitação HTTP. Aqui está um exemplo de código Groovy que mostra como usar o JSONSlurper no JMeter:

{
  "name": "John Doe",
  "age": 35,
  "address": {
    "street": "123 Main St",
    "city": "Anytown",
    "state": "WA"
  },
  "phoneNumbers": [
    {
      "type": "mobile",
      "number": "555-555-1234"
    },
    {
      "type": "home",
      "number": "555-555-5678"
    },
    {
      "type": "office",
      "number": "555-555-5111"
    },
    {
      "type": "virtual",
      "number": "555-555-3321"
    }
  ],
  "email": "john.doe@example.com"
}

2. Adicionamos um pós-processador JSR223 e introduzimos o seguinte código:

import groovy.json.JsonSlurper

def jsonSlurper = new JsonSlurper()
def response = prev.getResponseDataAsString()
def json = jsonSlurper.parseText(response)

log.info(json.phoneNumbers[0].number)

3. Isso retornaria o seguinte no log do JMeter:

2021-08-29 16:01:00,972 INFO o.a.j.t.JMeterThread: Thread started: Thread Group 1-1
2021-08-29 16:01:01,969 INFO o.a.j.e.J.JSR223 PostProcessor: 555-555-1234
2021-08-29 16:01:01,970 INFO o.a.j.t.JMeterThread: Thread is done: Thread Group 1-1

O exemplo anterior poderia ser mais simples se usássemos um extrator JSON para extrair um ou mais valores e armazená-los na memória, como mostrado nas imagens.

Quais outras utilizações o JSONSlurper pode ter em JMeter? #

JSONSlurper é uma ferramenta muito poderosa para a parseamento e extração de valores. O exemplo anterior é fácil de resolver com JSONPath, mas as coisas ficam complicadas quando precisamos extrair múltiplos valores da resposta, pois teríamos que usar um JSONPath para um valor de diferentes nós. No exemplo seguinte, temos vários usuários: John, Peter e Rick. As coisas começam a se tornar complicadas.

[{
  "name": "John Doe",
  "age": 35,
  "address": {
    "street": "123 Main St",
    "city": "Anytown",
    "state": "WA"
  },
  "phoneNumbers": [
    {
      "type": "mobile",
      "number": "555-551-1234"
    },
    {
      "type": "home",
      "number": "555-552-5678"
    }
  ],
  "email": "john.doe@example.com"
},{
  "name": "Peter Doe",
  "age": 34,
  "address": {
    "street": "123 Second St",
    "city": "Anytown",
    "state": "TX"
  },
  "phoneNumbers": [
    {
      "type": "mobile",
      "number": "555-553-1234"
    },
    {
      "type": "home",
      "number": "555-554-5678"
    }
  ],
  "email": "peter.doe@example.com"
},{
  "name": "Rick Doe",
  "age": 36,
  "address": {
    "street": "123 Third St",
    "city": "Anytown",
    "state": "NJ"
  },
  "phoneNumbers": [
    {
      "type": "mobile",
      "number": "555-555-1234"
    },
    {
      "type": "home",
      "number": "555-556-5678"
    }
  ],
  "email": "rick.doe@example.com"
}]

Para este exemplo, seria melhor salvar toda a resposta na memória como uma variável, depois recuperar um objeto ou nó da matriz (temos 3 nós ou usuários na matriz: John, Peter e Rick) e, em seguida, recuperar o primeiro número de telefone de cada nó:

import groovy.json.JsonSlurper

def response = prev.getResponseDataAsString()
vars.put("response",response) //Save the previous JSON response in the response variable
def jsonSlurper = new JsonSlurper()
def json = jsonSlurper.parseText(response) //Process the JSON input in case it needs to be reused.

// -- Examples - //
json.each { //Iterate over the array of nodes
  log.info( it.phoneNumbers[0].toString() ) //Print the value of the first phone number entry
}

Outros exemplos poderiam ser avaliar a idade do usuário mais velho para obter seu número de telefone:

def oldestPerson = json.sort{ it.age }[-1] //We sort the array and obtain the last value.
log.info(oldestPerson.name)

Também poderíamos obter o endereço de pessoas que moram em um determinado estado, como o Texas:

json.each {
  if(it.address.state.equals("TX")){ //We evaluate that the state of residence is Texas
    log.info(it.address.street)
  }
}

Por fim, poderíamos imprimir todos os e-mails que contêm uma determinada palavra-chave:

json.each {
  if(it.email.contains("doe")){
    log.info(it.email)
  }
}

Conclusão #

JSONSlurper é um excelente ferramenta para substituir qualquer Extractor JSON para obter múltiplos valores ou avaliação de mesmos para satisfazer uma ou mais critérios, o que poderia ser muito difícil com a query JSONPath por causa da utilização de funções nativas do Groovy. O ambiente e a manipulação de informações dentro dos nós tornam-se extremamente simples e altamente escalável, há muito tempo desenvolvi um critério para avaliar múltiplas arquivos JSON para reservar espaços, sem a ajuda de JSONslurper que teria se tornado uma grande problema, mas é rápido e pode exportar o objeto resultante como propriedade em JMeter como Listas ou Mapas, tornando a manipulação simples e limpa, obviamente há muito práticas necessárias para obter resultados esperados. Até a próxima e espero que você se divirta com a entrada.