Java Frameworks & APIs: enero 2012

Tutorial paso a paso para configurar GWT + Spring + Hiberante:

http://www.javacodegeeks.com/2010/05/gwt-2-spring-3-jpa-2-hibernate-35.html
http://www.springbyexample.org/examples/simple-gwt-spring-webapp-spring-js-config.html

Haga clic aqui para descargar una versión del proyecto donde encontraremos Maven + GWT + Spring + hibernate (con @PersistenceContext de JPA sin usar el JPADaoSupport de Spring):

También lo podremos encontrar en google code:

https://code.google.com/p/gwt-spring-hibernate-maven/

Nota: La diferencia es que este es un proyecto que esta en continuo desarrollo, por lo que seguramente si se hacen un checkout no sera la version preliminar que encontraremos si la descargamos aqui

Próximamente el proyecto incluirá: Maven + GWT + Spring + Hibernate.(usando JPADaoSupport de Spring)

Algunos tips de Spring que debemos entender para poder armar un servicio o un DAO:

if you are going to use JpaDaoSupport, use the JpaTemplate methods.
if you want to use EntityManager directly, then inject it via @PersistenceContext, and don't useJpaDaoSupport

Imágenes extraídas del sitio: http://www.slideshare.net/kensipe/spring-3-annotated-development

Configuración mas eficiente de Spring + JPA + Hibernate:

http://www.javacodegeeks.com/2010/05/jboss-42x-spring-3-jpa-hibernate.html

Gwt + Maven - Alternativas para generar un proyecto esqueleto

http://www.uptick.com.au/content/getting-started-gwt-maven-and-eclipse
http://cirovladimir.wordpress.com/2011/08/20/eclipse-indigo-gwt-maven/

Alternativa 1 para generar un proyecto esqueleto con GWT y Maven :

Generar un proyecto esqueleto usando gwt-maven-plugin archetype:

Right-click in the Project Explorer and choose "New -> Project...":
Then choose "Maven -> Maven Project" and click the "Next" button
Choose a Workspace for the new Maven project and then click the "Next" button
Select the "gwt-maven-plugin" archetype from org.codehaus.mojo and and then click the "Next" button
Enter the details (known as the Maven coordinates) for the new project and then click the "Finish" button.
Unfortunately, there are some issues with the project skeleton that is generated

Alternativa 2 para generar un proyecto esqueleto con GWT y Maven :

mvn archetype:generate
-DarchetypeRepository=https://nexus.codehaus.org/content/groups/snapshots-group/

-DarchetypeGroupId=org.codehaus.mojo
-DarchetypeArtifactId=gwt-maven-plugin
-DarchetypeVersion=2.1.1-SNAPSHOT
-DgroupId=au.com.uptick
-DartifactId=MyGwtMavenSampleApp
-Dversion=0.0.1-SNAPSHOT
-Dpackage=au.com.uptick.gwt.maven.sample
-Dmodule=MyGwtMavenSampleApp

Alternativa 3 para generar un proyecto esqueleto con GWT y Maven :

Una forma que no trajo demasiado dolores de cabeza a la hora de crear un projecto GWT con Maven es mediante el webAppCreator que viene al bajarnos la SDK de GWT del sitio oficial.

Para esto vamos a usar la versión 2.1.1 de gwt que es compatible con la JDK 1.5 y maven 2.

Para esto, nos situamos dentro de la SDK de GWT que nos descargamos desde el sitio de google y ejecutamos el siguietne comando:

webAppCreator -maven -out MyGwtMavenSampleApp au.com.uptick.gwt.maven.sample.MyGwtMavenSampleApp

