AttributeConverter Interface

Oct 13, 2025 by pinkandtrash.com 113 views

Overview

In this article, we will implement a custom AttributeConverter to convert a 2D array of Cell objects to a byte[] and vice versa. This converter will be used to store the 2D array in a database in a more efficient way.

AttributeConverter Interface

The AttributeConverter interface is defined in the Jakarta Persistence API. It provides two methods: convertToDatabaseColumn and convertToEntityAttribute. These methods are used to convert the application type to a database type and vice versa.

public interface AttributeConverter<X, Y> {
    Y convertToDatabaseColumn(X attribute);
    X convertToEntityAttribute(Y dbData);
}

Implementing the Converter

We will implement the AttributeConverter interface to convert a 2D array of Cell objects to a byte[] and vice versa.

CellArrayAttributeConverter Class

public class CellArrayAttributeConverter implements AttributeConverter<Cell[][], byte[]> {
    @Override
    public byte[] convertToDatabaseColumn(Cell[][] attribute) {
        int rows = attribute.length;
        int cols = attribute[0].length;
        int bytesRequired = 2 + (rows * cols + 7) / 8;
        byte[] result = new byte[bytesRequired];

        // Store the number of rows and columns
        result[0] = (byte) rows;
        result[1] = (byte) cols;

        // Create a BitSet to store the shot values
        BitSet bitSet = new BitSet(rows * cols);
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (attribute[i][j].isShot()) {
                    bitSet.set(i * cols + j);
                }
            }
        }

        // Convert the BitSet to a byte array
        byte[] bitSetBytes = bitSet.toByteArray();

        // Copy the values from the BitSet byte array to the result byte array
        System.arraycopy(bitSetBytes, 0, result, 2, bitSetBytes.length);

        return result;
    }

    @Override
    public Cell[][] convertToEntityAttribute(byte[] dbData) {
        // Check if the byte array is valid
        if (dbData.length < 2) {
            throw new IllegalArgumentException("Invalid byte array");
        }

        // Extract the number of rows and columns
        int rows = dbData[0];
        int cols = dbData[1];

        // Create a BitSet to store the shot values
        BitSet bitSet = new BitSet(rows * cols);
        byte[] bitSetBytes = new byte[(rows * cols + 7) / 8];
        System.arraycopy(dbData, 2, bitSetBytes, 0, bitSetBytes.length);
        bitSet.fromByteArray(bitSetBytes);

        // Create a 2D array of Cell objects
        Cell[][] result = new Cell[rows][cols];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                result[i][j] = new Cell(i * cols + j, bitSet.get(i * cols + j));
            }
        }

        return result;
    }
}

Cell Class

public class Cell {
    private int index;
    private boolean shot;

    public Cell(int index, boolean shot) {
        this.index = index;
        this.shot = shot;
    }

    public boolean isShot() {
        return shot;
    }
}

BitSet Class

import java.util.BitSet;

public class BitSet {
    private BitSet bitSet;

    public BitSet(int size) {
        this.bitSet = new BitSet(size);
    }

    public void set(int index) {
        bitSet.set(index);
    }

    public boolean get(int index) {
        return bitSet.get(index);
    }

    public byte[] toByteArray() {
        return bitSet.toByteArray();
    }

    public static BitSet fromByteArray(byte[] bytes) {
        BitSet bitSet = new BitSet();
        bitSet.fromByteArray(bytes);
        return bitSet;
    }
}

Tests

public class CellArrayAttributeConverterTest {
    @Test
    public void testConvertToDatabaseColumn() {
        Cell[][] cells = new Cell[2][2];
        cells[0][0] = new Cell(0, true);
        cells[0][1] = new Cell(1, false);
        cells[1][0] = new Cell(2, true);
        cells[1][1] = new Cell(3, false);

        byte[] result = new CellArrayAttributeConverter().convertToDatabaseColumn(cells);

        // Check the number of rows and columns
        assertEquals(2, result[0]);
        assertEquals(2, result[1]);

        // Check the shot values
        BitSet bitSet = BitSet.fromByteArray(result, 2, result.length - 2);
        assertTrue(bitSet.get(0));
        assertFalse(bitSet.get(1));
        assertTrue(bitSet.get(2));
        assertFalse(bitSet.get(3));
    }

