JavaFX: DialogBox/MessageBox

Actualmente dentro de las utilidades de JavaFX no existe la opción para desplegar Dialog Box o Message Box. Estas utilidades se pueden crear desde cero pero puede que lleven un poco de tiempo. A continuación se mostrará un alternativa que usa la siguiente librería. <-click.

Si no saben como agregar la librería en eclipse pueden visitar este post. Al importar y usar esta librería se podrán desplegar mensajes como el de la imagen anterior usando las siguientes lineas de código:

	import javafx.application.Application;
	import javafx.stage.Stage;
	import jfx.messagebox.MessageBox;
	public class SimpleMessageBox extends Application {
	@Override
	public void start(Stage primaryStage) {
	int answer = MessageBox.show(primaryStage,
	"Ejemplo de un DialogBox.\n\nLas opciones son las siguientes.\n[MessageBox.ICON_INFORMATION | MessageBox.OK | MessageBox.CANCEL]",
	"Information dialog",
	MessageBox.ICON_INFORMATION| MessageBox.OK | MessageBox.CANCEL);
	if (answer == MessageBox.OK) {
	System.out.println("Ok");
	} else if (answer == MessageBox.CANCEL) {
	System.out.println("Cancel");
	}
	answer = MessageBox.show(primaryStage,
	"Ejemplo de un mensaje de error.\n\nLas opciones son las siguientes.\n[MessageBox.ICON_ERROR]",
	"Error dialog",
	MessageBox.ICON_ERROR);
	System.out.println(answer);
	}
	public static void main(String[] args) {
	launch(args);
	}
	}

view raw DialogBoxFX.java hosted with ❤ by GitHub

Como se puede observar el método MessageBox.show(), requiere cuatro parámetros que son: Un Stage padre, mensaje a desplegar, titulo de la ventana y los botones e iconos que se deseen desplegar. El primer caso despliega la imagen anterior y el segundo un mensaje de error con un botón de aceptar. 

Como retorno el método de MessageBox.show() devuelve un Integer o int con el valor de la acción seleccionada el cual se puede usar para continuar con el flujo del programa.

JavaFX: Agregar Botón a Tabla

Tema relacionado: Agregar y eliminar filas en TableView

En una entrada anterior (esta) se mostró como crear una tabla con JavaFX. En este caso se hará un ejemplo agregando un botón en las celdas de la tabla. La tabla quedará como lo muestra la siguiente imagen:

En las tablas de JavaFX existe la opción de agregar celdas personalizadas, como se puede ver en la imagen existe un botón dentro de la celda. Otro punto importante es el manejo del contenido de la tabla por medio de una lista observable que realiza los cambios en la tabla cuando la lista cambia. El código de la tabla anterior es el siguiente:

	import javafx.application.Application;
	import javafx.beans.property.SimpleStringProperty;
	import javafx.collections.FXCollections;
	import javafx.collections.ObservableList;
	import javafx.event.Event;
	import javafx.event.EventHandler;
	import javafx.scene.Group;
	import javafx.scene.Scene;
	import javafx.scene.control.Button;
	import javafx.scene.control.TableColumn;
	import javafx.scene.control.TableView;
	import javafx.scene.control.cell.PropertyValueFactory;
	import javafx.stage.Stage;
	public class TableViewSample extends Application {
	private TableView table = new TableView();
	public static void main(String[] args) {
	launch(args);
	}
	@Override
	public void start(Stage stage) throws Exception {
	Group group = new Group();
	Scene scene = new Scene(group);
	stage.setTitle("Table View Sample");
	stage.setWidth(400);
	stage.setHeight(500);
	ObservableList<Person> data = FXCollections.observableArrayList(
	new Person("Paco", "Perez", "12345678",new Button("Info")),
	new Person("Isabella", "Garcia","12345678", new Button("Info")),
	new Person("Juan", "Juanes", "12345678",new Button("Info")),
	new Person("German", "Jones","12345678", new Button("Info")),
	new Person("Erick", "Mancha", "12345678",new Button("Info")));
	table.setEditable(true);
	table.setMinWidth(390);
	TableColumn firstNameCol = new TableColumn("Primer Nombre");
	firstNameCol.setCellValueFactory(new PropertyValueFactory<Person, String>("firstName"));
	firstNameCol.setMinWidth(100);
	TableColumn lastNameCol = new TableColumn("Segundo Nombre");
	lastNameCol.setCellValueFactory(new PropertyValueFactory<Person, String>("lastName"));
	lastNameCol.setMinWidth(100);
	TableColumn phoneCol = new TableColumn("Teléfono");
	phoneCol.setCellValueFactory(new PropertyValueFactory<Person, String>("phone"));
	phoneCol.setMinWidth(100);
	TableColumn infoCol = new TableColumn("Información");
	infoCol.setCellValueFactory(new PropertyValueFactory<Person, String>("button"));
	infoCol.setMinWidth(80);
	table.setItems(data);
	table.getColumns().addAll(firstNameCol, lastNameCol, phoneCol, infoCol);
	group.getChildren().add(table);
	stage.setScene(scene);
	stage.show();
	}
	}

