DEV Community

Cover image for SoapUI Lento: Causas e Como Melhorar o Desempenho
Lucas
Lucas

Posted on • Originally published at apidog.com

SoapUI Lento: Causas e Como Melhorar o Desempenho

Resumo

O desempenho lento do SoapUI geralmente está ligado à sobrecarga da inicialização da JVM, configurações de memória padrão insuficientes para projetos grandes e atrasos na análise de WSDL. Com ajustes práticos — como aumentar o tamanho da heap, cachear WSDLs e dividir projetos — é possível melhorar consideravelmente a velocidade. No entanto, se a sua equipe precisa de uma ferramenta mais ágil, que evite completamente esses gargalos, o Apidog funciona sem necessidade de ambiente Java.

Experimente o Apidog hoje

💡 Apidog é uma plataforma gratuita e completa para desenvolvimento de API. Funciona direto no navegador ou em um app desktop leve, eliminando a sobrecarga da JVM. Experimente gratuitamente, sem necessidade de cartão de crédito.

Introdução

O SoapUI é lento. Se você já usou a ferramenta por algumas semanas, certamente enfrentou inicializações demoradas, UI travando ao analisar WSDLs grandes ou execução de testes arrastada com muitos steps. Esses problemas são estruturais do projeto.

Este guia detalha as causas técnicas para o SoapUI ser lento, apresenta soluções concretas para cada uma e mostra até onde é possível otimizar. Algumas lentidões têm solução; outras exigem troca de ferramenta.

Causa raiz 1: Sobrecarga de inicialização da JVM

O SoapUI é um aplicativo Java Swing. Toda vez que inicia, carrega a JVM, centenas de classes, o framework Spring, seu projeto e a UI Swing. Mesmo em SSD moderno, pode levar de 20 a 60 segundos.

Por que isso ocorre: Aplicativos Java têm custo de inicialização. A JVM interpreta ou compila JIT o bytecode antes de rodar, e a Swing adiciona mais atraso.

Como otimizar:

  • Mantenha o SoapUI aberto: Não feche entre execuções de teste. Com a JVM ativa, tudo fica mais rápido.
  • Use SSD: Instale e execute o SoapUI a partir de um SSD. O carregamento de classes é muito mais rápido do que em HDD.
  • Use Java 11 ou 17: Versões recentes da JVM têm inicialização mais rápida. Edite o caminho do Java em soapui.bat (Windows) ou soapui.sh (Linux/Mac) e aponte para um JDK mais novo.
  • Configure o AppCDS: Ative o Application Class Data Sharing da JVM adicionando os parâmetros abaixo nas opções da JVM: 
  -XX:+UseAppCDS -XX:SharedArchiveFile=soapui.jsa
Enter fullscreen mode Exit fullscreen mode

Causa raiz 2: Configurações de memória padrão muito baixas

Por padrão, o SoapUI usa pouca memória, o que gera coleta de lixo frequente e lentidão em projetos grandes.

Configuração padrão (soapui.vmoptions ou soapui.bat):

-Xms128m
-Xmx768m
Enter fullscreen mode Exit fullscreen mode

Como otimizar o uso de heap:

Windows

Edite <SoapUI_Install>/bin/SoapUI.vmoptions:

-Xms512m
-Xmx2048m
Enter fullscreen mode Exit fullscreen mode

macOS

Edite SoapUI.app/Contents/vmoptions.txt ou o arquivo soapui.sh:

JAVA_OPTS="-Xms512m -Xmx2048m -XX:+UseG1GC"
Enter fullscreen mode Exit fullscreen mode

Linux

Edite <SoapUI_Install>/bin/soapui.sh:

JAVA_OPTS="-Xms512m -Xmx2048m -XX:+UseG1GC"
Enter fullscreen mode Exit fullscreen mode

Recomendações práticas:

  • Defina -Xms (heap inicial) para 512 MB ou mais.
  • Defina -Xmx (heap máximo) para 2 GB (projetos médios) ou 4 GB (grandes), nunca acima de metade da RAM total.
  • Use -XX:+UseG1GC em Java 9+ para coleta de lixo otimizada.
  • Adicione -XX:MaxMetaspaceSize=512m para limitar o crescimento do metaspace.

Como validar:

Após reiniciar, acesse Ajuda > Propriedades do Sistema no SoapUI e confira os valores de heap. Também monitore pelo gerenciador de tarefas.

Causa raiz 3: Arquivos de projeto grandes

O SoapUI salva tudo em um único XML. Projetos grandes ou com dados binários deixam o arquivo pesado e lento para abrir/salvar.

Indícios:

  • Lags de vários segundos ao salvar.
  • Arquivo de projeto com múltiplos MB.
  • Abertura lenta mesmo com a JVM já ativa.

