Tutorial Inicial Maven SVN Eclipse 2 -...

Tutorial Inicial Maven / SVN / Eclipse

Versión 1.0 Agosto 2008

Por: Pablo Tesone

Nicolás Di Benedetto Demian Renzulli

Nicolás Passerini

Técnicas Avanzadas de Programación Tutorial Inicial de Maven – Versión 1.0

Página 2 de 26

Introducción Este documento está orientado a los alumnos que cursan la materia Técnicas Avanzadas de

Programación de la UTN – FRBA. Su objetivo es presentar varias herramientas de soporte comúnmente utilizadas en los proyectos de desarrollo de software

El tutorial intenta que la utilización de estas herramientas sea más sencillo para la gente que

cursa TADP, sin embargo su utilidad no está limitada a los alumnos de la cátedra. Las herramientas que vamos a comentar son: l SVN l Maven l Eclipse l Tomcat

Recomendamos estas dos lecturas complementarias: Java Para Programadores Objetosos Tutorial - Creación de Proyectos En Eclipse El objetivo del tutorial es producir un entregable, más precisamente un proyecto de desarrollo

Java alojado en un servidor SVN. Para el ejemplo utilizaremos el servidor de SVN público en Assembla.

Sólo para los alumnos – Instrucciones para la entrega del TP El uso de estas herramientas es obligatorio para el desarrollo y correcta entrega de los diferentes

Trabajos Prácticos que iremos desarrollando a lo largo de la cursada (consulten los detalles con el ayudante responsable de su grupo de TP).

Cada entrega formal del Trabajo Práctico debe hacerse a través de un TAG en el repositorio SVN en Assembla donde pueda acceder el usuario de la cátedra.

La entrega se realiza enviando un mail al ayudante que tengan asignado informando solamente Nombre, Apellido, Legajo, Grupo y dirección donde se encuentra el TAG desde donde se puede hacer checkout del proyecto.

A lo largo del tutorial se aclaran los distintos puntos que permitan entender mejor el requerimiento.


Página 3 de 26

¿Qué es Maven? Antes de comenzar a ver cómo se usa esto de Maven1 vamos a tratar de explicar sintéticamente

qué es y para qué sirve. También vamos a entender por qué creemos que es importante su uso, tanto durante la cátedra como en nuestra actividad profesional.

Maven es una herramienta que permite la gestión del ciclo de desarrollo de un proyecto. Está

pensado para seguir un ciclo de vida dividido en una serie de fases. En cada una de las fases se realizan distintas operaciones sobre los fuentes y entregables.

Está pensado desde el punto de vista del desarrollador, por lo tanto no esperen gestión de

documentos de diseño, pero sí manejo de tests, reportes y armado de paquetes ejecutables. Es un producto que se encuentra desarrollado en Java y para Java, está pensado con una

arquitectura orientada a plugins, de esta manera todas las operaciones se terminan delegando en distintos plugins. Esto facilita la expansión de la herramienta y su capacidad de adaptarse a distintos proyectos.

Un punto a favor es que se centra la definición del proyecto, y su correspondiente proceso de

desarrollo, de forma declarativa; indicando qué es lo que se tiene que hacer y no cómo se tiene que hacer. Esto lo diferencia de productos como Ant donde debemos detallar el cómo de cada una de las operaciones. Esto lo realiza a través de un archivo que describe al proyecto (pom.xml: Project Object Model).

Algunos de los beneficios que podemos remarcar son: l Facilita el proceso de desarrollo l Provee una forma uniforme de desarrollo entre distintos usuarios y plataformas. l Provee mecanismos para generar información y reportes sobre la calidad del software

generado. l Fomenta el uso de buenas prácticas de desarrollo. l Permite realizar TDD de forma simple e integrada con el proceso de desarrollo. l Se basa en “separation of concerns” o “separación de incumbencias”. l Pregona la “convention over configuration” o “convención por sobre configuración”.

