PrimeFaces es un Framework para Java Server Faces 2.0, trae interesantes componentes que habia mencionado anteriormente, pues bien, NetBeans 6.10M1 trae soporte para primerfaces, simplemente cuando estamos creando el protecto web indicamos en la pestaña Components al momento de seleccionar el framework que usaremos primefaces.


Con esto podemos incorporar los componentes en nuestro proyecto.

Continuare con el tutorial de la creación del plugin basico para migrar datos desde las tablas en una base de datos en postgresql a couchdb.
En esta parte mostrare como agregar las bibliotecas necesarias para el plugin.

Seleccionamos elproyecto, y en el menu Archivo-Proyecto Properties(p2cNB)



Seleccionamos Bibliotecas y agregamos el Api de progreso

Ahora agregamos el driver jdbc de postgresql

Seleccionar en Librerias la pestaña Wrapped JARs



Dar clic en el botón Añadir
Seleccionamos el driver de postgresql


Agregamos las librerias de couchdb




En las siguientes secciones mostrare el código fuente de las clases desarrolladas.

Como parte de la integración del migrador de tablas postgresql a couchdb, estara integrado VisualDatabaseExplorer, en el tutorial
http://platform.netbeans.org/tutorials/nbm-visual_library2.html

Si tenemos una base de datos en postgresql y los nombres de tablas estan en minuscula como esta en la figura,



tendríamos una salida como esta.Es decir no nos mostraria los campos de las tablas ni mucho menos la relación existente entre ellas.


Para solucionar esto debemos ir al método createSceneFromConnection de la clase DBGraphScene.java y camabiar la linea
ResultSet columns = jdbcConnection.getMetaData().getColumns(null, null, table.toUpperCase(), "%");

por
ResultSet columns = jdbcConnection.getMetaData().getColumns(null, null, table, "%");

el procedimiento seria simplemente eliminar el metodo .toUpper() de table de manera que no lo convierta a mayuscula, ya que de esa manera nunca encontraria la tabla.

NetBeans IDE 6.10 M1 Esta disponible para descarga
Algunas de las características puedes verla aquí
http://netbeans.org/community/news/show/1493.html


Realice una prueba instalando el plugin p2cNB

Mostrare los pasos básicos para crear plugin basados en NetBeans Platform, este p2cNB permite exportar las tablas de una base de datos postgresql a couchdb.
Este plugin sera muy básico con la intención de que aquellos desarrolladores que nunca han utilizado NetBeans Platform, encuentren una forma rapida de desarrollar sus propios plugins.

Lo primero que haremos es crear un nuevo modulo

1. Crear el nuevo proyecto. Seleccionar Modulos NetBeans y en proyectos Module



2. En el nombre colocar p2cNB




3. Nombre inicial indicar el paquete org.avbravo.p2cnb


4. Agregamos un componente ventana



5. En la configuración , en Posición de Ventana seleccionar Editor


6. Ahora indicamos el nombre



7. Nos muestra los archivos generados


8. Abrimos MigradorP2CTopComponent.java, nos muestra el diseñador.


9. Diseñamos la interfaz


En las siguientes secciones hablare acerca del código y la forma de interacturar con Couchdb.

Decidí crear un plugins para NetBeans que me permitiera migrar las tablas
desde una base de Datos Postgresql a Couchdb.

Su funcionamiento es muy basico, simplemente analiza la estructura de la base de datos postgresql mediante jdbc, y luego realiza la exportación utilizando couchdb4j.

Creamos un nuevo proyecto de tipo Modulos NetBeans


Lo llame p2cNB (Postgresql 2 Couchdb NetBeans)


Puedes descargarlo desde
http://code.google.com/p/p2cnb/downloads/list

Nota:
Este modulo tiene un comportamiento básico, aun en etapa beta, no recomendado para ambientes de producción.
pronto estara el codigo fuente disponible para los interesados en ,mejorarlo.

Dentro de la Web semántica, una de las iniciativas que de a poco va ganando relevancia es la Web de datos o también conocida como Linked Data o también como Linked Open Data, aquí una presentación que explica Linked Data, que a través de 4 principios determina la forma en la que los datos deben ser descritos y publicados. Bajo estos preceptos se han generado varios Datasets, uno de ellos es DBpedia que es la versión semántica de la wikipedia. La mayoría de los Dataset poseen mecanismos de consulta que a través de SPARQL nos permiten tener acceso a la información que ahí se publica. Los mecanismos de consulta son servicios Web basados en REST.

En este post mostraremos como realizar consultas a la DBPedia a través de Java. Para ellos usaremos Jersey que es un API que no permite trabajar con servicios REST. Antes de pasar a realizar cualquier explicación les describiré brevemente la aplicación, el objetivo de la aplicación es encontrar el país al cual pertenece un punto cardinal expresado en latitud y longitud. Para ello vamos a realizar la siguiente consulta:

SELECT ?pais ?lat ?long WHERE {
?pais rdf:type <http://dbpedia.org/ontology/Country>.
?pais geo:lat ?lat FILTER (datatype(?lat) = xsd:float && (?lat-0.2273363048115043) < 0.005 && (-0.2273363048115043-?lat) < 0.005).
?pais geo:long ?long FILTER (datatype(?long) = xsd:float && (?long-78.892578125) < 0.005 && (-78.892578125-?long) < 0.005)
}