view raw TablaFX.java hosted with ❤ by GitHub

Para que la tabla funcione con el patrón observador es necesario que cree un POJO (Plain Old Java Object) que represente a la tabla y se haga una lista observable con estos. También se le debe indicar a las columnas de la tabla que elemento del POJO representan. Dentro del POJO se le dan atributos del tipo propiedad y en el caso del botón se le agrega el método que desee que ejecute. El código del POJO es el siguiente:

	public static class Person {
	private final SimpleStringProperty firstName;
	private final SimpleStringProperty lastName;
	private final SimpleStringProperty phone;
	private final Button button;
	private Person(String first, String last, String phon, Button button) {
	this.firstName = new SimpleStringProperty(first);
	this.lastName = new SimpleStringProperty(last);
	this.phone = new SimpleStringProperty(phon);
	this.button = button;
	button.setOnMouseReleased(new EventHandler() {
	@Override
	public void handle(Event arg0) {
	System.out.println(firstName + "," + lastName + "," + phone);
	}
	});
	}
	public String getFirstName() {
	return firstName.get();
	}
	public void setFirstName(String first) {
	firstName.set(first);
	}
	public String getLastName() {
	return lastName.get();
	}
	public void setLastName(String last) {
	lastName.set(last);
	}
	public String getPhone() {
	return phone.get();
	}
	public void setEmail(String phone) {
	this.phone.set(phone);
	}
	public Button getButton() {
	return button;
	}
	}

view raw POJOPersona.java hosted with ❤ by GitHub

JavaFX: Agregar Tabla

Para crear una tabla o TableView en JavaFX, desde la versión 2.0 y posteriores, se cuenta con una interfaz amigable al igual que para muchos de sus elementos. De por sí las tablas ya traen consigo un diseño bastante aceptable como el que se muestra a continuación:

Para realizar una tabla en JavaFX hay que tomar en consideración algunos elementos nuevos que trae. Por ejemplo existe la opción de agregar celdas personalizadas. Otro punto importante es el manejo del contenido de la tabla por medio de una lista observable que realiza los cambios en la tabla cuando la lista cambia. El código de la tabla anterior es el siguiente:

	import javafx.application.Application;
	import javafx.beans.property.SimpleStringProperty;
	import javafx.collections.FXCollections;
	import javafx.collections.ObservableList;
	import javafx.scene.Group;
	import javafx.scene.Scene;
	import javafx.scene.control.TableColumn;
	import javafx.scene.control.TableView;
	import javafx.scene.control.cell.PropertyValueFactory;
	import javafx.stage.Stage;
	public class SimpleTableView extends Application {
	private TableView table = new TableView();
	public static void main(String[] args) {
	launch(args);
	}
	@Override
	public void start(Stage stage) {
	Group group = new Group();
	Scene scene = new Scene(group);
	stage.setTitle("Simple Table View Sample");
	stage.setWidth(400);
	stage.setHeight(500);
	ObservableList<Person> data = FXCollections.observableArrayList(
	new Person("Paco", "Perez", "12345678"),
	new Person("Isabella","Garcia", "12345678"),
	new Person("Juan", "Juanes","12345678"),
	new Person("German", "Jones", "12345678"),
	new Person("Erick", "Mancha", "12345678"));
	table.setEditable(true);
	table.setMinWidth(390);
	TableColumn firstNameCol = new TableColumn("Primer Nombre");
	firstNameCol.setCellValueFactory(new PropertyValueFactory<Person, String>("firstName"));
	firstNameCol.setMinWidth(140);
	TableColumn lastNameCol = new TableColumn("Segundo Nombre");
	lastNameCol.setCellValueFactory(new PropertyValueFactory<Person, String>("lastName"));
	lastNameCol.setMinWidth(140);
	TableColumn phoneCol = new TableColumn("Teléfono");
	phoneCol.setCellValueFactory(new PropertyValueFactory<Person, String>("phone"));
	phoneCol.setMinWidth(100);
	table.setItems(data);
	table.getColumns().addAll(firstNameCol, lastNameCol, phoneCol);
	group.getChildren().add(table);
	stage.setScene(scene);
	stage.show();
	}
	}

view raw TablaSimpleFX.java hosted with ❤ by GitHub

