diciembre 11, 2011

working with ActiveVFP 5.6 on WebMatrix



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.

Esta es pequeña y rápida introducción a como utilizar ActiveVFP en su versión 5.6 vigente al 15/12/2011 (la ultima lanzada es la versión 6.03 del 29 de Enero del 2013, pero dicha versión solo corre sobre Windows Vista o superior, y por ello solo disponible en algunos servicios hosting.. las versiones 5.x si funcionan sobre cualquier versión de Windows y sobre cualquier servicio hosting Microsoft, y es en la practica lo mismo que la versión 6.x); y con lo que pretendemos saldar una deuda con los miembros de la comunidad del zorro, por cuanto, durante nuestro desarrollado profesional, y para el desarrollo de aplicaciones cliente-servidor de escritorio, muchas veces hemos recurrido a usar VisualFoxpro (VFP) en nuestros proyectos, y por supuesto, reconocemos las ventajas que nos proporciona utilizar el entorno de desarrollo VFP para lograr rápidamente productos de alcance profesional.. y al haberse indicado que una de las limitaciones de este entorno es su falta de integración al mundo del desarrollo Web, presentamos este codelab, que pretende mostrar en esta primera etapa, en un sencillo modelo, que también es posible trabajar rápidamente con ActiveVFP usando WebMatrix, utilizando comandos, funciones y clases VFP en nuestros proyectos Web, por el lado del servidor.

Para seguir este codelab solo se requiere tener conocimientos básicos de HTML, VFP y Javascript (no ExtJs que es el framework javascript que más utilizamos en nuestros codelabs), pues lo que buscamos es que se llegue a tener una visión completa de como trabaja ActiveVFP, y por supuesto vale reiterar, que ActiveVfp es un complemento que se encuentra correctamente integrado al desarrollo Web, y nos permite trabajar con tecnologías vigente como Ajax, Json, etc.. y a través de javascript y CSS, trabajar con frameworks como Jquery, ExtJs y toda la tecnología ligada a esas tecnologías.


Instalando nuestro codelab "avfp-guestbook" en WebMatrix

Como se indica, tenemos por supuesto que haber instalado en nuestro ordenador WebMatrix tal como se indica en nuestra entrada WebMatrix: la plataforma opensource de desarrollo Web de Microsoft, por lo que si no lo han realizado, deben seguir los pasos detallados en dicho codelab; y luego, proceder a cargar nuestro material de apoyo en una carpeta que podriamos llamar "AVFP" ó "ActiveVFP", como estimemos conveniente (..y por supuesto, si no deseamos instalar WebMatrix podríamos trabajar sobre un servidor IIS instalado en nuestro equipo Windows, pero su correcta configuración y uso tiene sus cosas.. por supuesto existe documentación y discusiones al respecto, por lo que también podríamos considerar como una opción).

