Serialización de objetos Java en XML

Posted on marzo 4, 2012 por 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 febrero 25, 2012 por 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 febrero 24, 2012 por 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 febrero 13, 2012 por 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.

Comunicación serial java y arduino

Posted on enero 28, 2012 por 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

El Blog de Jose

Blog de tecnología, software y programación

Archivo de la categoría: Java SE

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

Comunicación serial java y arduino

Uso de cookies