Česky   |  Deutsch   |  English   |  Español   |  Français   |  Indonesia   |  日本語   |  한글   |  Polski   |  Português (BR)   |  Türkçe   |  中文   |  正體中文   |  Tu idioma  
PlanetNetbeans
Planet NetBeans es un rama de NetBeans relacionado con toda la Blogosphere.
Feeds
[RSS 1.0 Feed] [RSS 2.0 Feed]
[FOAF Subscriptions] [OPML Subscriptions]
¿Tienes un blog acerca de NetBeans? Agrega tu blog a PlanetNetBeans.
Feed Subscripciones

Powered by:    Planet

Última actualización:
December 20, 2014 09:01 AM
All times are UTC

Sponsored by
sponsored by Oracle

visit NetBeans website
APIDesign - Blogs - June 02, 2014 07:49 AM
Podcast related to Japanese Translation

--JaroslavTulach 07:49, 2 June 2014 (UTC)

NetBeans Community Docs Blog - October 17, 2009 07:21 PM
Who's Who?

Hello all,

This team has seen some changes in the recent past. James Branam, NetBeans Community Docs Manager (March 2007 - August 2009) had stepped down from this program on August 31st, 2009.

He had made an announcement as well, you may read it over his blog. To quote,

"After two and a half years of managing the NetBeans Community Docs program, I've decided to step down."
While James decided to step down, he passed the torch to another technical writer from his NetBeans Documentation Team, Jeff Rubinoff. So, let us give him a warm welcome and the cooperation, he may require to make the program, better for you and the community.

In the end, I would like you all to thank James for initiating this program and helping to increase the adoption of the NetBeans IDE through the documentation created for the community, by the community.

NetBeans Community Docs Blog - September 03, 2009 01:45 PM
NBCD Monthly Newsletter #27

The Netbeans Community Docs newsletter for August 2009 is now available.

To view the newsletter, please click the link below.

August 2009

View the NBCD Newsletter Index:

NBCD Newsletter Index

Best to you, and thanks for reading.

Josh Juneau

NetBeans Community Docs Blog - July 14, 2009 10:53 AM
NetBeans Community Docs Survey

NetBeans Community Docs Survey

Today we (=the NetBeans Community Docs team) would like
to kindly ask you for input on our current and future doings:



Started in March 2007, the NetBeans Community Docs project has gone a long
way collecting and sorting pieces of documentation provided to the NetBeans
community solely by voluntary contributors from all around the globe. All
users involved into this process have done a great putting time and effort
into that project, and as a result, the impressive landmark of 300 user
contributed pieces of documentation has been reached in Februrary 2009.



However, sometimes things have to change, and so, by now we also want to
make some changes to the way NetBeans Community Docs project works. And for
that, being a 'community project' and thus not just maintained by the
community but also, in the content it collects, mainly aiming at providing
help and support to the community, we would like to know what the community
wants and needs before going any further. In near future, we want to make
NBCD more than ever an actively maintained, vivid 'community driven
knowledge base' directly addressing our users needs, adding our part to
helping people get the most out of NetBeans IDE.



For that, we would like to read your opinion. What do you like about NBCD so
far? What bothers you in using it in your everyday work? What kind of
content do you enjoy reading and using, and what would you like to see
improved as the project moves on? Take our survey now, take a chance to
tell us, to make 'the future NBCD' even more the community driven knowledge
base you would like to use and see.



Thanks very much for your time!

NetBeans Community Docs Blog - July 01, 2009 12:02 PM
NBCD Monthly Newsletter #26

The Netbeans Community Docs newsletter for June 2009 is now available.

To view the newsletter, please click the link below.

June 2009

View the NBCD Newsletter Index:

NBCD Newsletter Index

Best to you, and thanks for reading.

Josh Juneau

NetBeans Community Docs Blog - June 08, 2009 03:07 PM
Latest Buzz | NetBeans FAQs

We are still alive, the project is not dead. Come on, cheer up! Its time to get yourself updated about this program.

You already know that, NetBeans Team along with Community Members provide lots of FAQs over NetBeans Wiki. You should also know that, we have added a section on two wikis maintained by NetBeans Team, i.e. User FAQs and Developer FAQs.



Visit this section on NetBeans User FAQs and NetBeans Developer FAQs, for more details.

NetBeans Community Docs Blog - June 02, 2009 03:00 PM
NBCD Monthly Newsletter #25

The Netbeans Community Docs newsletter for May 2009 is now available.

To view the newsletter, please click the link below.

May 2009

View the NBCD Newsletter Index:

NBCD Newsletter Index

Best to you, and thanks for reading.

Josh Juneau

diesil java - May 28, 2009 07:43 PM
JavaScript en NetBeans 6.1

Esta entrada fue movida a

http://apuntesdejava.blogspot.com/2008/04/javascript-en-netbeans-61.html

Practical API Design - May 18, 2009 05:43 PM
API Podcast #2: Reentrancy

Listen to podcast #2: to learn about our take on Swing and its poor reentrancy. Find out what it may mean for your own API design and especially Runtime_Aspects_of_APIs that you create. Learn to fight with that problem by maximizing the declarative nature of your API. --JaroslavTulach 17:43, 18 May 2009 (UTC)

Practical API Design - May 12, 2009 07:50 PM
API PodCast #1

Listen to this: ! It is almost a year since we (me and Geertjan) started our regular API Design Tips podcasts. They used to be part of larger NetBeans podcasts, however recently I needed some promotion material for TheAPIBook and I decided to extract the API Tip parts. I am glad I can offer these sketches to you. Enjoy podcast #1. --JaroslavTulach 19:50, 12 May 2009 (UTC)

NetBeans Community Docs Blog - May 08, 2009 03:12 AM
NBCD Monthly Newsletter #24

The Netbeans Community Docs newsletter for April 2009 is now available.

To view the newsletter, please click the link below.

April 2009

View the NBCD Newsletter Index:

NBCD Newsletter Index

Best to you, and thanks for reading.

Josh Juneau

diesil java - May 06, 2009 06:52 PM
Mudado...!!

Si eras una de las personas que visitaba este humilde blog, pues te informo que todo lo he cambiado a otra dirección:

http://apuntesdejava.blogspot.com

Ahí están todos los posts... menos los comentarios.

Por ahora no he activado el foro ya que... vamos... no me da tiempo de responder las preguntas.

NetBeans Community Docs Blog - April 02, 2009 11:34 AM



Hi all,


Today I have a very important announcement to make. The NetBeans Community Docs program has a new Contribution Coordinator: Kristian Rink.

Kristian has been a very active participant in the program, and has also served as Evangelist. A native of Germany, Kristian has some excellent ideas for moving the program forward.

Please join me in congratulating Kristian and welcoming him to his new position.

I would also like to thank Varun Nischal, the program's former Contribution Coordinator, for a job well done. Under Varun's leadership, the program was able to reach new milestones, including the latest milestone of 300 contributions.

We all owe our thanks and congratulations to Varun.

Cheers!

--James

NetBeans Community Docs Blog - April 01, 2009 02:59 PM
NBCD Monthly Newsletter #23

The Netbeans Community Docs newsletter for March 2009 is now available.

To view the newsletter, please click the link below.

March 2009

View the NBCD Newsletter Index:

NBCD Newsletter Index

Best to you, and thanks for reading.

Josh Juneau

Bits y Bytes » NetBeans - March 05, 2009 06:21 PM
Métricas de calidad con NetBeans y Hudson

Este artículo como PDF.

Introducción

En un post anterior expliqué cómo montar un entorno de integración continua básico, que luego completamos para que también se convirtiera en un verdadero entorno TDD con tests y métricas de cobertura. El siguiente paso para tener un entorno totalmente ágil consiste en añadir métricas de calidad de código para favorecer la mejora continua del trabajo hecho por todo el equipo y para que los gestores puedan tener una perspectiva algo más “objetiva” del nivel de calidad. Continuaré en este tutorial sobre el mismo ejemplo, así que en numerosos puntos haré referencias a los artículos previos para no tener que repetirme más de lo necesario.

Nótese que he puesto la palabra objetiva entre comillas. En este artículo vamos a ver una serie de herramientas que detectarán malas prácticas, bugs potenciales o puntos mejorables y generarán informes al respecto. El desarrollo de software es algo muy complejo y la medida de su calidad real no es automatizable (si así fuera, también lo sería su desarrollo y aún no hemos llegado a ese punto), ni hay un convenio universal de en qué consiste, con lo cual hay que saber leer e interpretar el resultado que producen estas herramientas. Si están avisando de que nuestro código tiene problemas, muy probablemente tengan razón y deberemos poner medidas correctoras. Lo contrario, sin embargo, no implica que nuestro código sea de alta calidad, sino que no se han encontrado aquellas cosas que se sabe que producen problemas. No se podrá automatizar, por ejemplo, cosas como la detección de uso inadecuado de patrones de diseño o la escalabilidad de la plataforma, que podríamos estar de acuerdo que son medidas de calidad. Simplificando mucho: se puede detectar que el código de un proyecto tiene poca calidad de manera automática, pero no se puede decir que para aquellos para los que no se ha detectado, el código sea de alta calidad.

Hechas estas matizaciones, en este artículo vamos a explicar cómo integrar las siguientes herramientas en NetBeans y Hudson usando Ant:

  • Checkstyle : genera informes sobre el grado de seguimiento del código a los estándares de codificación establecidos.

  • Simian : detector de copia de bloques de código.

  • PMD : analizador de código estático en busca de posibles bugs y malas prácticas.

  • FindBugs : similar al anterior.

El procedimiento de instalación de las herramientas va a ser análogo para cada una de ellas:

  1. Instalación del plugin correspondiente en el NetBeans (si lo hubiere) y configuración del mismo.

  2. Instalación de las bibliotecas de la herramienta en la máquina de desarrollo.

  3. Modificación del script del Ant para poder lanzar el análisis sin la ayuda del IDE.

  4. Instalación del plugin correspondiente en el Hudson.

  5. Modificación del job para incluir la generación y publicación de informes correspondientes.

Checkstyle

Cuando hablo de estilo de codificación (o convenciones de código) me refiero a cosas como el nivel de indentación, utilizar espacios o tabuladores, añadir comentarios, cómo organizar las llaves de los bloques de código, el tamaño máximo de la línea, etcétera.

Parece un hecho ampliamente aceptado que la uniformidad de estilo a la hora de codificar facilita el grado de cohesión del equipo de desarrollo, la mantenibilidad de la base de código y en definitiva la productividad. Si todo el equipo trabaja con un mismo estilo, puede entender la estructura del programa más fácilmente de un vistazo.

En el mundo Java, Sun proporcionó unas guías de estilo que han sido ampliamente adoptadas por la comunidad. En este documento las podéis encontrar junto con los motivos que hay detrás de cada convención.

Checkstyle es una herramienta que genera informes del nivel de seguimiento de estas convenciones. Seguir el estilo al pie de la letra puede resultar algo duro en ocasiones, así que también es posible rebajar el nivel de exigencia decidiendo para qué convenciones se quiere generar una alarma y cuáles se puede ignorar o incluso para definir nuestras propias convenciones.

Checkstyle lo tenemos disponible en las tres vertientes: plugin para el NetBeans, como task del Ant y como plugin del Hudson.

Plugin para NetBeans del Checkstyle

El plugin no forma parte de los repositorios estándar, así que el primer paso para instalarlo será añadir el repositorio correspondiente. Para ello iremos a: Tools -> Plugins -> Settings -> Add y añadiremos la siguiente url : http://www.sickboy.cz/checkstyle/autoupdate/autoupdate.xml tal y como se muestra en las siguientes imágenes.

A continuación hacemos click en la pestaña de Available Plugins y seleccionamos Checkstyle Beans Library y Checkstyle Beans Plugin y los instalamos (seguimos los pasos indicados por el asistente y cuando nos pregunte si queremos instalar plugins no firmados le decimos que sí) . Ahora sólo resta reiniciar el NetBeans para que cargue el plugin.

Ahora cada vez que alguna línea de código no conforme con respecto a las convenciones de Sun, aparecerá una etiqueta a modo de aviso. Poniendo el ratón encima de la etiqueta, mostrará cuál es la convención que no se está siguiendo.

Como decía, se pueden utilizar plantillas con convenciones personalizadas. Para ello deberemos editar la configuración por defecto que se encuentra en: Tools -> Options -> Miscellaneous -> Checkstyle.

Incluir Checkstyle en el script de Ant del NetBeans

Como ya he explicado en otros artículos, NetBeans realiza todas sus tareas mediante scripts Ant que autogenera y el build.xml que hay en la raíz del proyecto es extensible para que los desarrolladores podamos introducir nuestros propios targets .

Lo primero que tenemos que hacer es descargarnos la distribución del Checkstyle (en el momento de escribir este artículo la versión 5 sigue siendo beta , así que yo me decanto por la versión 4.4) que, entre otras cosas, aporta los tasks necesarios para invocarlo desde Ant. A continuación habremos de descomprimir el paquete en algún lugar de la máquina de desarrollo. Yo, siguiendo mi propio estándar, lo situaré en el directorio /srv y luego lo enlazaré con un link simbólico para no tener que hardcodear la ruta hacia una versión concreta en ningún fichero de configuración o script que haga uso del mismo. También crearé un enlace simbólico al jar que contiene la implementación del task por el mismo motivo.

root@hargon:/srv# tar -zxf checkstyle-4.4.tar.gz
root@hargon:/srv# ln -s checkstyle-4.4 checkstyle
root@hargon:/srv# ls -alh checkstyle
lrwxrwxrwx 1 root root 14 2009-02-25 16:24 checkstyle -> checkstyle-4.4
root@hargon:/srv# rm checkstyle-4.4.tar.gz
root@hargon:/srv# cd checkstyle
root@hargon:/srv/checkstyle# ln -s checkstyle-all-4.4.jar checkstyle-all .jar

El siguiente paso consiste en modificar el build.xml . Lo primero que vamos a necesitar es importar el task tal y como sigue:

<taskdef
    resource="checkstyletask.properties"
    classpath="${checkstyle.dir}/checkstyle-all.jar"/>

Puesto que el valor de checktyle.dir puede ser diferente en la máquina de diferentes desarrolladores o en la máquina que contiene en el servidor de integración, esta propiedad la definimos en el fichero de propiedades privadas del proyecto (que recordemos no forma parte del repositorio de código): nbproject/private/private.properties.

checkstyle.dir=/srv/checkstyle

Como yo estoy partiendo del mismo ejemplo del artículo previo donde explicaba cómo integrar Cobertura, yo ya tengo definido un import en el build.xml del fichero de propiedades privadas, si no lo tuvierais acordaros de añadirlo.

<property file="nbproject/private/private.properties"/>

A continuación definimos el target que construirá los informes en el build.xml :

<target name="checkstyle-report">

    <property file="nbproject/project.properties"/>

    <mkdir dir="${checkstyle.report.dir}"/>

    <checkstyle failOnViolation="false"
        config="${checkstyle.dir}/sun_checks.xml">
        <fileset dir="${src.dir}" includes="**/*.java"/>
        <formatter type="xml"
            toFile="${checkstyle.report.dir}/checks.xml"/>
        <formatter type="plain"
            toFile="${checkstyle.report.dir}/checks.txt"/>
    </checkstyle>
</target>

El target es bastante fácil de entender. En primer lugar construimos el directorio donde se generarán los diferentes informes. A continuación lanzamos el task del Checkstyle indicándole que siga procesando el build.xml aunque se encuentren fallos de formato ( failOnViolation=”false” ) y que utilice las convenciones definidas en el fichero sun_checks.xml que forma parte de la distribución estándar de Checkstyle. Este fichero es donde se describen, en un formato que escapa al ámbito de este artículo, cuáles son las convenciones que caso de no seguirse generan un aviso. Obviamente podemos editar o sustituir este fichero por otro adaptado a nuestras necesidades, pero si dejamos éste, forzamos las convenciones de Sun que, como ya había indicado previamente, se describen en este documento .

Finalmente generamos los informes en dos formatos: en texto plano y en XML. El primero es más sencillo de leer por humanos pero el segundo es el adecuado para integrarlo con Hudson.

En este target presuponemos inicializadas las propiedades checkstyle.dir , src.dir y checstyle.report.dir . La primera ya la hemos configurado en el punto anterior, la segunda forma parte de las propiedades creadas por NetBeans y la última la tenemos que definir. Las añadiremos como propiedades del proyecto en el nbproject/project.properties :

reports.dir=${build.dir}/reports
checkstyle.report.dir=${reports.dir}/checkstyle-report

Integrando Checkstyle con Hudson

Para generar los informes en Hudson nos aprovecharemos del target que acabamos de definir en el build.xml del NetBeans, por tanto el proceso va a ser sencillo:

  1. añadir el plugin del Checkstyle al Hudson,

  2. instalar las bibliotecas del Checkstyle en la máquina donde reside el Hudson,

  3. añadir las propiedades privadas a mano (recordad que este fichero no forma parte del Subversion),

  4. añadir el nuevo target en la construcción del proyecto,

  5. configurar el job para que utilice el target .

El proceso para instalar el plugin, ya lo hemos visto en el post donde explicaba cómo añadir el plugin de Cobertura . Básicamente, seleccionarlo de la lista de plugins disponibles, instalarlo con el asistente y reiniciar el Hudson.

Utilizaré el mismo procedimiento y ruta para instalar la distribución del Checkstyle en el servidor donde se ejecuta el Hudson, así que repetiré exactamente los mismos pasos que hice en la máquina de desarrollo.

A continuación tenemos que modificar las propiedades privadas para añadir la ruta al Checkstyle. Nos situaremos en el directorio del job y editaremos (o crearemos) el fichero nbproject/private/private.properties para añadir la línea:

checkstyle.dir=/srv/checkstyle

Finalmente añadimos checkstyle-report a la lista de tagets a construir y configuramos el job para que lea los informes generados en xml y los publique. Adicionalmente podemos configurar opciones avanzadas como los límites a partir de los cuales el build debe considerarse inestable o roto.

Ahora ya sólo resta ver los informes que genera el Hudson:

Simian

Alguna vez oí, aunque no recuerdo la fuente, que en informática la duplicación es el diablo y yo no puedo estar más de acuerdo. En ciertas ocasiones requerimientos no funcionales, como por ejemplo eficiencia, puede requerir duplicar información (denormalización de tablas en bases de datos, materialización de cálculos de agregación de información, etc), pero ello debe ser consecuencia de una decisión de diseño meditada y no de la dejadez. La replicación de código, en general, es menos justificable e introduce un gran coste en mantenibilidad y calidad: modificaciones en cualquiera de las copias debería llevar aparejadas actualizaciones en el resto, lo cual se hace muy tedioso y complicado de implementar.

Por todo lo anterior, si tenemos repetido un bloque de código de un tamaño razonable, probablemente ello está descubriendo un mal diseño y ese código debería encapsularse de alguna manera para que exista en un único punto.

Simian es la herramienta que nos va a permitir encontrar replicación de bloques de código (o de texto en general) en una gran cantidad de lenguajes de programación y formatos de texto. Hasta donde yo sé, no existe como plugin para NetBeans (aunque sí para Eclipse e IntelliJ). Sí que existe el task para Ant y como plugin para el Hudson y por tanto veremos estas configuraciones.

Como el procedimiento para incluir nuevas herramientas de análisis y métricas va a ser siempre muy similar a lo que he explicado en el caso del Checkstyle, no explicaré el proceso de una manera tan detallada (entre otras cosas porque no aporta nada y sólo hace crecer el documento).

Incluir Simian en el script de Ant del NetBeans

Lo primero es obtener y configurar la herramienta en el entorno de desarrollo, para ello lo descargamos , lo descomprimimos en /srv / (id con cuidado porque el paquete no contiene un directorio raíz) y creamos el enlace simbólico correspondiente.

root@hargon:/srv# mkdir simian-2.2.24
root@hargon:/srv# cd simian-2.2.24
root@hargon:/srv/simian-2.2.24# mv ../simian-2.2.24.tar.gz .
root@hargon:/srv/simian-2.2.24# tar -zxf simian-2.2.24.tar.gz
root@hargon:/srv/simian-2.2.24# rm simian-2.2.24.tar.gz
root@hargon:/srv/simian# cd bin/
root@hargon:/srv/simian/bin# ln -s simian-2.2.24.jar simian.jar
root@hargon:/srv/simian-2.2.24# cd ../..
root@hargon:/srv# ln -s simian-2.2.24 simian

A continuación configuramos el build.xml de manera análoga al Checkstyle:

<taskdef
    resource="simiantask.properties"
    classpath="${simian.dir}/bin/simian.jar"/>

<target name="simian-report">
    <property file="nbproject/project.properties"/>

    <mkdir dir="${simian.report.dir}" />

    <simian>
        <fileset dir="${src.dir}" includes="**/*.java"/>

        <formatter type="xml"
            toFile="${simian.report.dir}/simian.xml"/>

        <formatter type="plain"
            toFile="${simian.report.dir}/simian.txt"/>
    </simian>