    @Test
    public void testConvertToEntityAttribute() {
        byte[] dbData = new byte[10];
        dbData[0] = 2;
        dbData[1] = 2;
        dbData[2] = (byte) 0b10000000;
        dbData[3] = (byte) 0b00000000;
        dbData[4] = (byte) 0b10000000;
        dbData[5] = (byte) 0b00000000;

        Cell[][] result = new CellArrayAttributeConverter().convertToEntityAttribute(dbData);

        // Check the number of rows and columns
        assertEquals(2, result.length);
        assertEquals(2, result[0].length);

        // Check the shot values
        assertTrue(result[0][0].isShot());
        assertFalse(result[0][1].isShot());
        assertTrue(result[1][0].isShot());
        assertFalse(result[1][1].isShot());
    }
}

Q: What is the purpose of the CellArrayAttributeConverter?

A: The CellArrayAttributeConverter is a custom AttributeConverter that converts a 2D array of Cell objects to a byte array and vice versa. This converter is used to store the 2D array in a database in a more efficient way.

Q: What is the benefit of using a BitSet to store the shot values?

A: Using a BitSet to store the shot values allows us to store the values in a compact way. Each bit in the BitSet represents a Cell object, and we can store 8 Cell objects in a single byte. This reduces the amount of memory required to store the 2D array.

Q: How does the convertToDatabaseColumn method work?

A: The convertToDatabaseColumn method takes a 2D array of Cell objects as input and returns a byte array. It first extracts the number of rows and columns from the input array. Then, it creates a BitSet to store the shot values. It iterates over the input array and sets the corresponding bits in the BitSet if the Cell object is shot. Finally, it converts the BitSet to a byte array and returns it.

Q: How does the convertToEntityAttribute method work?

A: The convertToEntityAttribute method takes a byte array as input and returns a 2D array of Cell objects. It first checks if the input byte array is valid. Then, it extracts the number of rows and columns from the input array. It creates a BitSet to store the shot values and converts the input byte array to a BitSet. Finally, it creates a 2D array of Cell objects and populates it with the shot values from the BitSet.

Q: What are the advantages of using the CellArrayAttributeConverter?

A: The CellArrayAttributeConverter has several advantages. It allows us to store the 2D array in a database in a more efficient way, reducing the amount of memory required. It also allows us to query the database more efficiently, as we can use the BitSet to quickly retrieve the shot values.

Q: What are the limitations of the CellArrayAttributeConverter?

A: The CellArrayAttributeConverter has several limitations. It assumes that the input 2D array is a square array, and it does not handle non-square arrays. It also assumes that the input byte array is valid, and it does not handle invalid byte arrays.

Q: How can I use the CellArrayAttributeConverter in my application?

A: To use the CellArrayAttributeConverter in your application, you need to create an instance of the converter and call the convertToDatabaseColumn or convertToEntityAttribute method. You can also use the converter in a JPA entity to store the 2D array in a database.

Q: Can I customize the CellArrayAttributeConverter to suit my needs?

A: Yes, you can customize the CellArrayAttributeConverter to suit your needs. You can modify the converter to handle non-square arrays, or to use a different data structure to store the shot values. You can also add additional methods to the converter to perform other operations.

Q: What are the best practices for using the CellArrayAttributeConverter?

A: The best practices for using the CellArrayAttributeConverter include:

Using the converter in a JPA entity to store the 2D array in a database.
Ensuring that the input 2D array is a square array.
Ensuring that the input byte array is valid.
Using the converter to store the 2D array in a database in a more efficient way.
Using the converter to query the database more efficiently.