JDB - Guia Rápido

A depuração é um procedimento técnico para localizar e remover bugs ou defeitos em um programa e obter os resultados esperados. A depuração inclui teste e monitoramento. É muito complexo quando as subunidades de um programa estão fortemente acopladas. Podemos depurar um programa usando as ferramentas de depuração que seguem as APIs prescritas. Um depurador permite percorrer todos os aspectos de um código, inspecionar todos os elementos e remover erros, se houver.

Técnicas de Depuração

Existem diferentes tipos de técnicas para depurar um programa Java. O método antigo de depuração é usando instruções de impressão no final de cada segmento que imprimirá as instruções de rastreamento no console. Dê uma olhada no código a seguir.

pubic class Add
{
   public static void main(String ar[])
   {
      int a=ar[0];
      system.out.println("A : " +a);
      int b=ar[1];
      system.out.println("B : " +b);
      int c = a + b;
      system.out.println("C = a + b : " +c);
   }
}

Aqui, temos um programa que adiciona dois números e imprime a saída. Observe que, em cada etapa, introduzimos uma instrução print que imprime o estado do programa no console. Esta é a abordagem tradicional para depurar um programa.

Além disso, temos conceitos avançados que podem ser usados ​​para depurar um programa, como:

  • stepping
  • pontos de interrupção e
  • exceções ou pontos de controle.

Tipos de depuração

Podemos depurar um programa usando vários métodos:

  • Usando bytecode Java (versão compilada do código Java)
  • Usando comentários dentro dos programas
  • Anexando classe a um programa em execução
  • Depuração remota
  • Depuração sob demanda
  • Depuração de código otimizada

Depuradores Java

Aqui estão alguns exemplos de depuradores Java disponíveis no mercado:

  • IDEs como Eclipse, Netbeans, etc. contêm seus próprios depuradores (Visual cafe, Borland, JBuilder)
  • GUIs do depurador autônomo (como Jikes, depurador da plataforma Java e JProbe)
  • Depurador de linha de comando (JDB da Sun)
  • Bloco de notas ou controlado por VI (rastreamento de pilha)

Este tutorial cobre como usar o depurador de linha de comando, jdb.

JDB

O depurador Java (JDB) é uma ferramenta para classes Java para depurar um programa na linha de comando. Ele implementa a arquitetura do depurador da plataforma Java. Ele ajuda a detectar e corrigir bugs em um programa Java usando Java Debug Interface (JDI).

JDB em JDK

A arquitetura a seguir define a função do JDB no JDK. Ele contém principalmente três unidades:

  • Java Virtual Machine Tool Interface (JVM TI)
  • Java Debug Wiring Pool (JDWP)
  • Java Debugger Interface (JDI)

JVM TI

É uma interface de programação nativa implementada por VM. Ele fornece maneiras de inspecionar e depurar o estado do aplicativo em execução na VM. Ele permite um implementador (Implementador de VM) que pode ser incluído facilmente na arquitetura de depuração. Ele também usa um canal de terceiros chamadoJDWP para comunicação.

JDWP

Ele define o formato das informações e as solicitações que passam entre o processo de depuração e o front-end do depurador. O objetivo principal de ter um JDWP é permitir que o depurado e o depurador se comuniquem quando forem executados em VMs separadas ou em plataformas separadas.

JDI

É uma interface Java de alto nível implementada como front end. Ele define as informações variáveis ​​no nível do código do usuário. É recomendado usar uma camada JDI para todo o desenvolvimento do depurador. Ele usa JDWP para comunicação com o JVM depurado.

Este capítulo explica como instalar o JDB em sistemas baseados em Windows e Linux. JDB faz parte do JDK. Portanto, a instalação do JDK é suficiente para usar o JDB no prompt de comando.

Requisitos de sistema

Aqui estão os requisitos do sistema para instalar o JDB:

JDK Java SE 2 JDK 1.5 ou superior
Memória 1 GB de RAM (recomendado)
Espaço em disco Sem requisitos mínimos
Versão do sistema operacional Windows XP ou superior, Linux

