RCP_TreeViewer的ContentProvider详解，以及Lazy载入

 为了实现这样的效果：
    载入的过程中，显示Pending。


    载入完毕，Pending消失。

   

我们先从基础的说起，先来看ITreeContentProvider 接口：

Java代码

1. public   interface  ITreeContentProvider {  
2.     public  Object[] getElements(Object inputElement) ;  
3.     public  Object[] getChildren(Object parentElement) ;  
4.     public   boolean  hasChildren(Object element) ;  
5.     // ...   
6. }  

public interface ITreeContentProvider {
	public Object[] getElements(Object inputElement) ;
	public Object[] getChildren(Object parentElement) ;
	public boolean hasChildren(Object element) ;
	// ...
}

    getElements 表示在setInput(Object)的时候，如何从Object中得到一个数组，而使用这个数组去将树的第一层结点显示出来。这个方法只在setInput时才使用一次。
    getChildren表示在每次展开树的节点时，如果得到下一级节点的值，当然，树的节点展开了一次就不会再调用这个方法了，因为在树节点对应的控件TreeItem中，已经创建好了子节点控件了。
    hasChildren就是判断当前节点是否有子节点，有的话，就显示+号。

ITreeContentProvider的使用类型可以分成3种（我自己分的，^-^）。
1。简单模式
2。Lazy Loader模式（简单）
3。Lazy Loader模式（显示Pending）


一． 简单模式
其实就是在setInput的模型中，已经预先将所有的子模型都载入完毕，而不用再动态的载入子模型了。
模型说明：
    这个模型代表树节点，是支持父子结构的。当然，在Jface里面是有一个TreeNode 的，org.eclipse.jface.viewers.TreeNode，相应的还提供了一个 org.eclipse.jface.viewers.TreeNodeContentProvider。

Java代码

