domingo, 25 de enero de 2009

Configurando Nuestra Herramienta de Trabajo, el NetBeans

Como programadores nuestro objetivo es facilitarle la vida a alguien a través de nuestras aplicaciones. Para hacer esto de una forma más simple, debemos usar varias y variadas herramientas en cada una de las etapas del ciclo de vida de nuestra aplicación. En esta ocasión me enfocaré unicamente a la etapa de desarrollo. En algún otro post hablaré de las herramientas que pueden servir en las etapas de análisis, diseño, y pruebas.

Con Java solo es necesario que contemos con el compilador (javac) para crear una aplicación. Podemos escribir todo el código fuente de nuestra aplicación en un blog de notas, vi, o cualquier editor de texto simple que nos permita guardar nuestro archivo con la extensión .java.

Una vez que tenemos nuestro archivo solo hay que compilarlo con el comando javac de la siguiente forma:

javac [opciones] Archivo.java

Y listo!! Esto nos genera un archivo .class, el cual es nuestra aplicación.

Sin embargo, cuando tenemos proyectos de un tamaño mediano/grande el hacer uso de un bloc de notas y la línea de comandos para compilar no es lo más recomendable. Comenzamos a necesitar separar nuestra aplicación en varios archivos, cada uno conteniendo una o varias clases. Posteriormente dividimos estas clases en paquetes, y asignamos la responsabilidad de estos paquetes a uno o varios desarrolladores.

La cosa se complica cuando comenzamos a hacer pruebas de rendimiento, y calidad, arreglo de bugs, etc.


Como podemos ver es mucho trabajo para dejarlo solo a un editor de texto. Es por esto que existen aplicaciones conocidas como IDEs o, en español, Entornos de Desarrollo Integrados, las cuales conjuntan un grupo de herramientas que nos permiten introducir el código, verificar su sintaxis y gramática, encontrar leaks de memoria, realizar pruebas, conocer el rendimiento de nuestras aplicaciones, trabajo colaborativo, etc.

La herramienta que más me gusta para trabajar con Java es NetBeans, que recientemente fue elegido como producto del año por developer.com. Usaremos la versión 6.5 (su versión más actual el momento de escribir este post) de esta herramienta a lo largo de todos los tutoriales. Por lo tanto, el resto de este post tratará sobre cómo configurar NetBeans para trabajar de una forma más agradable y rápida.

Para poder usar NetBeans primero debemos tener instalado nuestro jdk. Cómo este proceso es directo no voy a mencionarlo. Solo recuerden que es necesario configurar dos variables de entorno de la siguiente forma (suponiendo que su jdk está instalado en la ruta C:\Program Files\Java\jdk1.6.xxx):

  • JAVA_HOME: C:\Program Files\Java\jdk1.6.xxx
  • JRE_HOME: C:\Program Files\Java\jdk1.6.xxx (igual que el anterior)
Y, de forma opcional, pueden agregar a la variable de entorno PATH el valor de C:\Program Files\Java\jdk1.6.0_06\bin si es que pretenden hacer uso de java o javac a través de la línea de comandos.

El configurar estás variables de entorno nos facilitará el trabajo al momento de usar algunos contenedores de servlets y JSPs (como el Tomcat) y algunos servidores de aplicaciones (como el Glassfish).

Ya que tenemos instalado y configurado nuestro jdk debemos dirigirnos al sitio http://netbeans.org/ para descargar nuestro IDE de trabajo. La liga de descarga se encuentra en la página principal, así que no hay pierde.


Existen varias versiones con diversos paquetes que podemos bajar, estos paquetes le proporcionarán más funcionalidades a nuestro IDE. En este tutorial bajaremos la versión más básica para Java (también existen versiones para PHP y C/C++) y bajaremos los otros paquetes o plugins conforme los vayamos requiriendo. Esta versón pesa 39Mb por lo que tardará unos minutos en bajar.


