Documental de Arduino

Posted on March 21, 2012 by admin

Aqui les dejo el documental de Arduino, espero que lo disfruten tanto como yo, que grande son estos innovadores (para mi mas que soñadores, ya que lo hicieron realidad).

[vimeo clip_id=18539129]

Documental con subtítulos en español

[vimeo clip_id=18390711]

Por ultimo aprovechare este medio para solicitarles ayuda, todo material sea tutorial, biblioteca (library), sitio web, etc.. que conozcan, que trate acerca de XBEE explorer serial en Mac os X y la XBEE communication shield.

Estos son mis nuevos juguetes que me han regalo con motivo de mi cumpleaños y ya estoy deseoso de hacer algo con ellos.

Lo nuevo en Java 7

Posted on March 15, 2012 by admin

Tal como dice el titulo, si deseas conocer algunas de las novedades de Java 7, descárgate de forma gratuita este ebook y accede a el con tu aplicación kindle desde cualquiera de tus dispositivos, ya sea tu computadora, teléfono móvil (celular), tablet o dispositivo kindle.

Mas libros aquí

NOTA: Amazon también proporciona una aplicación Web en HTML5 para visualizar tus ebooks, que al igual que la app nativa te sincroniza tus notas, resaltados y ultima pagina alcanzada en la lectura del libro.

Parsing XML con StAX

Posted on March 12, 2012 by admin

Para muchos es común asociar parsing de documentos XML con DOM o SAX, pero ¿StAX?… no les sonará muy familiar.

¿Qué es StAX?

StAX (Streaming API for XML) es la ultima API en formar parte de la familia JAXP (Java API for XML Processing, conformado por SAX, DOM, StAX y TrAX) y nos provee una alternativa a SAX y DOM para el procesamiento de documentos XML. La principal meta de StAX es otorgarle el control del parseo al programador exponiendo una API basada en un iterador simple. StAX nos permite lograr un alto rendimiento en la iteración, procesado y modificación de documentos XML sobretodo en entornos donde se disponga de poca cantidad de memoria y limitada capacidad de extensibilidad.

Comparación de StAX con los otras API’s de JAXP

Característica	StAX	SAX	DOM	TrAX
Tipo de API	Pull, streaming	Push, streaming	En memoria	Regla XSLT
Facilidad de uso	Alta	Media	Alta	Media
Capacidad XPath	No	No	Si	Si
Eficiencia de CPU y memoria	Buena	Buena	Varia	Varia
Solo hacia adelante	Si	Si	No	No
Lee XML	Si	Si	Si	Si
Escribe XML	Si	No	Si	Si
Crear, Leer, Modificar, Borrar	No	No	Si	No

Casos de uso de StAX

Enlace de datos:

Marshalling/Unmarshalling de un documento XML. Procesamiento de documentos en paralelo y comunicación inalámbrica.

Procesamiento SOAP:

Parsing de estructuras simples predecibles, parsing de representaciones de grafos con referencias hacia adelante, parsing de WDSL.

Data source virtuales:

Ver datos almacenados en Bases de datos como XML, ver datos en objetos Java creados por enlace de datos XML (xml data binding), parseo de vocabularios XML específicos y procesamiento de XML canalizado.

StAX consta realmente de 2 distintas API:

Cursor API: Representa un cursor con el cual se puede ir hacia adelante en un documento XML desde el principio hasta el final. Este cursor puede apuntar un elemento a la vez y siempre se mueve hacia adelante, nunca hacia atrás.
Iterator API: Representa un flujo de un documento XML como un conjunto de objetos de eventos discretos. Estos eventos son sacados por la aplicación y provistos por el parseador en el orden en el cual ellos son leídos en la fuente del documento XML.

Una de las principales diferencias entre ambos estilos es que uno puede aferrarse a los objetos de evento ubicados a principios de XML cuando se usa la Iterator API, cosa que no puede realizarse cuando utilizamos la Cursor API, ya que una vez mueves el cursor hacia el próximo evento, no se tiene información acerca del evento previo. Sin embargo la Cursor API es mas eficiente en cuanto a memoria, así que la selección de que estilo de API utilizar dependerá de las necesidades y limitantes.

Muchos puede que aun tengan la necesidad de un ejemplo practico para tener una idea de donde utilizar StAX. Imaginen un documento XML con todos datos de los empleados de una gran organización de por ejemplo 5000 empleados, el trabajar con DOM implicaría cargar toda esa información en memoria y puede que el sistema no cuente con suficiente recursos para ello, mientras que trabajar con SAX implicaría parsear todo el documento, es aquí donde encaja StAX.

Una vez ya hemos dado algo de teoría, pasamos a la practica.

Dado un XML de empleados, mostrar únicamente aquellos donde el salario sea superior o igual a 30000.

Documento XML

<empleados>
	<empleado id="1">
		<nombre>José Antonio</nombre>
		<apellido>Rodríguez</apellido>
		<salario>30000</salario>
		<cargo>programador</cargo>
		<direccion>
			<ciudad>Madrid</ciudad>
			<provincia>Madrid</provincia>
			<cp>28020</cp>
			<calle>alcala</calle>
		</direccion>
	</empleado>
	<empleado id="2">
		<nombre>María José</nombre>
		<apellido>Rodríguez</apellido>
		<salario>35000</salario>
		<cargo>Contable</cargo>
		<direccion>
			<ciudad>Coslada</ciudad>
			<provincia>Madrid</provincia>
			<cp>28820</cp>
			<calle>henares</calle>
		</direccion>
	</empleado>
	<empleado id="3">
		<nombre>María Isabel</nombre>
		<apellido>Rodríguez</apellido>
		<salario>35500</salario>
		<cargo>Contralor</cargo>
		<direccion>
			<ciudad>Torrejon de Ardoz</ciudad>
			<provincia>Madrid</provincia>
			<cp>28850</cp>
			<calle>Guadiana</calle>
		</direccion>
	</empleado>
	<empleado id="4">
		<nombre>Fernando</nombre>
		<apellido>Carrillo</apellido>
		<salario>28000</salario>
		<cargo>gerente</cargo>
		<direccion>
			<ciudad>Madrid</ciudad>
			<provincia>Madrid</provincia>
			<cp>28029</cp>
			<calle>Ladera</calle>
		</direccion>
	</empleado>
	<empleado id="5">
		<nombre>Claudia</nombre>
		<apellido>marquez</apellido>
		<salario>20000</salario>
		<cargo>Asistenta</cargo>
		<direccion>
			<ciudad>Madrid</ciudad>
			<provincia>Madrid</provincia>
			<cp>28002</cp>
			<calle>clara del rey</calle>
		</direccion>
	</empleado>
</empleados>

<nombre>José Antonio</nombre>