Si miramos el POM que se genera, vemos que tenemos un PLUGIN de gwt para maven llamado MOJO (http://mojo.codehaus.org/gwt-maven-plugin/):

<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>gwt-maven-plugin</artifactId>

<executions>
<execution>
<phase>prepare-package</phase>
<goals>
<goal>compile</goal>
</goals>
</execution>
</executions>

<configuration>

<runTarget>MyGwtMavenSampleApp.html</runTarget>

<hostedWebapp>target/www</hostedWebapp>

<soyc>true</soyc>
</configuration>
</plugin>

ATENCION:

En caso que utilicemos una version inferior o distinta a la SDK 2.4 de GWT vamos a tener que indicarselo a dicho plugin ya que por defecto, viene para dicha version de GWT. Para esto, vamos a modificar la parte del plugin de MOJO del POM de la siguiente manera (como indica en esta parte del sitio de MOJO: http://mojo.codehaus.org/gwt-maven-plugin/user-guide/using-different-gwt-sdk-version.)

<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>gwt-maven-plugin</artifactId>
<dependencies>
<dependency>
<groupId>com.google.gwt</groupId>
<artifactId>gwt-user</artifactId>
<version>${gwtVersion}</version>
</dependency>
<dependency>
<groupId>com.google.gwt</groupId>
<artifactId>gwt-dev</artifactId>
<version>${gwtVersion}</version>
</dependency>
</dependencies>

<executions>
<execution>
<phase>prepare-package</phase>
<goals>
<goal>compile</goal>
</goals>
</execution>
</executions>

<configuration>

<runTarget>MyGwtMavenSampleApp.html</runTarget>

<hostedWebapp>target/www</hostedWebapp>

<soyc>true</soyc>
</configuration>
</plugin>

Continuamos con el ejemplo descargado, vamos a compilarlo, generar el WAR y configurarlo en el Eclipse

Si no descargamos todavía el proyecto, vamos a descargarlo desde aqui y seguir los siguientes pasos

EL POM, modificado con integración entre GWT, Spring, JPA y Hibernate seria el siguiente (es lo mismo que el descargado previamente):

<?xml version="1.0" encoding="UTF-8"?>
<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/maven-v4_0_0.xsd">


<modelVersion>4.0.0</modelVersion>
<groupId>au.com.uptick.gwt.maven.sample</groupId>
<artifactId>MyGwtMavenSampleApp</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>au.com.uptick.gwt.maven.sample.MyGwtMavenSampleApp</name>



<properties>


<gwtVersion>2.1.1</gwtVersion>
<org.springframework.version>3.0.5.RELEASE</org.springframework.version>


<maven.compiler.source>1.5</maven.compiler.source>
<maven.compiler.target>1.5</maven.compiler.target>
</properties>

<dependencies>

<dependency>
<groupId>com.google.gwt</groupId>
<artifactId>gwt-servlet</artifactId>
<version>${gwtVersion}</version>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>com.google.gwt</groupId>
<artifactId>gwt-user</artifactId>
<version>${gwtVersion}</version>
<scope>provided</scope>
</dependency>

<dependency>
<groupId>com.google.gwt</groupId>
<artifactId>gwt-dev</artifactId>
<version>${gwtVersion}</version>
<scope>test</scope>
</dependency>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.4</version>
<scope>test</scope>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${org.springframework.version}</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>${org.springframework.version}</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${org.springframework.version}</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${org.springframework.version}</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework.version}</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${org.springframework.version}</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${org.springframework.version}</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${org.springframework.version}</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${org.springframework.version}</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-oxm</artifactId>
<version>${org.springframework.version}</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${org.springframework.version}</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework.version}</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc-portlet</artifactId>
<version>${org.springframework.version}</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${org.springframework.version}</version>
<scope>test</scope>
</dependency>


<dependency>
<groupId>code.google.com</groupId>
<artifactId>spring4gwt</artifactId>
<version>0.0.1</version>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.16</version>
<scope>compile</scope>
</dependency>



<dependency>
<groupId>com.oracle.driver</groupId>
<artifactId>ojdbc14</artifactId>
<version>14</version>
</dependency>



<dependency>
<groupId>org.hibernate.javax.persistence</groupId>
<artifactId>hibernate-jpa-2.0-api</artifactId>
<version>1.0.1.Final</version>
</dependency>

<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>3.5.2-Final</version>
</dependency>

