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

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

Posted on febrero 10, 2012 por 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.

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

entrada por linea de comandos con Java

Posted on febrero 23, 2011 por admin

Aquellos que como yo vienen de la vieja escuela Java (por ejemplo java 1.1 o 1.2) recordarán que era algo engorroso la cantidad de lineas de código a escribir para ingresar datos por linea de comandos con Java(hay que comprender que desde un principio Java no estuvo pensado para esto), he aqui un ejemplo

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class EntradaDatosViejaForma {

	public static void main(String[] args){
		
		InputStreamReader isr = new InputStreamReader(System.in);
		BufferedReader br = new BufferedReader(isr);
		
		System.out.println("Introducir un numero: ");
		String dato;
		
		try {
		
			dato = br.readLine();
			System.out.println("El numero introducido fue: "+dato);
	
		} catch (IOException e) {
			e.printStackTrace();
		}	
	}

}

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class EntradaDatosViejaForma {

public static void main(String[] args){

InputStreamReader isr = new InputStreamReader(System.in);

BufferedReader br = new BufferedReader(isr);

System.out.println("Introducir un numero: ");

String dato;

try {

dato = br.readLine();

System.out.println("El numero introducido fue: "+dato);

} catch (IOException e) {

e.printStackTrace();

}

Desde la versión 1.6 de java existe la clase java.io.Console, una clase que nos hace un poco mas intuitivo el manejo (entrada y salida) de datos por linea de comandos, al igual que otros lenguajes como podrían ser C/C++.
Les muestro ahora la clase anterior haciendo uso de la clase Console

import java.io.Console;


public class EntradaDatosNuevaForma {

	public static void main(String[] args) {
		
		Console console = System.console();
		
		if (console == null) {
            System.err.println("No hay consola.");
            System.exit(1);
        }
		
		console.printf("Introducir un numero: ");
		String dato = console.readLine();
		
		console.printf("El numero introducido fue: %s \n", dato);
	}

}

import java.io.Console;

public class EntradaDatosNuevaForma {

public static void main(String[] args) {

Console console = System.console();

if (console == null) {

System.err.println("No hay consola.");

System.exit(1);

}

console.printf("Introducir un numero: ");

String dato = console.readLine();

console.printf("El numero introducido fue: %s \n", dato);

}

Como se puede observar es código es menor e incluso no hay que agregar una parte de código que para mi es engorrosa (en este caso) y son los bloques try, catch, así como tampoco manejar flujos, sino que en cambio se hace todo de una forma mas amigable por medio de la invocación de métodos de la clase Console. Hay una parte del código que seguro les causa un poco de curiosidad y es el ubicado entre las lineas 9-12, y este se debe, ya que hay ocasiones en que la obtención de la consola puede ser null, esto es debido a que las operaciones de consola o linea de comandos no están permitidas, por ejemplo al intentar el programa anterior desde el IDE Eclipse.

Además de los métodos de la clase Console utilizados en el segundo ejemplo, también existen métodos para entrada de password, lo cual deshabilita la impresión (o mostrado) de los valores ingresados por linea de comandos, así como también métodos para salida de datos formateados.

Si no has utilizado antes esta clase, no te preocupes tiene una API muy sencilla.

¿Has hecho alguna aplicación interesante con la clase Console? cuentalo y comparte tu experiencia con nosotros.

El Blog de Jose

Blog de tecnología, software y programación

Archivo de la etiqueta: java

Serialización de objetos Java en XML

Como compilar código Java desde una clase Java

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

Comunicación serial java y arduino

entrada por linea de comandos con Java

Uso de cookies