1. public   class  TreeNode {  
2.     private  TreeNode parent;  
3.     private  List<TreeNode> children =  new  ArrayList<TreeNode>();  
4.     private  Object value;  

public class TreeNode {
	private TreeNode parent;
	private List<TreeNode> children = new ArrayList<TreeNode>();
	private Object value;

ContentProvider代码：

Java代码

1. public   class  SimpleContentProvider  implements  ITreeContentProvider {  
2. public  Object[] getElements(Object inputElement) {  
3.     return  ((TreeNode) inputElement).getChildren().toArray();  
4. }  
5. public  Object[] getChildren(Object parentElement) {  
6.     return  ((TreeNode) parentElement).getChildren().toArray();  
7. }  
8. public   boolean  hasChildren(Object element) {  
9.     return  ((TreeNode) element).getChildren().size() >  0 ;  
10. }  

	public class SimpleContentProvider implements ITreeContentProvider {
	public Object[] getElements(Object inputElement) {
		return ((TreeNode) inputElement).getChildren().toArray();
	}
	public Object[] getChildren(Object parentElement) {
		return ((TreeNode) parentElement).getChildren().toArray();
	}
	public boolean hasChildren(Object element) {
		return ((TreeNode) element).getChildren().size() > 0;
	}

构建setInput的模型
就是在构建模型的时候，将所有的子模型都加载好了：

Java代码

1. private  TreeNode buildLazyContent() {  
2.     TreeNode root = new  TreeNode( null );  
3.     TreeNode level_1_1 = new  TreeNode( "1.1" );  
4.     root.addChild(level_1_1);  
5.     // ...   
6.     return  root;  
7. }  

	private TreeNode buildLazyContent() {
		TreeNode root = new TreeNode(null);
		TreeNode level_1_1 = new TreeNode("1.1");
		root.addChild(level_1_1);
		// ...
		return root;
	}

其他代码：

Java代码

1. viewer.setLabelProvider( new  TreeViewerLabelProvider());  
2. viewer.setContentProvider(new  SimpleContentProvider());  
3. viewer.setInput(this .buildSimpleContent());  

		viewer.setLabelProvider(new TreeViewerLabelProvider());
		viewer.setContentProvider(new SimpleContentProvider());
		viewer.setInput(this.buildSimpleContent());

二． Lazy Load模式（简单）
在setInput的模型中，只有最顶层的模型，再每次点击+的时间，将下一层的模型动态的载入，从而将树的子节点构造出来。也就是在getChildren中动态载入即可。

ContentProvider代码。
    注意getChildren 和hasChildren的方法实现，hasChildren返回true，表示需要给这个树节点显示+号。点击+号，getChildren会动态的载入子节点数据，这样就实现了Lazy Load了。

Java代码

1. public   class  SimpleLazyContentProvider  implements  ITreeContentProvider {  
2.     public  Object[] getChildren(Object parentElement) {  
3.         TreeNode parent = (TreeNode) parentElement;  
4.         this .loadChildren(parent);   
5.         return  parent.getChildren().toArray();  
6.     }  
7.     public   boolean  hasChildren(Object element) {  
8.         return   true ;   
9.     }  
10.     private   void  loadChildren(TreeNode parent) {  
11.         TreeNode child_1 = new  TreeNode( "1" );  
12.         parent.addChild(child_1);  
13.           
14.         TreeNode child_2 = new  TreeNode( "2" );  
15.         parent.addChild(child_2);  
16.     }  

public class SimpleLazyContentProvider implements ITreeContentProvider {
	public Object[] getChildren(Object parentElement) {
		TreeNode parent = (TreeNode) parentElement;
		this.loadChildren(parent); 
		return parent.getChildren().toArray();
	}
	public boolean hasChildren(Object element) {
		return true; 
	}
	private void loadChildren(TreeNode parent) {
		TreeNode child_1 = new TreeNode("1");
		parent.addChild(child_1);
		
		TreeNode child_2 = new TreeNode("2");
		parent.addChild(child_2);
	}

构建setInput的模型：
    只需要构建第一层树节点即可，后面的就交给ContentProvider去处理。

Java代码

1. private  TreeNode buildSimpleLazyContent() {  
2.     TreeNode root = new  TreeNode( null );  
3.     TreeNode level_1_1 = new  TreeNode( "1.1" );  
4.     root.addChild(level_1_1);  
5.     return  root;  
6. }  

	private TreeNode buildSimpleLazyContent() {
		TreeNode root = new TreeNode(null);
		TreeNode level_1_1 = new TreeNode("1.1");
		root.addChild(level_1_1);
		return root;
	}

其他代码：

Java代码

1. viewer.setLabelProvider( new  TreeViewerLabelProvider());  
2. viewer.setContentProvider(new  SimpleLazyContentProvider());  
3. viewer.setInput(this .buildSimpleLazyContent());  

		viewer.setLabelProvider(new TreeViewerLabelProvider());
		viewer.setContentProvider(new SimpleLazyContentProvider());
		viewer.setInput(this.buildSimpleLazyContent());

三． Lazy Loader模式（显示Pending）
   和模式是二一样的，都是点+载入子模型。但是，如果是需要长时间的加载，模式二会将界面卡住，而这个模式，再点击+号后，会先显示一个Pending树节 点（并可以显示进度条），并看到随着数据一个一个载入树节点一个一个添加出来，所有数据都载入后，Pending树节点消失，这样用户体验就会好很多。在 这个模式，需要用到很多其他的类，具体看代码：

模型代码：
1. 需要实现IDeferredWorkbenchAdapter接口。
2. 注意fetchDeferredChildren方法。将载入子数据的过程放到了模型里面（很怪）。

Java代码

1. public   class  PendingTreeNode  extends  TreeNode  implements  IDeferredWorkbenchAdapter {  
2.     public   void  fetchDeferredChildren(Object object, IElementCollector collector,  
3.             IProgressMonitor monitor) {  
4.         PendingTreeNode parent = (PendingTreeNode) object;  
5.           
6.         try  {  
7.             Thread.sleep(500 );  
8.         } catch  (InterruptedException e) {  
9.             e.printStackTrace();  
10.         }  
11.         PendingTreeNode node1 = new  PendingTreeNode( "1" );  
12.         parent.addChild(node1);  
13.         collector.add(node1, monitor);  
14.           
15.         try  {  
16.             Thread.sleep(500 );  
17.         } catch  (InterruptedException e) {  
18.             e.printStackTrace();  
19.         }  
20.         PendingTreeNode node2 = new  PendingTreeNode( "2" );  
21.         parent.addChild(node2);  
22.         collector.add(node2, monitor);  
23.     }  

public class PendingTreeNode extends TreeNode implements IDeferredWorkbenchAdapter {
	public void fetchDeferredChildren(Object object, IElementCollector collector,
			IProgressMonitor monitor) {
		PendingTreeNode parent = (PendingTreeNode) object;
		
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		PendingTreeNode node1 = new PendingTreeNode("1");
		parent.addChild(node1);
		collector.add(node1, monitor);
		
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		PendingTreeNode node2 = new PendingTreeNode("2");
		parent.addChild(node2);
		collector.add(node2, monitor);
	}

ContentProvider代码。
1. 添加了一个DeferredTreeContentManager，并使用该manager代理getChildren方法。
2. hasChildren返回true。
3. 修改了getElements方法。

Java代码

1. public   class  PendingLazyContentProvider  implements  ITreeContentProvider {  
2.     private  DeferredTreeContentManager manager;  
3.       
4.     public  Object[] getChildren(Object parentElement) {  
5.         return  manager.getChildren(parentElement);  
6.     }  
7.     public   boolean  hasChildren(Object element) {  
8.         return   true ;  
9.     }  
10.     public  Object[] getElements(Object inputElement) {  
11.         if  (inputElement  instanceof  PendingTreeNode) {  
12.             return  ((PendingTreeNode) inputElement).getChildren().toArray();              
13.         }   
14.         return   new  Object[ 0 ];  
15.     }  
16.     public   void  inputChanged(Viewer viewer, Object oldInput, Object newInput) {  
17.         if  (manager ==  null ) {  
18.             manager = new  DeferredTreeContentManager( this , (TreeViewer) viewer);  
19.         }  
20.     }  
21. }  

public class PendingLazyContentProvider implements ITreeContentProvider {
	private DeferredTreeContentManager manager;
	
	public Object[] getChildren(Object parentElement) {
		return manager.getChildren(parentElement);
	}
	public boolean hasChildren(Object element) {
		return true;
	}
	public Object[] getElements(Object inputElement) {
		if (inputElement instanceof PendingTreeNode) {
			return ((PendingTreeNode) inputElement).getChildren().toArray();			
		} 
		return new Object[0];
	}
	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
		if (manager == null) {
			manager = new DeferredTreeContentManager(this, (TreeViewer) viewer);
		}
	}
}

LabelProvider代码：
1. 修改了getText方法。由于我们说中间会创建一个显示Pending的节点，这个节点就是PendingUpdateAdapter，需要特别指定显示的text。

Java代码

1. public   class  PendingTreeViewerLabelProvider  extends  LabelProvider {  
2.     public  String getText(Object obj) {  
3.         if  (obj  instanceof  TreeNode) {  
4.             return  ((TreeNode) obj).getValue().toString();  
5.         } else   if  (obj  instanceof  PendingUpdateAdapter) {  
6.             return  ((PendingUpdateAdapter) obj).getLabel( null );   
7.         }  
8.         return  obj.toString();  
9.     }  

public class PendingTreeViewerLabelProvider extends LabelProvider {
	public String getText(Object obj) {
		if (obj instanceof TreeNode) {
			return ((TreeNode) obj).getValue().toString();
		} else if (obj instanceof PendingUpdateAdapter) {
			return ((PendingUpdateAdapter) obj).getLabel(null); 
		}
		return obj.toString();
	}

构建setInput的模型：
1. 只需要预先放入根节点即可。子节点的载入就依赖于点击+号，lazy载入了。

Java代码

1. private  PendingTreeNode buildPendingLazyContent() {  
2.     PendingTreeNode root = new  PendingTreeNode( null );  
3.   
4.     PendingTreeNode level_1_1 = new  PendingTreeNode( "1.1" );  
5.     root.addChild(level_1_1);  
6.     return  root;  
7. }  

	private PendingTreeNode buildPendingLazyContent() {
		PendingTreeNode root = new PendingTreeNode(null);

		PendingTreeNode level_1_1 = new PendingTreeNode("1.1");
		root.addChild(level_1_1);
		return root;
	}

其他代码：

Java代码

1. viewer.setLabelProvider( new  PendingTreeViewerLabelProvider());  
2. viewer.setContentProvider(new  PendingLazyContentProvider());  
3. viewer.setInput(this .buildPendingLazyContent());  

		viewer.setLabelProvider(new PendingTreeViewerLabelProvider());
		viewer.setContentProvider(new PendingLazyContentProvider());
		viewer.setInput(this.buildPendingLazyContent());

四． 总结
1. 简单模式适合于你一次性将数据全部载入，而后在setInput一次显示出来。
2. Lazy Load模式（简单）适合于性能影响不大的点击+号Lazy的载入数据。
3. Lazy Load模式（显示Pending）适合于载入过程比较长，为了提供用户交互而使用
4. Lazy Load模式都存在着遍历的问题。因为有的模型的子节点还没有完全载入，而你却依赖所有这些子节点的时候，这时就必须在代码里面将所有子节点打开，让其载入所有子数据至最后一层，对于（简单）和（显示Pending）都可以这么去做。
5. 还是4的情况，由于（显示Pending）是异步载入的，需要更复杂的判断，并基于线程去判断某节点是否载入完毕，等你自己去实现的时候，你会发现这是有多复杂的^-^


五． 其他相关的类
org.eclipse.jface.viewers.TreeNode
org.eclipse.jface.viewers.TreeNodeContentProvider
org.eclipse.jface.viewers.ArrayContentProvider
org.eclipse.ui.progress.IDeferredWorkbenchAdapter
org.eclipse.ui.progress.DeferredTreeContentManager