Generar códigos de barras y códigos QR con Java

Los códigos de barras y códigos QR son una imagen que codifica información y que es fácilmente legible por las computadoras con hardware dedicado. Son muy utilizados y su uso está muy extendido en diferentes ámbitos de la industria como en el sector de la distribución en supermercados, la logística, tiendas y comercios y en las entradas para el acceso a espectáculos digitales o impresas.

Cualquier producto de un supermercado está identificado por un código de barras que las cajeras al realizar el cobro simplemente tienen que pasar para que el lector lea el código, identifique el producto y añada su coste una el recibo de la compra. Todo automatizado por la computadora del cajero y registrando los productos de forma rápida para el cliente y también de forma sencilla por el empleado del supermercado.

Hay diferentes estándares de códigos de barras lineales como los de los productos de supermercado y otro tipo de códigos matriciales como los códigos QR con una imagen en dos dimensiones. En esencia codifican en una imagen el código compuesto de números o caracteres, con una cantidad limitada o de cualquier longitud según el estándar.

• Los códigos de barras, códigos QR y lectores hardware de códigos

Los lectores son un dispositivo hardware que permiten reconocer los códigos, se conectan al ordenador mediante cable USB o de forma inalámbrica y no necesitan de instalar controladores y son compatibles con cualquier sistema operativo ya sea Windows, GNU/Linux o macOS. Los lectores de códigos hardware son en esencia un teclado y el código que reconocen es como si se teclea manualmente con un teclado, teclear el código y son compatibles con cualquier programa.

Hay algunas aplicaciones para generar códigos de barras y códigos QR, dos aplicaciones disponibles en GNU/Linux en formato Flatpak son Zint Barcode Studio que soporta multitud de estándares y Decoder solo sirve para códigos QR pero que permite el reconocimiento dada una imagen o una captura de pantalla.

Los códigos de barras y códigos QR se pueden generar desde un programa e incluir la imagen del código.

Librerías para generar códigos de barras y códigos QR en Java

En el caso del lenguaje de programación Java hay varias librerías que permiten generar códigos de barras y códigos QR. Cada librería implementa un subconjunto de todos los estándares de códigos lineales o matriciales y ofrecen una API para el lenguaje de programación.

Como hay varias opciones hay que determinar por algún criterio cuál de ellas utilizar, teniendo en cuenta que varias de estas librerías son de código abierto hechos como un proyecto de una persona. Algunos criterios para elegir una son por supuesto los estándares que soporta este simple hecho ya puede descartar alguna opción si no soporta el estándar que se necesita o hay alguna librería que soporta más estándares o mejor, otro criterio es su popularidad, si tiene actualizaciones recientes de corrección de errores o nuevas características y su antigüedad.

En Java algunas de las librerías de código abierto son las siguientes pero que por su estado de mantenimiento es mejor otra opción:

• barcode-java: soporta varios estándares de códigos lineales.
• Barbecue: una librería cuya última actualización es del 2007.
• Barcode4J una librería cuya última actualización es del 2012.
• ZXing: el autor de esta librería ha dejado de desarrollar y solo incorpora los cambios que se le envíen.

También hay algunas librerías comerciales con un coste por su uso bastante significativo pero que tienen algunas características que no están en las de código abierto como el reconocimiento del código dada una imagen además de seguramente tener mejor mantenimiento. Dos librerías comerciales para generar códigos son:

• Barcode for Java
• Aspose Java Barcode Generation & Recognition API
• Free Spire.Barcode for Java

Buscando alguna opción de código abierto pero mejor mantenida que los casos anteriores está la siguiente que soporta una buena cantidad de estándares entre los que están los más utilizados:

• OkapiBarcode

Ejemplos de código

Los siguiente ejemplos de código son utilizando la librería OkapiBarcode que en esencia generan una imagen utilizando las clases que incluye el JDK de Java, esta imagen se puede exportar en diferentes formatos como png y jpg.

Generar un código de barras con Java

La librería ofrece una clase con el mismo nombre por cada estándar que implementa. En los códigos lineales se ofrece la posibilidad de mostrar el código del texto que codifica la imagen, lo que es útil en caso de que el lector hardware no funcione y haya que introducir manualmente el código en el ordenador. Se puede especificar el tamaño vertical de las barras, la fuente y posición del texto y es recomendable utilizar el RenderingHints.VALUE_TEXT_ANTIALIAS_ON para que el texto tenga mejor aspecto aplicando antialias a la fuente al generar la imagen.

• Obtener el ancho y alto, escalar y convertir a otro formato imágenes con Java

El estándar que se suele utilizar en los productos del supermercado es el EAN o UPN que es el que se muestra en la siguiente imagen, estos son varios estándares de códigos lineales.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

package io.github.picodotdev.blogbitix.javabarcode;

import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;

import javax.imageio.ImageIO;