<apellido>Rodríguez</apellido>

<cargo>programador</cargo>

<ciudad>Madrid</ciudad>

<provincia>Madrid</provincia>

<calle>alcala</calle>

</direccion>

</empleado>

<nombre>María José</nombre>

<apellido>Rodríguez</apellido>

<cargo>Contable</cargo>

<ciudad>Coslada</ciudad>

<provincia>Madrid</provincia>

<calle>henares</calle>

</direccion>

</empleado>

<nombre>María Isabel</nombre>

<apellido>Rodríguez</apellido>

<cargo>Contralor</cargo>

<ciudad>Torrejon de Ardoz</ciudad>

<provincia>Madrid</provincia>

<calle>Guadiana</calle>

</direccion>

</empleado>

<nombre>Fernando</nombre>

<apellido>Carrillo</apellido>

<cargo>gerente</cargo>

<ciudad>Madrid</ciudad>

<provincia>Madrid</provincia>

<calle>Ladera</calle>

</direccion>

</empleado>

<nombre>Claudia</nombre>

<apellido>marquez</apellido>

<cargo>Asistenta</cargo>

<ciudad>Madrid</ciudad>

<provincia>Madrid</provincia>

<calle>clara del rey</calle>

</direccion>

</empleado>

</empleados>

A continuación el código Java elaborado utilizando la Cursor API, asumiendo que estaríamos procesando un documento muy grande con la información de miles de empleados.

package jaxp.stax;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.ArrayList;

import javax.xml.stream.FactoryConfigurationError;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.events.XMLEvent;

/**
 * Ejemplo elaborado con cursor API
 * @author @josedeveloper
 *
 */
public class StaxExample {


	private static final String TAG_SALARIO = "salario";
	private static final String TAG_NOMBRE = "nombre";

	public static <e> void main(String[] args) throws FileNotFoundException, XMLStreamException, FactoryConfigurationError {

		//Creamos el flujo
		XMLInputFactory xmlif = XMLInputFactory.newInstance();

		//Cuando se crea una instancia de XMLStreamReader el evento inicial y actual es el START_DOCUMENT
		XMLStreamReader xmlsr = xmlif.createXMLStreamReader(new FileReader("PATH_FICHERO.xml"));
		ArrayList<string> nombres = new ArrayList<string>();
		String tag = null;
		String nombre = null;
		String salario = null;
		int eventType;

		System.out.println("Iniciando el documento");

		//iteramos con el cursor a lo largo del documento
		while (xmlsr.hasNext()){

			//obtenemos el tipo de evento
			eventType = xmlsr.next();

			//Al tener que manejar varios eventos el bloque switch resulta una solución elegante
			//para ir añadiendo case de eventos
			switch(eventType){

			case XMLEvent.START_ELEMENT:

				//obtenemos la etiqueta
				tag = xmlsr.getLocalName();

				if(tag.equals(TAG_NOMBRE)){
					nombre = xmlsr.getElementText();

				}else if(tag.equals(TAG_SALARIO)){
					salario = xmlsr.getElementText();
					if(Integer.parseInt(salario) >= 30000)
						nombres.add(nombre);
				}

				break;

			case XMLEvent.END_DOCUMENT:
				System.out.println("Fin del documento");
				break;

			}
		}

		System.out.println("Empleados con salario mayor a 30000: "+nombres);

	}
}

package jaxp.stax;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.util.ArrayList;

import javax.xml.stream.FactoryConfigurationError;

import javax.xml.stream.XMLInputFactory;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamReader;

import javax.xml.stream.events.XMLEvent;

