CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-com-vaadin--vaadin

Comprehensive Java web application development framework that enables server-side Java development with modern web UI components and automatic client-server communication.

Overview
Eval results
Files

data-components.mddocs/

Data Components

Vaadin's data components provide high-performance display and interaction with large datasets. These components support lazy loading, virtual scrolling, sorting, filtering, and selection.

Core Imports

// Data display components
import com.vaadin.flow.component.grid.Grid;
import com.vaadin.flow.component.treegrid.TreeGrid;
import com.vaadin.flow.component.virtuallist.VirtualList;

// Data providers and sources
import com.vaadin.flow.data.provider.DataProvider;
import com.vaadin.flow.data.provider.ListDataProvider;
import com.vaadin.flow.data.provider.CallbackDataProvider;
import com.vaadin.flow.data.provider.HierarchicalDataProvider;
import com.vaadin.flow.data.provider.TreeDataProvider;
import com.vaadin.flow.data.provider.TreeData;
import com.vaadin.flow.data.provider.Query;
import com.vaadin.flow.data.provider.QuerySortOrder;

// Selection models
import com.vaadin.flow.component.grid.GridSingleSelectionModel;
import com.vaadin.flow.component.grid.GridMultiSelectionModel;
import com.vaadin.flow.data.selection.SingleSelectionModel;
import com.vaadin.flow.data.selection.MultiSelectionModel;

// Renderers
import com.vaadin.flow.data.renderer.ComponentRenderer;
import com.vaadin.flow.data.renderer.LitRenderer;
import com.vaadin.flow.data.renderer.TextRenderer;
import com.vaadin.flow.data.renderer.NumberRenderer;
import com.vaadin.flow.data.renderer.LocalDateRenderer;
import com.vaadin.flow.data.renderer.LocalDateTimeRenderer;

// Core interfaces and utilities
import com.vaadin.flow.component.Component;
import com.vaadin.flow.component.HasSize;
import com.vaadin.flow.data.provider.HasDataProvider;
import com.vaadin.flow.function.ValueProvider;
import com.vaadin.flow.function.SerializablePredicate;
import com.vaadin.flow.shared.Registration;

// Grid specific enums and classes
import com.vaadin.flow.component.grid.Grid.SelectionMode;
import com.vaadin.flow.component.grid.Grid.Column;
import com.vaadin.flow.component.grid.ColumnTextAlign;
import com.vaadin.flow.component.grid.GridSortOrder;
import com.vaadin.flow.data.provider.SortDirection;
import com.vaadin.flow.component.grid.GridMultiSelectionModel.SelectAllCheckboxVisibility;

// Java standard library for data handling
import java.util.Set;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
import java.time.LocalDate;
import java.time.LocalDateTime;

Grid Component

Grid

High-performance data grid with columns, sorting, filtering, and selection capabilities.

public class Grid<T> extends Component implements HasDataProvider<T>, HasSize {
    public Grid();
    public Grid(Class<T> beanType);
    public Grid(Class<T> beanType, boolean autoCreateColumns);

    // Column management
    public Grid.Column<T> addColumn(ValueProvider<T, ?> valueProvider);
    public Grid.Column<T> addColumn(ValueProvider<T, ?> valueProvider, String columnKey);
    public Grid.Column<T> addColumn(String propertyName);
    public Grid.Column<T> addComponentColumn(ValueProvider<T, Component> componentProvider);
    public Grid.Column<T> addComponentColumn(ValueProvider<T, Component> componentProvider, String columnKey);
    public List<Grid.Column<T>> getColumns();
    public Grid.Column<T> getColumnByKey(String columnKey);
    public void removeColumn(Grid.Column<T> column);
    public void removeColumnByKey(String columnKey);
    public void removeAllColumns();
    public void setColumnOrder(Grid.Column<T>... columns);
    public void setColumnOrder(String... columnKeys);

    // Data management
    public void setItems(Collection<T> items);
    public void setItems(T... items);
    public void setDataProvider(DataProvider<T, ?> dataProvider);
    public DataProvider<T, ?> getDataProvider();
    public void setPageSize(int pageSize);
    public int getPageSize();

    // Selection
    public void setSelectionMode(SelectionMode selectionMode);
    public SelectionMode getSelectionMode();
    public GridSingleSelectionModel<T> asSingleSelect();
    public GridMultiSelectionModel<T> asMultiSelect();
    public Set<T> getSelectedItems();
    public Registration addSelectionListener(SelectionListener<Grid<T>, T> listener);

