JDB - Guía rápida

La depuración es un procedimiento técnico para encontrar y eliminar errores o defectos en un programa y obtener los resultados esperados. La depuración incluye pruebas y monitoreo. Es muy complejo cuando las subunidades de un programa están estrechamente acopladas. Podemos depurar un programa utilizando las herramientas de depuración que siguen las API prescritas. Un depurador le permite revisar cada aspecto de un código, inspeccionar todos los elementos y eliminar errores, si los hubiera.

Técnicas de depuración

Existen diferentes tipos de técnicas para depurar un programa Java. El antiguo método de depuración es mediante el uso de declaraciones de impresión al final de cada segmento que imprimirá las declaraciones de seguimiento en la consola. Eche un vistazo al siguiente código.

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);
   }
}

Aquí, tenemos un programa que suma dos números e imprime la salida. Observe que en cada paso, hemos introducido una declaración de impresión que imprime el estado del programa en la consola. Este es el enfoque tradicional para depurar un programa.

Además, contamos con conceptos avanzados que se pueden utilizar para depurar un programa como:

  • stepping
  • puntos de interrupción, y
  • excepciones o puntos de observación.

Tipos de depuración

Podemos depurar un programa usando varios métodos:

  • Usando código de bytes Java (versión compilada del código Java)
  • Usar comentarios dentro de los programas
  • Adjuntar clase a un programa en ejecución
  • Depuración remota
  • Depuración bajo demanda
  • Depuración de código optimizada

Depuradores de Java

A continuación, se muestran algunos ejemplos de depuradores de Java disponibles en el mercado:

  • Los IDE como Eclipse, Netbeans, etc. contienen sus propios depuradores (Visual cafe, Borland, JBuilder)
  • GUI de depurador independiente (como Jikes, depurador de plataforma Java y JProbe)
  • Depurador de línea de comandos (JDB de Sun)
  • Bloc de notas o VI impulsado (seguimiento de pila)

Este tutorial cubre cómo usar el depurador de línea de comandos, jdb.

JDB

El depurador de Java (JDB) es una herramienta para que las clases de Java depuren un programa en la línea de comandos. Implementa la arquitectura del depurador de la plataforma Java. Ayuda a detectar y corregir errores en un programa Java usando la Interfaz de depuración Java (JDI).

JDB en JDK

La siguiente arquitectura define el rol de JDB en JDK. Contiene principalmente tres unidades:

  • Interfaz Java Virtual Machine Tool (JVM TI)
  • Grupo de cableado de depuración de Java (JDWP)
  • Interfaz de depurador de Java (JDI)

JVM TI

Es una interfaz de programación nativa implementada por VM. Proporciona formas de inspeccionar y depurar el estado de la aplicación que se ejecuta en la máquina virtual. Permite un implementador (VM Implementer) que se puede incluir fácilmente en la arquitectura de depuración. También utiliza un canal de terceros llamadoJDWP para comunicarse.

JDWP

Define el formato de la información y las solicitudes que pasan entre el proceso de depuración y la interfaz del depurador. El propósito principal de tener un JDWP es permitir que el depurador y el depurador se comuniquen cuando se ejecutan en máquinas virtuales separadas o en plataformas separadas.

JDI

Es una interfaz Java de alto nivel implementada como front-end. Define la información variable a nivel de código de usuario. Se recomienda utilizar una capa JDI para todo el desarrollo de depuradores. Utiliza JDWP para comunicarse con la JVM depurada.

Este capítulo explica cómo instalar JDB en sistemas basados ​​en Windows y Linux. JDB es parte de JDK. Por lo tanto, la instalación de JDK es suficiente para usar JDB en el símbolo del sistema.

Requisitos del sistema

Estos son los requisitos del sistema para instalar JDB:

JDK Java SE 2 JDK 1.5 o superior
Memoria 1 GB de RAM (recomendado)
Espacio del disco Sin requisito mínimo
Versión del sistema operativo Windows XP o superior, Linux

Siga los sencillos pasos que se indican a continuación para instalar JDB en su sistema.

Paso 1: verificar la instalación de Java

En primer lugar, debe tener instalado el kit de desarrollo de software (SDK) de Java en su sistema. Para verificar esto, ejecute cualquiera de los dos comandos dependiendo de la plataforma en la que esté trabajando.

Si la instalación de Java se ha realizado correctamente, muestra la versión actual y las especificaciones de la instalación de Java. En la siguiente tabla se proporciona un resultado de muestra.