Para ejecutar la consulta y ver los resultados click aquí. Podemos ver en la consulta que estamos consultando los países (rdf:type <http://dbpedia.org/ontology/Country) que tenga sus valores de latitud y longitud como números tipos float (datatype(?lat) = xsd:float  y datatype(?long) = xsd:float) y ademas calculamos la diferencia en la latitud y longitud de cada país con los valores que los obtenemos de alguna manera (yo los obtuve con google maps). Si bien este método no es el mejor ha sido el que relativamente a funcionado mejor y según leí en algún lugar es una recomendación de la dbpedia.

Actualización 19/08/2010: La consulta anterior no dio buenos resultados por lo que busqué otras formas de consultar el país y encontré dos. La primera y que uso es invocando a un servicio, obviamente REST, CountryCode / reverse geocoding cuyo detalle lo pueden encontrar aquí – GeoNames. La segunda opción es usar Google Maps con su clase GClientGeoCoder y su método getLocations, detalles aquí. Que tiene su contraparte con la librería de Maps en GWT.

Con la consulta ya estructurada es hora de armar la URL del servicio que consumiremos. La URL tiene la siguiente forma: http://dbpedia.org/sparql?default-graph-uri=<valor>&query=<consulta>&output=<tipo_salida>

Para el ejemplo los valores son (para <consulta> el valor es la consulta SPARQL que les mostré anteriormente):

<valor> = http://dbpedia.org

<tipo_salida> = json

Veamos el código Java del programa

import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.WebResource;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import javax.ws.rs.core.MediaType;
import org.codehaus.jettison.json.JSONArray;
import org.codehaus.jettison.json.JSONException;
import org.codehaus.jettison.json.JSONObject;
/**
*
* @author jorgaf
*/

public class ClienteDBpedia {
   public static final String WS_URL_DBPEDIA = "http://dbpedia.org/sparql";
   public static void main(String[] args) {
      String defaultGraph = "http://dbpedia.org";
      String prefijos = "PREFIX owl: <http://www.w3.org/2002/07/owl#> \n"
         + "PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> \n"
         + "PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> \n"
         + "PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> \n"
         + "PREFIX foaf: <http://xmlns.com/foaf/0.1/> \n"
         + "PREFIX dc: <http://purl.org/dc/elements/1.1/> \n"
         + "PREFIX : <http://dbpedia.org/resource/> \n"
         + "PREFIX dbpedia2: <http://dbpedia.org/property/> \n"
         + "PREFIX dbpedia: <http://dbpedia.org/> \n"
         + "PREFIX skos: <http://www.w3.org/2004/02/skos/core#> \n";
      String qry = "SELECT ?pais ?lat ?long WHERE { "
         + "?pais rdf:type <http://dbpedia.org/ontology/Country>. "
         + "?pais geo:lat ?lat FILTER (datatype(?lat) = xsd:float && (?lat-2.8881803785839963) < 0.005 && (-2.8881803785839963-?lat) < 0.005). "
         + "?pais geo:long ?long FILTER (datatype(?long) = xsd:float && (?long-79.0576171875) < 0.005 && (-79.0576171875-?long) < 0.005) "
         + "}";
      String salida = "&output=json";
      String url = "";
      try {
         defaultGraph = URLEncoder.encode(defaultGraph, "UTF-8");
         prefijos = URLEncoder.encode(prefijos, "UTF-8");
         qry = URLEncoder.encode(qry, "UTF-8");
      } catch (UnsupportedEncodingException ex) {}

      Client client = new Client();
      url = WS_URL_DBPEDIA + "?default-graph-uri=" + defaultGraph
         + "&query=" + prefijos + qry + salida;
      WebResource resource = client.resource(url);
      String result = resource.accept("application/sparql-results+json").
         get(String.class);
<pre>      //String result = resource.accept("MediaType.APPLICATION_JSON").
      //   get(String.class);</pre>
try {
 procesar(result);
 } catch (JSONException ex) {}
 }

 private static void procesar(String res) throws JSONException{
 JSONObject result = new JSONObject(res).getJSONObject("results");
 JSONArray bindings = result.getJSONArray("bindings");
 JSONObject pais;
 JSONObject lat, lon;

 for (int i = 0; i < bindings.length(); i++) {
 pais = bindings.getJSONObject(i).getJSONObject("pais");
 lat = bindings.getJSONObject(i).getJSONObject("lat");
 lon = bindings.getJSONObject(i).getJSONObject("long");
 System.out.printf("País: %s Lat: %s Lon: %s\n",
 pais.get("value"),
 lat.get("value"),
 lon.get("value"));
 }
 }
}

Podemos ver como es necesario codificar los valores de las default-graph-uri, query y output. El programa muestra también como trabajar con información en formato JSON que fue el valor que le asignamos para la salida, vea le método procesar para ver como se pueden obtener los datos. La salida que se obtiene son las siguientes:

{ "head": { "link": [], "vars": ["pais", "lat", "long"] },
"results": { "distinct": false, "ordered": true, "bindings": [
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/Gabon" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "0.3833333253860474" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "9.449999809265137" }},
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/Kenya" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "-1.266666650772095" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "36.79999923706055" }},
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/S%C3%A3o_Tom%C3%A9_and_Pr%C3%ADncipe" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "0.3333333432674408" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "6.733333110809326" }},
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/Rwanda" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "-1.943883299827576" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "30.05945014953613" }},
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/Royal_Audience_of_Quito" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "-0.25" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "-78.58333587646484" }},
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/Ecuador" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "-0.1500000059604645" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "-78.34999847412109" }},
{ "pais": { "type": "uri", "value": "http://dbpedia.org/resource/Somalia" }        , "lat": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "2.033333301544189" }        , "long": { "type": "typed-literal", "datatype": "http://www.w3.org/2001/XMLSchema#float", "value": "45.34999847412109" }} ] } }

