1 / 15

Depurando con Eclipse (Debugging)

Veamos cómo depurar con Eclipse.

Contenidos

1. Introducción ............................................................................................................ 2

1.1. ¿Qué es depurar? .......................................................................................... 2

1.2. Depuración en Eclipse ................................................................................. 2

2. Debugging in Eclipse ............................................................................................ 2

2.1. Estableciendo Puntos de ruptura (Breakpoints) ....................................... 2

2.2. Inicializando el Depurador (Debugger) ...................................................... 3

2.3. Controlando la ejecución del programa (F5, F6, F7 y F8) ....................... 5

2.4. Pestaña de breakpoints ................................................................................ 6

4.5. Evaluación de variables en el depurador (debugger) .............................. 7

2.6. Cambiando el contenido de las variables con el depurador ................... 7

2.7. Control de la visualización de las variables con Detail Formatter .......... 7

3. Depuración avanzada ........................................................................................... 9

3.1. Propiedades de los puntos de ruptura ........................................................ 9

3.2. Punto de observación (Watchpoint) ......................................................... 10

3.3. Puntos de ruptura de excepciones (Exception breakpoints) ................. 10

3.4. Puntos de ruptura en métodos (Method breakpoint) .............................. 10

3.5. Puntos de ruptura en la carga de clases (Breakpoints for loading classes) ................................................................................................................. 11

3.6. Filtro de pasos (Step Filter) ........................................................................ 12

3.7. Hit Count ........................................................................................................ 13

3.8. Remote debugging ....................................................................................... 13

Note ........................................................................ ¡Error! Marcador no definido. 3.9. Salto al nivel (Drop to frame) ..................................................................... 14

4. Exercise: Create Project for debugging ........................................................... 15

4.1. Create Project ............................................................................................... 15

4.2. Debugging ..................................................................................................... 15

5. Debugging Links .................................................................................................. 15

2 / 15

1. Introducción

1.1. ¿Qué es depurar?

Depurar te permite ejecutar un programa interactivamente mientras ves el código fuente y las

variables durante la ejecución.

Con los puntos de ruptura (breakpoints) en el código fuente especificas donde debe parar la

ejecución del programa. Para parar la ejecución sólo si un campo es leido o modificado,

podemos usar los inspectores (watchpoints)

Una vez que el programa está parado podemos investigar variables, cambiar su contenido,

etc…

1.2. Depuración en Eclipse

Eclipse permite lanzar un programa Java en el modo Debug.

Eclipse tiene una perspectiva para el modo de depuración que nos permitirá controlar la

ejecución del programa e investigar el estado de las variables.

2. Debugging in Eclipse

2.1. Estableciendo Puntos de ruptura (Breakpoints)

Para colocar un punto de ruptura en tu código fuente, activa menú de contexto en el margen

izquierdo de tu código y selecciona Toggle Breakpoint. Se desactiva de la misma manera.

3 / 15

Vamos a abrir el archivo ForEach.java y colocamos un punto de ruptura en la línea 18.

2.2. Inicializando el Depurador (Debugger)

Para depurar la aplicación active el menu de contexto sobre el archive deseado y

selecciona Debug As → Java Application.

4 / 15

También podremos pulsar el botón Debug en la barra de herramientas de Eclipse.

Si no hemos definido ningún breakpoints, el programa se ejecutará normalmente.

5 / 15

Cuando entras en el depurador Eclipse te pregunta si quieres cambiar a la

Debug perspective .

Tras contestar Si aparecerá una pantalla como la siguiente:

2.3. Controlando la ejecución del programa (F5, F6, F7 y F8)

Eclipse proporciona botones en la barra de herramientas para controlar la ejecución del

programa que estamos depurando.

Podremos usar las teclas F5, F6, F7 y F8.

Teclas de control de ejecución del depurador

tecla Descripción

6 / 15

tecla Descripción

F5 Ejecuta la línea seleccionada y va a la siguiente línea. Si la línea es una llamada a

un método salta a sus líneas de código y las ejecuta paso a paso.

F6 F6 ejecuta las llamadas en un solo paso. Si hay una llamada de método en la

línea actual, se ejecuta la llamada al método internamente y sólo se mueve el

control a la siguiente línea.

F7 F7 sale del método que se está ejecutando y devuelve el control al método que lo

llamó.

F8 F8 dice al depurador que ejecute el código hasta el siguiente breakpoint o

watchpoint.

La denominada “pila de llamadas” muestra la parte del programa que está ejecutándose.

2.4. Pestaña de breakpoints

La pestaña (view) Breakpoints permite borrar y desactivar puntos de parada.

Para desactivar o borrar un breakpoint deberemos pulsaremos el botón correspondiente

icono. Observa la siguiente imagen.

Si tan solo queremos desactivar todos y saltárlos deberemos presionar sobre Skip all

breakpoints. Si lo vuelves a presionar se vuelven a activar.

7 / 15

4.5. Evaluación de variables en el depurador (debugger)

La pestaña de Variables muestra los campos y variables locales en los programas en

ejecución. El depurador debe estar lanzado.

Mediante el menú desplegable (drop-down menu) podemos ver y/o cambiar el contenido de

las variables e incluso personalizar la información que presenta

2.6. Cambiando el contenido de las variables con el depurador

En la pestaña de variables podremos incluso cambiar el contenido de las variables para

hacer la ejecución.

2.7. Control de la visualización de las variables con Detail Formatter

Por defecto la pestaña de Variables view usa el toString() método para determinar como

va a mostrarse una variable.

8 / 15

Podemos definer cómo se van a mostrar las variables usando Detail Formatter. En nuestro

ejemplo toString() method muestra la colección entre corchetes y separando por comas

los elementos y de las cadenas muestra el contenido. Si queremos modificar la forma de