</target>

Las propiedades las definiremos allí donde toca: el simian.dir (con valor /srv/simian ) en el nbproject/private/private.properties y el simian.report.dir (con valor ${reports.dir}/simian-report ) en el nbproject/project.properties .

El task de Simian es muy sencillo. En su configuración simple tal y como tenemos, tan sólo hace falta especificar el directorio que contiene el código a analizar y el formato de los informes (en XML para integrarse con el Hudson y en texto plano para que sea más legible por humanos).

Integrando Simian con Hudson

Como en el caso del Checkstyle, replicamos la instalación de Simian en la máquina donde se encuentra el Hudson y definimos la propiedad simian.dir en el nbproject/private/private.properties .

El siguiente paso debería consistir en instalar el plugin del Simian para el Hudson, pero cuando lo buscamos en la lista de plugins disponibles nos damos cuenta que no aparece. Afortunadamente existe un plugin llamado Violations que integra diferentes herramientas de análisis estático de código (de hecho podríamos utilizar este mismo plugin para otras de las tratadas en este artículo) y que tiene soporte para Simian. Lo instalamos de la manera habitual, reiniciamos el Hudson para que lo cargue y el siguiente paso consiste en configurar el job . Como siempre, añadiremos el simian-report a la lista de targets a construir por el Ant y a continuación configuramos el plugin tal y como se muestra en la ilustración (también podemos definir los límites a partir de los cuales se rompe el build ).

Tras construir el job podremos ver los informes de replicación de código de manera integrada en el Hudson.

PMD

Tanto PMD como FindBugs, son herramientas de análisis estático de código (analizan el código y no el programa en ejecución) en busca de estructuras potencialmente peligrosas tales como:

  • posibles bugs,

  • código “muerto” (variables no accedidas, bloques de ejecución inalcanzables, etc.),

  • código subóptimo,

  • bloques con una estructura poco legible o más complicada de lo necesario.

Estas herramientas son especialmente útiles integradas en el IDE porque de esta manera el programador puede ir viendo mientras escribe el código las posibles alertas. Obviamente también tienen tasks de Ant lo que permite integrarlas fácilmente en Hudson para obtener los informes correspondientes.

Plugin para NetBeans del PMD

En este caso el plugin del PMD no está accesible mediante un repositorio, por lo que para instalarlo procederemos a la descarga del mismo y a su instalación local.

Una vez tenemos el fichero, deberemos descomprimirlo y nos quedamos con el plugin empaquetado en el fichero pmd.nbm que instalaremos a través la pestaña Downloaded del gestor de plugins: primero lo añadimos a la lista mediante el botón Add Plugins y después le damos a Install .

Aceptamos la licencia, asumimos el riesgo de instalar un plugin “no firmado” y rebotamos el IDE para que se reflejen los cambios.

En este momento el plugin debería estar listo para ser utilizado. Mientras trabajamos PMD monitorizará el código que escribimos y nos pondrá una marca en el editor cuando algo no le guste. Si ponemos el puntero encima de la marca, se nos mostrará un mensaje informativo del problema en forma de tooltip .

Si queremos obtener un informe de todos los posibles problemas en una carpeta de código, paquete o clase, sobre la ventana Projects hacemos click derecho en el elemento correspondiente -> Tools -> Run PMD.

Ello abrirá una nueva pestaña de informe con todas los avisos disponibles en forma de tabla (permitiendo ordenación por las diferentes columnas). Haciendo doble click sobre cualquiera de las advertencias, el editor se desplazará a la línea de código correspondiente.

PMD puede ser muy estricto y es posible que nos interese personalizar el tipo de alertas generadas y, quizá, desactivar algunas. Hay que encontrar un compromiso entre lo razonable y la calidad. Por ejemplo, algunas de las estructuras autogeneradas por el IDE (como el equals mostrado en el ejemplo unas líneas más arriba) producen advertencias que podríamos ignorar con tranquilidad ya que NetBeans sabe lo que hace . Para modificar la configuración del plugin y el tipo de reglas que aplicar, nos vamos al menú de opciones: Tools -> Options -> Miscellaneous.

Las reglas se gestionan mediante rulesets temáticos. Es decir un ruleset puede contener todas aquellas reglas ( rules) que tengan que ver, por ejemplo, con código muerto. Mediante el menú de rulesets podemos incluir o no las incluidas con PMD y añadir otras propias generadas por nosotros o por terceros. En el menú Manage rules se nos permite la activación o desactivación de reglas individuales.

Incluir PMD en el script del Ant de NetBeans

De manera análoga a las herramientas anteriores, descargamos e instalamos la herramienta en /srv .

root@hargon:/srv# unzip -q pmd-bin-4.2.5.zip
root@hargon:/srv# ln -s pmd-4.2.5/ pmd
root@hargon:/srv# rm pmd-bin-4.2.5.zip
root@hargon:/srv# cd pmd/lib/
root@hargon:/srv/pmd/lib# ln -s pmd-4.2.5.jar pmd.jar

A continuación modificaros el build.xml de manera adecuada.

<taskdef name="pmd"
    classname="net.sourceforge.pmd.ant.PMDTask"
    classpath="${pmd.dir}/lib/pmd.jar"/>

<target name="pmd-report">
    <property
        file="nbproject/project.properties"/>

    <mkdir dir="${pmd.report.dir}" />

    <pmd shortFilenames="true">
        <ruleset>unusedcode,basic,design,controversial</ruleset>
        <formatter type="xml"
            toFile="${pmd.report.dir}/pmd.xml"
            linkPrefix="http://pmd.sourceforge.net/xref/" />

        <formatter type="html"
            toFile="${pmd.report.dir}/pmd.html"
            linkPrefix="http://pmd.sourceforge.net/xref/" />

        <fileset dir="${src.dir}">
            <include name="**/*.java"/>
        </fileset>
    </pmd>
</target>

Las propiedades las añadimos al fichero correspondiente: el pmd.dir (con valor /srv/pmd ) en el nbproject/private/private.properties y el pmd.report.dir (con valor ${reports.dir}/pmd-report ) en el nbproject/project.properties .

El task del PMD es sencillo de utilizar. Primeramente indicamos qué rulesets de los estándar queremos analizar (podríamos también especificar rulesets personalizados) y a continuación indicamos en qué formatos queremos generar los informes. Como es habitual, tendremos los informes en XML que se integran bien con Hudson y en formato HTML para ser leídos por humanos.

Integrando PMD con Hudson

Al igual que las dos herramientas anteriores, instalamos PMD en el servidor de integración y definimos la propiedad pmd.dir en el nbproject/private/private.properties .

A continuación instalamos el plugin del PMD del Hudson de la manera habitual (no olvidéis rebotar lo) y ya podemos proceder a la configuración del job tal y como se muestra en la siguiente captura. Obviamente podemos establecer los límites que por defecto, como casi siempre, están desactivados.

Y estos serían los informes generados.

FindBugs

Sin entrar en demasiados detalles, FindBugs es una herramienta similar a la anterior. En el momento de escribir este tutorial todavía no existe una versión compatible del plugin para NetBeans 6.5, pero los ingenieros de FindBugs están trabajando en ello y me imagino que estará disponible en breve (sí que existen versiones funcionales para otros IDEs).

Incluir FindBugs en el plugin de Ant de NetBeans

Procedemos a descargar el paquete para instalarlo de la manera habitual.

root@hargon:/srv# tar -zxf findbugs-1.3.7.tar.gz
root@hargon:/srv# ln -s findbugs-1.3.7 findbugs
root@hargon:/srv# ls -alh findbugs
lrwxrwxrwx 1 root root 14 2009-03-05 15:55 findbugs -> findbugs-1.3.7

A continuación modificamos el build.xml para añadir un target que use el task del NetBeans.

<taskdef name="findbugs"
    classname="edu.umd.cs.findbugs.anttask.FindBugsTask"
    classpath="${findbugs.dir}/lib/findbugs.jar" />

<target name="findbugs-report" depends="compile">

    <property file="nbproject/project.properties"/>

    <mkdir dir="${findbugs.report.dir}"/>

    <findbugs home="${findbugs.dir}"
        output="xml"
        outputFile="${findbugs.report.dir}/findbugs.xml">
    
        <sourcePath path="${src.dir}" />
        <class location="${build.classes.dir}" />

    </findbugs>
</target>

Como en los casos anteriores, añadimos las propiedades a los ficheros correspondientes: el findbugs.dir (con valor /srv/findbugs ) en el nbproject/private/private.properties y el findbugs.report.dir (con valor ${reports.dir}/findbugs-report ) en el nbproject/project.properties .

El task del FindBugs requiere no sólo el código fuente sino también las clases compiladas y por ello el target tiene una dependencia del target estándar de NetBeans compile . Las clases compiladas se referencian mediante una propiedad también estándar de NetBeans: build.classes.dir .

El resto de propiedades son las típicas que hemos ido viendo, el directorio de instalación de la herramienta y el directorio de salida de los informes.

En este caso estamos generando los informes en XML que son los que entiende Hudson, pero también pueden generarse en otros formatos, como en texto plano o en HTML.

Integrando FindBugs con Hudson

Como siempre, replicamos la instalación del FindBugs en la máquina donde está instalado el Hudson y definimos la propiedad findbugs.dir apuntando al directorio correspondiente en el nbproject/private/private.properties .

FindBugs también tiene un plugin nativo para Hudson, así que lo instalamos y reiniciamos. A continuación, de manera totalmente análoga al PMD, configuramos el nuevo target y las opciones de FindBugs.

Finalmente ya podemos ver los informes generados.

Conclusión

En este artículo hemos aprendido que existen herramientas que nos pueden ayudar a generar métricas sobre la calidad de nuestro código. También hemos enfatizado el hecho que obtener un 100% de puntuación no garantiza un software de calidad.

Hemos visto que las herramientas suelen venir en tres “sabores”: como plugin para el IDE que dan un feedback inmediato al programador, como task del Ant que permiten ejecutarlas en modo consola e integrarlas con otros sistemas y como plugin para Hudson que permite publicar los informes correspondientes de una manera agradable para los humanos.

Existen muchas más herramientas de calidad. En próximos artículos tocaré algunas mas.


Tagged: Agile, Ant, calidad, Hudson, Java, NetBeans

NetBeans Community Docs Blog - March 01, 2009 04:48 PM
NBCD Monthly Newsletter #22

The Netbeans Community Docs Monthly Newsletter for February 2009 is available at this time. The Netbeans Community Docs team has added a few new sections to the newsletter. We think that they will be of great value to the readers.

To view the newsletter, please follow the link below.

February 2009

View the NBCD Newsletter Index:

NBCD Newsletter Index

Best to you, and thanks for reading.

Josh Juneau

NetBeans Community Docs Blog - February 27, 2009 08:45 PM
NBCD Monthly Newsletter #21

The Netbeans Community Docs Monthly Newsletter for January 2009 is available at this time. The format of the newsletter has changed a bit, we hope you like it.

To view the newsletter, please follow the link below.

January 2009

In the future, you will be able to view an index of all newsletters using the following link. We will begin to post a link to each newsletter from this date forward on the newsletter index page.

View the NBCD Newsletter Index.

Best to you, and thanks for reading.

Josh Juneau

Bits y Bytes » NetBeans - February 07, 2009 07:00 PM
Cobertura con NetBeans y Hudson

Este artículo como PDF.

Introducción

Una vez tenemos montado un entorno TDD, y si efectivamente estamos trabajando con esta orientación, nuestro proyecto empezará a acumular tests unitarios con JUnit o cualquier otro framework lo que permitirá a nuestro servidor de integración (Hudson) utilizarlos como tests de regresión.

Si estamos siendo estrictos en la aplicación de una metodología TDD, en principio el grado de cobertura del código (el porcentaje de líneas de código que son evaluadas por un test) debería estar cerca del 100% por aquello del “ escribe primero el test y luego el código que lo supera”. Sin embargo bien porque seamos principiantes aplicando la metodología o bien porque escribamos los tests como parte del proceso de calidad en una metodología diferente, puede resultar muy complicado calcular el grado de cobertura mediante técnicas manuales. Incluso en un entorno TDD maduro, la propia complejidad del software puede complicar extraer esta información. Es por ello que se han desarrollado una serie de frameworks y herramientas que permiten automatizar este proceso.

Como decía, no estamos solos ante el peligro y tenemos herramientas diversas y con todo tipo de licencias. Por citar algunas: Clover, EMMA, VectorCAST o Cobertura. Mi elección en este caso será la última por varios motivos: es un producto open source (por los que tengo debilidad, especialmente cuando uno es autónomo), ofrece tasks para usarlo desde Ant y tiene plugins para Hudson. Es una lástima que no tenga un plugin nativo para NetBeans, aunque como el IDE nos permite ejecutar targets de Ant fácilmente, se lo podemos perdonar.

Por cierto, existe un plugin de análisis de cobertura de código para NetBeans. No he jugado mucho con él, pero parece que es un servicio que sólo puede activarse para proyectos de JSE y no está disponible, por ejemplo, para un proyecto web. Si alguien tiene experiencia con el mismo, se agradecerá el feedback.

Gran parte de la información necesaria que he usado para escribir esta entrada la he obtenido de este post .

Configurar Cobertura en el NetBeans

El proceso es sencillo:

  1. descargar el software,

  2. instalarlo,

  3. modificar el build.xml del NetBeans.

Así pues, lo primero que tenemos que hacer es descargarnos el software desde SourceForge. Nosotros vamos a contentarnos con la versión binaria y dejaremos el hacking para otro momento. A continuación procederemos a la instalación que no es más que descomprimirlo en una carpeta de la máquina de desarrollo. Yo tengo la costumbre de instalar estas cosas en el directorio /srv y además suelo crear un enlace simbólico (que será el que referencie desde los proyectos) que no incluya el número de versión para que cada vez que haga una actualización no tenga que recorrer todos los scripts para corregir la referencia.

root@hargon:/srv# tar -zxf cobertura-1.9.1-bin.tar.gz
root@hargon:/srv# ln -s cobertura-1.9.1 cobertura
root@hargon:/srv# ls -alh total 684K
drwxr-xr-x  7 root      root    4,0K 2009-02-07 13:42 .
drwxr-xr-x 21 root      root    4,0K 2009-02-07 11:23 ..
lrwxrwxrwx  1 root      root      15 2009-02-07 13:42 cobertura -> cobertura-1.9.1
drwxr-xr-x  4 root      root    4,0K 2009-02-04 21:23 cobertura-1.9.1
-rw-r--r--  1 root      root    649K 2009-02-04 21:40 cobertura-1.9.1-bin.tar.gz
root@hargon:/srv# rm cobertura-1.9.1-bin.tar.gz

Como ya he explicado en alguna ocasión, NetBeans usa scripts de Ant para realizar todas sus tareas y están modularizados de manera que podamos introducir nuestros propios targets y personalizaciones. En particular el fichero que podemos “tocar” tranquilamente es el build.xml que está en la raíz del proyecto así que, mientras no diga lo contrario, todos los fragmentos de código deberán picarse en este fichero.

Lo primero que tendremos que hacer proporcionar a Ant los diferentes tasks proporcionados por Cobertura.

<path id="cobertura.classpath">
    <fileset dir="${cobertura.dir}">
        <include name="cobertura.jar" />
        <include name="lib/**/*.jar" />
    </fileset>
</path>

<taskdef classpathref="cobertura.classpath"
    resource="tasks.properties" />

Esto es uso estándar de Ant. La ruta a la raíz del frameworks lo indicamos en la propiedad cobertura.dir que a su vez cargamos del fichero de propiedades privadas. Usamos el fichero de propiedades privadas (nbproject/private/private.properties) porque la ruta del framework tiene sentido que pueda ser diferente en las máquinas de desarrollo y en el servidor de integración y, recordemos, si tenemos bien montado el repositorio de código el directorio nbproject/private no suele incluirse en el mismo. Para que todo esto funcione deberemos cargar desde el build.xml directamente dicho fichero de propiedades:

<property file="nbproject/private/private.properties"/>

y efectivamente añadir la propiedad en nbproject/private/private.properties :

cobertura.dir=/srv/cobertura

Los pasos para usar Cobertura son los siguientes:

  1. instrumentalizar el código bajo testing,

  2. ejecutar los tests unitarios con JUnit que genera los datos de cobertura y

  3. parsear los datos de cobertura para generar informes.

Instrumentalizar el código

Cobertura (y la mayoría de de frameworks de este tipo) funciona de manera que al ejecutar los tests unitarios se analiza qué parte de las clases bajo testing están siendo accedidas por las pruebas y qué partes no y se vuelca esta información en un archivo. Para que el framework de testing (en nuestro caso JUnit) pueda obtener esta información, Cobertura habrá tenido que instrumentalizar previamente las clases bajo test. Es decir, antes de ejecutar los tests, habremos tenido que permitir a Cobertura que genere un bytecode modificado (instrumentalizado) para cada una de las clases bajo testing. Es un proceso similar a como funcionan algunos profilers . Para obtener las clases instrumentalizadas lo haremos de la siguiente manera:

<target name="cobertura-instrument" depends="compile">
    <cobertura-instrument
        todir="${cobertura.classes.dir}"
        datafile="${cobertura.ser.file}" >

    <fileset dir="${build.classes.dir}">
        <include name="**/*.class"/>
    </fileset>
    </cobertura-instrument>
</target>

Creo que el target se entiende bastante fácilmente: básicamente estamos especificando donde guardaremos las las clases instrumentalizadas ( cobertura.classes.dir ), en qué fichero se escribirán los datos de cobertura ( cobertura.ser.file ) y dónde residen las clases a instrumentalizar ( build.classes.dir ). Esta última propiedad es una de las propiedades estándar que residen en el nbproject/properties ; las otras dos deberemos introducirlas en dicho fichero.

cobertura.ser.file=${build.dir}/cobertura.ser
cobertura.classes.dir=${build.dir}/cobertura/classes

Como nuestro target requiere los bytecode de las clases a instrumentalizar tiene como dependencia el target estándar compile que es el que usa NetBeans para compilar el proyecto. Entre las dependencias del propio compile se encuentra el target init que, entre otras cosas, es el encargado de cargar el fichero de propiedades (y por eso nosotros no tenemos que hacer de manera explícita la carga del mismo).

Ejecutar los tests

El siguiente paso consiste en ejecutar los tests sobre las clases instrumentalizadas para así extraer la información de cobertura. Aquí también podemos aprovecharnos de los scripts generados por NetBeans. Nuestro nuevo target , que llamaremos test-cobertura básicamente será una copia del target test (que es el que normalmente usa NetBeans para ejecutar las diferentes tests unitarios) con pequeñas modificaciones. Esta es la pinta que debería tener:

<target name="cobertura-test"
    depends="set-cobertura-file, init,compile-test,
    -pre-test-run,cobertura-instrument,
    -do-test-run,test-report,-post-test-run,-test-browse">
</target>

Con respecto al original, hemos añadido dos nuevas dependencias. Por un lado cobertura-instrument que es una referencia al target anterior para asegurarnos que existen las clases instrumentalizadas. Por otro lado hemos definido otra dependencia a otro target que también debemos construir y que muestro a continuación:

<target name="set-cobertura-file" depends="init">
    <property
        name="test-sys-prop.net.sourceforge.cobertura.datafile"
        value="${cobertura.ser.file}"/>
</target>

Este target es necesario para establecer un parámetro de sistema que debemos pasar a todos los tasks de JUnit usados en los diferentes targets de los ficheros de scripting incluidos desde el build.xml (en particular el build-impl.xml ). Necesitamos pasar este parámetro para que los tasks del JUnit sepan dónde escribir la información de cobertura mientras ejecuta los tests.

El nombre de la propiedad de sistema a pasar es net.sourceforge.cobertura.datafile el porqué se pasa el parámetro de sistema en una propiedad con un nombre algo diferente, lo tengo explicado en este otro post . El valor de la propiedad, como ya hemos visto (pues es un propiedad que ya he necesitado en targets anteriores), está dentro del fichero nbproject/project.properties y por eso nuestro target tiene una dependencia del target init que es el que se encargaba de cargar las propiedades definidas en ese fichero.

Falta un detalle adicional: especificar al JUnit que ejecute las clases instrumentalizadas y no las generadas directamente en la fase de compilación. Para hacer esto sólo tenemos que introducir unos pequeños cambios en el classpath utilizado por los targets de testing lo que implica cambiar la propiedad run.test.classpath definida en el nbproject/project.properties para que quede así:

run.test.classpath=\
    ${cobertura.dir}/cobertura.jar:\
    ${cobertura.classes.dir}:\
    ${javac.test.classpath}:\
    ${build.test.classes.dir}

Si hemos hecho todo correctamente al ejecutar el target cobertura-test deberían ejecutarse los tests unitarios como siempre pero además debería haberse construido el fichero build/cobertura.ser que contiene la información de cobertura.