Para que la tabla funcione con el patrón observador es necesario que cree un POJO (Plain Old Java Object) que represente a la tabla y se haga una lista observable con estos como se ve en la linea 28. También se le debe indicar a las columnas de la tabla que elemento del POJO representan. Esto se hace con el método setCellValueFactory() de la clase TableColumn, a la cual se le indica que la propiedad a tomar apuntando que objeto y atributo del objeto elegir. El código del POJO es el siguiente:

	public static class Person {
	private final SimpleStringProperty firstName;
	private final SimpleStringProperty lastName;
	private final SimpleStringProperty phone;
	private Person(String first, String last, String phon) {
	this.firstName = new SimpleStringProperty(first);
	this.lastName = new SimpleStringProperty(last);
	this.phone = new SimpleStringProperty(phon);
	}
	public String getFirstName() {
	return firstName.get();
	}
	public void setFirstName(String first) {
	firstName.set(first);
	}
	public String getLastName() {
	return lastName.get();
	}
	public void setLastName(String last) {
	lastName.set(last);
	}
	public String getPhone() {
	return phone.get();
	}
	public void setEmail(String phone) {
	this.phone.set(phone);
	}
	}

view raw PojoSPersona.java hosted with ❤ by GitHub

Eclipse: Crear un JAR

Cuando se ejecuta un programa desde eclipse, lo que se hace generalmente es compilar el código fuente y ejecutar los .class sin la necesidad de crear un JAR que se pueda ejecutar. Para generar o crear un JAR en eclipse basta con seguir los siguientes pasos:

Damos click derecho en el proyecto y elegimos la opcion Export...

Esto mostrará una ventana en la cual podemos elegir 3 opciones:

• JAR file: Esta opción permite crear un JAR en forma de librería, lo cual permite que se pueda importar cualquier clase dentro del mismo y hacer uso de sus métodos y utilidades.
• Javadoc: Esta opción es un auxiliar de la anterior, ya que permitirá crear un JAR que brindará la documentación necesaria de las clases y métodos del JAR anterior.
• Runnable JAR file: Esta opción nos permite crear un JAR que se puede ejecutar con el comando "java -jar <archivo.jar>". Si deseamos poder ejecutar el programa esta es la opción a utilizar.

De haber elegido la opción "Runnable JAR file" se presentara la siguiente ventana en la cual simplemente determinamos la ubicación del JAR generado, la configuración de inicio (en caso de tener más de un método Main, se puede elegir con cual iniciar y con que argumentos) y el manejo de librerías (ya sea extrayendolas o empaquetandolas dentro del JAR).

Al final se tendrá el JAR listo para ser utilizado como ejecutable, librería o documentación.

Java: Convertir un Array de Bytes a un Archivo

Para convertir un arreglo de bytes en un archivo se puede utilizar la clase FileOutputStream de Java. Esta clase contiene el método "write(byte[] array)" el cual permite convertir el array de bytes al archivo usando el array de bytes que se le da como parámetro. El código muestra como lo hace.

	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	public class BytesToFile {
	public static void main(String[] args) {
	FileInputStream fileInputStream = null;
	File file = new File("C:\\FileTests\\Cliente-servidor-1.jpg");
	byte[] fileArray = new byte[(int) file.length()];
	try {
	// Con este código se obtienen los bytes del archivo.
	fileInputStream = new FileInputStream(file);
	fileInputStream.read(fileArray);
	fileInputStream.close();
	// Con este código se agregan los bytes al archivo.
	FileOutputStream fileOuputStream = new FileOutputStream("C:\\FileTests\\Cliente-servidor-2.jpg");
	fileOuputStream.write(fileArray);
	fileOuputStream.close();
	} catch (Exception e) {
	//Manejar Error
	}
	}
	}

view raw BytesToFile.java hosted with ❤ by GitHub

Lo primero que se hace en el código anterior es leer los bytes de un archivo y luego se usan estos mismos bytes para crear un archivo idéntico con diferente nombre. Para que el ejemplo funcione debe existir el primer archivo.

Java: Escribir un Json

Post relacionado: Java: Leer/Escribir Json con Gson

Como ya se había mencionado en un post anterior los archivos JSON son una opción para sustituir a los archivos DOM. JSON usa una sintaxis basada en listas separadas por comas y agrupadas por llaves para manejar a los hijos dentro de las listas.