Siga as etapas simples fornecidas abaixo para instalar o JDB em seu sistema.

Etapa 1: Verificar a instalação do Java

Em primeiro lugar, você precisa ter o Java Software Development Kit (SDK) instalado em seu sistema. Para verificar isso, execute qualquer um dos dois comandos, dependendo da plataforma em que está trabalhando.

Se a instalação do Java foi feita corretamente, ele exibe a versão atual e as especificações da instalação do Java. Um exemplo de saída é fornecido na tabela a seguir.

Plataforma Comando Saída de amostra
janelas

Abra o console de comando e digite:

\>java –version

Versão Java "1.7.0_60"

Java (TM) SE Run Time Environment (build 1.7.0_60-b19)

Java Hotspot (TM) Servidor VM de 64 bits (versão 24.60-b09, modo misto)
Linux

Abra o terminal de comando e digite:

$java –version

versão java "1.7.0_25"

Open JDK Runtime Environment (rhel-2.3.10.4.el6_4-x86_64)

Abra o servidor VM JDK de 64 bits (compilação 23.7-b01, modo misto)

Presumimos que os leitores deste tutorial tenham o Java SDK versão 1.7.0_60 instalado em seus sistemas. Caso você não possua Java SDK, baixe sua versão atual no linkhttp://www.oracle.com/technetwork/java/javase/downloads/index.html e instale-o.

Etapa 2: Configurando o ambiente Java

Defina a variável de ambiente JAVA_HOME para apontar para o local do diretório base onde o Java está instalado em sua máquina. Por exemplo,

Plataforma Descrição
janelas defina JAVA_HOME para C: \ ProgramFiles \ java \ jdk1.7.0_60
Linux export JAVA_HOME = / usr / local / java

Anexe o caminho completo do local do compilador Java ao caminho do sistema.

Plataforma Descrição
janelas Anexe a string "C: \ Arquivos de programas \ Java \ jdk1.7.0_60 \ bin" no final da variável de sistema PATH.
Linux exportar PATH = $ PATH: $ JAVA_HOME / bin /

Execute o comando java -version no prompt de comando, conforme explicado acima.

Etapa 3: Verificando a instalação JDB

Verifique a versão JDB da seguinte forma:

Plataforma Comando Saída de amostra
janelas

Abra o console de comando e digite:

\>jdb –version

 Este é o JDB versão 1.6 (Java SE versão 1.7.0_60)
Linux

Abra o terminal de comando e digite:

$jdb –version

 Este é o JDB versão 1.6 (Java SE versão 1.7.0_60)

Este capítulo explica a sintaxe do comando JDB. A sintaxe contém quatro seções listadas a seguir:

  • JDB
  • option
  • class
  • arguments

Sintaxe

A sintaxe do JDB é a seguinte.

jdb [ options ] [ class ] [ arguments ]

JDB

Ele chama jdb.exe do Java Development Kit.

Opções

Isso inclui as opções de linha de comando usadas para depurar um programa Java de maneira eficiente. O lançador JDB aceita todas as opções (como -D, -classpath e -X) e algumas opções avançadas adicionais, como (-attach, -listen, -launch, etc.).

Classe

É o nome da classe na qual você deseja executar operações de depuração.

Argumentos

Estes são os valores de entrada dados a um programa em tempo de execução. Por exemplo, arg [0], arg [1] para o método main ().

Nos quatro segmentos acima, as opções são o mais importante.

Este capítulo descreve as opções importantes disponíveis no JDB que são enviadas como argumentos com o comando jdb.

Opções

A tabela a seguir contém uma lista de opções aceitas pelo JDB:

Nome Descrição
-Socorro Exibe a mensagem de ajuda e lista as opções relacionadas.
-sourcepath Usa o caminho fornecido para os arquivos de origem, se o caminho não for especificado, ele usa o caminho padrão “.”, Ou seja, o diretório atual.
-anexar Anexa o depurador à VM em execução, especificando o endereço da VM em execução.
-ouço Espera que a VM em execução se conecte usando o conector padrão.
-listenany Espera que a VM em execução se conecte usando qualquer endereço.
-lançamento Inicia o aplicativo depurado imediatamente na tarefa de inicialização.
-listconectores Lista os conectores disponíveis nesta VM.
-conectar Conecta-se à VM de destino usando um conector nomeado com valores de argumento listados.
-dbgtrace Imprime informações para depurar jdb.
-tclient Executa o aplicativo em Java Hotspot VM (cliente).
-tserver Executa o aplicativo em Java Hotspot VM (servidor).
-Jopção Passa a opção para a máquina virtual Java usada para executar JDB.

Usando opções com comandos

Os comandos a seguir mostram como usar algumas das opções acima:

-Socorro

O comando a seguir obtém -help sobre o uso de JDB.

\>jdb -help

-anexar

O comando a seguir anexa o depurador a uma VM especificada (número da porta: 1099).

\> jdb -attach 1099

-ouço

O comando a seguir faz com que o processo JDB em execução na VM atual espere usando o conector padrão (VM em 8008).

\>jdb -listen 8088

-listenany

O comando a seguir faz com que o processo JDB em execução na VM atual espere usando qualquer conector (VM na porta em execução no momento).

\>jdb –listenany

-tclient

O comando a seguir executa o aplicativo em Java Hotspot (™) VM (cliente).

\>jdb –tclient

-tserver

O comando a seguir executa o aplicativo em Java Hotspot (™) VM (servidor).

\>jdb -tserver

Este capítulo descreve como iniciar uma sessão JDB de maneiras diferentes. O lançamento de JDB é a técnica freqüentemente usada para iniciar uma sessão de JDB.

Existem duas maneiras diferentes de iniciar uma sessão JDB:

  • Iniciando a sessão JDB adicionando classe (nome da classe principal) a ela.
  • Incluindo JDB para executar JVM para iniciar a sessão.

Inicie uma Sessão Adicionando Classe

O seguinte comando inicia uma sessão JDB:

Sintaxe

\>jdb <classname>

Exemplo

Vamos supor que temos uma classe chamada TestClass. O comando a seguir inicia uma sessão JDB a partir do TestClass.

\>jdb TestClass

Se você seguir este comando, ele iniciará um novo Java VM com quaisquer parâmetros especificados. Depois disso, ele carrega a classe e a interrompe antes de executar a primeira instrução da classe.

Inicie uma sessão adicionando JDB a uma JVM em execução

A seguir, é fornecida a sintaxe e o exemplo para iniciar uma sessão JDB adicionando o JDB a uma JVM em execução.

Sintaxe

A seguinte sintaxe é para sessão JDB:

-agentlib:jdwp=transport=dt_shmem,address=
      
       ,server=y,suspend=n

Exemplo

Vamos supor que o nome da classe principal seja TestClasse o JVM permite que o JDB o conecte posteriormente. A seguir está o comando para adicionar JDB à JVM:

\>java
-agentlib:jdwp=transport=dt_shmem,address=jdbconn,server=y,suspend=n TestClass

Agora você pode anexar o JDB ao JVM com o seguinte comando:

\> jdb -attach jdbconn

Note: Aqui o TestClass não é adicionado ao comando JDB, porque JDB está conectado à VM em execução em vez de lançar uma nova.

Este capítulo apresenta os comandos básicos do JDB. Depois de iniciar uma sessão, esses comandos são usados ​​para depurar um programa.

A seguir está a lista de comandos usados ​​para depuração.

Nome Descrição
ajuda ou? O mais importante JDBcomando; ele exibe uma lista de comandos reconhecidos com uma breve descrição.
corre Depois de começar JDB e definir os pontos de interrupção necessários, você pode usar este comando para iniciar a execução e depurar um aplicativo.
cont Continua a execução do aplicativo depurado após um ponto de interrupção, exceção ou etapa.
impressão Exibe objetos Java e valores primitivos.
despejar Para valores primitivos, este comando é idêntico ao print. Para objetos, ele imprime o valor atual de cada campo definido no objeto. Campos estáticos e de instância são incluídos.
tópicos Lista os threads em execução no momento.
fio Seleciona um tópico para ser o tópico atual.
Onde Despeja a pilha do segmento atual.