Plataforma Mando Salida de muestra
Ventanas

Abra la consola de comandos y escriba:

\>java –version

Versión de Java "1.7.0_60"

Entorno de tiempo de ejecución Java (TM) SE (compilación 1.7.0_60-b19)

VM de servidor Java Hotspot (TM) de 64 bits (compilación 24.60-b09, modo mixto)
Linux

Abra el terminal de comando y escriba:

$java –version

versión de Java "1.7.0_25"

Entorno de tiempo de ejecución abierto de JDK (rhel-2.3.10.4.el6_4-x86_64)

Abra la máquina virtual del servidor JDK de 64 bits (compilación 23.7-b01, modo mixto)

Suponemos que los lectores de este tutorial tienen la versión 1.7.0_60 de Java SDK instalada en su sistema. En caso de que no tenga Java SDK, descargue su versión actual desde el enlacehttp://www.oracle.com/technetwork/java/javase/downloads/index.html e instalarlo.

Paso 2: Configurar el entorno Java

Configure la variable de entorno JAVA_HOME para que apunte a la ubicación del directorio base donde está instalado Java en su máquina. Por ejemplo,

Plataforma Descripción
Ventanas establezca JAVA_HOME en C: \ ProgramFiles \ java \ jdk1.7.0_60
Linux exportar JAVA_HOME = / usr / local / java

Agregue la ruta completa de la ubicación del compilador Java a la ruta del sistema.

Plataforma Descripción
Ventanas Agregue la cadena "C: \ Archivos de programa \ Java \ jdk1.7.0_60 \ bin" al final de la variable de sistema PATH.
Linux export PATH = $ PATH: $ JAVA_HOME / bin /

Ejecuta el comando java -version desde el símbolo del sistema como se explicó anteriormente.

Paso 3: Verificación de la instalación de JDB

Verifique la versión de JDB de la siguiente manera:

Plataforma Mando Salida de muestra
Ventanas

Abra la consola de comandos y escriba:

\>jdb –version

 Esta es la versión 1.6 de JDB (Java SE versión 1.7.0_60)
Linux

Abra el terminal de comando y escriba:

$jdb –version

 Esta es la versión 1.6 de JDB (Java SE versión 1.7.0_60)

Este capítulo explica la sintaxis del comando JDB. La sintaxis contiene cuatro secciones enumeradas a continuación:

  • JDB
  • option
  • class
  • arguments

Sintaxis

La sintaxis de JDB es la siguiente.

jdb [ options ] [ class ] [ arguments ]

JDB

Llama a jdb.exe desde el kit de desarrollo de Java.

Opciones

Estos incluyen las opciones de la línea de comandos que se utilizan para depurar un programa Java de manera eficiente. El iniciador de JDB acepta todas las opciones (como -D, -classpath y -X) y algunas opciones avanzadas adicionales como (-attach, -listen, -launch, etc.).

Clase

Es el nombre de la clase en la que desea realizar las operaciones de depuración.

Argumentos

Estos son los valores de entrada dados a un programa en tiempo de ejecución. Por ejemplo, arg [0], arg [1] al método main ().

En los cuatro segmentos anteriores, las opciones son las más importantes.

Este capítulo describe las opciones importantes disponibles en JDB que se envían como argumentos con el comando jdb.

Opciones

La siguiente tabla contiene una lista de opciones aceptadas por JDB:

Nombre Descripción
-ayuda Muestra el mensaje de ayuda y enumera las opciones relacionadas.
-sourcepath Utiliza la ruta dada para los archivos de origen si no se especifica la ruta, entonces toma la ruta predeterminada “.”, Es decir, el directorio actual.
-adjuntar Adjunta el depurador a la máquina virtual en ejecución especificando la dirección de la máquina virtual en ejecución.
-escucha Espera a que la máquina virtual en ejecución se conecte mediante un conector estándar.
-escuchar cualquier Espera a que la máquina virtual en ejecución se conecte utilizando cualquier dirección.
-lanzamiento Inicia la aplicación depurada inmediatamente en el trabajo de inicio.
-lista de conectores Enumera los conectores disponibles en esta VM.
-conectar Se conecta a la máquina virtual de destino mediante un conector con nombre con los valores de los argumentos enumerados.
-dbgtrace Imprime información para depurar jdb.
-tclient Ejecuta la aplicación en Java Hotspot VM (cliente).
-servidor Ejecuta la aplicación en Java Hotspot VM (servidor).
-Jopción Pasa la opción a la máquina virtual Java utilizada para ejecutar JDB.