Crear los informes de cobertura

El fichero build/cobertura.ser , como decíamos, contiene la información de cobertura pero está en formato binario porque ha tenido que generase en tiempo de ejecución de los tests de manera eficiente. Para extraer información legible hay que parsear dicho fichero. Para ello Cobertura nos proporciona el task cobertura-report .

Este task permite generar los informes en dos formatos: en XML o en HTML . Nosotros generaremos ambos. El primero lo necesitaremos para pasárselo al plugin correspondiente en el Hudson. El segundo nos proporcionará una vista agradable y legible. Veamos el target que tenemos que definir:

<target name="cobertura-report" depends="cobertura-test">
    <cobertura-report
        datafile="${cobertura.ser.file}"
        format="xml"
        destdir="${cobertura.report.dir}"
        srcdir="${src.dir}" />

    <cobertura-report
        datafile="${cobertura.ser.file}"
        format="html"
        destdir="${cobertura.report.dir}"
        srcdir="${src.dir}" />
</target>

Creo que aquí no hay mucho que explicar. Defino dónde está el fichero que contiene la información de cobertura, dónde quiero generar los informes y el formato de los mismos. Como siempre habremos de definir la propiedad cobertura.report.dir en el nbproject/project.properties :

reports.dir=${build.dir}/reports
cobertura.report.dir=${reports.dir}/cobertura-report

Si ahora ejecutamos este target deberían generarse los informes en el directorio especificado. Si le echamos un ojo a los informes de tipo HTML vemos que básicamente ha generado unas páginas al estilo de la documentación de las API pero con la información de cobertura. Una manera muy útil e intuitiva de mostrar la información.

Configurar el Hudson

Una vez hemos configurado todo lo anterior, ya tenemos hecho el trabajo duro. La configuración del Hudson, afortunadamente, es bastante sencilla. Estos son los pasos:

  1. instalar Cobertura,

  2. instalar el plugin de Cobertura y

  3. configurar el job :

    1. configurar el workspace para indicar dónde está Cobertura,

    2. añadir el cobertura-report en la lista de targets que tiene que ejecutar el Ant y

    3. configurar el directorio donde están los informes en XML

Instalar Cobertura

Para que el Ant lanzado por Hudson al construir el proyecto sea capaz de instanciar los tasks del Cobertura, éste tendrá que ser instalado en la máquina donde reside Hudson. El proceso de instalación será exactamente análogo al que hemos hecho en el entorno de desarrollo: descargar el paquete, descomprimirlo en el directorio /srv y establecer un enlace simbólico.

Instalar el plugin

Una vez tenemos Hudson instalado, añadir plugins es trivial. Desde la interfaz web vamos a Hudson -> Manage Hudson -> Manage Plugins -> Available y entonces seleccionamos Hudson Cobertura plugin y le damos a Install . El asistente entonces instala el plugin tras los cual habrá que reiniciar Hudson.

Configurar eljob

Aquí estamos presuponiendo que ya existe un job previo correctamente configurado y al que simplemente vamos a añadir el soporte de cobertura. Si no fuera así, echadle un ojo a este otro post que ya publiqué en su momento.

Lo primero que haremos es configurar el workspace para que sea capaz de encontrar Cobertura durante la fase de construcción del proyecto. Para ello, nos vamos al directorio nbproject/private/private.properties del job correspondiente y añadimos la propiedad que indica dicha ruta:

cobertura.dir=/srv/cobertura

A continuación modificaremos los targets de Ant que usa Hudson para construir el job . Si tuviéramos el target test lo eliminaríamos y a continuación añadiremos el target cobertura-report .

Lo siguiente es configurar el plugin para que utilice el informe XML generado:

  • Publish Cobertura Coverage Report : activamos la opción para que Hudson muestre la información de cobertura.

    • Cobertura xml report pattern : build/reports/cobertura-report/coverage.xml
      Aquí ponemos la ruta al fichero donde hemos generado el informe en formato XML.

    • Coverage Metric Targets : este apartado nos permite definir las métricas a partir de las cuales la construcción del job se considera estable o no.


En principio ya está todo. Ahora podríamos lanzar una construcción para comprobarlo. Si todo va bien, Hudson mostrará los informes de cobertura bajo el enlace Coverage Report en la raíz del job .

- 8 -


Tagged: Agile, calidad, Hudson, Java, NetBeans, TDD

Bits y Bytes » NetBeans - February 06, 2009 07:59 PM
Pasar propiedades de sistema a los tasks JUnit de los scripts de NetBeans

Como ya he explicado alguna vez, NetBeans utiliza scripts de Ant para realizar las diferentes tareas que lleva acabo el IDE, como compilar el proyecto, lanzar los tests, ejecutarlo, desplegarlo, etc.

NetBeans genera los scripts de manera modular de manera que el usuario pueda personalizarlo de forma adecuada. Genera el build.xml principal en la raíz del proyecto que a su vez incluye otros tantos recursos del subdirectorio de nbproject. Estos recursos son ficheros de propiedades y de scripting adicionales con la implementación real de los diferentes targets.

La idea de esta estructuración es que los ficheros con targets en el directorio nbproject (build-impl.xml, por ejemplo) nunca deberían tocarse ya que se pueden regenerar (y por tanto se perdería toda nuestra personalizacion) en función de las diferentes opciones que definamos para nuestro proyecto a través de la propia interfaz del IDE. Por contra, el build.xml principal no se regenerará y es por tanto en este fichero donde personalizaremos los scripts (añadir nuevos targets, definir propiedades, etc.).

El problema surge cuando queremos modificar el comportamiento de algunos de los targets definidos en los ficheros “intocables”. Por ejemplo, un requerimiento que puede surgir fácilmente (veremos algún ejemplo en próximos posts) es la necesidad de pasar parámetros de sistema a los tasks que ejecutan las pruebas unitarias con JUnit.

Afortunadamente el equipo de NetBeans ha previsto esta situación y la solución es bastante sencilla. Imaginemos que queremos pasar una propiedad de sistema que se llama MiPropiedad con valor MiValor, la solución pasa por definir en el build.xml una propiedad que se llame test-sys-prop.MiPropiedad y todos los taks Junit de los scripts generados automáticamente recibirán la propiedad MiPropiedad con el valor que le hayamos indicado. Si necesitáramos pasar más de una propiedad repetiríamos el mismo proceso con otro nombre de parámetro.

En código, habría que incluir el siguiente tag en el build.xml principal:

<property name="test-sys-prop.MiPropiedad" value="MiValor" />

Si queréis entender el motivo exacto y hackear los scripts de NetBeans, echadle un ojo a este post.


Tagged: Ant, JUnit, NetBeans

Bits y Bytes » NetBeans - February 06, 2009 05:30 PM
Monitorizar Hudson desde NetBeans

En un post anterior explicaba como montar un entorno básico para poder empezar a trabajar en un entorno TDD. El ide que elegí fue NetBeans y el servidor de integración continua Hudson. El siguiente paso natural es poder monitorizar Hudson desde el propio NetBeans sin tener que abrir el navegador web. Para poder llevar a cabo esta tarea, existe un plugin desarrollado por el propio equipo de Hudson. Aunque su uso es muy sencillo, en este post explicaré cómo instalarlo, configurarlo y utilizarlo. Los desarrolladores del plugin tienen un entrada en su wiki, así que mi post es un poco redundante :-P

Instalar el plugin

El primer paso consiste en instalar el plugin. Para ello tenemos varias alternativas.

Podemos descargarlo desde el NetBeans Plugin Portal como un fichero nbm que luego instalaremos a través del gestor de plugins del NetBeans: Tools -> Plugins -> Downloaded -> Add Plugins y seleccionaremos el fichero descargado.

La otra alternativa, que prefiero, es hacerlo directamente desde la pestaña de plugins disponibles siempre que tengamos configurado el Update Center del Plugin Portal : Tools -> Plugins -> Available Plugins -> Install .

Configurar el plugin

Una vez instalado lo tenemos disponible en la pestaña Services junto con los servidores, los SGBDs y demás, valga la redundancia, servicios.

Haciendo click derecho sobre el icono del Hudson, nos aparece la opción de añadir una instancia (podríamos monitorizar simultáneamente diferentes servidores de integración). Simplemente tendremos que completar el asistente dándole un nombre a esa instancia, asignándole la url donde reside el servidor y una frecuencia de refresco del estado del mismo.

Usar el plugin

A partir de ese momento podemos ver el estado de Hudson de un vistazo. Por un lado podemos ver el estado de todos los jobs con códigos de colores (correcto, roto o inestable) y el estado de ocupación de la cola de construcción. Por otro lado podemos programar nuevas construcciones de cualquier job haciendo click derecho sobre el job -> Start job o ver una información más extendida del job haciendo doble click sobre el mismo (lo que abre una ventana en el panel del editor). Obviamente podemos saltar directamente a la página web correspondiente en el navegador haciendo click derecho sobre el nodo correspondiente -> Open in Browser .

netbeans_service_hudson1

El “problema” de monitorizar de esta manera es que nos fuerza a acceder a la pantalla de servicios. Afortunadamente el plugin también proporciona una alerta a manera de iconito rojo parpadeante y estresante en el margen inferior izquierdo del NetBeans. El icono omnipresente persiste hasta que se arregle el job roto. Clickando sobre el mismo nos da información del job (o jobs ) que están causando la alerta.

Disfrutadlo.


Tagged: Hudson, NetBeans, TDD

NetBeans Community Docs Blog - January 16, 2009 08:13 AM
Developing Jython Apps using NetBeans IDE

...is the first community-contributed tutorial on Python support in NetBeans 6.5 IDE, written by Joshua Juneau, NetCAT 6.5 Participant

Here's a brief overview of the tutorial;

Since Netbeans 6.5 has been released, Python and Jython support has been available via the nbPython plugin. There is quite a bit of documentation available for this plugin in various locations. In this article, I will tie together some of the different references for this plugin and I will show you how to generate a small Jython application which uses some Java libraries contained within an external JAR file.



Thanks, Josh!

Bits y Bytes » NetBeans - January 12, 2009 06:24 PM
Montando un entorno de integración continua (Hudson + Ant + SVN + NetBeans)

Este post como artículo en PDF

Introducción

Cuando uno lee posts, libros y escucha experiencias de la aproximación ágil al desarrollo del software y empieza a profundizar y a aprender conceptos tales como el TDD (test driven development) y la integración continua, se le despiertan una ganas irrefrenables de empezar a trabajar de este modo. En este post lo que intentaré explicar es cómo montar un entorno sencillo que nos permita tener los cimientos de un sistema ágil que cada uno podrá extender para satisfacer sus propias necesidades. Como se menciona en este post, tres de los pilares de la integración continua son: un repositorio de datos, un servidor de integración continua y una herramienta que permita automatizar la construcción de la aplicación. Yo además añadiría un cuarto: un IDE que se integre bien con el resto del entorno. No es el propósito de este post discutir la utilidad de estos componentes (el post mencionado anteriormente puede ser un buen punto de partida para los recién llegados), sino elegir unas herramientas concretas y describir su configuración e integración. En mi caso he hecho la siguiente elección (que no tiene por qué ser la única ni la mejor):

  • repositorio de código: SVN
  • servidor de integración continua: Hudson
  • herramienta de construcción: ANT
  • IDE: NetBeans 6.5

Por simplicidad he distribuido el entorno entre una máquina Linux (Ubuntu 8.10) con IP 192.168.1.10 (dato que es relevante para tareas de configuración que iremos viendo) que actúa simultáneamente como repositorio de datos y de integración continua y un número arbitrario de máquinas de desarrollo (también Ubuntu 8.10) que contienen los IDE’s y el entorno con el que trabajan los desarrolladores. En cualquier caso, otras distribuciones tienen exactamente la misma complicación y los pasos requeridos son directamente extrapolables y fácilmente adaptables. Para explicar los diferentes pasos utilizaré un mismo ejemplo ya que considero que hablar con algo concreto suele ser más sencillo, tanto para el que explica como para el que intenta entender, que hacerlo en general o en abstracto. Presupongo la inteligencia de los potenciales lectores para hacer las adaptaciones requeridas en cada punto a sus propias necesidades. No es muy relevante, pero utilizaré un proyecto personal que estoy empezando estos días que sirve para hacer un seguimiento de las valoraciones de mis cursos y que se titula, en un alarde de originalidad, “Encuestas”.

En el siguiente diagrama muestro el entorno que acabaremos montando. Las rutas que aparecen en el servidor no tenemos por qué entenderlas ahora pero servirán como referencia a medida que vayamos construyendo la solución.

Configuración Subversion

He elegido Subversion porque es un repositorio más o menos potente que supera algunas de las limitaciones de nuestro querido y viejo CVS y aún a día de hoy es una de las herramientas que, bajo mi humilde opinión, están más extendidas en la industria. No voy a entrar en los detalles de instalación y de configuración del propio Subversion. Para ello ya hay mucha documentación online (por ejemplo aquí). Me centraré en la creación de un repositorio para nuestro proyecto. Es cierto que se puede usar el mismo repositorio para más de un proyecto, pero yo prefiero tenerlo separado (alguno de los motivos aparecerán más adelante, aunque también se puede justificar razonadamente la otra postura).

Crear el repositorio del SVN que almacenará el proyecto

Como decía, presupongo que el servidor que actuará como repositorio de datos tiene instalado el Subversion y sus herramientas administrativas (si no es así, nuestro querido apt-get o Synaptic vendrán a nuestro rescate). Lo primero que hay que hacer es determinar en qué ruta almacenaré el repositorio. Yo tiendo a almacenar los diferentes repositorios de cada uno de los proyectos bajo una misma raíz y así mantengo el servidor más o menos organizado. La ruta también debería ser vistosa porque luego formará parte de la configuración que utilicen los clientes (como los IDE’s) para conectarse con dicho repositorio. Trabajando con Ubuntu, y si hemos instalado el Subversion desde paquetes, se crea un usuario svn. Para que todo funcione de manera correcta, deberíamos asegurarnos que el propietario del repositorio es este usuario. Una manera de hacerlo es ejecutar los comandos de administración del Subversion con este usuario y otro es cambiar después el propietario del directorio (y su contenido) con el comando chown (chown -fR svn .)/Encuestas-2). En definitiva, para crear el repositorio haremos lo siguiente:

svnadmin create /srv/svn/Encuestas-2

El directorio /srv/svn es la raíz de todos mis repositorios y Encuestas-2 es el que usaré para este proyecto en particular. Si ahora nos situamos en en el ese directorio y hacemos un listado deberíamos ver (más o menos) lo siguiente:

ivan@hargon:/srv/svn/Encuestas-2$ ls -alh
total 36K
drwxr-xr-x 7 svn root 4,0K 2009-01-11 10:43 .
drwxr-xr-x 6 svn root 4,0K 2009-01-11 10:43 ..
drwxr-xr-x 2 svn root 4,0K 2009-01-11 10:43 conf
drwxr-xr-x 2 svn root 4,0K 2009-01-11 10:43 dav
drwxr-sr-x 5 svn root 4,0K 2009-01-11 10:43 db
-r--r--r-- 1 svn root    2 2009-01-11 10:43 format
drwxr-xr-x 2 svn root 4,0K 2009-01-11 10:43 hooks
drwxr-xr-x 2 svn root 4,0K 2009-01-11 10:43 locks
-rw-r--r-- 1 svn root  229 2009-01-11 10:43 README.txt

Establecer la seguridad del repositorio

Cuando se crea un repositorio en el Subverson es, obviamente, para que los desarrolladores puedan utilizarlo. Por tanto un paso importante es la parte de securización y autorización del mismo: establecer quién podrá acceder y sus credenciales. Subversion tiene diferentes mecanismos de autenticación y de transporte seguro de la información (incluyendo ssh). No voy a entrar en los detalles y explicaré cómo hacerlo de la manera más sencilla. Para más información os remito al anterior enlace.

En mi caso, todas las máquinas residen en el interior de mi red de área local, que puede considerarse “zona segura”. Un punto importante es que los mecanismos de seguridad (y otros más) se establecen por repositorio (en contraposición a una configuración global para todos ellos) lo que nos permite que convivan repositorios con diferentes configuraciones (este es uno de los motivos por los que prefiero tener un repositorio por proyecto). Lo primero es determinar el modo de autenticación. Para ello habremos de editar el fichero

/srv/svn/Encuestas/conf/svnserve.conf

para que quede más o menos así:

[general]
anon-access = none
auth-access = write
password-db = passwd
realm = My Realm

De hecho estas opciones seguramente preexisten en el fichero generado en el repositorio y lo único que habrá que hacer es descomentarlas. También es posible que en el fichero haya otras tantas opciones comentadas que no vamos a necesitar para nuestra configuración básica, así como diferentes comentarios descriptivos. Yo los he obviado por claridad. Con esta configuración lo que estamos haciendo es decirle al Subversion que busque los usuarios y las credenciales en un fichero de texto plano. El siguiente paso, precisamente, consiste en configurar qué usuarios y con qué credenciales podrán acceder al repositorio editando dicho fichero que se encuentra en:

/srv/svn/Encuestas/conf/passwd

que editaremos para que quede algo parecido a lo siguiente:

[users]
ivan = super-secret-passwd
ana = top-secret-passwd

Estos serán los usuarios y passwords que habrá que configurar en los clientes (en nuestro caso usaremos NetBeans).

Configuración NetBeans

Supongamos que nuestra aplicación de ejemplo Encuestas es una aplicación web típica que va a correr encima de un Tomcat 6. Así pues lo primero que haremos es crear un nuevo proyecto web mediante los asistentes del IDE. Asumo que estos pasos los sabréis llevar a cabo pero, en cualquier caso, no son el tema del presente post y lo pasaré muy rápido.

Asistente del NetBeans para crear un proyecto web

Conexión con el Subversion

Una vez tenemos creado el proyecto web, lo siguiente es enlazarlo con el Subversion. Para ello haremos click derecho en el nombre del proyecto, y en el menú versioning seleccionaremos la opción Import into Subversion Repository que nos abrirá un asistente para configurar la conexión. En mi versión de NetBeans (la 6.5) el aspecto que tiene es el que podéis ver en la siguiente captura de pantalla.

Asistente del NetBeans para configurar el SVN - Paso 1

Los siguientes pasos nos permiten seleccionar qué ficheros importar al repositorio. En este punto se podría abrir una discusión sobre si sólo subir los ficheros de código y recursos necesarios para el proyecto desde un punto de vista de independencia del IDE utilizado o si bien subir también los ficheros y recursos asociados al IDE. Puede ser una discusión interesante, pero la dejaremos para otro momento. En esta ocasión, para simplificar (y en mi caso es siempre la opción preferida), subiremos todos los recursos tal y como muestra el tercer paso del asistente.

bla bla

En este momento ya tenemos conectado el IDE con el repositorio. Los pasos e ideas fundamentales son los mismos para otros entornos como Eclipse y CVS. Quizá en otro post puedo explicar cómo configurar alguna de estas otras opciones. Para utilizar el NetBeans como cliente de Subversion tan sólo hay que hacer click derecho sobre el recurso correspondiente (un directorio o un fichero) y elegir la opción Subversion del menú contextual. La siguiente captura de pantalla lo ilustra.

Usando NetBeans como cliente de SVN

Tests unitarios con JUnit en NetBeans

En posts siguientes explicaré cómo integrar en el entorno ágil que estamos montando diferentes herramientas que aumenten nuestra productividad y la calidad de nuestro código ( PMD, CheckStyle, FindBugs, herramientas de cobertura…), pero por el momento me centraré en aquellas herramientas mínimas que requiere un entorno ágil que quiera trabajar con TDD: test unitarios. La idea es la siguiente: imaginemos que queremos trabajar con el framework de tests unitarios JUnit. Instalaríamos la herramienta en tres “lugares”:

  1. Como plug-in del IDE, lo que permite un uso integrado en el entorno de desarrollo del programador, con todas la ventajas de uso que ello conlleva.
  2. Como target en el build.xml del Ant. Este target nos permitirá ejecutar las mismas tareas desde la línea de comandos sin ayuda del IDE pero además, y más importante, permitirá al servidor de integración continua lanzar la tarea y generar los diferentes informes (en el caso de JUnit serán ficheros XML) especificando qué tests han sido superados, cuáles han fallado, etcétera.
  3. Como plug-in (que a veces puede venir preinstalado) del servidor de integración continua (en nuestro caso Hudson), de manera que pueda utilizar los informes generados en el target del Ant para mostrar información útil y gráfica y determinar si la construcción ha fallado o no entre otras cosas.