<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>3.5.2-Final</version>
</dependency>








<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.5.8</version>
</dependency>









</dependencies>

<build>




<outputDirectory>${project.build.directory}/${project.build.finalName}/WEB-INF/classes</outputDirectory>

<plugins>


<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>gwt-maven-plugin</artifactId>
<dependencies>

<dependency>
<groupId>com.google.gwt</groupId>
<artifactId>gwt-user</artifactId>
<version>${gwtVersion}</version>
</dependency>
<dependency>
<groupId>com.google.gwt</groupId>
<artifactId>gwt-dev</artifactId>
<version>${gwtVersion}</version>
</dependency>
</dependencies>


<executions>
<execution>
<phase>prepare-package</phase>
<goals>
<goal>compile</goal>


</goals>
</execution>
</executions>

<configuration>

<runTarget>MyGwtMavenSampleApp.html</runTarget>


<hostedWebapp>${project.build.directory}/${project.build.finalName}</hostedWebapp>

<soyc>true</soyc>

</configuration>
</plugin>


<plugin>
<artifactId>maven-resources-plugin</artifactId>
<executions>
<execution>
<phase>compile</phase>
<goals>
<goal>copy-resources</goal>
</goals>
<configuration>

<outputDirectory> ${project.build.directory}/${project.build.finalName}</outputDirectory>
<resources>
<resource>
<directory>src/main/webapp</directory>
</resource>
</resources>
</configuration>
</execution>
</executions>
</plugin>


<plugin>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.8</version>
<configuration>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
<wtpversion>2.0</wtpversion>
</configuration>
</plugin>


</plugins>
</build>
</project>

Una vez descargado el proyecto que integra GWT + Spring + Jpa + Hibernate + Maven

Verificamos que sea la correcta versión de Maven y la JDK 1.5

Luego , vamos a generar los siguientes comando de maven para compilar el proyecto, generar los archivos para poder importarlo en el eclipse, y generar el war:

Vemos que esto lo esta arrojando en /tarjet/MyGwtMavenSampleApp-1.0-SNAPSHOT segun lo definido en el POM

...

<outputDirectory>${project.build.directory}/${project.build.finalName}/WEB-INF/classes</outputDirectory>
...

IMPORTANTE: Al arrojar mvn package o mvn install, siempre nos tendremos que asegurar que se ejecute la compilacion de JavaScript aportado por el plugin de mojo.Ver en la captura que aparece algo que dice compiling 5 permitations...

