Instalación de Spring Framework
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 fácil obtenerlas.
Crear la aplicación base (esqueleto) con Eclipse
El primer paso para la integración de Spring es crear un proyecto Java con Eclipse; lo iré explicando por pasos y con imágenes para que sea mas fácil entenderlo.
Primero hay que abrir el IDE Eclipse
A continuación vamos al Menú File->New->Other… tras lo cual se presentara el asistente de creación de proyectos de Eclipse:
En esta ventana básicamente vamos a elegir el tipo de proyecto a crear. Como puedes ver hay muchos tipos de proyectos, en este caso vamos a crear un Proyecto de Maven.
Bueno, vamos a ello, seleccionamos la carpeta de Maven -> Maven Project y damos click en el botón Next:
Se presentara una ventana similar a la siguiente. En esta debemos elegir el nombre y ubicación del proyecto, en mi caso desmarque la casilla de verificación Use Default Workspace working location para elegir otra ubicación 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.
Quizás tarde un poco en presentar la siguiente pantalla 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 así como el esqueleto o plantilla 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. No es mi intencion profundizar mucho en temas de Maven pero es importante recordar que un Artefacto Maven puede ser un jar, war, ear o incluso un archivo POM, etc.
Continuemos, en la ventana anterior damos click en el botón Next y se presentara la siguiente pantalla:
Rellena los campos con los datos que se observan en la imagen.
A continuación una breve descripción de los campos de esta ventana.
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 ahí la estructura de carpetas del nuevo proyecto.
Version: Número de versión de tu proyecto, en este caso indicamos que es la versión 1.0.
Para finalizar y crear el nuevo proyecto de Maven damos click en el botón Finish.
Estructura del proyecto Maven
La siguiente imagen muestra la estructura de carpetas y los paquetes creados por el asistente:
Donde
\InstalacionSpring\src\main\java
Es donde se deben colocar los paquetes y el código fuente del proyecto.
\InstalacionSpring\src\test\java
Es donde se deben colocar los paquetes y el código fuente para las pruebas unitarias que sean necesarias.
Vamos a crear las siguientes carpetas:
\InstalacionSpring\src\main\resources
\InstalacionSpring\src\test\resources
Dichas carpetas nos permitirán colocar archivos de configuración y recursos en general del proyecto; como son el archivo xml descriptor de Spring (generalmente llamado applicationContext.xml), archivos de propiedades, archivos de idioma, etc. Ademas, estas carpetas forman parte de la estructura estandar de un proyecto de Spring con Maven, honestamente desconozco porque el asistente de creación de proyectos de Maven no crea estas carpetas, si en un futuro lo descubro actualizare este articulo.
En la carpeta \InstalacionSpring\src\main\java se creo el paquete
com.notasprogramacion.spring.setup y dentro de éste la clase App.java que contiene el clásico Hola Mundo:
|
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 \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 básica con JUnit. Las pruebas unitarias las veremos mas adelante en un articulo por separado.
|
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 ); } } |
Integración del Framework Spring al archivo pom.xml
El archivo descriptor de Maven \InstalacionSpring\pom.xml es donde vamos a integrar el Framework de Spring, actualmente debe lucir mas o menos así:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
<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 así:
|
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 |
<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 <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 27 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 46 a 80); 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 84 a 88 se esta indicando que la carpeta src/main/resources es una carpeta de recursos.
En la linea 90 se esta indicando el nombre del artefacto a generar InstalacionSpring Como el proyecto es de tipo jar (esto se esta indicando en la linea 7). El artefacto final resultante se llamara InstalacionSpring.jar.
De la linea 92 a 98 se esta indicando la versión de java a utilizar para compilar, en este caso el JDK 1.7.
De la linea 100 a 107 se esta indicando que se omita la ejecución de las pruebas unitarias al momento de compilar el proyecto.
Ahora vamos a recargar la nueva configuración del archivo pom.xml para ello da click con el botón derecho sobre el nombre del proyecto y elige la opción Maven->Update project…, en la ventana que se presenta da click sobre el botón OK.
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 parámetro 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 serán contestados a la brevedad.
Hasta pronto.