Herramientas necesarias
Las herramientas que necesitas para realizar este tutorial son:
Como puedes observar deje un enlace a la pagina de descarga de algunas herramientas para que te sea mas facil obtenerlas.
Crear la aplicacion base (esqueleto) con Eclipse
El primer paso para la instalacion es crear un proyecto Java con Eclipse, lo ire explicando por pasos y con imagenes para que sea mas facil entenderlo.
Abrir el IDE Eclipse
A continuacion vamos al Menu File->New->Other… y se presentara el asistente de creacion de proyectos de Eclipse:
En esta ventana basicamente vamos a elegir el tipo de proyecto a crear; en este caso un Proyecto de Maven, como puedes ver hay muchos tipos de proyectos. Seleccionamos la carpeta de Maven -> Maven Project y damos click en el boton Next:
La siguiente pantalla nos permite elegir el Nombre y Ubicacion del proyecto (donde se creara), en mi caso desmarque la casilla de verificacion Use Default Workspace working location para elegir otra ubicacion distinta a la default y seleccione la carpeta del workspace de Eclipse como se muestra en la siguiente pantalla.
Damos click en el boton Next y se nos presenta la siguiente pantalla (quizas tarde un poco en presentarla debido a que se deben descargar desde el repositorio central de maven todos los arquetipos disponibles):
En esta pantalla debemos elegir el Arquetipo a utilizar para el nuevo proyecto de maven. Recordemos que un arquetipo es algo asi como el esqueleto de un proyecto maven. En el Campo Filter escribimos el nombre del arquetipo maven-archetype-quickstart, si hay mas de uno con ese nombre tener cuidado de elegir el que tenga el groupId org.apache.maven.archetypes. Este arquetipo crea un Artefacto Maven de tipo Jar, damos click en el boton Next para continuar, se presentara la siguiente pantalla (rellenamos los campos con los datos que se observan):
Group Id: Debemos pensar en este dato como si fuera el paquete principal del proyecto. Típicamente aquí se pone el nombre de la empresa u organización a la que pertenece este proyecto.
Artifact Id: Es el nombre de tu proyecto, Maven creara una carpeta con este nombre y colocara ahi la estructura de carpetas del nuevo proyecto.
Version: Número de versión de tu proyecto, en este caso indicamos que es la version 1.0.
Para finalizar y crear el nuevo proyecto damos click en el boton Finish.
Estructura del proyecto Maven
La siguiente imagen muestra la estructura de carpetas y los paquetes creados por Maven:
Basicamente se creo la siguiente estructura de carpetas:
[nombreWorkspace]\InstalacionSpring\src
[nombreWorkspace]\InstalacionSpring\src\main\java
[nombreWorkspace]\InstalacionSpring\src\test\java
Donde
[nombreWorkspace]\InstalacionSpring\src\main\java
Es donde se deben colocar los paquetes y el codigo fuente del proyecto.
[nombreWorkspace]\InstalacionSpring\src\test\java
Es donde se deben colocar los paquetes y el codigo fuente para las pruebas unitarias que sean necesarias.
Vamos a crear las siguientes carpetas:
[nombreWorkspace]\InstalacionSpring\src\main\resources
[nombreWorkspace]\InstalacionSpring\src\test\resources
Dichas carpetas nos permitiran colocar archivos de configuracion y recursos en general del proyecto; como son el archivo xml descriptor de Spring, archivos de propiedades, archivos de idioma, etc. Ademas, estas carpetas forman parte de la estructura estandar de un proyecto de Spring.
En la carpeta [nombreWorkspace]\InstalacionSpring\src\main\java se creo el paquete
com.notasprogramacion.spring.setup y dentro de éste la clase App.java que contiene el clasico Hola Mundo (“Hello World!”)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package com.notasprogramacion.spring.setup; /** * Hello world! * */ public class App { public static void main( String[] args ) { System.out.println( "Hello World!" ); } } |
En la carpeta [nombreWorkspace]\InstalacionSpring\src\test\java se creo el paquete
com.notasprogramacion.spring.setup y dentro de éste la clase AppTest.java que contiene una prueba unitaria muy basica con JUnit (las pruebas unitarias las veremos mas adelante).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
package com.notasprogramacion.spring.setup; import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite; /** * Unit test for simple App. */ public class AppTest extends TestCase { /** * Create the test case * * @param testName name of the test case */ public AppTest( String testName ) { super( testName ); } /** * @return the suite of tests being tested */ public static Test suite() { return new TestSuite( AppTest.class ); } /** * Rigourous Test :-) */ public void testApp() { assertTrue( true ); } } |
Integracion del Framework Spring al archivo pom.xml
El archivo descriptor de Maven [nombreWorkspace]\InstalacionSpring\pom.xml es donde vamos a integrar el Framework de Spring, actualmente debe lucir mas o menos asi:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
<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/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.notasprogramacion.spring.setup</groupId> <artifactId>InstalacionSpring</artifactId> <version>1.0</version> <packaging>jar</packaging> <name>InstalacionSpring</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> </dependencies> </project> |
Para integrar Spring Core modifiquelo para que ahora se vea asi:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 |
<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/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.notasprogramacion.spring.setup</groupId> <artifactId>InstalacionSpring</artifactId> <version>1.0</version> <packaging>jar</packaging> <name>InstalacionSpring</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <!-- Version de Spring --> <spring.version>3.2.3.RELEASE</spring.version> <!-- Logging --> <log4j-version>1.2.17</log4j-version> <org.slf4j-version>1.6.1</org.slf4j-version> <!-- Testing --> <junit.version>4.10</junit.version> </properties> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> <!-- Excluir Commons Logging en favor de SLF4j --> <exclusions> <exclusion> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> </exclusion> </exclusions> </dependency> <!-- Logging --> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>${org.slf4j-version}</version> </dependency> <!-- Spring utiliza Jakarta Commons Logging, con esto podemos leer logs de spring ya que se imita las clases de JCL e internamente llama SLF4J --> <dependency> <groupId>org.slf4j</groupId> <artifactId>jcl-over-slf4j</artifactId> <version>${org.slf4j-version}</version> <scope>runtime</scope> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-log4j12</artifactId> <version>${org.slf4j-version}</version> <scope>runtime</scope> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>${log4j-version}</version> <scope>runtime</scope> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>${junit.version}</version> <scope>test</scope> </dependency> </dependencies> <build> <resources> <resource> <directory>src/main/resources</directory> </resource> </resources> <finalName>InstalacionSpring</finalName> <plugins> <plugin> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>1.7</source> <target>1.7</target> </configuration> </plugin> <!-- Omitir Tests --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-plugin</artifactId> <configuration> <skipTests>true</skipTests> <junitArtifactName>junit:junit</junitArtifactName> </configuration> </plugin> </plugins> </build> </project> |
Una vez modificado el archivo guárdelo, a continuación explicare algunas lineas del archivo pom.xml:
De la linea 28 a 45 se agrego el modulo Core; si quisiéramos activar o utilizar algún otro modulo de Spring Framework, por ejemplo Spring JDBC, simplemente agregamos su dependencia (con la versión respectiva que queramos usar):
|
1 2 3 4 5 6 |
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.1.0.RELEASE</version> </dependency> |
..y listo maven se encargara de descargar los jars necesarios para que utilicemos dicho modulo. Observa como agregue 3 dependencias mas (lineas 47 a 81); logf4j, slf4j y junit, éstas no forman parte del modulo Core de Spring. Las primeras 2 las usaremos para mostrar logs en la consola y junit para hacer algunas pruebas unitarias mas adelante.
De la linea 85 a 89 se esta indicando que la carpeta src/main/resources es una carpeta de recursos.
De la linea 93 a 99 se esta indicando la versión de java a utilizar para compilar, en este caso el jdk 1.7.
En la linea 91 se esta indicando el nombre del artefacto a generar InstalacionSpring; como el proyecto es de tipo
|
1 |
<packaging>jar</packaging> |
El artefacto final resultante se llamara InstalacionSpring.jar.
De la linea 101 a 108 se esta indicando que se omita la ejecución de las pruebas unitarias al momento de compilar el proyecto.
A continuación de click con el botón derecho sobre el nombre del proyecto y elija la opcion Maven->Update project…, en la ventana que se presenta de click sobre el boton OK, esto con el objetivo de que se vuelva a cargar la nueva configuración del archivo pom.xml
A continuación vamos a compilar el proyecto y colocarlo dentro de nuestro repositorio local de Maven. Nuevamente da click con el botón derecho sobre el nombre del proyecto y elija la opción Run As-> Maven build…, en la ventana que se presenta en el campo Goals escriba clean install; clean para borrar todas las clases .class y archivos binarios que pudiera haber, es decir, limpiar compilaciones previas, y el parametro install para compilar e instalar el proyecto en el repositorio local de Maven.
Observe en la siguiente pantalla como se descargaron otros jars, los cuales aunque no forman parte directa de spring son necesarios para que éste funcione de manera correcta.
Con esto ha quedado instalado el modulo Core de Spring en el proyecto, en las siguientes entregas estare mostrando como utilizarlo y las bondades que ofrece al desarrollar aplicaciones.
Si tienes alguna duda o deseas expresar alguna inquietud, no olvides dejar tus comentarios y si es necesario seran contestados a la brevedad.
Hasta pronto.