En este apartado veremos el primer punto y el resto los iré desarrollando a lo largo del post. También os aconsejo que leáis este magnífico post sobre cómo usar JUnit en NetBeans del propio blog oficial del IDE. El plug-in de JUnit ya está instalado por defecto en la mayoría (si no en todas) las distribuciones de NetBeans como IDE Java. Incluye además las dos versiones que se utilizan hoy día (la familia 3.X y la familia 4.X). Yo personalmente me decanto por la versión 4 porque me gusta poder utilizar anotaciones. Al crear cualquier proyecto Java con los asistentes de NetBeans, éste ya está preconfigurado para utilizar el framework (aunque nosotros podamos ignorarlo). Lo podéis comprobar en dos sitios: por un lado en la ventana Projects podemos ver que se ha creado un directorio Test Packages y por otro lado si hacemos click derecho sobre el nombre del proyecto, y abrimos el diálogo Properties en la sección Libraries – Compile Test veremos que están están agregadas las bibliotecas correspondientes.

Configuración por defecto de librerias en un proyecto web de NetBeans

La manera de construir un test unitario con NetBeans es muy simple. Simplemente tenemos que seleccionar la clase que queremos testear, hacer click derecho, seleccionar Tools y finalmente Create JUnit Tests que lanzará un menú modal en el que podremos seleccionar qué código autogenerar en el unit test que se va a crear (en el primero unit test que creemos, el entorno nos preguntará qué versión de JUnit querremos usar y ya la mantendrá para el resto del proyecto).

Crear un unit test a partir de una clase

Una vez codifiquemos el test unitario, lo siguiente es poder ejecutarlo; nada más sencillo: Run -> Test Project (o la combinación ALT + F6) y el resultado indicando si se pasan o no los tests se mostrará por la consola del IDE.

Configuración del Ant

Supongo que en este punto no tengo que explicar qué es Ant y asumo que conocéis su funcionamiento. Si bien trabajando en local, el IDE puede hacernos transparentes todos aquellos aspectos engorrosos como configurar el CLASSPATH, compilar, generar documentación, correr herramientas de análisis, desplegar en el servidor de aplicaciones, etcétera, cuando tenemos que hacerlo de manera remota, o hacer el despliegue en producción, o automatizar cualquiera de estas tareas dentro de un script, o, lo que más nos interesa en este post, permitir a un servidor de integración continua que construya nuestro proyecto, necesitamos una herramienta independiente del IDE. Ant es una opción que nos permite llevar esto a cabo (otra opción, por ejemplo, sería Maven).

Trabajando con Eclipse, hasta donde llega mi conocimiento, no tenemos más remedio que construir los build.xml a mano. De todos modos una vez que se ha hecho uno, si se organiza y parametriza de forma adecuada, el resto de proyectos pueden ir reutilizando una misma “plantilla” con cambios mínimos.

Trabajando con NetBeans podemos tener parte del trabajo resuelto. Ello se debe a que todas las tareas que realiza el IDE (compilar, testear, configurar los diferentes CLASSPATH, desplegar, etc.), lo hace con Ant mediante ficheros build.xml (y otros ficheros auxiliares) que construye dinámicamente en función de lo que nosotros configuremos de manera gráfica en la interfaz de NetBeans o a través de cualquiera de sus asistentes. Nosotros podemos aprovecharnos de estos ficheros generados para utilizarlos desde fuera del IDE para nuestros propios propósitos. La propia estructura de los scripts preveen diferentes targets “hook” donde añadir nuestro propio scripting si el generado no es suficiente.

A primera vista esto podría parecer genial y bueno, en gran parte lo es, pero hay que tener en cuenta una serie de consideraciones. La principal es que los scripts generados no son totalmente independientes del IDE ni de la máquina en la que se han generado porque utilizan recursos (bibliotecas y tasks) que sólo existen en los directorios de instalación del IDE y algunas de las rutas generadas son absolutas y por tanto dependientes de la máquina en donde se generaron. Por tanto si estos ficheros quieren utilizarse en otro contexto habrá que hacer algunos ajustes a mano. Dependiendo del tipo de proyecto en el que estemos trabajando (no será lo mismo una aplicación JSE que una aplicación J2EE con dependencias de un servidor de aplicaciones) la cantidad de esfuerzo requerida para hacer los scripts portables será mayor o menor. En este post se muestran algunos de los perfiles de aplicaciones y sus posibles problemas y soluciones (se corresponde con una versión de NetBeans algo vieja, pero la mayor parte de lo que se explica todavía aplica a las versiones actuales).

NetBeans genera el build.xml en la raíz del proyecto. Si lo abrís podéis ver que básicamente es un script vacío que lo que hace es importar otros tantos ficheros (más o menos dependiendo del tipo de proyecto) que se encuentran en la subcarpeta nbproject. NetBeans utiliza esta carpeta como su directorio de trabajo y para contener los diferentes metadatos del proyecto. En principio no deberíamos tocar ninguno de los ficheros contenidos bajo esta jerarquía de directorios a no ser que sepamos exactamente lo que estamos haciendo. Dentro de nbproject tenemos otra carpeta especial: private. Deberemos ir con cuidado de no incluir esta carpeta en el repositorio (por defecto el asistente ya lo hace bien) ya que contiene ficheros de parámetros con paths absolutos y dependientes de la máquina de cada desarrollador (o servidor de integración) usados por, entre otras cosas, por los scripts de Ant. Esto será parte de lo que tendremos que replicar a mano en el servidor de integración adaptándolo adecuadamente. (pero ya lo veremos más adelante).

Detalle del build.xml generado por el NetBeans

Al abrir el build.xml desde el propio NetBeans, la ventana Navigator nos muestra las tareas disponibles. Si queréis detalles, investigad un poco, pero bueno tenemos todos aquellos targets que esperaríamos encontrar y que podemos necesitar (y muchos más), por ejemplo:

  • clean
  • compile
  • debug
  • dist
  • javadoc
  • test

Los incrédulos podéis abrir una consola y comprobar como podéis invocar las tareas desde la línea de comandos. Para ello sólo os tenéis que situar en el directorio raíz del proyecto y ejecutar el ant como lo haríais con cualquier otro build.xml.

Configuración Hudson

Sólo resta la última pieza del puzle: automatizar la construcción del proyecto desde nuestro servidor de integración continua (Hudson) conectándolo al repositorio. También explicaré como automatizar el hecho que se programe una nueva construcción automática cada vez que hay un commit en el repositorio. La instalación y configuración inicial de Hudson es trivial pero está fuera del ámbito de este tutorial (baste decir que básicamente consiste en desplegar un war en un servidor de aplicaciones o un contenedor web como Tomcat).

Automatización de la construcción

Hudson automatiza la construcción de proyectos en lo que denomina j obs, así pues un mismo proyecto software puede tener diferentes jobs. Por ejemplo, tener configurado un job que se ejecute cada vez que se haga un commit en el repositorio y que lo único que compruebe es que el proyectos es compilable y que se pasan los test unitarios y tener otro job programado para ejecutarse tres veces al día para correr tests de aceptación o de integración más pesados. Nosotros empezaremos por algo muy sencillo, configurando un job para que haga lo que explicaba en el primer ejemplo (compilación más tests unitarios).

Hudson tiene una interfaz muy sencilla de utilizar. A diferencia de otros servidores de integración, tanto la creación como la configuración de los jobs se hace íntegramente desde la interfaz web.

Página principal del Hudson

