Bases de datos con Payara Server

Se necesita lo siguiente:

• Tener instalado el JDK versión 8 o superior.
• Bases de datos:
• Tener instalado MySql versión 5.7.24 o superior, en caso de MariaBD la versión 10.3.12 o superior
• Tener instalado el servidor Payara Server versión 5 o superior.
• Un IDE (Eclipse o NetBeans preferiblemente) para iniciar el servidor. (clic aquí para ver como)

---

Usar MySQL o MariaBD con Payara Server (JDBC Connection Pool)

PRIMER PASO:

Iniciar el servidor desde el IDE así como el servicio de la base de datos

Debe aparece el servicio iniciado:

Luego se debe acceder desde el navegador al administrador que es generalmente la ruta http://localhost:4848/

SEGUNDO PASO:

Dependiendo del SO se ingresa al CLI de Linux o PowerShell de Windows, ahí se debe navegar hasta la ubicación de la instalación del servidor, específicamente a la carpeta "bin", los pasos y comandos son:

• Cambiar la ubicación a "bin": CD 'E:\Program Files (x86)\payara5\bin\'
• Llamar al comando de administrador: ./asadmin
• Agregar el driver de conección, se debe indicar la ruta donde tienen el JAR: add-library "D:\Mis Documentos\JAR\MySQL\mysql-connector-java-5.1.23-bin.jar"
• Salir: exit

Windows PowerShell
Copyright (C) Microsoft Corporation. Todos los derechos reservados.

PS C:\Users\USER> CD 'E:\Program Files (x86)\payara5\bin\'
PS E:\Program Files (x86)\payara5\bin> ./asadmin
Use "exit" to exit and "help" for online help.
asadmin> add-library "D:\Mis Documentos\JAR\MySQL\mysql-connector-java-5.1.23-bin.jar"
Command add-library executed successfully.
asadmin> exit
Command multimode executed successfully.
PS E:\Program Files (x86)\payara5\bin>

TERCER PASO:

Reiniciar el servidor desde el IDE y volver a acceder al panel de administración WEB: http://localhost:4848/
Ubicarse en el menu lateral en "Resources" y acceder a "JDBC" y "JDBC Connection Pools", crear uno nuevo con el botón "new" y en la nueva ventana llenar los campos como se aprecia en la siguiente imagen.

• A: Es el nombre de la conexión
• B: Es el tipo de recurso
• C: Es el nombre del proveedor

Presionar "next". Luego se debe completar algunos campos, aparecerán por defecto una gran cantidad de ellos, los puede borrar y colocar los siguientes

En estos campos se debe completar el nombre de la base de datos, para este caso es "blog", el usuario y contraseña (no se recomienda "root", pero para pruebas es válido), la ubicación que es "localhost" en este caso y el número de puerto.
Luego presionar finish, entrar a la conexión creada haciendo clic sobre su nombre en la lista y comprobar la conexión haciendo clic en "ping", el resultado debería ser: "Ping Succeeded"

Finalmente crear el recurso JDBC haciendo clic en "JDBC Resources" y luego en "new", completar los campos

Dar clic en "OK" y observar que se han agregado los dos componentes necesarios para las conexiones con bases de datos desde Payara Server

• A: Es el nombre del recurso que será llamado luego por las aplicaciones
• B: Es el JDBC pool al que hace referencia

Ahora el servidor se ha conectado exitosamente a una base de datos y puede cerrar el panel de administración

Clase utilitaria DeString

package util;

import java.util.ArrayList;
import java.util.List;

public class DeString {

    public static Integer aInteger(String s) {
        Integer result = null;

        if (s != null) {
            try {
                result = Integer.valueOf(s);
            } catch (NumberFormatException e) {
            }
        }

        return result;
    }

    public static Double aDouble(String s) {
        Double result = null;

        if (s != null) {
            try {
                result = Double.valueOf(s);
            } catch (NumberFormatException e) {
            }
        }

        return result;
    }

    public static List<Integer> ids(String _ids) {
        List<Integer> list = new ArrayList<>();

        if (_ids != null) {
            String[] v_ids = _ids.split(",");
            for (String v_id : v_ids) {
                Integer id = aInteger(v_id);
                if (id != null) {
                    list.add(id);
                } else {
                    list = null;
                    break;
                }
            }
        }
        return list;
    }