    // Sorting
    public void sort(List<GridSortOrder<T>> order);
    public List<GridSortOrder<T>> getSortOrder();
    public Registration addSortListener(ComponentEventListener<SortEvent<Grid<T>, GridSortOrder<T>>> listener);

    // Appearance
    public void setRowStripes(boolean rowStripes);
    public boolean isRowStripes();
    public void setAllRowsVisible(boolean allRowsVisible);
    public boolean isAllRowsVisible();
    public void setVerticalScrollingEnabled(boolean enabled);

    // Details
    public void setDetailsVisibleOnClick(boolean detailsVisibleOnClick);
    public void setItemDetailsRenderer(Renderer<T> renderer);
    public void setDetailsVisible(T item, boolean visible);
    public boolean isDetailsVisible(T item);

    // Event handling
    public Registration addItemClickListener(ComponentEventListener<ItemClickEvent<T>> listener);
    public Registration addItemDoubleClickListener(ComponentEventListener<ItemDoubleClickEvent<T>> listener);
}

public static class Column<T> {
    // Header and footer
    public Column<T> setHeader(String text);
    public Column<T> setHeader(Component component);
    public Component getHeaderComponent();
    public Column<T> setFooter(String text);
    public Column<T> setFooter(Component component);

    // Sorting
    public Column<T> setSortable(boolean sortable);
    public boolean isSortable();
    public Column<T> setSortProperty(String... properties);
    public Column<T> setSortOrderProvider(SortOrderProvider provider);

    // Appearance
    public Column<T> setWidth(String width);
    public String getWidth();
    public Column<T> setFlexGrow(int flexGrow);
    public int getFlexGrow();
    public Column<T> setResizable(boolean resizable);
    public boolean isResizable();
    public Column<T> setFrozen(boolean frozen);
    public boolean isFrozen();
    public Column<T> setVisible(boolean visible);
    public boolean isVisible();

    // Text alignment
    public Column<T> setTextAlign(ColumnTextAlign textAlign);
    public ColumnTextAlign getTextAlign();

    // Auto-width
    public Column<T> setAutoWidth(boolean autoWidth);
    public boolean isAutoWidth();

    // Key and renderer
    public String getKey();
    public Column<T> setRenderer(Renderer<T> renderer);
    public Renderer<T> getRenderer();
}

TreeGrid

Hierarchical data grid for displaying tree-structured data.

public class TreeGrid<T> extends Grid<T> {
    public TreeGrid();
    public TreeGrid(Class<T> beanType);

    // Hierarchy management
    public void setTreeData(TreeData<T> treeData);
    public TreeData<T> getTreeData();
    public void setDataProvider(HierarchicalDataProvider<T, ?> dataProvider);
    public HierarchicalDataProvider<T, ?> getDataProvider();

    // Expand/collapse
    public void expand(T... items);
    public void collapse(T... items);
    public void expandRecursively(T... items);
    public void collapseRecursively(T... items);
    public boolean isExpanded(T item);
    public Set<T> getExpandedItems();

    // Hierarchy column
    public void addHierarchyColumn(ValueProvider<T, ?> valueProvider);
    public void addHierarchyColumn(String propertyName);
    public Grid.Column<T> getHierarchyColumn();

    // Event handling
    public Registration addExpandListener(ComponentEventListener<ExpandEvent<T, TreeGrid<T>>> listener);
    public Registration addCollapseListener(ComponentEventListener<CollapseEvent<T, TreeGrid<T>>> listener);
}

VirtualList

High-performance virtualized list for displaying large datasets with custom item renderers.

public class VirtualList<T> extends Component implements HasDataProvider<T>, HasSize {
    public VirtualList();

    // Data management
    public void setItems(Collection<T> items);
    public void setItems(T... items);
    public void setDataProvider(DataProvider<T, ?> dataProvider);
    public DataProvider<T, ?> getDataProvider();

    // Rendering
    public void setRenderer(ComponentRenderer<? extends Component, T> renderer);
    public ComponentRenderer<? extends Component, T> getRenderer();

    // Placeholder
    public void setPlaceholderItem(T placeholderItem);
    public T getPlaceholderItem();

    // Event handling
    public Registration addAttachListener(ComponentEventListener<AttachEvent> listener);
    public Registration addDetachListener(ComponentEventListener<DetachEvent> listener);
}

Data Providers

DataProvider Interface

Core interface for providing data to components with lazy loading support.

public interface DataProvider<T, F> {
    // Data fetching
    Stream<T> fetch(Query<T, F> query);
    int size(Query<T, F> query);

    // Refresh operations
    void refreshAll();
    void refreshItem(T item);