/**

* Ejemplo elaborado con cursor API

* @author @josedeveloper

public class StaxExample {

private static final String TAG_SALARIO = "salario";

private static final String TAG_NOMBRE = "nombre";

public static <e> void main(String[] args) throws FileNotFoundException, XMLStreamException, FactoryConfigurationError {

//Creamos el flujo

XMLInputFactory xmlif = XMLInputFactory.newInstance();

//Cuando se crea una instancia de XMLStreamReader el evento inicial y actual es el START_DOCUMENT

XMLStreamReader xmlsr = xmlif.createXMLStreamReader(new FileReader("PATH_FICHERO.xml"));

ArrayList<string> nombres = new ArrayList<string>();

String tag = null;

String nombre = null;

String salario = null;

int eventType;

System.out.println("Iniciando el documento");

//iteramos con el cursor a lo largo del documento

while (xmlsr.hasNext()){

//obtenemos el tipo de evento

eventType = xmlsr.next();

//Al tener que manejar varios eventos el bloque switch resulta una solución elegante

//para ir añadiendo case de eventos

switch(eventType){

case XMLEvent.START_ELEMENT:

//obtenemos la etiqueta

tag = xmlsr.getLocalName();

if(tag.equals(TAG_NOMBRE)){

nombre = xmlsr.getElementText();

}else if(tag.equals(TAG_SALARIO)){

salario = xmlsr.getElementText();

if(Integer.parseInt(salario) >= 30000)

nombres.add(nombre);

}

break;

case XMLEvent.END_DOCUMENT:

System.out.println("Fin del documento");

break;

}

System.out.println("Empleados con salario mayor a 30000: "+nombres);

}

la salida final sería la siguiente:

Iniciando el documento
Fin del documento
Empleados con salario mayor a 30000: [José Antonio, María José, María Isabel]

Iniciando el documento

Fin del documento

Empleados con salario mayor a 30000: [José Antonio, María José, María Isabel]

Como han podido ver al realizar (o visualizar) el ejemplo, no resulta complejo utilizar StAX, lo complejo quizás pueda ser el entender como trabajan cada tipo de API y para eso nada mejor que la practica y por eso dejo de parte de ustedes realizar el ejemplo con la Iterator API.

Conclusión

El tratamiento (parsing) de documentos XML hoy en día resulta algo muy común, ya que el XML se esta convirtiendo o de facto ya lo es, el formato por defecto de intercambio de información, como en efecto podemos corroborarlo con los servicios web (tanto SOAP como REST) que establecen su comunicación mediante el envío y recepción de documentos XML, pero la realidad es que aun la cantidad de desarrolladores Java que desconocen o no utilizan StAX resulta muy grande, conviertiendolo en el gran desconocido, cuya consecuencia principal esta en la selección errónea en su lugar de DOM o SAX para el tratamiento del XML, cuando digo errónea no me refiero al estilo de programación sino a un mal uso de los recursos, sobretodo en esta época donde la conexión por medio de dispositivos móviles (moviles, pda’s, tablets, etc..) se ha incrementado a pasos agigantados y este es uno de los casos donde el uso de StAX viene como anillo al dedo, pero no resulta el único, ya que también dependiendo del caso (requerimientos y/o limitantes) su uso por ejemplo en un servidor puede resultar en una mejora en el rendimiento, sin que para esto se tenga que recurrir al aumento de recursos (mejor procesador, mas memoria RAM..) del equipo que efectúa el tratamiento del XML.

Información de este post ha sido obtenida del tutorial de Oracle y de jenkov.com

Serialización de objetos Java en XML

Posted on March 4, 2012 by admin

JAXB (Java Architecture for XML Binding) nos proporciona una API que nos permite mapear (mapping) entre documentos XML y objetos Java automaticamente. Será con este framework que llevaremos a cabo la serialización de un objeto Java en un fichero (que será un documento XML) persistiendo el estado del objeto, además de crear un objeto Java a partir de un documento XML (recuperando el estado que tenia dicho objeto al ser serializado).

Crearemos las siguientes clases:

1. Clase Localidad

@XmlType
class Localidad{
	private String nombre;
	private int cp;

	public String getNombre() {
		return nombre;
	}
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
	public int getCp() {
		return cp;
	}
	public void setCp(int cp) {
		this.cp = cp;
	}
}

@XmlType

class Localidad{

private String nombre;

private int cp;

public String getNombre() {

return nombre;

}

public void setNombre(String nombre) {

this.nombre = nombre;

}

public int getCp() {

return cp;

}

public void setCp(int cp) {

this.cp = cp;

}

2. Clase Provincia

@XmlRootElement
class Provincia {
	private String nombre;
	private Localidad[] localidad;

	public String getNombre() {
		return nombre;
	}
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
	public Localidad[] getLocalidad() {
		return localidad;
	}
	public void setLocalidad(Localidad[] localidad) {
		this.localidad = localidad;
	}

}

@XmlRootElement

class Provincia {

private String nombre;

private Localidad[] localidad;

public String getNombre() {

return nombre;

}

public void setNombre(String nombre) {

this.nombre = nombre;

}

public Localidad[] getLocalidad() {

return localidad;

}

public void setLocalidad(Localidad[] localidad) {

this.localidad = localidad;

}

Nada fuera de lo normal en estas clases salvo las annotations presentes.

@XmlType: Indica a JAXB que debería generar un tipo de dato XML schema a partir de un tipo de dato Java.

@XmlRootElement: Indica que JAXB debería generar un documento XML (la raíz) a partir de una clase Java

Por ultimo la clase con el main donde se llevará a cabo la serialización/deserialización de los objetos

package examples.serialization;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

public class JAXBSerializationExample {

	private static final String PROVINCIA_DAT_FILE = "provincia.dat";

	public static void main(String[] args) throws JAXBException, IOException {

		JAXBContext context = JAXBContext.newInstance(Provincia.class);
		Marshaller marshaller = context.createMarshaller();
		marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

		Provincia provincia = fillProvincia();

		//Mostramos el documento XML generado por la salida estandar
		marshaller.marshal(provincia, System.out);

		FileOutputStream fos = new FileOutputStream(PROVINCIA_DAT_FILE);
		//guardamos el objeto serializado en un documento XML
		marshaller.marshal(provincia, fos);
		fos.close();

		Unmarshaller unmarshaller = context.createUnmarshaller();
		//Deserealizamos a partir de un documento XML
		Provincia provincaAux = (Provincia) unmarshaller.unmarshal(new File(PROVINCIA_DAT_FILE));
		System.out.println("********* Provincia cargado desde fichero XML***************");
		//Mostramos por linea de comandos el objeto Java obtenido
		//producto de la deserialziacion
		marshaller.marshal(provincaAux, System.out);

	}

	private static Provincia fillProvincia(){

		String[] nombreLocalidad = {"Madrid", "Coslada"};
		int[] cpLocalidad = {28028, 28820};
		Localidad[] localidades = new Localidad[2];

		for(int i=0; i<2; i++){
			localidades[i] = new Localidad();
			localidades[i].setCp(cpLocalidad[i]);
			localidades[i].setNombre(nombreLocalidad[i]);
		}

		Provincia provincia = new Provincia();
		provincia.setNombre("Madrid");
		provincia.setLocalidad(localidades);

		return provincia;
	}

}

package examples.serialization;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import javax.xml.bind.JAXBContext;

import javax.xml.bind.JAXBException;

import javax.xml.bind.Marshaller;

import javax.xml.bind.Unmarshaller;

import javax.xml.bind.annotation.XmlRootElement;

import javax.xml.bind.annotation.XmlType;

public class JAXBSerializationExample {

private static final String PROVINCIA_DAT_FILE = "provincia.dat";

public static void main(String[] args) throws JAXBException, IOException {

JAXBContext context = JAXBContext.newInstance(Provincia.class);

Marshaller marshaller = context.createMarshaller();

marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

Provincia provincia = fillProvincia();

//Mostramos el documento XML generado por la salida estandar

marshaller.marshal(provincia, System.out);

FileOutputStream fos = new FileOutputStream(PROVINCIA_DAT_FILE);

//guardamos el objeto serializado en un documento XML

marshaller.marshal(provincia, fos);

fos.close();

Unmarshaller unmarshaller = context.createUnmarshaller();

//Deserealizamos a partir de un documento XML

Provincia provincaAux = (Provincia) unmarshaller.unmarshal(new File(PROVINCIA_DAT_FILE));

System.out.println("********* Provincia cargado desde fichero XML***************");

//Mostramos por linea de comandos el objeto Java obtenido

//producto de la deserialziacion

marshaller.marshal(provincaAux, System.out);

}

private static Provincia fillProvincia(){

String[] nombreLocalidad = {"Madrid", "Coslada"};

int[] cpLocalidad = {28028, 28820};

Localidad[] localidades = new Localidad[2];

for(int i=0; i<2; i++){

localidades[i] = new Localidad();

localidades[i].setCp(cpLocalidad[i]);

localidades[i].setNombre(nombreLocalidad[i]);

}

Provincia provincia = new Provincia();

provincia.setNombre("Madrid");

provincia.setLocalidad(localidades);

return provincia;

}

Como pueden ver resulta bastante sencillo la serialización de objetos a XML, quizás aquí no podamos apreciar todo su potencial, pero les puedo mencionar que es justo esto lo que utiliza el framework jax-ws en los servicios web SOAP con tipos de datos complejos, por supuesto cuando trabajamos con jax-ws no nos percatamos de esto ya que el framework esconde este proceso de convertir los datos XML recibidos en objetos Java y los objetos Java enviados con el cliente del servicio web convertidos a XML (Los servicios web envían XML para de esta manera ser interoperables e independientes de plataformas y lenguajes), siendo transparente para el programador, de esta manera el programador se enfoca en desarrollar la lógica de la aplicación (sea la creación del servicio web o la aplicación que hace uso del cliente del servicio).

Además de esta funcionalidad JAXB también nos ofrece otras herramientas como xjc que nos permite crear clases Java a partir de un XML schema (XSD) y schemagen que lleva a cabo la función inversa, es decir, crear un XML schema (XSD) a partir de una clase Java.

Como desplegar un servicio web sin utilizar un Java EE container

Posted on February 25, 2012 by admin

Desde la javaSE 6 es muy sencillo la creación de servicios Web ya que las annotations incluidas (proyecto Metro) en el jsdk nos permiten que un POJO pueda fácilmente convertirse en un servicio.

NOTA: Desde javaSE 5 podíamos crear servicios web con annotations, pero para entonces el jsdk no incluía al proyecto Metro, por lo cual era necesario descargar los jar necesarios del proyecto Metro e incluirlos en nuestra aplicación.

En esta oportunidad les traigo un pequeño ejemplo de un servicio Web pero con la particularidad de que lo desplegaremos sin hacer uso del un Java EE container (contenedor de servlet, servidor de aplicaciones).

Nuestro primer paso será crear el SEI (Service Endpoint Interface), aunque no es requisito indispensable, resulta en una buena practica de programación.

package examples.helloworld;

import javax.jws.WebMethod;
import javax.jws.WebService;

//Definimos el SEI
@WebService
public interface HelloWorld {

	//Indicamos que este metodo será una operación web
	@WebMethod
	public String sayHello(String name);
}

package examples.helloworld;

import javax.jws.WebMethod;

import javax.jws.WebService;

//Definimos el SEI

@WebService

public interface HelloWorld {

//Indicamos que este metodo será una operación web

@WebMethod

public String sayHello(String name);

}

Una vez definido el SEI procedemos a realizar la implementación del servicio o lo que es lo mismo el SBI (Service Bean Implementation).

package examples.helloworld;

import javax.jws.WebService;

//Enlazamos el SBI (esta clase) con el SEI
@WebService(endpointInterface="examples.helloworld.HelloWorld")
public class HelloWorldImpl implements HelloWorld {

	@Override
	public String sayHello(String name) {
		return "Hello "+name;
	}

}

package examples.helloworld;

import javax.jws.WebService;

//Enlazamos el SBI (esta clase) con el SEI

@WebService(endpointInterface="examples.helloworld.HelloWorld")

public class HelloWorldImpl implements HelloWorld {

@Override

public String sayHello(String name) {

return "Hello "+name;

}

Ahora viene una parte que a mi me resulta interesante, creamos el Publisher, el cual no es mas que la clase encargada de crear y publicar el endPoint de nuestro servicio Web.

package examples.helloworld;

import javax.xml.ws.Endpoint;

public class HelloWorldPublisher {
	public static void main(String[ ] args) {
	      // 1st argumento URL donde se publicara el servicio
	      // 2nd argumento SIB
	      Endpoint.publish("http://127.0.0.1:9876/helloworld", new HelloWorldImpl());
	    }
}

package examples.helloworld;

import javax.xml.ws.Endpoint;

public class HelloWorldPublisher {

public static void main(String[ ] args) {

// 1st argumento URL donde se publicara el servicio

// 2nd argumento SIB

Endpoint.publish("http://127.0.0.1:9876/helloworld", new HelloWorldImpl());

}

Para aquellos que no lo sepan, el servicio Web que acabamos de crear y publicar lo hemos hecho utilizando jax-ws y por ende nuestro servicio web es del tipo SOAP.

Como comprobar que nuestro servicio esta funcionando correctamente, teniendo en cuenta que no nos arroja ningún mensaje de error por consola? Sencillamente iniciemos nuestro navegador (browser) de preferencia e introduzcamos la ruta http://localhost:9876/helloworld?wsdl ó http://127.0.0.1:9876/helloworld?wsdl y les aparecerá un mensaje como este:

Ese documento XML que hemos obtenido no es mas que el WSDL (Web Service Definition Language) que es una especie de contrato donde están definidas las operaciones y características del servicio Web.

NOTA: Los usuarios de Safari verán sencillamente una pagina en blanco, pero si revisan el código fuente de dicha pagina podrán ver el documento XML, es esta la razón por la cual he optado por utilizar Firefox.

Ahora bien, ya hemos hecho un servicio Web, lo hemos publicado e incluso hemos podido ver su WSDL, queda realizar lo más esperado, poder ejecutar y probar nuestro servicio Web, para esta labor haré uso de SoapUI una herramienta gratuita que nos permite hacer pruebas de servicios web de forma sencilla, para esto crearemos un nuevo proyecto de SoapUI y le indicamos el WSDL de nuestro servicio Web, como verán en la siguiente imagen:

Esta herramienta utilizara el WSDL para construir los sobres SOAP haciendo muy sencilla la tarea de hacer las pruebas. Para finalizar haremos una ejecución editando el XML de petición que por defecto nos elabora soapUI y le colocaremos una cadena de caracteres, en este caso he utilizado mi nombre (Uds. tienen todo el derecho de colocar el suyo/vuestro jejeje) y procedemos a pulsar el símbolo de play o triángulo de ejecución y podrán ver el mensaje de respuesta de nuestro servicio.

Aqui les dejo una imagen de la ejecución hecha por mi.

Finalmente hemos realizado un servicio Web de tipo SOAP mediante jax-ws, lo hemos desplegado sin necesidad de un servidor de aplicaciones o contenedor Java EE (lo cual tiene sus limitantes, ya que solo puede recibir una petición a la vez) y hemos fácilmente hecho pruebas de nuestro servicio con una herramienta sencilla así como también útil que es soapUI. Espero les haya sido de utilidad y les haya resultado interesante.

Sabias que el serialVersionUID en las clases Java nos previene de errores en la deserialización

Posted on February 24, 2012 by admin

Estoy seguro que todos aquellos que hemos programado en Java en alguna oportunidad hemos visto como nuestro IDE nos arrojaba un warning (advertencia) indicandonos que “la clase serializable nombre_clase no declara un campo serialVersionUID final estatico de tipo long” y más seguro estoy (por experiencia propia) de que sin meditarlo mucho optamos por la opción que nos daba el IDE (eclipse, netbeans o cualquier otro) para que nos resolviera el warning y asi tener nuestro código limpio de mensajes de advertencia y errores.

Ejemplo de mensaje warning de serialVersionUID

¿Qué es serialVersionUID?

Es un número de versión que posee cada clase Serializable, el cual es usado en la deserialización para verificar que el emisor y el receptor de un objeto serializado mantienen una compatibilidad en lo que a serialización se refiere con respecto a la clases que tienen cargadas (el emisor y el receptor).

¿Qué pasa si no declaro un serialVersionUID?

El proceso de serialización asocia cada clase serializable a un serialVersionUID. Si la clase no especifica un serialVersionUID el proceso de serializacion calculará un serialVersionUID por defecto, basandose en varios aspectos de la clase. Es muy recomendable que se declare un serialVersionUID en las clases serializables, ya que el calculo del serialVersoinUID es muy sensible a detalles de la clase, los cuales pueden variar entre compiladores, es decir, si trabajamos serializando/deserializando objetos y trabajamos con distintos compiladores Java podemos llegar a obtener una InvalidClassException durante el proceso de deserialización debido a discrepancias entre los serialVersionUID calculados por cada compilador. Por eso para garantizar un serialVersionUID que sea indiferente a la implementación del compilador es altamente recomendado declarar un valor explicito del serialVersionUID (de tipo long) y de ser posible que tenga el modificador de acceso private para que afecte unicamente a la clase que lo ha declarado y no a las clases hijas (subclases) que hereden de ella, forzando de alguna manera a cada clase hija a declarar su propio serialVersionUID (Ver imagen abajo).

Ejemplo de herencia de clase Serializable observando warning de serialVersionUID en clase hija

Para mas información no dejen de revisar en la API la interfaz Serializable

Como compilar código Java desde una clase Java

Posted on February 13, 2012 by admin

Días atras dandole un vistazo a la Java API, me encontre con una interfaz que no tenia idea que existiera y es la interfaz JavaCompiler. A continuación un ejemplo sencillo de como compilar una clase:

import java.io.IOException;

import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;

public class JavaCompilerExample {
	public static void main(String args[]) throws IOException{

		//Obtenemos el compilador Java del sistema
		JavaCompiler compiler =ToolProvider.getSystemJavaCompiler();
	    //Ejecuta la compilacion
		int results = compiler.run(null, null, null, "C:/Example.java");
	    System.out.println("Success: " + (results == 0));
	}

}

import java.io.IOException;

import javax.tools.JavaCompiler;

import javax.tools.ToolProvider;

public class JavaCompilerExample {

public static void main(String args[]) throws IOException{

//Obtenemos el compilador Java del sistema

JavaCompiler compiler =ToolProvider.getSystemJavaCompiler();

//Ejecuta la compilacion

int results = compiler.run(null, null, null, "C:/Example.java");

System.out.println("Success: " + (results == 0));

}

Para el ejemplo anteriormente mostrado, asumimos que hemos codificado una clase y ubicada en c:/Example.java. Como mi idea es demostrar como compilar, le dejo a ustedes la tarea de crear una clase cualquiera, con y sin errores para poder observar la salida de la ejecución de este programa.

Brevemente comento del código.

Clase ToolProvider, disponible desde la versión 6, esta clase nos permite obtener proveedores de compiladores.
Invocación del método run, método heredado de la interfaz Tool (presente desde la versión 6 de Java), es una interfaz utilizada para invocar programas, y en nuestro caso la utilizamos para la invocación del compilador. Incluso podríamos obtener las versiones soportadas por la herramienta invocando el método getSourceVersions();

La anterior no es la única forma de poder llevar a cabo la compilación, he aquí otro ejemplo, pero en este caso usando métodos propios de la interfaz JavaCompiler.

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;

public class JavaCompilerExample2 {

	public static void main(String args[]) throws IOException{

		//Obtenemos el compilador Java del sistema
		JavaCompiler compiler =ToolProvider.getSystemJavaCompiler();
		String sourceFile = "C:/Example.java";
	    //Obtenemos manejador estandar de ficheros
		StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);

	    List sourceFileList = new ArrayList();
	    sourceFileList.add(new File(sourceFile));
	    Iterable compilationUnits = fileManager
	        .getJavaFileObjectsFromFiles(sourceFileList);
	    //Obtenemos la tarea de compilación a ejecutar posteriormente
	    CompilationTask task = compiler.getTask(null, fileManager, null, null, null, compilationUnits);
	    //Ejecutamos la tarea
	    boolean result = task.call();
	    if (result)
	      System.out.println("La compilación ha sido exitosa");
	    else
	      System.out.println("La compilación ha fallado");

	    fileManager.close();
	}

}

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import javax.tools.JavaCompiler;

import javax.tools.JavaFileObject;

import javax.tools.StandardJavaFileManager;

import javax.tools.ToolProvider;

import javax.tools.JavaCompiler.CompilationTask;

public class JavaCompilerExample2 {

public static void main(String args[]) throws IOException{

//Obtenemos el compilador Java del sistema

JavaCompiler compiler =ToolProvider.getSystemJavaCompiler();

String sourceFile = "C:/Example.java";

//Obtenemos manejador estandar de ficheros

StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);

List sourceFileList = new ArrayList();

sourceFileList.add(new File(sourceFile));

Iterable compilationUnits = fileManager

.getJavaFileObjectsFromFiles(sourceFileList);

//Obtenemos la tarea de compilación a ejecutar posteriormente

CompilationTask task = compiler.getTask(null, fileManager, null, null, null, compilationUnits);

//Ejecutamos la tarea

boolean result = task.call();

if (result)

System.out.println("La compilación ha sido exitosa");

else

System.out.println("La compilación ha fallado");

fileManager.close();

}

Esta ultima forma de llevar a cabo la compilación, particularmente es de mi preferencia ya que nos permite mejorar en rendimiento, en el caso de que llevemos a cabo la compilación de un grupo de ficheros (archivos) mientras reutilicemos el gestor de archivos, además de poder pasarle de una forma mas ordenada las opciones de compilación.

NOTA: En este segundo ejemplo también dejo de parte de ustedes la creación del fichero a compilar (C:/Example.java), que en este caso he hecho uso del mismo en ambos ejemplos.

espero les pueda ser de utilidad, incluso podríamos hasta crearnos nuestro propio IDE, donde compilemos y a su vez nos muestre los mensajes de error en caso de haberlos.

Sabias que los literales enteros en Java por defecto son compilados como int

Posted on February 10, 2012 by admin

Este es el primer post de la nueva categoría que he denominado “Sabias que…”, donde les iré contando cosas que me resultan curiosas e interesantes sin que por eso no dejen de ser algunas veces “triviales”, en esta oportunidad les contare algo que algunos puede que desconozcan e incluso puede que llegue a serles útil en el caso de buscar certificarse.

Sin más preámbulos, así como dice el titulo, por defecto todos los literales enteros que declaremos en nuestro programa Java, serán compilados como int (entero). Lo demostrare mediante el siguiente ejemplo, que consistirá de una función que validará el rango de un número entero. Realmente es un ejemplo sencillo pero que cumple con el objetivo del post. A continuación el código.

public class DefaultLiteralExample {

	public static boolean validarRangoEntero(long valor, long min, long max){

		if((min <= valor) && (valor <= max))
			return true;
		return false;
	}

	public static void main(String args[]){
		//Se podría suponer que habia un cast automatico
		//pero NO es asi
		validarRangoEntero(30, 1, 9999999999);

	}
}

public class DefaultLiteralExample {

public static boolean validarRangoEntero(long valor, long min, long max){

if((min <= valor) && (valor <= max))

return true;

return false;

}

public static void main(String args[]){

//Se podría suponer que habia un cast automatico

//pero NO es asi

validarRangoEntero(30, 1, 9999999999);

}

Si compilan el código mostrado anteriormente, les aparecería el mensaje

DefaultLiteralExample.java:14: integer number too large: 9999999999
 validarRangoEntero(30, 1, 9999999999);

1 2	DefaultLiteralExample.java:14: integer number too large: 9999999999 validarRangoEntero(30, 1, 9999999999);

Si hacen uso del IDE Eclipse les aparecería el mensaje “The literal 9999999999 of type int is out of range”.

Es un error de compilación que se resuelve sencillamente agregando la letra “L”, al literal quedando de esta manera 9999999999L.

Como pueden ver es algo muy sencillo, incluso para algunos será trivial pero les aseguro que en una prueba de certificación mas de uno de seguro se equivocaría y diría que el código se compila perfectamente, asumiendo un cast automático.

Si deseas compartir con nosotros eso que te parece interesante y/o curioso, no dudes en hacerlo, así todos aprenderemos.

Cambiar estilos en tu tema de blog wordpress

Posted on January 30, 2012 by admin

Tienes problemas con los estilos de tu blog wordpress y deseas cambiarlos, si es ese el caso, no te preocupes a continuación te mostrare una solución sencilla.

Primero que nada, no cambies directamente los estilos en el tema de tu blog, ya que si posteriormente actualizas la versión del tema, puede que pierdas los cambios realizados. La solución esta en crear un tema hijo (child theme) a partir de un tema de tu preferencia que hayas seleccionado para tu blog.

Para crear un tema hijo, debes seguir los siguientes pasos:
– Dentro de tu carpeta wp-content/themes, crea una carpeta con el nombre que pensaras darle a tu nuevo tema.
– Dentro de la carpeta de tu nuevo tema, crea un fichero style.css. Lo minimo necesario que ha de tener este fichero es lo siguiente

/*
Theme Name: Twenty Eleven Child
Theme URI:
Description: Child theme for the Twenty Eleven theme
Author: Jose Antonio
Author URI:
Template: twentyeleven
Version: 1.0
*/