    /*Listas*/
    public static Integer[] aIntegerL(String[] s) {
        Integer[] result = null;

        if ((s != null) && (s.length > 0)) {
            result = new Integer[s.length];

            for (int i = 0; i < result.length; i++) {
                try {
                    result[i] = Integer.valueOf(s[i]);
                } catch (NumberFormatException ex) {
                    result = null;
                    break;
                }
            }
        }

        return result;
    }

    public static Double[] aDoubleL(String[] s) {
        Double[] result = null;

        if ((s != null) && (s.length > 0)) {
            result = new Double[s.length];

            for (int i = 0; i < result.length; i++) {
                try {
                    result[i] = Double.valueOf(s[i]);
                } catch (NumberFormatException ex) {
                    result = null;
                    break;
                }
            }
        }

        return result;
    }

}

Escritura en archivos

Manejo de archivos

La lectura y escritura de archivos es una de las funcionalidades que ha proveído Java desde sus inicios, siendo mejorada tras sus diversas versiones

Escribir en un archivo de texto

En el siguiente ejemplo se ingresará un texto por consola y luego se almacenará en un archivo txt llamado datos.txt que se creará en la ruta especificada. Cada vez que se ejecute el programa se reescribirá el valor del texto como si se creara una nuevo.

package test;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class WriteTxt {

    public static void main(String[] args) {
    
        // Captura de datos
        Scanner s = new Scanner(System.in);
        System.out.println("Ingrese un texto y luego ENTER...");
        String texto = s.nextLine();
                
        try {
            //Creación del archivo
            FileWriter fw = new FileWriter("/media/jhon/Disco/Documentos/datos.txt");
            
            //Creación del buffer para escritura
            try (BufferedWriter bw = new BufferedWriter(fw)) {
                bw.write(texto);
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
            }
            
        } catch (IOException e) {
            System.err.println("Error: " + e.getMessage());
        }        

    }
}

Añadir texto

Si se desea agregar texto sin reemplazar el original, se debe indicar en el objeto de tipo FileWriter como segundo parámetro el valor lógico TRUE. Además, en el cuerpo del buffer de escritura se añade previo al texto un salto de línea.

package test;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class WriteTxt {

    public static void main(String[] args) {
        // Captura de datos
        Scanner s = new Scanner(System.in);
        System.out.println("Ingrese un texto y luego ENTER...");
        String texto = s.nextLine();
                
        try {
            //Se indica TRUE para añadir texto en lugar de reemplazar
            FileWriter fw = new FileWriter("/media/jhon/Disco/Documentos/datos.txt",true);
            
            //Creación del buffer para escritura
            try (BufferedWriter bw = new BufferedWriter(fw)) {
                bw.write("\n"); //Se agrega un salto de línea
                bw.write(texto);
            } catch (Exception e) {
                System.err.println("Error: " + e.getMessage());
            }
            
        } catch (IOException e) {
            System.err.println("Error: " + e.getMessage());
        }        

    }
}

Cargar imagen en Java Swing

Para este ejemplo se emplea NetBeans, una imagen jpg y la biblioteca Java Swing. 

 

Estructura del proyecto

Se creo un JFrame que llamará a la imagen, se aprovechar esto para mostrar como llamar a la imagen desde una ubicación externa a la aplicación y desde el mismo JAR de la aplicación.

La estructura es la siguiente:	La imagen cat.jgp es:

Llamada desde fuera del JAR

Las líneas de código relevante de todo el JFrame (líneas 10 a 15) son las que declaran el objeto de tipo ImageIcon desde la ruta absoluta o path seguido de un condicional que evalúa si el estado de carga de la imagen es COMPLETO y en cuyo caso procede a borrar el texto del JLabel y asignar la imagen dentro de este.

package images;

import javax.swing.ImageIcon;

public class ImagenView extends javax.swing.JFrame {

