Software Guru Conference & Expo 2014

Hola mundo Gradle

Hola Mundo -> Gradle, Spring Tool Suite

Para Novatos
Por Loko

Bueno pues les cuento que iniciando a trabajar con JSP, ya que al momento únicamente trabajo con PHP y que mi conexión con java ha sido únicamente con algunos proyectos en Android, me recomendaron trabajar con Spring Tool Suite y Gradle.

Como ya dije soy nuevo en JSP me vi en la necesidad de buscar información y ejemplos del clásico “Hola Mundo” pero no encontré mucho al respecto o al menos no algo que pudiera entender. Entonces me decidí a hacer un pequeño ejemplo espero les sirva algunos y así contribuir al material que ya exista en la web. Espero les sirva de algo a mis amigos novatos ;D

Y… ¿Que es Gradle?

Bueno pues, Gradle es una herramienta para construir proyectos de forma automatizada pero tiene algunas ventajas sobre otras que se utilizan con fuerza hasta el momento como Ant y Maven en la parte del mundillo Java. Gradle posee la personalización de Ant, y la automatización de dependencias y convenciones de Maven. Un de las primeras diferencias es que en vez de XML utiliza Groovy.

¡¡Comencemos!!

Primero debemos instalar Gradle, nos aseguramos de tener instalado JDK y descargamos la versión más reciente que pueden encontrar en http://gradle.org Descomprimimos él .zip en una carpeta y creamos una variable de entorno para $GRADLE_HOME. Para probar que la instalación se ha realizado correctamente vamos a consola (cmd) y tecleamos.

gradle -v

Bien ahora que ya tenemos Gradle instalado, que además es necesario para trabajar por primera vez con Gradle wrapper.

Pero… ¿Que es Gradle wrapper?

El wrapper es un batch script en Windows, y un shell script para otros sistemas. Esto con la finalidad de no tener que instalar Gradle a la hora de compartir nuestro proyecto, pues de esto se encarga el envoltorio descargando todas las cosas necesarias de internet. Pues vamos a ver como trabajar con este:

1.- Crear la estructura de directorios

Para utilizar Gradle wrapper es necesario crear un archivo de configuración de Gradle lo nombraremos build.gradle el cual deberá contener lo siguiente.

task wrapper(type: Wrapper) {
 gradleVersion = '1.0-milestone-9'
}

Ahora ejecutamos en consola ejecutaremos el siguiente comando, ubicándonos en donde esta nuestro directorio en este caso “HolaGradle”.

gradle createWrapper

Este comando hace uso del Gradle que previamente instalamos, la versión no tiene que ser la misma a la que especificas en el proyecto. Entonces como ya sabemos Gradle Wrapper evita que al compartir tu proyecto debas previamente instalar Gradle. Entonces veras creado lo siguiente:

gradle. Aquí encontramos un jar con lo necesario para correr el Gradle Wrapper
gradlew. Shell script para otros sistemas Unix
gradlew.bat. Archivo por lotes para Windows

Bien con esto tenemos ya el Gradle Wrapper pero ahora es necesario crear algunos archivos para mostrar en el navegador el guapo “Hola Mundo”.
1.- Primero en java creamos el controlador que llamara el jsp HelloWorldController.java

package com.springsourcery.helloWorld;

import javax.servlet.http.HttpServletRequest;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/helloWorld")
public class HelloWorldController {

        @RequestMapping(method = RequestMethod.GET)
        public String showHello(Model model, HttpServletRequest request) {
                return "hello";
        }
}

2.- Ahora el .jsp dentro del directorio jsp crear el archivo llamado “hello.jsp”

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<!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>helloWorld</title>
        </head>
       
        <body>
                        <h1>hello.</h1>
        </body>
</html>

3.- Ahora crearemos el “web-application-config.xml.” dentro de WEB-INF

<?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"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/mvc <a href="http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
" title="http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
">http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
</a>            <a href="
http://www.springframework.org/schema/beans" title="http://www.springframework.org/schema/beans">http://www.springframework.org/schema/beans</a> <a href="http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
" title="http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
">http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
</a>            <a href="
http://www.springframework.org/schema/context" title="http://www.springframework.org/schema/context">http://www.springframework.org/schema/context</a> <a href="http://www.springframework.org/schema/context/spring-context-2.5.xsd
" title="http://www.springframework.org/schema/context/spring-context-2.5.xsd
">http://www.springframework.org/schema/context/spring-context-2.5.xsd
</a>            <a href="
http://www.springframework.org/schema/aop" title="http://www.springframework.org/schema/aop">http://www.springframework.org/schema/aop</a> <a href="http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
" title="http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
">http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
</a>    <mvc:annotation-driven/>
       
        <!-- Scan for annotation based controllers -->
        <context:component-scan base-package="com.springsourcery" />
       
        <bean id="viewResolver"
                class="org.springframework.web.servlet.view.InternalResourceViewResolver">
                <property name="viewClass"
                        value="org.springframework.web.servlet.view.JstlView" />
                <property name="prefix" value="/WEB-INF/jsp/" />
                <property name="suffix" value=".jsp" />
        </bean>
</beans>

