Crear un proyecto web con Spring

Hoy vamos a ver como crear desde cero un proyecto web  con spring y gradle. Para lo cual seguiremos los siguientes pasos:

En el siguiente enlace https://github.com/blancoparis-tfc/basicoSpring podéis encontrar el proyecto completo.

¿Herramienta para gestión y construcción del proyecto?

Para la gestión de las librerías y montaje del proyecto vamos a utilizar la herramienta gradle (Ojo también podemos usar maven) a fin de cuentas gradle va a usar los repositorios de maven :). 

¿Por que he seleccionado Gradle, en vez de maven? Es simple, por que ahora estoy aprendiendo gradle, pero para realizar esta tarea en principio nos valen las dos herramientas.

Ahora que tenemos seleccionada la herramienta vamos a ver que pasos tenemos que dar.

¿Decidimos que necesitamos?

Antes de empezar a picar una linea de código tenemos que tener claro que necesitamos. A continuación enumeramos los compomentes para empezar un proyecto web en spring.

• Seleccionar los plugins de gradle que necesitamos:
• 'java': Por que va a ser un proyecto java.
• 'war': Por que va a ser un proyecto web.
• 'eclipse': Lo vamos a integrar con el ide eclipse.
• 'eclipse-wtp':Lo vamos a integrar con eclipse-wtp.
• La versión de jdk (en nuestro caso vamos a seleccionar la versión JDK 1.8)
• Definir el contenedor de servlet (Nuestro caso sera 3.0).
• El repositorio, que vamos a utilizar para gestionar las dependencias.
• La dependencias que vamos a necesitar.
• La librería de spring para hacer una aplicación web (spring-webmc).
• Las librerías para los logs (slf4j + logback).
• La libreria para los test unitarios (junit)

Ahora voy a explicar paso a paso como configurar el proyecto en gradle.

Plugins: Ponemos los plugins que necesitamos:

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'war'
apply plugin: 'eclipse-wtp'

La versión de la JDK 1.8:  Para indicar que jdk vamos a trabajar usaremos la variable sourceCompatibility. Y también aprovecharemos y definimos la versión de nuestra aplicación.

sourceCompatibility = 1.8
version = '1.0'

Configuración del proyecto web: Par que eclipse, sepa la versión del servlet (3.0), tenemos que indicarse lo explicita-mente en gradle (indicándole el facet que tiene que usar), por ejemplo en maven la integración con eclipse se apaña leyendo el fichero web.xml.

eclipse{
 wtp{
  facet{
  facet name: 'jst.web', version: '3.0'
  }
 }
}

Repositorio: Aquí le definimos que repositorio vamos a utilizar para buscar las dependencias. En el caso de maven es algo que no necesitamos definir.

repositories {
    mavenCentral()
}

Dependencias: Aqui vamos a definir las dependencias (Son las mismas que utilizamos en maven), http://mvnrepository.com/

dependencies {
 compile 'org.springframework:spring-webmvc:4.1.6.RELEASE'
 compile 'org.slf4j:slf4j-api:1.7.10'
 compile 'ch.qos.logback:logback-classic:1.1.2'
 providedCompile 'javax.servlet:javax.servlet-api:3.0.1'
  testCompile group: 'junit', name: 'junit', version: '4.+'
}

Ojo: providedCompile: Usamos este contexto de  una dependencia para que a la hora de compilar use la librería, pero en la creación del proyecto no la ponga ya que la tenemos en el servidor web y puede entrar en conflicto. Compile: Se usa en la compilación y en la construcción. testCompile: Estas librerías no se usara en la compilación del proyecto, pero si en la compilación y ejecución de los test.

Ojo2: En eclipse, juntara en compilación las librerías de test y las normales y puede llevar alguna confusión ya que eclipse en principio no hace una diferencia en las dependencias entre entorno de test y de ejecución.

Configuración del fichero de gradle, como quedara:

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'war'
apply plugin: 'eclipse-wtp'

sourceCompatibility = 1.8
version = '1.0'
eclipse{
 wtp{
  facet{
  facet name: 'jst.web', version: '3.0'
  }
 }
}
repositories {
    mavenCentral()
}

dependencies {
 compile 'org.springframework:spring-webmvc:4.1.6.RELEASE'
 compile 'org.slf4j:slf4j-api:1.7.10'
 compile 'ch.qos.logback:logback-classic:1.1.2'
 providedCompile 'javax.servlet:javax.servlet-api:3.0.1'
  testCompile group: 'junit', name: 'junit', version: '4.+'
}

Creamos la estructura de directorios básica:

Ahora vamos a crear el directorio donde se guardaran los fuentes de nuestro proyecto.

• "src\main\java": Aquí es donde crearemos los ficheros de java.
• "src\main\resources": Donde pondremos los recursos del proyecto.
• "src\main\webapp": Donde ubicaremos los ficheros para un proyecto web.

Configuración del proyecto.

En un proyecto web,  vamos a configurar donde se ubicaran los:

• Controladores. (org.dbp.controller)
• Los jsp (/WEB-INF/pages/)

Aparte le indicaremos a Spring que es un proyecto web mvc (con la anotación enabledWebMvc).

package org.dbp.conf;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@EnableWebMvc
@ComponentScan(
  basePackages={
    "org.dbp.controller" // Es donde se ubicaran los controladores
    }
  )
public class WebConfig {
 /**
  * 
  * Configuramos que las paginas se guarden en la carpeta pages
  * 
  * @return
  */
    @Bean
    public InternalResourceViewResolver getInternalResourceViewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/pages/");
        resolver.setSuffix(".jsp");
        return resolver;
    }
}

Una vez establecida la configuración básica de spring, solo nos toca configurar en el web.xml el dispacher. Simplemente le indicamos donde se encuentra la clase de configuración.

Fichero /WEB-INF/web.xml

<web-app id="WebApp_ID" version="3.0" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemalocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
 <welcome-file-list>
  <welcome-file>index.jsp</welcome-file>
 </welcome-file-list>
 <servlet>
  <servlet-name>dispacher</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
   <param-name>contextClass</param-name>
   <param-value>
            org.springframework.web.context.support.AnnotationConfigWebApplicationContext
        </param-value>
  </init-param>
  <init-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>org.dbp.conf.WebConfig</param-value>
  </init-param>
 </servlet>

 <servlet-mapping>
  <servlet-name>dispacher</servlet-name>
  <url-pattern>/</url-pattern>
 </servlet-mapping>

</web-app>

Controlador de prueba:

Una vez configurado el proyecto vamos a crear nuestro controlador llamado inicio, que simplemente nos redirigirá a una página. 

Controlador org.dbp.InicioController

package org.dbp.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("inicio")
public class InicioController {

 @RequestMapping
 public String inicio(){
  return "inicio";
 }
 
}

La jsp /WEB-INF/pages/inicio.jsp

Inicio

Es un ejemplo simple de direccionamiento a una pagina en concreto.

http://localhost:8080/basicoSpring/inicio (Esta url tendría que devolvernos la palabra inicio.