    public ImagenView() {
        initComponents();
        //Se carga la imagen en un ImageIcon
        ImageIcon icono = new ImageIcon("/NetBeansProjects/Blog/src/images/cat.jpg");
        if (icono.getImageLoadStatus() == java.awt.MediaTracker.COMPLETE) {
            lblImagen.setText("");
            lblImagen.setIcon(icono); // Se coloca en el JLabel
        }
        
    }

    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() {
        lblImagen = new javax.swing.JLabel();
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Cargando imagen");
        lblImagen.setText("Sin imagen");
        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(lblImagen, javax.swing.GroupLayout.DEFAULT_SIZE, 
                226, Short.MAX_VALUE)
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(lblImagen, javax.swing.GroupLayout.DEFAULT_SIZE, 
                226, Short.MAX_VALUE)
                .addContainerGap())
        );

        pack();
    }// </editor-fold>                        

    public static void main(String args[]) {
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : 
            javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException | InstantiationException | 
        IllegalAccessException | javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(ImagenView.class.getName())
            	.log(java.util.logging.Level.SEVERE, null, ex);
        }

        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new ImagenView().setVisible(true);
            }
        });
    }

    // Variables declaration - do not modify                     
    private javax.swing.JLabel lblImagen;
    // End of variables declaration                   
}

Llamada desde dentro del JAR

Se requiere de la clase java.net.URL para indicar la ubicación de la imagen y cargarla posteriormente

package images;

import java.net.URL;
import javax.swing.ImageIcon;

public class ImagenView extends javax.swing.JFrame {

    public ImagenView() {
        initComponents();
        
        //Se carga la imagen en un ImageIcon desde su URL
        URL url = getClass().getResource("cat.jpg");
        ImageIcon icono = new ImageIcon(url);
        
        if (icono.getImageLoadStatus() == java.awt.MediaTracker.COMPLETE) {
            lblImagen.setText("");
            lblImagen.setIcon(icono); // Se coloca en el JLabel
        }
        
    }

    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() {
        lblImagen = new javax.swing.JLabel();
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Cargando imagen");
        lblImagen.setText("Sin imagen");
        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(lblImagen, javax.swing.GroupLayout.DEFAULT_SIZE, 
                226, Short.MAX_VALUE)
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(lblImagen, javax.swing.GroupLayout.DEFAULT_SIZE, 
                226, Short.MAX_VALUE)
                .addContainerGap())
        );

        pack();
    }// </editor-fold>                        

    public static void main(String args[]) {
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : 
            javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException | InstantiationException | 
        IllegalAccessException | javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(ImagenView.class.getName())
            	.log(java.util.logging.Level.SEVERE, null, ex);
        }

        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new ImagenView().setVisible(true);
            }
        });
    }

    // Variables declaration - do not modify                     
    private javax.swing.JLabel lblImagen;
    // End of variables declaration                   
}

En ambos casos la salida en pantalla sería:

Lectura de archivos

Manejo de archivos

La lectura y escritura de archivos es una de las funcionalidades que ha proveído Java desde sus inicios, siendo mejorada tras sus diversas versiones.

Lectura de archivos de texto

Para llevar a cabo la lectura de un archivo de texto se pueden emplear diversos métodos de la clase java.io.*, pero se recomienda complementar esta con la clase java.nio.* considerada la clase de reemplazo de la anterior, que contiene entre sus componentes a Files y Paths permitiendo simplificar acciones como copiar un archivo en uno nuevo y brindando el soporte para llevar a cabo las acciones clásicas de la clase original.

Por ejemplo, supongamos un archivo txt con el siguiente contenido:

-A: Hola
-G: Hola, ¿cómo estas?
-A: Bien, y tú
-G: Igualmente
-A: Debo irme, hasta luego
-G: Hasta luego, saludos a doña Dana

Ahora una clase "main" de Java con el siguiente código que mostrará el contenido del archivo en consola empleando diversas formas:

package test;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.List;

public class Test {

    public static void main(String[] args) throws IOException {
        //Archivo indicando la ruta
        File archivo = new File("/media/ruta/data.txt");
        //Definición de caracteres UTF-8
        Charset cs = StandardCharsets.UTF_8;
        
        /*Lectura de datos*/
        //USANDO Files.readAllLines
        try {
            List<String> lines = Files.readAllLines(archivo.toPath(), cs);
            lines.forEach(l -> {
                System.out.println(l);
            });
        } catch (IOException e) {
            System.err.println(e.getMessage());
        }
        
        System.out.println("====================================");
        
        //USANDO BufferedReader
        try (BufferedReader br = Files.newBufferedReader(archivo.toPath(), cs)) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.err.println(e.getMessage());
        }
        