    // Event handling
    Registration addDataProviderListener(DataProviderListener<T> listener);

    // Filtering
    DataProvider<T, F> withFilter(F filter);
    DataProvider<T, Void> withConfigurableFilter();

    // Conversion
    <C> DataProvider<C, F> map(ValueProvider<T, C> mapper);
}

public static class Query<T, F> {
    public int getOffset();
    public int getLimit();
    public Stream<QuerySortOrder> getSortOrders();
    public Optional<F> getFilter();
    public List<String> getInMemorySorting();
}

ListDataProvider

In-memory data provider for collections with built-in sorting and filtering.

public class ListDataProvider<T> extends AbstractDataProvider<T, SerializablePredicate<T>> {
    public ListDataProvider(Collection<T> items);
    public ListDataProvider(Stream<T> items);

    // Item management
    public Collection<T> getItems();
    public void refreshItem(T item);
    public void refreshAll();

    // Sorting
    public void setSortOrder(ValueProvider<T, ?> valueProvider, SortDirection direction);
    public void setSortOrder(SerializableComparator<T> comparator);
    public void setSortComparator(SerializableComparator<T> comparator);

    // Filtering
    public void setFilter(SerializablePredicate<T> filter);
    public void addFilter(SerializablePredicate<T> filter);
    public void removeFilter();
    public SerializablePredicate<T> getFilter();
}

CallbackDataProvider

Backend data provider that uses callbacks for data fetching.

public class CallbackDataProvider<T, F> extends AbstractDataProvider<T, F> {
    public CallbackDataProvider(SerializableFunction<Query<T, F>, Stream<T>> fetchCallback,
                               SerializableFunction<Query<T, F>, Integer> sizeCallback);

    // ID-based operations
    public CallbackDataProvider<T, F> withConfigurableFilter(SerializableBiFunction<Query<T, F>, F, Query<T, F>> filterConverter);
}

HierarchicalDataProvider

Data provider interface for tree-structured data.

public interface HierarchicalDataProvider<T, F> extends DataProvider<T, F> {
    // Hierarchy queries
    Stream<T> fetchChildren(HierarchicalQuery<T, F> query);
    int getChildCount(HierarchicalQuery<T, F> query);
    boolean hasChildren(T item);
}

public class TreeDataProvider<T> extends AbstractHierarchicalDataProvider<T, SerializablePredicate<T>> {
    public TreeDataProvider(TreeData<T> treeData);

    public TreeData<T> getTreeData();
    public void setFilter(SerializablePredicate<T> filter);
}

Data Structures

TreeData

Container for hierarchical data structure.

public class TreeData<T> {
    public TreeData();

    // Item management
    public TreeData<T> addItem(T parent, T item);
    public TreeData<T> addItems(T parent, T... items);
    public TreeData<T> addItems(T parent, Collection<T> items);
    public TreeData<T> addRootItems(T... items);
    public TreeData<T> addRootItems(Collection<T> items);
    public boolean removeItem(T item);
    public void clear();

    // Hierarchy queries
    public List<T> getRootItems();
    public List<T> getChildren(T item);
    public T getParent(T item);
    public boolean contains(T item);
    public Stream<T> getChildren(T item);
}

Selection Models

Grid Selection Models

public interface GridSingleSelectionModel<T> extends SingleSelectionModel<Grid<T>, T> {
    void select(T item);
    void deselect(T item);
    Optional<T> getSelectedItem();
    void setDeselectAllowed(boolean deselectAllowed);
    boolean isDeselectAllowed();
}

public interface GridMultiSelectionModel<T> extends MultiSelectionModel<Grid<T>, T> {
    void select(T item);
    void deselect(T item);
    void selectAll();
    void deselectAll();
    Set<T> getSelectedItems();
    void updateSelection(Set<T> addedItems, Set<T> removedItems);

    // Select all checkbox
    void setSelectAllCheckboxVisibility(SelectAllCheckboxVisibility visibility);
    SelectAllCheckboxVisibility getSelectAllCheckboxVisibility();
}

Renderers

Component Renderers

public class ComponentRenderer<COMPONENT extends Component, ITEM> implements Renderer<ITEM> {
    public ComponentRenderer(SerializableFunction<ITEM, COMPONENT> componentFunction);
    public ComponentRenderer(SerializableFunction<ITEM, COMPONENT> componentFunction,
                           SerializableBiConsumer<COMPONENT, ITEM> itemConsumer);

    public static <ITEM> ComponentRenderer<Component, ITEM> of(SerializableFunction<ITEM, Component> componentFunction);
}