Para crear nuestro job haremos click en New Job y se iniciará el asistente de creación. Lo primero que tenemos que hacer es dar un nombre a nuestro job que será utilizado tanto en la interfaz e internamente en el servidor de integración. Se puede utilizar cualquier símbolo en el nombre e incluso espacios, pero yo prefiero (manía personal) utilizar nombres con una sola palabra porque cuando luego se quiere navegar “a mano” (mediante la consola) por los jobs siempre es más cómodo no tener espacios puesto que el nombre que usemos se corresponderá con el nombre del directorio donde residirá toda la información asociada a dicho job. En nuestro ejemplo: Encuestas-2. Lo siguiente es elegir el tipo de job que estamos construyendo; nosotros construiremos un job estándar que es lo que Hudson llama un Build a free-style software project. Lo seleccionamos y le damos a OK para ir a la siguiente pantalla del asistente. En esta nueva pantalla tenemos todos los elementos de configuración del job que rellenaremos (aquéllos que haga falta) como sigue:

  • Source Code Managment: Subversion
    • Repository URL: svn://192.168.1.10/srv/svn/Encuestas-2/Encuestas
      Aquí hay que tener en cuenta una cosa. La raíz del repositorio es Encuestas-2 pero configuramos la url hasta Encuestas . Si no fuera así, el workspace generado para construir este job tendría un subdirectorio Encuestas (lo que complicaría la configuración del resto de elementos del job )

  • Build Triggers: permite definir en qué momento Hudson tiene que construir el proyecto. Hay diferentes políticas con las que podéis experimentar. Nuestro propósito para este job es que se construya cada vez que hay modificaciones en el repositorio. Para implementar esta política hay dos posibles maneras: o bien Hudson va preguntando al repositorio “¿ha habido cambios en el código?” de forma periódica (lo que se conoce como mecanismo por encuesta y que se corresponde con la opción “poll”) o bien que el propio Subversion avise a Hudson cada vez que ha habido un cambio. Esta última aproximación es más eficiente (y a mí parecer más elegante), pero se trata más bien de una configuración del Subversion (que veremos más adelante) y no del Hudson. Así pues no activaremos ningún tipo de trigger (lo dejamos tal y como está).
  • Build: nos permite configurar cómo Hudson debe construir el proyecto. Existen diferentes mecanismos pero nosotros en este post vemos cómo se hace mediante Ant, así que será esta la opción que elegiremos.
    • Ant version: dejaremos la “Default” con lo que Hudson utilizará la versión que encuentre en el path (esto está presuponiendo que existe un Ant configurado correctamente en la máquina donde reside Hudson).
    • Targets : compile test javadoc
      Aquí tendremos que especificar los targets definidos en el build.xml que queremos que Hudson ejecute. Como estamos utilizando el build.xml automáticamente generado por NetBeans tendremos que tener en cuenta algunas consideraciones que explico más adelante (como había comentado el build.xml generado no es del todo independiente del NetBeans y habrá que poner algún parche para que funcione desde Hudson).
  • Publish Javadoc : marcamos esta opción para publicar los documentos generados por javadoc asociados a nuestro proyecto. Los javadoc se generarán porque hemos definido el target correspondiente en la sección previa.
    • Javadoc directory :Encuestas/dist/javadoc
  • Publish JUnit test result report : marcamos esta opción para publicar los informes (y gráficas) de los resultados producidos por los diferentes test unitarios creados en el proyecto.
    • Test report XMLs : Encuestas/build/test/results/*.xml


Configurar el workspace del Hudson y añadir dependencias externas al Subversion

Hudson almacena todos los ficheros que necesita para su funcionamiento así como los diferentes artefactos para cada uno de los job en un directorio raíz conocido como el HUDSON_HOME. No es el propósito de este artículo explicar cómo configurarlo, pero puesto que necesitaremos modificar algunos aspectos de nuestro job sí que necesitamos saber cuál es su valor. Para verlo, desde la página principal de Hudson accedemos al menú de configuración y es el primer parámetro que nos encontramos (Hudson Home -> Manage Hudson -> System Configuration -> Home directory). En mi caso es el siguiente

HUDSON_HOME = /srv/hudson_home

Dentro de este directorio existe el subdirectorio jobs que contiene una entrada para cada job configurado. Así pues aquí tendremos un subdirectorio Encuestas-2 (que, como decía, se corresponde con el nombre que le asignamos al job cuando lo configuramos previamente). Dentro del directorio correspondiente a cada job, uno de los subdirectorios es workspace (si no existiera, le daríamos a construir el job desde la interfaz del Hudson). Este directorio contiene los ficheros descargados desde el repositorio de código cada vez que se lanza una construcción del job (el código fuente, los ficheros a usar por Ant, las bibliotecas incluidas en el proyecto, etc) y los artefactos generados en la construcción del proyecto. Lo remarco de nuevo: contiene los ficheros descargados desde el repositorio. Lo que quiere decir que si el proyecto para ser construido necesita artefactos que existen en los entornos de desarrollo pero que no están incluidos en el repositorio (o sus localizaciones son diferentes a las especificadas en los diferentes scripts de construcción), la construcción inevitablemente fallará. Con las herramientas con las que estamos trabajando habrá que hacer lo siguiente:

  • opcionalmente, si es un proyecto J2EE o requiere bibliotecas externas al contenido del repositorios de código, hacerlas accesibles al Hudson,
  • añadir algunas otras dependencias de NetBeans que tiene el build.xml generado,
  • construir el directorio /nbproject/private y su contenido para solucionar las dependencias.

Nuestro proyecto es un proyecto web que hemos configurado de manera que haga uso de la implementación de Servlets de Tomcat. Ello significa que en nuestro entorno de desarrollo tenemos un Tomcat y por tanto tendremos que replicar su instalación en la máquina donde reside Hudson para que pueda usar dichas bibliotecas. Lo más sencillo es empaquetar el Tomcat instalado en uno de los entornos de desarrollo y desempaquetarlo tal cual en el servidor de integración. En mi caso lo situaré en /srv/apache-tomcat-6.0.18.

La manera más sencilla de solucionar las dependencias que tienen los scripts del Ant del NetBeans es seguir una aproximación similar a la del caso del servidor de aplicaciones: copiar el propio NetBeans en la máquina donde reside el servidor de integración para que éste tenga acceso directo a todos los recursos. Obviamente es posible usar una aproximación menos “drástica” y copiar sólo aquellos recursos necesarios, pero sin duda copiar todo el entorno es la manera más rápida que hacerlo y la única penalización que obtenemos es ocupar unos cuantos MB más en el disco duro. Personalmente prefiero “malgastar” esos pocos a MB a tener que estar hackeando los scripts para ver qué necesito exactamente o pelearme con posibles y sutiles errores difíciles de trazar. Recapitulando: empaquetaremos el NetBeans de una de las máquinas de desarrollo y en mi caso lo situaré en /srv/netbeans-6.5. Adicionalmente NetBeans también guarda parte de la configuración en un directorio oculto en el home del usuario en un directorio oculto llamado .netbeans (esto es útil para que diferentes usuarios en una misma máquina física puedan tener configuraciones diferentes). En este caso no será necesario copiarlo absolutamente todo (un poco más adelante daré los detalles).

A continuación hemos de construir el directorio private que contiene los metadatos donde, entre otras cosas, se está configurando parte de la información local a utilizar por Ant y que por ello no se ha incluido en el Subversion. El tipo de proyecto que estamos usando (proyecto web usando Tomcat) sólo genera un fichero en esta carpeta, build.properties . Construiremos la carpeta private como un subdirectorio de la carpeta nbproject y copiaremos el fichero properties de uno de los entornos de desarrollo.

Los cambios que aplicaremos (todos relacionados con el cambio de rutas absolutas diferentes en desarrollo y en integración) son los siguientes:

  • cambiar la ruta al Tomcat por la que corresponde (sustituir la cadena /home/ivan/apache-tomcat-6.0.18 por la cadena /srv/apache-tomcat-6.0.18),
  • cambiar la ruta del Netbeans (sustituir la cadena /home/ivan/.netbeans-6.5 por la cadena /srv/netbeans-6.5),
  • cambiar las referencias al directorio de configuración del home (sustituir la cadena /home/ivan/.netbeans por /srv/.netbeans).

La primera línea del nbproject/private/ properties pasará a referenciar al archivo de configuración del Tomcat a la nueva ubicación en el servidor de integración en la ruta /srv/.netbeans/6.5/tomcat60.properties . Editaremos el fichero para adaptarlo al nuevo entorno; de hecho realmente la única línea que habremos de modificar es la que define el directorio donde reside el Tomcat porque el resto sólo tienen sentido si queremos arrancar el propio Tomcat (circunstancia que se da en las máquinas de desarrollo pero no, en principio, en el servidor de integración). Tras modificar el fichero tendríamos algo así:

tomcat.home=/srv/apache-tomcat-6.0.18
tomcat.password=super-password-de-administracion-de-Tomcat
tomcat.url=http://localhost:8084
tomcat.username=ide

Otro fichero referenciado en el nbproject/private/ properties que también tendemos que modificar será el /srv/.netbeans/6.5/build.properties . Este fichero gestiona una gran cantidad de propiedades. Afortunadamente con sólo sustituir todas las ocurrencias de la cadena que indica la ruta de la raíz de la instalación del NetBeans por la nueva ruta en el servidor de integración será suficiente (en mi caso, sustituir /home/ivan/netbeans-6.5 por /srv/netbeans-6.5 ).

Comprobando que el job está bien configurado

¡Felicidades! El camino ha sido más o menos largo y tedioso (no tanto, ¿verdad?), pero ya hemos casi terminado.

Para asegurarnos que todo se ha configurado correctamente intentaremos construir el proyecto desde la consola del servidor de integración. Para ello nos situaremos en el directorio Encuestas dentro del workspace del job que estamos configurando (/srv/hudson_home/jobs/Encuestas-2/workspace/Encuestas) que define la raíz del proyecto tal y como está en el Subversion. En ese directorio tenemos el build.xml así que podemos invocar al Ant tranquilamente. Una buena idea es probar todos los targets que querremos ejecutar desde el Hudson ( compile, test y javadoc ). Si se ejecutan sin problemas tenemos la garantía que Hudson también podrá hacerlo.

La prueba de fuego será construir el job desde la interfaz del Hudson: Hudson Home -> Encuestas-2 -> Build Now lo que programa una ejecución. Al terminar la misma, tendremos una nueva entrada en la Build History que tendrá una bullet azul o roja en función de si el proyecto se ha podido construir de forma correcta o de si ha habido algún error.

Los links Javadoc y Latest Test Result nos permiten acceder respectivamente a la documentación del proyecto y a los informes de testing generados por los diferentes tests unitoarios (Junit).

En este punto no estaría de más hacer una copia de seguridad del directorio nbproject/private y todo su contenido. El resto del workspace lo podéis regenerar al momento desde el repositorio, pero los cambios que habéis aplicado a los ficheros contenidos en el private no los tenéis en ningún otro sitio. Puesto que a priori, como decía, podemos recuperar (casi) todo el workspace desde el Subversion, en según qué circunstancias podemos decidir borrarlo sin acordarnos de todas las modificaciones que hemos tenido que hacer manualmente.

Conexión con el SVN

Podríamos dejarlo aquí, pero uno de los requisitos que queríamos configurar es que el job se construyera automáticamente cada vez que hiciéramos un commit en el Subversion. Para conseguir este comportamiento tenemos que configurar el Subversion para que avise al Hudson cada vez que detecte esta situación.

Una de las características que tiene Hudson es que permite programar la construcción de un job haciendo una petición GET sobre una url asociada al proyecto en cuestión. Siguiendo con nuestro ejemplo dicha url sería http://192.168.1.10:8180/hudson/job/Encuestas-2/build.

Por otro lado, el Subversion prevee una serie de eventos que pueden ser detectados y asociarles un script. Tenemos una serie de plantillas de los scripts y eventos que se pueden detectar en la carpeta hooks del repositorio que estamos utilizando. Puesto que nosotros queremos activar la construcción del proyecto cada vez que hacemos un commit, el script que necesitamos codificar es uno que se llame post-commit:

svn@hargon:/srv/svn/Encuestas-2/hooks$ ls
post-commit.tmpl          post-unlock.tmpl  pre-revprop-change.tmpl

post-lock.tmpl            pre-commit.tmpl   pre-unlock.tmpl
post-revprop-change.tmpl  pre-lock.tmpl     start-commit.tmpl
svn@hargon:/srv/svn/Encuestas-2/hooks$ cp post-commit.tmpl
post-commit
svn@hargon:/srv/svn/Encuestas-2/hooks$ chmod ug+x post-commit

El fichero que hemos copiado es una simple plantilla. Ahora la editaremos para que efectivamente haga una petición GET . Esto lo podemos hacer de múltiples maneras, aunque una muy fácil es utilizar Perl y algunas de sus bibliotecas (el gestor de paquetes apt-get o Synaptic nos permitirá instalar todas las bibliotecas requeridas de una manera sencilla ). Una posible implementación de este script es la siguiente:

#!/usr/bin/perl
use LWP::Simple;
use HTML::LinkExtor;
my $content =
get("http://192.168.1.10:8180/hudson/job/Encuestas-2/build");

Comprobemos que el script funciona ejecutándolo desde la consola. Si todo va bien, al abrir el Hudson veremos que se ha lanzado una construcción del job.

El último paso es probar que la integración con el Subversion funciona correctamente. Simplemente tenemos que hacer un commit que modifique cualquier fichero y el Hudson debería construir el job.

ACTUALIZACIÓN: 2ª Parte – Añadir métricas de cobertura de código de los tests unitarios

ACTUALIZACIÓN: 3ª Parte – Métricas de calidad con NetBeans y Hudson


Tagged: Agile, Ant, Hudson, Integración Continua, Java, JUnit, NetBeans, SVN, TDD

NetBeans Community Docs Blog - January 07, 2009 03:32 PM
Monthly Topmost Contributors 2007-08

Yesterday, we posted the statistics of our documentation project over the past 2 years (2007-08). Today, we present to you the list of our project's Monthly Topmost Contributors..

Year 2007

March
Spiros Gezerlis (2 docs)

April
Ahmet N Murati, Antonio Pintus (2 docs)

May
Paulo Cristo (5 docs)

July
Aristides Villarreal Bravo (3 docs)


August
Amit Kumar Saha (3 docs)

September
Amit Kumar Saha (2 docs)

October
Teera Kanokkanjanarat (2 docs)

November
Tonny Kohar (2 docs)

Year 2008
January
Kristian Rink (3 docs)

February
Amit Kumar Saha (2 docs)

March
Berni, Prakan Puvibunsuk (2 docs)

April
Jay Mahadeokar, John Muchow (3 docs)

May
Kunal Modi, Rajath Shanbag (2 docs)

June
Varun Nischal (8 docs)

July
Aristides Villarreal Bravo (3 docs)


August
Diego E. Silva L. (7 docs)

September
Hubert A. Klein Ikkink (5 docs)

October
Aristides Villarreal Bravo, Varun Nischal (2 docs)


November
Hubert A. Klein Ikkink (13 docs)

December
Anton Epple (4 docs)


Summary

Year 2007
June (4 docs) and December (9 docs), there were no significant contributors as authors wrote 1 doc each...
Year 2008
March, April, May and October featured 2 Topmost Contributors, while July, October and December featured members from NetBeans Dream Team.

Thank you!

NetBeans Community Docs Blog - January 07, 2009 10:12 AM
Dec 2008 | NetBeans Dream Team

Now, we shall see contributions done by NetBeans Dream Team Members during the month of December, 2008!

When was the last time they contributed?
Two months back, in Nov '08! They contributed Tutorials and Developer FAQs.


Tips & Tricks

Spanish
Aristides Villarreal Bravo

Dec 24
Cambiar el formato de fecha de jXDatePicker

English
Anton Epple
Dec 24
Create your own Platform versions

Dec 24
Fix Navigator Mode in NetBeans Platform Applications

Dec 23
NetBeans on USB Stick

Dec 08
Fix External Web Browser in NetBeans Platform Application
Varun Nischal
Dec 08
Want to use GSF API's?
Kristian Rink
Dec 05
NetBeans for Processing users

Thank you, Anton, Aristides, Kristian and Varun!

NetBeans Community Docs Blog - January 06, 2009 01:35 PM
Community-Contributed Docs Statistics

Statistics: Year 2007-08

Year 2007

Contributions- 76 (10 Months)
Unique Authors- 55
Analysis: This states that nearly every month, 8 docs were contributed to our project, and there were 5-6 authors joining the project every month..

Year 2008
Contributions- 203 (12 Months)
Unique Authors- 60
Analysis: This states that nearly every month, 17 docs were contributed to our project, and there were nearly 5 authors joining the project every month..

Comparative Study
From the above figures, one can infer that in the year 2008, there was 62.56% increase in the no. of contributions.. However, the rate of authors joining the project remained the same..

What Next?

This is your project and you are the driving force, so if you have any suggestions for betterment of this project, let us know.. We hope to see the same enthusiasm again this year, wish you good luck and thank you for your contributions till date..

Happy New Year :)

NetBeans Community Docs Blog - January 01, 2009 01:05 PM
NBCD Weekly Newsletter #20 (Spanish)

Últimos Documentos de la Comunidad

Trucos & Sugerencias


Aristides Villarreal Bravo

Dec 24 | Cambiar el formato de fecha de jXDatePicker

Trucos & Sugerencias

Anton Epple
Dec 24 | Create your own Platform versions

Dec 24 | Fix Navigator Mode in NetBeans Platform Applications

Dec 23 | NetBeans on USB Stick

Tutorial

Vaibhav Choudhary

Dec 26 | Getting Started with JavaFX (NB 6.1)

Noticias Especiales

Nuevo Contribuidor..
Vaibhav Choudhary es el último contribuidor del Programa NetBeans Community Docs .

Documentos JavaFX..
Hoy, James escribio en su blog acerca de la última contribución realizada por Vaibhav en Java FX, él escribio apasionadamente acerca de Java FX en su blogs. Deseando más documentos de él, así como de usted y a la comunidad de NetBeans. Rock on!!

Que es lo Nuevo..
Esta ese la última edición de nuestro Weekly Newsletters y desde Enero de 2009 en adelante, usted comenzara a recibir el Boletin Mensualmente... Por lo tanto , hemos comenzado a archivar arctículos de noticias seleccionados desde el boletin semanal publicados anteriormente al 19 y esta edición sera la última.

Esperando a todos ustedes han disfrutado de nuestra dosis semanal de últimas noticias de nuestro programa de documentos de comunidad NetBeans multilingüe y esperamos con interés con su cooperación en el año nuevo así.

Saludos de temporada


Esperando que todos ustedes hayan disfrutado nuestra dosis semanal de las últimas noticias desde nuestro Multilingual NetBeans Community Docs Program y esperamos con interés su cooperación en el Nuevo Año también.

Para finalizar, James Branam (NetBeans Community Docs Program Manager) ha escrito un special post para este programa y la comunidadand en el éxito del proyecto y un año lleno de acontecimientos, también discutiendo lo que se encuentra en el futuro..


Esta edición ha sido presentada a usted por;
Aristides Villarreal Bravo

___________________________________________________________
Available Languages: English , German, Spanish

NetBeans Community Docs Blog - December 29, 2008 07:21 PM
Year In Review: Blogs, Wikis, Evangelists and More...

So, 2 days left for New Year 2009 and everyone's in party mood, so are we. However, we want to end this year with a special review done by none-other-than James Branam, NetBeans Community Docs Program Manager.

Year 2008

2008 was a very successful year for the NetBeans Community Docs program, and I am proud to say that all of you played a role in its success. I especially would like to thank Contribution Coordinator Varun Nischal for his tremendous achievements and innovative leadership, both of which were vital factors in the growth of the program.

2008 also saw the appointment of Community Docs Evangelists, increased multi-language documentation, the publication of a regular newsletter, and a blog dedicated to the program. 2008 was also a good year for the program in terms of recognition. It was highlighted in several articles and as part of NetBeans 10th Birthday celebration.

Year 2009

2009 is nearly here, and the program will continue to evolve. We want to take the existing momentum and expand the program to reach a wider range of contributors. We also want to increase focusing on quality of contributions and adherence to existing style guides. Another challenge we look forward to engaging is creating a more purposeful documentation wish list and creating specialists for certain types of documentation.

On April 1, a new Contribution Coordinator will take the reins: Kristian Rink. A long time participant in the program, Kristian will bring new ideas to the program, building on the strong foundation that Amit Kumar Saha and Varun Nischal have established.

Happy New Year

I look forward to the new year and the challenges it will certainly bring. More importantly, I am proud to be working with such fine people as you all are, and I wish you a happy, healthy, and successful 2009.

Thank You!

NetBeans Community Docs Blog - December 29, 2008 07:08 PM
NBCD Weekly Newsletter #20

Latest Community Docs

Tips & Tricks


Aristides Villarreal Bravo

Dec 24 | Cambiar el formato de fecha de jXDatePicker

Tips & Tricks

Anton Epple
Dec 24 | Create your own Platform versions

Dec 24 | Fix Navigator Mode in NetBeans Platform Applications

Dec 23 | NetBeans on USB Stick

Tutorial

Vaibhav Choudhary

Dec 26 | Getting Started with JavaFX (NB 6.1)

Special News

New Contributor..
Vaibhav Choudhary is one of the latest contributor of the NetBeans Community Docs Program.

JavaFX Docs..
Today, James blogged about the latest contribution made by Vaibhav on Java FX, he's blogging passionately about Java FX on his blogs. Looking forward to more docs from him, as well as from you and NetBeans community. Rock on!!

What's New..
This is the last edition of our Weekly Newsletters and from January 2009 onwards, you would start receiving Monthly Newsletters... So, we had started archiving selected news items from the previously published 19 weekly newsletters and this edition would provide the last one.

Season Greetings


Hoping you all have enjoyed our weekly dose of latest news from our Multilingual NetBeans Community Docs Program and we look forward to your cooperation in the New Year as well.

To end, James Branam (NetBeans Community Docs Program Manager) has written a special post for this program and the community on the project's successful & eventful year, also discussing what lies in the future..


The final edition was brought to you by;
Varun Nischal
___________________________________________________________
Available Languages: English , German, Spanish

NetBeans Community Docs Blog - December 25, 2008 12:53 PM
Season Greetings

On behalf of the NetBeans Community Docs Team, I would like to wish each one of you who has been part of this successful community-driven project, NetBeans Community Docs Program...

Merry Christmas
, as well as want to tell you that on 29th December, 2008. We would be publishing 20th and the last edition of Weekly Newsletter, as thereafter you would receive Monthly Newsletters...

So, make sure you don't miss the special edition next week...

Stay Tuned for more...

NetBeans Community Docs Blog - December 23, 2008 07:20 PM
275 Docs and counting...

Hey,

We crossed an important milestone, as we await a major one! We have now more than 275 community-contributed docs as per Dec 24, 2008...We are now just 23 away from reaching a bigger milestone: 300 docs

Once again, thanks all for putting in your efforts...
We are rocking!

NetBeans Community Docs Blog - December 23, 2008 04:01 AM
Nov 2008 | NetBeans Dream Team

Now, we shall see contributions done by NetBeans Dream Team Members during the month of November, 2008!

When was the last time they contributed?
Two months back, in Oct '08! They contributed Tutorials and Tips & Tricks.


Tutorials

Spanish
Aristides Villarreal Bravo

Nov 04
Primeros pasos con Documentos NetBeans
German
Kristian Rink
Nov 06
Schnellstart mit der NetBeans-Dokumentation


Developer FAQ

Tom Wheeler
Nov 10
There sure are a lot of modules in the source tree. What are they for?

Thank you, Aristides, Kristian and Tom!

NetBeans Community Docs Blog - December 22, 2008 05:19 PM
NBCD Weekly Newsletter #19 (Spanish)

Últimos Documentos de la Comunidad

Tutoriales

Samuel Tan

Dec 19 | NetBeans 6.1 Hibernate JPA
Hendro Steven
Dec 19 | Simple JPA Application with Netbeans 6.0/6.1

Hubert A. Klein Ikkink
Dec 16 | Create Groovy 1.5.7 script in NetBeans 6.5

Noticias Especiales


Nuevo Contribuidor..
Hendro Steven, Samuel Tan son los últimos contribuidores del Programa NetBeans Community Docs.

... Tú eres sólo un mensaje de correo electrónico fuera, ¿qué decir?

Documentos Python ..
Bien, todos conocen acerca de Python EA Release con NetBeans 6.5, acerca de cómo contribuyen los documentos basados en el soporte Python ...Estás a sólo un correo electrónico, ¿qué dice?

Libro de Trucos y Sugerencias..
Este libro se centra en las recetas específicas que pueden hacerle más productivo en sus tareas rutinarias de desarrollo y proporciona respuestas a sus preguntas más apremiantes.


Dream Team Docs
Nov 2008
Aristides, Kristian contribuyeron con tutoriales, mientras Tom documento otro developer faq, en el mes de Noviembre.

Esta edición ha sido presentada a usted por;
Aristides Villarreal Bravo
___________________________________________________________
Available Languages: English , German, Spanish

NetBeans Community Docs Blog - December 22, 2008 01:46 PM
NBCD Weekly Newsletter #19

Latest Community Docs

Tutorials

Samuel Tan

Dec 19 | NetBeans 6.1 Hibernate JPA
Hendro Steven
Dec 19 | Simple JPA Application with Netbeans 6.0/6.1

Hubert A. Klein Ikkink
Dec 16 | Create Groovy 1.5.7 script in NetBeans 6.5

Special News


New Contributor..
Hendro Steven, Samuel Tan are the latest contributors of the NetBeans Community Docs Program.

Python Docs..
Well, you all know about Python EA Release with NetBeans 6.5, how about contributing docs based on the Python support...You're just an email away, what say?

Tips & Tricks Book..
This book focuses on specific recipes that can make you more productive in your routine development tasks and provides answers to your most pressing questions.


Dream Team Docs
Nov 2008
Aristides, Kristian contributed tutorials, while Tom documented yet another developer faq, in the month of November.

This edition was brought to you by;
Varun Nischal
___________________________________________________________
Available Languages: English , German, Spanish

NetBeans Community Docs Blog - December 17, 2008 12:19 PM
NBCD Weekly Newsletter #18 (Spanish)

Últimos Documentos de la Comunidad

Screencast

Prakan Puvibunsuk

Dec 09 | Pagination in SAF

Trucos y Sugerencias

Varun Nischal
Dec 08 | Want to use GSF API's?

Anton Epple
Dec 08 | Fix External Web Browser in NetBeans Platform Application

Michel Graciano
Dec 08 | Solving editor garbled text

Noticias Especiales


Archivos..
Documentos de Noviembre estan archivados, además ahora puedes encontrar mensualmente quien es "Topmost Contributor" visitando el archivo wiki de cada mes separadamente. Actualmente , sólo esta visible los meses del 2008, se esta trabajando para el 2007 ...

Blogs Deliciosos...
Se ha añadido un widget en el panel derecho de nuestro blog (debajo de la sección "The Gang" ) que muestra los blogs marcados ocasionalmente con su estatus...Puede ver las últimas 5 entradas..
Háganos saber ¿qué sientes?

Primer Aniversario..
El miembro de la comunidad, Varun Nischal celebró su cumpleaños el domingo 14 de Diciembre. El dia que realmente empezo a escribir documentos el año pasado.Por lo tanto, es su primer aniversario con este proyecto. Por lo tanto, su su primer aniversario con este proyecto. Las Personas interesadas pueden dar una lectura a su blog...

Blog da Docs

Esta sección incluye las entradas de los blogs contribuidos por los contribuidores superiores , en nuestras ediciones del boletín semanal (#11, #14, #15, #16).

Aristides Villarreal Bravo
#11 | CVS and Localization

Hubert A. Klein Ikkink
#14, #15, #16 | Tips and Tricks, Hat-trick Hero

Esta edición ha sido presentada a usted por;
Aristides Villarreal Bravo
___________________________________________________________
Available Languages: English , German, Spanish

NetBeans Community Docs Blog - December 16, 2008 06:28 PM
NBCD Weekly Newsletter #18

Latest Community Docs

Screencast

Prakan Puvibunsuk

Dec 09 | Pagination in SAF

Tips and Tricks

Varun Nischal
Dec 08 | Want to use GSF API's?

Anton Epple
Dec 08 | Fix External Web Browser in NetBeans Platform Application

Michel Graciano
Dec 08 | Solving editor garbled text

Special News


Archives..
November Docs are now archived, also you can now find out who's the monthly "Topmost Contributor" by visiting wiki archive of each month separately. Currently, visible only in 2008 months, work for 2007 going on...

Delicious Blogs...

We have added a widget on right-panel of our blog (below "The Gang" section) that shows the blogs we bookmark occasionally along with their status...You would always see the latest 5 entries..Let us know what do you feel?


First Anniversary..
Community members, Varun Nischal celebrated his birthday on Sunday, Dec 14th. The day he actually began writing docs last year. So, its his first anniversary with this project. Interested people can give his blog a read..

Blog da Docs

This section features the blog entries of the docs contributed by the topmost contributor(s) featured, in our weekly newsletter editions (#11, #14, #15, #16).

Aristides Villarreal Bravo
#11 | CVS and Localization

Hubert A. Klein Ikkink
#14, #15, #16 | Tips and Tricks, Hat-trick Hero

This edition was brought to you by;
Varun Nischal
___________________________________________________________
Available Languages: English , German, Spanish

Practical API Design - December 12, 2008 09:06 AM
2009: The Year of Annotations

As I noted recently, I see the year 2009 as the year of annotations. The NetBeans project is about to rely on them more heavily. Finally! We've been waiting for that for ages, but finally we can compile with JDK 1.6 JavaC and we can use compile time annotation processors. As a result we can replace our layer based registrations with annotations and benefit from compile type checking, code completion, from having the registrations in the same place as the code that is being registered, etc. Also we can offer our API users simple looking annotations and let associated annotation processors do more advanced and more effective processing. As a result the developers have simple API to deal with, while actual registration hidden behind can be as effective as possible, even at the cost of complexity, but without compromises to reliability (as the complexity is kept in the processing infrastructure, not exposed to API users).

The other project related to annotations that we are likely to incorporate during 2009 is our extended use of Annotations for Software Defect Detection. This is heavily based on the JSR 305, yet until it is stable we do not want to expose such unstable API to users of our stable APIs (more on that in Chapter 10, in section Beware of Using Other APIs). As such we are going to create our own annotations (still recognizable by FindBugs and co.). The hope is that our annotation will stay compatible even if the underlaying JSR 305 slightly changes. Please find our current patch and comment here or in the issue 137437.

Last project that deals with annotations is developed by our editor hints guru Jan Lahoda - its aim is to bring complex refactoring to masses! How? Why? We have observed that using @Deprecated annotation is good hint to help your API users recognize that some part of your API is obsolete and shall no longer be used, however that in no way helps users of your API with converting their code to new, non-deprecated style. We have a solution: Use Code Transformation Annotations! Dear [API] writers, let's adopt these annotations and use them in your API! They are completely standalone (read more), lightweight and we are ready to incorporate feedback of everyone interested in the project. Indeed, my plan is to bring these easy to use and flexible refactorings to NetBeans soon, hopefully for version 7.0.

So these are my three annotation related projects. I find them quite exciting and I cannot wait to see them being used. Annotations are here to simplify life of API users and developers. As soon as we have them, we will have full right to call the year 2009 the year of annotations!

Listen to our podcast or download it.

Name (required):

Comment:

--JaroslavTulach 09:06, 12 December 2008 (UTC)

NetBeans Community Docs Blog - December 10, 2008 01:18 AM
NBCD Weekly Newsletter #17 (Spanish)

Destacado de la Semana

Hoy, contamos con otro importante contribuyente, quién obtuvo el Community Recognition durante el NetBeans B'day Bash. Terminamos esta serie especial de blogs el Domingo, 7 de Diciembre.

Tom Wheeler
El ha sido por mucho tiempo colaborador de NetBeans Platform related Developer FAQs, observe algunas de las contribuciones en los últimos tiempos...



Últimos documentos

Trucos y Sugerencias

Kristian Rink

Dec 05 | NetBeans for Processing users

Diego E. Silva L.
Dec 03 | Cambiando el ícono a un JFrame

Andrew Harmel-Law
Dec 03 | Profiling Maven 2 Applications in Netbeans 6

Noticias Especiales

Nuevo Contribuidor..
Andrew Harmel-Law es el último contribuyente del Programa NetBeans Community Docs .

Archivos..
Restructuración de los documentos en sub-nivel en el wikis está casi completa. Pronto le daremos una guía sobre la forma de referirse a ellos para tener un acceso rápido /aleatorio a los documentos contribuidos por la comunidad.

Record Roto..
En el mes de Noviembre obtuvimos un gran conjunto de contribuciones. El tercer más exitoso mes en nuestro programa desde Julio, Agosto de este año.

Contribuyente Importante...
Acabamos de terminar una series de blogs sobre personas que tiene el Reconocimiento de la Comunidad...Gracias a Diego, Hubert, Prakan, Siegfried and Tom por sus contribuciones...

Dream Team Docs
Oct 2008
Aristides & Varun contribuyeron con tutoriales & trucos y sugerencias, respectivamente, en el mes de Octubre.

Esta edición se ha presentado a usted por;
Aristides Villarreal Bravo
___________________________________________________________
Available Languages: English , German, Spanish

NetBeans Community Docs Blog - November 25, 2008 04:00 PM
NBCD Weekly Newsletter #15 (Spanish)

Destacado de la Semana

Luis Enrique Funes

Actualmente, trabaja en una compañia dedicada a telecomunicaciones llamada R-Link. Me dedico generalmente al desarrollo de drivers de comunicaciones y visualizadores de AVL (tanto Web como de escritorio) para el hardware desarrollado en la compañia, y además estoy encargado de todo lo referente a SIG. Desarrollo principalmente en Java (usando NetBeans IDE) y PHP (uso particularmente el editor Notepad++, y en este momento estoy en plena migración a NetBeans).
Además, tenemos otro importante contribuyente, que obtuvo el Community Recognition durante NetBeans B'day Bash. Por lo tanto, permítase echarle un vistazo a él;

Hubert A. Klein Ikkink

Él ha sido por largo tiempo contribuyente de trucos y sugerencias, por lo que permita echar un vistazo a muchos de ellos que contribuyo recientemente...También, el acaba de romper el récord del máximo numero de contribuciones de documentos realizados por un miembro de la comunidad en un solo mes
NetBeans IDE 6.5 (Just Released)

Últimos documentos

Trucos y Sugerencias

Hubert A. Klein Ikkink
Nov 21 | Keyboard Shortcuts Reference Card in NetBeans

Nov 21 | Using NetBeans HTTP monitor with Jetty and Maven

Nov 16 | Check Java version in the About Box

Nov 16 | Use fix code to correct your code

Tutoriales

Filip Jirsák

Nov 20 | Usage of Spring and hibernate in NetBeans Platform application
Luis Enrique Funes
Nov 15 | Conociendo a NetBeans Platform: Introducción

Noticias Especiales


Nuevo Contribuyente..
Filip Jirsák es el último contribuyente del programa NetBeans Community Docs .

Desarrollo Simplificado..
NetBeans™ IDE 6.5 introduce varias características nuevas, incluyendo un robusto IDE para PHP, JavaScript, Depuración para Firefox e IE, y el soporte para Groovy y Grails.

Records Tumbling..

Esta es la primera vez, que alguien aparece en cada sección de las noticias semanal. Estamos orgullosos de anunciar,que Hubert A Klein Ikkink a roto el record del número máximo de contribuciones de documentos en un solo mes por un miembro de la comunidad. Previamente alcanzado por Varun Nischal, quien contribuyo con 8 documentos en un solo día en el mes de Junio.

Contribuidor Superior..
Hubert A. Klein Ikkink
T
Esta edición se ha presentado a usted por;
Aristides Villarreal Bravo
-----------------------------------------------------------------
Available Languages- English , German , Spanish

NetBeans Community Docs Blog - November 06, 2008 06:01 PM
NBCD Weekly Newsletter #12 (Spanish)

Destacado de la Semana

Esta vez no haremos ninguna pregunta,en su lugar mencionaremos a aquellos que han recibo recientemente el Reconocimiento de la Comunidad por sus contribuciones al programa NetBeans Community Docs.

Hay 5 miembros que se consideran importantes colaboradores. Para iniciar con esto, permita dar un vistazo a los siguientes colaboradores;


Prakan Puvibunsuk

El había recibido el spotlight, y fue recientemente reconocido como Colaborador Importante en nuestro proyecto de documentación (durante la Celebración del Cumpleaños de NetBeans ), también ha sido desde hace mucho tiempo colaborador de Screencasts!
Mes de Octubre- 15 Documentos Contribuidos..

Últimos Documentos

Artículos


Aristides Villarreal Bravo
Oct 29 | Proyecto WebSynergy

Consejos y Trucos

Hubert A. Klein Ikkink
Oct 30 | Show Maven Build Plan in NetBeans
George Birbilis
Oct 28 | Repairing NetBeans Support for Java Code after a JDK Reinstallation
Varun Nischal
Oct 28 | Configure Clusters And Modules

Oct 28 | Editor Windows Reactivated

Tutorial

Roger Searjeant

Oct 31 | Fixing Blank Dialog Box in NetBeans

Noticias Especiales



Dos Nuevos Contribuidores..
George Birbilis y Roger Searjeant, permitame darles una cálida bienvenida y usar sus documentos para ayudarles a ustedes y a otros también.!

Archivos..
Septiembre y Octubre las contribuciones han sido archivadas, así estas seguirán siendo visibles en la lista principal de contribución ,permanezca atento a las actualizaciones!


Contribuidor Superior..

Varun Nischal


Blog da Docs

Esta sección presenta las entradas en el blog de los documentos aportados por los contribuyentes superiores ,ofrecido en nuestro Boletín Semanal #10.

Diego E. Silva L. (Diego Silva)
01-02 | Look and Feel, plus Internationalization

Dream Team Docs
Agosto 2008 [Developer FAQs]
Tom contribuyo con algunas faqs para desarrolladores en el mes de Agosto. Gracias a ti suscribase a la siguiente serie de mini-blogs;

Esta edición se ha presentado a usted por;
Aristides Villarreal Bravo

Envie sus comentarios/sugerencias para mejorarlo..
Si desea suscribirse mediante email para el semanal-
hágalo ahora!
Muchas gracias!
___________________________________________________________
Available Languages: English , German , Spanish

NetBeans Community Docs Blog - October 31, 2008 06:49 AM
NBCD Weekly Newsletter #11 (Spanish)

Reconocimientos Finales

La celebración de los 10 años de NetBeans llega a su fin! y un hurra va dedicado a todas las personas destacadas que han participado en el proyecto de NetBeans , desde el inicio hasta hoy en día con sus esfuerzos. Queremos reconocer y agradecer a algunos de ellos.

Hay tantas personas que han ayudado al Proyecto NetBeans a través de este viaje, aunque no podemos dar las gracias a todos por su nombre, tienen nuestra máxima gratitud. Gracias por estos increibles diez años!!
Decathlon finalizado, Saludos de James Gosling, oficina de Praga, Brazil y finalmente, cerramos con las palabras de Jonathan Schwartz CEO de Sun.

Gracias por su
celebración del cumpleaños de NetBeans !



Últimos documentos


Artículos


Aristides Villarreal Bravo
Oct 27 | Usar CVS

Oct 24 | Como integrar sus archivos en NetBeans CVS
Diego Silva
Oct 24 | Instrucciones para trabajar la traducción de NetBeans 6.5 usando Subversion

Cómo

Varun Nischal

Oct 20 | Configure XAMPP with Database Explorer
Tutorial

Aristides Villarreal Bravo

Oct 20 | Plugins de Localizaciones

Noticias Especiales


Boletin de Noticias localizado ...
Weekly Newsletter Edition #10 fue liberado en Español también. Compruebe este blog para más actualizaciones sobre como tener acceso a boletines de noticias por email/feedreaders.

Otro Tutorial Destacado..
Después de una brecha de casi 2 meses, tengo otro tutorial que aparece en NetBeans Knowledge Base

Reconocimiento de la Comunidad ..
Como parte de las celebraciones de cumpleaños,el Programa NetBeans Community Docs consiguó el reconocimiento,y dio reconocimiento a nuestros héroes colaboradores, leer más...

Mayor Colaborador ..
Aristides Villarreal Bravo


Dream Team Docs
Aug 2008 [Tutoriales]
Aristides contribuyó parte de los tutoriales en el mes de Agosto. A continuación, puede ver el FAQs del Desarrollador!

Esta edición se ha presentado a usted por;
Aristides Villarreal Bravo

Envie sus comentarios/sugerencias para mejorarlo.
Si desea suscribirse mediante email para el semanal-
hágalo ahora!
Muchas gracias!
___________________________________________________________
Available Languages: English , German , Spanish

NetBeans Community Docs Blog - October 22, 2008 07:40 AM
NBCD Weekly Newsletter #10 (Spanish)

Celebración de Cumpleaños de NetBeans

Este es nuestra
edición 10 del boletín semanal, coincidentalmente nosotros celebramos el cumpleaños tambien esta semana.

Bienvenido a la Celebración de los 10 años de NetBeans! Unase a nosotros a celebrar con nuestra vibrante comunidad y reconocer a las personas y proyectos que han formado nuestro éxito.!
Participa en el Decatlón, siga las Actualizaciones Diarias,vea los saludos de James Gosling y la oficina en Praga y mucho más.

Es tiempo de Fiesta, únase a nosotros
y
celebre el cumpleaños de NetBeans!


Documentos más recientes

Sugerencias y Trucos


Diego Silva
Oct 17 Cambiando el Look And Feel

Oct 16 I18n con Visual JSF
Prakan Puvibunsuk
Oct 12 Using Embedded Derby in SAF [Screencast]

Noticias Especiales


Boletín de Noticias Localizado....
Edición de Boletín de noticias Semanal #9 en Alemán fue liberado.

sugerencias y trucos..
James Branam, Program Manager anunció "Convocatoria para contribuciones de consejos y trucos", seguido por un blog de localización sobre ello!

Colaborador Destacado..
Diego Silva


Blog de Documentos

Esta sección destaca las entradas de blog contribuidos por el colaborador más destacado , en la Edición del boletín semanal de Noticias #8, por Hubert A. Klein Ikkink.

Hubert A. Klein Ikkink
01-04 Cocoon, Maven with NetBeans


Documentos del Dream Team
Aug 2008 [Trucos y Sugerencias]
Alex, Tonny and Varun contribuyeron con parte de los trucos y sugerencias en el mes de Agosto. A continuación, puede ver Tutoriales, FAQs de Desarrolladores!

Esta edición le fue traída por;
Aristides Villarreal Bravo

Envie sus comentarios/sugerencias para mejorarlo.
Si desea suscribirse mediante email para el semanal-
hagalo ahora!
Muchas gracias!
___________________________________________________________
Lenguajes Disponibles: Ingles , Alemán , Español


Netbeans 6.1 beta - April 23, 2008 03:24 AM
Mi carta para los reyes magos

En estos días he estado haciendo mi carta para los reyes magos, se que falta mucho tiempo pero ya no puedo esperar más para ver mis regalos...

Queridos reyes magos, yo se que me he portado mal (muy mal :P) este año pero se que ustedes siempre comprenden que un niño como yo se emociona mucho con los regalos que le traen, prometo que si me traen mis regalos me portaré mucho mejor para el prox. año (siempre decía lo mismo :) )

Me gustaría que Netbeans 6.1 rc3 tenga las siguientes características.

1. Que el editor de java cuando escriba '<' , automáticamente ponga el cierre
... lo mismo que hace con los paréntesis.

2. Agregar ligas cuando se estan subiendo los archivos del svn/cvs/mercurial, que aparezcan subrayados los nombres de los archivos para poder ir a ellos.

3. Cuando le hago refactor a una propiedad, no le hace refactor a sus gets y sets.

4. Posibilidad de agregar o eliminar carpetas de un repositorio desde Netbeans.

5. Quisiera ver si le pudieran un poco de colorcito a los comentarios, seria interesante poner en cursiva los TODO, o cambiarlos a otro color para asi reconocerlos de los simples comentarios.

6. Soporte para jquery (me dijo santa clause que ya tienen soporte para prototype y eso es genial por que la sintaxis ${} es igual ... pero digo, jquery tiene mucha popularidad y todos los niños lo estan pidiendo ... que les cuesta darle soporte?)

7. Crear un plugin para jarfinder http://www.jarfinder.com/ para saber a que jar pertenece cierta clase (este lo hago yo en los proximos días para que digan que me porto bien)

8. Poner marcas del lado derecho a los comentarios con TODO, así como lo hacen como los bookmarks pero ahora con los TODO

9. Librerias con rutas relativas (oh, esto ya me lo trajeron el día de mi cumpleaños, gracias !)

10. Ahora que sus templates soportan freemarker, ¿sería mucho pedir un plugin decente? (me tuve que rebajar a pedirle prestados sus juguetes a mi vecinito juan ... sus papás le compraron el 'jboss tools freemarker ide').

11.No quiero ser grosero con ustedes pero está re gacha la interfaz para JUnit.

  • No se ve el avance de los test (en %)
  • La consola de junit no tiene la misma potencia que la consula por default(output), no se tienen ligas para ir hacia los errores
  • Es tedioso estar cambiando entre la pestaña de junit y la de output console.
  • No se puede buscar texto dentro de la consola de JUnit.
  • No se sabe cuanto tiempo tardan todos los test.

12. Cuando estoy en un editor de xml/html y creo una etiqueta de apertura, deberia crearse automáticamente la etiqueta de cierre como le pasa a mi vecinito juan con su IDE, ya he buscado como cambiar este comportamiento y parece ser que no se puede.

13. Con este regalo sí me muero de felicidad. Extender el editor gráfico de jsf para que sea capaz de soportar controles como richfaces, icefaces, tomahawk, sandbox, etc ... en lugar de solo estar atados a woodstock. Yo se que ustedes pueden, hace unos cuantos años me dieron la sorpresa con el editor matisse, ahi puedo agregar componentes de distintos componentes. No me extrañaría levantarme mañana y ver los controles colgados de la paleta.

14. Soporte para hibernate. Gracias benditos reyes magos

15. Soporte para spring. Prometo portarme bien pero no me lo quiten.

16. En el editor html pone lineas amarillas cuando un elemento es deprecated, estaría de lujo si el IDE dijera qué debo usar como nuevo elemento (' lo que debo usar en lugar del deprecated')... oh ya me enteré que las sugerencias en javascript te dicen sobre qué navegador correrá tu script ... ¡ Te luciste pinche gaspar ! (Ya se me solto la primer groseria, espero no lean esta parte :S).

17. A veces me pongo a jugar con mis proyectitos web y estan llenos de imágenes que ya no uso. ¿Me podrían avisar de alguna forma qué imáges del proyecto web no están siendo ocupadas?
¿Sería mucho pedir para los css/js y demás recursos externos ?

18. Mejorar el editor jsp, darle la misma potencia que el editor de código fuente java.

19. Soporte para jetty

20. Soporte para comentarios multilínea, esto quiere decir que cuando seleccione código fuente y presione [ctrl + c ] entonces comente de la forma /* */ y no de la forma //

