Download Framework desarrollo Eclipse

http://glugcen.dc.uba.ar/pipermail/glug/2006-October/000875.html
Framework desarrollo Eclipse
Cuando se está desarrollando software siempre se buscan editores de código que nos faciliten la
vida. Qué se compile de una forma rápida, que el entorno sea amigable y lo más sencillo posible de
utilizar y que no te tengas que tirar "dos días" para poderlo utilizar.
A veces no se le da importancia a las herramientas de desarrollo, pero cuando se está desarrollando
en un proyecto son una pieza clave para la calidad y la productividad del proyecto.
En este tutorial os enseñamos como funciona el entorno de desarrollo Eclipse, donde vamos a poder
ver algunas de las alternativas que presenta. Una de las principales características que tiene, a
parte de basarse en la licencia Common Public License Version 1.0 ("CPL"), es que es totalmente
extensible, te puedes hacer tus propios plug-ins (un plug-in es un desarrollo a parte de la plataforma
de eclipse que aportan una determinada funcionalidad) o utilizar los que ya están desarrollados.
Eclipse es una estructura (workbench) que puede soportar distintas herramientas de desarrollo y
para cualquier lenguaje.
Os recomiendo que visitéis la siguiente página http://www.eclipseplugins.info/eclipse/index.jsp donde podéis encontrar multitud de plug-ins para eclipse.
Para ver los plug-ins que tenemos instalado podemos ir a la siguiente pantalla:
Desde el menú Help-> About Eclipse Platform
Si pulsamos el botón "Plug-in Details".
A continuación mostramos las principales características del JDT (Java Development Tooling) que
es lo que aporta realmente la capacidad de desarrollo a la plataforma para java y añade las
funcionalidades del IDE. Vale la pena mencionar también el plugin de desarrollo para C/C++ el CDT.
El entorno de desarrollo Eclipse (también sus plugins) está desarrollado completamente en java,
pero se base en la librería de widgets SWT que es equivalente a Swing pero se aprovechan los
widgets nativos del sistema sobre el que se ejecuta, esto permite que la ejecución de interfaces de
usuario sea mucho más rápida que si se utiliza Swing. Otra característica del SWT es que el "Look &
Feel" es del sistema y no hace falta emularlo.
Las características principales del IDE son las siguientes:















Permite trabajar con varios proyectos a la vez
El editor de código tiene colores para la sintaxis y también lo que es conocido como "code
highlighting".
Los errores de compilación a parte de darte una descripción de error te indica donde se ha
producido el error en los márgenes
Formateador de código.
Permite encontrar código duplicado.
Tiene lo que se conoce como "code folding".
Permite personalizar el entorno.
El editor tiene intellisense
Cuando estás escribiendo te permite terminar de completar el código.
Puedes ver el javadoc del api del jdk que se esté utilizando en ese momento.
Refactorización del código.
El editor permite buscar y reemplazar palabras.
Integración con aplicaciones controladoras de versión como por ejemplo CVS.
Permite compara archivos.
Mantiene una historia local de los archivos de la que se pueden restaurar.




