Java Command-Line, GUI and Web Apps for Scanning Barcode and QR Code
Tags: java, springboot, gui, qrcode
Published: 2022-03-25 01:34:25

In [previous article](https://www.dynamsoft.com/codepool/java-barcode-reader-scan-multiple.html), we discussed how to construct a command-line barcode and QR code scanning application using Java and [Dynamsoft Barcode Reader](https://www.dynamsoft.com/barcode-reader/sdk-desktop-server/). In this article, we will create more fancy applications, such as a desktop GUI application and a web application. In addition, we will import [ZXing](https://github.com/zxing/zxing) SDK to make a comparison with Dynamsoft Barcode Reader.


## SDK Version
- ZXing v3.4.0
- [Dynamsoft Barcode Reader v9.0](https://www.dynamsoft.com/barcode-reader/downloads/)
    
    To activate the SDK, you must click [here](https://www.dynamsoft.com/customer/license/trialLicense?product=dbr) to get a valid license key.

## Maven Configuration
Configure the dependencies in the **pom.xml** file:
```xml
<repositories>
        <repository>
            <id>dbr</id>
            <url>https://download2.dynamsoft.com/maven/dbr/jar</url>
        </repository>
</repositories>
<dependencies>
        <dependency>
            <groupId>com.dynamsoft</groupId>
            <artifactId>dbr</artifactId>
            <version>9.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.google.zxing</groupId>
            <artifactId>core</artifactId>
            <version>3.4.0</version>
          </dependency>
</dependencies>
```


## Test Image
The test image contains multiple barcode and QR code.

![multiple barcode image](https://www.dynamsoft.com/codepool/img/2020/02/AllSupportedBarcodeTypes-1000x652.png)

## A Variety of Java Applications for Scanning Barcode and QR Code
Let's see how ZXing and Dynamsoft Barcode Reader perform in command-line, GUI and web applications.

### Command-Line Application
Create a new Maven project:

```plain
mvn archetype:generate -DgroupId=com.java.barcode -DartifactId=app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false
```

Import ZXing and Dynamsoft Barcode Reader:

```java
import com.dynamsoft.dbr.*;
import com.google.zxing.BinaryBitmap;
import com.google.zxing.MultiFormatReader;
import com.google.zxing.NotFoundException;
import com.google.zxing.RGBLuminanceSource;
import com.google.zxing.Result;
import com.google.zxing.common.HybridBinarizer;
import com.google.zxing.multi.*;
```

Decode the image file with **ImageIO** and **BufferedImage**:

```java
import java.awt.image.*;
import javax.imageio.ImageIO;

BufferedImage image = null;
try {
    image = ImageIO.read(new File(filename));
} catch (IOException e) {
    System.out.println(e);
    return;
}
```

To read multiple barcodes encoded with different barcode symbologies in ZXing, we need to use `MultiFormatReader` and `GenericMultipleBarcodeReader`. The `BufferedImage` needs to be converted to `BinaryBitmap`:

```java
BinaryBitmap bitmap = null;
int[] pixels = image.getRGB(0, 0, image.getWidth(), image.getHeight(), null, 0, image.getWidth());
RGBLuminanceSource source = new RGBLuminanceSource(image.getWidth(), image.getHeight(), pixels);
bitmap = new BinaryBitmap(new HybridBinarizer(source));
            
MultiFormatReader reader = new MultiFormatReader();  
GenericMultipleBarcodeReader multiReader = new GenericMultipleBarcodeReader(reader);
try {
    Result[] zxingResults = multiReader.decodeMultiple(bitmap);
} catch (NotFoundException e) {
    e.printStackTrace();
}
pixels = null;
bitmap = null;
```

In contrast, invoking Dynamsoft Barcode Reader API is much simpler, because it supports `BufferedImage` as the input parameter:

```java
BarcodeReader br = null;
try {
    br = new BarcodeReader("LICENSE-KEY");
} catch (Exception e) {
    System.out.println(e);
    return;
}

TextResult[] results = null;
try {
    results = br.decodeBufferedImage(image, "");
} catch (Exception e) {
    System.out.println("decode buffered image: " + e);
}
```

To run the Java program conveniently in terminal, we assemble all dependencies into one jar file by using the **maven-assembly-plugin**:

```xml
<build>
<plugins>
    <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <configuration>
            <descriptorRefs>
                <descriptorRef>jar-with-dependencies</descriptorRef>
            </descriptorRefs>
        </configuration>
    </plugin>
</plugins>
</build>
```

Build the Maven project and run the application:

```bash
mvn clean install assembly:assembly -Dmaven.test.skip=true
java -cp target/command-line-1.0-SNAPSHOT-jar-with-dependencies.jar com.java.barcode.App ..\images\AllSupportedBarcodeTypes.png
```

![java barcode command line](https://www.dynamsoft.com/codepool/img/2020/03/java-barcode-command-line-1000x623.png)

We can see ZXing only returns **8** results, whereas Dynamsoft Barcode Reader returns **18** results.

### Desktop GUI Application built with Java Swing

Based on the command-line Java program created above, we can add **Swing** class to turn the command-line app into a GUI app.

Import the relevant classes:

```java
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JComboBox;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.filechooser.FileNameExtensionFilter;

import java.awt.BorderLayout;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
```

The widgets we need include `JTextArea`, `JButton`, `JFileChooser` and `JComboBox`:

- JTextArea: display the results.
- JButton: trigger the click event.
- JFileChooser: select an image file from the disk drive.
- JComboBox: toggle ZXing and Dynamsoft Barcode Reader.

We initialize the layout with all the widgets:

```java
public App() {
    super(new BorderLayout());
    
    mFileChooser = new JFileChooser();
    FileNameExtensionFilter filter = new FileNameExtensionFilter(
            ".png", "png");
    mFileChooser.setFileFilter(filter);
    mLoad = new JButton("Load File");
    mLoad.addActionListener(this);
    
    mSourceList = new JComboBox(new String[]{"ZXing", "Dynamsoft"});
    mSourceList.setSelectedIndex(0);
    
    JPanel buttonPanel = new JPanel(); 
    buttonPanel.add(mSourceList);
    buttonPanel.add(mLoad);
    add(buttonPanel, BorderLayout.PAGE_START);
    
    mTextArea = new JTextArea();
    mTextArea.setSize(480, 480);
    JScrollPane sp = new JScrollPane(mTextArea); 
    add(sp, BorderLayout.CENTER);
}
```

As the button click event is triggered, we can load an image for recognizing barcode and QR code:

```java
public void actionPerformed(ActionEvent e) {

    int returnVal = mFileChooser.showOpenDialog(App.this);

    if (returnVal == JFileChooser.APPROVE_OPTION) {
        File file = mFileChooser.getSelectedFile();     
        String filename = file.toPath().toString();          
        if (mSourceList.getSelectedItem().toString().equals("Dynamsoft")) {
            TextResult[] results = decodefileDynamsoft(filename);
        }
        else {
            Result[] results = decodefileZXing(filename);
        }
    } 
}
```

Build and run the Java GUI application:

```plain
mvn clean install assembly:assembly -Dmaven.test.skip=true
java -cp target/gui-1.0-SNAPSHOT-jar-with-dependencies.jar com.java.barcode.App
```

![java barcode gui](https://www.dynamsoft.com/codepool/img/2020/03/java-barcode-gui.png)

You can switch ZXing and Dynamsoft Barcode Reader by drop-down list.

### Web Application built with Java Spring Boot

**Spring Boot** is used to develop web applications. We can follow the official [tutorial](https://docs.spring.io/spring-boot/docs/current/reference/html/getting-started.html) to get started with a simple web app.

To quickly test the server-side Java barcode API, we can integrate **swagger-ui** into the Spring Boot app by adding the following dependencies:

```xml
<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-core</artifactId>
    <version>1.1.45</version>
    <exclusions>
        <exclusion>
            <groupId>io.github.classgraph</groupId>
            <artifactId>classgraph</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-ui</artifactId>
    <version>1.1.45</version>
</dependency>
```

Afterwards, we create a controller that contains POST mappings for ZXing and Dynamsoft Barcode Reader:

```java
@RestController
public class BarcodeController {

    private DynamsoftBarcode mDynamsoftBarcode;
    private ZXingBarcode mZXingBarcode;

    @Autowired
    public BarcodeController(DynamsoftBarcode dynamsoft, ZXingBarcode zxing) 
    {
        mDynamsoftBarcode = dynamsoft;
        mZXingBarcode = zxing;
    }

    @PostMapping(value = "/api/dynamsoft"
            , consumes = MediaType.MULTIPART_FORM_DATA_VALUE
            , produces = MediaType.APPLICATION_JSON_VALUE)
    public BarcodeResponse getDynamsoft(@RequestPart MultipartFile file) throws Exception {
        return mDynamsoftBarcode.decode(file.getOriginalFilename(), file.getInputStream());
    }

    @PostMapping(value = "/api/zxing"
            , consumes = MediaType.MULTIPART_FORM_DATA_VALUE
            , produces = MediaType.APPLICATION_JSON_VALUE)
    public BarcodeResponse getZXing(@RequestPart MultipartFile file) throws Exception {
        return mZXingBarcode.decode(file.getOriginalFilename(), file.getInputStream());
    }
}
```

Finally, we build and run the Spring Boot app as follows:

```bash
mvn clean install
java -jar target/web-1.0-SNAPSHOT.jar
```

Now, visit **http://localhost:8080/swagger-ui.html** to test ZXing and Dynamsoft Barcode Reader via POST event.

![java barcode spring boot](https://www.dynamsoft.com/codepool/img/2020/03/java-barcode-spring-boot-1000x832.png)

## Source Code
[https://github.com/yushulx/java-barcode-command-gui-web](https://github.com/yushulx/java-barcode-command-gui-web)