首先是可复用设计的基石：开闭原则，即一个软件实体要对扩展开放，对修改关闭！这句话对于有一些面向对象编程经验的人应该不陌生！不管是什么软件系统，设计者总是希望在不用更改源代码的情况下可以扩展。

   第二个原则是：里氏代换原则，这个原则依然是我们众所周知的，其表述是如果一个软件实体使用一个基类的话，那么一定适用其子类，而且他根本察觉不出其基类对象和子类对象的区别。其实学习面向对象语言的人都知道，子类拥有基类的除其私有资源的一些特性！在java中，编译器通常会检查是否符合里氏代换原则！

  第三个原则是:依赖倒转或者叫依赖倒置原则，这个原则也许大家听说过，但是由他演变的另一个名词我想大家应该不陌生---IOC（依赖注入），对有人说IOC其实就是DIP。不过我认为ioc应该是一种技术，他是为了实现dip的，dip的表述就是：抽象不应该依赖于细节，细节应该依赖于抽象！或者是“应当依赖于接口编程，不应依赖于实现”。基本上要想实现开闭原则，dip应该是必须途径！至于ioc的设计理念，最近正在学习，我将在另一篇帖子中谈一下我对他的理解！

  第四个原则是：接口隔离原则，一个类对另外的一个类的依赖应当建立在最少的接口之上！这也许对于我们难以理解，那么我来换另一种表述：使用多个专门的接口比使用单一的接口要好！我们在编写程序中往往想将接口写的越少越好，于是乎，我们将多个功能的代码，放到同一个接口中！其实这是错误的，我们应当将不同功能分开设立专门的接口，这正是接口隔离原则

  其实，以上几个原则，在我们学习面向对象编程的过程中，都有接触。以上几个原则也是设计模式所遵循的原则！理解这些基本理论对于设计模式，或者说编程思想的学习是大有益处的！！！

    废话少说，在北京时，一位刚毕业的师兄，有一天问我:什么是CALLBACK！，说是面试时，有好多个公司都问了这个问题!当时我一时无语，只记着，在阅读thinking in java是看到过有关他的介绍，但具体也说不清楚了，于是赶紧翻书，上网查资料。发现虽然都说的比较全面，但是都不是好理解！后来我又阅读了c++中回调函数的概念，才对他有了一个模糊的认识！

  其实我们从字面意思来判断，就已经知道他大概的意思了，我从网上摘抄的定义是：软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。同步调用是一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用；回调是一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口(有待商榷)；异步调用是一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。回调和异步调用的关系非常紧密，通常我们使用回调来实现异步消息的注册，通过异步调用来实现消息的通知。是不是有点抽象，其实我们可以举个简单的例子：我写个程序（也可能是个类，或者是个组件）称为a，其中预留有回调函数接口，并封装好了该程序。另外一个人B要让a调用自己的程序b中的一个方法，于是，他通过我提供的接口回调自己b中的方法，目的达到。

  然后我们就可以写程序了，

Code
public class Caller {     
public MyCallInterface mc;     
public void setCallfuc(MyCallInterface mc) {       
 this.mc= mc;    
 }     
public void call(){this.mc.method();     
} 
}    
// 我还需要定义一个接口，以便程序员B根据我的定义编写程序实现接口
public interface MyCallInterface { 
public void method();

}     
//于是，程序员B只需要实现这个接口就能达到回调的目的了
 public class B implements MyCallInterface { 
public void method() { 
System.out.println("回调实现");     
}

 public static void main(String args[]){       
 Caller call = new Caller();        
call.setCallfuc(new B());       
 call.call();} 
}

 

OK，可以看到b实现了a回调他的方法！我们再来看个具体的例子，可能要复杂一点！有这样的一个问题：

老板（Boss）让工人（Worker）干完活告诉他干的情况如何。（来自网上的例子http://lavasoft.blog.51cto.com/62575/90453）

这是一个典型的回调问题，即工人要调用老板提供的接口，并且要老板调用学生的方法或属性，来了解工人的完成情况

代码如下：

Code
public interface Event { 
    /** 
     * 返回发生事件信息 
     * 
     * @return 事件信息 
     */ 
    public String happendEvent(); 
}