Exemplo

Vamos supor que temos uma classe de amostra chamada Add para os seguintes exemplos:

Add.java

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

Compile esta classe Add.java usando o seguinte comando:

\>javac Add.java

Corre

Este comando executa o arquivo de classe principal, que é adicionado ao JDB para depuração. Execute os seguintes comandos para executar a classe Add.

\>jdb Add
initializing jdb …
>run

Ao executar esses comandos, você verá a seguinte saída:

Este capítulo explica o conceito de breakpoints e como definir breakpoints em um programa. Um ponto de interrupção introduz uma parada ou pausa explícita na execução de um programa em uma linha de código específica durante a depuração. É útil adquirir conhecimento sobre as variáveis ​​do programa em sua execução.

Sintaxe

O seguinte comando configura um ponto de interrupção em um número de linha específico:

> stop at <class name>:<Line no>

O comando a seguir configura um ponto de interrupção em um método específico ou em uma variável específica:

> stop in <class name>:< Method name | Variable name>

Exemplo

O exemplo a seguir mostra como configurar um ponto de interrupção em uma classe.

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

Salve o arquivo acima como Add.java. Compile este arquivo usando o seguinte comando:

\>javac Add.java

Depurando

Vejamos um exemplo de depuração. Aqui, começamos o processo de depuração configurando um ponto de interrupção em main (). Abaixo estão as etapas a serem seguidas no processo de depuração:

Etapa 1: iniciar uma sessão JDB

O seguinte comando inicia uma sessão JDB em Add class for debugging:

\> jdb Add

Etapa 2: definir um ponto de interrupção

O comando a seguir configura um ponto de interrupção no método main () de Add class.

> stop in Add.main

Se o ponto de interrupção for definido com sucesso, você verá a seguinte saída:

Deferring breakpoint Add.main.
It will set after the class is loaded.
>

Etapa 3: comece a depurar

O seguinte comando inicia a execução da classe Add:

> run Add

Se você executar este comando, verá a seguinte saída. Nesta saída, você descobre que a execução para na posição do ponto de interrupção, ou seja, na função main ().

A execução pára na primeira linha do método principal, ou seja, em "int a = 5, b = 6;" ou Linha nº: 11 no código. Você pode observar essas informações na saída.

Etapa 4: continuar a execução

O seguinte comando continua a execução do programa:

cont

Ele fornece a parte de execução restante e a saída da seguinte forma:

> Add:11
The application exited
\>

Este capítulo explica como usar o conceito de Stepping na depuração de um programa. A revisão é o recurso do depurador que permite executar o código percorrendo linha por linha. Usando isso, você pode examinar cada linha do código para garantir que estão se comportando conforme o esperado.

Os seguintes comandos são usados ​​no processo de revisão:

  • etapa: etapas para a próxima linha de execução
  • lista: examina onde você está no código
  • cont: continua a execução restante

Exemplo

O exemplo a seguir usa a classe Add que usamos no capítulo anterior:

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

Salve o arquivo acima como Add.java. Compile este arquivo usando o seguinte comando:

\>javac Add.java

Vamos supor que o ponto de interrupção seja definido no método main () da classe Add. As etapas a seguir mostram como aplicar a revisão na classe Adicionar.

Etapa 1: execute o trabalho

O comando a seguir começa a executar a classe chamada Add.

> run Add

Se você executar este comando, verá a seguinte saída. Nesta saída, você pode descobrir que a execução para na posição do ponto de interrupção, ou seja, no método main ().

A execução pára na primeira linha do método principal, ou seja, em "int a = 5, b = 6;" ou Linha nº: 11 no código. Você pode observar essas informações na saída.

Etapa 2: percorrer o código

O comando a seguir leva a execução para a próxima linha.

main[1] step

Agora, as etapas de execução para a linha no: 12. Você verá a seguinte saída.

Etapa 3: liste o código

O seguinte comando lista o código:

main[1] list