Ø Puede que parte de las razones que enunciamos no se entiendan en este momento, confiamos en que van a ir cerrando mejor cuando vayamos viendo los diferentes temas de la materia.

1 http://maven.apache.org/

http://maven.apache.org/


Página 4 de 26

¿Qué es SVN? SVN o mejor dicho Subversion es un sistema de control de versiones o SCM (Administrador de

Configuración de Software), permite la integración y el trabajo de un grupo de personas distribuido y concurrente. Además de sincronizar y distribuir versiones de archivos, permite el manejo de versiones de los mismos.

Esto nos facilita la forma de trabajo y nos permite que múltiples personas interactúen sobre los

mismos archivos, por supuesto con cierto cuidado. Trabaja manteniendo una copia local (working copy) donde el usuario actúa sobre los archivos

como si fueran archivos comunes, y una copia de los mismos en el servidor. En el servidor se mantienen todas las versiones, permitiendo en cualquier momento volver a cualquiera de ellas. Las versiones se aplican a nivel de archivo, o sea puedo traerme la versión ‘x’ de un archivo y la ‘x±n’ de otro.

El usuario trabaja sobre su ‘working copy’, generando cambios sobre archivos, creando nuevos

o borrándolos. Una vez que considera que tiene cambios que quiere propagar a todo el equipo hace un ‘commit’, que implica el impactar los cambios de sus archivos en el servidor generando una nueva versión (revisión) del mismo.

Cuándo hacer commit (o commitear en spanglish) va a depender de cómo trabaja cada grupo.

Se considera políticamente correcto no commitear co una frecuencia tan alta que rompa todo el proyecto, pero tampoco es políticamente correcto commitear cada 6 meses ya que es más que probable que se modifiquen los mismos archivos por varios usuarios, varias veces en el interín.

En caso de que se modifique el mismo archivo por dos usuarios distintos, el svn trata de hacer

un ‘merge’ (integrar o fusionar los archivos) pero si no puede porque tocaron las mismas líneas o parecidas va a generar un conflicto que se debe resolver a mano.

Existen clientes y servidores de Subversion para distintas plataformas, todas pueden interactuar

entre sí. Básicamente para este tutorial se van a mostrar los comandos de consola necesarios, pero es posible usar clientes visuales como TortoiseSVN (para Windows) o RapidSVN (para Linux). TortoiseSVN tiene el beneficio de integrarse con el explorador de archivos, permitiendo hacer las operaciones con un click del botón derecho.

Además de los clientes ‘standalone’ existen plugins para integrar SVN con los IDE más

utilizados, no solo de Java, sino de casi cualquier cosa. Subversion: http://subversion.tigris.org/ TortoiseSVN: http://tortoisesvn.net/ Subclipse (plugin de Eclipse): http://subclipse.tigris.org/

http://subversion.tigris.org/

http://tortoisesvn.net/

http://subclipse.tigris.org/


Página 5 de 26

Creación de un repositorio en Assembla

Para la gestión del TP cuatrimestral vamos a utilizar un SVN gratuito, el mismo se llama Assembla (www.assembla.com) y provee herramientas para el seguimiento de proyectos; entre las herramientas que provee vamos a utilizar el svn y el issue tracker.

Es importante que cada alumno tenga una cuenta en assembla, para que se puedan identificar las

operaciones que haga cada uno dentro del repositorio, esto no es por un tema de control nuestro sino para que ustedes aprendan cómo se trabaja en grupo. La cátedra va a solicitar que cada alumno comunique su usuario de assembla para poder efectuar seguimientos.

Para este tutorial vamos a crear un repositorio para cada uno, una vez que tenemos la cuenta en

assembla procedemos a crear un nuevo repositorio. Desde la página inicial de nuestro usuario accedemos a Manage spaces.

Una vez allí creamos un nuevo espacio con el nombre Tutorial y el nombre de la url con el

formato apellido_tp.

Es importante que marquen en Setup this space for: Software Developers (integrated). Todas las otras opciones por default son válidas y le pueden dar ‘siguiente’ a todas. Es

