sábado, 4 de julio de 2015

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

18:14Eclipse, java, Maven, SpringMVC, tomcat71 comment

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

        <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

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

Para Log con Logback: versión 1.0.13

        <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:

<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:

<?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

<?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

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:

<%@ 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:

<%@ 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:

http://localhost:8080/enSpringMVC_v01/

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

https://github.com/PabloEzequiel/Java

Un poco de Feedback...

¿Pudieron seguir todos los pasos?

¿De que manera les gustaría ampliar el contenido de este artículo?

¿Como hacer debug remoto con el Tomcat y el Eclipse?

20:00Eclipse, FAQ, java, tomcat7No comments

¿Como iniciar el Tomcat 7 en modo debug?

En windows primero tienen que estar seteadas las variables:

set JPDA_ADDRESS=8000
set JPDA_TRANSPORT=dt_socket

Luego vamos al directorio "bin" del tomcat y ejectamos

%TOMCAT_HOME%/bin/catalina.bat jpda start

En UNIX, es como siguie, exportando las variables:

export JPDA_ADDRESS=8000
export JPDA_TRANSPORT=dt_socket

Y para iniciar al tomcat en modo debug ejecutamos:

%TOMCAT_HOME%/bin/catalina.sh jpda start

¿Como hacer debug remoto con el Eclipse?

Para hacer debug remoto de un proyecto es necesario que el Tomcat esté levantado en modo debug.

En la primera parte del post, ya explicamos como se levanta el tomcat en modo debug.

En esta segunda parte vamos a ver los paso que tenemos que hacer en el eclipse

1. En el eclipse vamos a Run > Debug Configuration

2. Seleccionamos Remote Java Application y New

3. Completamos los datos seleccionando a nuestro proyecto java. El puerto 8000 es el puerto default para debug Remoto:

4. Y en la pestaña Source tenemos que vincular los fuentes: A través del botón Add... accedemos a las opciones:

5. Cuando aceptamos todo y si está el Tomcat levantado, va a intentar establecer la conexión para permitirnos hacer el debug remoto:

6. En la perspectiva del Debug podemos ver que la conexión quedo establecida en el puerto 8000 Y también tenemos la opción de desconectar la aplicación a través del botón de Debug:

A continuación podremos agregar breakpoints en métodos de nuestro código fuente, que al ser invocados en tiempo de ejecución nos permitirá hacer el típico trabajo de debug.

Un poco de Feedback

¿Pudieron lograr conectarse al Tomcat en modo debug?
¿Habría que analizar algún punto mas?

Como cambiar el @author en eclipse

22:00EclipseNo comments

Para cambiar el @author en eclipse

Abrimos Eclipse Preferences, en el filtro de Templates seleccionamos Java->Code Style->Code Templates

Editamos el “Pattern”

Y a partir de ahora cuando creamos una nueva clase cambia el @author de la misma:

Con esa misma estrategia podemos cambiar otros atributos en el eclipse.

¿Como agregamos el Spring Tool Suite (STS) al eclipse?

15:42Eclipse, java, Spring Tool Suite (STS)No comments

En Help > Eclipse Marketplace buscamos "Spring Tool Suite (STS) for Eclipse"

Presionamos el boton de Install:

Aceptamos TyC y comienza a instalar. Después solicita un restar del eclipse luna:

Tenemos que reiniciar el eclipse:

Luego de reiniciar tenemos el STS instalado sobre el Eclipse:

Y trabajamos con el STS:

A veces hay una sutil diferencia y esta forma de obtener el STS puede ser preferible a descargar el STS directamente.

Como crear un proyecto web con Maven y STS (Spring Tool Suite)

19:12Maven, Spring Tool Suite (STS), tomcat7No comments

Para crear un proyecto web Maven con STS:

Luego:

A continuación:

Seguimos con:
com.javame
myApiRest

Tenemos el pom.xml generado a partir del arquetipo:

Agregamos los fuentes java:

Y también la dependencia de servlet y el plugin del tomcat:

 <!-- Servlet Library -->
 <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
 </dependency>

 <plugins>
     <plugin>
         <groupId>org.apache.tomcat.maven</groupId>
         <artifactId>tomcat7-maven-plugin</artifactId>
         <version>2.2</version>
     </plugin>
 </plugins>