Você obtém a seguinte saída. O comando List é usado para informar a linha no código até a qual o controle do programa atingiu. Observe a marca de seta => na captura de tela a seguir que mostra a posição atual do controle do programa.

Etapa 4: continuar a execução

O seguinte comando continua a executar o código:

main[1] cont

Este comando continua executando as linhas restantes do código. A saída é mostrada abaixo:

> Add:11
The application exited
\>

Geralmente, existem três tipos de revisão:

  • Entrar
  • Passar por cima
  • Sair

Entrar

Usando este comando, você pode ir para a próxima linha do código. Se a próxima linha do código for uma chamada de função, ela entrará na função acionando o controle na linha superior da função.

No código a seguir, a marca de seta define o controlador no código.

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      -> Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

Se você usar o step intocomando, o controlador passa para a próxima linha, ou seja, "int c = ob.addition (a, b);". Nesta linha, há uma chamada de funçãoaddition(int, int) portanto, o controlador se move para a linha superior da função de adição com a marca de seta conforme mostrado abaixo:

public class Add
{
   public int addition( int x, int y)
   -> {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      int c = ob.addition(a,b);
   System.out.println("Add: "+c);
   }
}

Passar por cima

Step Over também executa a próxima linha. Mas se a próxima linha for uma chamada de função, ela executa essa função em segundo plano e retorna o resultado.

Vamos dar um exemplo. No código a seguir, a marca de seta define o controle no código.

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      -> Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

Se você usar o step overcomando, o controle se move para a próxima linha, ou seja, "int c = ob.addition (a, b);". Nesta linha, há uma chamada de funçãoaddition(int, int) portanto, a execução da função é feita em segundo plano e o resultado é retornado para a linha atual com a marca de seta, conforme mostrado abaixo:

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      -> int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

Sair

Step Out executa a próxima linha. Se a próxima linha for uma chamada de função, ela a ignora e a execução da função continua com as linhas restantes do código.

Vamos dar um exemplo. No código a seguir, a marca de seta define o controlador no código.

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      -> Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

Se você usar o step outcomando, o controlador passa para a próxima linha, ou seja, "int c = ob.addition (a, b);". Nesta linha, há uma chamada de funçãoaddition(int, int) portanto, a execução da função é ignorada e a execução restante continua com a marca de seta, conforme mostrado abaixo:

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      -> int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

Este capítulo explica como lidar com a classe de exceção usando JDB. Geralmente, sempre que um programa levanta uma exceção sem uma instrução catch, a VM imprime a linha de exceção, a causa da exceção e sai. Se a exceção foi gerada com uma instrução catch, a exceção é tratada pela instrução catch. Aqui, a VM imprime a saída com a causa da exceção.

Quando a classe que levanta a exceção está em execução no JDB, ela também lança o uncaughtexceção. Essa exceção pode ser tratada usando ocatch comando.

Exemplo

Vamos dar um exemplo da classe JdbException:

public class JdbException
{
   public static void main(String ar[]) throws Exception
   {
      int a=8, b=0;
      System.out.println("Welcome");
      System.out.println("Ex: "+(a/b));
   }
}

Salve o arquivo acima com o nome JdbException.java. Compile este arquivo usando o seguinte comando:

\>javac JdbException.java

Siga as etapas fornecidas abaixo para lidar com a exceção.

Etapa 1: Executar a aula

O seguinte comando executa a classe chamada JdbException do seguinte modo:

\>jdb JdbException
>run

este JdbException classe contém uma exceção, portanto, você verá a seguinte saída:

Etapa 2: pegue a exceção

O seguinte comando captura a exceção:

mian[1] catch java.lang.ArithmeticException

Ele fornecerá a seguinte saída:

Set all java.lang.ArithmeticException

Etapa 3: continuar a execução

O seguinte comando continua a execução. Agora, o catch trata a exceção aritmética da seguinte maneira:

Este capítulo explica como usar JDB no Eclipse. Antes de prosseguir, você precisa instalar o Eclipse Indigo. Siga as etapas fornecidas abaixo para instalar o Eclipse Indigo em seu sistema.

Etapa 1: Baixe e instale o Eclipse