De ahi el proceso es muy sencillo. Solamente hay que seguir los pasos del instalador (next, next, next).


Ahora, es aquí en donde comienza lo interesante. Cuando entremos veremos una interface de usuario como la de la siguiente imagen, en la cual he resaltado los títulos de cada una de las secciones:



Como podemos ver, en la página inicial (la cual pude ser mostrada o no siempre que iniciemos el IDE) tenemos nuestra lista de proyectos recientes, tutoriales y novedades (muy útiles para principantes y no tan principantes), demos en video para los que nos cuesta un poco de trabajo entender algunas cosas, y entradas recientes de los blogs más importantes de desarrolladores. Todos lo que se muestra aquí está relacionado casi siempre con el NetBeans, pero podemos encontrar aún así cosas muy interesantes. Yo en lo personal siempre veo está página de inicio para enterarme un poco de lo que puedo hacer y para conocer los nuevos tutoriales.

En la imagen anterior también he resaltado un ícono de notificación de actualizaciones que aparece en la parte inferior derecha del NetBeans cada vez que encuentra alguna actualización, ya sea del propio IDE o de alguno de los plugins que tengamos instalados. Estas actualizaciones se verifican de forma automática, así que podemos tener nuestro entorno de trabajo actualizado de una forma muy sencilla.

Después de bajar las actualizaciones que se indican procedemos a personalizar el NetBeans para trabajar más agusto.

Todas las ventanas pueden ser movidas a cualquier parte de la interface, así que podemos poner las ventanas que más utilizamos siempre a la vista en la posición en la que nosotros queramos. De la misma forma podemos minimizar todas las ventanas en forma de "dock" para que se muestren cuando pasemos el cursor del ratón sobre el ícono o nombre de la ventana. Por ejemplo en la siguiente imagen podemos ver que en 1 he minimizado las ventanas "Files" y "Services" por lo que solo sarán visibles cuando pase el cursor sobre ellas. Y en 2 he colocado la ventana "Files" debajo de la ventana "Projects" para poder ver las dos al mismo tiempo, mientras que he dejado la ventana "Services" minimizada. Como puede verse, podemos colocar cualquier ventana en cualquier parte del área de trabajo, incluso las ventanas de salida de la aplicaciones o ventanas de los plugins que vayamos agregando (como CSS en el caso del plugin para aplicaciones web). Si por error han cerrado una ventana al estarla moviendo, no se preocupen, siempre podemos volver a mostrarla seleccionandola en el en menu Window.



Además de esto tenemos dos "modos de trabajo" en el editor. No conozco el nombre formal de estos, pero yo los llamo modo "minimizado" y modo "maximizado". Para intercambiar entre estos dos modos, solo es necesario seleccionar una ventana y presionar Shift + Esc. Con esto verán que la ventana que han seleccionado se maximiza mientras las demás desaparecen. Pueden hacer esto con cualquier ventana que deseen (la del editor, la pagina de inicio, Projects, etc.). Ya se que si han revisado la lista de atajos de teclado para el NetBeans (la cual pueden encontrar en el menu Help -> Keyboard Shortcuts Card) me dirán que es el atajo para maximizar ventanas. Bueno, esto es cierto, sin embargo pasa algo curioso con esto: cuando tenemos una ventana maximizada (depues de haber pulsado Shift + Esc), podemos mostrar alguna otra ventana (como la de Services) y ahora, cada vez que presonemos Shift + Esc veremos las ventanas en esta misma posición, y al volver a presionarlo, veremos las ventanas que teniamos anteriormente. Esto puede sonar algo confuso, pero hagan la prueba para ver lo que les digo. Por ejemplo, en esta imagen:



En 1 se ve mi área de trabajo normal. Al presionar Shift + Esc en la página de inicio (que cuando creemos un proyecto será nuestra área de edición de código) esta se maximiza. Ahora, muestro la ventana "Services" en el área de trabajo y la dejo fija (presionando el ícono "Pin"), quedando mi área de trabajo como en 2. Ahora, cada vez que presiona Shift + Esc cambiare mi área de trabajo entre las ventanas que tengo en 1 y las que tengo en 2. Esto es muy útil cuando estamos trabajando en distintas partes del proyecto. Por ejemplo cuando tengo que hacer alguna edición de CSS para un proyecto web muestro en el área de trabajo normal las ventana de proyectos y en el área de trabajo maximizada (o minimizado, como la quieran ver) las ventanas de edición y previsualización de CSS).

Bien, el posicionar las ventanas es solo la primer parte de personalización del entorno de trabajo. Ahora pasaremos a ver cómo modificar las opciones de edición de código, así como las plantillas del mismo. Primero personalizaremos lo referente al formateo del código.

Si nos dirigimos al menu Tools -> Options aparecerá una ventana para configurar muchas opciones de nuestro editor. La que nos interesa en este momento son las referentes al Formateo de código Java, por lo que seleccionamos la opción "Editor" y luego el tab "Formatting". Una vez ahi seleccionamos como lenguaje Java y listo, podremos editar todas las opciones referentes al formateo de código. Estas opciones están divididas en distintas categorías, y nos permiten controlar la posición de las llaves, alineaciones, espacios en blanco, saltos de línea, etc. Dejo a gusto del lector las opciones que desee personalizar.



Ahora personalizaremos una de las opciones que, en lo personal, más me gusta. Las plantillas de código (Code Templates). Estas nos permiten tener como una especie de atajos (llamados abreviaciones) para bloques de código, desde palabras simples como public o protected hasta bloques completos como ciclos for, que podemos "pegar" en nuestro código en el momento de edición. Estas plantillas de código se ecuentran en el menu Tools -> Options, en la ventana que aparece seleccionamos la opción "Editor" y después el tab "Code Templates". Como podemos ver, NetBeans ya cuenta con muchos templates predeterminados. Podemos navegar un poco entre estos templates para familiarizarnos con ellos. Pero, además, podemos agregar nuestros propios templates o modificar los ya existentes para poder accesar a ellos de una forma más fácil para nosotros. Por ejemplo, la abreviación por default para el bloque de código System.out.println es sout. Pero para mi es más fácil escribir simplemente Sy. Por lo que, para agregar esta abreviación presionamos en el botón "New" a la derecha de los templates y en la ventana que se abre escribimos nuestra abreviación (en mi caso Sy). Una vez que tenemos nuestra abreviación escribmos el que será su "texto expandido" en la tab "Expanded Text" que está debajo de las abreviaciones.



También podemos elegir con qué tecla queremos "pegar" estas plantillas de código. Por default esto se hace con Tab, pero para mi es más facil hacerlo al presionar Space. Por lo que cuando estoy escribiendo my código y presiono Sy seguido de un espacio, este es remplazado por System.out.println.

Finalmente, y para terminar este post, hablaremos sobre la personalizaciónplantillas de archivos. Cada vez que creamos un nuevo archivo desde NetBeans de cualquier tipo (clases Java, interfaces Java, archivos de propiedades, archivos JSP, Applets, etc.) este revisa su lista de plantillas y selecciona la del tipo que hemos escogido. Esta plantilla puede contener algunos comentarios y bloques de código predefinidos. Por ejemplo, por default la plantilla para la creación de clases Java es la siguiente:


Cuando creamos una nueva clase Java llamada "ClasePrueba" con esta plantilla, la clase generada luce como la siguiente:


Esto podría ser suficiente para la mayoría de las personas, sin embargo, cuando estamos trabajando en una organización y colaboramos en un equipo de trabajo mediano a grande, o cuando estamos desarrollando por nuestra propia cuenta y, por alguna razón, queremos distribuir nuestros archivos fuente, tal vez queramos poner algo más de información en esta plantilla sobre quién desarrollo esta clase y dónde contactarlo en caso de bugs o mejoras. Tal vez solamente queramos modificar el formateo del archivo para no tener que estar haciendolo cada vez que creamos un nuevo archivo de este tipo. Por lo que, procederemos a editar esta plantilla para agregar esta información.

Las plantillas se encuentran en el menu Tools -> Templates. Aquí se encuentra el "Template Manager" que es donde podemos crear nuevas plantillas, editar o eliminar las ya existentes, entre otras cosas. Las plantillas están dividas es categorías o Folders más o menos intuitivas. Para editar la plantilla de clases Java, que es la que nos interesa en este momento, abrimos el Folder Java y ahi seleccionamos "Java Class". Ahora, esto puede ser un poco extraño ya que para abrir la plantilla para editarla, no funcionará hacer doble click en el nombre, sino que hay que hacer click en el botón "Open in Editor"


Aqui modificamos la plantilla con el contenido que deseamos. En mi caso coloqué esto:


Con lo que, cada vez que se crea una nueva clase, esta queda de la siguiente forma:


De las dos imágenes anteriores podemos ver que, además del texto estático, podemos usar algunas propiedades dentro de expresiones (como en este caso ${user} y ${package} donde ${} representa una expresión y user y package son propiedades) las cuales son reemplazadas en el momento de la generación del archivo con sus valores correspondientes. En este caso ${user} es reemplazado con mi nombre de usuario en el sistema (ProgramadorJava).