En la compilación a parte de la generación de las classes (*.class) permite una compilación
incremental.
Permite el uso de herramientas externas como es ANT o JUNIT.
Para el debug de los programas es compatible con JPDA.
Permite codificar código java, c/c++, xml, jsp, html, etc.
I.
II. Instalación de eclipse
Los requerimientos necesarios es tener instalado el JDK 1.3 o superior y preferiblemente tener 256
MB de memoria y si es más pues mejor.
Lo primero que tenemos que hacer es bajarnos el software correspondiente
de http://www.eclipse.org. De todas formas os recomiendo este sitio para la descarga del
software http://gul.uc3m.es/eclipse/downloads/
Eclipse puede funcionar en Windows, Linux, Solaris, etc..
Descomprimimos el fichero eclipse-SDK-3.0-win32.zip que nos acabamos de bajar en el
directorio c:\eclipse al que llamamos eclipse_home. Nosotros hemos optado por trabajar con la
última versión de eclipse 3.0.
Para arrancar la plataforma eclipse basta con ejecutar eclipse.exe que se encuentra dentro
eclipse_home.
III. Creación de un proyecto en eclipse
Desde el menú Window -> Open perspective -> Java
Empezamos con el wizard de creación de un proyecto desde el menú File -> New -> Project o bien
pulsando sobre el botón que se ve en la imagen.
En la primera pantalla del wizard ponemos un nombre al proyecto y decidimos donde se guardará,
por defecto se crea una carpeta con el nombre del proyecto dentro de eclipse_home en el directorio
workspace.
Pulsamos "Next" para ir a la pantalla de configuración del classpath, del directorio donde se
guardarán las clases generadas, si el proyecto que estamos creando depende de algún otro, etc.
Una vez que se ha configurado el proyecto pulsamos "Finish" para terminarlo de crear.
IV. Integración de Eclipse con Tomcat
Tenemos que tener ya instalado el servidor Tomcat. La instalación la podéis seguir en uno de
nuestros artículos.
Lo primero que tenemos que hacer es instalarnos un plug-ins de tomcat para eclipse, como yo estoy
utilizando la versión 3.0 de eclipse he optado por utilizar el plug-in de sysdeo. De momento está en
la versión beta para poder trabajar con eclipse 3.0. Lo descargamos.
Y lo descomprimimos dentro del directorio plug-ins. Cerramos y volvemos a abrir el entorno eclipse y
podemos observar que nos aparece una entrada en el menú de Tomcat, y los iconos
correspondientes a Tomcat como se puede ver en la siguiente pantalla:
Para configurar el servidor Tomcat con el que trabajaremos, nos vamos al menú Window ->
Preferences, podemos observar como nos aparece una entrada para Tomcat, la seleccionamos y
podemos escoger la versión del servidor, y donde tenemos instalado el servidor Tomcat.
Podemos indicar a Tomcat que se reinicie en modo debug, escoger el classpath, etc..
Una vez que ya está configurado Tomcat, podemos crear un proyecto nuevo para utilizarlo.
Desde el menú New -> Project, escogemos Tomcat Project como podemos ver en la siguiente
figura.
Seguimos el wizard de creación del proyecto como hemos visto anteriormente, y nos pregunta por el
nombre del contexto.
Y nos crea la estructura necesaria y actualiza el fichero server.xml de tomcat.
V. Eclipse y J2EE
Existen varios plugins para utilizar J2EE dentro de eclipse nosotros hemos escogido Lomboz porque
a parte de ser gratuito cumple perfetamente con el desarrollo de aplicaciones J2EE.
Nos los podemos descargar de http://forge.objectweb.org/projects/lomboz
Lo descomprimimos dentro de eclipse_home\plugins. Nos vamos al directorio
eclipse_home\plugins\com.objectlearn.jdt.j2ee_3.0.1\servers y vemos que contiene ficheros de
configuración de varios servidores:
Escogemos el fichero para el servidor de aplicaciones que estemos utilizando, en esta caso vamos a
utilizar el fichero tomcat50x.server y el resto los renombramos a .bak para que no molesten. El
fichero de configuración quedaría de la siguiente forma:
<serverDefinition
name="Apache Tomcat v5.0.x"
ejbModules="true"
webModules="true"
earModules="false">
<property id="serverRootDirectory"
label="Application Server Directory:"
type="directory"
default="C:\java\Tomcat 5.0" />
<property id="serverAddress"
label="Address:"
type="string"
default="127.0.0.1" />
<property id="serverPort"
label="Port:"
type="string"
default="8080" />
<property id="classPathVariableName"
label="Classpath Variable Name:"
type="string"
default="TOMCAT_HOME" />
<property id="classPath"
label="Classpath Variable:"
type="directory"
default="C:/nmd/dev/java/appservers/jakarta-tomcat-5.0.16" />
<serverHome>${serverRootDirectory}</serverHome>
<webModulesDeployDirectory>${serverRootDirectory}/webapps</webModulesDeplo
yDirectory>
<ejbModulesDeployDirectory>NOTSUPPORTED</ejbModulesDeployDirectory>
<earModulesDeployDirectory>NOTSUPPORTED</earModulesDeployDirectory>
<jndiInitialContextFactory>NOTSUPPORTED</jndiInitialContextFactory>
<jndiProviderUrl>NOTSUPPORTED</jndiProviderUrl>
<startClass>org.apache.catalina.startup.Bootstrap</startClass>
<startWorkingDirectory>${serverRootDirectory}/bin</startWorkingDirectory>
<startVmParameters>-DJAVA_HOME="${jrePath}" Dcatalina.base="${serverRootDirectory}" -Dcatalina.home="${serverRootDirectory}"
-Djava.io.tmpdir="${serverRootDirectory}/temp" Djava.endorsed.dirs="${serverRootDirectory}/bin;${serverRootDirectory}/common/en
dorsed"</startVmParameters>
<startProgramArguments>start</startProgramArguments>
<stopClass>org.apache.catalina.startup.Bootstrap</stopClass>
<stopWorkingDirectory>${serverRootDirectory}/bin</stopWorkingDirectory>
<stopVmParameters>-DJAVA_HOME="${jrePath}" Dcatalina.base="${serverRootDirectory}" -Dcatalina.home="${serverRootDirectory}"
-Djava.io.tmpdir="${serverRootDirectory}/temp" Djava.endorsed.dirs="${serverRootDirectory}/bin;${serverRootDirectory}/common/en
dorsed"</stopVmParameters>
<stopProgramArguments>stop</stopProgramArguments>
<serverClassPath>
<jar type="variable">JDK_TOOLS</jar>
<jar type="variable">${classPathVariableName}/bin/bootstrap.jar</jar>
</serverClassPath>
<clientClassPath>
</clientClassPath>
<projectClassPath>
<jar type="variable">JDK_TOOLS</jar>
<jar type="variable">${classPathVariableName}/bin/bootstrap.jar</jar>
<jar type="variable">${classPathVariableName}/common/lib/servlet-api.jar</jar>
<jar type="variable">${classPathVariableName}/common/lib/jsp-api.jar</jar>
</projectClassPath>
</serverDefinition>
Nos vamos a Windows -> Customize Perspective y nos seleccionamos Lomboz J2EE Wizards.
Ahora si nos vamos al menú File -> New, podemos comprobar como nos aparecen las entradas
para utilizar Lomboz en proyectos J2EE.
Para crear un proyecto J2EE nos vamos al menú File -> New -> Project y seleccionamos Lomboz
J2EE Project
Escogemos el nombre para el proyecto.
Seleccionamos las librerias que van a ser necesarias para el proyecto y la ruta donde vamos a dejar
las clases generadas y pulsamos Next.
Nos aparece la pantalla para crear un módulo J2EE.
Con la pestaña seleccionada de Web Modules pulsamos el botón Add... e introducimos el nombre
del modulo web.
Si nuestro proyecto utiliza EJBs desde la pestaña EJB Modules escogeríamos los nombres de los
EJBs.
Y en la pestaña Targeted Servers escogemos el servidor sobre el que vamos a trabajar, en nuestro
caso Tomcat 5.0 y pulsamos sobre el botón Add.. para añadirlo y luego finalmente sobre el botón
Finish para finalizar de crear el proyecto.
Y vemos el resultado.
VI. Integración de Eclipse y CVS
CVS (Concurrent Versions System) es uno de los controladores de versiones open source más
famoso, ya viene integrado con Eclipse, no hace falta instalar ningún plugin adicional.
Se puede empezar utilizando CVS de dos formas:


Creando un repositorio nuevo
Compartiendo el proyecto y utilizar un repositorio ya existente.
Para crear un nuevo repositorio nos situamos en la perspectiva CVS Repositories
Con el botón derecho escogemos 'New -> Repository Location...' donde seleccionamos el servidor,
la ruta, etc.
Y para compartir un proyecto abrimos la perspectiva java y con el botón derecho seleccionamos
'Team -> Share Project...' y seleccionamos el repositorio que queramos dejar el código.
Damos a continuar y terminamos el wizard. Podemos ver como en la pantalla anterior también
podemos crear un nuevo repositorio.
VII. Eclipse y JUnit
Desde eclipse se pueden crear y ejecutar pruebas unitarias utilizando el framework JUnit, podéis
encontrar nuestro tutorial aquí.
Últimamente se ha hablado mucho de eXtreme Programming y una de las cosas que destaca esta
metodología es el desarrollo dirigido por test. Primero se hace el desarrollo para las pruebas luego
se hace el desarrollo del código que pasen las pruebas y así sucesivamente, pero no nos tenemos
que olvidar que esto requiere un desarrollo adicional con lo que puede aumentar el coste del
proyecto.
Nos descargamos el framework JUnit y lo descomprimimos en un directorio.
Dentro del entorno de Eclipse sobre el menú File -> New -> Project escogemos Java Project y
pulsamos Next.
Escogemos el nombre del proyecto y damos a continuar. En la siguiente pantalla incluimos la librería
junit.jar a nustro proyecto.
Para poder trabajar con JUnit desde el menú nos vamos a Window -> Customize Perspective y
dentro de Java seleccionamos JUnit como podemos ver en la siguiente pantalla:
Ahora nos vamos a New -> JUnit Test Case
Seleccionamos el checkbox de "public static void main (String[] args)" y pulsamos a "Finish".
Y esta es la clase que genera
import junit.framework.TestCase;
/*
* Created on Jul 27, 2004
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
/**
* @author Isaac Gutiérrez
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class PrimeraClaseTest extends TestCase {
/**
* Constructor for PrimeraClaseTest.
* @param arg0
*/
public PrimeraClaseTest(String arg0) {
super(arg0);
}
public static void main(String[] args) {
}
}
Una vez que se ha codificado la funcionalidad para probar el test nos tenemos que ir a Run -> Run
as -> JUnit Test como vemos en la siguiente pantalla:
De esta forma vemos si lo que estamos probando funciona o no.
VIII. Conclusiones
En este tutorial se ha visto como funciona el entorno de desarrollo Eclipse. Es cierto que no nos
debemos encerrar en una herramienta y centrarnos más en la tecnología que estamos utilizando,
pero es fundamental cuando se están desarrollando proyectos utilizar una herramienta de desarrollo,
que conozcan todos los desarrolladores, esto hará que aumente la productividad ya que si es un
entorno de desarrollo como Eclipse viene con wizards que te ayudan en la codificación, tiene
detectores de errores que hace que el código desarrollado sea de mayor calidad o permite
compartir código entre un grupo de desarrolladores. También tiene la ventaja de integrar varios
productos en un único entorno que para la gente que está empezando es mucho más sencillo de
utilizar. Todo esto hace que los tiempos de desarrollo sean menores y por consiguiente los costes
también.
Si os estáis planteando empezar a desarrollar un nuevo proyecto pensar en utilizar una herramienta
de desarrollo, y si ya estáis utilizando una herramienta de desarrollo preguntaros si es la que debéis
utilizar.