importante que en este punto inviten a los miembros del equipo que van a trabajar con el repositorio

http://www.assembla.com


Página 6 de 26

Ø Si sos alumno de TADP no te olvides de invitar al usuario de la cátedra para que podamos corregir el TP.

Continuamos con el wizard hasta que creamos el repositorio.

Ahora se puede entrar al sitio del repositorio. Es importante que tengan habilitado SVN/Trac (se van a dar cuenta porque les aparece una pestaña que dice SVN/Trac), si no está habilitado pueden habilitarlo en la pestaña Admin de la página del Space.


Página 7 de 26

Una vez que está habilitado el acceso por SVN, haciendo click en la pestaña SVN/Trac, se

puede ver la dirección url del SVN, en este caso es:

http://svn.assembla.com/svn/tadp_tutorial Con esta dirección vamos a interactuar con el svn. A partir de ahora podemos instalar el cliente de SVN que queramos.

http://svn.assembla.com/svn/tadp_tutorial


Página 8 de 26

Instalación de Maven La instalación de Maven puede parecer una tarea complicada, por la cantidad de cosas que hay

que hacer pero no es imposible, y si son ordenados y siguen todos los pasos no van a tener problemas.

1. Bajar e instalar la JDK de Java: la misma se puede bajar de http://java.sun.com/javase/downloads/index.jsp

2. Definir la variable de entorno2 JAVA_HOME: esta variable tiene que apuntar al directorio donde instalaron Java, el raíz donde esta la JDK. Por ejemplo en Windows podría ser “C:\Archivos de Programa\Java\JDK1.6.0_02”.

3. Bajar la distribución de Maven: Se puede bajar los ejecutables desde http://maven.apache.org/download.html

4. Descomprimir Maven en algún lado: pueden descomprimir Maven en cualquier lado... solo recuerden donde ya que desde ahí va a ejecutar.

5. Definir la variable de entorno M2_HOME: esta variable tiene que contener la ruta al directorio de instalación de Maven.

6. Agregar a la variable PATH los binarios: tienen que agregar %JAVA_HOME%\bin y %M2_HOME%\bin en Windows; y $JAVA_HOME/bin y $M2_HOME/bin en los Unix-like.

7. (Opcional) Agregar la variable de entorno que indica dónde se constituirá el repositorio local: tienen que indicar dónde se almacenarán las dependencias descargadas y los entregables generados por Maven. Si se omite esta variable (M2_REPO) el valor asumido es %HOME%/.m2 en Windows y ~usuario/.m2 en Un*x.

Nota: para la correcta utilización de Maven se recomienda tener una conexión a internet levantada, ya que continuamente se están bajando Plugins, Jar y archivos pom. Esto puede parecer molesto, pero en realidad es una gran ventaja ya que permite que sea altamente extensible y automatiza el acceso a todos los recursos necesarios.

Existe una forma de operar ‘Offline’ que consiste en indicar la opción ‘–o’ (sin las comillas) a la línea de comandos de maven, pero en ese caso maven se limitará a emplear el repositorio local para la compilación de proyectos y eso implica que se debe contar con todas las dependencias -tanto las directas como las transitivas- de antemano, cosa que rara vez sucede.

2 Ver Anexo de seteo de variables de entorno.

http://java.sun.com/javase/downloads/index.jsp

http://maven.apache.org/download.html


Página 9 de 26

Instalación de Eclipse Este paso lo pueden cambiar por la IDE que más les guste. Para poder instalar Eclipse es necesario bajarlo de Internet, se encuentra en

http://www.eclipse.org/downloads/. Es importante que se bajen la versión para Java EE Developers Para realizar la instalación se deberá descomprimir el paquete en donde va a quedar

instalado. Si se instaló correctamente la JDK al hacer doble click debería abrir el Eclipse. Para poder integrar mucho mejor SVN, Maven y Eclipse es recomendable que instalen

alguno de los siguientes plugins:

l Subclipse: http://subclipse.tigris.org/ l m2eclipse: http://m2eclipse.sonatype.org/