public class EventA implements Event { 
    /** 
     * 返回发生事件信息 
     * 
     * @return 事件信息 
     */ 
    public String happendEvent() { 
        return "发生了事件 EventA！"; 
    } 
}

public class EventB implements Event{ 
    /** 
     * 返回发生事件信息 
     * @return 事件信息 
     */ 
    public String happendEvent() { 
        return "发生了事件 EventB！"; 
    } 
}


public class Worker { 
    private Event event;    //事件 
    private String name;    //工人姓名 
    private Boss boss;      //工人所属的老板 

    public Worker(String name, Boss boss) { 
        this.name = name; 
        this.boss = boss; 
    } 

    /** 
     * 干活 
     */ 
    public void doWork() { 
        System.out.println(name + " is doing working"); 
        //工人挺辛苦，干着枯燥乏味的重复工作，哈哈 
        for (int i = 0; i < 2000000; i++) { 
            int x = i / 234 + 234; 
        } 
        System.out.println(name + " was finished work."); 
        //向老板说明发生的情况 
        boss.getWorkerEvent(this, event); 
    } 

    public Event getEvent() { 
        return event; 
    } 

    public void setEvent(Event event) { 
        this.event = event; 
    } 

    public String getName() { 
        return name; 
    } 

    public void setName(String name) { 
        this.name = name; 
    } 
}
 

public class Boss { 
    private String name; 

    public Boss(String name) { 
        this.name = name; 
    } 

    /** 
     * 老板接收工人的事件 
     * @param worker 工人 
     * @param event  事件 
     */ 
    public void getWorkerEvent(Worker worker, Event event) { 
        System.out.println("老板接收到事件信息： "+worker.getName() + ": " + event.happendEvent()); 
    } 
}
 

public class Test { 
    public static void main(String args[]){ 
        //初始化老板和工人 
        Boss boss = new Boss("老板"); 
        Worker worker1= new Worker("张三",boss); 
        Worker worker2= new Worker("李四",boss); 

        //捏造两个事件 
        Event event1 = new EventA(); 
        Event event2 = new EventB(); 

        //事件是工人发出的 
        worker1.setEvent(event1); 
        worker2.setEvent(event2); 

        //工人干活，干完了通知老板干的情况如何 
        worker1.doWork(); 
        worker2.doWork(); 

    } 
}

   我们可以看到在boss中，我们回调了工人的happendEvent方法，一般我们都用接口来实现回调！

     之前我们以一个小DEMO的形式介绍了GEF的model,Controller的实现,今天我们就来介绍gef中MVC的最后一个----view,即视图.由于我们这个DEMO是一个eclipse plug-in程序.所以他视图部分用的知识大部分是eclipse plug-in的相关知识(涉及的eclipse plug-in的相关知识我们将不作说明).

      通常我们用eclipse 的Editor作为主要视图,我们必须扩展org.eclipse.ui.editors这个扩展点，这个可以在plugin.xm 定义，定义后的文件如下：

Code
<point="org.eclipse.ui.editors">
              <editor
            class="hya.gef.demo.shapes.ui.ShapesEditor"
            default="true"
            extensions="Demo"
            icon="shapes.gif"
             contributorClass="hya.gef.demo.shapes.ui.ShapesEditorActionBarContributor"
            id="hya.gef.demo.shapes"
            name="GEF Demo"/>
            </extension>

其中，class属性指定我们编辑器对应的类；
           Extensions属性指定编辑器打开文件的扩展名为workflow；
           Default属性指出该编辑器是扩展名为workflow文件的默认打开方式；
           Icon为扩展名为workflow的文件和编辑器的图标；
           Id属性为编辑器的唯一标识
          Name为编辑器显示的名称

      然后我们定义编辑器的主界面类ShapesEditor,他继承GraphicalEditorWithFlyoutPalette，GraphicalEditorWithFlyoutPalette是带有面板的图形化编辑器.我们先来看看ShapesEditor的代码

Code
ackage hya.gef.demo.shapes.ui;