Continuando pero sobre la plataforma WebMatrix, lo primero es proceder a crear un nuevo "site" en WebMatrix a partir de la carpeta creada al extraer los archivos de nuestra descarga (denominada "avfp-guestbook"). El proceso de carga y configuración de nuestro servidor IIS es realizado en forma automática por WebMatrix, por lo que luego solo debemos seleccionar nuestro navegador de preferencia para ejecutar el ejercicio y éste será lanzado al navegador seleccionado a través de un puerto que se encuentre disponible ( http://localhost:xxxxx ).


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

avfp-guestbook.rar, que corresponde a una adaptación de un "libro de visitas" bajo un formato que ya hemos utilizado utilizado en nuestros codelabs referidos al uso del datastore de Google App Engine, pero ahora utilizando como Back-End a Visual Foxpro, mediante ActiveVFP, y desplegando nuestro proyecto sobre un servidor IIS incluído en la plataforma de WebMatrix; debiendo reiterarse que nuestro Back-End es VFP, por cuanto utilizamos las tablas *.dbf de dicha plataforma, y los comandos, funciones y clases de VFP requeridos para interactuar con ella.







ActiveVFP es una implementación en lenguaje ASP y ASP.Net de Visual Foxpro (como por ejemplo, tambien lo es la librería Quercus que nos permite trabajar con PHP en el mundo Java), vale decir que nuestros comandos, funciones y clases VFP son interpretados como comandos ASP que son los que si reconoce y ejecuta un servidor IIS, y el nivel de adecuación de esta herramienta es bastante completa y eficiente, abarcando incluso la versión 9 de VisualFoxpro.. otro punto importante, es que el proyecto ActiveVFP es bastante activo y vigente, siendo su ultima actualización realizada a fecha 29/01/2013 (versión 6.03 como hemos indicado, y la que se puede descargar directamente del homepage del proyecto activeVFP en codeplex).

Las instrucciones y clases para la interpretación de VFP se encuentran contenidas en los archivos activevfp.dll, VFP9RENU.dll y otros archivos *.dll contenidos en el complemento, y los que deben incluirse en la carpeta principal de cada uoo de nuestros proyectos, siendo también necesaria la existencia de una carpeta "prg", que es la que va a contener como mínimo, a nuestro archivo "main.prg", la que pone en funcionamiento la librería (mediante la función "AVFPinit()"), y en la cual podremos configurar las principales variables de entorno disponibles por la librería, entre las que podemos destacar:

  • oProp.DataPath, para indicar en que carpeta de nuestro "servidor" ó equipo se encuentra alojada la data de nuestro proyecto.
  • oProp.HtmlPath, para indicar en que carpeta se alojaran nuestros archivos HTM, que este caso han sido ruteados hacia "oProp.AppStartPath", que contiene la carpeta de donde se llama a nuestro proyecto.
  • oProp.Action, en donde podemos indicar el nombre del script llamado en cada proceso, etc.

En ese mismo archivo podremos definir nuestras propias funciones VFP que utilizaremos en el proyecto.. en este caso no necesitamos ninguno (excepto el que estamos utilizando para mostrar el código de nuestra página), pero conviene que en la documentación de ActiveVFP revisemos la clase AVFPproperties (casi al final de lista de clases).

En este codelab tambien estamos trabajando con la clase AVFPrequest, para capturar los datos de los FORM de nuestras páginas HTML (*.avfp en este caso), y asimismo a la clase AVFPresponse para redirigirnos a una dirección ó URL, pero para mayores detalles también conviene que revisemos la documentación al respecto.

Considérese que nuestras tablas *.dbf en la ruta indicada en la ruta de oProp.DataPath se encuentran disponibles para su uso, y "abiertas" en modo shared, porque aún estando en ejecución nuestro proyecto, podremos acceder a ellas, abriéndolas desde la pantalla de comandos VFP, pero verificando que también usemos modo "shared"; asimismo, si hicieramos alguna modificación en las mismas no olvidemos de ejecutar el comando "flush" desde nuestra ventana de comandos (ó código de nuestros programas y sistemas) para que se carguen nuestras modificaciones a las tablas y los podamos observar al refrescar nuestro navegador.

Este último punto muestra uno de los retos de programación referidos a desarrollo Web en cuanto a que las modificaciones que puedan estar efectuando nuestros usuarios no son reflejados automáticamente en nuestras "tablas" ó "grids", excepto que nuestro código contemple un periodo de refresco (pudiendo utilizar Ajax con esa finalidad), ó adecuando nuestra lógica para que considere probables modificaciones de la data que puedan efectuar nuestros usuarios.. ests técnicas también son consideradas cuando trabajamos a nivel cliente-servidor con bases de datos externas a VFP como MySQL, postgressSQL, SQLServer, etc. por lo que ahora debemos mantener las mismas formas pero en desarrollo Web.


Instalando la demo de ActiveVFP 5.6 en nuestro WebMatrix

Para los que han tenido alguna dificultad en la correcta configuración del ruteo de los enlaces del demo de ActiveVFP 5.6, les pasamos nuestra versión corregida para que puedan trabajar con ella sin mayores contratiempos; debiendo resaltarse que, para el correcto funcionamiento de algunas de sus opciones (como el despliegue de gráficos e impresión de reportes VFP en formato PDF, eben efectuarse las instalaciones y configuraciones indicadas en el mismo demo, las que también son detalladas en la documentación disponible en el mismo demo.


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

activeVFP_5.6.rar, correspondiente a la demo de la versión 5.6 de ActiveVFP, lista para instalar sobre WebMatrix.. y a la que le hemos agragado la "impresión de algunas variables de entorno para su revisión..




Instalando una plantilla para nuevos proyectos ActiveVFP 5.6 en WebMatrix.


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

myproject.rar, que corresponde a un proyecto "vacío" que solo contiene un Hola Mundo para que lo podamos utilizar para iniciar nuestros propios proyectos, debiendo destacar que, para el caso de la creación de las "tablas" debemos crearlas desde la ventana de comandos de nuestro VFP directamente sobre la carpeta "mydata" de la descarga de éste material de apoyo ó configurar en el archivo "main.prg" la ruta de ubicación de nuestra data, y de los otros componentes de nuestro proyecto si lo estimásemos necesario.

Descarguemos este material de apoyo en la misma carpeta donde estemos trabajando este codelab, y luego al crear un sitio en nuestro WebMatrix a partir de la carpeta "myproject" creada con la descarga, pongamoslo en funcionamiento en nuestro navegador y tendremos una pagina como la mostrada.. y dispondremos de una plantilla ActiveVFP 5.6 que podremos utilizar para hacer nuestras propias pruebas ó proyectos.




Trabajando con el Back-End VFP en un modelo CRUD usando Ext-JS v.3.4.0


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

avfp-CRUD.rar, que corresponde a nuestro modelo CRUD (Create, Read, Update y Delete), de una Tabla VFP que contiene a los presidentes de U.S.A. llamada presidents.dbf, la cual utiliza a otra Tabla llamada parties.dbf que contiene a los partidos políticos que respaldaron a cada presidente. Este es un modelo sencillo que nos muestra como utilizando un framework, como ExtJS version 3.4.0 en este caso, se puede "ordenar" nuestros proyectos, separando nuestros códigos del lado del cliente (HTML, Javascript, CSS), de nuestro código el lado del servidor ó Back-End.







En este caso, los códigos del manejo de nuestra base de datos NO se "incrustan" en el código HTML de nuestro proyecto; y nuestro código VFP del lado del servidor se muestra más ordenado y comprensible, los que se encuentran alojados en la carpeta "prg", y comprende a los siguientes archivos:

  • main.prg, archivo principal de nuestro proyecto, de ejecución automática al iniciarse el proyecto, y que aparte de contener la lógica principal de manejo y gestión de nuestras tablas VFP, permite la configuración de las principales variables y objetos del entorno de desarrollo activeVFP.
  • updatepr.prg, archivo PRG que contiene el código VFP que permite la modificación y actualización de nuestra tabla de presidentes.
  • createpr.prg, archivo PRG que contiene el código VFP que permite la creación de nuestra tabla de presidentes.
  • deletepr.prg, archivo PRG que contiene el código VFP que permite el borrado "lógico" de uno ó varios de los registros de nuestra tabla de presidentes. En este caso vale destacar que las tabla VFP son abiertas por defecto en modo SHARED por activeVFP, por lo que restringe el borrado físico de registros, por lo que debemos adecuar la lógica de nuestros proyectos a esta condición.
  • Las opciones de búsqueda son aplicadas directamente sobre el código de nuestro archivo main.prg, los que deberá revisar para mayor detalle.

Los archivos javascript que componen el proyecto se encuentran alojados en la carpeta  "javascript" y comprende a los siguientes archivos:

  • mainscript.js, archivo JS que contiene el código ExtJS que permiten la creación,visualización y manejo de nuestra ventana, grilla, y otros componentes de nuestro proyecto (ventanas de creación de registros, búsqueda, etc), y que además contienen la lógica del proyecto por el lado del "cliente", referidos a los procesos necesarios para que un usuario pueda realizar las operaciones CRUD de nuestro listado de presidentes desde el navegador de su preferencia.
  • searchfield.js, archivo JS que contiene el código ExtJS que permiten la búsqueda rápida de un nombre o apellido ingresado.
  • GridPrint.js, archivo JS que contiene el código ExtJs y Javascript que permiten la impresión de un listado simple de nuestra lista de presidentes.

Otros componentes del proyecto:

  • carpeta "CSS", contiene a los archivos style.css, que controla las imagenes de nuestra grilla;, y GridPrint.css, que controla los estilos de nuestra impresión.
  • carpeta "ext-3.4.0", contiene los archivos javascript y css que comprenden al framework ExtJS de la verión que se indica (los que son llamados desde el archivo index.html de nuestro proyecto.
  • y por supuesto, la carpeta "data", que contiene a las tablas presidents.dbf y parties.dbf que son las utilizadas en este ejercicio.

Inicio del proyecto:

  • El archivo de inicio de este ejercicio es el archivo "index.html" que se encuentra alojado en la ruta oProp.AppStartPath, es decir la carpeta desde donde "arranca" nuestro proyecto. Los otros archivos que se encuentran en dicha carpeta son componentes de activeVFP y no pueden ser borrados.

las carpetas "bin" y "temp" son también del proyecto activeVFP y no conviene eliminarlas.. y hay otra carpetas que parecen en la demostración del proyecto activeVFP pero que hemos eliminado porque no las utilizamos en este ejercicio.



Saludos
@Mlaynes


NOTAS DE TRABAJO :

1.- Para abrir un documento *.avfp ó *.prg desde WebMatrix, haga click derecho sobre el archivo requerido y seleccionemos la opción "abrir con WebMatrix"

2.- Resulta interesante observar que para hacer nuestra prueba y seguir este "codelab" no es necesario incluso que tengamos VFP instalado en nuestro ordenador... activeVFP compila automáticamente el archivo "main.prg" y las modificaciones que podamos realizar sobre ella, aunque por supuesto, resulta necesario tener instalado VFP para inspeccionar y/o modificar nuestras tablas *.dbf. Pero vale indicar que, si trabajamos con varios PRG, llamados a traves de SET PROCEDURE TO, activeVFP no compila automáticamente esos archivos, y resultó necesario compilar esos archivos desde la ventana de comandos de VFP (updatepr.prg, deletepr.prg, etc).

3.- Por lo expuesto en el punto anterior, conviene que durante nuestros desarrollos, realicemos y probemos nuestros códigos incrustados en nuestro "main.prg" (que se compila automáticamente), y luego, si resultase necesario, y no sobrecargar nuestro main.prg, crear los *.prg que necesitemos.

4.- No olvidemos que podemos modificar en la opción configuración de nuestro "Site" el puerto que utilizaremos para lanzar nuestro proyecto a nuestro navegador (opción Configurar)

5.- Conviene también que ejecutemos la opción "Informe" de nuestro "Site", que nos indicará en forma bastante detallada la manera de optimizar nuestros proyectos.

6.- La opción database de nuestro "Site" la utilizaremos para trabajar con una base de datos SQL Server compact, que es una versión ligera y liberada de SQLServer de Microsoft que viene integrada a WebMatrix (como MySQL en las plataformas LAMP ó WAMP).







Using PHP on Appengine-JavaWeb projects



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 nuestros codelabs referidos al entorno GAE-Java, pasamos ahora a detallar como trabajar con PHP en proyectos Appengine-JavaWeb, utilizando Netbeans IDE como herramienta de desarrollo tal como lo hicimos en nuestra entrada anterior Working GAE-Java projects with Netbeans, pues esta herramienta nos permite un mejor control de los procesos de construcción, compilación, depuración, optimización y despliegue de nuestros proyectos tanto en nuestro servidor local de pruebas, como para su lanzamiento en la plataforma cloud de Google. Si Ud. no esta familiarizado a trabajar con Netbeans en desarrollos Appengine para Java, conviene que de primero una revisión a los codelabs de la mencionada entrada.

PREPARANDO NUESTRO ENTORNO DE DESARROLLO.

Para trabajar con PHP en GAE, como hicimos en nuestros proyectos JavaWeb, debemos descargar la última versión del WAR de Quercus desde la pagina oficial de caucho.com (versión 4.0.18 vigente al 15/12/2011), y grabarla en nuestra carpeta "appengine" que utilizamos en nuestro codelab anterior (para mantener un orden y porque allí también descargamos el SDK de Java).. y listo! ...el resto de operaciones es configurar.

Empecemos con nuestro "build.xml" de cada uno de los proyectos que instalemos ó desarrollemos, y allí debemos indicar la ruta de nuestras descargas tal como tambien hicimos en nuestro codelab anterior; pero en esta oportunidad, también debemos agregar las instrucciones ANT requeridas para que nuestro proyecto Java Web reconozca a PHP-Quercus, ...y para que Google App Engine reconozcan nuestros archivos *.php, por cuanto, en la infraetructura GAE, todos los archivos que no sean *.jsp, contenidos dentro de la estructura de nuestra carpeta WAR, estos son considerados "estáticos", y solo los reconocerá como archivos TXT, y por supuesto, no ejecutará los comandos PHP que contengan.. vale pues resaltar que debemos revisar las instrucciones de nuestros archivos "web.xml" y "appengine-web.xml" alojados en "web/WEB-INF" de la carpeta de nuestro material de apoyo descargado.

Instalando nuestro codelab "gae-phpwithjava" 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 ya hemos descrito en nuestro codelab anterior.

Resumiendo el proceso,  tenemos que crear un proyecto JavaWeb vacío sobre la carpeta "appengine",  donde descargamos nuestro SDK de Java y el WAR de Quercus, indicando que vamos a utilizar el servidor Appengine en él. Este proyecto recomendamos llamar "gae-phpwithjava", y luego de creado y probado corriendo el mismo, procedemos a "borrarlo" (deteniendo primero el servidor), y sobre la carpeta "gae-phpwithjava", correspondiente a nuestro proyecto "vacío" creado, descargar nuestro material de apoyo proporcionado, verificar nuestro archivo "build.xml" (la ruta de nuestras descargas del SDK y del WAR de quercus), ...y listo, carguemos nuestro codelab como un proyecto JavaWeb con "fuentes existentes" (indicando que utilizaremos nuestro build.ml), y podremos correr nuestro proyecto "gae-phpwithjava" sobre nuestro servidor local Appengine de pruebas utilizando Netbeans IDE....

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

gae-phpwithjava.rar, que corresponde a nuestra adaptación del proyecto "php-withjava" que describimos en nuestro codelab: Using PHP on JavaWeb projects", pero ahora corriendo sobre la plataforma de Google App Engine.

Al correr este proyecto podrán observar que podemos ejecutar dentro de la infraestructura GAE archivos *.php (de la versión 5.3.2 para la versión de Quercus 4.0.18 vigente a la fecha), inclusive conviviendo con archivos *.jsp y "servlets java".. y en el siguiente codelab observarán como integrar java con PHP en una misma aplicación...



Instalando nuestro codelab "gae-PHPguestbook" como proyecto Appengine JavaWeb en Netbeans IDE


procederemos ahora a correr nuestro codelab que presenta como cambiar el proyecto "guestbook" de los ejemplos de Google App Engine para que trabaje usando PHP (y aprovechando las clases java empleadas en él)... y por supuesto, debemos cargar nuestro material de apoyo a nuestro Netbeans como ya hemos indicado.

Resumiendo el proceso,  tenemos que crear un proyecto JavaWeb vacío sobre la carpeta "appengine",  donde descargamos nuestro SDK de Java y el WAR de Quercus, indicando que vamos a utilizar el servidor Appengine en él. Este proyecto recomendamos llamar "gae-phpguestbook", y luego de creado y probado corriendo el mismo, procedemos a "borrarlo" (deteniendo primero el servidor), y sobre la carpeta "gae-phpguestbook", correspondiente a nuestro proyecto "vacío" creado, descargar el material de apoyo proporcionado, verificar nuestro archivo "build.xml" (la ruta de nuestras descargas del SDK y del WAR de quercus), ...y listo, carguemos nuestro codelab como un proyecto JavaWeb con "fuentes existentes" (indicando que utilizaremos nuestro build.ml), y podremos correr nuestro proyecto "gae-phpguestbook" sobre nuestro servidor local Appengine de pruebas utilizando Netbeans IDE....


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

gae-phpguestbook.rar, que nos muestra el clásico ejemplo "guestbook" de Google App Engine (que utilizan tanto en su plataforma para Java como Phyton, y ahora también en lenguaje "Go" desarrollado por el propio Google), pero ahora utilizando PHP para el manejo de las clases Java que componen el proyecto. Conviene a este respecto que revisemos esta entrada del blog de Caucho.com que nos presenta con mayor detalle la construcción del proyecto:

http://blog.caucho.com/2009/04/28/quercus-on-the-google-app-engine/




...resulta interesante observar como con Quercus pueden interactuar sin mayores conflictos códigos y datos PHP con Java, y ese potencial es el que utilizaremos en el desarrollo de nuetro próximo codelab referido a Google Cloud SQL, que es una implementación de la base de datos MySQL sobre la infraestructura cloud de Google, y por supuesto, para cualquier desarrollador Web resulta  fácilmente comprensible trabajar con PHP+MySQL.(los que son utilizados por proyectos sociales muy difundidos como Drupal, Wordpress, Elgg, phpBB, etc.  ..una larga lista de proyectos, pues veremos que si es posible trabajar manteniendo algunas de esas modalidad pero dentro de la infraestructura de Google App Engine...

pero aún hay más, porque en el mismo blog de caucho.com presentan un ejercicio de como implementar Wordpress para ser instalado y ejecutado completamente sobre la infraestructura de Google App Engine (utilizando Quercus para utilizar las instrucciones PHP propias del proyecto, pero adecuando la conexión a la base de datos para trabajar con el datastore de Google Appengine... éste proyecto creemos que vale propiciar su desarrollo, así que en brevedad, y sobre esta misma página, liberaremos nuestro código respectivo (el cual ya estamos terminando de depurar), ..y realmente esperamos se propicie el interés para adecuar el proyecto a versiones vigentes de Wordpress...

Pueden revisar los detalles del proyecto en el blog de caucho.com, en la siguiente dirección:

Ahora es importante resaltar que, este proyecto ha sido actualizado por lo que conviene revisar con detalle el siguiente enlace :

las fuentes del proyecto se pueden descargar de GitHub :

..y su 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).


Saludos @Mlaynes



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 1ra2da. 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