http://www.eclipse.org/downloads/

http://subclipse.tigris.org/

http://m2eclipse.sonatype.org/


Página 10 de 26

Instalación de Plugins

Los plugins dentro de nuestro IDE extienden su funcionalidad y nos ayudan automatizando los procesos repetitivos en nuestras tareas de desarrollo. En particular, m2eclipse, nos facilita la integración con Maven.

En este tutorial haremos uso de una de sus funcionalidades básicas, el asistente en la importación de proyectos Maven, sin embargo puede también emplearse en otras, como la descarga automática de dependencias y actualizaciones, la creación de proyectos con Maven Archetypes, y la integración con otros componentes, como Subclipse.

Antes de la instalación debemos asegurarnos de estar utilizando la versión de Eclipse 3.2 o superior. A continuación tendremos que chequear si en nuestro entorno de desarrollo tenemos configurada la JDK que descargamos en pasos previos.

Para esto, en nuestro menú de Eclipse seleccionamos Window->Preferences ->Java->Installed JRes. Nos encontraremos en un menú como el que se muestra a continuación:

En caso de no tener una referencia a la JDK, agregamos la ruta al directorio de instalación mediante Add y la tildamos.

Una vez cumplidos los requisitos previos pasaremos a la instalación del plugin propiamente dicho y de las dependencias necesarias.

Tener en cuenta que en caso de estar utilizando la versión 3.4 de Eclipse (Ganymede), la


Página 11 de 26

instalación de dependencias se simplifica notablemente, por lo que puede no ser necesario llevar a cabo el procedimiento de instalación de dependencias en forma manual.

El proceso básico de instalación de cualquier plugin desde dentro de Eclipse responde a una serie de pasos:

• Dentro del menú de Eclipse seleccionamos Help->Software Updates-> Find and Install.

• Seleccionamos Search for new Features to Install.

• Luego tendremos que seleccionar el sitio del cual descargar el plugin en cuestión, para lo cual elegimos New Remote Site

• Finalmente colocamos el nombre del plugin y la Url Nuestro panel de sitios de descargas se irá completando con las direcciones registradas:

Para proceder a la descarga tildamos los sitios que deseemos, damos click en finalizar y en el nuevo diálogo elegimos qué componentes deseamos instalar.

Tener en cuenta que en caso de encontrarse utilizando el IDE desde una máquina conectada a un Proxy http será necesario configurar el mismo para permitir la descarga de los complementos.

Para ello, desde la ventana de preferencias vamos a General->Network Connections y


Página 12 de 26

completamos los datos del proxy en cuestión. M2eclipse interactúa con otros cuatro plugins, por lo que para utilizar la funcionalidad completa del mismo deberán tenerse en cuenta las siguientes dependencias, de las cuales, las dos primeras son requeridas, y las últimas dos opcionales:

Plugin Name URL Descripción

Subclipse Subclipse 1.4.x

http://subclipse.tigris.org/update_1.4.x

Interfaz para utilizar subversion desde dentro del Eclipse.

Mylyn Mylyn 3.3 / 3.4 http://download.eclipse.org/tools/mylyn/update/e3.3 http://download.eclipse.org/tools/mylyn/update/e3.4

Permite simplificar la presentación de la información en tareas compartidas.

AJDT AJDT 3.3 / 3.4 http://download.eclipse.org/tools/ajdt/33/dev/update http://download.eclipse.org/tools/ajdt/34/dev/update

Soporte para aspectos en Java (AspectJ)

WTP WTP http://download.eclipse.org/webtools/updates/ Extensión para aplicaciones Java EE y Web.

Una vez instaladas las dependencias necesarias podemos proceder a la instalación de m2eclipse

repitiendo el procedimiento general mencionado para la descarga de plugins. Finalmente cargaremos la ruta a nuestro directorio de instalación de Maven en la solapa Maven

de la ventana de preferencias:

http://subclipse.tigris.org/update_1.4.x

http://download.eclipse.org/tools/mylyn/up