4.- Ahora crearemos el “web.xml.” dentro de WEB-INF

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee <a href="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
" title="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
">http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
</a>    version="2.4">
        <!-- The front controller of the Spring MVC Web application, responsible
                for handling all application requests -->
        <servlet>
                <servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
                <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
                <init-param>
                        <param-name>contextConfigLocation</param-name>
                        <param-value>
                                /WEB-INF/web-application-config.xml
                        </param-value>
                </init-param>
                <load-on-startup>1</load-on-startup>
        </servlet>
        <!-- Map requests to the DispatcherServlet for handling -->
        <servlet-mapping>
                <servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
                <url-pattern>/app/*</url-pattern>
        </servlet-mapping>
   
        <welcome-file-list>
                <welcome-file>index.jsp</welcome-file>
        </welcome-file-list>
</web-app>

5.- Ahora crearemos el index.jsp dentro de webapp

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%-- Redirected because we can't set the welcome page to a virtual URL. --%>
<c:redirect url="/app/helloWorld"/>

Muy bien ahora es hora de modificar el build.gradle, como recuerdan hicimos lo necesario para crear el Gradle Wrapper, bien pues ahora necesitamos modificar este archivo para crear las dependencias necesarias y que de esta forma Gradle sepa con cuales va a trabajar. Bien a este archivo eliminaran lo que tiene y pondrán lo siguiente, guardamos y listo.

/****************************************************************
Aca van los PLUGINS con los que vamos a trabajar
*****************************************************************/

apply plugin : 'war'
apply plugin : 'eclipse'
apply plugin:"java"
apply plugin: "eclipse"
apply plugin: "jetty"
springVersion = "3.0.6.RELEASE"
sourceCompatibility = 1.6
slf4jVersion = "1.6.1"
group = 'com.springsourcery.helloWorld'
version = '1.0'

/****************************************************************
REPOSITORIOS
*****************************************************************/

repositories {
        mavenCentral()
}
dependencies{
        compile "org.slf4j:jcl-over-slf4j:$slf4jVersion","org.slf4j:jul-to-slf4j:$slf4jVersion"
        compile "org.springframework:spring-webmvc:$springVersion"
        compile "javax.servlet:servlet-api:2.5"
        compile "javax.faces:jsf-api:1.2_02"
        compile "javax.faces:jsf-impl:1.2-b19"
        compile "javax.servlet:jstl:1.1.2", "taglibs:standard:1.1.2"  
        runtime "org.slf4j:slf4j-log4j12:$slf4jVersion"
        testCompile "junit:junit:4.8.2"
        testCompile "org.springframework:spring-test:$springVersion"
}

Ahora que ya tenemos el archivo build, entonces vamos a abrir una consola y nos dirigimos al directorio raíz de donde tengamos nuestro proyecto en mi caso es C:\Spring\HolaGradle y vamos a teclear gradlew task para ver que tareas podemos realizar, esto dependerá de las dependencias que agregamos al build.gradle. Veremos algo como esto. (tendremos que teclear gradlew en lugar de gradle puesto que ya tenemos el Wrapper en nuestro proyecto.

Bien ahora es momento de correr nuestro servidor Jetty para los que no saben que es aca pego la definición según WikiPedia “Jetty es un servidor HTTP 100% basado en Java y un contenedor de Servlets escrito en Java. Jetty se publica como un proyecto de software libre bajo la licencia Apache 2.0.”

Bueno seguimos en la consola y tecleamos gradlew jettyRun (como lo pueden ver en las tareas Web application task que ahí existe), compilara java entre algunas otras cosas que corre y al final nos mostrara cual es la ruta para poder ir al navegador y correrlo, acá la imagen.

Bueno ahora vamos a nuestro navegador preferido que en lo personal es Firefox puesto que me he acostumbrado a trabajar con el Firebug por lo de mis desarrollos PHP y JQuery en fin ustedes pueden hacerlo en el que seleccionen, introducimos la dirección y vemos que nos arroja.

Ahora para poderlo exportar al Spring Tool Suite únicamente en la consola vamos a teclear gradlew eclipse, con esto podremos importar el proyecto de la típica forma.

File->Import->General->Existing Projects into Workspace

Seleccionamos el directorio y Finish. De esta manera podrán modificar los archivos desde Spring Tool Suite pero tendrán que correrlo todo desde comandos, yo no tengo idea si se pueda hacer desde Spring Tool Suite y cómo hacerlo con tomcat por ejemplo así que si alguien sabe pues agradeceré la info.

Dependencias

Para concluir les dejo una página donde pueden ver más acerca de las dependencias que utilizamos su funcionamiento es muy sencillo en la parte de buscar agregamos por ejemplo mysql y encontraremos varias opciones seleccionamos alguna. http://mvnrepository.com

Después de seleccionar nos aparecerá la manera de poder agregar las dependencias en Maven, Ivi, Grape, Gradle, Buildr, SBT. (Si lo sé una cosa muy chula o al menos a mí me gusto).

Bueno de mi parte es todo espero les sea de utilidad para quienes comienzan en este mundillo y espero quienes ya tienen experiencia puedan compartir más material, como conexión a BD en la creación de un formulario, pruebas con JUnit etc. (En realidad se los pido de favor :D) bien pues agradezco el tiempo que se tomaron el leer este documento y pues por acá andamos.

Salu2 Lokos!!

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de ricardo8a

Buen aporte

Gracias por el articulo, lo seguí paso a paso (los xml subieron mal). Y sobre el trabajo, espero que encuentres pronto algo a tus fines.

Imagen de Sr. Negativo

buen material

Muy bien explicado

Imagen de metallikito

Muy bueno

Justo hace un rato empece a buscar información sobre Gradle y tu post y otro de chochox fueron de ayuda.
Me parece muy practico Gradle, el buidl.gradle es mas ligero que el pom.xml de maven.

De nuevo gracias!

Me alegro que sea de ayuda

Vale me alegra que les gustara, pues no recibia opiniones... con forme avance en el tema subire mas material o lo subo a mi canal de tutoriales en youtube.

Salu2

espero que le guste siñora !!!

Bien...

Buen aporte, esta bien explicado para novatos como yo, te daría 5 estrellas pero con una sera suficiente... seria bueno subirle el tono,
Saludos...