Tuesday, May 10, 2016

What about chesspresso?

Desde hace tiempo estoy con ganas de escribir alguna app asociada al ajedrez, un juego que amo.

Y para ahorrar esfuerzo de desarrollo, me decidía a buscar alguna librería.
¿Que es lo que necesitaría que ofrezca esta librería?

  • Un interprete de archivos PGN y FEN (Base de datos de partidas y posiciones respectivamente)
  • Una interfaz gráfica GUI
  • La capacidad de conectarse a un Motor de Juego
  • Un lector de libro de aperturas
  • Un motor de juego, obviamente no, porque ya existe el Stockfish y otros...

En ese contexto, surge chesspresso (http://www.chesspresso.org/) que pareciera ser una buena librería, escrita en Java, que ofrece varias de estas cosas....  y surge la pregunta de este post

What about chesspresso?

¿Se puede utilizar esta librería? ¿Es gratis? ¿Es open source? ¿Que licencias tiene? ¿Que significa estas licencias? ¿La puedo incluir en mi código si me decido a comercializar mi App de alguna manera? ¿Es difícil de utilizar? ¿Además de Java está la versión para Android? ¿Como se instala? ¿Como se utiliza?





Con estas preguntas en la cabeza, vamos a continuar con el desarrollo del Post.

Comencemos

Descargamos el código fuente del repositorio oficial, aunque hay también algunos proyectos en GitHub

https://sourceforge.net/projects/chesspresso/

Licencia

Tiene licencia GNU Library or Lesser General Public License version 2.0 (LGPLv2)
Y para entender mejor los alcances de esta licencia, me gusta la explicación de la wikipedia sobre GNUL: https://es.wikipedia.org/wiki/GNU_Lesser_General_Public_License

Lamentablemente, no logro aún entender si podría hacer uso del software en el caso que quisiera comercializar la app que utilizaría esta librería. Pareciera que si... pero no estoy seguro. Llegado el caso, revisaré este punto, aunque aún estoy muy lejos de poder subir alguna app de ajedrez al store... sigamos

Descarga y Testing

Directorio de trabajo en mi PC:

/Users/pabloin/Desktop/NoCuestaNada/Mob/CrossFit Chess/04 Chesspresso

Lo primero que observamos, es que viene sin los fuentes y con el Javadoc, y la API parece sencilla. Además que se pueda con Junit

En el readme recomiendan ejecutar:

run the tests with
    java -classpath chesspresso-lib.jar;chesspresso-lib-test.jar;%JUNIT_HOME%\junit.jar chesspresso.AllTests






aunque yo voy a utilizar el eclipse (no tengo ganas de buscar al Junit e incluirlo en el classpath)

Con el workspace en:
/Users/pabloin/Desktop/NoCuestaNada/Mob/CrossFit Chess/04 Chesspresso

Proyecto creado, con la librería chesspresso-lib.jar incluida y también Junit incluido. Aunque Observemos que tenemos que hacer algo para que el eclipse confíe en el jar de chesspresso-lib.jar

chesspresso-lib.jar no puede abrirse porque proviene de un desarrollador no identificado


Continúo para avanzar de otro proyecto tomado de GitHub, donde están los fuentes de la librería:
Lo que en realidad me interesa, es tener una clase de Testing para la librería, que me permita ejecutar un ejemplo de la librería chesspreso funcionado. Esta clase la cual copio a continuación, que reproduce en el visor las primeras jugadas de una apertura Ruy Lopez:


   

package com.probarnocuestanada.chess.chesspreso;

import javax.swing.JFrame;

import org.chesspresso.Chess;
import org.chesspresso.game.Game;
import org.chesspresso.game.view.GameBrowser;
import org.chesspresso.move.IllegalMoveException;
import org.chesspresso.move.Move;

/**
* @author PabloEzequiel on 6 de may. de 2016
*
* * ProbarNoCuestaNada.com
*

* @no_cuestanada https://github.com/PabloEzequiel https://javaen.blogspot.com
*/
public class ChesspressoGameBrowser extends JFrame {

private Game chessGame = new Game();
private GameBrowser gameBrowser = new GameBrowser(chessGame);
private static final long serialVersionUID = -6856238414376776882L;

public ChesspressoGameBrowser() {
setTitle("Chesspresso test");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

add(gameBrowser);
pack();

addMove(Chess.E2, Chess.E4, false, "Controlando el centro");
addMove(Chess.E7, Chess.E5, false, "Clasica respuesta");

addMove(Chess.G1, Chess.F3, false, null);
addMove(Chess.B8, Chess.C6, false, null);

addMove(Chess.F1, Chess.B5, false, "Apertura Ruy Lopez");
addMove(Chess.A7, Chess.A6, false, null);
}

private void addMove(int fromSquareIndex, int toSquareIndex, boolean isCapturingMove, String comment) {
try {
short move = Move.getRegularMove(fromSquareIndex, toSquareIndex, isCapturingMove);
if (Move.isValid(move)) {
chessGame.getPosition().doMove(move);
if (comment != null && comment.length() > 0)
chessGame.addComment(comment);
}
} catch (IllegalMoveException e) {
e.printStackTrace();
}
}


}




A continuación creamos otra clase también para que la invoque:


   

package com.probarnocuestanada.chess.chesspreso;

/**
* @author PabloEzequiel on 6 de may. de 2016
*
* * ProbarNoCuestaNada.com
*

* @no_cuestanada
* https://github.com/PabloEzequiel
* https://javaen.blogspot.com
*/
public class TestChesspresso {

public static void main(String[] args) {
ChesspressoGameBrowser chessFrame = new ChesspressoGameBrowser();
chessFrame.setVisible(true);
System.out.print("Hola");
}
}




Después de ejecutar el ejemplo queda, observamos que se levanta un visor básico de Chesspresso:



Veamos que hay mucho para parametrizar aún:

Ok, en este punto damos por cerrado el post. La librería tienen muy buena fama, Quizá no sea demasiado complicado integrarlo a una aplicación Android.

Mi directorio de trabajo fué:

  • /Users/pabloin/Desktop/NoCuestaNada/Mob/CrossFit-Chess-tmp

Creo que no vale la pena compartir el proyecto en GitHub, porque es básicamente la librería y la clase java que copié en le post.



Links
          Ejemplo de uso de la librería

              Una excelente librería de chess en Javascript. No está directamente relacionada a este post,
              pero puede ser una buena idea para el futuro.













    Labels: , ,

    Sunday, September 20, 2015

    Proyecto myApiRest en GitHub con Eclipse

    Vamos a subir un proyecto simple a GitHub con una API Rest muy básica, que tenga un interceptor y Spring MVC

    Utilizamos
    La versión inicial del myApiRest.war para los que quieran seguir el post, se encuentra en la siguiente dirección de dropbox:


    La evolución del myApiRest.war la realizaremos en GitHub

    Comencemos:

    Tomamos el war de myApiRest.war y lo importamos en el eclipse, como un nuevo proyecto maven:


    Además ejecutamos, run > maven install que nos trae las dependencias y complica el proyecto.






    Observemos el pom.xml que contiene el plugin de Tomcat, con lo cual, vamos a ejecutar el war y realizar algunas invocaciones:


    org.apache.tomcat.maven
    tomcat7-maven-plugin
    2.2



    Para probar el proyecto, agregamos una nueva configuración al eclipse, equivalente a:

    mvm tomcat7:run



    Lo cual nos permitirá consumir algunas URL del WAR, después de ejecutar el tomcat7:run que configuramos






    Podemos hacer lo mismo para utilizar Jetty en vez del Tomcat.


    org.eclipse.jetty
    jetty-maven-plugin
    9.3.7.v20160115


    10

    /myApiRest


    8080





    Ok, con jetty levantado, también podemos invocar  a las url anteriores.

    En esta primera versión, tenemos el ejemplo funcionando, con spring MVC, un interceptor, y además está swagger incorporado al proyecto.

    Probando el WAR

    Invocamos a uno de los controladores de spring

    http://localhost:8080/myApiRest/javaBookManager/

    Observamos en el log, que el controlador responde, además que el interceptor también lo captura.

    El error que muestra es recién en la respuesta, porque intentamos retornar una respuesta JSON y nos falta incluir a jackson al proyecto



    Las dependencias a agregar al pom.xml son las siguientes:
        
    com.fasterxml.jackson.core
    jackson-core
    2.2.3


    com.fasterxml.jackson.core
    jackson-databind
    2.2.3


    com.fasterxml.jackson.core
    jackson-annotations
    2.2.3


    Y vemos el resultado, donde se recupera el JSON, a su vez, en el log podemos ver al interceptor trabajando:




    Clases Java - Controller y @ResponseBody

    Si bien el ejercicio completo está en GitHub en:


    Vamos a mencionar un par de componentes Java: Observemos el  @ResponseBody para convertir las respuestas a JSON

       

    package com.javaen.web;

    import java.util.Collection;

    import javax.servlet.http.HttpServletResponse;

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.HttpStatus;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.ResponseStatus;

    import com.javaen.business.BookManagerService;
    import com.javaen.domain.JavaBook;


    /**
    * @author [Pablo Ezequiel]
    *
    * REST API Book Manager
    *
    * - getAll
    * - {id}
    * - update (string, book)
    * - add()
    *
    * http://localhost:8080/myApiRest/javaBookManager/
    * http://localhost:8080/myApiRest/javaBookManager/001
    *
    * http://localhost:8080/myApiRest/swagger-ui/index.html
    */

    @Controller
    @RequestMapping("/javaBookManager")
    public class BookManagerController {

    static final Logger LOG = LoggerFactory.getLogger(BookManagerController.class);

    @Autowired BookManagerService bookManagerService;

    @RequestMapping(value="/{id}",method=RequestMethod.GET)
    public @ResponseBody JavaBook get(@PathVariable String id) {

    LOG.debug("BookManagerController::get("+id+")");

    JavaBook book = bookManagerService.get(id);

    LOG.debug("Book("+id+"): " + book);

    return book;
    }


    @RequestMapping(method=RequestMethod.GET)
    public @ResponseBody Collection select() {
    LOG.debug("BookManagerController::getAll()");

    Collection books = bookManagerService.getAll();

    LOG.debug("BookManagerController select(): " + books);

    return books;
    }

    @RequestMapping(value="/{id}",method=RequestMethod.PUT)
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void update(@PathVariable String id, @RequestBody JavaBook book) {

    LOG.debug("BookManagerController::update("+id+","+book+")");

    book.setId(id);
    bookManagerService.update(id, book);
    }


    @RequestMapping(method=RequestMethod.POST)
    @ResponseStatus(HttpStatus.CREATED)
    public void add(@RequestBody JavaBook book, HttpServletResponse response) {

    LOG.debug("BookManagerController::add("+book+")");

    bookManagerService.add(book);
    }

    }



    Con esto damos finalizado el ejercicio de un proyecto con Spring MVC para una hacer una API REST

    Se deja el siguiente TAG en GitHub para el que le interese recuperar el estado de esta versión:

    https://github.com/PabloEzequiel/Java/releases/tag/v1.0.1


    En un próximo post, el objetivo será que swagger levante la info de la API Rest para documentarla.


    Un poco de Feedback


    • ¿Pudieron hacer funcionar el ejemplo?



    Labels: , , , , ,

    Thursday, September 3, 2015

    Como importar un proyecto de GitHub al Eclipse

    Importar los proyectos de GitHub al Eclipse resulta muy sencillo, y existen muchas alternativas.

    Una de las mas comunes es hacer un download zip del repositorio. Para luego importarlo en el eclipse.

    Otra opción cómoda cuando hablamos de proyectos Java es utilizar el Eclipse, sobre todo si ya disponemos del plugin del Eclipse eGit. 

    El plugin de Eclipse eGit se puede descargar desde la página oficial, o bien agregar al eclipse a través de Help > Eclipse Marketplatce. Aunque lo más probable es que la distribución de eclipse que estén utilizando ya venga con un plugin de Git incorporado.



    Descargando de GitHub un Proyecto Java con Eclipse

    Utilizaremos como ejemplo el repositorio:



    Luego desde el Eclipse: File > Import > Git  > Project From Git


    Presionamos Next y luego Clone URL:








    Pegamos la URL

    https://github.com/PabloEzequiel/Javaen.blogspot.com.git


    y luego master:


    y elegimos el directorio donde se bajar el proyecto, que en nuestro caso es:

    C:\javaen\desa\Javaen01


    Presionamos Next:


    Presionamos Next:


    Y finalmente tenemos nuestro proyecto Java



    Como pudimos ver, en GitHub es muy sencilla tanto la subida de proyectos como bajar nuestros los proyectos que nos interesa









    GitHub



    Un Poco de Feedback

    • ¿Pudieron seguir los paso?
    • ¿Que proyectos están compartiendo en GitHub?

    Url Abreviada

    • Si te resulto interesante, puedes compartirlo




    Labels: , ,

    Tuesday, September 1, 2015

    Como subir un proyecto a GitHub con Eclipse

    El proceso para subir un proyecto Java con el eclipse a GitHub es sencillo, y nos permitirá además de compartir nuestro código, tenerlo disponible en la nube para posteriormente poder descargarlo a cualquier lugar.

    En este sencillo tutorial, utilizamos

    • Eclipse Mars
    • Plugin de Eclipse eGit
    • Nuestra cuenta de GitHub

    El plugin de Eclipse eGit se puede descargar desde la página oficial, o bien agregar al eclipse a través de Help > Eclipse Marketplatce. Aunque lo más probable es que la distribución de eclipse que estén utilizando ya venga con un plugin de Git incorporado.


    Necesitamos también una cuenta en GitHub a continuación compartimos la de Javaen.blogspot.com donde hemos creado un nuevo repositorio para le ejemplo:



    Comencemos creando con el Eclipse un proyecto Java Nuevo...







    ... con la típica clase de "Hola Mundo": 



    Y lo conectamos primero a un repositorio local de Git, a diferencia de la conexión a GitHub que es un repositorio remoto.

    El plugin del eclipse se encargará de crear este repositorio local de Git

    Elegimos Team > Share Project dentro del eclipse:



    Y hacemos Team > Commit



    Agregando una descripción por el cambio:



    Luego, hacemos el push para subir los cambios al directorio remoto de GitHub

    Elegimos: Team > Remote > Push



    Y en la URL indicamos el de nuestro repositorio de GitHub

    En nuestro caso es: https://github.com/PabloEzequiel/Javaen.blogspot.com.git

    Y también debemos ingresar nuestro usuario y password de nuestra cuenta de GitHub

    El plugin luego se encarga de completar el resto de los campos.


    Observemos las selecciones a continuación:


    Y presionando Finish, el proyecto se sube a GitHub


    Esta acción la podemos verificar en la siguiente imagen donde están los fuentes publicados:




     Estos son todos los pasos, y en el próximo post veremos el camino inverso: como bajar un proyecto de GitHub el cual es mucho mas sencillo.





    Links Externos

    Quizás te interese saber como puedes subir un proyecto a GitHub con el potente editor Sublime Text 3 y el plugin SublimeGit:

    GitHub

    Un Poco de Feedback


    • ¿Pudieron completar el ejercicio?
    • ¿Tuvieron alguna dificultad?
    • ¿Ya están utilizando GitHub?
    • ¿Que otros IDE además del Eclipse utilizan?

    Url Abreviada


    Si te gustó o te pareció útil, puedes compartirlo en tus redes sociales






    Labels: , ,

    Saturday, July 4, 2015

    ¿Como es un proyecto simple de SpringMVC en Eclipse con Maven y Tomcat?

    Veamos como podemos armar el proyecto mas simple posible de Spring MVC utilizando Eclipse, Maven y Tomcat.


    Versiones:

    • Eclipse (Eclipse Luna 4.4.1)
    • Maven (Apache Maven 3.3.3)
    • Tomcat (Apache Tomcat 7.0.62)
    • Java (jdk1.8.0_20)
    • Spring MVC (4.1.1.RELEASE)


    Paso 01: Creamos un Dynamic Web Project


    En Eclipse Luna creamos un nuevo proyecto web de la siguiente manera:



     
    Utilizamos para el proyecto el nombre enSpringMVC_v001 y presionamos el botón “Finish”



    Paso 02: Convertimos al Proyecto Web un Proyecto Maven


    En eclipse esto se logra con un click derecho sobre el proyecto y eligiendo: Project > Configure > Convert to Maven Project





    Nos muestra la siguiente pantalla, que está Ok, con lo cual no modificamos ningún valor:





    Luego, una vez creado el pom.xml le vamos a agregar dependencias:




    Podremos agregar dependencias en el pom.xml presionando el botón “Add...





    Las dependencias que buscaremos incorporar son las siguientes:


    • Spring Framework: versión 4.1.1.RELEASE
    • Servlet JSTL: versión 1.2
    • Log con Logback: versión 1.0.13








    En el pom.xml sería como sigue, Igual dejaremos que el eclipse sea quien edite el pom.xml


    Para Spring Framework: versión 4.1.1.RELEASE


     1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
            <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>4.1.1.RELEASE</version>
    </dependency>


    Para Servlet JSTL: versión 1.2

    1
    2
    3
    4
    5
            <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
    </dependency>

    Para Log con Logback: versión 1.0.13

    1
    2
    3
    4
    5
            <dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.0.13</version>
    </dependency>

    Comenzamos agregando las dependencias con el Eclipse:

    Primero Spring Framework: versión 4.1.1.RELEASE




    Y seguimos agregando las dependencias anteriormente mencionadas hasta que llegamos a la última:


    Dependencia Log con Logback: versión 1.0.13





    El pom.xml que nos genera el eclipse queda de la siguiente manera:

     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
    <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>enSpringMVC_v01</groupId>
    <artifactId>enSpringMVC_v01</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <build>
    <sourceDirectory>src</sourceDirectory>
    <plugins>
    <plugin>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.4</version>
    <configuration>
    <warSourceDirectory>WebContent</warSourceDirectory>
    <failOnMissingWebXml>false</failOnMissingWebXml>
    </configuration>
    </plugin>
    <plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.3</version>
    <configuration>
    <source>1.8</source>
    <target>1.8</target>
    </configuration>
    </plugin>
    </plugins>
    </build>
    <dependencies>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>4.1.1.RELEASE</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>4.1.1.RELEASE</version>
    </dependency>

    <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
    </dependency>

    <dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.0.13</version>
    </dependency>
    </dependencies>
    </project>

    Paso 03: Agregamos el archivo XML de beans de Spring 


    Creamos el archivo XML para definir los beans de spring. Por convención (convention over configuration) tenemos que nombrarlo  javaen-servlet.xml para que spring lo encuentre dentro del WEB-INF:


    LA convención se debe a que en el web.xml utilizamos el nombre del servlet de spring javaen
    <servlet-name>javaen</servlet-name>


    Desde el eclipse > New XML File




    Lo creamos vacío presionando Finish y hacemos copy&paste de este sencillo xml:

     1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    <?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"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <context:component-scan base-package="com.javaen.controller" />

    <bean id="viewResolver"
    class="org.springframework.web.servlet.view.UrlBasedViewResolver">
    <property name="viewClass"
    value="org.springframework.web.servlet.view.JstlView" />
    <property name="prefix" value="/WEB-INF/jsp/" />
    <property name="suffix" value=".jsp" />
    </bean>
    </beans>


    Como se puede observar, ya estamos definiendo dónde vamos a dejar los Controller de Spring, o sea dentro del paquete com.javaen.controller


    Y también donde vamos a dejar las “vistas”, o sea las páginas JSP que alojaremos dentro del directorio /WEB-INF/jsp/







    Paso 04: Agregamos el web.xml al proyecto web


    A continuación, generamos el web.xml si no está en nuestro proyecto. En nuestro caso, no está con lo cual lo tuvimos que agregarlo:


    Hacemos click con el botón derecho del mouse sobre nuestro Proyecto y elegimos:


    Java EE Tools > Generate Deployment Descriptor Stub





    Editamos al web.xml para agregar al DispatchServlet de Spring

     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
    <?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"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">
    <display-name>enSpringMVC_v01</display-name>

    <servlet>
    <servlet-name>javaen</servlet-name>
    <servlet-class>
    org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
    <servlet-name>javaen</servlet-name>
    <url-pattern>*.htm</url-pattern>
    </servlet-mapping>


    <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    </web-app>





    Paso 05: Creamos nuestro primer Controller de Spring






    Y después de presionar el botón Finish obtenemos nuestra clase Java sobre la cual copiaremos el siguiente código que define el controller de Spring con sus anotaciones:


    HelloController.java


     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
    package com.javaen.controller;

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

    /**
    * @author [Pablo Ezequiel]
    *
    */
    @Controller
    public class HelloController {

    @RequestMapping("/helloController")
    public ModelAndView helloController() {

    String message = "<br>"
    +"<div style='text-align:center;'>"
    +"<h2>Hola Mundo Spring MVC!</h2>"
    +"Mensaje del Controller de Spring"
    +"</div><br><br>";

    return new ModelAndView("respuesta", "message", message);
    }
    }


    Compartimos a continuación la imagen de la clase HelloController en el eclipse





    A continuación crearemos las páginas JSP

    Paso 06: Creamos las vistas en páginas JSP



    Vamos a crear a dos páginas JSP:


    • index.jsp Una para dar la bienvenida
    • respuesta.jsp para ser accedida a través del controller de Spring MVC


    Contenido de la página index.jsp de bienvenida:


     1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    <%@ 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>Hola Spring MVC</title>
    </head>
    <body>

    <br>Primera aplicación con Spring MVC
    <br>
    <a href="helloController.htm">Click para un nuevo mensaje de bienvenida</a>
    </body>
    </html>




    Creación de la página respuesta.jsp en el directorio WEB-INF/jsp para alojar las vistas:


     1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    <%@ 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>Hola Spring MVC</title>
    </head>
    <body>

    Hola! Soy la respuesta con el Mensaje desde el controller:
    <br>
    ${message}

    </body>
    </html>

    Veamos las pantallas en el Eclipse:




    Paso 07: Revisamos la estructura del proyecto

    La estructura del proyecto debería verse de la siguiente manera:

    Resaltamos con el marcado amarillo a los componentes mas importantes:





    Paso 08: Agregamos el proyecto web al Tomcat


    Con el botón derecho sobre el servidor Tomcat nos aparece el diálogo que nos permite agregar a nuestra aplicación web al Tomcat con “Add and Remove …”



    A continuación podemos iniciar el servidor web Tomcat habilitando a nuestro proyecto enSpringMVC_v001 a brindar servicio:





    Con el Tomcat levantado, accedemos a la URL donde nuestro proyecto enSpringMVC_v001 está escuchando:







    Y ahora:





    Referencias:

    El artículo estuvo basado en el tutorial http://crunfy.me/1FI1eHD  del blog de java http://crunchify.com/  


    Descargar el código de GitHub:

    Pueden descargar el código de este ejemplo en el repositorio de GitHub del Blog


    Un poco de Feedback...

    ¿Pudieron seguir todos los pasos?
    ¿De que manera les gustaría ampliar el contenido de este artículo?





    Labels: , , , ,