21. Editor grafico para jsp y un atari.

22. Soporte para trac.

23. Mi plugin para facelets se quedo sin pilas, corría para netbeans 6.0.1 pero ha muerto en la version 6.1.

24. Hacer el IDE Online (oh, espero y no solo sean rumores y me lo traigan despues del 2009)

25. Soporte para Bugzilla

26. Por favor, cuando tenga un proyecto sobre un repositorio de versiones y elimine un paquete ... también eliminenlo de la estructura de directorios (ya que se queda el iconito del paquete vacío y por mas que lo borro no desaparece), evitenme el trabajo de ir a la pestaña Files y borrar manualmente la carpeta.

27. Al poner la primer comilla del atributo src de un tag html, mostrar un mensaje para elegir por medio de un dialogo nuestro recurso. Algo así como lo hace dreamweaver.

28. Mostrar por medio de alguna marca las ligas rotas hacia recursos inexistentes, por ejemplo si una etiqueta apunta hacia una imágen que no existe, el IDE lo podría notificar?

29. Refresh para los proyectos. En ocasiones no se actualiza el icono del proyecto, por ejemplo cuando tienes un error de compilación y se corrige ... el icono del proyecto (o del archivo) se queda con el error siendo que éste no existe. Para solucionar el problema tengo que cerrar y volver a abrir el proyecto :(

Pd. No olviden las pilas de mis juguetes

Netbeans 6.1 beta - April 22, 2008 02:45 AM
Todos estan invitados a la fiesta ... JQuery en NB6.1

Poco se ha hablado que la versión de Netbeans 6.1 tiene soporte para la sorprendente librería de javascript jquery. JQuery es una librería muy pequeña para desarrollar de forma simple y rápida javascript, además de que cuenta con una amplia gama de plugins para hacer casi cualquier cosa. En este tutorial hablaré del soporte con que cuenta NB61 para jquery y no tanto de la librería.

La nueva versión de netbeans cuenta con soporte para javascript, prototype y jquery.
Vamos a crear un proyecto web y a la par iremos viendo las características que aporta el IDE...



1. Crea un nuevo proyecto web


  • Menú File/New Project
  • Categories: Web
  • Projects: Web application
  • Next
  • Project Name: JQuerySupport
  • Click en Next








2. En la siguiente ventana deje los valores por default y de click en Next



3. Deje en blanco la lista de frameworks



4. Click en Finish

5. Descarga la libreria de jquery desde la página oficial

6. Agrega la librería a tu proyecto, para ello:
  • Crea un folder sobre la carpeta WebPages de tu proyecto (Click derecho sobre la carpeta Web Pages/New/Other/Categories: Other/File types: Folder
  • Folder name: js
  • Pegue la librería que descargó de jquery al nuevo folder js


Note que en la paleta de componentes se pueden ver todos los miembros de la librería:




7. Agregue la definición de la librería en el archivo index.jsp


8. Aquí viene lo interesante.
JQuery utiliza la sintaxis '$()' para crear a su vez un objeto de jquery (chainability), como se muestra en la siguiente imágen, el ide nos da sugerencias de qué objeto podría ir allí dentro, un resumen, sintaxis, parámetros y documentación. ¡ Realmente bueno !




9. Sugerencia de métodos: en el punto anterior comenté que la sentencia '$()' sirve para crear un objeto jquery. Como se puede ver en la siguiente imágen, el IDE nos da sugerencia de métodos.



10. El método ready de jquery sirve para ejecutar alguna instruccion cuando el documento esté listo, es similar al evento onload del body pero a diferencia de éste, se ejecuta cuando termina de construir el arbol dom (y no hasta que pinte todos los elementos de la página)
Agregue el siguiente script:

$(document).ready(function() {
alert("CARGADO");
});

11. Prueba jquery



Top 10 de las características más espectaculares de Netbeans 6.1 en el soporte para jquery.


1. Para cada elemento, nos sugiere la compatibilidad con navegadores ....


2. Coloreado de sintaxis:



3. La sugerencia en tiempo real de los elementos de la página:



4. No deje de admirar, agregue un div dentro del body, 'Sugerencia de los elementos hijo' ...


5. ¿ Sugerencia de atributos ? Si porfavor



6. Errores javascript en tiempo de desarrollo



7. Muestra posibles errores en el código fuente (warnings)



8. Acompletado de métodos javascript.



9. Ctrl + click ->Ir a la declaración del método


10. Go to type (ctrl + o)



¡ El único IDE que tu necesitas !

Netbeans 6.1 beta - April 22, 2008 02:38 AM
Envolviendo un pequeño obsequio


En este blog crearé un plugin para Netbeans 6.1 el cual ayudará a buscar el jar a partir del nombre de una clase. A mi parecer siempre ha hecho falta un plugin que haga esto, ¿cuántas veces no te has encontrado con un ClassDefNotFoundException o un NoClassDefFoundError por que no se encuentra presente un jar dentro del proyecto ?

El objetivo de este blog es crear un campo de texto en el toolbar del ide donde podrás anotar el nombre de tu clase y al presionar enter abrirá un browser con los posibles jar que la contienen.




Pasos

1. File/New Project/

  • [Categories]: Netbeans Modules,
  • [Projects]: Module
  • Click en next


2. Aparecerá una nueva ventana para indicar la ruta y nombre del proyecto.
  • Project name: JarFinderToolbar
  • Crea el proyecto como un standalone module ya que no será parte de una suite de módulos,
  • Click en Next.



3. Aparecerá la siguiente ventana en la cual deberás indicar el paquete de tu proyecto, así como el nombre que mostrará y la localización de los archivos de recursos...
  • Code Name Base: org.jarfindertoolbar
  • Module display name: JarFinder Toolbar
  • Localizing Bundle: org/jarfindertoolbar/Bundle.properties



4. Click en Finish
5. Ahora, crearemos el JPanel que contendrá el text field para la busqueda.
  • Da clic derecho sobre el proyecto
  • New
  • Other...


6. Elije la categoría Swing GUI Forms y en File Types: JPanel Form... click en Next


7. En el campo class name escribe JarFinderPanel y en package elige el que aparece en la lista, click en Finish.


8. Diseña tu JPanel similar al siguiente ...


9. Crea el evento key typed para el text field del diseño
  • Click derecho al textField/Events/Key/Key Typed.


10. Define el método keytyped del textfield como el siguiente:

private void jTextField1KeyTyped(java.awt.event.KeyEvent evt) {
int i = evt.getKeyChar();
if (i==10){//The ENTER KEY
// we display the jarfinder url.
try{
URLDisplayer.getDefault().showURL
(new URL("http://www.jarfinder.com/?class="+jTextField1.getText()+"&submit=search"));
} catch (Exception e){
return;
}
}
}

11. Has un reformat code (Alt+Shift+F)
12. Como netbeans trabaja por medio de módulos, deberás agregar una dependencia para la clase URLDisplayer.

13. Da click derecho a tu proyecto/Properties/Del lado izquierdo elige la categoría Libraries



14. Agrega la dependencia para la clase URLDisplayer


15. Has un fix all imports (ctrl + shift + i) y da clic en ok


16. Las librerías de tu proyecto deberán quedar con las de esta ventana.



17. Lo único que resta es agregar un acción para nuestro JPanel, para ello da click derecho a tu proyecto/New/Action...
  • Indica que siempre este disponible (Always enabled)/Click en Next
  • Aparecerá una pantalla donde deberás indicar en category: Edit
  • Desactivar el check Global Menu item
  • En la sección de Global Toolbar Button elegir Edit en toolbar y Redo-Here en position
  • Click en Next


18. En la siguiente ventana deberás indicar los datos para acción.
  • Class Name: JarFinderAction
  • Display Name: JarFinder Action
  • Icon: Debes elegir uno aunque no se vaya a mostrar
  • Click en Finish


19. Declara la siguiente variable dentro del archivo JarFinderAction.java
JarFinderPanel jarFinderPanel = new JarFinderPanel();

20. Sobreescribe el método getToolbarPresenter() y retorna la variable jarFinderPanel


21. Solo basta probar tu nuevo obsequio...
Clic derecho al proyecto
Install/Reload in Development IDE: Lo ejecuta sobre el ide en el que estes trabajando actualmente.



22. Escribimos una clase sobre nuestro plugin, por ejemplo: 'com.sun.tools.javac.code.Flags' ... damos enter

23. Precioso resultado, ahora sabemos en que jar podemos encontrar la clase


24. Lo único que hace falta es distribuir el módulo como plugin para que todos puedan usarlo.
  • Click derecho al proyecto
  • Create NBM
  • Ve a la pestaña Files
  • Carpeta build
  • Veras el archivo org-jarfindertoolbar.nbm
25. El plugin lo puedes descargar de la siguiente url




'Ahora tienes el obsequio, de ti depende si lo abres'

Netbeans 6.1 beta - April 21, 2008 06:56 PM
Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1

Este blog lo he creado con la intención de participar en el concurso Netbeans IDE 6.1 Beta blogging contest y aportar un granito de arena a la comunidad de desarrolladores de Netbeans hispanos.


Quiero inaugurar con el primer artículo de una serie llamada 'Corre más rápido que el viento y llega antes que nadie con Netbeans 6.1', la serie la estoy creado con la finalidad de que los usuarios de otros entornos se sientan atraidos por Netbeans 6.1 ya que hablo sobre un tema poco conocido. Cómo desarrollar aplicaciones de una forma increiblemente veloz desde Netbeans 6.1 es el tema central ya que ésta característica fué una de las decisivas para que yo migrara a la plataforma y terminara amandola.

¿Cuántos programadores se preocupan en medir el desempeño de sus aplicaciones en milisegundos (que mejor si lo haces desde netbeans profiler) ?
Para mi, la respuesta es pocos...

¿Cuántos programadores se preocupan en medir su rapidez escribiendo código fuente?
Para mi, la respuesta es casi nadie

¿Cuántas veces al día repites la sentencia 'System.out.println("")' para imprimir una variable en tu código fuente ?
¿ Cuántas veces al día escribes el tedioso for(int i=0; i < ...), cuantas veces recorres un iterator ?

¿ Cuántos milisengundos tardas en escribir código fuente ?


¿ Se podría considerar este tema como la pieza que hacia falta en el rompecabezas de la programación ágil ?

Code templates
Los code templates es una característica de Netbeans que sirve para insertar pedazos de código fuente por medio de abreviaciones.
Una de las características más importantes es que una vez insertados se pueden modificar de acuerdo a la declaración del code template.

Por ejemplo:
Existe un code template para crear nuevos objetos el cual se ejecuta con el comando [newo + tab]
Al tipear [newo + tab] se insertará:





Una vez insertado el code template, se puede modificar ya que el cursor queda sobre la palabra [Object], si al insertarlo tipea String se modificará de la siguiente forma:

String obj = new String();

Modificar los code templates
Usted puede modificar o crear nuevos code templates llendo a Tools/Options/[Code templates]


















Tenga en cuenta que no solo existen code templates para java, usted puede cambiar el lenguaje desde la lista etiquetada como languages:

Top 10 de los code templates:

1. Imprimir en pantalla [sout + tab]
/* Tipea [sout + tab] Resultado ... */
System.out.println("");

2. Imprimir una variable en pantalla [soutv + tab]
Busca hacia arriba la primer variable y la imprime.
Ejemplo:
int variableLargaDeTipoEntero = 9;
/* Tipea [soutv + tab] Resultado ... */
System.out.println("variableLargaDeTipoEntero = " + variableLargaDeTipoEntero);

3. Recorrer automaticamente un array [fori + tab]
Busca hacia arriba el primer array y lo recorre.
Ejemplo:



4. Recorrer automaticamente una lista por medio de su iterator [forc + tab]
Busca hacia arriba la primera coleccion y la recorre
List listaStrings = new ArrayList();
/* Tipea [forc + tab] Resultado ... */
for (Iterator it = listaStrings.iterator(); it.hasNext();) {
String string = it.next();
}

5. Recorrer automaticamente una lista por medio de foreach [fore + tab]
List listaStrings = new ArrayList();
/* Tipea [fore + tab] Resultado ... */
for (String string : listaStrings) {
}

6. Recorrer automaticamente una lista por medio de su indice [forl + tab]



7. Crear el método main [psvm + tab]
/* Tipea [psvm + tab] Resultado ... */
public static void main(String[] args) {
}

8. Poner la palabra reservada public [pu + tab]
/* Tipea [pu + tab] Resultado ... */
public

9. Poner la palabra reservada private [pr + tab]
/* Tipea [pr + tab] Resultado ... */
private

10.Poner la palabra reservada String [St + tab]
/* Tipea [St + tab] Resultado ... */
String

En este artículo traté el tema de code templates pero aquí no termina el aprendizaje de la programacion veloz en Netbeans 6.1, en próximos blogs mostraré cómo puedes crear tus propios code templates, utilizar macros, hints y shortcuts.

'Ahora me arrepiento por tanto tiempo perdido en la obscuridad de un eclipse'

Netbeans 6.1 beta - April 21, 2008 06:30 PM
La potencia de Netbeans 6.1 para soportar una librería ... commons-logging

La mayoría de los proyectos en producción no utilizan la sentencia System.out.println(""), en lugar de ello utilizan un sistema de trazas basado en Log4J, el log predefinido de java o un wrapper como lo es Commons logging.

En este artículo explicaré cómo configurar el sistema de trazas para Netbeans 6.1 y utilizarlo de una forma muy productiva.

Pasos a seguir
1. Crear los code templates para los mensajes de consola...

1.1 Ve al menú Tools/Options/Editor/[Code templates]/New/Abbreviation=logd



1.2 En Expanded Text introduce lo siguiente:
log.debug("${cursor}");



1.3 Crea un nuevo code template llamado logdv, éste lo usaremos para imprimir en pantalla en modo debug la primer variable que encuentre hacia arriba (similar a soutv pero con un sistema de trazas.)
--------------------------------------------------
Abbreviation: logdv
Expanded text: log.debug("${EXP instanceof="" default="exp"} = " + ${EXP});
--------------------------------------------------

El resultado será algo similar a lo siguiente:



1.4 Repite el mismo proceso para los siguientes code templates
Mensajes de warning: logw, logwv
Mensajes de info: logi, logiv
Mensajes de error: loge, logev
Mensajes de fatal: logf, logfv

El resultado debería ser similar al siguiente:



2. Para utilizar el sistema de trazas en una clase, se necesita una variable que tenga una referencia a la clase, por lo tanto es necesario crear un code template para insertar la variable log como miembro de las clases:

------------------------------
Abbreviation: logv
Expanded text:
private static final Log log = LogFactory.getLog(${clase}.class);
-----------------------------


Resultado:



No todo es miel sobre hojuelas, punto en contra para Netbeans:

El IDE tiene un code hint para envolver un método que lanza excepciones con un try y catch
Para probarlo declare un método que lance cualquier excepción y mandelo a llamar desde cualquier otro método.
Después tipe [alt + enter] y verá un foco en la parte izquierda sugiriendo envolver el método con un try/catch como muestra la imágen.



Al ejecutarlo nos da el siguiente resultado:



Como te puedes dar cuenta, el sistema de trazas que esta ocupando es el que tiene por defecto el JDK y no el de commons logging, intentemos personalizarlo llendo al menú Tools/Options/[Java Code]/[HInts]/Error Fixes/Sorround with try-catch


Desafortunadamente no hay forma de indicarle al IDE que utilice el sistema de trazas de commons logging o mínimo de log4j... ¡ lastima ! ya será para la próxima versión. Aún así podrías crear un code template o una macro ;)

Lo único que resta es instalar log4j y commons logging en un nuevo proyecto.
1. Crea un nuevo proyecto java con el nombre LoggingTest




2. Expande tu proyecto y sobre source packages click derecho/New/ Other.../




3. Ve a la categoría other y elige properties file


4. En File name pon log4j



5. Introduce el siguiente código en tu nuevo archivo log4j.properties:

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.rootLogger=debug, stdout

6. Descarga (log4j y commons-logging)

7. Click derecho al proyecto y Clean and build.

8. Prueba el resultado:




Ahora tienes un Netbeans 6.1 completamente armado para utilizar commons-logging como wrapper para cualquier sistema de trazas, costó un poco de trabajo pero a cambio de ello serás mucho más productivo y veloz a la hora de escribir código fuente.

'A partir de ahora tu camino en Netbeans 6.1 deja huella'

Netbeans 6.1 beta - April 21, 2008 08:28 AM
Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 2)

