Blog dedicado a la programación y a la informática en general

DosM Blog

Ir al contenido | Ir al menú | Ir a las búsquedas

Spring MVC - Maven: Crear Proyecto - Parte 1

Por Fran Márquez el Miércoles, 1 de Octubre de 2014, 07:30 - Enlace permanente

Spring es un framework de código abierto para el desarrollo de aplicaciones JAVA.

MVC es un módulo de Spring que implementa el un patrón de arquitectura software que separa los datos y la lógica de negocio de una aplicación de la interfaz de usuario. Spring MVC provee herramientas para la extensión y personalización de aplicaciones web y servicios Web REST.


Después de esta breve descripción, nos ponemos manos a la obra para la creación de nuestro proyecto Spring MVC con Maven.


Instalación de Maven


Para el desarrollo del proyecto vamos a trabajar con Eclipse, y añadiremos el plugin oficial de Maven.

Con el Eclipse abierto, pulsamos sobre "Help"->"Eclipse Marketplace...". De esta forma se abre Eclipse Marketplace, que es la solución que Eclipse aporta para la instalación de plugin directamente desde el propio IDE. Para continuar con la instalación de Maven, buscamos "Maven Integration" e instalamos el que corresponda con la versión de Ecplise con la que estamos trabajando. El proceso de instalación es bastante intuitivo por lo que no entro en detalles en esta parte.


Creación del Proyecto


Ya tenemos el entorno de desarrollo preparado para la creación del proyecto, por lo que nos ponemos manos a la obra. "File"->"New" ->"Project..." para abrir el asistente de Nuevo Proyecto, y en el campo Wizards escribimos Maven para que se filtren los posibles proyectos que podemos crear.

Spring_MVC1.png

Seleccionamos "Maven Project" y avanzamos a la siguiente pantalla con el botón "Next". La siguiente pantalla es para la configuración de algunos parámetros del proyecto, pero no es necesario tocar nada por lo que volvemos a pulsar "Next". La siguiente pantalla es muy importante porque tenemos que seleccionar el Arquetipo del proyecto que queremos realizar. Para ello vamos a buscar el "Artifact Id" "webapp-javaee6", podemos ayudarnos filtrando los resultados de búsqueda poniendo "webapp".

Spring_MVC2.png

Avanzamos a la siguiente pantalla donde definiremos el nombre y paquete del proyecto.

Spring_MVC3.png

  • groupId: Es el identificador único del proyecto. Debe seguir unas reglas de nomenclaturas, al menos debe tener un formato que se acepte como nombre de dominio. Para más informacón entrar aquí
  • artifactId: Es el nombre del jar.
  • package: Nombre del paquete.


Por último finalizamos el asistente y comenzara a crear se proyecto.

Errores en el proyecto inicial


En mi caso, cada vez que creo que creo un proyecto Maven, el archivo pom.xml me marca un error del plugin para Eclipse. En este caso, el error lo indica en las acciones que debe realizar Maven cuando realice la orden "validate", que consisten en copiar el archivo WAR generado a una ruta en concreto. Como para nosotros eso no va a ser necesario podemos borrar las siguientes lineas de código solucionando el problema en cuestión.

<executions>
     <execution>
             <phase>validate</phase>
             <goals>
                   <goal>copy</goal>
             </goals>
             <configuration>
                    <outputDirectory>${endorsed.dir}</outputDirectory>
                    <silent>true</silent>
                    <artifactItems>
                          <artifactItem>
                               <groupId>javax</groupId>
                               <artifactId>javaee-endorsed-api</artifactId>
                                <version>6.0</version>
                                <type>jar</type>
                            </artifactItem>
                      </artifactItems>
                </configuration>
      </execution>
</executions>

Ya tenemos nuestro proyecto Maven, y ahora debemos añadir las librerías de Spring. Para ello, debemos utilizar el archivo pom.xml, que es el archivo de configuración de Maven. Buscamos la sección "<dependencies>" del xml y añadimos las siguientes dependencias de las que depende Spring


 <dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	<version>3.2.5.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-web</artifactId>
	<version>3.2.5.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-tx</artifactId>
	<version>3.2.5.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aop</artifactId>
	<version>3.2.5.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-webmvc</artifactId>
	<version>3.2.5.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-test</artifactId>
	<version>3.2.5.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-oxm</artifactId>
	<version>3.2.5.RELEASE</version>
</dependency>
        <dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-orm</artifactId>
	<version>3.1.1.RELEASE</version>
</dependency>

<dependency>
	<groupId>jstl</groupId>
	<artifactId>jstl</artifactId>
	<version>1.1.2</version>
</dependency>
<dependency>
	<groupId>taglibs</groupId>
	<artifactId>standard</artifactId>
	<version>1.1.2</version>
</dependency>

<dependency>
	<groupId>org.codehaus.jackson</groupId>
	<artifactId>jackson-core-asl</artifactId>
	<version>1.9.12</version>
</dependency>
<dependency>
	<groupId>org.codehaus.jackson</groupId>
	<artifactId>jackson-mapper-asl</artifactId>
	<version>1.9.12</version>
</dependency>

Vamos a hacer una breve descripción de las librerías que hemos añadido.

  • org.springframework Son las librerías propias de Spring.
  • taglibs y jstl Son librerías para añadir funcionalidad en las vistas (JSP)
  • org.codehaus.jackson El intercambio de información en servicios REST de Spring, se pueden hacer mediante JSON, para ello usamos estás librerías.


Archivos de configuración


Para los archivos de configuración vamos a crear una estructura de carpetas concreta, "src"/"main"/"webapp"/"WEB-INF". Podemos ver que únicamente tenemos que crear la carpeta "WEB-INF" porque la estructura superior ya viene definida en al proyecto.