@import url("../twentyeleven/style.css");

Theme Name: Twenty Eleven Child

Theme URI:

Description: Child theme for the Twenty Eleven theme

Author: Jose Antonio

Author URI:

Template: twentyeleven

Version: 1.0

@import url("../twentyeleven/style.css");

IMPORTANTE: Los campos “Theme Name” y “Template”, no los dejes vacíos. A continuación una breve explicación de los campos

Theme Name: se utiliza para especificar el nombre del nuevo tema (hijo) que estas creando.
Theme URI: Sitio web del tema.
Description: Descripción del nuevo tema (hijo) a crear.
Author: Autor del nuevo tema.
Author URI: Sitio web del autor del tema
Template: Tema padre desde el cual estamos heredando estilos.
Version: Versión del tema a crear.

Por ultimo se puede notar la sentencia “@import url(“../twentyeleven/style.css”);”, aquí lo que se hace es importar el fichero de estilos del tema padre.

Cualquier estilo que deseas modificar o añadir, sencillamente agregalo al fichero style.css del nuevo tema a crear (ver ejemplo mas abajo).

Por ultimo indicarles que el funcionamiento será de la siguiente manera, para todos los estilos encontrados, se seleccionarán los estilos especificados en el nuevo fichero style.css del nuevo tema (hijo) creado, en caso de no encontrarlo, hará uso del estilo presente en el fichero style.css del tema padre. En caso de necesitar una personalización más profunda del nuevo tema, se puede crear el fichero functions.php en el nuevo tema y también se podrán añadir ficheros php y su funcionamiento será semejante al de los estilos, en caso de invocar un fichero .php tendrán prioridad los presentes en el tema hijo, en caso de no existir se utilizará el fichero presente en el tema padre.