Existen algunas propiedades por default. No conozco todas, pero al menos las que yo más uso son:
  • ${user} - Nuestro nombre de usuario dentro del sistema.
  • ${name} - El nombre del archivo.
  • ${nameAndExt} - El nombre y la extensión del archivo que estamos creando (en ese caso ClasePrueba es en nombre del archivo y .java es la extensión.
  • ${date} - La fecha de creación del archivo.
  • ${time} - La hora de creación del archivo.
Para usar estas expresiones solo tenemos que colocarlas en nuestra plantilla y sus valores serán reemplazados de forma automática al generarse el archivo.

Adicionalmente, podemos crear nuestras propias propiedades con un valor estático que serán tratadas de forma similar al de las expresiones por default. Para esto debemos colocar el nombre nuestras propiedades en una plantilla especial que se encuentra en el folder "User Configuration Properties" llamada User.properties. Cuando abrimos esta plantilla en el editor vemos que tiene un pequeño ejemplo comentado de cómo cambiar el nombre de usuario que se muestra en nuestros archivo generados. Para cambiar esto, podemos descomentar el ejemplo y cambiar el nombre por nuestro nombre. Yo por ejemplo dejo:

user=Alex

Con esto, cada vez que genere un archivo en el que se use la propiedad ${user} este será reemplazado por Alex en vez de usar ProgramadorJava como occuria anteriormente.

Pero podemos agregar algunas otras propiedades. Voy a agregar el nombre de la empresa en la que trabajo, junto con dos direcciones de correo para que me contacten en caso de que se encuentren errores o bugs en esta clase. Un correo será el de la empresa y otro correo será personal. De esta forma, si cambio de empresa, solo debo cambiar su nombre en este archivo de propiedades y de forma automática se usará este nombre en los archivos que se generen a partir del cambio. O si en la empresa se agrega alguna política de que cada archivo debe llevar alguna cabecera con, digamos con el lema de la empresa o alguna licencia, puedo agregarlo en las plantillas directamente, o como una expresión y posteriormente puedo ir cambiando esto conforme vaya siendo necesario. Esto es mucho más fácil que cambiar el nombre en todas las plantillas que modifique ^-^. Al final mi archivo de propiedades queda de la siguiente forma:


Y mi plantilla de clases de esta otra forma:


Por lo que, a partir de ahora, cada vez que se crea una nueva clase, el archivo generado queda de la siguiente forma:


Igualmente podemos crear archivos propios con las extensiones que queramos y podemos usarlos como plantillas. Por ejemplo un archivo Readme.txt que usamos en cada proyecto, algún archivo de configuración, etc.

Estas plantillas, como algunos ya se habrán dado cuenta, hacen uso de FreeMaker por lo que podemos crear plantillas un poco más dinámicas, pero esto está fuera de los alcances de este tutorial. Si alguien quiere adentrarse un poco más en el tema, pueden visitar estos enlaces:


Bueno, pues este es el final de este primer tutorial sobre la configuración de la que será nuestra herramienta prinicipal de trabajo, el IDE galardonado por developer.com, NetBeans en su versión 6.5. Espero que este tutorial les sea de utilidad y no olviden dejar todos sus comentarios, dudas y sugerencias.

12 comentarios:

  1. Alex o progamadorjava, me parece muy interesante tu podcast, netbeans es un IDE muy completo que esta a la altura de otros como el RAD o el JBuilder, con estos "atajos" podemos trabajar mucho mas rápido. Muchas gracias por los tips, estaré al pendiente de lo nuevo.

    Saludos.

    ResponderEliminar
  2. Si borras toda una rama de plantillas desde Tools / Templates como puedes recuperarla?.

    ResponderEliminar
  3. Pues en realidad si has borrado alguna plantilla no hay forma de recuperarla, a menos que tengas un respaldo. Si es el caso, puedes pegar tu respaldo en userHome/.netbeans/6.5/config/Templates. Sino tienes un respaldo puedes tratar de crear de nuevo las plantillas.

    ResponderEliminar
  4. Si no tengo copia de respaldo entiendo que tendré que reinstalar el IDE. Quizás no debería insistir tanto en tener las plantillas pero creo que para poder hacer rápido pantallas tipo forms, crear un cuadro de diálogo, etc. es mucho más rápido aplicando las plantillas Swing GUI Forms verdad?

    ResponderEliminar
  5. Efectivamente. Si estas creando una aplicación swing, la forma más facil y rápida de crear los componentes de tu interface de usuario es usando las plantillas de Swing GUI Forms.

    ResponderEliminar
  6. La configuración del entorno actual se la guarda a nivel de usuario por lo que en Windows bajo Documents and Setting/usuario.x/ hay una carpeta .netbeans donde se almacena la configuración que has personalizado ( borrar las plantillas por ejemplo ). Borras dicha carpeta y vuelves a arrancar el IDE.

    ResponderEliminar
  7. Hola, felicidades por tu blog, me parece una propuesta muy interesante para quienes estamos empezando a programar en java. Tengo una pregunta: ¿Cómo hago para tener la vista de diseño para editar páginas web y poder arrastrar controles desde el palette?

    Saludos

    ResponderEliminar
  8. @Daniel
    Hola Daniel;

    Lamentablemente en las últimas versiones esta característica se eliminó del NetBeans :(. Así que ya no es posible hacer esto.

    Saludos

    ResponderEliminar
  9. Como bloque la tecla tab en un formulario de Java

    ResponderEliminar
  10. como recupero la ventana de propiedades es que se me erro

    ResponderEliminar
  11. cuando abro un proyecto en mi laptop aparece en los archivos de mi proyecto una llave inglesa en la esquina del icono de mis archivos

    ResponderEliminar
  12. He querido correr el proyecto recreándolo desde cero pero me sale el siguiente error:
    java.lang.NullPointerException
    at com.apuntesdejava.spring.mvc.store.HomeController.welcome(HomeController.java:20)
    at sun.reflect.GeneratedMethodAccessor806.invoke(Unknown Source)

    Una duda mas: como se crea la carpeta Other Sources, ya que en otro ejemplo vi que en esta carpeta se crea el views.properties para manejos de tiles desde netbeans.

    Saludos

    ResponderEliminar