http://download.eclipse.org/tools/mylyn/up

http://download.eclipse.org/tools/ajdt/33/d

http://download.eclipse.org/tools/ajdt/34/d

http://download.eclipse.org/webtools/updates/


Página 13 de 26

En la opción de Installations completaremos la ruta en donde se encuentra el archivo settings.xml. habitualmente %M2_HOME%\conf\settings.xml, y de esta forma habremos finalizado la integración del entorno con Maven.

Obtención del Proyecto desde el SVN

Para poder comenzar a trabajar es necesario obtener el proyecto desde el SVN, para eso vamos a hacer un checkout, podemos hacerlo a través del Tortoise o desde la línea de comando; aquí es donde tenemos que usar la dirección del repositorio, el usuario y la password de assembla.

Si lo hacemos desde la línea de comando nos tenemos que parar en el directorio donde vamos a poner el proyecto, y ejecutamos:

svn checkout http://svn.assembla.com/svn/tadp_tutorial --username tadp El formato del comando es

svn checkout [url repositorio] –-username [usuario]

Esto nos va a generar un directorio llamado, en este caso, “tadp_tutorial”, el mismo tiene la metadata necesaria para funcionar como working copy.

http://svn.assembla.com/svn/tadp_tutorial


Página 14 de 26

Creación de un proyecto con Maven

Para la creación del proyecto vamos a utilizar una de las facilidades de Maven, la capacidad de crear estructura de proyectos comunes. Esto permite que ejecutando un plugin se genere la estructura típica del tipo de proyecto.

Este concepto previamente dicho se llama Archetype, y permite crear los proyectos con la configuración correcta.

En este ejemplo vamos a crear un proyecto para una aplicación web. Antes que nada vamos a hablar un poco sobre la forma que utiliza Maven para identificar los

artefactos que puede gestionar o utilizar, ya que nos permite que integremos nuestros proyectos con otros existentes, nuestros o no, dentro del repositorio. Por supuesto que para acceder a publicar artefactos en los repositorios públicos existen procedimientos administrativos para garantizar su calidad. Pero el mismo funcionamiento se da en nuestro repositorio local.

Este momento es el indicado para decir que Maven genera un repositorio local donde guarda las

versiones que obtiene desde el repositorio central (que reside en Internet) y las versiones que nosotros vamos generando. Por ejemplo si nosotros tuviéramos más de un proyecto en Maven, este mantiene todas sus versiones. Esto garantiza la integridad de los “releases” permitiendo que 2 proyectos trabajen con una misma dependencia pero en distintas versiones (e.g., Dos proyectos dependen de hibernate, pero uno utiliza la versión 2.1 y el otro la 3.0.3)

Una de las ventajas que tiene Maven es la resolución de dependencias, o sea me resuelve el problema de tener que estar buscando los Jar necesarios para usar este o aquel framework, y lo resuelve transitivamente. Es decir, si A depende de B y B a su vez depende de C, y mi proyecto depende de A, al generar el entregable maven se encargará de incluirme tanto A como B y C. Por otro lado si además C dependiera de A, maven resolvería el ciclo produciendo el mismo resultado que antes (A, B y C).

Volviendo al tema, la identificación de los artefactos se realiza a través de tres valores:

GroupId: identificativo del grupo / empresa que desarrollo el artefacto, por ejemplo puede ser:

org.apache.tomcat, org.hibernate, ar.edu.utn.frba.tadp, etc. Siguen la misma nomenclatura de los paquetes JAVA.

Ø En TADP vamos a utilizar ar.edu.utn.frba.tadp.CCCC.grupoXX, donde XX es el numero de grupo y CCCC la identificación de tu curso.


Página 15 de 26

ArtifactId: es el identificador de cualquier entregable producido por maven. Por ejemplo hibernate, digester, tadp_tutorial. En TADP vamos a utilizar el nombre del TP que será comentado en cada caso.

Version: es la versión del artefacto. Por ejemplo 3.21-ga, 0.1.1-SNAPSHOT. Este campo es

