Cached Objects

Often it’s necessary to pass a Java object between functions. You might have one function that creates a complex Java object that is used as an input to various other functions, and it’s not convenient or efficient to keep recreating that object from lots of primitive inputs every time you need it.

Jinx allows you to pass objects around as easily as primitive values via its managed object cache. When a function returns a Java type that can’t be converted to a simple Excel type, Jinx assigns it a unique handle and returns that to Excel. Any function that takes an object of the same type (or a super-type) can be passed that handle and Jinx will fetch the object from the cache and pass it to the Java method.

Jinx takes care of making sure that once objects are no longer referenced they are removed from the cache so they can be garbage collected.

Cached objects are not persisted when Excel closes, and they are not saved with the workbook. This means that every time you open a workbook that depends on cached objects it has to be recalculated so that the object cache is repopulated.

The following is a simple example to demonstrate the prinicple:

import com.exceljava.jinx.ExcelFunction;

class Car {
    private final String color;

    private Car(String color) {
        this.color = color;
    }

    @ExcelFunction
    public static Car newCar(String color) {
        return new Car(color);
    }

    @ExcelFunction
    public static String getCarColor(Car car) {
        return car.color;
    }
}