Mientras que la salida ya procesada es la siguiente:

País: http://dbpedia.org/resource/Gabon Lat: 0.3833333253860474 Lon: 9.449999809265137
País: http://dbpedia.org/resource/Kenya Lat: -1.266666650772095 Lon: 36.79999923706055
País: http://dbpedia.org/resource/S%C3%A3o_Tom%C3%A9_and_Pr%C3%ADncipe Lat: 0.3333333432674408 Lon: 6.733333110809326
País: http://dbpedia.org/resource/Rwanda Lat: -1.943883299827576 Lon: 30.05945014953613
País: http://dbpedia.org/resource/Royal_Audience_of_Quito Lat: -0.25 Lon: -78.58333587646484
País: http://dbpedia.org/resource/Ecuador Lat: -0.1500000059604645 Lon: -78.34999847412109
País: http://dbpedia.org/resource/Somalia Lat: 2.033333301544189 Lon: 45.34999847412109

Hasta aquí no existe complicación alguna, pero lamentablemente y no sé porqué algunas veces el programa no funciona y presenta una excepción 406 Not Acceptable Actualización 19/08/2010: el problema anterior se resolvió cambiando la línea: resource.accept(MediaType.APPLICATION_JSON).get(String.class) por resource.accept(“application/sparql-results+json”).get(String.class); . La única forma de que trabaje es copiando la URL a la barra de dirección del navegador y luego de un par de intentos funciona en el navegador y luego en el programa Java. Si alguno de ustedes me puede ayudar con alguna solución se los agradeceré mucho.

Espero que les ayude y les sirva como base para futuros trabajos.

Se ha liberado para descarga NetBeans 6.9.1, que incluye el soporte para JavaFX 1.3.1.
Puedes descargarlo desde http://netbeans.org/downloads/index.html

Aqui puedes ver algunas caracteristicas tecnicas.
http://netbeans.org/community/releases/69/

Únete a la petición para la liberación de JavaFX, agregate a los participantes para promever
http://steveonjava.com/javafx-petition/

Nuestro amigo Diego Silva, que ha contribuido enormemente con la traducción de NetBeans y con gran cantidad de documentos y blogs sobre NetBeans, en esta ocasión nos presenta en su blog Instalación de Liferay en un servidor GlassFish v3 para producción


Sin duda que sera de mucha utilidad para todos.

En algunas ocasiones necesitamos hacer las consultas utilizando un patrón determinado, en las setencias sql generalmente usamos like %patron%.

Asumimos que tenemos una clase llamada Interes.java, agregamos un nuevo @NamedQuery y colocamos lower() para convertir a minuscula el resultado y utilizamos like para la busqueda del patrón.