opcional y en caso de omitirse maven intentará utilizar la última versión disponible en sus repositorios. Esto puede ser una buena idea para los plug-ins, pero no para las dependencias, porque justamente estaríamos violando uno de de los beneficios que mencionamos de maven, que era justamente la integridad en la liberación del entregable (“release”).

La identificación univoca de los artefactos se realiza a través de la integración de los tres valores. En Tadp vamos a utilizar 1.0-SNAPSHOT

Ejemplos de nombres completos son:

GroupId ArtifactId Version org.hibernate hibernate 3.2.6.ga org.apache.maven.surefire surefire 2.4.3

Una vez que aclaramos esto vamos a crear la aplicación, para eso vamos a ejecutar este comando (todo en una misma línea).

mvn archetype:create -DgroupId=ar.utn.tadp -DartifactId=tutorial -

DarchetypeArtifactId=maven-archetype-webapp Ahora vamos a analizar este comando en partes,

Operador Descripción

mvn es el ejecutable de Maven

archetype:create esto le dice que ejecute el Goal create del plugin archetype. esto me genera un nuevo proyecto con el formato que le diga.

-DXXXXXXX el operador -D define una propiedad que modifica el comportamiento de Maven.

-DgroupId=ar.utn.tadp Le indica el valor que va a tener el groupId del nuevo proyecto a crear.

-DartifactId=tutorial Le indica el valor que va a tener el


Página 16 de 26

artifactId del nuevo proyecto a crear.

-DarchetypeArtifactId=maven-archetype-webapp

Le indica el tipo de archetype para utilizar en este caso el elegido es el correcto para un webapp.

La ejecución de este comando resulta en la generación de un directorio con el nombre del artefacto creado.

Este directorio tiene una estructura que corresponde con la esperada por Maven, la estructura que espera Maven es la siguiente:

tutorial Directorio raiz del proyecto.

pom.xml POM que describe el proyecto

src/ Directorio donde se encuentran los fuentes del proyecto. Tanto de los Tests como de los ejecutables.

main/ Aquí se agrupan los archivos que se compilaran e incluirán en el producto de la compilación.

webapp/ Archivos del site, ya que va a ser una WebApp aparecen los archivos a presentar. JSP, imagenes y HTML entre otros.

java/ Los archivos .java que contienen el código de nuestro artefacto. A partir de aca se arma la estructura clasica de paquetes.

resources/ Recursos que no son compilados, archivos de configuración y esas cosas.

test/ En esta carpeta se encuentran los elementos necesarios para realizar el testeo de la aplicación.

java/ Código fuente de los Test que se van a ejecutar y de clases necesarias para ejecutar dichos tests.

resources/ Archivos de configuración y recursos necesarios para realizar los tests.

target/ En este directorio se generan todos los archivos creados a lo largo de todo el proceso de construcción. Este directorio no debe ser agregado al SVN. Ya que se genera cn cada ejecución.


Página 17 de 26

Es importante tener en cuenta esta convención en la distribución de directorios ya que es la que maven adopta como estándar y, haciendo uso de uno de sus fundamentos –“convention over configuration”-, nos veremos beneficiados en forma gratuita de muchas de las facilidades que ofrece esta herramienta. Algunos ejemplos de estas facilidades son:

• Todo el código java alojado en el directorio “src/main/java” será compilado en la fase de compilación.

• Todos los recursos adicionales (i.e., archivos de configuración, localización, internacionalización, etc) serán excluídos en la compilación pero agregados al entregable que producirá maven, directamente accesibles e incluidos en el CLASSPATH del mismo.

• Todos los tests unitarios alojados en el directorio “src/test/java” serán ejecutados posteriormente a la compilación del código y de dichos tests. Por medio de parámetros adicionales de configuración se puede decidir el futuro del resto de la compilación en función de los resultados producidos por la ejecución de los tests.

• En el directorio “target” se alojará el único (“separation of concerns”) entregable producido por maven.

En este momento debemos indicarle a Maven que vamos a operar con Java 1.5; para lo que