import hya.gef.demo.shapes.Activator;
import hya.gef.demo.shapes.models.DiagramModel;
import hya.gef.demo.shapes.models.RadioModel;
import hya.gef.demo.shapes.models.RectangularModel;
import hya.gef.demo.shapes.models.TriangleModel;
import hya.gef.demo.shapes.parts.ShapesEditPartFactory;
import hya.gef.demo.shapes.parts.tree.ShapesTreeEditPartFactory;

import java.util.EventObject;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.gef.ContextMenuProvider;
import org.eclipse.gef.DefaultEditDomain;
import org.eclipse.gef.EditPartViewer;
import org.eclipse.gef.GraphicalViewer;
import org.eclipse.gef.dnd.TemplateTransferDragSourceListener;
import org.eclipse.gef.dnd.TemplateTransferDropTargetListener;
import org.eclipse.gef.editparts.ScalableFreeformRootEditPart;
import org.eclipse.gef.palette.CombinedTemplateCreationEntry;
import org.eclipse.gef.palette.ConnectionCreationToolEntry;
import org.eclipse.gef.palette.MarqueeToolEntry;
import org.eclipse.gef.palette.PaletteContainer;
import org.eclipse.gef.palette.PaletteDrawer;
import org.eclipse.gef.palette.PaletteGroup;
import org.eclipse.gef.palette.PaletteRoot;
import org.eclipse.gef.palette.PaletteSeparator;
import org.eclipse.gef.palette.PanningSelectionToolEntry;
import org.eclipse.gef.palette.ToolEntry;
import org.eclipse.gef.requests.CreationFactory;
import org.eclipse.gef.requests.SimpleFactory;
import org.eclipse.gef.ui.actions.ActionRegistry;
import org.eclipse.gef.ui.palette.PaletteViewer;
import org.eclipse.gef.ui.palette.PaletteViewerProvider;
import org.eclipse.gef.ui.parts.ContentOutlinePage;
import org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette;
import org.eclipse.gef.ui.parts.TreeViewer;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.util.TransferDropTargetListener;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.part.IPageSite;
import org.eclipse.ui.views.contentoutline.IContentOutlinePage;

public class ShapesEditor extends GraphicalEditorWithFlyoutPalette {

    private static PaletteRoot PALETTE_MODEL;
    // 顶层模型类
    private DiagramModel diagram;

    public ShapesEditor() {
        setEditDomain(new DefaultEditDomain(this));

    }

    /**
     * @Override 创建创建调色板
     */
    protected PaletteRoot getPaletteRoot() {
        if (PALETTE_MODEL == null)
            PALETTE_MODEL = createPalette();
        return PALETTE_MODEL;
    }

    // 在编辑器的GraphicalViewer加监听
    protected void initializeGraphicalViewer() {

        super.initializeGraphicalViewer();
        GraphicalViewer viewer = getGraphicalViewer();
        viewer.setContents(getModel());
        // 增加监听，用于监听用户动作
        viewer.addDropTargetListener(createTransferDropTargetListener());

    }

    // 建立监听
    private TransferDropTargetListener createTransferDropTargetListener() {
        return new TemplateTransferDropTargetListener(getGraphicalViewer()) {
            protected CreationFactory getFactory(Object template) {
                return new SimpleFactory((Class) template);
            }
        };
    }

    // 给面板增加监听
    protected PaletteViewerProvider createPaletteViewerProvider() {
        return new PaletteViewerProvider(getEditDomain()) {
            protected void configurePaletteViewer(PaletteViewer viewer) {
                super.configurePaletteViewer(viewer);
                viewer.addDragSourceListener(new TemplateTransferDragSourceListener(
                                viewer));
            }
        };
    }

    public void commandStackChanged(EventObject event) {
        firePropertyChange(IEditorPart.PROP_DIRTY);
        super.commandStackChanged(event);
    }

    @Override
    public void doSave(IProgressMonitor arg0) {
        // TODO Auto-generated method stub

    }

    public DiagramModel getModel() {
        return diagram;
    }

    protected void configureGraphicalViewer() {

        super.configureGraphicalViewer();
        GraphicalViewer viewer = getGraphicalViewer();
        viewer.setEditPartFactory(new ShapesEditPartFactory());
        viewer.setRootEditPart(new ScalableFreeformRootEditPart());

        // 添加右键菜单
        ContextMenuProvider cmProvider = new EditorContextMenuProvider(viewer,
                getActionRegistry());
        viewer.setContextMenu(cmProvider);
        getSite().registerContextMenu(cmProvider, viewer);
    }