public class LitRenderer<SOURCE> implements Renderer<SOURCE> {
    public static <SOURCE> LitRenderer<SOURCE> of(String template);
    public LitRenderer<SOURCE> withProperty(String property, ValueProvider<SOURCE, ?> provider);
    public LitRenderer<SOURCE> withFunction(String functionName, SerializableConsumer<SOURCE> handler);
}

public class TextRenderer<SOURCE> implements Renderer<SOURCE> {
    public TextRenderer();
    public TextRenderer(ValueProvider<SOURCE, String> valueProvider);
    public TextRenderer(ValueProvider<SOURCE, String> valueProvider, String nullRepresentation);
}

public class NumberRenderer<SOURCE> extends TextRenderer<SOURCE> {
    public NumberRenderer(ValueProvider<SOURCE, Number> valueProvider);
    public NumberRenderer(ValueProvider<SOURCE, Number> valueProvider, String format);
    public NumberRenderer(ValueProvider<SOURCE, Number> valueProvider, String format, Locale locale);
}

public class LocalDateRenderer<SOURCE> extends TextRenderer<SOURCE> {
    public LocalDateRenderer(ValueProvider<SOURCE, LocalDate> valueProvider);
    public LocalDateRenderer(ValueProvider<SOURCE, LocalDate> valueProvider, String format);
    public LocalDateRenderer(ValueProvider<SOURCE, LocalDate> valueProvider, String format, Locale locale);
}

public class LocalDateTimeRenderer<SOURCE> extends TextRenderer<SOURCE> {
    public LocalDateTimeRenderer(ValueProvider<SOURCE, LocalDateTime> valueProvider);
    public LocalDateTimeRenderer(ValueProvider<SOURCE, LocalDateTime> valueProvider, String format);
    public LocalDateTimeRenderer(ValueProvider<SOURCE, LocalDateTime> valueProvider, String format, Locale locale);
}

Common Types and Enums

// Selection modes
public enum SelectionMode {
    SINGLE, MULTI, NONE
}

// Column alignment
public enum ColumnTextAlign {
    START, CENTER, END
}

// Sort direction
public enum SortDirection {
    ASCENDING, DESCENDING
}

// Grid sort order
public class GridSortOrder<T> {
    public GridSortOrder(Grid.Column<T> column, SortDirection direction);
    public Grid.Column<T> getSorted();
    public SortDirection getDirection();
}

// Query sort order
public class QuerySortOrder {
    public QuerySortOrder(String sorted, SortDirection direction);
    public String getSorted();
    public SortDirection getDirection();
}

// Select all checkbox visibility
public enum SelectAllCheckboxVisibility {
    VISIBLE, HIDDEN, DEFAULT
}

// Value provider interface
public interface ValueProvider<SOURCE, TARGET> extends SerializableFunction<SOURCE, TARGET> {
}

Usage Examples

Basic Grid with Bean Binding

Grid<Person> grid = new Grid<>(Person.class);
grid.setColumns("firstName", "lastName", "email", "age");
grid.setItems(personService.findAll());

grid.addColumn(person -> person.getFullName()).setHeader("Full Name");
grid.addComponentColumn(person -> new Button("Edit")).setHeader("Actions");

Grid with Custom Data Provider

Grid<Person> grid = new Grid<>();
grid.addColumn(Person::getFirstName).setHeader("First Name");
grid.addColumn(Person::getLastName).setHeader("Last Name");

CallbackDataProvider<Person, Void> dataProvider = new CallbackDataProvider<>(
    query -> personService.fetch(query.getOffset(), query.getLimit()).stream(),
    query -> personService.count()
);

grid.setDataProvider(dataProvider);

TreeGrid with Hierarchical Data

TreeGrid<Department> treeGrid = new TreeGrid<>();
treeGrid.addHierarchyColumn(Department::getName).setHeader("Department");
treeGrid.addColumn(Department::getEmployeeCount).setHeader("Employees");

TreeData<Department> treeData = new TreeData<>();
treeData.addRootItems(rootDepartments);
rootDepartments.forEach(dept ->
    treeData.addItems(dept, dept.getSubDepartments())
);

treeGrid.setTreeData(treeData);

These data components provide efficient handling of large datasets with minimal memory footprint and excellent user experience through virtual scrolling and lazy loading.

Install with Tessl CLI

npx tessl i tessl/maven-com-vaadin--vaadin

docs

components.md

data-binding.md

data-components.md

index.md

layouts.md

routing.md

security.md

server-communication.md

theming.md

tile.json