Finalmente aquí les dejo el fichero (completo) style.css de mi nuevo tema.

/*
Theme Name: Twenty Eleven Child
Theme URI:
Description: Child theme for the Twenty Eleven theme
Author: Jose Antonio
Author URI: http:
Template: twentyeleven
Version: 1.0
*/

@import url("../twentyeleven/style.css");

.singular .entry-header,
.singular .entry-content,
.singular footer.entry-meta,
.singular #comments-title {
margin: 0 auto;
width: 100%;
}

.singular .entry-header,
.singular .entry-content,
.singular footer.entry-meta,
.singular #comments-title {
width: 100%;
}

Theme Name: Twenty Eleven Child

Theme URI:

Description: Child theme for the Twenty Eleven theme

Author: Jose Antonio

Author URI: http:

Template: twentyeleven

Version: 1.0

@import url("../twentyeleven/style.css");

.singular .entry-header,

.singular .entry-content,

.singular footer.entry-meta,

.singular #comments-title {

margin: 0 auto;

width: 100%;

}

.singular .entry-header,

.singular .entry-content,

.singular footer.entry-meta,

.singular #comments-title {

width: 100%;

}

Comunicación serial java y arduino

Posted on January 28, 2012 by admin

Voy a mostrarles a continuación un sencillo ejemplo de interacción y comunicación vía Serial con una placa Arduino (one). Tengo aproximadamente un mes jugando con mi arduino one y confirmo lo que me habían contado, “es sencillamente emocionante ver que haces encender y apagar un LED”, como me comento una amiga “es un juego para adultos”, no me queda mas que reirme y aceptar que en mi caso es así y disfruto del poco tiempo que he podido dedicarme a hacer ejemplos.

