वाडिन - आलसी क्वेरी कंटेनर

Question

मैं वाडिन 7 में अपना प्रोजेक्ट कर रहा हूं। मुझे एक ट्रिटेबल के लिए एक आलसी क्वेरी कंटेनर लागू करने की आवश्यकता है। मुझे वेब सेवा से ट्रिटेबल के लिए डेटा मिलेगा।

क्या कोई व्यक्ति कृपया दिखा सकता है कि मेरे डेटा स्रोत के रूप में एक वेब सेवा के साथ आलसी क्वेरी कंटेनर का उपयोग कैसे करें?

कृपया मुझे इसे लागू करने के लिए आवश्यक चरणों को बताएं या मुझे शुरू करने के लिए नमूना कोड दिखाएं।

Answer 1

यहाँ LQC के लिए अच्छा प्रलेखन है: https://vaadin.com/wiki/-/wiki/Main/Lazy%20Query%20Container

दस्तावेज में उदाहरण javax.persistence एपीआई का उपयोग कर MovieQuery कार्यान्वित कर रहे हैं, लेकिन यह आसान MockQuery example आधार के रूप में इस्तेमाल करते हैं और वेब सेवा के साथ प्राप्त करने में कठिनाई वास्तविक डेटा को बदलने के लिए आसान हो सकता है कहता है।

Answer 2

निम्नलिखित आलसी लोडिंगHierarchical इंटरफ़ेस पर एक नज़र डालें।
सभी डेटा एक webservice IViewService से पढ़ा जाता है।
उदाहरण Tree घटक का उपयोग करता है लेकिन यह TreeTable के लिए भी काम करता है।

यह (HashMaphierarchy में मेरे मामले में) एक स्थानीय संरचना में सभी तत्वों को स्टोर करने के लिए तत्वों को कई बार यह काम नहीं करता नहीं पढ़ते बहुत महत्वपूर्ण है। मुझे लगता है क्योंकि वाडिन equals() और 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(); 
    } 

} 

Tree इस तरह के कंटेनर जोड़ना:

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()); 
    } 
});