presentar esta información activaremos el menu de contexto y seleccionaremos Detail

Formater. Para las cadenas podremos detallar la información según nuestros intereses.

En nuestro ejemplo hacemos que nos presenta la cadena mostrando primero el tamaño de

ésta, después unas comillas de apertura y cierre y dentro el contenido de la cadena.

9 / 15

3. Depuración avanzada

3.1. Propiedades de los puntos de ruptura

Tras colocar el punto de ruptura podremos modificar sus propiedades activando el menú de

contexto del mismo. Podremos poner condiciones como la activación ante determinadas

condiciones.

Este es el menu de contexto del punto de ruptura.

En nuestro ejemplo le decimos que, en el bucle para, se detenga cuando lleve 25 iteraciones,

de esta manera conseguimos que se pare cuando haya escrito hasta la ‘z’.

Podemos poner condiciones que harán que se ejecute el punto de ruptura cuando sean

ciertas.

10 / 15

3.2. Punto de observación (Watchpoint)

Un watchpoint es un punto de ruptura pero asignado a una variable. El depurador parará

cuando el campo sea leído o cambiado.

Para poner un punto de observación, sobre un atributo de una clase, haremos doble click

en el margen izquierdo cuando se declara la variable. En las propiedades podremos

configurar si el watchpoint debe parar durante la lectura, la escritura o ambos.

Si pulsamos Ctrl + Shift + D o Ctrl + Shift + i sobre en una variable o expresión seleccionada

se mostrará el valor. También podemos añadir un seguimiento permanente de la expresión /

variable que se mostrará en expresiones ver depuración cuando está encendido.

3.3. Puntos de ruptura de excepciones (Exception breakpoints)

Puedes poner puntos de ruptura cuando se lanza una excepción. Para definirla haremos click

en el botón Add Java Exception Breakpoint en la barra de tareas de Breakpoints.

Podremos configurar que pare cuando se captura o cuando no se captura la excepción.

3.4. Puntos de ruptura en métodos (Method breakpoint)

11 / 15

Un punto de ruptura en un método se define hacienda doble click en el margen izquierdo del

editor junto a la cabecera del método.

Podremos configurar si queremos que pare el programa antes de entrar o después de salir

del método.

3.5. Puntos de ruptura en la carga de clases (Breakpoints for loading classes)

Se parará la ejecución del programa cuando se carga una clase.

Para poner un punto de ruptura cuando se carga una clase, active el menu de contexto en la

clase en la vista Outline y elije la opción Toggle Class Load Breakpoint.

12 / 15

También podremos hacer doble click en el borde izquierdo del editor de Java junto a la

definición de la clase.

3.6. Filtro de pasos (Step Filter)

Podemos definir que ciertos paquetes deben saltarse depurando.

Esto es útil si usas un esquema o plantilla (framework) para chequear las clases. Este

paquete puede configurarse Window → Preferences → Java → Debug → Step Filtering. O

cuando entramos (F5) en un método que puede entrar en las bibliotecas externas (como

Java) y es posible que no lo necesitemos. Podemos añadir un filtro en las preferencias y que

no incluyan los paquetes.

13 / 15

3.7. Contador de visitas o de paso( Hit Count)

Para cada punto de ruptura podemos especificar un contador de paso en propiedades. La

aplicación es detenida cada vez que el punto de ruptura ha sido ejecutado el número de

veces definido en el contador.

3.8. Depuración remota (Remote debugging)

Eclipse te permite depurar aplicaciones que se ejecutan en otra máquina virtual de Java o

incluso en otra máquina.

Para habilitar la depuración remota necesitamos inicializar la aplicaicón Java con ciertas

banderas, como en el siguiente ejemplo.

java -Xdebug -Xnoagent \

-Djava.compiler=NONE \

-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005

14 / 15

3.9. Salto a otro nivel (Drop to frame)

Eclipse nos permite seleccionar cualquier nivel (frame) en la “pila de llamadas” durante la

depuración y configure el JVM para restablecer dicho punto.

Esto posibilita la reejecución de una parte del programa. Tenga en cuenta que las variables

que hayan sido modificadas por el código que está corriendo permanecerán modificadas.

Para usar esta característica, selecciona el nivel en tu pila y presiona el botón Drop to

Frame en la barra de tareas en la vista Debug.

Nota

Los registros y datos externos no se veran afectados por el reset. Por ejemplo si escribes

una entrada en la base de datos y después saltas a una frame previa, esta entrada estará

en la base de datos.

La siguiente pantalla describe cómo resetear. Si reseteamos el bucle for, el

campo result no vuelve a su valor inicial y por lo tanto el bucle no se ejecuta como si

reseteasemos a un punto previo.

15 / 15

4. Ejercicio: Creando proyecto para depurar

4.1. Crea un proyecto con las siguientes clases

public class Counter {

private int result = 0;

public int getResult() {

return result;

}

public void count() {

for (int i = 0; i < 100; i++) {

result += i + 1;

}

}

}

public class Main {

/**

* @param args

*/

public static void main(String[] args) {

Counter counter = new Counter();

counter.count();

System.out.println("We have counted "

+ counter.getResult());

}

}

4.2. Depurando

Coloca un punto de rupture en la clase Counter class. Depura tu programa y sigue la

ejecución del método count.

Define un Detailed Formatter para tu Counter que use el método getResult. Depura tu

programa de nuevo y verifica que tu nuevo formato es usado.

Borra tu breakpoint y añade un breakpoint para la carga de la clase. Depura tu programa de

Nuevo y verifica que el depurador para cuando la clase es cargada.

5. Enlaces de depuración

Eclipse IDE book from Lars Vogel

http://www.eclipse.org/articles/Article-Debugger/how-to.html How to develop your own

debugger