Ha sido de esta manera, haciendo ejemplos del libro Getting Started with Arduino y leyendo por internet que me nació el gusanillo (curiosidad) por hacer un sencillo ejemplo pero donde en vez de comunicar los lenguajes Processing y Arduino, lo hiciera usando Java, C o C++ (estos 2 últimos espero poder hacerlos y de ser posible publicarlos mas adelante). ¿Con qué finalidad? además de aprender, sencillamente poder gozar de las bondades y herramientas que nos ofrece el trabajar con los lenguajes anteriormente mencionados.

Ahora si vamos al grano, primero indicare los componentes utilizados:

1 Placa arduino one
1 bombillo LED
1 cable usb AM/BM (para cargar programa arduino)

La conexión es muy sencilla, consiste únicamente de colocar el LED (la pata mas larga) en el pin 13 y la otra pata en GND (tierra).

Una vez, hecho esto pasamos a hacer el sketch Arduino.

const int LED = 13; //LED connected to digital pin 13
int inByte = 0;

void setup(){
    Serial.begin(9600); //Open the serial port
    pinMode(LED, OUTPUT); //Set the digital pin as output
}

void loop(){

    if(Serial.available() > 0){

        inByte = Serial.read(); //read the incoming byte

        if(inByte == '1')
            digitalWrite(LED, HIGH); //turn the LED on
        else
            digitalWrite(LED, LOW); //turn the LED off
    }
}