@NamedQuery(name = "Interes.findByNombreLike", query = "SELECT i FROM Interes i WHERE
lower(i.nombre) like :nombre"),

Editamos la clase controlador
public List findByNombreLike() {

EntityManager em = null;
try {
// itemsSearch = null;
if (current == null) {
}
String nombre = current.getNombre();
if (nombre == null) {

return null;
}
em = getEntityManager();

// aqui convertimos a minuscula y buscamos la palabra en cualquier
nombre = "%" +nombre.trim() +"%";
return em.createNamedQuery("Interes.findByNombreLike").setParameter("nombre", nombre).getResultList();

} catch (Exception ex) {
JsfUtil.addSuccessMessage(ex.getLocalizedMessage());
JsfUtil.addErrorMessage(ex, "Error. findNombre() ");
}
return null;
}

Cuando deseamos internalización de nuestras aplicaciones Web, debemos crear un archivo properties.

Agregamos los diversos idiomas


Seleccionamos el idioma



Para agregarlo a nuestro código
en el < h:head> agregamos
< h:head>




Para utilizarlo
< h:outputText value="#{i18n['mensajes.titulo']}">< /h:outputText>

En NetBeans 6.9 no se crea el archivo faces-config.xml ya que JSF 2.0 no lo necesita.
Podemos crearlo en la carpeta WEB-INF

Y agregamos el contenido



En el indicamos la ruta donde esta almacenado el archivo de propiedades
es la variable que usaremos, y no tendremos que usar el en las paginas.

Usar los archivos de propiedades en las paginas
value="#{i18n['interes.titulo.lista']}"

value="#{i18n.titulo}"

y en las clases
JsfUtil.addSuccessMessage(ResourceBundle.getBundle("/org/gbiweb/properties/i18n").getString("interes.mensajes.actualizado"));

Luego de haber creado las Clases de Entidad a partir de la base de datos, podemos crear nuestros beans de sesiones.
Creamos un nuevo archivo
Seleccionamos Session Beans For Entity Clases


Seleccionamos las clases disponibles

ahora


Seleccionamos Nuevo Archivo-> Categorias:Java Server Faces ->Tipo de Archivos: JSF Managed Bean

alcance: Session


Crear los objetos

private Interes current;
private DataModel items = null;
@EJB private jpa.controller.InteresFacade ejbFacade;

Generar los métodos get
Código generado
public Interes getCurrent() {
return current;
}

public InteresFacade getEjbFacade() {
return ejbFacade;
}

public DataModel getItems() {
return items;
}
Editamos el método getItems() y lo reemplazamos por el siguiente codigo

public DataModel getItems() {
if (items == null) {
items = new ListDataModel(getListaInteres());
}
return items;
}

Agregar el método getListaInteres() que devuelve un List de la clase Interes
public List getListaInteres() {
try {
return getEjbFacade().getEntityManager().createNamedQuery("Interes.findAll").getResultList();
} catch (Exception ex) {
JsfUtil.addErrorMessage(ex, "Error ");
}
return null;
}

Si observamos solo tenemos que utilizar getEjbFacade().getEntityManager().

Cuando generamos una aplicación web, utilizando JPA, y tenemos campos autoincrementables, debemos definir la estrategia de generación
@GeneratedValue(strategy=GenerationType.IDENTITY)
en el campo, antes de generar las paginas JSF a partir de las entidades o crear las clases controladoras.

Ejemplo:

public class Interes implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@Basic(optional = false)
@Column(name = "id_interes")
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer idInteres;

y comentamos el campo id para que no se muestre en la pagina .xhtml
< !--
< h:outputLabel value="#{bundle.CreateInteresLabel_idInteres}" for="idInteres" />
< h:inputText id="idInteres" value="#{interesController.selected.idInteres}" title="#{bundle.CreateInteresTitle_idInteres}" required="false" requiredMessage="#{bundle.CreateInteresRequiredMessage_idInteres}"/>
-- >

Creamos una base datos en postgresql

Generamos la persistence

indicamos las clases

entity





Utilizando JPA Controller
Creamos las clases JPA controller


Error


Editamos el archivo persistence.xml


Quitamos la marca y agregamos las clases


Editar el index.xhtml agregamos un dataTable de OpenFaces, con algunos

Indicamos la columna y los valores





Editar la clase InteresJpaController
Creamos un objeto
private DataModel items = null;
public DataModel getItems() {
if (items == null) {
items = new ListDataModel(getListaInteres());
}
return items;
}

public List getListaInteres() {
EntityManager em = null;
try {
em = getEntityManager();

return em.createNamedQuery("Interes.findAll").getResultList();

} catch (Exception ex) {
String msg = ex.getLocalizedMessage();

doneMessage = new FacesMessage("Error " + msg);

FacesContext.getCurrentInstance().addMessage(null, doneMessage);

} finally {
if (em != null) {
em.close();
}
}

return null;

}
Ejecución

Si deseamos crear una aplicación web j2ee con NetBeans 6.9

Creamos las clases de entidad a partir de la base de datos

Seleccionamos la base de datos y las tablas

Ahora indicamos el paquete

Vamos a crear las paginas jsf a partir de las clases

Agregamos las clases

Especificamos la carpeta para almacenar las jsf generadas

Tenemos la estructura generada, y ejecutamos elproyecto



Entrar en cualquier opción

Tenemos nuestra aplicación CRUD

Recientemente fue liberado la versión 6.9 de NetBeans, un IDE con muchas características, en esta ocasión, empezamos a probarlo creando una aplicación Web con Java Server Faces 2.0 y utilizando OpenFaces.


Creación del proyecto utilizando NetBeans.
Pasos:
1. Seleccionar desde el menu Archivo-> Proyecto Nuevo
2. Seleccionar en categorias: Java Web y en Projects Web Application

3. Seleccionamos el servidor

4.Indicamos el frameworks Java Server Faces y presionamos el botón FINALIZAR


5. Ejecutamos el proyecto
6. Se muestra la salida en el browser


7.Descargar OpenFaces desde http://www.openfaces.org
8.Agregar la biblioteca a NetBeans

9. Agregamos la biblioteca al proyecto

10. Seleccionar OpenFaces


11. Agregar en el archivo web.xml


12. Agregar un componente calendario al archivo index.xhtml
12.1 Agregar xmlns:o="http://openfaces.org/">
12.2 Agregar el componente calendar


13. Ejecutamos el proyecto


Solo nos muestra la pagina cargando

14. Crear el archivo beans.xml dentro de WEB-INF

15. Agregar el siguiente contenido



16. Quedaría de la siguiente manera


17.Ejecutamos el proyecto

Puedes descargarlo desde el siguiente enlace
http://dlc.sun.com.edgesuite.net/netbeans/6.9/rc/

Aun no esta concluida la traducción de NetBeans al idioma español y se estan corrigiendo algunos errores.

Ya esta disponible NetBeans 6.9 RC2 ,pueden encontrar más información en el siguiente enlace http://netbeans.org/community/releases/69/

NetBeans IDE 6.9 incluye JavaFX Composer. Soporte OSGi para aplicaciones NetBeans Platform ,JavaFX SDK 1.3, PHP Zend framework, y Ruby on Rails 3.0; mejoras en el editor Java, Java Debugger.

Este es el informe de avances en la traducción de NetBeans 6.9
Pueden colaborar registrándose en nuestro grupo en google.

Ya esta disponible la versión NetBeans 6.9 RC1, que entre las caracteristicas incluyen:
OSGi
JavaFX Composer
Java EE

la lista de esta disponible en el siguiente enlace
http://netbeans.org/community/releases/69/

Tengo la costumbre de que cuando algo no me sale (un proyecto en java :furious: ) lo dejo temporalmente y me pongo a hacer otra cosa, esta vez intente trabajar en Windows ya que casi no lo uso y se olvidan como se manejan unas cosas en este SO. :no:

Resulta que durante mis practicas trabaje con Apache + PHP + MySQL sobre GNU/Linux y decidí usar el patrón de Modelo, Vista, Control para separar toda la parte gráfica, representación de datos, manejo del negocio y el acceso a la base de datos.

Precisamente uno de los punto que mas recalcaron en la uni cuando nos explicaron en que cosistia el MVC fue que podíamos cambiar de manera facíl el acceso al manejador de base de datos, asi que tome el la DB que estaba en MySQL y la pase a SQL Server, en teoria solo tenia que modificar algunas cosas y para el resto del sistema seria transparente el cambio de manejador. Pero me encontré con un problema que no logro entender a que se debe. ...

Tengo la costumbre de que cuando algo no me sale (un proyecto en java :furious: ) lo dejo temporalmente y me pongo a hacer otra cosa, esta vez intente trabajar en Windows ya que casi no lo uso y se olvidan como se manejan unas cosas en este SO. :no:

Resulta que durante mis practicas trabaje con Apache + PHP + MySQL sobre GNU/Linux y decidí usar el patrón de Modelo, Vista, Control para separar toda la parte gráfica, representación de datos, manejo del negocio y el acceso a la base de datos.

Precisamente uno de los punto que mas recalcaron en la uni cuando nos explicaron en que cosistia el MVC fue que podíamos cambiar de manera facíl el acceso al manejador de base de datos, asi que tome el la DB que estaba en MySQL y la pase a SQL Server, en teoria solo tenia que modificar algunas cosas y para el resto del sistema seria transparente el cambio de manejador. Pero me encontré con un problema que no logro entender a que se debe.

Este es mi blog 500, aunque en los últimos meses no había escrito mucho, por otros compromisos, haré un breve resumen, de lo ocurrido en estos años:

NetBeans Dream Team
Traducción NetBeans al idioma Español
NetBeans Community Docs
NetBeans Community Docs blog

Mi Podcast en JavaHispano


Primer Congreso PanamaJUG en el año 2007

La comunidad hispana ha colaborado mucho en la traducción de NetBeans y en los proyectos de documentación.

Sin lugar a dudas una de las noticias más importantes para todos fue la compra de Sun por parte de Oracle.

NetBeans IDE


Espero tener tiempo para mantener al día mi blog,ya que pronto tendremos la versión 6.9 de NetBeans y presenta grandes mejoras sobre la versión 6.8.

Crearemos una nueva pagina



NetBeans genera dos archivos .html y .java, donde podemos crear los componentes y agregarlos al archivo .html.



Agregamos una etiqueta al archivo .java
Ejemplo.java
public final class Ejemplo extends WebPage {
public Ejemplo() {
super ();
Label label1 = new Label("label1","Wicket NetBeans");
}

Agregamos la etiqueta al archivo .html
Ejemplo.html

< span wicket:id="label1">Etiqueta< /span >

NetBeans nos permite utilizar Wicket de manera sencilla,mostrare los paso básicos para crear un proyecto Web.
Desde el menu Archivo->Nuevo Proyecto->Seleccionamos en Categorias: Java Web y en Proyectos Web Application


Ahora indicamos el nombre del proyecto y si deseamos compartir las librerias usamos


Ahora indicamos el nombre del proyecto: MiWicket y si deseamos compartir las librerias marcamos Use Dedicated Folder for Storing Libraries



Indicamos el servidor Web



Selecciones el Framework


NetBeans genera la estructura del proyecto



Ahora procedemos a ejecutarlo


Wicket ofrece un modelo muy adecuado de programación, permitiendo una separación de la vista con el modelo.

En Wired podemos leer una interesante entrevista a Larry Ellison, acerca de la compra de Oracle a Sun.
Enlace de la entrevista

Algunos aspectos que se analizan de los errores cometidos por Sun que los llevo a la compra por parte de Oracle, casi no menciona el tema de Java y algunos proyectos.

La combinación Wicket con NetBeans es excelente, en esta ocasión, mostrare como indicar en Wicket cuales son las paginas de error, de acceso denegado o de sesión expirada.
Solo debemos sobrescribir el método init() de la clase Application.java e indicamos las clases que se ejecutaran al producirse uno de los eventos.
@Override
protected void init(){
IApplicationSettings settings = getApplicationSettings();
settings.setAccessDeniedPage(AccesoDenegado.class);
settings.setPageExpiredErrorPage(SesionExpirada.class);
settings.setInternalErrorPage(ErrorInterno.class);
}

Wicket posee un excelente soporte para Ajax, en este ejemplo haremos una actualización básica de algunos componentes( hacerlos visibles o invisibles) con solo hacer click sobre los enlaces sin afectar a los demás componentes.
Código:

Label label1 = new Label("label1","Hola mundo");
label1.setOutputMarkupPlaceholderTag(true);
AjaxLink link = new AjaxLink("link") {
public void onClick(AjaxRequestTarget target) {
label1.setVisible(true);
target.addComponent(label1);
}
};
AjaxLink link2 = new AjaxLink("link2") {
public void onClick(AjaxRequestTarget target) {
label1.setVisible(false);
target.addComponent(label1);
}
};



label1.setVisible(false);
form.add(link);
form.add(link2);
form.add(label1);
add(form);

CODIGO HTML

< span wicket:id="label"/ > < /span>
< a wicket:id="link">Aparecer< /a>
< a wicket:id ="link2">Ocultar < /a>

Es importante recordar que NetBeans 6.8 Ofrece un excelente soporte para Wicket, la versión beta NetBeans 6.9 aun no tiene el soporte para Wicket.

Amigos ya esta disponible la plataforma para la traducción de NetBeans 6.9 al idio español, puedes ingresar en la siguiente dirección.
http://translate.sun.com

Apache Wicket es un gran framework para el desarrollo de aplicaciones Web en Java, en esta ocasión mostrare segmentos de código que nos permite desplegar en una ventana modal mensajes para que el usuario observe una aplicación más atractivas

Si no ingresamos un valor y le damos click al link Entrar , nos aparecer el siguiente mensaje



En el objeto TextField que usamos en el ejemplo agregamos
.add(new AjaxFormComponentUpdatingBehavior("onblur") {
protected void onUpdate(AjaxRequestTarget target) {
}

De manera que se actualice el componente

cedula = new TextField("cedula", new Model(""));

cedula.add(new AjaxFormComponentUpdatingBehavior("onblur") {

protected void onUpdate(AjaxRequestTarget target) {

}
});

De esta manera podemos verificar el valor que obtiene el TextField llamado cedula y vavalidar su contenido y si es necesario llamar al modalwindows

linkLogin = new AjaxLink("linkLogin") {

public void onClick(AjaxRequestTarget target) {
//

String lcedula = cedula.getValue();
if (lcedula == null || lcedula.equals("")) {
cedulaErradaModalWindow.show(target);

}

En el día de ayer se celebro el FLISOL 2010, en el cual se presentaron varios expositores de varias comunidades y organizaciones y desde luego NetBeans estuvo presente.

algunas características las puedes consultar en

Estos ultimos meses he estado trabajando en un proyecto usando Perl + MySQL + PHP y en la etapa del desarrollo web me he enfrentado a algunos problemas con el manejo de algunas variables con php :D

El problema es que no logro rastrear donde se queda un valor mientras es procesado :o buscando la forma de rastrearla, recorde que con Netbeans podemos hacer un debug de codigo php :up:

Y como no se me quita la costubre de usar versiones en desarrollo :rolleyes: instale la version 6.9 Milestone 1


Netbeans hace uso de xdebug para poder hacer un debug. Para su instalacion en OpenSuSE descargamos el software desde el Build Service de openSUSE, una vez ahi buscamos xdebug y lo instalamos con unos cuantos clicks :up:

Una vez instalado se configura para que pueda funcionar con Netbeans, para esto se edita:

/etc/php5/apache2/php.ini

y se agrega lo siguiente:

zend_extension=/usr/lib/php5/extensions/xdebug.so
xdebug.remote_enable = on
xdebug.remote_handler = dbgp
xdebug.remote_host = localhost
xdebug.remotes_port=9000

Con esto ya podemos hacer un debug de codigo php.

Estos ultimos meses he estado trabajando en un proyecto usando Perl + MySQL + PHP y en la etapa del desarrollo web me he enfrentado a algunos problemas con el manejo de algunas variables con php :D

El problema es que no logro rastrear donde se queda un valor mientras es procesado :o buscando la forma de rastrearla, recorde que con Netbeans podemos hacer un debug de codigo php :up:

Y como no se me quita la costubre de usar versiones en desarrollo :rolleyes: instale la version 6.9 Milestone 1


Netbeans hace uso de xdebug para poder hacer un debug. Para su instalacion en OpenSuSE descargamos el software desde el Build Service de openSUSE, una vez ahi buscamos xdebug y lo instalamos con unos cuantos clicks :up:

Una vez instalado se configura para que pueda funcionar con Netbeans, para esto se edita:

/etc/php5/apache2/php.ini

y se agrega lo siguiente:

zend_extension=/usr/lib/php5/extensions/xdebug.so
xdebug.remote_enable = on
xdebug.remote_handler = dbgp
xdebug.remote_host = localhost
xdebug.remotes_port=9000

Con esto ya podemos hacer un debug de codigo php.

A los tiempos un post.

Ahora no presento soluciones sino un problema.

Estamos desarrollando un proyecto en el cual trabajamos con Jena (para hacer unas consultas a una ontología). La aplicación es Web y estamos trabajando con GWT 2 (como la han mejorado a la esta herramienta, al fin pude hacer debbug desde la Mac!) la GUI full Ajax y RPC sin problemas. Necesitamos subirla a un servidor público y se me ocurrió subirla al Google App Engine, desde un principio tuve dudas relacionadas sobre las restricciones que impone Google (número de archivos y clases restringidas) y las dudas se convirtieron en problemas.

El problema se da en el método hasNext() de la clase ResultSet para versión 2.5.7 del Jena al parecer deriva de algunas clases no permitidas. Cambié los .jar del Jena a la versión 2.6.2 y el problema se dio en el método create(String) de la clase QueryFactory.

He encontrado los siguientes links que mencionan el algo el problema:

Aquí se detallan los Frameworks y APIs  soportados parcial, total o definitivamente por Google App Engine

Mientras que en éste link se habla sobre un problema que se presenta.

Finalmente aquí se presenta una solución (aunque no estoy seguro que sea para mi problema) trataré de implementar lo que se recomienda.

Por ahora el problema está sin solución, si alguien ha logrado solucionar o tienes más detalles del problema y quiere compartir sus ideas o soluciones, les pido su ayuda.

Una de las figuras mas conocidas en las comunidades Java a nivel internacional Felipe Gaúcho ha muerto según informan en CEJUG, este es su blog.

http://blogs.sun.com/geertjan/date/20100305

:hat: el blog cumplio 4 años :hat:

:hat: el blog cumplio 4 años :hat:

Para los interesados en soporte verificar NetBeans 6.9M1 en español, pueden descargar el pack desde este enlace

Descomprimirlo y copiarlo en el directorio de instalación de NetBeans 6.9M1

La versión de NetBeans 6.9 Milestone 1, aun no tiene soporte para el plugin JavaFx Composer, como comenta Lukas Hasik en su blog, este estará disponible con la siguiente liberación del SDK de JavaFX.
Creo que esta liberación de NetBeans, ha sido una de las más expectativas ha causado y no solo por las mejoras al IDE o la incorporación de nuevas características, si no por el hecho de que ha estado en medio de la adquisición de Sun por parte de Oracle y existia muchas dudas sobre las decisiones que Oracle tomaría respecto a NetBeans ya que ellos tienen su propio IDE, pero al pasar los días, todo parece que esta tomando un aspecto positivo para la comunidad NetBeans que espera que siga avanzando el desarrollo e incrementándose la comunidad.

Próximamente se estará realizando el evento FLISOL 2010, en Panamá se esta coordinando para realizarlo nuevamente en varias ciudades, realmente un evento que reúne a muchas comunidades. Sitio web:
Festival Latinoamericano de Instalación de Software Libre (FLISoL) .
Hemos creado el evento en OSUM, para los interesados en participar este es el enlace
http://osum.sun.com/events/flisol2010-osum-panamajug

La versión de NetBeans 6.9 Milestone 1, esta disponible para su descarga, puedes encontrar más información aquí .

Puedes descargarlo desde este enlace

Uno de los API’s, dentro del mundo Java, que permiten trabajar con servicios Web basados en REST se denomina Jersey. Este API viene incluido con NetBeans desde ya hace algunas versiones atrás. Inclusive en el sitio de NetBeans existe documentación en donde se muestra como crear un servicio Web Rest basado en una tabla de una base de datos. Pero no existe ninguna documentación, al menos en sitio de NetBeans, que muestre como crear un cliente Jersey que consuma algún servicio Rest.

Buscando en la Web encontré un par de ejemplos. Uno de ellos Consuming RESTful Web Services With the Jersey Client API, desarrolla un cliente (en modo consola) de Twitter.

Otro ejemplo bastante sencillo, pero no menos ilustrativo se llama Yahoo Search Restful Client using Jersey, aquí se desarrolla un cliente que consume el servicio de búsqueda de Yahoo. Dicho servicio de búsqueda devuelve los resultados en XML así que es necesario usar JAXB Binding para obtener las clases que representaran la información.

No he encontrado un ejemplo en donde se trabaje con JSON, tomando en cuenta que ese formato es bastante popular hoy por hoy. Así que me decidí a elaborar un cliente Jersey que consuma el API de Google AJAX search que devuelve información en JSON. El código desarrollado es el siguiente:

package ecc.edu.utpl;

import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.WebResource;
import java.util.Scanner;
import javax.ws.rs.core.MediaType;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

/**
 *
 * @author jorgaf
 */
public class ClienteGoogle {

    public static void main(String[] args) {
        Scanner lector = new Scanner(System.in);
        String consulta;
        char opc = 'S';
        String URI = "http://ajax.googleapis.com/ajax/services/search/web?v=1.0&q=";
        Client cliente = Client.create();
        do {
            do {
                System.out.print("Ingrese el texto a buscar: ");
                consulta = lector.nextLine();
                consulta = consulta.trim();
                consulta = consulta.replace(" ", "%20");
            } while (consulta == null || consulta.length() == 0);

            URI += consulta;
            WebResource recurso = cliente.resource(URI);
            String result = recurso.accept(MediaType.APPLICATION_JSON).get(String.class);
            try {
                System.out.printf("---RESULTADOS:%s---\n", consulta);
                mostarResultados(result);
                System.out.printf("---%d páginas aprox.---\n",
                        obtenerTotalResultados(result));
            } catch (JSONException ex) {
                ex.printStackTrace();
            }
            System.out.println("\n-------------------------------");
            System.out.println("¿Desea realizar otra búsqueda?");
            System.out.print("Presione S(Si) o N(No): ");
            opc = lector.next().charAt(0);
            System.out.println();
        } while (opc != 'N');

    }

    public static void mostarResultados(String respuesta) throws JSONException {
        JSONObject objJSON = new JSONObject(respuesta);
        JSONObject responseData = objJSON.getJSONObject("responseData");
        JSONArray results = responseData.getJSONArray("results");
        for (int i = 0; i < results.length(); i++) {
            JSONObject link = results.getJSONObject(i);
            System.out.printf("URL: %s\n", link.getString("url"));
            System.out.printf("Title: %s\n", link.getString("title"));
            System.out.printf("Contenido: %s\n", link.getString("content"));
            System.out.println();
        }
    }

    public static long obtenerTotalResultados(String respuesta){
        long total = 0;
        try {
            JSONObject objJSON = new JSONObject(respuesta);
            JSONObject responseData = objJSON.getJSONObject("responseData");
            JSONObject cursor = responseData.getJSONObject("cursor");
            total = cursor.getLong("estimatedResultCount");
        } catch (JSONException ex) {
            ex.printStackTrace();
        }
        return total;
    }
}

Para poder realizar este cliente tuve que agregar las siguientes librerías adicionales:

• jersey-client-1.1.5
• jersey-core-1.1.5
• JSON.org
• JAX-RS 1.1

Las tres primeras librerías se pueden descargar desde la Web haciendo clic en cada uno de los enlaces. Pero el último lo agregué desde NetBeans. La siguientes imágenes les guiarán en ese proceso.

Los métodos mostrarResultados y obtenerTotalResultados, son los encargados de trabajar con JSON. Para conocer la estructura JSON de la información devuelta por Google hagan clic aquí y busquen el tema “Entornos Flash y otros entornos que no utilizan JavaScript” que casi se encuentra al final.

Espero que este post les ayude.

Tenemos la visita de un gran amigo Tomasz Slota del equipo de NetBeans en Praga, con quien hemos conversado bastante sobre muchos aspectos entre estos el futuro de NetBeans.

Inicia un nuevo año, muchas son las expectativas que existen por lo que nos espera para esta nueva temporada, en lo referente a Java, MySQL, GlassFish y en especial NetBeans.
Ahora estos productos formaran parte de Oracle, realmente esperemos la evolución de -JavaFX, NetBeans 6.9.
Sin duda sera un año de muchos cambios...

Cuando usemos un equipo con pocos recursos y ejecutemos procesos que consumen muchos recursos, podemos encontrar un mensaje indicandonos esta situación.

Aquí podemos ver la ejecución

Ya esta disponible NetBeans 6.8 puedes descargarlo desde

Geertjan Wielenga, ha escrito en su blog una guia interesante de una aplicación CRUD, utilizando NetBeans Platform

Ya esta disponible la versión RC1 de NetBeans 6.8, una versión que incorpora algunas características interesantes, que puedes descargar desde aquí.
Algunas características:

• Java Enterprise Edition 6: JavaEE 6,EJB 3.1, JPA 2.0

• Web Projects con JavaServer Faces 2.0 (Facelets)

• JavaFx 1.2.1

• Soporte para PHP 5.3

• Maven

• Ruby

• C and C++

• Kenai.com

Buen tutorial disponible para NetBeans 6.8
Generating a JavaServer Faces 2.0 CRUD Application from a Database
Nuestro amigo Diego Silva, nos muestra una serie de videos con los pasos necesarios para crear las aplicaciones.
http://www.apuntesdejava.com/2009/11/javaday-uni-2009-javaee-6-lo-que-no-se.html

OpenCTI
Nuevo portal de CTI,
https://translate.sun.com/opencti/

El proyecto Zembly, que inicio hace aproximadamente 3 años, cerrara este 30 de Noviembre.

Aqui puedes encontrar información del equipo de desarrollo, en el sitio oficial
www.zembly.comZembly.com

En ésta ocasión Scott Hommel nos muestra en 6 pasos (un tutorial corto pero bueno) como crear una aplicación JavaFX que muestra un grupo de fotografías con transición automática y efectos entre transición, al estilo diapositivas. En realidad resulta bastante sencillo el ver cómo se realiza la aplicación con pocas líneas de código.

La herramienta que ha utilizado en éste caso es NetBeans, y a propósito de NetBeans ya está disponible para la descarga la versión 6.8 Beta y en el blog de Avbravo pueden encontrar una entrada NetBeans 6.8 Beta JavaFX Ubuntu 9.10 el nombre es por demás descriptivo de lo que encontrarán. Sería interesante hacer el slideshow con las herramientas del post de Avbravo.

Los 6 pasos que se muestran en el post Creating an Image Slideshow:

1. Crear el proyecto Slideshow
2. Crear el Stage y Scene
3. Configurar el color de fondo
4. Cargar y mostrar las imágenes
5. Agregar una línea de tiempo
6. Agregar la transición

El post de Hommel es interesante porque al final se muestran otros recursos relacionadas con cada una de las actividades realizadas para crear el post.

Espero que sea de su interés.

Nuestro amigo Diego Silva, ha hecho un recuento de algunos plugins interesantes que estan disponibles para NB6.8, puedes leer este blog aqui.

Con la llegada de Ubuntu 9.10 (Karmic Koala), me decidi a probar un poco NB6.8 Beta y JavaFx.

Ubuntu 9.10, nos ofrece en "Centro de Software Ubuntu", la versión de NetBeans 6.7.1