vamos a abrir el archivo pom.xml y agregamos la sección en amarillo:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

<modelVersion>4.0.0</modelVersion> <groupId>ar.utn.tadp</groupId> <artifactId>tutorial</artifactId> <packaging>war</packaging> <version>1.0-SNAPSHOT</version> <name>tutorial Maven Webapp</name> <url>http://maven.apache.org</url> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> </dependencies>

http://maven.apache.org/POM/4.0.0

http://www.w3.org/2001/XMLSchema

http://maven.apache.org/POM/4.0.0

http://maven.apache.org/maven

http://maven.apache.org


Página 18 de 26

<build> <finalName>tutorial</finalName> <plugins> <plugin> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>1.5</source> <target>1.5</target> </configuration> </plugin> </plugins> </build> </project>


Página 19 de 26

Importar el Proyecto en Eclipse

Para poder trabajar más claramente con este proyecto es aconsejable importarlo dentro de Eclipse.

Antes que eso vamos a crear los directorios faltantes para generar la estructura que mostramos

antes, para eso creamos: src/main/java

src/main/resources src/test/java

src/test/resources Una vez creada la estructura, dentro del Eclipse seleccionamos File / Import. Podemos filtrar las

operaciones sobre proyectos de Maven, escribiendo “maven” en la caja de texto. Y seleccionamos Maven Project.

Al darle Next, seleccionamos el directorio raiz donde se encuentra el proyecto. Al finalizar, si

tenemos instalado el plugin de SVN nos va a decir que el proyecto se encuentra dentro de un directorio manejado por SVN, y si le permitimos agregarlo al manejo de versiones interno del plugin de SVN; contestamos que si.

Otra forma más sencilla es utilizar el archetype que provee maven para proyectos eclipse:


Página 20 de 26

Para ello, editamos el pom.xml y agregamos el plugin a la sección <plugins></plugins>, como vimos antes, y agregamos las siguientes líneas:

<plugin>

<groupId>org.apache.maven.plugins</groupId> <artifactId>maven-eclipse-plugin</artifactId> <version>2.5 </version>

</plugin> Una vez hecho esto, simplemente corremos la línea de comandos:

mvn eclipse:eclipse y listo! El plug-in genera todos los descriptores necesarios para eclipse, indicándole dónde se

encuentra nuestro código fuente (recordar “Convention ver configuration”: src/main/java, src/main/resources, src/test/java, src/test/resources, etc); dónde compilar las clases (target/); dónde buscar otros proyectos; y lo más importante, configura el classpath del proyecto con TODAS las depenendecias (directas y transitivas) dejando todo listo para ponerse a codificar.

En caso de eliminar alguna dependencia del pom, o cambiar su versión, basta con ejecutar:

mvn eclipse:clean eclipse:eclipse para volver a tener todo el proyecto sincronizado!

Otra de las ventajas que tiene maven es que cada archetype sabe en qué fase debe ejecutarse,

por lo cual es muy fácil encadenar archtypes en una misma línea de comandos. Por ejemplo, podríamos tener nuestro proyecto compilado, testeado, empaquetado y sincronizado con el eclipse haciendo:

mvn clean install eclipse:clean eclipse:eclipse

De esta forma ya tenemos el proyecto dentro del Eclipse y listo para trabajar.


Página 21 de 26

Haciendo Commit de lo que hicimos

Ahora vamos a hacer Commit de los cambios que hicimos en la copia local del proyecto.

Esto lo vamos a hacer desde el Eclipse. Antes de poder continuar vamos a marcar la carpeta target para que la ignore de esta forma

cuando impactemos cambios al SVN no se envíen todos los archivos resultantes del proceso de Build. Esto se debe hacer sólo una vez, después el SVN recuerda las propiedades, en este caso svn:ignore.

Para realizar esto es necesario darle botón derecho en la carpeta target, y elegir la opción Team /

add to svn:ignore. Luego hacer click sobre el botón Ok.