Você pode baixar o Eclipse no seguinte link: http://www.eclipse.org/downloads/packages/eclipse-ide-java-ee-developers/indigosr2

Etapa 2: Criar um novo projeto e uma nova classe

  • Crie um novo projeto Java seguindo as opções File-> New -> Java project.
  • Nomeie como “sampledebug”.
  • Crie uma nova classe clicando com o botão direito no samplebebug projeto.
  • Selecione options ->new -> class
  • Nomeie como “Add.java”

Add.java

public class Add
{
   public int addition( int x, int y)
   {
      int z = x+y;
      return z;
   }
   public static void main( String ar[ ] )
   {
      int a = 5, b = 6;
      Add ob = new Add();
      int c = ob.addition(a,b);
      System.out.println("Add: "+c);
   }
}

Etapa 3: abrir a perspectiva de depuração

Siga as instruções fornecidas abaixo para abrir a perspectiva de depuração.

No IDE Eclipse, vá para Window -> Open perspective -> Debug. Agora você obtém a perspectiva de depuração do programa Add.java. Você verá a seguinte janela.

Seções na perspectiva de depuração

As seções na perspectiva de depuração são as seguintes:

Seção de Codificação

O código Java é exibido nesta seção. É o código que você deseja depurar, ou seja,Add.java. Aqui podemos adicionar um ponto de interrupção em uma linha clicando duas vezes na frente da linha. Você encontra a bolha azul com um símbolo de seta para apontar o ponto de interrupção dessa linha. Veja a imagem a seguir; você pode encontrar a área selecionada com um círculo vermelho apontado como “1”.

  1. Clique duas vezes aqui. Você pode definir o ponto de interrupção para esta linha.

Seção Breakpoint

Esta seção define a lista de pontos de interrupção definidos para o código do programa. Aqui podemos adicionar, excluir, localizar e gerenciar os pontos de interrupção. A captura de tela a seguir mostra a seção do ponto de interrupção.

Observe as seguintes opções na captura de tela fornecida:

  1. Usando a caixa de seleção à esquerda, podemos selecionar ou desmarcar um ponto de interrupção. Aqui, usamos um ponto de interrupção, ou seja, o método Add class-main ().

  2. O ícone de cruz única “X” é usado para excluir o ponto de interrupção selecionado.

  3. O ícone de cruz dupla “XX” é usado para excluir todos os pontos de interrupção em seu código.

  4. O ponteiro de seta é usado para apontar para o código onde o ponto de interrupção selecionado é aplicado.

As funcionalidades restantes na seção de ponto de interrupção são as seguintes:

  • Hitcount: Mostra quantas vezes o controle atinge este ponto de interrupção. É usado para lógica recursiva.

  • Suspend thread : Podemos suspender o tópico atual selecionando-o.

  • Suspend VM : Podemos suspender a VM selecionando-a.

Seção de depuração

Esta seção é usada para o processo de depuração. Ele contém opções que são usadas na depuração.

Start debugging : Siga as instruções fornecidas abaixo para iniciar a depuração.

Clique com o botão direito no code -> clique Debug as -> clique 1 Java application.

O processo de depuração começa conforme mostrado na imagem a seguir. Ele contém algumas opções selecionadas, destacadas com dígitos numéricos.

  1. Aplicamos um ponto de interrupção no método main () Add class. Quando começamos a depurar, ocontroller fica preso na primeira linha do método main ().

  2. É usado para Resumeo processo de depuração e pule o ponto de interrupção atual. Funciona de forma semelhante aocont comando na linha de comandos JDB.

  3. É usado para interromper o processo de depuração.

  4. Funciona de forma semelhante ao step inprocesso na linha de comando JDB. É usado para mover o controle para a próxima linha, ou seja, o ponto “1” move para a próxima linha.

  5. Funciona de forma semelhante ao step over processo na linha de comando JDB.

  6. É usado para ver em qual linha o breakpoint é aplicado.

Siga as etapas e seções fornecidas para depurar seu código no Eclipse IDE. Por padrão, todo IDE contém esse processo de depuração.