    protected void setInput(IEditorInput input) {
        super.setInput(input);
        diagram = new DiagramModel();
    }

    public Object getAdapter(Class type) {
        if (type == IContentOutlinePage.class)
            return new OutlinePage(new TreeViewer());
        return super.getAdapter(type);
    }

    /***************************************************************************
     * 提供建立调色板（及工具箱)的方法
     **************************************************************************/
    // 建立工具箱
    private PaletteRoot createPalette() {
        PaletteRoot palette = new PaletteRoot();
        palette.add(createToolsGroup(palette));
        palette.add(createShapesDrawer());
        return palette;
    }

    // 建立图形工具
    private PaletteContainer createShapesDrawer() {
        PaletteDrawer componentsDrawer = new PaletteDrawer("Shapes");

        CombinedTemplateCreationEntry component = new CombinedTemplateCreationEntry(
                "圆形", "Create an elliptical shape", RadioModel.class,
                new SimpleFactory(RadioModel.class), ImageDescriptor
                        .createFromFile(Activator.class, "icons/redio.gif"),
                ImageDescriptor.createFromFile(Activator.class,
                        "icons/redio2.gif"));
        componentsDrawer.add(component);

        component = new CombinedTemplateCreationEntry("矩形",
                "Create a rectangular shape", RectangularModel.class,
                new SimpleFactory(RectangularModel.class),
                ImageDescriptor.createFromFile(Activator.class,
                        "icons/rectangle.gif"), ImageDescriptor.createFromFile(
                        Activator.class, "icons/rectangle2.gif"));
        componentsDrawer.add(component);

        component = new CombinedTemplateCreationEntry("三角形",
                "Create a Triangle shape", TriangleModel.class,
                new SimpleFactory(TriangleModel.class), ImageDescriptor
                        .createFromFile(Activator.class, "icons/triangle.gif"),
                ImageDescriptor.createFromFile(Activator.class,
                        "icons/triangle.gif"));
        componentsDrawer.add(component);

        return componentsDrawer;
    }

    private static PaletteContainer createToolsGroup(PaletteRoot palette) {
        PaletteGroup toolGroup = new PaletteGroup("Tools");

        ToolEntry tool = new PanningSelectionToolEntry();
        toolGroup.add(tool);
        palette.setDefaultEntry(tool);

        toolGroup.add(new MarqueeToolEntry());

        toolGroup.add(new PaletteSeparator());

        tool = new ConnectionCreationToolEntry("连线", "连接两个图形", null,
                ImageDescriptor.createFromFile(Activator.class,
                        "icons/connection.gif"), ImageDescriptor
                        .createFromFile(Activator.class,
                                "icons/connection2.gif"));
        toolGroup.add(tool);
        return toolGroup;
    }

    /***************************************************************************
     * 建立大纲视图对应类，以内部类的形式
     **************************************************************************/
    public class OutlinePage extends ContentOutlinePage {
        /**
         * 为editor建立一个新的大纲 使用树结构显示大纲
         */
        public OutlinePage(EditPartViewer viewer) {
            super(viewer);
        }

        public void createControl(Composite parent) {
            // create outline viewer page
            getViewer().createControl(parent);
            // configure outline viewer
            getViewer().setEditDomain(getEditDomain());
            getViewer().setEditPartFactory(new ShapesTreeEditPartFactory());

            // 让大纲视图和编辑器的GraphicalViewer视图同步选择
            getSelectionSynchronizer().addViewer(getViewer());
            // 设置大纲视图的根内容为DiagramModel
            getViewer().setContents(getModel());
        }

        public void dispose() {
            // unhook outline viewer
            getSelectionSynchronizer().removeViewer(getViewer());
            // dispose
            super.dispose();
        }

        // 返回我们的outline成员变量，也就是指定让这个控件出现在大纲视图中
        public Control getControl() {
            return getViewer().getControl();
        }

