Setting up TableColumns Value using Generic Types

Question

I wanted to program a TableBrowser for a MYSQl Database in JavaFX.

My first problem is: i dont know which types i get back from the Database.

So i decided to wrap those types with a Wrapper-class.

To show these values on the GUI, i used the TableColumns setCellValueFactory-method, which needs a value, that implements ObservableValue.

So i tried to implement the ObservableValue-interface.

But when i run the program it doesnt show the right Values.

TableBrowser after connecting to the Database

Has anyone an idea where i did wrong or knows a more recommended way to implement it ?

Here is the Part of the Code from the TableBrowser

/*
 * this variable is used to iterate over the tableview's columns.
 * It is a class variable, because it is not possible (for some reasons)
 * to use a local variable while working with it in the context of Lambda-expressions
 */
int t = 0;  

// those two variables are defined in the class Body
private final TableView<Entry> tableview = new TableView<>();  
private final ObservableList<Entry> columndata = FXCollections.observableArrayList();    

// the following Code is inside the Button's Actionlistener

for(int i = 1; i <= maxcol; i++) // adds a new TableColum for every colum in the DB
{
   tableview.getColumns().add(new TableColumn<Entry, String>rsmd.getColumnName(i)));
}

// iterates over the ResultSet
while(rs.next())  
{
    // this is the dataset i put in my TableView
    Entry row = new Entry(maxcol); 

    // for each Column i add the columnvalue to the current dataset
    for(int i = 1; i <= maxcol; i++) 
    {
       int type = rsmd.getColumnType(i);
       Object value = rs.getObject(i);
       row.setCellValue(i-1, type, value);
    }       
    // adds a new dataset to the ObservableList<Entry>
    columndata.add(row);
}
// puts all datasets in the TableView
tableview.setItems(columndata);

 // iterates over all Columns
for(t = 0; t < tableview.getColumns().size(); t++)
{
    // should set the CellValueFactory for each Column so it shows the data

    /*
     * I apologise if there a horrible mistake.
     * I never worked with Lamda before and just copied it form an example page :)
     */
    tableview.getColumns().get(t).setCellValueFactory(celldata -> celldata.getValue().getCellValue(t-1));
}

This is my Entry class, which is an inner Class in TableBrowserclass

/* 
 * should represent a Dataset. 
 * Has an array, which holdes every columnvalue as a WrapperType
 */
private class Entry
{
    WrapperType<?>[] columns;

    private Entry(int columncount) 
    {
        columns = new WrapperType[columncount];
    }

    private WrapperType<?> getCellValue(int col)
    {
        return columns[col];
    }

    private void setCellValue(int col, int type, Object value)
    {
        columns[col] = MySQLTypeWrapper.getInstance().wrapType(type, value);
    }
}

Here is the MySQLTypeWrapper class, which holds the WrapperType as an inner class

public class MySQLTypeWrapper 
{
    public WrapperType<?> wrapType(int type, Object Value)
    {
       Class<?> typeclass = toClass(type);
       return new WrapperType<>(typeclass.cast(Value));
    }

   /*
    *  returns the appropriate class def for every database type
    *  Expl: VARCHAR returns String.class
    */
    private static Class<?> toClass(int type) {...}

    /*
     * I copied the content of the of the overridden Methods from StringPropertyBase
     * as i have clue how to implement ObservableValue
     */
    class WrapperType<T> implements ObservableValue<WrapperType<T>>
    {
        private T value;
        private ExpressionHelper<WrapperType<T>> helper = null;

        private WrapperType(T value)
        {
            this.value = value;
        }

        @Override
        public void addListener(InvalidationListener listener) 
        {
           helper = ExpressionHelper.addListener(helper, this, listener);
        }

        @Override
        public void removeListener(InvalidationListener listener) 
        {
           helper = ExpressionHelper.removeListener(helper, listener);
        }

        @Override
        public void addListener(ChangeListener<? super WrapperType<T>> listener) 
        {
            helper = ExpressionHelper.addListener(helper, this, listener);
        }

        @Override
        public void removeListener(ChangeListener<? super WrapperType<T>> listener) 
        {
           helper = ExpressionHelper.removeListener(helper, listener);
        }

        @Override
        public WrapperType<T> getValue() 
        {
           return this;
        }

        public String toString()
        {
           return value.toString();
        }
    }
}

Thanks for your help in advance :)

Answer 1

As mentioned in the comments, your first problem was not using the TableView's Items property.

For the second part - one solution would be to create a helper method along the lines of

private <T> Callback<TableColumn.CellDataFeatures<Entry,T>,ObservableValue<T>> createCellFactory(int columnIndex) {
    return celldata -> celldata.getValue().getCellValue(columnIndex);
}

and then change the loop to

// Now t can be a local variable, as it is not directly passed to the lambda.
for(int t = 0; t < tableview.getColumns().size(); t++)
{
    // should set the CellValueFactory for each Column so it shows the data

    tableview.getColumns().get(t).setCellValueFactory(createCellFactory(t));
}

Note that this time the variable passed to the lambda is a local effectively-final variable and not an instance variable, so the lambda is created with the correct value every time.

One last word of advice - are you sure you need this amount of generality? What I mean is - it is usually better to create a class to directly represent your DB structure with proper getters and setters, then you can use PropertyValueFactory.