Agrgamos la configuracion para ejecutar el tomcat:

Nueva

Valores:
Run configuration
Browse worspace
goal: tomcat:run -X

Luego Apply & Run

Y la aplicación queda levantada en:

http://localhost:8080/myApiRest

Para detener el Tomcat simplemente hacemos uso del botón stop.

Un poco de Feedback...

¿Les funcionó?
¿Pudieron armar su proyecto con Maven, Tomcat7 y STS?

¿Como instalar nuestra aplicación en Tomcat7 con Maven y STS?

20:00Maven, Spring Tool Suite (STS), tomcat7No comments

¿Como hacer el deploy en Tomcat7 con Maven y STS?

En el caso que utilicemos una instancia de tomcat separada del STS, podemos instalar el war de nuestra aplicación web de la siguiente manera

Primero en el POM.XML tenemos que tener el plugin del tomcat7-maven-plugin

<plugins>

 <plugin>
  <groupId>org.apache.tomcat.maven</groupId>
  <artifactId>tomcat7-maven-plugin</artifactId>
  <version>2.2</version>
  <configuration>

   <server>localhost</server>
   <url>http://localhost:8080/manager/text</url>
   <path>/myAPP</path>
   <port>8080</port>
   <username>admin</username>
      <password>admin</password>
   <warFile>target\myAPP-1.0.war</warFile>
   <update>false</update>
  </configuration>
 </plugin>

</plugins>

En el tomcat7 tenemos que tener habilitado los perfiles del administrador:


c:\apache-tomcat-7.0.62\conf\tomcat-users.xml

<tomcat-users>  

  <role rolename="manager-gui"/>
  <role rolename="admin-gui"/>
  <role rolename="manager-script"/>
  <role rolename="manager"/>
  <user username="admin" password="admin" roles="admin-gui,admin,manager,manager-gui,manager-script,manager-jmx,manager-status"/>

</tomcat-users>

Luego Levantamos el tomcat7:


cd c:\apache-tomcat-7.0.62\bin\



catalina run

Podemos hacer el deploy del war activando la regla del pom.xml


mvn tomcat7:deploy

Integrando STS (Spring Tool Suite) con el CVS

20:30CVS, Spring Tool Suite (STS)No comments

El STS (Spring Tool Suite) trae integrado el soporte par Git, pero en caso que necesitemos otro controlador de versiones como el antiguo CVS tenemos que recurrir a la instalación de un plugin.

Uno de los plugin mas populares que nos permitirá conectarnos al CVS es es Eclipse CVS Client, veamos como sería la instalación de este plugin en IDE Spring Tool Suite

Los pasos son:

Help > Install New Software ..

Elegimos Eclipse CVS Client

Continuar:

Después de reiniciar al STS observamos que tenemos disponible la perspectiva del CVS

Reiniciamos al STS (Spring Tool Suite) para ver la integración con el CVS

Y podemos subir el proyecto al CVS:

sábado, 4 de julio de 2015

Paso 01: Creamos un Dynamic Web Project

Paso 02: Convertimos al Proyecto Web un Proyecto Maven

Paso 03: Agregamos el archivo XML de beans de Spring

Paso 04: Agregamos el web.xml al proyecto web

Paso 05: Creamos nuestro primer Controller de Spring

Paso 06: Creamos las vistas en páginas JSP

Paso 07: Revisamos la estructura del proyecto

Paso 08: Agregamos el proyecto web al Tomcat

Referencias:

Descargar el código de GitHub:

Un poco de Feedback...

miércoles, 1 de julio de 2015

¿Como iniciar el Tomcat 7 en modo debug?

¿Como hacer debug remoto con el Eclipse?

Un poco de Feedback

domingo, 28 de junio de 2015

sábado, 27 de junio de 2015

viernes, 26 de junio de 2015

Un poco de Feedback...

miércoles, 24 de junio de 2015

¿Como hacer el deploy en Tomcat7 con Maven y STS?

lunes, 22 de junio de 2015

Help > Install New Software ..

Publicidad

Archivo del Blog

Buscar en iOS en.blogspot.com

Etiquetas

Archivo del Blog

Paginas

Labels

LOGOS