        /**
         * 绑定UNDO/REDO/DELETE等命令到Eclipse主窗口 方法必须
         * 否则将否则当大纲视图处于活动状态时，主工具条上的这些命令就会变为不可用状态
         * 
         */
        public void init(IPageSite pageSite) {
            super.init(pageSite);
            ActionRegistry registry = getActionRegistry();
            IActionBars bars = pageSite.getActionBars();
            String id = ActionFactory.UNDO.getId();
            bars.setGlobalActionHandler(id, registry.getAction(id));
            id = ActionFactory.REDO.getId();
            bars.setGlobalActionHandler(id, registry.getAction(id));
            id = ActionFactory.DELETE.getId();
            bars.setGlobalActionHandler(id, registry.getAction(id));
        }

    }

}

在这个类getPaletteRoot()方法中，创建了面板。

在setInput方法中，定义了一个DiagramModel对象；

在构造函数中setEditDomain(new DefaultEditDomain(this));就是给当前编辑器设置一个默认编辑域，这个域跟命令堆栈有关。

initializeGraphicalViewer()方法，把GraphicalViewer的内容设计为DiagramModel，说明后编辑的是一个DiagramModel，并且添加了监听以监听用户的请求（用createTransferDropTargetListener方法建立监听）

在configureGraphicalViewer()，注册控制器工厂，并通过ContextMenuProvider来创建右肩菜单。

getAdapter(Class type)在此方法中创建大纲视图,大纲视图的相关创建我们以后再说明.

建立大纲和建立面板以后我们会做详细说明

这是视图界面截图:

有人往往会问：他创建了几个对象？我想答案是众所周知的2个。这个问题也从一个侧面说出了String的一些不同。

    我们接着说创建String对象的另-中方式：

String str="aaa"

显然，这种方式他创建了一个对象。这种方式是String特有的（确实我们在java中好像没有看到过也从来没有过其他对象这样的方式创建）。其实java中这样设置String，应该是让他和内置的基本类型定义时一致。

  然后我们再来看看这样一段代码：

String str1="hya";   
String str2="hya";  

他创建的对象还是一个，以前初学时我就感到疑惑。为什么会是一个呢？

   其实java里有一个字符串池的概念。确切地应该说是jvm中存在着一个字符串池，其中保存着很多String对象，并且可以被共享使用，因此它提高了效率。由于String类是final的，它的值一经创建就不可改变，因此我们不用担心String对象共享而带来程序的混乱。字符串池由String类维护，我们可以调用intern()方法来访问字符串池。 （来自javaeye的定义）

   当我们遇到String str1=“hya”的语句时，Java会先在字符串池中寻找是否已经存在"hya"这个字符串,如果没有，则建立字符串"hya"对象，然后变量 str1指向这个地址；然后遇到语句String str2=“hya”这时字符串池中已经有 "hya"了，所以直接让变量str2也指向这个地址。

    我们再来看看String str=new String("a");这个语句如何处理的呢？"a"是字符串池中的一个对象，然后new String（）是建立一个对象，并将句柄赋值给str，这与其他的对象建立没有什么不同。

  以让的知识介绍完后，我们再来看看这个问题（考试哦！）

String str=new String("a");
String s=new String("a");

他创建了几个对象？如果明白了上面的知识的话，这个答案是不容置疑的！！！

    然后我们再来看看，实际编程中遇到的==和equqls的区别，这里主要针对String而言的。

    看如下代码：

String a = "Hello";
String b = "Hello";
String c = new String("Hello");
String d = new String("Hello");
System.out.println(a == b);
System.out.println(b == c);
System.out.println(c == d);
System.out.println(a.equals(b));
System.out.println(b.equals(c));
System.out.println(c.equals(d));  

 

输出结果是

true
false
false
true
true
true

