Introducción
En esta sesión aprenderemos a validar datos en formularios y a manejar eventos avanzados en Java Swing. La validación de datos es esencial para garantizar que la información ingresada por el usuario sea correcta y segura. Adicionalmente, exploraremos el control avanzado de eventos para mejorar la interactividad de nuestras interfaces:
- Validación de campos vacíos.
- Validación de tipos de datos.
- Validación con expresiones regulares.
- Uso de DocumentListener para capturar cambios en tiempo real en componentes de texto.
- Validación en tiempo real con InputVerifier restringir la entrada de datos.
Validación de Datos en Formularios
¿Por qué es importante validar datos?
La validación de datos en formularios evita errores y posibles vulnerabilidades en nuestras aplicaciones. Algunos beneficios son:
- Evita datos incorrectos o incompletos.
- Mejora la experiencia del usuario.
- Protege contra ataques como la inyección de código.
- Facilita la integridad de los datos en bases de datos.
Tipos de Validaciones
Las validaciones se pueden dividir en:
- Validaciones en el lado del cliente: Se realizan antes de enviar los datos.
- Validaciones en el lado del servidor: Se ejecutan en el backend antes de procesar los datos.
En Java Swing, realizamos validaciones en el lado del cliente.
Validaciones Comunes en Java Swing
- Validación de Campos Vacíos
- Es importante asegurarse de que los campos obligatorios no estén vacíos antes de procesar el formulario.
- Validación de Tipo de Datos
- Números enteros o decimales.
- Direcciones de correo electrónico.
- Fechas en formato correcto.
- Nombres sin caracteres especiales.
- Validación con Expresiones Regulares: permiten validar datos de forma flexible y precisa.
- Correo electrónico:
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ - Teléfono:
^\d{9}$ - Nombre sin números:
^[A-Za-z\s]+$
- Correo electrónico:
Validación de Campos Vacíos
Es importante asegurarse de que los usuarios rellenen los campos obligatorios. Podemos usar un ActionListener para comprobar si un campo está vacío antes de procesarlo.
Ejemplo
import javax.swing.*;
import java.awt.event.*;
public class ValidacionCamposVacios {
public static void main(String[] args) {
JFrame frame = new JFrame("Validación de Campos Vacíos");
JTextField campoTexto = new JTextField(15);
JButton boton = new JButton("Enviar");
JLabel mensaje = new JLabel("");
boton.addActionListener(e -> {
if (campoTexto.getText().trim().isEmpty()) {
mensaje.setText("El campo no puede estar vacío.");
} else {
mensaje.setText("Enviado correctamente.");
}
});
JPanel panel = new JPanel();
panel.add(campoTexto);
panel.add(boton);
panel.add(mensaje);
frame.add(panel);
frame.setSize(300, 150);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
Validación de Tipos de Datos
Validación de Números Enteros
Podemos verificar que el usuario introduce solo números enteros en un JTextField.
campoTexto.addKeyListener(new KeyAdapter() {
public void keyTyped(KeyEvent e) {
char c = e.getKeyChar();
if (!Character.isDigit(c)) {
e.consume(); // Ignora la entrada si no es un número
}
}
});
Validación de Direcciones de Correo Electrónico con Expresiones Regulares
String emailPattern = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,6}$";
if (!texto.matches(emailPattern)) {
mensaje.setText("Correo electrónico no válido.");
}
Uso de DocumentListener para Validación Dinámica
El DocumentListener permite reaccionar a cambios en tiempo real dentro de un campo de texto. En concreto permite escuchar cambios en el contenido de un JTextField o JTextArea. Es útil cuando queremos validar o modificar los datos en tiempo real a medida que el usuario los escribe.
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
public class ValidacionConDocumentListener {
public static void main(String[] args) {
JFrame frame = new JFrame("Validación en Tiempo Real");
JTextField campoTexto = new JTextField(15);
JLabel mensaje = new JLabel("Introduce tu nombre");
campoTexto.getDocument().addDocumentListener(new DocumentListener() {
@Override
public void insertUpdate(DocumentEvent e) { validar(); }
@Override
public void removeUpdate(DocumentEvent e) { validar(); }
@Override
public void changedUpdate(DocumentEvent e) { validar(); }
private void validar() {
if (campoTexto.getText().matches("\\d+")) {
mensaje.setText("Texto válido: número detectado");
mensaje.setForeground(Color.GREEN);
} else {
mensaje.setText("Solo números permitidos");
mensaje.setForeground(Color.RED);
}
}
});
JPanel panel = new JPanel();
panel.add(campoTexto);
panel.add(mensaje);
frame.add(panel);
frame.setSize(300, 150);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
Explicación del Código
- Se crea un
JTextFieldy unJLabel. - Se agrega un
DocumentListeneral campo de texto. - Cada vez que el usuario escribe o borra caracteres, se verifica si el texto contiene solo números.
- Si el texto es válido, el mensaje se muestra en verde; si no, en rojo.
InputVerifier para Validación en Tiempo Real
El InputVerifier permite validar datos antes de que el componente pierda el foco. De esta forma, podemos impedir que el usuario cambie el foco de un campo hasta que se introduzca un valor correcto.
import javax.swing.*;
import java.awt.*;
public class EjemploInputVerifier {
public static void main(String[] args) {
JFrame frame = new JFrame("Validación con InputVerifier");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 150);
frame.setLayout(new FlowLayout());
JTextField campoTexto = new JTextField(15);
JLabel mensaje = new JLabel("Introduce un número entero");
campoTexto.setInputVerifier(new InputVerifier() {
@Override
public boolean verify(JComponent input) {
JTextField tf = (JTextField) input;
if (tf.getText().matches("\\d+")) {
mensaje.setText("Dato válido");
mensaje.setForeground(Color.GREEN);
return true;
} else {
mensaje.setText("Introduce solo números");
mensaje.setForeground(Color.RED);
return false;
}
}
});
frame.add(campoTexto);
frame.add(mensaje);
frame.setVisible(true);
}
}
Explicación del Código
- Se define un
InputVerifierque se ejecuta cuando el usuario intenta cambiar el foco. - Si el texto contiene solo números, se permite el cambio de foco.
- Si no, el mensaje de error se muestra y el foco no cambia.
Otro ejemplo:
import javax.swing.*;
class ValidadorCorreo extends InputVerifier {
@Override
public boolean verify(JComponent input) {
JTextField campo = (JTextField) input;
return campo.getText().matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,6}$");
}
}
public class ValidacionInputVerifier {
public static void main(String[] args) {
JFrame frame = new JFrame("Validación con InputVerifier");
JTextField campoEmail = new JTextField(15);
campoEmail.setInputVerifier(new ValidadorCorreo());
JPanel panel = new JPanel();
panel.add(new JLabel("Correo:");
panel.add(campoEmail);
frame.add(panel);
frame.setSize(300, 100);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
}
Creación de Eventos Personalizados
En algunas situaciones, es útil definir nuestros propios eventos para comunicar cambios entre componentes. Los eventos personalizados permiten reaccionar a cambios específicos dentro de los formularios.
Los eventos personalizados son muy interesantes y sirven para infinidad de situaciones. Por eso los veremos más a fondo en otra entrada.
Conclusión
La validación de datos y el control avanzado de eventos en Java Swing mejoran la calidad de nuestras aplicaciones. Aplicando estas técnicas, podemos crear formularios robustos y seguros, asegurando que los datos ingresados sean correctos y útiles.
Hemos visto diferentes formas de validar datos en formularios Swing.
- DocumentListener es útil para actualización dinámica.
- InputVerifier impide cambiar el foco si el dato es incorrecto.
- Expresiones regulares ayudan a validar formatos complejos.
Cada técnica se adapta a diferentes necesidades según la complejidad del formulario.
Deja una respuesta