O que fazer:

  • Divida projetos grandes: Ative projetos compostos em Projeto > Configurações > Projeto Composto. Suítes de teste passam a ser arquivos separados, tornando o carregamento e o salvamento mais rápidos.
  • Remova casos de teste antigos: Arquive ou exclua o que não é mais necessário.
  • Externalize corpos de requisição grandes: Use o DataSource baseado em arquivo para carregar grandes payloads externos, evitando inchar o XML do projeto.
  • Desative backup automático ao sair: Em Preferências > Configurações da UI, desative a opção de backup para evitar gravação extra ao fechar.

Causa raiz 4: Atrasos na análise de WSDL

Ao abrir projetos que usam WSDL, o SoapUI pode reanalisar arquivos grandes ou remotos, causando lentidão.

Indícios:

  • UI trava ou exibe carregamento ao expandir interface.
  • Erros de timeout antes do início dos testes.
  • Diferença de tempo de carregamento em diferentes máquinas.

Como corrigir:

  • Cache local de WSDL: Clique com o direito na interface > Atualizar Definição e aponte para um WSDL local.
  • Use caminho file://: Atualize a URL do WSDL para file:///caminho/para/seu/servico.wsdl para leitura instantânea do disco.
  • Desative atualização automática: Em Preferências > WS-Security, desmarque opções de revalidação automática de WSDL.
  • Aumente timeout HTTP: Em Preferências > HTTP, aumente tempo de conexão para evitar travamentos em servidores WSDL lentos.

Causa raiz 5: Execução lenta de grandes suítes

Testes com centenas de casos e muitos scripts/asserções tendem a ser lentos.

Dicas práticas:

  • Execução paralela: No executor de TestSuite, ative “Executar casos de teste concorrentemente”. Certifique-se de que o serviço suporta concorrência.
  • Desative asserções desnecessárias: Revise e remova asserções redundantes.
  • Otimize scripts Groovy: Centralize lógica compartilhada em scripts de projeto e evite operações pesadas repetidas.
  • Use asserções de tempo de resposta com moderação: SLA altos em endpoints instáveis podem bloquear execuções.
  • Reduza logs: Em Preferências > HTTP, diminua o nível de log para grandes suítes.

O que você não pode corrigir

Alguns gargalos do SoapUI são estruturais:

  • Renderização Swing: Sempre será mais lenta que UI nativa ou web.
  • Inicialização da JVM: Pode ser otimizada, não eliminada.
  • Análise single-thread de WSDL: SoapUI analisa WSDLs sequencialmente; não há paralelismo.
  • Consumo mínimo de memória: JVM + Swing + Spring consomem de 300 a 400 MB mesmo em projetos pequenos.

Quando mudar de ferramenta

Se, após todas as otimizações, o SoapUI ainda freia seu fluxo de trabalho, talvez seja hora de migrar.

O Apidog funciona como web app ou app desktop Node.js, abre em segundos e não requer Java. Para equipes que sofrem com inicialização e lentidão de UI, trocar de ferramenta pode ser mais simples do que ajustar a JVM.

Observação: O Apidog não importa WSDL. Se você depende disso para onboarding, mantenha o SoapUI para essa etapa e use o Apidog para testes do dia a dia.

FAQ

Qual heap recomendado para projetos grandes (50+ suítes)?

  • Defina -Xmx para pelo menos 2 GB, idealmente 4 GB em máquinas com 16 GB+ de RAM. -Xms de 512 MB a 1 GB. Sempre use -XX:+UseG1GC.

Como verificar o uso de heap do SoapUI?

  • Vá em Ajuda > Propriedades do Sistema. Os argumentos da JVM estão listados. Para monitorar coleta de lixo, adicione temporariamente -verbose:gc nas opções da JVM.

Usar JDK mais recente melhora desempenho?

  • Sim. Java 11/17 trazem melhorias em inicialização e garbage collection. Sempre verifique a compatibilidade do SoapUI com o JDK escolhido.

Por que o SoapUI fica lento após horas de uso?

  • Fragmentação de memória e coleta de lixo se acumulam. Fechar e reabrir o SoapUI zera o estado. Aumentar -Xmx e usar G1GC ajuda, mas não elimina totalmente o problema.

Executar SoapUI em modo headless melhora?

  • Sim, reduz a sobrecarga da UI. Use flags como -Dorg.uncommons.watchmaker.swing.SwingEvolutionMonitor=false e prefira o testrunner CLI em pipelines CI/CD.

Como o Apidog lida com grandes coleções?

  • As coleções ficam na nuvem, carregadas sob demanda. Não existe XML local grande. Execução de testes via CLI não exige JVM.

A maioria dos problemas de desempenho do SoapUI pode ser mitigada com ajuste de heap e boas práticas. Comece pelas configurações de memória antes de partir para soluções mais avançadas.

Top comments (0)