const int LED = 13; //LED connected to digital pin 13

int inByte = 0;

void setup(){

Serial.begin(9600); //Open the serial port

pinMode(LED, OUTPUT); //Set the digital pin as output

}

void loop(){

if(Serial.available() > 0){

inByte = Serial.read(); //read the incoming byte

if(inByte == '1')

digitalWrite(LED, HIGH); //turn the LED on

else

digitalWrite(LED, LOW); //turn the LED off

}

Compilamos el sketch y lo cargamos en la placa Arduino. Cargado el sketch, procedemos entonces con el programa Java. Para poder conectarnos con la placa arduino será necesario que tengamos la biblioteca RXTX (una biblioteca semejante a la Java Communications API extension), esta biblioteca posee los jar necesarios para poder establecer comunicación vía serial con la placa. La instalación dependerá del sistema operativo que utilicen, así que les recomiendo seguir los pasos de instalación indicados en el fichero README de la versión de la biblioteca (así sea la versión con los binarios o los fuentes) que se descarguen, o en el sitio web en la sección de instalación.

Una vez descargada e instalada la biblioteca RXTX, seguimos con nuestro programa Java, que consistirá unicamente de una interfaz grafica sencilla (un JFrame) con 2 botones para encender o apagar el LED.

Aqui les dejo el código fuente java:

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Enumeration;

import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class JPanelTurnOnOffLED extends JPanel
	implements ActionListener {

	private static final String ON = "On";
	private static final String OFF = "Off";
	private static final String TURN_ON = "1";
	private static final String TURN_OFF = "0";

	private JButton switchOnButton;
	private JButton switchOffButton;
	private JLabel label;
	private JFrame frame;

	/** The output stream to the port */
	private OutputStream output = null;

	SerialPort serialPort;
	private final String PORT_NAME = "/dev/cu.usbmodem1d11";
	/** Milliseconds to block while waiting for port open */
	private static final int TIME_OUT = 2000;
	/** Default bits per second for COM port. */
	private static final int DATA_RATE = 9600;

	public JPanelTurnOnOffLED(){
		switchOnButton = new JButton(ON);

		switchOffButton = new JButton(OFF);
		switchOffButton.setEnabled(false);

		label = new JLabel("Turn On/Off LED:");

		switchOnButton.addActionListener(this);
		switchOffButton.addActionListener(this);

		add(label);
		add(switchOnButton);
		add(switchOffButton);

		initializeArduinoConnection();
	}

	public void initializeArduinoConnection(){

		CommPortIdentifier portId = null;
		Enumeration portEnum = CommPortIdentifier.
								getPortIdentifiers();

		// iterate through, looking for the port
		while (portEnum.hasMoreElements()) {
			CommPortIdentifier currPortId = (CommPortIdentifier)
					portEnum.nextElement();

			if (PORT_NAME.equals(currPortId.getName())) {
				portId = currPortId;
				break;
			}
		}

		if (portId == null) {
			showError("Could not find COM port.");
			System.exit(ERROR);
			return;
		}

		try {
			// open serial port, and use class name for the appName.
			serialPort = (SerialPort) portId.open(this.getClass()
					.getName(), TIME_OUT);

			// set port parameters
			serialPort.setSerialPortParams(DATA_RATE,
					SerialPort.DATABITS_8,
					SerialPort.STOPBITS_1,
					SerialPort.PARITY_NONE);

			// open the streams
			output = serialPort.getOutputStream();

		} catch (Exception e) {
			showError(e.getMessage());
			System.exit(ERROR);
		}

	}

	public static void createAndShowGUI(){

		JFrame frame = new JFrame("Turn On/Off LED example");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		//Create and set up the content pane.
		JPanelTurnOnOffLED newContentPane = new JPanelTurnOnOffLED();
        newContentPane.setOpaque(true); //content panes must be opaque
        frame.setContentPane(newContentPane);

        //Display the window.
        frame.pack();
        frame.setVisible(true);
	}

	public static void main(String args[]){

		javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });

	}

	@Override
	public void actionPerformed(ActionEvent e) {
		if(ON.equals(e.getActionCommand())){
			switchOnButton.setEnabled(false);
			switchOffButton.setEnabled(true);
			sendData(TURN_ON);

		}else{
			switchOnButton.setEnabled(true);
			switchOffButton.setEnabled(false);
			sendData(TURN_OFF);
		}

	}

	private void sendData(String data){

		try {
			output.write(data.getBytes());
		} catch (IOException e) {
			showError("Error sending data");
			System.exit(ERROR);
		}
	}

	private void showError(String errorMessage){
		JOptionPane.showMessageDialog(frame,
				errorMessage,
			    "Error",
			    JOptionPane.ERROR_MESSAGE);
	}

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.IOException;

import java.io.OutputStream;

import java.util.Enumeration;

import gnu.io.CommPortIdentifier;

import gnu.io.SerialPort;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

public class JPanelTurnOnOffLED extends JPanel