呵呵，看出什么了吗？首先我们来说明一下在java中==和equqls的区别：

    ==：对于基本类型来说是则是判断它们的值是否相等；对于两个对象则是判断它们的引用是否指向同一个对象；

    equqls：是一个方法，针对基本类型的外覆盖类和String而言它是判断值是否相等；而对于普通的对象，他们的缺省的实现和==并没有区别。

  所以对于上面的一段代码，不管他们是不是同一个对象，他们的值都是Hello，所以用equqls方法，返回的值都是true。

  由于java中String的用处十分的广，所以初于使用和性能上的考虑，对他作了一些特殊处理。最后我们再来说说String对象在JVM中的存储，以及字符串池与heap和stacK的关系。java中的数据主要存储在heap和stacK这两个数据结构中其中：栈（stack）：主要保存基本类型（或者叫内置类型）（char、byte、short、int、long、float、double、boolean）和对象的引用，数据可以共享，速度仅次于寄存器（register），快于堆。 堆（heap）：用于存储对象。

我们查看String类的源码就会发现，它有一个value属性，保存着String对象的值，类型是char[]，这也正说明了字符串就是字符的序列。
当执行String a="hya";时，JVM会在栈中创建三个char型的值'h'、'y'和'a'，然后在堆中创建一个String对象，它的值（value）是刚才在栈中创建的三个char型值组成的数组{'h','y','a'}，最后这个新创建的String对象会被添加到字符串池中。如果我们接着执行String b=new String("hya");代码，由于"hya"已经被创建并保存于字符串池中，因此JVM只会在堆中新创建一个String对象，但是它的值（value）是共享前一行代码执行时在栈中创建的三个char型值值'a'、'b'和'c'。 

  ps:以上属于个人理解，如有错误，还请指正！谢谢！  

一个eclipse plug-in程序，要有一个编辑区（editor），一个大纲（outline）.编辑区有画板，画板里有三角，矩形，圆形，连接线。用户可以通过拖拽的方式把图形拽到编辑区。编辑区图形能够实现删除，同时拥有uodo/redo。

看似简单的要求....
 好了那我们首先就开始吧,对了还是先介绍一下GEF这个架构吧
 

GEF（Graphical Editor Framework）是一个图形化编辑框架，它允许开发人员以图形化的方式展示和编辑模型，从而提升用户体验。这样的应用程序有很多，例如：UML类图编辑器、图形化XML编辑器、界面设计工具以及图形化数据库结构设计工具等等.这是引用八进制老兄的话.对了貌似struts那个编辑器,就是能拖能拽的那个,就是用的这个框架.

  他采用MVC框架模式实现，模型对应业务逻辑，实现相应的接口，并添加事件监听器，实现对模型改变事件的监听。控制器由GEF提供的EditPart实现，安装编辑策略，监听模型的变化，处理模型变化请求，执行相应的Command命令完成相应的操作，绘制图形。视图部分由Eclipse提供的Draw2d实现，绘制相应的图形。我们也从这三个方面来说明程序的设计实现.
    什么是Draw2d,我们只说GEF,Draw2d的相关知识,还是去找google,百度吧.当然了同时我们还要有Eclipse插件开发的相关知识.就这两样我还是看了将近一天呢.
   现在我们在具体说一下GEF的大致工作原理:一下内容引自(八进制老兄的博客)

图2 GEF结构图

模型：GEF的模型只与控制器打交道，而不知道任何与视图有关的东西。为了能让控制器知道模型的变化，应该把控制器作为事件监听者注册在模型中，当模型发生变化时，就触发相应的事件给控制器，后者负责通知各个视图进行更新。

典型的模型对象会包含PropertyChangeSupport类型的成员变量，用来维护监听器成员即控制器；对于与其他对象具有连接关系的模型，要维护连入/连出的连接列表；如果模型对应的节点具有大小和位置信息，还要维护它们。这些变量并不是模型本身必须的信息，维护它们使模型变得不够清晰，但你可以通过构造一些抽象模型类（例如让所有具有连接的模型对象继承Node类）来维持它们的可读性。

相对来讲GEF中模型是MVC中最简单的一部分。

控制器：我们知道，在MVC结构里控制器是模型与视图之间的桥梁，也是整个GEF的核心。它不仅要监听模型的变化，当用户编辑视图时，还要把编辑结果反映到模型上。举个例子来说，用户在数据库结构图上删除一个表时，控制器应该从模型中删除这个表对象、表中的字段对象、以及与这些对象有关的所有连接。当然在GEF中这些操作不是由直接控制器完成的，这个稍后就会说到。

