Vaadin - Lazy Query Container

Question

Sto facendo il mio progetto in Vaadin 7. Devo implementare un contenitore Lazy Query per un Treetable. Otterrò i dati per il Treetable da un servizio web.

Qualcuno potrebbe mostrare come utilizzare un contenitore Lazy Query con un servizio Web come origine dati?

Per favore fatemi sapere i passaggi necessari per implementare questo o mostrare un codice di esempio per iniziare.

Answer 1

C'è buona documentazione per LQC qui: https://vaadin.com/wiki/-/wiki/Main/Lazy%20Query%20Container

Gli esempi nella documentazione attuano MovieQuery usando javax.persistence API, ma potrebbe essere più facile da usare semplice MockQuery example come base e sostituire i dati effettivi che vanno a prendere con webservice chiamate.

Answer 2

Dai un'occhiata al seguente lazy loading interfaccia Hierarchical.
Tutti i dati vengono letti da un webservice IViewService.
L'esempio utilizza il componente Tree ma funziona anche per TreeTable.

E 'molto importante per memorizzare tutti gli elementi di una struttura locale (nel mio caso in HashMaphierarchy), non leggere gli elementi più volte questo non funziona. Penso che Vaadin non usi equals() e hashCode().

import java.util.Collection; 
import java.util.Collections; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 

import com.softmodeler.common.CommonPlugin; 
import com.softmodeler.model.OutputNode; 
import com.softmodeler.service.IViewService; 
import com.vaadin.data.Container.Hierarchical; 
import com.vaadin.data.Item; 
import com.vaadin.data.Property; 
import com.vaadin.data.util.BeanItem; 

/** 
* @author Flavio Donzé 
* @version 1.0 
*/ 
public class OutputNodeHierachical implements Hierarchical { 
    private static final long serialVersionUID = 8289589835030184018L; 

    /** the view service */ 
    private IViewService service = CommonPlugin.getService(IViewService.class); 

    /** collection of all root nodes */ 
    private List<OutputNode> rootNodes = null; 
    /** parent=>children mapping */ 
    private Map<OutputNode, List<OutputNode>> hierarchy = new HashMap<>(); 

    /** 
    * constructor 
    * 
    * @param rootNodes collection of all root nodes 
    */ 
    public OutputNodeHierachical(List<OutputNode> rootNodes) { 
     this.rootNodes = Collections.unmodifiableList(rootNodes); 

     addToHierarchy(rootNodes); 
    } 

    @Override 
    public Collection<?> getChildren(Object itemId) { 
     try { 
      List<OutputNode> children = hierarchy.get(itemId); 
      if (children == null) { 
       OutputNode node = (OutputNode) itemId; 
       children = service.getChildren(node.getNodeId(), false); 

       hierarchy.put(node, children); 

       // add children to hierarchy, their children will be added on click 
       addToHierarchy(children); 
      } 
      return children; 
     } catch (Exception e) { 
      VaadinUtil.handleException(e); 
     } 
     return null; 
    } 

    /** 
    * add each element to the hierarchy without their children hierarchy(child=>null) 
    * 
    * @param children elements to add 
    */ 
    private void addToHierarchy(List<OutputNode> children) { 
     for (OutputNode child : children) { 
      hierarchy.put(child, null); 
     } 
    } 

    @Override 
    public boolean areChildrenAllowed(Object itemId) { 
     return !((OutputNode) itemId).getChilds().isEmpty(); 
    } 

    @Override 
    public boolean hasChildren(Object itemId) { 
     return !((OutputNode) itemId).getChilds().isEmpty(); 
    } 

    @Override 
    public Object getParent(Object itemId) { 
     String parentId = ((OutputNode) itemId).getParentId(); 
     for (OutputNode node : hierarchy.keySet()) { 
      if (node.getNodeId().equals(parentId)) { 
       return node; 
      } 
     } 
     return null; 
    } 

    @Override 
    public Collection<?> rootItemIds() { 
     return rootNodes; 
    } 

    @Override 
    public boolean isRoot(Object itemId) { 
     return rootNodes.contains(itemId); 
    } 

    @Override 
    public Item getItem(Object itemId) { 
     return new BeanItem<OutputNode>((OutputNode) itemId); 
    } 

    @Override 
    public boolean containsId(Object itemId) { 
     return hierarchy.containsKey(itemId); 
    } 

    @Override 
    public Collection<?> getItemIds() { 
     return hierarchy.keySet(); 
    } 

    @Override 
    public int size() { 
     return hierarchy.size(); 
    } 

    @Override 
    public boolean setParent(Object itemId, Object newParentId) throws UnsupportedOperationException { 
     throw new UnsupportedOperationException(); 
    } 

    @Override 
    public boolean setChildrenAllowed(Object itemId, boolean areChildrenAllowed) throws UnsupportedOperationException { 
     throw new UnsupportedOperationException(); 
    } 

    @Override 
    public Item addItem(Object itemId) throws UnsupportedOperationException { 
     throw new UnsupportedOperationException(); 
    } 

    @Override 
    public Object addItem() throws UnsupportedOperationException { 
     throw new UnsupportedOperationException(); 
    } 

    @Override 
    public boolean removeItem(Object itemId) throws UnsupportedOperationException { 
     throw new UnsupportedOperationException(); 
    } 

    @Override 
    public boolean removeAllItems() throws UnsupportedOperationException { 
     throw new UnsupportedOperationException(); 
    } 

    @Override 
    public Class<?> getType(Object propertyId) { 
     throw new UnsupportedOperationException(); 
    } 

    @Override 
    public Collection<?> getContainerPropertyIds() { 
     throw new UnsupportedOperationException(); 
    } 

    @Override 
    public Property<?> getContainerProperty(Object itemId, Object propertyId) { 
     throw new UnsupportedOperationException(); 
    } 

    @Override 
    public boolean addContainerProperty(Object propertyId, Class<?> type, Object defaultValue) throws UnsupportedOperationException { 
     throw new UnsupportedOperationException(); 
    } 

    @Override 
    public boolean removeContainerProperty(Object propertyId) throws UnsupportedOperationException { 
     throw new UnsupportedOperationException(); 
    } 

} 

Aggiunta del contenitore al Tree in questo modo:

OutputNodeHierachical dataSource = new OutputNodeHierachical(rootNodes); 

Tree mainTree = new Tree(); 
mainTree.setSizeFull(); 
mainTree.setContainerDataSource(dataSource); 
mainTree.addItemClickListener(new ItemClickListener() { 
    private static final long serialVersionUID = -413371711541672605L; 

    @Override 
    public void itemClick(ItemClickEvent event) { 
     OutputNode node = (OutputNode) event.getItemId(); 
     openObject(node.getObjectId()); 
    } 
});