Framework desarrollo eclipse

1
92178

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 https://marketplace.eclipse.org/
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.

 

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.

 

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.

 

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-inde 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.

 

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</webModulesDeployDirectory>
<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/endorsed»</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/endorsed»</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.

 

 

 

 

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.

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.

 

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.

1 Comentario

  1. Mil gracias por el tuto me ha sido de mucha ayuda, espero escrivir alguno que tambien sirva a la comunidad, para devolver un poco de lo que me dan!

Dejar respuesta

Please enter your comment!
Please enter your name here