GEF中的控制器是所谓的EditPart对象，更确切的说应该是一组EditPart对象共同组成了GEF的控制器这部分，每一个模型对象都对应一个EditPart对象。你的应用程序中需要有一个EditPartFactory对象负责根据给定模型对象创建对应的EditPart对象，这个工厂类将被视图利用。

RootEditPart是一种特殊的EditPart，它和你的模型没有任何关系，它的作用是把EditPartViewer和contents（应用程序的最上层EditPart，一般代表一块画布）联系起来，可以把它想成是contents的容器。EditPartViewer有一个方法setRootEditPart()专门用来指定视图对应的RooEditPart。

图3 EditPart对象

用户的编辑操作被转换为一系列请求（Request），有很多种类的请求，这些种类在GEF里被称为角色（Role），GEF里有图形化和非图形化这两大类角色，前者比如Layout Role对应和布局有关的的操作，后者比如Connection Role对应和连接有关的操作等等。角色这个概念是通过编辑策略（EditPolicy）来实现的，EditPolicy的主要功能是根据请求创建相应的命令（Command），而后者会直接操作模型对象。对每一个EditPart，你都可以"安装"一些EditPolicy，用户对这个EditPart的特定操作会被交给已安装的对应EditPolicy处理。这样做的直接好处是可以在不同EditPart之间共享一些重复操作。

在GEF SDK提供的帮助文档（GEF开发指南）里有一份详细的EditPolicy、Role和Request类型列表，这里就不赘述了。

视图：前面说过，GEF的视图可以有很多种，GEF目前提供了图形（GraphicalViewer）和树状（TreeViewer）这两种，前者利用Draw2D图形（IFigure）作为表现方式，多用于编辑区域，后者则多用于实现大纲展示。视图的任务同样繁重，除了模型的显示功能以外，还要提供编辑功能、回显（Feedback）、工具提示（ToolTip）等等。

GEF使用EditPartViewer作为视图，它的作用和JFace中的Viewer十分类似，而EditPart就相当于是它的ContentProvider和LabelProvider，通过setContents()方法来指定。我们经常使用的Editor是一个GraphicalEditorWithPalette（GEF提供的Editor，是EditorPart的子类，具有图形化编辑区域和一个工具条），这个Editor使用GraphicalEditViewer和PaletteViewer这两个视图类，PaletteViewer也是GraphicalEditViewer的子类。开发人员要在configureGraphicalViewer()和initializeGraphicalViewer()这两个方法里对EditPartViewer进行定制，包括指定它的contents和EditPartFactory等等。

EditPartViewer同时也是ISelectionProvider，这样当用户在编辑区域做选择操作时，注册的SelectionChangeListener就可以收到选择事件。EditPartViewer会维护各个EditPart的选中状态，如果没有被选中的EditPart，则缺省选中的是作为contents的EditPart。

初步了解了GEF的MVC实现方式，让我们看看典型的GEF应用程序是什么样子的。大部分GEF应用程序都实现为Eclipse的Editor，也就是说整个编辑区域是放置在一个Editor里的。所以典型的GEF应用程序具有一个图形编辑区域包含在一个Editor（例如GraphicalEditorWithPalette）里，可能有一个大纲视图和一个属性页，一个用于创建EditPart实例的EditPartFactory，一些表示业务的模型对象，与模型对象对应的一些EditPart，每个EditPart对应一个IFigure的子类对象显示给用户，一些EditPolicy对象，以及一些Command对象。

GEF应用程序的工作方式如下： EditPartViewer接受用户的操作，例如节点的选择、新增或删除等等，每个节点都对应一个EditPart对象，这个对象有一组按操作Role分开的EditPolicy，每个EditPolicy会对应一些Command对象，Command最终对模型进行直接修改。用户的操作转换为Request分配给适当的EditPolicy，由后者创建适当的Command来修改模型，这些Command会保留在EditDomain（专门用于维护EditPartViewer、Command等信息的对象，一般每个Editor对应唯一一个该对象）的命令堆栈里，用于实现撤消/重做功能。

引用完毕.

了解了其基本原理后我们就可以开始开发了(呵呵,省去n多小示例的开发)....

ps:我会把这一周的收获一一写来.呵呵....