En java para poder escribir estos archivos desde java existen librerías que nos facilitan el trabajo. En este caso usaremos json-simple la cual pueden descargar con este link -> librería o de la pagina de code.google.com. Para realizar la lectura simplemente basta agregar la librería (descrito este post) y usar el siguiente código para escribir la información dentro del archivo.

	import java.io.FileWriter;
	import java.io.IOException;
	import org.json.simple.JSONArray;
	import org.json.simple.JSONObject;
	public class JSONWrite {
	public static void main(String[] args) {
	JSONObject obj = new JSONObject();
	obj.put("Blog", "http://javainutil.blogspot.com");
	obj.put("Temas", "Informatica");
	obj.put("Inicio", new Integer(2012));
	JSONArray list = new JSONArray();
	list.add("tag 1");
	list.add("tag 2");
	list.add("tag 3");
	obj.put("Tags", list);
	JSONObject innerObj = new JSONObject();
	innerObj.put("PostX","Escribir un JSON");
	innerObj.put("PostY", "Leer un JSON");
	innerObj.put("PostZ", "lalala");
	obj.put("Posts",innerObj);
	try {
	FileWriter file = new FileWriter("c:\\FileTests\\prueba.json");
	file.write(obj.toJSONString());
	file.flush();
	file.close();
	} catch (IOException e) {
	//manejar error
	}
	System.out.print(obj);
	}
	}

view raw JSONRead.java hosted with ❤ by GitHub

Se puede observar que el método que permite agregar nuevos elementos a la lista es "put()". Este método ingresa en nombre de una variable y su valor. El valor pueden ser los tipos básicos de variables (int, long, String, etc) una lista del tipo JSONArray o un objeto del tipo JSONObject los cuales se pueden ir anidando para agregar mas niveles. Al final el código anterior creara un archivo que contendrá el siguiente JSON:

	{
	"Tags":["tag 1","tag 2","tag 3"],
	"Posts":{
	"PostZ":"lalala",
	"PostY":"Leer un JSON",
	"PostX":"Escribir un JSON"
	},
	"Temas":"Informatica",
	"Inicio":2012,
	"Blog":"http:\/\/javainutil.blogspot.com"
	}

view raw JSONWriteOut hosted with ❤ by GitHub

Java: Leer un Json

Post relacionado: Java: Leer/Escribir Json con Gson

Los archivos JSON son una opción para sustituir a los archivos DOM. JSON usa una sintaxis basada en listas separadas por comas y agrupadas por llaves para manejar a los hijos dentro de las listas.

En java para poder leer estos archivos existen librerías que nos facilitan el trabajo. En este caso usaremos json-simple la cual pueden descargar con este link -> librería o de la pagina de code.google.com. Para realizar la lectura simplemente basta agregar la librería (descrito este post) y usar el siguiente código para obtener la información dentro del archivo.

	import java.io.FileNotFoundException;
	import java.io.FileReader;
	import java.io.IOException;
	import java.util.Iterator;
	import org.json.simple.JSONArray;
	import org.json.simple.JSONObject;
	import org.json.simple.parser.JSONParser;
	import org.json.simple.parser.ParseException;
	public class JSONRead {
	public static void main(String[] args) {
	JSONParser parser = new JSONParser();
	try {
	Object obj = parser.parse(new FileReader("c:\\FileTests\\prueba.json"));
	JSONObject jsonObject = (JSONObject) obj;
	String blog = (String) jsonObject.get("Blog");
	System.out.println(blog);
	String temas = (String) jsonObject.get("Temas");
	System.out.println(temas);
	long inicio = (Long) jsonObject.get("Inicio");
	System.out.println(inicio);
	JSONObject innerObject = (JSONObject) jsonObject.get("Posts");
	System.out.println(innerObject.toJSONString());
	// loop array
	JSONArray tags = (JSONArray) jsonObject.get("Tags");
	Iterator<String> iterator = tags.iterator();
	while (iterator.hasNext()) {
	System.out.println(iterator.next());
	}
	} catch (FileNotFoundException e) {
	//manejo de error
	} catch (IOException e) {
	//manejo de error
	} catch (ParseException e) {
	//manejo de error
	}
	}
	}

view raw JSONRead2.java hosted with ❤ by GitHub

Es importante notar que se pueden leer objetos tipo JSONObject dentro de otro del mismo tipo como un hijo, lo cual nos permite anidar información. Luego de haber ejecutado el código el resultado que obtendrán en consola sera el siguiente:

	http://javainutil.blogspot.com
	Informatica
	2012
	{"PostZ":"lalala","PostY":"Leer un JSON","PostX":"Escribir un JSON"}
	tag 1
	tag 2
	tag 3

view raw JSONReadOut hosted with ❤ by GitHub

Con esta librería se debe conocer que parámetros existen dentro del archivo para mandarlos a llamar.
Para la prueba se utilizo el siguiente JSON:

	{
	"Tags":["tag 1","tag 2","tag 3"],
	"Posts":{
	"PostZ":"lalala",
	"PostY":"Leer un JSON",
	"PostX":"Escribir un JSON"
	},
	"Temas":"Informatica",
	"Inicio":2012,
	"Blog":"http:\/\/javainutil.blogspot.com"
	}

view raw JSONWriteOut hosted with ❤ by GitHub