Usar opciones con comandos

Los siguientes comandos muestran cómo utilizar algunas de las opciones anteriores:

-ayuda

El siguiente comando obtiene -ayuda sobre el uso de JDB.

\>jdb -help

-adjuntar

El siguiente comando adjunta el depurador a una máquina virtual específica (número de puerto: 1099).

\> jdb -attach 1099

-escucha

El siguiente comando hace que el proceso JDB que se ejecuta en la VM actual espere usando el conector estándar (VM en 8008).

\>jdb -listen 8088

-escuchar cualquier

El siguiente comando hace que el proceso de JDB que se ejecuta en la VM actual espere usando cualquier conector (VM en el puerto que se está ejecutando actualmente).

\>jdb –listenany

-tclient

El siguiente comando ejecuta la aplicación en Java Hotspot (™) VM (cliente).

\>jdb –tclient

-servidor

El siguiente comando ejecuta la aplicación en Java Hotspot (™) VM (servidor).

\>jdb -tserver

Este capítulo describe cómo iniciar una sesión JDB de diferentes formas. El lanzamiento de JDB es la técnica que se utiliza con frecuencia para iniciar una sesión de JDB.

Hay dos formas diferentes de iniciar una sesión JDB:

  • Iniciando la sesión de JDB agregando la clase (nombre de la clase principal).
  • Adición de JDB para ejecutar JVM para iniciar la sesión.

Iniciar una sesión agregando una clase

El siguiente comando inicia una sesión de JDB:

Sintaxis

\>jdb <classname>

Ejemplo

Supongamos que tenemos una clase llamada TestClass. El siguiente comando inicia una sesión JDB desde TestClass.

\>jdb TestClass

Si sigue este comando, inicia una nueva máquina virtual Java con los parámetros especificados. A continuación, carga la clase y la detiene antes de ejecutar la primera instrucción de la clase.

Inicie una sesión agregando JDB a una JVM en ejecución

A continuación se muestra la sintaxis y el ejemplo para iniciar una sesión JDB agregando el JDB a una JVM en ejecución.

Sintaxis

La siguiente sintaxis es para la sesión JDB:

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

Ejemplo

Supongamos que el nombre de la clase principal es TestClassy JVM permite que JDB lo conecte más tarde. El siguiente es el comando para agregar JDB a JVM:

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

Ahora puede adjuntar la JDB a la JVM con el siguiente comando:

\> jdb -attach jdbconn

Note: Aquí el TestClass no se agrega al comando JDB, porque JDB está conectado a la VM en ejecución en lugar de lanzar una nueva.

Este capítulo lo lleva a través de los comandos básicos de JDB. Después de iniciar una sesión, estos comandos se utilizan para depurar un programa.

La siguiente es la lista de comandos utilizados para depurar.

Nombre Descripción
ayuda o? El más importante JDBmando; muestra una lista de comandos reconocidos con una breve descripción.
correr Después de comenzar JDB y estableciendo los puntos de interrupción necesarios, puede utilizar este comando para iniciar la ejecución y depurar una aplicación.
cont Continúa la ejecución de la aplicación depurada después de un punto de interrupción, una excepción o un paso.
impresión Muestra objetos Java y valores primitivos.
tugurio Para valores primitivos, este comando es idéntico a imprimir. Para los objetos, imprime el valor actual de cada campo definido en el objeto. Se incluyen campos estáticos y de instancia.
hilos Enumera los subprocesos que se están ejecutando actualmente.
hilo Selecciona un hilo para que sea el hilo actual.
dónde Vuelca la pila del hilo actual.

Ejemplo

Supongamos que tenemos una clase de muestra llamada Add para los siguientes ejemplos:

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 clase Add.java usando el siguiente comando:

\>javac Add.java

correr

Este comando ejecuta el archivo de clase principal, que se agrega a JDB para su depuración. Ejecute los siguientes comandos para ejecutar la clase Add.

\>jdb Add
initializing jdb …
>run

Al ejecutar estos comandos, puede ver el siguiente resultado:

Este capítulo explica el concepto de puntos de interrupción y cómo establecer puntos de interrupción en un programa. Un punto de interrupción introduce una parada o pausa explícita en la ejecución de un programa en una línea particular de código durante la depuración. Es útil adquirir conocimientos sobre las variables del programa en su ejecución.