Una de las características por default que hacen falta a Netbeans 6.1 rc2 (hasta hoy) es la posibilidad de tener un code template que valide si un objeto es nulo.

Sería fantástico tipear por ejemplo [ifnn + tab] y que buscara el primer objeto hacia arriba e insertara el siguiente código:


Desafortunadamente no se cuenta con el code template por default, podriamos crear un code template para agregar la característica, pero para ilustrar un nuevo tema casi no documentado, haremos uso de las macros...



- Start Macro -
Las macros, otra de las características de Netbeans que permite un desarrollo más veloz.
Es cierto que no son una característica nueva de Netbeans 6.1 y existen desde versiones anteriores pero quiero hablar sobre este tema ya que casi nadie habla de ellas y es una pieza fundamental en el rompecabezas de una serie de artículos llamados 'Corre más rápido que el viento con Netbeans 6.1', los cuales he creado con la finalidad de que los usuarios de otros entornos se sientan interesados por Netbeans 6.1

Una macro es un conjunto de acciones que pueden ser grabadas para reproducirlas posteriormente.
Para iniciar la grabación de una macro vaya al menú Edit/Start macro recording
Para detener la grabación de una macro vaya al menú Edit/Stop macro recording

Pasos para crear una macro que valide si un objeto es nulo
1. De acuerdo a la imagen anterior, posicionate sobre la variable obj y seleccionala.
2. Inicia la grabación de la macro
3. tipea [ctrl + c]
4. tipea [fin]
5. tipea [enter]
6. tipea if ( [ctrl + v] ) { [enter]}
7. Deten la grabación de la macro
8. Aparece un dialogo para poner el nombre de la macro, llamemosle if-not-null
9. Aparecerá un dialogo similar al siguiente:

Al final de la grabación debería quedarte un Macro Code como este:
copy-to-clipboard caret-end-line insert-break "if (" paste-from-clipboard " != null" caret-forward " {" insert-break

10. Pon un shortcut para que se ejecute la macro, yo he puesto (ctrl + alt + N)

11. Prueba tu macro, posicionate sobre una variable y seleccionala ... tipea (ctrl + alt + N)







Resultado:









No mas validaciones manuales para saber si un objeto es nulo

Ahora que sabes como crear una macro para validar si un objeto es nulo, ya sabras que puedes crear cualquier tipo de macro para evitar las tareas repetitivas.

'Dime como hacerlo y lo haré paso a paso, dame alas y volaré.'

- Stop macro -

Netbeans 6.1 beta - April 21, 2008 08:27 AM
Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 3)

En esta ocasion hablare sobre los shortcuts osea los atajos del teclado que trae consigo el IDE para realizar las tareas mas comunes desde el teclado. Hablaremos especificamente de los shortcuts que trae consigo el editor y un top ten de los que más he utilizado.

Para modificar o agregar un shortcut, puedes ir al menú Tools/Options/[Key Map]

La lista etiquetada como profile sirve para cambiar el perfil de keymap, esto es muy útil para programadores que vienen de eclipse o de emacs, como ya saben todos los atajos fácilmente pueden cambiar el perfil y reutilizar los atajos que ya conocian.

Un par de reclamos ....

¿ Qué hay de los programadores que vienen de IntelliJ IDEA ?

¿ Qué hay de los que conocen los shortcuts en JBuilder y quieren migrar a Netbeans 6.1 ?

¿ Por qué se acordaron del viejo emacs y no de mi querido vi :'( ?
No todo esta perdido :), existe un plugin https://sourceforge.net/project/showfiles.php?group_id=3653 )


[Shortcuts Top 10]

1. Duplicar una línea [ctrl + shift + abajo], [ctrl + shift + arriba]
Tradicionalmente ¿ cómo pasas la línea superior a la línea actual ?

Cuando programaba con eclipse ...
Movimiento 1. Ir a la línea que quieres copiar
Movimiento 2. Apretaba [shift]
Movimiento 3. Apretaba [fin]
Movimiento 4. Apretaba [ctrl + c]
Movimiento 5. Apretaba [fin]
... empiezo a aburrirme :P
Movimiento 6. Apretaba [Enter]
Movimiento 7. Apretaba [ctrl + v]
... que bueno que termine, empezaba a darme dolor de dedos.
Movimiento 8. Frotar mis dedos

Ahora con Netbeans 6.1 ...
Movimiento 1. Ir a la línea que quieres copiar
Movimiento 2. Ctrl + Shift + abajo
Movimiento 3. Poner una carita de felicidad :)




2. Formatear el código fuente [alt + shift + f]
Para acomodar todo tu código fuente presiona [alt + shift + f], la característica más sobresaliente del reformat code de Netbeans 6.1 es la capacidad de eliminar los espacios en blanco que se encuentran a los costados de las sentencias. Por ejemplo si tienes espacios en blanco después de un System.out.println("");____,
al presionar [alt + shift + f] el IDE eliminara esos espacios por ti.

3. Fix all imports [ctrl + shift + i]
Fix all imports es una característica muy útil para reparar todos los imports que no se encuentran en el código fuente. Imagina que copias un trozo de código fuente de algun sitio pero no tienes a la mano los imports. Al presionar [ctrl + shift + i] aparecerá un dialogo para corregir todos los imports faltantes.



4. Insert code [alt + ins]
Esta nueva versión de Netbeans cuenta con una herramienta para crear constructores, sobreescribir métodos, agregar propiedaes, crear get/set de tus propiedades, crear el método hashCode(), equals() ...
Para mostrar el cuadro de diálogo presiona [alt + ins] y se feliz.



5. Seleccionar porciones de código, caminar[alt + shift + .], retroceder [alt + shift + ,]
En ocaciones es múy útil seleccionar el código fuente por porciones, imagina que necesitas seleccionar todo el for en el que estás trabajando pero es muy grande, lo que debes hacer es ir hacia arriba y buscar donde empieza el for, después ir abajo y buscar la llave de cierre del for.
Lo mismo sucede con los métodos, con los if, while, switch, etc.
Netbeans pone a tu disposición un shortcut para seleccionar porciones de código, si estas dentro de ese enorme for, solo tipea [alt + shift + .] y verás seleccionado todo el cuerpo del for, si lo vuelves a tipear verás seleccionado el for completo.

De esta forma puedes seleccionar mas y mas porciones de código hasta llegar a seleccionar todo el código fuente de tu clase.



6. Borrar la línea actual [ctrl + e]
Este es uno de mis preferidos, solo presiona [ctrl + e] y se borrará la línea en la que te encuentras actualmente

7. Agregar o eliminar comentarios [ctrl + shift + c]
Con Netbeans 6.1 tienes la posibilidad de comentar porciones de código fuente, lo único que debes hacer es posicionarte sobre la línea o seleccionar una porción de código fuente y tipear el comando [ctrl + shift + c], lo mismo debes hacer para descomentar.




8. Cerrar la ventana actual [ctrl + w]
Para cerrar la ventana actual, presione [ctrl + w]

9. Maximizar la ventana actual [shift + esc]
Existen varias formas de ampliar el área de trabajo, uno de los más útiles es con el shortcut [shift + esc], el cual maximiza la ventana actual.


Otra posibilidad es utilizando el modo fullscreen con [ctrl + alt + enter]

Y por último, puedes dar click derecho sobre la pestaña de la ventana de trabajo y elegir undock window lo cuál hará que la ventana salga del entorno como si de un programa distinto se tratara.



10. Cambiar de ventana [ctrl + tab]
Puedes cambiar entre ventanas con el simple comando [ctrl + tab]




'La luz es más rápida que el viento, pero si conoces los atajos del laberinto tu serás el primero ...'

Netbeans 6.1 beta - April 21, 2008 08:19 AM
Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 5)

La versión 6.1 de Netbeans cuenta con un editor mucho más mejorado que nunca, prueba de ello es el nuevo coloreado de sintaxis.
Gracias a este nuevo coloreado se puede distinguir entre variables estáticas (aparecen en cursiva), variables locales o variables a nivel de clase, atributos deprecated (los cuales aparecen subrayados).



Además de que cuenta con una interesante característica, si tienes un método con múltiples retornos y pones el puntero en el tipo de dato de retorno del método, puedes saber todas las sentencias de salida.




También puedes seleccionar una variable y conocer todas las coincidencias en tiempo real.



Lo mismo sucede con los métodos.




'Aprende a correr de noche, ilumina las salidas'

Netbeans 6.1 beta - April 21, 2008 08:15 AM
Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 6)

Este artículo va dedicado al archi ultra reconocido semicolon (;)

¿Cuántos lenguajes de programación han planteado la posibilidad de no repetir el símbolo (;) al final de casi todas las sentencias?
Esta característica no va a cambiar nunca en c, c++, java. Lo que sí puedes cambiar es tu IDE, Netbeans 6.1 cuenta con un poderoso editor de código que te hace la vida más fácil.

Para entender mejor esta característica, hablemos de la forma tradicional de insertar el semicolon al final de las sentencias:

1. Inserta una sentencia de código, por ejemplo
String s = " | "
2. Debes moverte hacia la derecha un par de casillas
3. Tipear ;

Lo veo simple, ¿cómo hacerlo más simple?

Ve al menú Tools/Options/[Key map]/Expande la carpeta other/Busca la acción Complete Line/

Por defecto el shortcut es [ctrl+semicolon] pero en nuestros teclados si queremos el ';' deberiamos presionar [ctrl + shift + ;], al tener [shift] dentro del shortcut cambia y por lo tanto no funciona. Consecuencia de esto los usuarios hispanos de netbeans por 'defecto' no podemos hacer uso de esta característica :(.
Para habilitarla solo cambia el shortcut de la acción, yo he puesto [ctrl + ñ]

Ahora que hemos cambiado el shortcut podemos hacer uso de él.
1. Inserta por ejemplo la siguiente instrucción.
String s = " | "
2. Tipea [ctrl + ñ], automaticamente se pondrá un ';' al final de la sentencia sin tener que recorrerte todo hasta la derecha.

Lo mismo puedes hacer para la acción "Complete Line and Create New Line", asignale el shortcut
[ctrl + shift + ñ], ahora aparte de agregar el ';' al final de la sentencia, se insertará un newline al final y empezaras en la siguiente línea.
Nota que esta característica no solo aplica a sentencias simples, en sentencias complicadas puede ser de gran ayuda...


class Nb61 {
public static void main(String[] args) {System.out.println("Duke in Netbeans 6.1 blogging contest");}
static{}
static{}
static{}
static{}
static{}
static{} ;;;
static{} ;;;;;
static{} ;;;;;;;
static{} ;;;;;;;;;
static{} ;;;;;;;;;;;
static{} ;;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;;;;;;;;;
static{} ;;;;;;;;;;;; ;;;;;;;;;;;;
static{} ;;;;;;;;;;;;;;;;;;;;;;;;;;
static{} ;;;;; ;;;;;;;;;;;;;;; ;;;
static{} ;;;; ;;;;;;;;;;;;;;; ;;;
static{} ;;; ;;;;;;;;;;;;;;;;; ;;;
static{} ;;;;;;;;;;;;;;;;;;;;;;; ;;;
static{} ;;;;;;;;;;;;;;;;;;;;;;; ;;;
static{} ;;;;;;;;;;;;;;;;;;;;;;; ;;;
static{} ;;;;;;;;;;;;;;;;;;; ;; ;;;
static{} ;; ;;;;;;;;;;;;; ;; ;;;
static{} ;; ;;;;;; ;;;; ;;;
static{} ;;; ;;
static{} ;;; ;;
static{} ;;; ;;;
static{} ;;; ;;
static{} ;;; ;;
static{} ;;; ;;;
static{} ;; ;;
static{} ;; ;;;
static{} ;; ;;
static{} ;; ;;
static{} ;;; ;;
static{} ;;; ;;
static{} ;; ;;;
static{} ;; ;;
static{} ; ;;
static{} ;; ;;
static{} ;;; ;;;
static{} ;;; ;;;;;;;; ;;;
static{} ;;; ;;;;;;;;;;;;;;; ;;
static{} ;; ;;;;; ;;;; ;;
static{} ;; ;;;; ;;; ;;
static{} ;; ;;;; ;;; ;;;
static{} ;; ;;; ;;; ;;
static{} ;; ;;;; ;;; ;;
static{} ;;;;;;;;; ;;; ;;
static{} ;;;; ;;;;;;;;;
static{} ;;;;;
static{}
static{}
static{}
}


'Duke ha aprendido a utilizar el semicolon en Netbeans 6.1, ahora corre más rápido que nunca... ya tiene tenis (;)-(;) y además compila'

Netbeans 6.1 beta - April 21, 2008 08:11 AM
Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 7)