import uk.org.okapibarcode.backend.Code128;
import uk.org.okapibarcode.backend.Ean;
import uk.org.okapibarcode.backend.HumanReadableLocation;
import uk.org.okapibarcode.backend.QrCode;
import uk.org.okapibarcode.backend.Upc;
import uk.org.okapibarcode.output.Java2DRenderer;

public class Main {

    public static void main(String[] args) throws Exception {
        {
            Code128 barcode = new Code128();
            barcode.setFontSize(32);
            barcode.setModuleWidth(4);
            barcode.setBarHeight(100);
            barcode.setHumanReadableLocation(HumanReadableLocation.BOTTOM);
            barcode.setContent("1234567890");

            int width = barcode.getWidth();
            int height = barcode.getHeight();

            BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
            Graphics2D g2d = image.createGraphics();
            g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            Java2DRenderer renderer = new Java2DRenderer(g2d, 1, Color.WHITE, Color.BLACK);
            renderer.render(barcode);

            ImageIO.write(image, "png", new File("code-128.png"));
        }

        {
            Ean ean13 = new Ean();
            ean13.setFontSize(32);
            ean13.setModuleWidth(4);
            ean13.setBarHeight(100);
            ean13.setHumanReadableLocation(HumanReadableLocation.BOTTOM);
            ean13.setContent("1234567890");

            int width = ean13.getWidth();
            int height = ean13.getHeight();

            BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
            Graphics2D g2d = image.createGraphics();
            g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            Java2DRenderer renderer = new Java2DRenderer(g2d, 1, Color.WHITE, Color.BLACK);
            renderer.render(ean13);

            ImageIO.write(image, "png", new File("ean-13.png"));
        }

        {
            Upc upc = new Upc();
            upc.setFontSize(32);
            upc.setModuleWidth(4);
            upc.setBarHeight(100);
            upc.setHumanReadableLocation(HumanReadableLocation.BOTTOM);
            upc.setContent("1234567890");

            int width = upc.getWidth();
            int height = upc.getHeight();

            BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
            Graphics2D g2d = image.createGraphics();
            g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            Java2DRenderer renderer = new Java2DRenderer(g2d, 1, Color.WHITE, Color.BLACK);
            renderer.render(upc);

            ImageIO.write(image, "png", new File("upc.png"));
        }

        ...
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

plugins {
    id 'application'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'uk.org.okapibarcode:okapibarcode:0.3.3'
}

application {
    mainClass = 'io.github.picodotdev.blogbitix.javabarcode.Main'
}

Generar un código QR con Java

Otro formato de códigos son los que tienen dos dimensiones entre los que está el popular código QR que muchos smartphones reconocen con la cámara.

En este caso basta instancia la clase que representa el código QR y proporcionarle el contenido que se desea codificar, el proceso de generación de la imagen es igual que en el caso de los códigos de barras.

Como el programa Decoder soporta decodificación dada una imagen permite comprobar si el código QR contiene el valor codificado al generarla.

Normalmente los códigos suelen generarse en los colores blanco y negro pero también es posible cambiar el color primario y de fondo si se desean otros colores teniendo en cuenta que han de ser colores que el lector pueda reconocer al leerlo. Hay que cambiar el formato del píxel de la imagen con BufferedImage.TYPE_INT_ARGB y especificar otros colores en la clase Java2DRenderer.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

package io.github.picodotdev.blogbitix.javabarcode;

...

public class Main {

    public static void main(String[] args) throws Exception {
        ...

        {
            QrCode qrCode = new QrCode();
            qrCode.setContent("1234567890");

            int width = qrCode.getWidth();
            int height = qrCode.getHeight();

            BufferedImage image = new BufferedImage(width * 8, height * 8, BufferedImage.TYPE_BYTE_GRAY);
            Graphics2D g2d = image.createGraphics();
            g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            Java2DRenderer renderer = new Java2DRenderer(g2d, 8, Color.WHITE, Color.BLACK);
            renderer.render(qrCode);

            ImageIO.write(image, "png", new File("qr-code.png"));
        }

        {
            QrCode qrCode = new QrCode();
            qrCode.setContent("https://picodotdev.github.io/blog-bitix/");

            int width = qrCode.getWidth();
            int height = qrCode.getHeight();

            BufferedImage image = new BufferedImage(width * 8, height * 8, BufferedImage.TYPE_INT_ARGB);
            Graphics2D g2d = image.createGraphics();
            g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            Java2DRenderer renderer = new Java2DRenderer(g2d, 8, Color.YELLOW, Color.BLUE);
            renderer.render(qrCode);

            ImageIO.write(image, "png", new File("qr-code-blogbitix.png"));
        }
    }
}

El código fuente completo del ejemplo puedes descargarlo del repositorio de ejemplos de Blog Bitix alojado en GitHub y probarlo en tu equipo ejecutando siguiente comando:
./gradlew run