Para correr la aplicación vamos a ejecutar el archivo: MyGwtMavenSampleApp.launch (este nos arroja un error que lo solucionamos copiando los JARs a WEB-INF/lib mediante el siguiente comando:

mvn dependency:copy-dependencies

y deberiamos agregar esto al POM.xml




<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.1</version>
<configuration>
<outputDirectory>${webInfLibPath}</outputDirectory>
<excludeGroupIds>${pom.groupId}</excludeGroupIds>
<excludeScope>provided</excludeScope>
</configuration>
</plugin>

En caso que querramos que Eclipse tenga integracion con GWT (en este ejemplo, utilizamos esta alternativa) nos tendremos que descargar el plugin
Luego vamos a tener que activar este plugin para el proyecto existente de GWT + Maven (creado anteriormente mediante el webAppCreator):

If you have an existing Maven project in Eclipse and want to enable GPE functionality, follow these steps:
In Eclipse, open your project's properties (Alt+Enter or right-click, Properties)
Under Google | App Engine, select the version of the App Engine SDK you're using. GPE is not yet able to use the version defined in your Maven POM, so you may need to download your SDK version using the Eclipse software updater (see http://code.google.com/eclipse/docs/download.html)
Under Google | Web Toolkit, likewise select the version of the GWT SDK you're using. As with the App Engine SDK, install it via the Eclipse plugin update site if needed.
Under Google | Web Application, check the "This project has a WAR directory" box and point it to your project's src/main/webapp directory. This is the standard WAR source folder for Maven Web projects. Be sure that the "Launch and deploy from this directory" box is NOT checked.
Under Java Build Path, select the Order and Export tab and move all Maven dependencies to the BOTTOM. Otherwise, GPE will see the App Engine and GWT SDKs from the Maven repo on the build path and complain that they are not valid. This is because GPE expects a specific SDK structure used to enable other tooling. Asegurase que en la pestaña “Order and Export” la entrada Maven Dependencies este hasta abajo, de lo contrario te aparecerá un error diciendo “The project … does not have any GWT SDKs on its build path”
Also under Java Build Path, select the Source tab and ensure that the Build output directory is enabled and pointing to target/your-project-name/WEB-INF/classes. If you created the project with mvn eclipse:eclipse, this should be done for you automatically.
Finally, and this is very important, the first time you launch your project using Run As | Web Application (or Debug), you will be prompted to select the war directly. This is NOT src/main/webapp, but rather the WAR output folder, which is target/your-project-name. If you make a mistake, simply go to Run | Run Configurations... and remove any old configurations for the project. GPE will then ask you again next time you try to Run As | Web Application.
Listo, ahora puedes lanzar tu aplicación medainte el plugin del eclipse dando clic derecho en tu proyecto y seleccionando “Debug As -> Web Application”, la primera vez te pedira que selecciones un directorio, asegurate de que sea el directorio “target/www/”. Cuando carga la aplicación en el navegador me muestra el error: “No source code is available for type com.google.gwt.junit.client.GWTTestCase” pero la aplicación funciona correctamente. Esto mismo me pasa cuando le doy “GWT compile” aunque quite el módulo RimelJUnit.xml de la configuración.
Otro error que me tiro cuando armaba el WAR es el siguiente: module may need to be (re)compiled para lo cual encontre la solucion en este link: http://cirovladimir.wordpress.com/tag/gwt-module-may-need-to-be-recompiled/ El tema era que me estaba generando codigo en src/main/webapps que no me deberia generar. Borre la carpeta creada y listo!!

Ver: http://cirovladimir.wordpress.com/2011/08/20/eclipse-indigo-gwt-maven/
Ver: http://www.uptick.com.au/content/getting-started-gwt-maven-and-eclipse
Ver: http://googlewebtoolkit.blogspot.com/2010/08/how-to-use-google-plugin-for-eclipse.html

Esto generara todo el esqueleto, donde luego vamos a tener que importarlo al ecilpse como un proyecto maven existente. Nos quedara de la siguiente forma:

Luego lanzamos la aplicacion haciendo clic derecho sobre el proyecto => run as => web applicaton y la primera vez vamos a tener q seleccionar el proyecto compilardo)

Y listo!.

Luego podemos generar el WAR mediante el mvn clean install

y luego podemos deployarlo directamente en el TOMCAT:

Antes que anda le cambiamos el puerto donde escuachara en tomcat/conf/server.xml

....
....


<Connector port="8081" maxHttpHeaderSize="8192"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
connectionTimeout="20000" disableUploadTimeout="true" />
<!-- Note : To disable connection timeouts, set connectionTimeout value
....
....

Luego agregamos dos nuevos roles y un nuevo usuario que tenga dichos roles para poder entrar a la parte de la adminstracion para deployar.
Para esto vamos a tomcat/conf/tomcat-users.xml

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
<role rolename="tomcat"/>
<role rolename="role1"/>
<role rolename="manager"/>
<role rolename="admin"/>
<user username="tomcat" password="tomcat" roles="tomcat"/>
<user username="both" password="tomcat" roles="tomcat,role1"/>
<user username="role1" password="tomcat" roles="role1"/>
<user username="admin" password="admin" roles="manager,admin"/>
</tomcat-users>

y luego iniciamos el tomcat y entramos al manager:

Vemos que la app quedo deployada sin problemas. Hacemos clic sobre al app y se nos abrira un browser con la app.

Espero que se haya entendido.

Java Frameworks & APIs

viernes, 13 de enero de 2012

GWT - GWT + Spring + JPA + Hiberante