Una vez realizado esto es posible realizar el commit de todo el proyecto. Para eso hacemos click en la opción Team/Commit... esto nos muestra la siguiente pantalla:

Donde podemos seleccionar los archivos a subir al repositorio y ponerle un comentario al

commit.


Página 22 de 26

Creación de Clases

A continuación vamos a crear dos clases y una interfaz, la idea es generar un ejemplo práctico donde se pueda ver como utilizar el Eclipse.

Para realizar esto vamos a escribir una nueva interfaz, llamada Poligono.

Hacemos click derecho sobre la carpeta src/main/java y elegimos New/Package y ponemos el

nombre ar.edu.utn.frba.tadp.tutorial. Con esto estamos creando un nuevo paquete para agrupar nuestras clases e interfaz.

Sobre el paquete recién creado hacemos click derecho y seleccionamos New / Interface y le ponemos el nombre Poligono, esto nos va a crear un nuevo archivo .java con el nombre de la interfaz. Pegamos el siguiente contenido:

package ar.edu.utn.frba.tadp.tutorial; public interface Poligono { public Double area(); public Double perimetro(); } Una vez que realizamos esto, vamos a proseguir a crear la clase Triangulo; para hacerlo damos

click derecho en el paquete y elegimos New / Class esto va a abrir la siguiente ventana, donde además del nombre de la clase vamos a indicarle qué interfaz tiene que implementar la clase. Además le indicamos que genere los métodos abstractos que hereda de la interfaz. Quedando la ventana de la siguiente manera.


Página 23 de 26

Copiamos el siguiente código fuente:

package ar.edu.utn.frba.tadp.tutorial; public class Triangulo implements Poligono { private Double ladoA; private Double ladoB; private Double ladoC; public Triangulo(Double ladoA, Double ladoB, Double ladoC) { super(); this.ladoA = ladoA; this.ladoB = ladoB; this.ladoC = ladoC; } public Double area() { // Vamos a aplicar la formula de Herán para calcular // el Área en función de los lados.


Página 24 de 26

Double sp = this.perimetro()/2; Double a = Math.sqrt(sp*(sp-this.ladoA)*(sp-this.ladoB)*(sp-this.ladoC)); return a; } public Double perimetro() { return this.ladoA+this.ladoB+this.ladoC; } } Ahora repetimos el mismo procedimiento para crear la clase ‘Cuadrado’, copiando el siguiente

código:

package ar.edu.utn.frba.tadp.tutorial; public class Cuadrado implements Poligono { private Double lado; public Cuadrado(Double lado) { super(); this.lado = lado; } @Override public Double area() { return this.lado *this.lado; } @Override public Double perimetro() { return lado*4; } }


Página 25 de 26

A continuación vamos a crear una clase con un método main para poder probar lo que hicimos

hasta ahora. Vamos a crear la clase Geometria y vamos a crearla con el siguiente código.

package ar.edu.utn.frba.tadp.tutorial;

public class Geometria {

public static void main(String[] args) {

Poligono p = new Triangulo(1D,2D,2D); System.out.println("Triangulo:"); System.out.println(p.area()); System.out.println(p.perimetro()); p = new Cuadrado(2D); System.out.println("Cuadrado:"); System.out.println(p.area()); System.out.println(p.perimetro());

} } Para poder ver el resultado de ejecutar esta clase, que se puede ejecutar ya que tiene un método

main, hacemos click derecho sobre la clase y elegimos Run As/Java Application y en caso de que queramos hacer debug de la aplicación elegimos Debug As / Java Application.

Una vez realizada todo commiteamos la versión existente.


Página 26 de 26

Bibliografía Tim O'Brien, John Casey, Maven Definitive Guide, Sonatype, http://www.sonatype.com/book/pdf/maven-definitive-guide.pdf

http://www.sonatype.com/book/pdf/maven-definitive-guide.pdf

Tutorial Inicial Maven SVN Eclipse 2 -...

Documents

Transcript of Tutorial Inicial Maven SVN Eclipse 2 -...