        System.out.println("====================================");
        
        //USANDO InputStream
        try (InputStream is = Files.newInputStream(archivo.toPath())) {
            byte[] bytes = new byte[(int) archivo.length()];
            is.read(bytes);
            String content = new String(bytes, cs);
            System.out.println(content);
        } catch (IOException e) {
            System.err.println(e.getMessage());
        }

    }
}

Mostrará el siguiente resultado:

-A: Hola
-G: Hola, ¿cómo estas?
-A: Bien, y tú
-G: Igualmente
-A: Debo irme, hasta luego
-G: Hasta luego, saludos a doña Dana
====================================
-A: Hola
-G: Hola, ¿cómo estas?
-A: Bien, y tú
-G: Igualmente
-A: Debo irme, hasta luego
-G: Hasta luego, saludos a doña Dana
====================================
-A: Hola
-G: Hola, ¿cómo estas?
-A: Bien, y tú
-G: Igualmente
-A: Debo irme, hasta luego
-G: Hasta luego, saludos a doña Dana

Lectura de archivos multimedia

Además, se pueden cargar archivos como:

• Imágenes
• En la web (https://javajhon.blogspot.com/2020/06/imagenes-servlet.html)
• En una aplicación de escritorio (https://javajhon.blogspot.com/2020/12/imagen-swing.html)
  
• Audio
• Video
• Documentos

Cada uno de estos tiene sus particularidades y diferentes formas de llamado dependiendo del entorno donde se desee mostrarlos, es diferente cargar una imagen en una aplicación WEB que en una aplicación de escritorio.

Conectar SQLite con Eclipse

Programas o Software requerido

Para realizar la conexión necesitamos tener los siguientes programas:

• Eclipse (Pueden elegir la versión que deseen así como la arquitectura de su Pc o Mac): http://www.eclipse.org/downloads/packages/ 
• El driver JDBC de SQLite (sqlite-jdbc-3.30.1).
• Un programa que administre bases de datos de SQLite para crear las bases de datos y opcionalmente comprobar si los cambios realizados en el programa JAVA realizan cambios en la base de datos.
• SQLiteStudio: https://sqlitestudio.pl/ 
• DB Browser for SQLite: https://sqlitebrowser.org/

Paso 1 - La base de datos

Si ya posee la base de datos, solo basta conocer la dirección exacta de esta. Si no posee la base de datos, puede seguir el siguiente tutorial para generar una: https://inlearningcode.blogspot.com/2020/11/sqlite-tabla.html

Paso 2 - El proyecto en Eclipse

Ahora procedemos a Eclipse donde creamos un nuevo proyecto, colocamos el nombre del proyecto como queramos llamarlo. Luego continuamos y vamos a la pestaña Libraries (Bibliotecas) y dentro de ella agregamos una nueva (Add Library).

Despliega una nueva ventana y elegimos la opción Add External JARs y luego seleccionar el archivo JAR correspondiente, en mi caso el sqlite-jdbc-3.30.1.jar, y aceptar.

Dentro del proyecto se observa las bibliotecas del Jdk y el driver de conexión.

package util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class Conectabd {
	private final String URL = "jdbc:sqlite:D:\\bd\\blog.db";
    private final String DRIVER = "org.sqlite.JDBC";

    
    public Connection conexionDB() throws SQLException{
    Connection c = null;
        try {
            Class.forName(DRIVER).newInstance();
            c = DriverManager.getConnection(URL);
        } catch (ClassNotFoundException | 
                 IllegalAccessException | 
                 InstantiationException | 
                 SQLException e) {
            throw new SQLException(e.getMessage());
        }
    
    return c;
    }
    		
	}
	
}

La constante URL es una combinación del JDBC y la ubicación real de la base de datos SQLite que es un archivo en sí. Mientras el DRIVER es para este caso "org.sqlite.JDBC"

Al ser una base de datos de SQLite un archivo, no requiere de usuario ni de contraseña, pero mantiene la misma lógica para llevar a cabo la conexión.

Paso 3 - Probando la clase de conexión

Creamos la siguiente clase Test.java

package test;

import java.sql.Connection;

import util.Conectabd;

public class Test {

	public static void main(String[] args) {

		Conectabd conectabd = new Conectabd();
		try (Connection c = conectabd.getConexion()) {
			System.out.print("Conexión exitosa");
		} catch (Exception e) {
			System.err.print("Error: "+e.getMessage());
		}
	}

}

Al ser ejecutada la clase devolverá: "Conexión exitosa" o indicará si ocurrió una excepción. Generalmente suelen ser un error en la redacción de la URL o el driver.

Métodos de búsqueda

Búsqueda secuencial o lineal

Consiste en recorrer una estructura de datos comparando cada elemento con el valor buscado, si el elemento buscado se encuentra al inicio, el tiempo de búsqueda será muy corto, pero será cada vez más largo mientras el elemento se encuentre más cerca del final o no se encuentre.

Algoritmo de implementación

package busqueda;

public class Busca {

    public static Integer Secuencial(Integer[] data, int valor) {
        Integer pos = null;
        for (int i = 0; i < data.length; i++) {
            if (valor == data[i]) {
                pos = i;
                break;
            }
        }
        return pos;
    }
}

Aplicando el algoritmo a un Array

package test;

import busqueda.Busca;

public class TestBusqueda {

    public static void main(String[] args) {
        Integer[] datos = {2, 255, 10, 0, 11, 1172, 1};
        System.out.println("Array: " + Arrays.toString(datos));
        
        //Búsqueda de la posición de forma secuencial		
        Integer index = Busca.Secuencial(datos, 11); // Busca 11
        System.out.println("Buscando 11 ...");
        //Mostrar resultado
        if (index != null) {
            System.out.println("Elemento encontrado en la posición " + index);
        } else {
            System.out.println("Elemento no encontrado");
        }
		
        index = Busca.Secuencial(datos, 12); // Busca 12
        System.out.println("Buscando 12 ...");
        //Mostrar resultado
        if (index != null) {
            System.out.println("Elemento encontrado en la posición " + index);
        } else {
            System.out.println("Elemento no encontrado");
        }
    }
}

El resultado sería el siguiente:

Array: [2, 255, 10, 0, 11, 1172, 1]

Buscando 11 ...
Elemento encontrado en la posición 4

Buscando 12 ...
Elemento no encontrado

Búsqueda binaria

Consiste en recorrer una estructura de datos dividiéndola constantemente en dos partes hasta encontrar la coincidencia de búsqueda. Este método requiere que la estructura de datos este previamente ordenada de forma ascendente o descedente.

Algoritmo de implementación

package busqueda;

public class Busca {

    public static Integer Binario(Integer[] data, Integer valor) {
        int li = 0;
        int ls = data.length;
        while (li <= ls) {
            int lm = (ls - li) / 2 + li;
            if (data[lm] < valor) {
                li = lm + 1;
            } else if (data[lm] > valor) {
                ls = lm - 1;
            } else {
                return lm;
            }
        }
        return null;
    }
}

Aplicando el algoritmo a un Array

package test;

import busqueda.Busca;
import java.util.Arrays;

public class TestBusqueda {

    public static void main(String[] args) {
        Integer[] datos = {2, 255, 10, 0, 11, 1172, 1};
        System.out.println("Array: " + Arrays.toString(datos));
        
        //Búsqueda de la posición por búsqueda binaria
        Arrays.sort(datos); // Ordenamiento de datos
        System.out.println("Array ordenado: " + Arrays.toString(datos));
        
        Integer index = Busca.Binario(datos, 172); 
        System.out.println("Buscando 172 ..."); 
        //Mostrar resultado
        if (index != null) {
            System.out.println("Elemento encontrado en la posición " + index);
        } else {
            System.out.println("Elemento no encontrado");
        }
        
        index = Busca.Binario(datos, 255);
        System.out.println("Buscando 255 ...");
        //Mostrar resultado
        if (index != null) {
            System.out.println("Elemento encontrado en la posición " + index);
        } else {
            System.out.println("Elemento no encontrado");
        }
    }
}

El resultado sería el siguiente:

Array: [2, 255, 10, 0, 11, 1172, 1]
Array ordenado: [0, 1, 2, 10, 11, 255, 1172]

Buscando 172 ...
Elemento no encontrado

Buscando 255 ...
Elemento encontrado en la posición 5