Asignar el valor de retorno a una nueva variable

Desde las primeras versiones de Netbeans tuve la inquietud de los code templates, shortcuts, code hints y macros, una de las cosas que me decepcionaba es que el editor no tenia forma de generar el código para cachar el retorno de un método dentro de una variable.
Me explico con un ejemplo, imagina el siguiente método:

public static int metodoRegresaEntero() { return 1;}

Ahora imagina que dentro del método main mandas a llamar al método metodoRegresaEntero();
public static void main(String args[]) {
metodoRegresaEntero();
}

Siempre busqué una forma para que el editor hiciera lo siguiente:
public static void main(String args[]) {
int i = metodoRegresaEntero();
}

Mi sueño se ha hecho realidad con Netbeans 6.1 y me siento en las nubes, ahora lo puedes hacer de una forma muy simple...

public static void main(String args[]) {

/* Tipea [alt + enter] y aparecerá un pequeño foco del lado izquierdo, elige assign return value to new variable y por arte de magia el editor inferirá el tipo de dato de retorno y lo pondrá por ti*/

int metodoRegresaEntero = metodoRegresaEntero();
}

El editor es capaz de inferir los datos hasta de generics, presta atención a la siguente imágen en la cual toda la parte subrayada fué generada automaticamente por el editor siguiendo los pasos descritos anteriormente:




'Debes voltear atrás para conocer a tu oponente'

Netbeans 6.1 beta - April 21, 2008 08:09 AM
Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 8)

Crea tus propios code templates.

Netbeans 6.1 cuenta con code templates para recorrer una lista, un iterador, un iterador con un while, poner un try catch, throws, public, private, String, static, if ... y un largo etc, pero no cuenta con un code template para recorrer el entry set de un mapa.
Después de un rato de trabajo he creado el siguiente code template:

1. Vaya al menú tools/Options/click en New/Abbreviation=mape

2. En expanded text introduzca lo siguiente:

for (${TYPE rightSideType default="Map.Entry"} ${ELEM newVarName default="entry"} : ${MAP mapeable instanceof="java.util.Map" default="entrySet"}.entrySet()) {
${TYPES rightSideType default="Object"} ${KEY newVarName default="key"} = ${TYPE_CAST cast default="" editable=false}${ELEM}.getKey();
${TYPES rightSideType default="Object"} ${VALUE newVarName default="value"} = ${TYPE_CAST cast default="" editable=false}${ELEM}.getValue();
${selection}${cursor}
}

3. Introduzca la siguiente instrucción:



En un artículo anterior creamos una macro que validaba si un objeto era nulo, ahora vamos a crear el code template para validar si un objeto es nulo, sigue los pasos anteriores y pon en abbreviation: ifnn y en expanded text:
if (${EXP instanceof="Object"} != null) { ${selection}${cursor} }

Prueba tu nuevo code template:



'Dame la llave y yo elijo la puerta'

Netbeans 6.1 beta - April 21, 2008 04:12 AM
Corre mas rápido que el viento y llega antes que nadie con Netbeans 6.1 (Parte 4)

Desde la versión 6 tienes la posibilidad de reemplazar las variables de tu código fuente y ver los cambios en tiempo real, para conseguir este comportamiento posicionate sobre una variable de la clase, tipea [ctrl + r] y escribe ... verás el cambio 'al aire'.





'correr más rápido que el viento implica conocer los elementos en el aire'.

Programación Web y Tecnologías Informáticas - March 13, 2008 05:08 AM
Java Server Pages: Directiva include

Esta directiva nos permite incluir ficheros en el momento en que la página JSP es traducida a un servlet. La directiva se parece a esto:

<%@ include file="cabecera.html" %>
La URL especificada normalmente se interpreta como relativa a la página JSP a la que se refiere, pero, al igual que las URLs relativas en general, podemos decirle al sistema que interpreta la URL relativa al directorio home del servidor Web empezando la URL con una barra invertida. Los contenidos del fichero incluido son analizados como texto normal JSP, y así pueden incluir HTML estático, elementos de script, directivas y acciones. Por ejemplo, muchas sites incluyen una pequeña barra de navegación en cada página. Debido a los problemas con los marcos HTML, esto normalmente se implementa mediante una pequeña tabla que cruza la parte superior de la página o el lado izquierdo, con el HTML repetido para cada página de la site. La directiva include es una forma natural de hacer esto, ahorrando a los desarroladores el mantenimiento engorroso de copiar realmente el HTML en cada fichero separado. Aquí tenemos un código representativo:
<HTML> <HEAD> <TITLE>Ejemplo del uso de la directiva include en JSP</TITLE> </HEAD> <BODY> <%@ include file="/navbar.html" %> <!-- Contenido de la página --> </BODY> </HTML>
Es importante tener presente que como la directiva include inserta los ficheros en el momento en que la página es traducida, si la página incluida cambia, necesitamos re-traducir todas las páginas JSP que la refieren. Esto es un buen compromiso en una situación como esta, ya que esto generalmente se utiliza en las páginas de un sitio que no cambian frecuentemente, y queremos que el proceso de inclusión sea tan eficiente como sea posible. Si los ficheros incluidos cambian de forma más frecuente, podríamos usar la acción jsp:include en su lugar. Esto incluye el fichero en el momento en que se solicita la página JSP.

Programación Web y Tecnologías Informáticas - March 12, 2008 05:03 AM
Java Server Pages: Directiva taglib

Indica al contenedor JSP que la página va a utilizar "tag libraries" o librerías de etiquetas. Estas librerías contienen etiquetas creadas por el propio programador con sus correspondientes atributos que encapsulan determinada funcionalidad. Lo habitual es utilizar librerías públicas que han diseñado otros programadores y han sido profundamente probadas. La sintaxis de esta directiva tiene dos atributos. El contenido del atributo uri permite localizar el fichero descriptor de la librería de extensión tld. El atributo prefix especifica el identificador que todas las etiquetas de la librería deben incorporar. Es una directiva muy interesante que facilita y complementa la programación habitual de las páginas JSP. Las taglibs son simplemente un cambio de interfaz con respecto al código Java normal; te ahorran insertar código dentro de las páginas, y son, en general, más fáciles de mantener, porque, en el más puro estilo OO, encapsulan su lógica y el que las usa no tiene que preocuparse por cómo hacen lo que hacen, sólo por acceder a ellas. Desarrollar sitios web utilizando etiquetas presenta ciertas ventajas como: • Facilitar el aprendizaje. • Facilitar el mantenimiento. • Fomentar la modularidad y la reutilización. • Simplificar el código y reducir el número de líneas necesarias. Su sintaxis es como se muestra en el ejemplo siguiente:

<%@ taglib uri="/taglib/lycka" prefix="lycka" %> <!-- ( ... ) --> <lycka:hola/> <!-- ( ... ) -->
A la hora de generar el código Java de la Servlet, esta etiqueta hola será interpretada por el Servidor como perteneciente a la librería de etiquetas (Tag Library) lycka. Esta librería estará identificada en el fichero descriptor de nuestra aplicación (web.xml) con el nombre de recurso (URI) /taglib/lycka de la siguiente forma:
<taglib-uri>/taglib/lycka</taglib-uri> <taglib-location>/WEB-INF/tags/lycka.tld</taglib-location>
Para profundizar sobre el tema de la directiva taglib le recomiendo este archivo PDF con una descripción más detallada y con algunos ejemplos prácticos.

Programación Web y Tecnologías Informáticas - March 11, 2008 03:23 PM
Tecnologías del lado del cliente: Applet

Un applet es un componente de una aplicación que se ejecuta en el contexto de otro programa, por ejemplo un navegador web. El applet debe ejecutarse en un contenedor, que lo proporciona un programa anfitrión, mediante un plugin, o en aplicaciones como teléfonos móviles que soportan el modelo de programación por applets. A diferencia de un programa, un applet no puede ejecutarse de manera independiente, ofrece información gráfica y a veces interactúa con el usuario, típicamente carece de sesión y tiene privilegios de seguridad restringidos. Un applet normalmente lleva a cabo una función muy específica que carece de uso independiente. Cuando un Navegador carga una página Web que contiene un Applet, este se descarga en el navegador Web y comienza a ejecutarse esto nos permite crear programas que cualquier usuario puede ejecutar con tan solo cargar la página Web en su navegador. Ejemplos comunes de applets son las Java applets y las animaciones Flash. Otro ejemplo es el Windows Media Player utilizado para desplegar archivos de video incrustados en los navegadores como el Internet Explorer. Otros plugins permiten mostrar modelos 3D que funcionan con un applet. Applet de Java Un Java applet es un código Java que carece de un método main, por eso se utiliza principalmente para el trabajo de páginas web, ya que es un subprograma o pequeño programa que es utilizado en una página HTML y representado por una pequeña pantalla gráfica dentro de ésta. Por otra parte, la diferencia entre una aplicación Java y un applet radica en cómo se ejecutan. Para cargar una aplicación Java se utiliza el intérprete de Java. En cambio, un applet se puede cargar y ejecutar desde cualquier explorador que soporte Java (Nescape, Internet Explorer de Windows, Mozilla Firefox, etc.). Entre sus características podemos mencionar un esquema de seguridad que permite que los applets que se ejecutan en el equipo no tengan acceso a partes sensibles, por ejemplo no pueden escribir archivos, a menos que uno mismo le dé los permisos necesarios en el sistema; la desventaja de este enfoque es que la entrega de permisos es engorrosa para el usuario común, lo cual juega en contra de uno de los objetivos de los Java applets: proporcionar una forma fácil de ejecutar aplicaciones desde el navegador web. Ventajas de los applet de Java • Funcionan en Linux, Windows y Mac OS, son multiplataforma • El mismo applet pueden trabajar en "todas" las versiones de Java, y no sólo la última versión del plug-in. Sin embargo, si un applet requiere una versión posterior de la JRE, el cliente se verá obligado a esperar durante la gran descarga. • Es soportado por la mayoría de los navegadores Web • Puede ser almacenado en la memoria cache de la mayoría de los navegadores Web, de modo que se cargará rápidamente cuando se vuelva a cargar la página Web, aunque puede quedar atascado en la caché, causando problemas cuando se liberan nuevas versiones. • Puede tener acceso completo a la máquina en la que se está ejecutando, si el usuario lo permite • Puede ejecutarse con velocidades comparables (pero en general más lento) a la de otros lenguajes compilados, como C + +, pero muchas veces más rápida que la de JavaScript • Puede trasladar el trabajo del servidor al cliente, haciendo una solución Web más escalable tomando en cuenta el número de usuarios / clientes Desventajas de los applet de Java • Requiere el plug-in de Java, que no está disponible por defecto en todos los navegadores web. • Sun no ha creado una implementación del plug-in para los procesadores de 64 bits • No puede iniciar la ejecución hasta que la Máquina virtual de Java está en funcionamiento, y esto puede tomar tiempo la primera vez que se ejecuta un applet. • Si no esta firmado como confiable, tiene un acceso limitado al sistema del usuario - en particular no tiene acceso directo al disco duro del cliente o al portapapeles. • Algunas organizaciones sólo permiten la instalación de software a los administradores. Como resultado, muchos usuarios (sin privilegios para instalar el plug-in en su navegador) no pueden ver los applets. • Un Applet podría exigir una versión específica del JRE. Cómo crear un applet de java Para crear un applet necesitamos escribir una clase que herede de la clase Applet del paquete java.applet.*;

import java.applet.*; public class MiApplet extends Applet { //Cuerpo del ''applet''. }
El código anterior declara una nueva clase MiApplet que hereda todas las capacidades de la clase Applet de Java. El resultado es un fichero MiApplet.java. Una vez creada la clase que compone el applet, escribimos el resto del código y después lo compilamos, obteniendo el fichero MiApplet.class. Para poder crear el applet se necesita compilar el código Java en un intérprete.
import java.applet.*; import java.awt.*; import java.util.*; import java.text.DateFormat; public class MiApplet extends Applet implements Runnable { private Thread hilo = null; private Font fuente; private String horaActual = "00:00:00"; public void init() { fuente = new Font("Verdana", Font.BOLD, 24); } public void start() { if (hilo == null) { hilo = new Thread(this, "Reloj"); hilo.start(); } } public void run() { Thread hiloActual = Thread.currentThread(); while (hilo == hiloActual) { //obtener la hora actual Calendar cal = Calendar.getInstance(); Date hora = cal.getTime(); DateFormat df = DateFormat.getTimeInstance(); horaActual = df.format(hora); repaint(); try { Thread.sleep(1000); } catch (InterruptedException e){} } } public void paint(Graphics g) { //Dibujar un rectangulo alrededor del contenedor g.draw3DRect(1, 1, getSize().width-3, getSize().height-3, false); //Establecer la Fuente g.setFont(fuente); //mostrar la Hora g.drawString(horaActual,14,40); } public void stop() { hilo = null; } }
Finalmente, para ejecutar el applet hay que crear una página Web que haga referencia al mismo. La etiqueta HTML que permite hacer eso es <applet>:
<html> <applet code="MiApplet.class" width="370" height="270"> </applet> </html>
Los parámetros "MiApplet.class", "370" y "270" correspondientes a la ubicación del archivo que contiene la clase, el ancho y el alto del applet, se pueden modificar.

Programación Web y Tecnologías Informáticas - March 11, 2008 03:21 PM
Tecnologías del lado del cliente: Java Virtual Machine Plugin

Una Máquina virtual Java (en inglés Java Virtual Machine, JVM) es un programa nativo, es decir, ejecutable en una plataforma específica, capaz de interpretar y ejecutar instrucciones expresadas en un código binario especial (el Java bytecode), el cual es generado por el compilador del lenguaje Java. El código binario de Java no es un lenguaje de alto nivel, sino un verdadero código máquina de bajo nivel, viable incluso como lenguaje de entrada para un microprocesador físico. Como todas las piezas del rompecabezas Java, fue desarrollado originalmente por Sun Microsystems. La JVM es una de las piezas fundamentales de la plataforma Java. Básicamente se sitúa en un nivel superior al Hardware del sistema sobre el que se pretende ejecutar la aplicación, y este actúa como un puente que entiende tanto el bytecode, como el sistema sobre el que se pretende ejecutar. Así, cuando se escribe una aplicación Java, se hace pensando que será ejecutada en una máquina virtual Java en concreto, siendo ésta la que en última instancia convierte de código bytecode a código nativo del dispositivo final. La gran ventaja de la máquina virtual java es aportar portabilidad al lenguaje de manera que desde Sun Microsystems se han creado diferentes máquinas virtuales java para diferentes arquitecturas y así un programa .class escrito en un Windows puede ser interpretado en un entorno Linux. Tan solo es necesario disponer de dicha máquina virtual para dichos entornos. De ahí el famoso axioma que sigue a Java, "escríbelo una vez, ejecútalo en cualquier parte", o "Write once, run anywhere". La máquina virtual de Java puede estar implementada en software, hardware, una herramienta de desarrollo o un Web browser; lee y ejecuta código precompilado bytecode que es independiente de la plataforma multiplataforma. La JVM provee definiciones para un conjunto de instrucciones, un conjunto de registros, un formato para archivos de clases, la pila, un heap con recolector de basura y un área de memoria. Cualquier implementación de la JVM que sea aprobada por SUN debe ser capaz de ejecutar cualquier clase que cumpla con la especificación. Existen varias versiones, en orden cronológico, de la máquina virtual de Java. En general la definición del Java bytecode no cambia significativamente entre versiones, y si lo hacen, los desarrolladores del lenguaje procuran que exista compatibilidad hacia atrás con los productos anteriores. En un sentido amplio, la Máquina Virtual de Java actúa como un puente entre el resultado de la compilación (el bytecode) y el sistema sobre el que se ejecuta la aplicación. Para cada dispositivo debe haber una JVM específica, ya sea un teléfono móvil, un PC con Windows XP, o un microondas. En cualquier caso, cada máquina virtual conoce el conjunto de instrucciones de la plataforma destino, y traduce un código escrito en lenguaje Java (común para todas) al código nativo que es capaz de entender el Hardware de la plataforma. Una arquitectura de maquina virtual permite un control granular fino sobre las acciones que el código puede hacer dentro de la máquina. Esto está diseñado para permitir ejecución segura de código no confiable desde fuentes remotas, un modelo usado muy famoso son las Java applets. Applets se ejecutan dentro de una VM incorporada en el navegador del usuario, ejecutando código descargado desde un servidor HTTP remoto. El código remoto se ejecuta en un entorno cerrado y altamente restringido, llamado también sandbox, el cual está diseñado para proteger al usuario de código erróneo o malicioso. Los Publicadores con recursos financieros suficientes pueden conseguir un certificado con el cual hacer applets con firma digital que las caractericen como seguras ("safe"), dándoles entonces permisos para salir de la sandbox y acceder al sistema de ficheros local y sistema de red, presumiblemente bajo el control del usuario.

Programación Web y Tecnologías Informáticas - March 11, 2008 03:14 PM
Java Server Pages: Directiva page

Esta directiva da instrucciones al motor que procesa las páginas JSP; estas instrucciones se aplican a todo el fichero fuente. Utilizando esta directiva se podría especificar un comentario informativo que formará parte del fichero JSP compilado, el lenguaje de script usado en el fichero fuente JSP, los paquetes de ficheros fuentes que serán importados, o la página de error que se llamará si ocurren errores o excepciones, entre otros aspectos. Podemos usar la directiva page en cualquier lugar del fichero JSP, pero es muy recomendable situarlo en la parte superior del fichero. Como es una etiqueta JSP, podemos situarla antes de la etiqueta de apertura <html>. Un ejemplo de uso de esta directiva es el siguiente:

<%@ page language='java' contentType="text/html" info='Mi primera página en JSP" import='java.util.*' errorPage='paginadeerror.jsp' %>
A continuación detallamos todos los parámetros que se pueden definir utilizando la directiva page, con un ejemplo en cada caso.

Atributo

Sintaxis

Utilización

import

<%@ page import="java.utils.*" %>

Importa clases y paquetes Java para ser utilizadas dentro del fichero JSP.

session

<%@ page session="false" %>

Especifica si utiliza los datos contenidos en sesión; por defecto "true".

contentType

<%@ page contentType="class; class" %>

Especifica el tipo MIME del objeto "response"; por defecto "text/html; charset=ISO-8859-1".

buffer

<%@ page buffer="12KB" %>

Buffer utilizado por el objeto writer "out"; puede tomar el valor de "none"; por defecto "8KB".

errorPage

<%@ page errorPage="/error_page.jsp" %>

Especifíca la ruta de la página de error que será invocada en caso de producirse una excepción durante la ejecución de este fichero JSP.

isThreadSafe

<%@ page isThreadSafe="false" %>

Un valor de true (por defecto) indica un procesamiento del servlet normal, donde múltiples peticiones pueden procesarse simultáneamente con un sólo ejemplar del servlet, bajo la suposición que del autor sincroniza las variables de ejemplar. Un valor de false indica que el servlet debería implementar SingleThreadModel, con peticiones enviadas serialmente o con peticiones simultáneas siendo entregadas por ejemplares separados del servelt.

autoflush

<%@ page autoflush="true" %>

Un valor de true (por defecto) indica que el buffer debería descargase cuando esté lleno. Un valor de false, raramente utilizado, indica que se debe lanzar una excepción cuando el buffer se sobrecargue. Un valor de false es ilegal cuando usamos buffer="none".

extends

<%@ page extends="package.class" %>

Esto indica la superclase del servlet que se va a generar. Debemos usarla con extrema precaución, ya que el servidor podría utilizar una superclase personalizada.

info

<%@ page info="Mi página JSP" %>

Define un string que puede usarse para ser recuperado mediante el método getServletInfo.

language

<%@ page language="java" %>

En algunos momentos, esto está pensado para especificar el lenguaje a utilizar. Por ahora, no debemos preocuparnos por él ya que java es tanto el valor por defecto como la única opción legal.

isErrorPage

<%@ page isErrorPage="true" %>

Determina si este fichero JSP es una página que maneja excepciones. Únicamente a este tipo de páginas pueden acceder a la variable implícita "exception", que contiene la excepción que provocó la llamada a la página de error.

Programación Web y Tecnologías Informáticas - March 11, 2008 03:13 PM
Java Server Pages: Directivas

Java Server PagesLas directivas en las Java Server Pages son órdenes que se ejecutan antes de que se comience a procesar el archivo JSP y modifican de alguna forma el resultado del mismo. Todas las directivas en JSP se indican con una arroba (@) después del comienzo de la orden JSP (<%). La sintaxis de una directiva es como se muestra en el ejemplo siguiente:

<%@ directiva atributo="valor" %>
Es importante destacar que los atributos de estas directivas son sensibles a las mayúsculas. En los post siguientes abordaremos las características más importantes de las directivas page, taglib e inlude.