插件开发：我们应该在什么时候收集扩展点？

在插件开发中，为了利用插件的扩展性，我们通常会自定义一些扩展点(相当于定义一个标准，一个接口)。
而将实现，放在其它插件中去实现。既然定义了扩展点，那么我们就应该去收集它以使用。
不要在start方法中去收集扩展点，我们应该尽量保证我们的插件懒加载(lazy)。
而是应该在使用的时候收集扩展点，什么时候使用，什么时候去加载。

eg:
package net.chenxs.common.navigator.loader;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.Platform;

import net.chenxs.common.navigator.CommonNavigatorActivator;
import net.chenxs.common.navigator.extensions.IViewerSort;

/*
 *
 */
public class ViewerSorterProviderLoader {

 private static ViewerSorterProviderLoader INSTANCE = null;
 private static Object obj = new Object();
 private static String ID = CommonNavigatorActivator.PLUGIN_ID
   + ".viewerSorter";
 private static String CLASS = "class";
 private List<IViewerSort> sorterProviders;

 private ViewerSorterProviderLoader() {
  sorterProviders = loadMenuProviders();
 }

 public static ViewerSorterProviderLoader getInstance() {
  synchronized (obj) {
   if (INSTANCE == null) {
    INSTANCE = new ViewerSorterProviderLoader();
   }
  }
  return INSTANCE;
 }

 private List<IViewerSort> loadMenuProviders() {
  IConfigurationElement[] elements = Platform.getExtensionRegistry()
    .getConfigurationElementsFor(ID);
  List<IViewerSort> listeners = new ArrayList<IViewerSort>(
    elements.length);
  for (IConfigurationElement ice : elements) {
   try {
    Object menuClass = ice.createExecutableExtension(CLASS);
    listeners.add((IViewerSort) menuClass);
   } catch (CoreException e) {
    e.printStackTrace();
    continue;
   }
  }
  return listeners;
 }

 public List<IViewerSort> getProviders() {
  return sorterProviders;
 }
}

使用的时候：

/*
 *  导航视图过滤器
 */
public class CommonTreeSorter extends ViewerSorter {

 private List<IViewerSort> providers;

 public CommonTreeSorter(){
  providers = ViewerSorterProviderLoader.getInstance().getProviders();//收集过滤器扩展
               //这样，收集到的扩展点对应的实例我们就可以提供给外部使用了
 }
 
 public int category(Object element) {
  if(element instanceof CategoryModel){
   return 0;
  }
  for(IViewerSort sort:providers){
   if(sort.isAcceptable(element)){
    return sort.category(element);
   }
  }
  return super.category(element);
 }

 public int compare(Viewer viewer, Object e1, Object e2) {
  for(IViewerSort sort:providers){
   if(sort.isAcceptable(e1)){
    return sort.compare(viewer,e1,e2);
   }
  }
  return super.compare(viewer, e1, e2);
 }
 
}