diciembre 07, 2011

Working GAE-Java projects on Netbeans IDE



Recuerde que..
Este blog esta desarrollado en idioma español pero utilizando Google Traductor puede adecuarlo al lenguaje de su preferencia.. Favor utilice la opcion del recuadro superior derecho... y Bienvenido a Integracion Google.

Continuando con nuestras investigaciones y pruebas de tecnologías Web vigentes, volvemos ahora con Google App Engine (GAE), pero en esta oportunidad utilizando el entorno de desarrollo Java (correspondiente a utilizar el SDK de Google App Engine para Java versión 1.6.0 vigente al 15/12/2011); y este es el primero de una saga de 03 codelabs en que trabajaremos proyectos GAE-Java utilizando la herramienta de desarrollo Netbeans IDE, en virtud a sus bondades y facilidades proporcionadas para el manejo de este entorno, que ya hemos utilizado en nuestros codelabs referentes al manejo del Back-End Java(JSP)+MySQL y para la instalación del proyecto sdSimple, ...y si han seguido y desarrollado dichos codelabs, pues creemos que deben haber observado las ventajas de trabajar con Netbeans IDE en nuestros proyectos JavaWeb, y de manejo de servidores de aplicaciones y contenedores de servlets como Tomcat ó Glassfish (que utilizamos incluso para trabajar con PHP en dicha plataforma mediante Quercus), y en esta oportunidad, vamos a integrar a la plataforma de desarrollo de Appengine, y del servidor  Jetty que es un servidor HTTP contenedor de servlets 100% basado en Java, y que son utilizados por Google App Engine para integrar el lenguaje Java en su infraestructura de desarrollo.


PREPARANDO NUESTRO ENTORNO DE DESARROLLO.

Existen hasta 04 formas para trabajar con proyectos GAE-Java, y que podemos resumir en:

  • Utilizando ANT, que es una herramienta opensource que nos permite facilitar el proceso de creación, compilación, configuración del despliegue y lanzamiento de nuestros proyectos Java y  JavaWeb en un servidor de aplicaciones ó contenedor de servlets que trabaje con Google App Engine, como el servidor Jetty que viene incluído en el SDK para Java.

    ANT se puede descargar de http://ant.apache.org, y es quizá una de las formas mas difundidas de trabajo en proyectos Java ..y es que con un formato de directorios ya estandarizado, (las conocidas carpetas WAR y SRC), y mediante el archivo "build.xml" (donde indicamos las etiquetas que conforman las diversas tareas de nuestro proceso de formación e nuestros proyectos y sus dependencias entre ellos), disponiendo así  de todas las instrucciones necesarias para construir y desplegar nuestros proyectos, y sobre cualquier sistema operativo (lo que no se puede hacer utilizando scripts o archivos *.bat), y dependiendo de nuestra modalidad de trabajo, pues casi siempre con un mismo archivo "build.xml", y con pocas modificaciones referidos a los datos específicos de cada proyecto, lo podemos adecuar para trabajar en todos nuestros proyectos Java, y en el caso de los proyectos GAE-Java, dicha manera se mantiene, adecuando por supuesto, nuestro código a los requerimientos, necesarios para poner en funcionamiento un proyecto GAE-Java en nuestro servidor local de pruebas; y luego, para poderlos desplegar sobre la infraestructura de Google, como si se tratase de un servicio de hosting externo. Todo ello por supuesto, trabajando desde nuestra ventana de comandos, sobre Windows, Linux ó MAC-Apple, pues como ya debiéramos tener presente, Java es un lenguaje multiplataforma y corre sin problemas en cualquier sistema operativo.

    Para correr con ANT nuestros proyectos Java, JavaWeb y GAE-Java, después de haber descargado ANT desde la ruta indicada, debemos ubicarnos en la carpeta de nuestro proyecto donde se encuentra el archivo "build.xml" y correr la instrucción:
      %path-ANT%/bin/ANT runserver (enter), donde "runserver" es el nombre la etiqueta de nuestro archivo build.xml que ejecuta nuestro proyecto con el comando "dev_appserver" del SDK para Java de Google App Engine, y que usualmente depende de otras etiquetas necesarias para la construcción y ejecución de nuestro proyecto las que podemos revisar con detalla al abrir el archivo build.xml con nuestro editor de preferencia.
  • Utilizando los comandos proporcionados por el mismo SDK para Java, para cual solo es necesario que nuestro proyecto se encuentre correctamente configurado y construido (pudiendo utilizar ANT para ello), y luego utilizando el comando :
      (%path_sdk%)/bin/dev_appserver.cmd (%path_war%), se procederá con el lanzamiento de nuestros proyectos a nuestro servidor local de pruebas, y por supuesto, de manera similar podemos lanzar nuestro proyecto a la infraestructura de Google una vez probados y aprobados  nuestros proyectos. El SDK de Java los podemos descargar de la pagina oficial de Google de la siguiente dirección: http://code.google.com/intl/en/appengine/downloads.html, y es uno de los componentes básicos del entorno GAE-Java porque ademas de contener las clases que permiten nos permiten trabajar con el datastore "big table" de Google, entre otras herramientas para trabajar en dicho entorno, pues contiene al servidor local Appengine que nos permite realizar nuestras pruebas (el servidor Jetty como hemos indicado)
  • Utilizado el IDE Eclipse, para lo cual Google ha lanzado un plug-in oficial para trabajar nuestros proyectos GAE-Java sobre dicha plataforma de desarrollo, y que tiene como principal ventaja y desventaja, que "automatiza" algunos procesos de configuración de nuestros proyectos, y muchas veces creemos que es mejor que observemos y tengamos un mejor control de todos los procesos y componente de nuestros proyectos para mantener un desarrollo más limpio y eficiente (los codelabs de Google App Engine presentados en la pagina oficial de Google como el Developer Codelabs y el propio tutorial contenido en la documentación referidos a GAE-Java, se muestran utilizando esta herramienta, por lo que pueden revisarlos si les resulta conveniente).
  • y por supuesto, utilizando Netbeans IDE, el cual a nuestro criterio presenta algunas ventajas no solo tal vez porque ya los estemos utilizando en nuestros proyectos Java, sino que para los procesos de detección y solución de errores, y depuración, optimización y refactoring, Netbeans es bastante amigable, intuitivo y eficiente como tal vez ya lo hayan podido comprobar.. y por supuesto con Netbeans también se podemos automatizar todo el proceso construcción y lanzamiento de nuestros proyectos GAE-Java a nuestro servidor local de pruebas (sin tener que recurrir a digitar comandos), y también realiza el despliegue de nuestros proyectos en la infraestructura "cloud" de Google App Engine (que por supuesto requiere que previamente hayamos registrado nuestra cuenta Google y obtengamos una cuenta Appengine, y que registremos el nombre de nuestra aplicación y dominio propio, siendo éste último solo si lo estimasemos necesario.. Google nos provee un subdominio "appspot.com" que incluso lo podríamos utilizar en forma permanente).