web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="WebApp_ID" version="2.5">

	<display-name>DosMWeb</display-name>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<servlet>
		<servlet-name>spring</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>spring</servlet-name>
		<url-pattern>/dm/*</url-pattern>
	</servlet-mapping>


	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
		/WEB-INF/spring-servlet.xml,
		/WEB-INF/applicationContext.xml
		</param-value>
	</context-param>

</web-app>

Con la etiqueta <servlet-mapping> indicamos la estructura de nombre que va a tener nuestra aplicación, en este caso todas paginas que definamos posteriormente van ir precedidas automáticamente por /dm/. Por ejemplo, si tuvieramos un controlador "listado", para llamarlo por URL habría que poner http://127.0.0.1:8080/dm/listado. Pero esto ya lo veremos con detalle cuando lleguemos al apartado correspondiente.

Por otro lado también indicamos los archivos donde vamos a configurar spring.

spring-servlet.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	   		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

	<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver"
		p:prefix="/WEB-INF/jsp/" p:suffix=".jsp" />

	<bean id="jacksonMessageConverter"
		class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />

	<bean
		class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
		<property name="messageConverters">
			<list>
				<ref bean="jacksonMessageConverter" />
			</list>
		</property>
	</bean>

	<bean id="methodHandlerExceptionResolver"
		class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver">
		<property name="messageConverters">
			<list>
				<ref bean="jacksonMessageConverter" />
			</list>
		</property>
	</bean>
</beans>

En este otro archivo de configuración de Spring, se configura para que de manera automática utilice JSON en los mapeos HTML. También se le indica como debe resolver las peticiones web, en este caso, cuando a Spring se le solicite una vista (JSP), éste irá a buscarlo a la carpeta "WEB-INF/jsp" y se le concatenara al sufijo ".jsp"

applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">

	<context:annotation-config />
	
	<context:component-scan base-package="com.dos.web" />
	
	<mvc:annotation-driven />
	
</beans>

En este archivo se indica donde van a estar los controladores Spring.



Ejecutando el proyecto



Ya tenemos configurado Spring para que mapee las peticiones, por tanto, ahora vamos a indicar que peticiones son las que va a aceptar. Sobre el paquete "com.dos.web", pulsamos con el segundo botón "New"->"Class", y creamos una clase InicioController.

Spring_MVC4.png

InicioController.java
@Controller
@RequestMapping(value = "/dosmweb")
public class InicioController{

	@RequestMapping(value = "/index", method = RequestMethod.GET, headers = "Accept=application/json")
	public String getIndex(Model model) {

		return "index";
	}
	
}

Las anotaciones a nivel de clase son las siguientes:
@Controller Con esta etiqueta marcamos la clase como un controlador de Spring @RequestMapping Indica el mapeo que va a llevar el controlador actual
Por otro lado, tenemos anotaciones a nivel de métodos de clase, en este caso tenemos la misma anotación que tenemos en la clase, @RequestMapping y le indicamos un nuevo valor para el mapeo. También le indicamos el método de petición que permite, en este caso GET y por último le definimos que acepta peticiones por JSON.

Podemos ver que el método getIndex devuelve una cadena que indica la vista que queremos mostrar. Aunque la cadena es "index", en realidad Spring se va a encargar de buscar "WEB-INF/jsp/index.jsp", ya que como vimos anteriormente en el archivo "spring-servlet.xml" en el "viewResolver" le definimos que a las peticiones de vistas le añadiera el prefijo "WEB-INF/jsp/" y el sufijo ".jsp".

Entonces lo que nos falta es poner el archivo index.jsp en la ruta indicada.


<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>DosMWeb</title>
</head>
<body>
Spring MVC - Maven: Crear Proyecto - Parte 1
</body>
</html>
index.jsp
Tomcat 6.0


Ya tenemos el proyecto listo, ahora solo necesitamos un servidor para probarlo.

En Eclipse, "Window"->"Show View"->"Other..." y selecciona la vista "Server". Con aparece una nueva vista "Server" donde iremos añadiendo todos los servidores que necesitemos.
Para añadir un servidor, pulsamos con el botón derecho sobre la ventana "Server", "New"->"Server", seleccionamos "Apache Tomcat 7" y seguimos el asistente. En la siguiente pantalla, seleccionamos del listado de la izquierda y lo añadimos al listado de la derecha y por último pulsamos "Finish".

Una vez que tenemos el servidor, pulsamos sobre el servidor con el segundo botón, y arrancamos el servidor ("Start"). En la consola de Eclipse mostrara el proceso de arranque, y en pocos segundo el servidor estará arrancado.

Ahora por último, vamos a ver que todo a funcionado correctamente. Nos vamos al navegador web, y entramos en http://localhost:8080/DosMWeb/dm/dosmweb/index

Como breve recordatorio, vamos a desgranar la url para ver como se ha llegado a ella.

  • DosMWeb: Nombre del proyecto
  • dm: Definido en el archivo web.xml
  • dosmweb: Definido en el RequestMapping de la Clase InicioController.java
  • index: Definido en el RequestMapping del método getIndex de la Clase InicioController.java

Hasta aquí la primera parte y la más compleja para iniciarse en Spring. En posteriores tutoriales, integraremos Hibernate, Spring Security y algunas librerías para darle potencia a nuestros JSP.

Un Saludo!!!

Añadir un comentario

El código HTML se muestra como texto y las direcciones web se transforman automáticamente.

Discusiones sobre el mismo tema

URL de retroenlace : https://www.dosmweb.com/blog/index.php?trackback/6

Fuente de los comentarios de esta entrada