Sintaxis

El siguiente comando establece un punto de interrupción en un número de línea en particular:

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

El siguiente comando establece un punto de interrupción en un método en particular o en una variable en particular:

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

Ejemplo

El siguiente ejemplo muestra cómo configurar un punto de interrupción en una clase.

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);
   }
}

Guarde el archivo anterior como Add.java. Compile este archivo usando el siguiente comando:

\>javac Add.java

Depuración

Tomemos un ejemplo de depuración. Aquí, comenzamos el proceso de depuración configurando un punto de interrupción en main (). A continuación se muestran los pasos a seguir en el proceso de depuración:

Paso 1: Inicie una sesión JDB

El siguiente comando inicia una sesión de JDB en la clase Add para depurar:

\> jdb Add

Paso 2: establece un punto de interrupción

El siguiente comando establece un punto de interrupción en el método main () de la clase Add.

> stop in Add.main

Si el punto de interrupción se establece correctamente, puede ver el siguiente resultado:

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

Paso 3: comience a depurar

El siguiente comando inicia la ejecución de la clase Add:

> run Add

Si ejecuta este comando, verá el siguiente resultado. En esta salida, encuentra que la ejecución se detiene en la posición del punto de interrupción, es decir, en la función main ().

La ejecución se detiene en la primera línea del método principal, es decir, en "int a = 5, b = 6;" o Línea no: 11 en el código. Puede observar esta información en la salida.

Paso 4: continuar con la ejecución

El siguiente comando continúa la ejecución del programa:

cont

Le da la parte de ejecución restante y la salida de la siguiente manera:

> Add:11
The application exited
\>

Este capítulo explica cómo utilizar el concepto de Stepping al depurar un programa. Stepping es la función del depurador que le permite ejecutar el código pasando línea por línea. Con esto, puede examinar cada línea del código para asegurarse de que se comportan según lo previsto.

Los siguientes comandos se utilizan en el proceso de creación de pasos:

  • paso: pasos a la siguiente línea de ejecución
  • lista: examina dónde se encuentra en el código
  • cont: continúa la ejecución restante

Ejemplo

El siguiente ejemplo usa la clase Add que hemos usado en el 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);
   }
}

Guarde el archivo anterior como Add.java. Compile este archivo usando el siguiente comando:

\>javac Add.java

Supongamos que el punto de interrupción se establece en el método main () de la clase Add. Los siguientes pasos muestran cómo aplicar el paso a paso en la clase Agregar.

Paso 1: ejecutar el trabajo

El siguiente comando comienza a ejecutar la clase llamada Agregar.

> run Add

If you execute this command, you get to see the following output. In this output, you can find that the execution stops at the breakpoint position, i.e., at the main() method.

The execution stops at the first line of the main method, that is at "int a=5, b=6;" or Line no: 11 in the code. You can observe this information in the output.

Step 2: Step through the Code

The following command steps the execution to the next line.

main[1] step

Now the execution steps to Line no: 12. You get to see the following output.

Step 3: List the Code

The following command lists the code:

main[1] list

You get the following output. List command is used to let you know the line in the code up to which the program control has reached. Notice the arrow mark => in the following screenshot that shows the current position of the program control.

Step 4: Continue Execution

The following command continues to execute the code:

main[1] cont

This command continues executing the remaining lines of the code. The output is as shown below:

> Add:11
The application exited
\>

Generally, there are three types of stepping:

  • Step Into
  • Step Over
  • Step Out

Step Into

Using this command, you can step to the next line of the code. If the next line of the code is a function call, then it enters the function by driving the control at the top line of the function.

In the following code, the arrow mark defines the controller in the code.

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);
   }
}

If you use the step into command, the controller moves to the next line, i.e., "int c = ob.addition(a,b);". At this line, there is a function call addition(int, int) hence the controller moves to the topmost line of the addition function with the arrow mark as shown below:

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);
   }
}

Step Over

Step Over also executes the next line. But if the next line is a function call, it executes that function in the background and returns the result.

Let us take an example. In the following code, the arrow mark defines the control in the code.

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);
   }
}

If you use the step over command, the control moves to the next line, i.e., "int c = ob.addition(a,b);". In this line, there is a function call addition(int, int) hence the function execution is done in the background and the result is returned to the current line with the arrow mark as shown below:

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);
   }
}

Step Out