No es nuestro objetivo en estos momentos comparar ni calificar las ventajas o desventajas de cada método de trabajo, menos comparar plataformas de desarrollo como GAE-Phyton y GAE-Go con GAE-Java; si no por el contrario, mostrar que todos estos procesos pueden de alguna manera complementarse y que es necesario conocer su funcionamiento para tener un completo concepto del funcionamiento de la plataforma de desarrollo Appengine y GAE-Java en particular, y así poder manejar todos sus detalles y componentes, más aún cuando como hemos indicado al principio, éste codelab es la antesala de otros dos en que presentaremos (además de trabajar con Java y el datastore "big table" de Google App Engine (que corresponde a éste codelab), a como trabajar con Java y PHP sobre esta misma plataforma usando Quercus (que ya hemos utilizado para trabajar con PHP en nuestros proyectos Java Web); e incluso para trabajar con Java y PHP sobre Google Cloud SQL, que es una implementación de la base de datos relacional MySQL sobre la infraestructura cloud de Google, que junto a la implementación del lenguaje Go para Google App Engine, corresponden a lo últimos desarrollos lanzados por Google para Appengine.
En todos estos casos vamos a trabajar con Netbeans IDE como herramienta de desarrollo para mantener un estándar de trabajo..así que sin mayores preámbulos empecemos con nuestro codelab...


PREPARANDO NETBEANS PARA TRABAJAR PROYECTOS GAE-JAVA

Recomendamos trabajar con Netbeans versión 7 en lugar de las versiones anteriores por el hecho que sus scanning son más rápidos y amigables que sus predecesoras de la versión 6.9 y anteriores, y en lo respecta para trabajar GAE-Java, pues también cabe resaltar que, en este tipo de proyectos debe indicarse, antes de lanzarlos a nuestro servidor local de pruebas, cual es nuestro "Main project" ...ello porque en GAE-Java, nuestros proyectos excepto los configuremos adecuadamente, serán lanzados por un mismo puerto, el 8080 por defecto, y para poder "cerrar" uno y "abrir" otro, además de cerrar nuestro servidor local de pruebas, deberá establecerse que proyecto desplegaremos al servidor, y en Netbeans 7, el IDE nos indica también de manera más amigable si nuestro proyecto ya ha sido seleccionado..

NOTAS IMPORTANTES :

  1. Al instalarse Netbeans 7, se nos indicará durante el proceso si queremos cargar los proyectos JavaWeb desplegados en versiones anteriores (que no son necesario desinstalar), y estos serán agregados a los proyectos de nuestro IDE instalado.. ahora también se nos solicitará que indiquemos si requerimos instalar las ultimas versiones de los servidores Apache Tomcat y Glassfish, los que podremos instalar a nuestro requerimiento, en una carpeta adecuada para nuestro caso, y que durante su instalación, Netbeans IDE efectuará las configuraciones necesarias para evitar conflictos de puertos entre ellos, no siendo tampoco necesario desinstalar los servidores de Aplicaciones u otros contenedores de servlets que tengamos instalados.
  2. Para el caso que nuestro proyecto haya sido lanzado a nuestro servidor local de pruebas, y no hayamos cerrado nuestro servidor antes de pasar a otro proyecto, nos conviene tener una herramienta como Java VisualVM, para observar los procesos Java que han sido desplegados, e incluso poder cerrarlos o eliminarlos "manualmente" de presentarse algún contratiempo en nuestra lógica de programación sin necesidad de reiniciar nuestro ordenador. Esta herramienta la podemos descargar de http://visualvm.java.net/download.html. y asimismo, una vez instalada, conviene que le agreguemos el plug-in KillApplication, que viene listo para ser instalado en la opción del menú: Tools, plug-ins lengüeta avaible plug-ins; y con ello en la pantalla de visualización de nuestros procesos Java, y solo haciendo click derecho con el mouse, se mostrará la opción "Kill Application", con lo podremos cerrar nuestros procesos Java facilmente, y sin necesidad de digitar en nuestra pantalla de comandos: Taskkill /pid=nn (donde "nn" es el numero de identificación que nos muestra Java VisualVM).



  1. Si trabajamos con la version 1.7.2 ó superior del SDK para Java de Appengine debemos asegurarnos que en el archivo appengine-web.xml se encuentre el siguiente script:
    <!--
    Allows App Engine to send multiple requests to one instance in parallel:
    -->
    <threadsafe>true</threadsafe>
    Incluso para la muestra "guestbook" que viene con el SDK para Java debemos verificar que se encuentre este script para que funcione correctamente..
  2. Si trabajamos con la version 1.7.3 del SDK para Java de Appemgine debemos asegurarnos que en carpeta WEB-INF-lib se encuentre grabado el archivo appengine-endpoint.jar, y que se encuentre cargado en nuestro proyecto para que el SDK se encuentre completo.

INSTALANDO EL SDK PARA JAVA EN NUESTRO NETBEANS

Debemos ahora cargar el servicio Appengine a nuestro Netbeans, y para ello debemos ir también al menú de Netbeans: Tools, plug-ins, y a la lengüeta Settings; allí no debe aparecer la opción de "Google AppEngine". Esta pantalla corresponde a la pantalla de configuración automática de actualización de los plug-ins de Netbeans, y nuestro plugi-in no aparece por cuanto aún no la hemos instalado ...para ello, elijamos la opción "Add" de esta pantalla para poder agregarlo, pongamosle como nombre "Google Appengine", y en la ruta URL indiquemos :

http://kenai.com/downloads/nbappengine/NetBeans69/updates.xml, que corresponde a la dirección del plug-in del fabricante para la version 6.9 y superior (válida también para Netbeans 7, aunque puede revisar la pagina de kenai.com para mayor verificación.



Aunque realmente vale destacar que Kenai ya no esta brindado un adecuado soporte a su plugin y a las contantes actualizaciones del SDK para Java de Google App Engine, por ello en varias oportunidades estuvimos buscando y revisando varias alternativas, y la mas adecuada que encontramos es la siguiente:


Importante !


from stackOverflow :

it's possible obtain a good plug-in for Netbeans 7.3 and GAE Java SDK v.1.8 from this repository:
https://github.com/Valery-Sh/NbAppEngine

with this plugin, GAE projects like guestbook sample or new personal projects are running very fine..

Method of use:


1. delete completely App Engine server of your Netbeans (I had to reinstall Netbeans to remove the service completely, but there must be a way to do)
2. download plug-in from : https://code.google.com/p/nb-gaelyk-plugin/downloads/detail?name=nbappengine-7.3-gae1.8.x.zip or last plugin versions to any folder..
3. install plug-in : Tools / Plugins / Downloaded
4. verify update of plugins..

latest News:

test on Netbeans 7.3.1 Ok.! (July 2013)


A. Con lo anterior, debemos haber cargado el plug-in Google Appengine de Kenai.com a nuestro Netbeans, y ahora debemos activarlos (en caso hayamos utilizado el plugin Valery-nbappengine, éste no requiere ser activado sino que directamente debemos crear nuestro servidor local como se indica en el parrafo "B" siguiente ), de ser el caso, debemos ir a la lengueta "avaible plug-ins" de la misma pantalla, y seleccionemos todos los plug-ins disponibles para Google App Engine ("server", "configuration", "deployment" y "samples"); si su Netbeans ya hubiese estado preparado para trabajar con "Java Hints", podrá tambien instalar el plug-in "Google App Engine Eitor Hints", pero si no es el caso, no marque esta opción... los plug-ins requeridos mencionados funcionarán sin mayores contratiempos.

B. Con el paso anterior descrito, tenemos los plugins instalados listos para trabajar con Netbeans, pero aún nos falta como debemos crear nuestro servidor local Appengine para nuestras pruebas, y para ello debemos descargar el SDK de Java en una carpeta que podríamos llamar "appengine", en donde también descargaremos los códigos que corresponden a nuestro codelab ...entonces, descargado el SDK de Java, debemos implementar el servidor, y para ello debemos recurrir a la lengüeta "services" de nuestra pantalla principal de Netbeans (al lado de donde se despliegan nuestros proyectos y "Files" de los mismos). Allí debemos hacer click derecho sobre la opción "servers" para poder adicionar uno nuevo, la pantalla a continuación nos indicará que servidores tenemos disponibles para instalar, y debe aparecer "Google App Engine" por cuanto nuestro plug-in ya ha sido instalado..Al seleccionarla, en la parte inferior de la pantalla, se nos permitirá modificar el nombre de nuestro servidor, y conviene que indiquemos la version de nuestro SDK descargado, por ejemplo Appengine SDK 1.6.0 (podremos agregar nuevos servidores Appengine segun las nuevas versiones del SDK disponibles, y no descartar las existentes hasta que hayamos probado completamente nuestros proyectos) ...sigamos entonces las instrucciones de Netbeans y listo.. ya tendremos a nuestro servidor local GAE listo para trabajar...

C. Adicionalmente si queremos probar que todo esta correctamente instalado, en el Menu de Netbeans indiquemos que queremos crear un nuevo proyecto... pero en lugar de seleccionar un proyecto "JavaWeb", vayamos a la opción "ejemplos", allí busquemos el ejemplo de Google App Engine, y la instalación de nuestro plug-in debe ahora permitirnos mostrar la opción Guest Book (que corresponde a un libro de Visitas que Google muestra como ejercicio en su página oficial), siga los pasos e indique que va instalar el proyecto en la carpeta "appengine", donde también descargamos el SDK de Java para mantener nuestros proyectos en un mismo lugar.. y listo, debe crearse el proyecto "guestbook" así que ahora corramos el proyecto y debería desplegarse en nuestro navegador de preferencia...





podemos consultar con nuestro Java VisualVM que nuestro proyecto ha sido desplegado (tiene 03 componentes, el proceso ANT, el proceso de despliegue, y el "debug", cada uno con un numero de proceso diferente), ..y para detener al servidor puede recurrir al botón rojo al lado de la pantalla de salida "output" de Netbeans o cerrar el proceso con "KillApplication" de Java VisualVM, en cualquier caso, si selecciona uno de los procesos desplegados se cerrarán los otros (no cierre el proceso Netbeans pues cerrará al IDE)



Si revisamos las propiedades de nuestro proyecto "guestbook" cargado automáticamente como ejemplo de una aplicación GAE-Java en Netbeans (botón derecho el mouse sobre el nombre de nuestro proyecto), podrán observar que se mantienen las opciones básicas de un proyecto JavaWeb, pero que se nos permite seleccionar/deseleccionar nuestro proyecto como "Main project", y asimismo, que al final de la lista, antes de las propiedades, se encuentra activada la opción "Deploy to Google App Engine" (para lanzar nuestros proyecto directamente a la plataforma cloud de Google); conviene tambien que le demos una revisión a las propiedades de nuestro proyecto, en especial a la pestañas "source" y "run", donde podremos indicar la versión de JDK y codificación que utilizaremos (JDK5 y UTF-8 por defecto) ..y el servidor que utilizaremos para desplegar nuestro proyecto... si tuviesemos varios SDK Java instalados podremos cambiar entre ellos y ver los resultados antes de eliminar alguno de ellos...

Hasta aquí.. ya tenemos nuestro entorno de desarrollo GAE-Java listo para trabajar nuestros propios proyectos con Netbeans en esta plataforma.. pero como hay algunas "inconsistencias" respecto a trabajar con GAE-Java en Netbeans, vamos a detallar paso a paso como cargar nuestro codelab "gae-guestbook" a nuestra plataforma GAE-Java de Netbeans que hemos instalado...


Instalando nuestro codelab "gae-guestbook" en Netbeans IDE

Como se indica, tenemos por supuesto que haber instalado en nuestro ordenador Netbeans y haberlo habilitado para trabajar con un servidor local Appengine, mediante la instalación de los plug-ins necesarios y de nuestro servidor local Appengine de pruebas, como hemos descrito en los pasos anteriores.

Material de Apoyo : 
( do click on blue icons to download )

gae-guestbook.rar, que corresponde a nuestra adaptación del proyecto "guestbook" básico presentado en nuestra instalación del ejemplo de Netbeans, y donde les presentamos como trabajar con tipos de datos string, numéricos, date y user con el datastore de Google App Engine, y presentándolos sobre un "table" HTML, pero a diferencia de todos nuestros codelabs anteriores, nuestro códigos no están contenidos en una carpeta que descargar e importar como un proyecto "JavaWeb con fuentes existentes" directamente sobre Netbeans IDE... es allí donde se comienza lo que podríamos llamar algunas "inconsistencia" en el manejo de proyectos GAE-Java que espero logren adecuar en versiones futuras del IDE, pero que podemos y debemos superar para poder trabajar con Netbeans sin mayores contratiempos.


Nota importante:


en caso estemos trabajando con el plugin Valery-nbappengine y lo utilicemos para crear nuestro servidor GAE-Java utilizando el SDK para Java version 1.8, pues tenemos una grata e importante noticia:
  1. En este caso ya no es necesario crear un proyecto vacio para "sobreescribir sobre ella" las fuentes de nuestra descarga dado que este plugin nos permite crear proyectos GAE-Java sin mayores problemas utilizando su opción: New Project/Java Web/Web Application with existing sources
  2. Asimismo, para desplegar nuestra aplicación en la plataforma GAE solo basta con hacer click derecho sobre nuestro proyecto y utilizar la opción "Deploy To Google App Engine" (debe por supuesto crearse primero nuestra cuenta GAE y registrar nuestro proyecto, como corresponde), con las versiones del plugin disponibles en kenai.com esta opción tampoco trabajaba correctamemte para las nuevas versiones de Netbeans y del SDK para Java
  3. y es tambien una buena noticia que en la version 7.3 de Netbeans ya no resulta necesario y no existe la opción "set/unset as main project", con lo que el manejo de proyectos GAE-Java en Netbeans resulta ahora mucho mas sencillo, rápido y eficiente; y por lo que varios de los pasos detallados a continuación deben obviarse segun corresponda..

El caso es que para proyectos GAE-Java, resulta necesario que creemos primero en nuestro Netbeans un proyecto JavaWeb y que le indiquemos que utilizaremos un servidor Appengine que ya debemos haber instalado (y en este caso ponerle  el nombre "gae-guestbook" ( por supuesto, este es un nombre sugerido.. puede ser cualquier otro)


1. Creando nuestro proyecto Java-Web

2. Indicando el nombre y la ruta de nuestro proyecto...


3. Seleccionando el servidor...


4. Termiando nuestro proyecto gae-guestbook "vacío"...


Hasta este punto, lo que hemos hecho es crear un proyecto "vacío",  por defecto Netbeans nos presenta un simple "Hello World" para verificar que todo ha sido correctamente configurado y lo podamos desplegar en nuestro servidor local Appengine de pruebas... En la imagen a continuación pueden observar que a este código le hemos agregado una simple descripcion a este proyecto antes de lanzarlo a nuestro navegador...


5. Agregando una descripción a nuestro código generado...


6. Ejecutandi nuestro proyecto...




7. Nuestro proyecto en nuestro navegador de preferencia..

Hasta este punto lo que hemos conseguido es mostrar nuestro proyecto JavaWeb en nuestro servidor local Appengine de pruebas y todo parece funcionar correctamente.. vale entonces "cargar" ahora nuestro proyecto, pero continuando con las "inconsistencias" mencionadas, vale indicar que Netbeans mantiene algun problema para cargar directamente nuestro proyecto, y todo porque aún no le encuentro una opción para cargar a Netbeans un "Main Project" GAE-Java a su lista "interna" de proyectos.. pero eso lo hemos conseguido creando este proyecto "vacío"... ahora tenemos que "borrarlo".. pero indicando que no se eliminen las "fuentes" del mismo (debe quedar desmarcada la opción al respecto).. asimismo, es importante que tambien "detengamos nuestro servidor", por cuanto, al ejecutar nuestro proyecto "gae-guestbook" este se encuentra en funcionamiento (puede comprobarlo observando los procesos Java desplegados mediante "Java VisualVM"), y esto lo podemos hacer mediante el mismo Netbeans o mediante "Java VisualVM".. si no efectuamos este paso, al querer eliminar nuestro proyecto no se permitirá "borrar" las carpetas en uso de nuestro proyecto y tendremos que eliminarlas manualmente.. luego de detener al servidor, pues en eso caso, al estar los archivos en uso tampoco podrá ser efectuado.


8. observando nuestros procesos activos con Java VisualVM


9. cerrando nuestros servidor eliminando los procesos Java con Java VisualVM


10. cerrando nuestro servidor con el mismo Netbeans...


11. Borrando nuestro proyecto "vacio"

Si todo lo hubiésemos efectuado correctamente, en la carpeta "gae-guestbook" donde se ha creado nuestro proyecto solo se debería observar a las carpetas WEB y SRC (que son los requiere nuestro proyecto para ser desplegado en Netbeans).. e incluso podemos probar ahora cargar esta carpeta como un proyecto JavaWeb con "fuentes existentes" en nuestro servidor Appengine, y podrán observar que éste ahora si podrá ser creado sin mayores contratiempos..y que se creará con el nombre de nuestra carpeta como cuando creamos nuestros proyectos JavaWeb...




12. Carpetas basicas de un proyecto GAE-Java en Netbeans..

El caso es que para nuestros propósitos conviene que nuestros proyectos muchas veces reconozcan el formato ANT (y con el archivo build.xml incluído), y para observar como hacer éste proceso podemos entonces "descargar" nuestras fuentes a la carpeta de este proyecto vacío, sobreescribiendo las carpetas y archivos que existan (por supuesto, previamente nuestro proyecto ha sido borrado de nuestro Netbeans)








Efectuada esta operación conviene que revisemos nuestro archivo build.xml descargado y indiquemos correctamente la ruta de descarga de nuestro SDK de Java.. y listo! ya estamos listo para cargar nuestro proyecto en Netbeans:


14. Verificando la ruta de nuestro SDK de Java en build.xml



15. Cargando nuestro proyecto gae-guestbook...

Nuestro Netbeans detectará que existe un archivo build.xml al cargar nuestro proyecto así que seleccionemos Ok cuando se nos pregunte al respecto...



Como podemos observar, Netbeans carga todo nuestro proyecto sin mayores cambios puesto que la carpeta WAR propios de los proyectos JavaWeb la hemos nombrado WEB (que reconoce automáticamente Netbeans), y asimismo, en nuestro build.xml se han efectuado las modificaciones necesarias para que trabajemos con esta carpeta... así que corremos nuestro proyecto y listo! ya podemos cargar proyectos GAE-Java como proyectos JavaWeb de Netbeans, y revisarlos, modificarlos, ejecutarlos y cargarlos a la plataforma Cloud de GAE directamente desde Netbeans.














Al probar nuestro proyecto "gae-guestbook" podrán observar que al "firmar el libro de Visitas", y para las 10 primeras entradas, se nos lanzará a una página similar a la del ejemplo "guestbook" instalado inicialmente al preparar nuestro Netbeans... Asimismo, que con la opción "LIKE Search" hemos implementado una busqueda "%like%" sobre el datastore de GAE. Cabe destacar que "big table datastore" de AppEngine es una potente base de datos "escalable" y de alta disponibilidad (sin límites y siempre disponible aún cuando se "caigan" alguno de los servidores que la soportan.. y que por diseño soporta "persistencia" de datos, lo que nos permite incluso miles de conexiones simultaneas sin desmejorar el rendimiento del sistema; pero el costo de estas bondades, es que algunas operaciones de la base de datos están limitadas o restringidas (como es el caso de las consultas "%Like%" indicada, entre otras), por lo que nos conviene revisar con detalle lo siguiente :

Unsupported Features of JDO

The following features of the JDO interface are not supported by the App Engine implementation:
  • Unowned relationships. You can implement unowned relationships using explicit Key values. JDO's syntax for unowned relationships may be supported in a future release.
  • Owned many-to-many relationships.
  • "Join" queries. You cannot use a field of a child entity in a filter when performing a query on the parent kind. Note that you can test the parent's relationship field directly in query using a key.
  • JDOQL grouping and other aggregate queries.
  • Polymorphic queries. You cannot perform a query of a class to get instances of a subclass. Each class is represented by a separate entity kind in the datastore.
  • IdentityType.DATASTORE for the @PersistenceCapable annotation. Only IdentityType.APPLICATION is supported.
  • There is currently a bug preventing owned one-to-many relationships where the parent and the child are the same class, making it difficult to model tree structures. This will be fixed in a future release. You can work around this by storing explicit Key values for either the parent or children.



Por supuesto, para la conexión al GAE Datastore hemos utilizado "JDO", y conviene también tener presente la documentación al respecto:

http://code.google.com/intl/en/appengine/docs/java/datastore/jdo/overview.html

Instalando nuestros codelabs:
"Int-Google01" e "Int-Google02" como proyectos GAE-JavaWeb en Netbeans IDE


Nuestros proyectos Integración Google 1ra y 2da. parte son desarrollados exclusivamente con HTML y Javascript (considérese que el framework ExtJs utilizado en esos proyectos es Javascript), pueden entonces cargarse estos ejercicios como proyectos JavaWeb de Netbeans, como hicimos en nuestro codelab referido al Back-End Java(JSP)+MySQL, ó como lo hicimos sobre WebMatrix, correspondiente al uso de servidores IIS de Microsoft; y por supuesto, tambien pueden cargarse como proyectos "Appengine JavaWeb" en nuestro Netbeans (y poder luego colgarlos en la infraestructura cloud de Google), pero para ello, debemos configurar su presentación para que trabajen como proyectos GAE-Java, y los cambios realmente son mínimos, como ya hemos indicado, debemos adecuar la ruta de descarga de nuestro SDK en "build.xml", y además, verificar el contenido de los archivos "web.xml" y "appengine-web.xml" de la carpeta web/WEB-INF, que es donde se alojan los archivos de configuración de nuestros proyectos GAE-Java. En el caso de "web.xml", tal como en cualquier proyecto JavaWeb, se ha indicado que el archivo de partida de nuestro proyecto es "index.html"; y en "appengine-web.xml", indicamos el nombre de nuestra aplicación... y eso es todo, el código utilizado respecto a nuestros proyectos iniciales que corrimos sobre una plataforma LAMP ó WAMP no varían en nada...


Material de Apoyo : 
( do click on blue icons to download )

gae-IntGoogle01.rar (1.7Mb), que nos muestra Visualizaciones Google sobre ExtJs (la versión Ext-3.4.0 en este caso), correspondiente a dicho codelab, ahora adecuados a un formato "Java Web" para poder cargarlos como un proyecto de Netbeans. Puede revisar nuestra entrada Integracion Google 1ra parte para mayores detalles de sus componentes y forma de desarrollo. Asimismo recuerde qu, por el momento, primero debemos crear un proyecto Appengine JavaWeb"vacio" con nuestro Netbeans, sobre la carpeta appengine que descargamos el SDK de Java, y luego de verificar su funcionamiento, para el servidor Appengine, borrarlo con Netbeans, escargar en la carpeta creada nuestro material de apoyo, y finalmente, crear nuestro proyecto JavaWeb con "fuentes existentes" indicando por supuesto que vamos a utilizar como servidor a Google App Engine... y eso es todo.



gae-IntGoogle02.rar (2.3Mb), que nos muestra Visualizaciones Google y ExtJs de nuestro documento "Spreadsheet" de Google Docs, Puede revisar nuestro codelab Integracion Google 2da. partepara mayores detalles de sus componentes y forma de desarrollo. Se adjunta la copia de hoa de calculo en formato "xls" para que podamos nuestras propias sobre un documento propio que podríamos cargar en nuestro Google Docs, para ello, pueden revisar nuestro mencioando codelab Integracion Google 2da parte para mayores detalles de los componentes y la forma de desarrollo del proyecto.



Para cargar estos proyectos a Netbeans como proyectos "Appengine JavaWeb", como ya hemos indicado, debemos crear primero sendos proyectos "vacios" que podemos llamar "gae-intGoogle02" y "gae-intGoogle02" respectivamente; y luego, de manera similar a como "cargamos" nuestro proyecto "gae-guestbook", eliminar estos proyectos y descargar en las carpetas correspondientes nuestro material de apoyo. Luego procedemos a crearlos nuevamente pero como proyectos JavaWeb con "fuentes existentes", que utilizarán el servidor Google App Engine, y listo.. podremos ejecutar niestros proyectos Integración Google 1ra y 2da parte en la infraestructura local de pruebas de Google App Engine para Java, y posteriormente cargarlos a la plataforma Cloud de Google..aunque respecto a este último proceso, vale reiterar que Google solo nos otorga un servicio libre limitado a 10 proyectos, y de hasta 500Mb de espacio de uso del datastore, entre otras limitaciones que tambien debemos tener en cuenta, y que podemos consultar en la documentación respectiva.

NOTA IMPORTANTE :

Resulta que el sistema de autorización "AuthSub for JavaScript" de Google ya no se encuentra disponible (pueden revisar el siguiente enlace), por lo que nuestro botón "Login" de nuestro codelab no permite el acceso a nuestro ejercicio; asimismo, la documentación de Google nos recomienda que utilicemos ahora "OAuth 2.0 for client-side applications", vale decir, tendremos que utilizar Google API Javascript Client para poder acceder a nuestras aplicaciones (u otra API cliente según la plataforma back-end que utilicemos, tal como PHP, Java, .NET, entre otros), pero en nuestro caso, como solo estamos trabajando aplicaciones por el lado del cliente, tendremos que recurrir a la librería cliente para Javascript indicada.

Por lo que, mientras adecuamos nuestro código, resulta conveniente que NO CONSIDEREN el proceso de acceso a la aplicación de la siguiente manera:

function activando(auth) {
  var c = Ext.getCmp('center');
  //google.accounts.user.login('http://www.google.com/m8/feeds/');
  auth = true;
  c.enable();
  c.update('');
  if (auth) {
    vistree.enable();
  };
};

within from : MenuGVisualization_01.js / MenuGVisualization_02.js where appropiate!


TRABAJANDO CON OAUTH 2.0 :

por supuesto, a la brevedad actualizaremos todos nuestros códigos para que trabajen con el protocolo OAuth20, y les presentamos en esta oportunidad el código y su demo de nuestro codelab que hemos cargado a la plataforma GAE (Google App Engine), pero que usted también puede probar en su servidor local de pruebas utilizando el SDK para Java de Google App Engine..

 ..now you can test our IntGoogle01-Oauth demo  (New!) .
the demo may prompt popup window (you must enable it)

IntGoogle01-OAuth20.rar ( 3.05Mb ), Este código corresponde a nuestro codelab pero adecuado al protocolo OAuth version 2.0, utilizando la "Google API Javascript Client", la cual en esta versión, incluso nos permite acceder directamente al email de nuestros usuarios.

 ..now you can test our IntGoogle02-Oauth demo  (New!) .
the demo may prompt popup window (you must enable it)

IntGoogle02-OAuth20.rar ( 3.20Mb ), Este código corresponde a nuestro codelab pero adecuado al protocolo OAuth version 2.0, utilizando la "Google API Javascript Client", la cual en esta versión, incluso nos permite acceder directamente al email de nuestros usuarios.


Es importante indicar que la documentación de Google nos indica que ahora debemos trabajar con OAuth 2.0 que se esta convirtiendo en el estándar de autenticación y autorización para acceder a nuestras cuentas y poder utilizar todas las API de Google, por ello hemos adecuado nuestro codelab a dicho estándar debiéndose tener en cuenta lo siguiente:

  • Crear un nuevo proyecto en el Google API Console, con el nombre mas adecuado que queramos
  • Crear una "OAuth 2.0 Client ID" en la opción API Access de la consola.. allí podremos indicar el nombre de nuestra aplicación y la URL de un logo que la represente ..a continuación debemos indicar el tipo de nuestra aplicación ("web application" en nuestro caso), y la URL de nuestra aplicación (acepta http://localhost ó http://localhost:8080 para trabajar con nuestro servidor local de pruebas, debiendo verificar que se elija correctamente el protocolo "http ó https" y la ruta completa de acceso a nuestra aplicación para que todo funcione correctamente); por lo que al crear nuestra API Access se nos indicará la carpeta "Redirect URI" donde se realizará el proceso de autenticación y autorización OAuth 2.0 solicitado (si no ha sido creada debemos editar la configuración y registrar manualmente la carpeta donde se realizará el proceso, puede ser cualquiera dentro de "www" o crear la carpeta "oauth2callback" indicada)..
  • ..y finalmente, en la misma "Google API Console" debemos seleccionar a la opción "Services" y activar la "Google+ API" (debe estar "ON" y de color verde), lográndose con ello finalmente crear nuestra "API key" en forma automática.
  • y todo ya está listo! ..ahora al volver a la opción "API Access" de nuestra aplicación, ya tendremos disponible nuestro "Client ID" y la "API Key" (dentro de "Simple Access API"), estos datos son las que debemos utilizar y reemplazar en el archivo "index.html" de nuestra aplicación para que todo pueda funcionar correctamente.

    Conviene también revisar las diferentes opciones que nos presenta la "Google API Console" pues nos puede ser necesarias como crear, modificar, renombrar, eliminar proyectos principalmente.

  • ..y ahora a probar nuestra aplicación IntGoogle01-Oauth20 y IntGoogle01-Oauth20 como proyectos GAE-JavaWeb !

  • y una ultima indicación.. Como estamos trabajando con la Google Maps API v2, tenemos que activar el servicio "Google Maps API v2" en la API consola, y registrar nuestra API Key al importar la API en nuestro proyecto antes de subirlo a un servicio de hosting con un dominio personalizado y así puedan funcionar los mapas de nuestro proyecto sin mayores inconvenientes (aunque la Google Maps API v2 solo estará activa hasta Marzo 2013, por lo que debemos programar nuestras actualizacion a la API v.3)..por supuesto, al trabajar con nuestro servidor local "localhost" no se presentan problemas.. el asunto es, como indicamos, al cargar nuestros proyectos a un servicio de hosting externo cualquiera.. como es el caso de la plataforma GAE (Google App Engine), que es donde esta corriendo nuestra demo)


NOTAS DE TRABAJO :

1.- No debemos olvidar que para "abrir" un proyecto debemos previamente cerrar el que tengamos abierto, e indicar que el proyecto que vamos a desplegar sea seleccionado como nuestro "Main project". Si no lo hacemos, al correr un proyecto se compilará nuestro proyecto, pero se lanzará a nuestro navegador el proyecto que este marcado como "Main project", lo que podría confundirnos.

2.- En caso que no hayamos cerrado nuestro servidor Appengine en algún proyecto, y ya no lo podamos cerrar con Netbeans, entonces podemos utilizar la herramienta Java VisualVM, y el plug-in "killApplication" que debemos haber instalado en ella, y cerrar los procesos Java que correspondan (solo basta cerrar uno de los procesos pues se eliminan en bloque para una aplicación desplegada)

3.- Podemos configurar nuestros proyectos para utilizar diferentes puertos de "salida" y "debug", y tener abiertos en forma simultanea al hacer nuestras pruebas. La configuración se realiza en el archivo "build.xml"

4.- Para correr nuestro proyecto utilizando ANT, en su pantalla de comando debe dirigirse a la carpeta que contiene nuestro proyecto (que debe contener a la carpeta build.xml por supuesto), y alli ejecutar el comando : ant runserver (enter)

5.- Para correr nuestro proyecto utilizando los comandos del SDK de Java, conviene que agreguemos a la ruta de descarga de nuestro SDK (y a la carpeta "bin" en particular" como una variable de entorno PATH (opciones avanzadas de propiedades de myPC en Windows), y en la misma posición donde ejecutamos el comando anterior debemos ejecutar el comando : dev_appserver.cmd web (enter). Caso contrario, debemos indicar en nuestro comando toda la ruta de nuestro SDK: (%pathSDK%)/bin/dev_appserver.cmd web(enter).

6.- Podemos observar asimismo, la diferencia de "pesos" de nuestros codelabs gae-intGoogle01 (1.7Mb) y gae-intGoogle02 (2.3Mb); a pesar que en realidad son parecidos y el código Javascript que utilizan son casi del mismo peso ...ocurre que en el primero caso utilizamos ExtJs4-MVC "comprimido" con el SDK de Sencha, y en el otro empleamos ExtJs-3.4  Al correr estos ejercicios podrá comprobar que nuestros desarrollos bajo ExtJs4 son mucho mas rápidos para cargar y ejecutarse, en comparación que los desarrollados con ExtJs-3.x., y esto a nuestro criterio es una de las principales mejoras de ExtJs4, que incluso es aún más eficientes en su versión ExtJs-4.1, de próxima liberación en su formato GPL. Puede ver con más detalle nuestro codelab Integracion Google 1ra parte donde explicamos con más detalle la construcción del código ExtJs4 de este ejercicio.


Saludos
@Mlaynes




Publicado por Miguel Angel Laynes Sanchez en 10:42 p. m.
Etiquetas: ,