implements ActionListener {

private static final String ON = "On";

private static final String OFF = "Off";

private static final String TURN_ON = "1";

private static final String TURN_OFF = "0";

private JButton switchOnButton;

private JButton switchOffButton;

private JLabel label;

private JFrame frame;

/** The output stream to the port */

private OutputStream output = null;

SerialPort serialPort;

private final String PORT_NAME = "/dev/cu.usbmodem1d11";

/** Milliseconds to block while waiting for port open */

private static final int TIME_OUT = 2000;

/** Default bits per second for COM port. */

private static final int DATA_RATE = 9600;

public JPanelTurnOnOffLED(){

switchOnButton = new JButton(ON);

switchOffButton = new JButton(OFF);

switchOffButton.setEnabled(false);

label = new JLabel("Turn On/Off LED:");

switchOnButton.addActionListener(this);

switchOffButton.addActionListener(this);

add(label);

add(switchOnButton);

add(switchOffButton);

initializeArduinoConnection();

}

public void initializeArduinoConnection(){

CommPortIdentifier portId = null;

Enumeration portEnum = CommPortIdentifier.

getPortIdentifiers();

// iterate through, looking for the port

while (portEnum.hasMoreElements()) {

CommPortIdentifier currPortId = (CommPortIdentifier)

portEnum.nextElement();

if (PORT_NAME.equals(currPortId.getName())) {

portId = currPortId;

break;

}

if (portId == null) {

showError("Could not find COM port.");

System.exit(ERROR);

return;

}

try {

// open serial port, and use class name for the appName.

serialPort = (SerialPort) portId.open(this.getClass()

.getName(), TIME_OUT);

// set port parameters

serialPort.setSerialPortParams(DATA_RATE,

SerialPort.DATABITS_8,

SerialPort.STOPBITS_1,

SerialPort.PARITY_NONE);

// open the streams

output = serialPort.getOutputStream();

} catch (Exception e) {

showError(e.getMessage());

System.exit(ERROR);

}

public static void createAndShowGUI(){

JFrame frame = new JFrame("Turn On/Off LED example");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//Create and set up the content pane.

JPanelTurnOnOffLED newContentPane = new JPanelTurnOnOffLED();

newContentPane.setOpaque(true); //content panes must be opaque

frame.setContentPane(newContentPane);

//Display the window.

frame.pack();

frame.setVisible(true);

}

public static void main(String args[]){

javax.swing.SwingUtilities.invokeLater(new Runnable() {

public void run() {

createAndShowGUI();

}

});

}

@Override

public void actionPerformed(ActionEvent e) {

if(ON.equals(e.getActionCommand())){

switchOnButton.setEnabled(false);

switchOffButton.setEnabled(true);

sendData(TURN_ON);

}else{

switchOnButton.setEnabled(true);

switchOffButton.setEnabled(false);

sendData(TURN_OFF);

}

private void sendData(String data){

try {

output.write(data.getBytes());

} catch (IOException e) {

showError("Error sending data");

System.exit(ERROR);

}

private void showError(String errorMessage){

JOptionPane.showMessageDialog(frame,

errorMessage,

"Error",

JOptionPane.ERROR_MESSAGE);

}

NOTA: Tener en cuenta que para programar en Java podremos usar el IDE de nuestra preferencia, en mi caso he utilizado Eclipse. [Actualización] En el código Java no olvidar editar la constante PORT_NAME e indicar el puerto que utilicen[/Actualización]

Para compilar escribir en consola:
javac -classpath path_instalacion_biblioteca/RXTXcomm.jar:. JPanelTurnOnOffLED.java

Después de haber compilado nuestro programa Java, procedemos a ejecutarlo, de la siguiente manera:

java -Djava.library.path=. -cp path_instalacion_biblioteca/RXTXcomm.jar:. JPanelTurnOnOffLED

path_instalacion_biblioteca: Ruta de instalación de la biblioteca, es decir, donde estarán alojados los jar.

Voilà!!!, ya deberíamos poder visualizar el JFrame con sus respectivos botones de encendido y apagado. Así que, ¿qué esperas? empieza ya a encender y apagar tu LED.

Recomendación: En el libro Getting Started with Arduino, nos sugieren que en caso de mantener el LED mucho tiempo encendido usar una resistencia de 270 ohm, en cuyo caso necesitaríamos adicionalmente para hacer nuestro ejemplo una breadboard y par de cables.

Puntos importantes a tener en cuenta para usuarios Mac OS X (snow leopard)

– Si colocas (copiar con el comando sudo) la biblioteca RXTX en /Library/Java/Extensions, nuestro programa java podrá ser compilado y ejecutado de la siguiente manera:

javac JPanelTurnOnOffLED.java

java JPanelTurnOnOffLED

Aunque esta quizás no es la forma más recomendada en caso de que se llegase a trabajar con distintas versiones de la biblioteca, ya que en ese caso lo adecuado sería tener una instalación para cada versión y compilar y ejecutar nuestro programa Java de la manera indicada en un principio para poder indicarle al compilador y a la maquina virtual con que versión de la biblioteca estamos trabajando.

– Puede que te sea necesario al momento de ejecutar el programa Java indicar que se ejecute en 32 bits, si obtienes una exception similar a la que te muestro a continuación

“java.lang.UnsatisfiedLinkError: /Library/Java/Extensions/librxtxSerial.jnilib: no suitable image found. Did find: /Library/Java/Extensions/librxtxSerial.jnilib: no matching architecture in universal wrapper thrown while loading gnu.io.RXTXCommDriver”

Lo que implicará que tengamos que añadir un argumento a nuestro comando de ejecución , quedando de la siguiente manera

java -d32 JPanelTurnOnOffLED

– Ir a la carpeta /var/lock (si no existe, crearla) y otorgarle permisos de escritura al o los usuarios que vayan a ejecutar el programa, esto podrás hacerlo desde el finder o por linea de comandos con el comando chmod.

Conclusión

Cada día que pasa y me involucro más con mi nuevo hobbie, me fascino con su versatilidad, pues además de ser una arquitectura abierta, nos permite interactuar con una gran gama de lenguajes de programación entre los que les puedo mencionar C, C++, Java, Objective-C, entre otros, de una gran lista, lo cual como les dije antes, nos permite gozar de las bondades (ventajas) de un lenguaje o plataforma de software, como lo es en este caso Java, ya que podríamos aprovechar el gran numero de bibliotecas existentes, así como también de su variedad de frameworks (que son unos cuantos). Este ejemplo ha resultado interesante para mi, ya que además de lo mencionado anteriormente, es un ejemplo que podemos extrapolar a algo mas complejo, es decir, podemos imaginar que en vez de ser 2 botones, podemos crear una interfaz mas compleja con unos 5 o 6 botones y cada uno de ellos con una instrucción distinta, que nos permita por ejemplo dado el botón pulsado, ver en una pantalla, la temperatura, posicionamiento global, etc…, o incluso controlar un servomotor.

En fin, como comente en un post anterior, aquí el limite es nuestra imaginación y mas aun cuando podemos interactuar con una variedad de lenguajes, lo que no resulta en un impedimento el no saber Processing, pues si tu fuerte es Perl, Python o Java, no importa, puedes empezar a programar ya!!!.

Video de la aplicación Java en ejecución
[tube]http://www.youtube.com/watch?v=jwGwnlEBuAI[/tube]

User's blog

Author Archives: admin

Documental de Arduino

Lo nuevo en Java 7

Parsing XML con StAX

Serialización de objetos Java en XML

Como desplegar un servicio web sin utilizar un Java EE container

Sabias que el serialVersionUID en las clases Java nos previene de errores en la deserialización

Como compilar código Java desde una clase Java

Sabias que los literales enteros en Java por defecto son compilados como int

Cambiar estilos en tu tema de blog wordpress

Comunicación serial java y arduino