Step Out executes the next line. If the next line is a function call, it skips that and the function execution continues with the remaining lines of the code.

Let us take an example. In the following code, the arrow mark defines the controller in the code.

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);
   }
}

If you use the step out command, the controller moves to the next line, i.e., "int c = ob.addition(a,b);". In this line, there is a function call addition(int, int) hence the function execution is skipped and the remaining execution continues with the arrow mark as shown below:

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);
   }
}

This chapter explains how to handle the exception class using JDB. Generally, whenever a program raises an exception without a catch statement, then the VM prints the exception line, the cause of the exception, and exits. If the exception has been raised with a catch statement, then the exception is handled by the catch statement. Here, the VM prints the output with the cause of exception.

When the class that raises the exception is running under JDB, it also throws the uncaught exception. That exception can be handled using the catch command.

Example

Let us take an example of the class 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));
   }
}

Save the above file with the name JdbException.java. Compile this file using the following command:

\>javac JdbException.java

Follow the steps given below to handle the exception.

Step 1: Run the Class

The following command executes the class named JdbException as follows:

\>jdb JdbException
>run

This JdbException class contains an exception, hence you get to see the following output:

Step 2: Catch the Exception

The following command catches the exception:

mian[1] catch java.lang.ArithmeticException

It will give you the following output:

Set all java.lang.ArithmeticException

Step 3: Continue Execution

The following command continues the execution. Now the catch handles the arithmetic exception as follows:

This chapter explains how to use JDB in Eclipse. Before proceeding further, you need to install Eclipse Indigo. Follow the steps given below to install Eclipse Indigo on your system.

Step 1: Download and Install Eclipse

You can download Eclipse from the following link: http://www.eclipse.org/downloads/packages/eclipse-ide-java-ee-developers/indigosr2

Step 2: Create a New Project and a New Class

  • Create a new Java project by following the options File-> New -> Java project.
  • Name it as “sampledebug”.
  • Create a new class by right clicking on the samplebebug project.
  • Select options ->new -> class
  • Name it as “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);
   }
}

Step 3: Open the Debug Perspective

Follow the instructions given below to open the debug perspective.

On the Eclipse IDE, go to Window -> Open perspective -> Debug. Now you get the debug perspective for the program Add.java. You get to see the following window.

Sections in Debug Perspective

The sections in the Debug perspective are as follows:

Coding Section

Java code is displayed in this section. It is the code you want to debug, that is, Add.java. Here we can add a breakpoint on a line by double clicking in front of the line. You find the blue bubble with an arrow symbol to point out the breakpoint of that line. See the following screenshot; you can find the selected area with a red circle pointed as “1”.

  1. Double click here. You can set the breakpoint for this line.

Breakpoint Section

This section defines the list of breakpoints that are set to the program code. Here we can add, delete, find, and manage the breakpoints. The following screenshot shows the breakpoint section.

Observe the following options in the given screenshot:

  1. Using the check box in the left, we can select or deselect a breakpoint. Here, we use one breakpoint, i.e., Add class-main() method.

  2. The single cross icon “X” is used to delete the selected breakpoint.

  3. The double cross icon “XX” is used to delete all the breakpoints in your code.

  4. The arrow pointer is used to point to the code where the selected breakpoint is applied.

The remaining functionalities in the breakpoint section are as follows:

  • Hitcount : It shows how many times the control hits this breakpoint. It is used for recursive logic.

  • Suspend thread : We can suspend the current thread by selecting it.

  • Suspend VM : We can suspend the VM by selecting it.

Debug Section

This section is used for the process of debugging. It contains options that are used in debugging.

Start debugging : Follow the instructions given below to start debugging.

Right click on the code -> click Debug as -> click 1 Java application.

The process of debugging starts as shown in the following screenshot. It contains some selected options, highlighted using numeric digits.

  1. We apply a breakpoint on the Add class main() method. When we start debugging, the controller gets stuck at the first line of the main() method.

  2. It is used to Resume the debugging process and skip the current breakpoint. It works similar to the cont command in the JDB command line.

  3. It is used to stop the debugging process.

  4. It works similar to the step in process in the JDB command line. It is used for moving the control to the next line, i.e., point “1” moves to the next line.

  5. It works similar to the step over process in the JDB command line.

  6. It is used to see on which line the breakpoint is applied.

Follow the given steps and sections to debug your code in eclipse IDE. By default, every IDE contains this debugging process.