RapidMiner的核心处理类是Process，其是Operator的集合，而ProcessRenderer是负责Process上的事件。

      com.rapidminer.Process是用观察者模式实现的，这里套用下《JAVA与模式》一书中对观察者模式的定义：观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

      下面来看下Process类的实现：

      Observable接口：  

package com.rapidminer.tools; import java.util.NoSuchElementException; /** 这个接口是Java观察者模式的重新实现，相比于jdk实现，该接口有如下改进: * 接口与实现分离 * 更新方法上添加了泛型参数支持 * 最重要一点: 更新方法可以被Event Dispatch Thread (EDT)调用. * 线程同步的 * 定义了异常处理方法 * */public interface Observable {    /** 添加一个observer，并且如果onEDT参数是true的话，会被通知到EDT，如果observer参数是null，则抛出NoSuchElementException异常     *  @throws a NPE if observer is null. */    public void addObserver(Observer observer, boolean onEDT);        /** 删除一个observer，如果这个observer没有注册过，则抛出NoSuchElementException异常     *  @throws    NoSuchElementException if observer is not registered with this Observable. */    public void removeObserver(Observer observer);    /** 与addObserver功能相同, 只是添加observer到列表最前端     */    void addObserverAsFirst(Observer observer, boolean onEDT);    }

     Observer接口（观察者）：

package com.rapidminer.tools;/** * @see Observable  * @author Simon Fischer * */public interface Observer {    public void update(Observable observable, A arg);    }

     AbstractObservable：是Observable接口的实现类

package com.rapidminer.tools;import java.util.LinkedList;import java.util.List;import java.util.NoSuchElementException;import javax.swing.SwingUtilities;/** * @author Simon Fischer */public class AbstractObservable implements Observable {    //普通的观察者    private final LinkedList
      > observersRegular = new LinkedList
      >();     //启用EDT的观察者    private final LinkedList
      > observersEDT  = new LinkedList
      >();     //锁对象，同步时候在此对象上加锁    private final Object lock = new Object();    @Override    public void addObserverAsFirst(Observer observer, boolean onEDT) {        if (observer == null) {            throw new NullPointerException("Observer is null.");        }        if (onEDT) {            synchronized (lock) {                observersEDT.addFirst(observer);            }        } else {            synchronized (lock) {                observersRegular.addFirst(observer);            }                    }    }    @Override    public void addObserver(Observer observer, boolean onEDT) {        if (observer == null) {            throw new NullPointerException("Observer is null.");        }        if (onEDT) {            synchronized (lock) {                observersEDT.add(observer);            }        } else {            synchronized (lock) {                observersRegular.add(observer);            }                    }    }    @Override    public void removeObserver(Observer observer) {        boolean success = false;        synchronized (lock) {            success |= observersRegular.remove(observer);            success |= observersEDT.remove(observer);        }        if (!success) {            throw new NoSuchElementException("No such observer: "+observer);        }    }    /** Updates the observers in the given list. */    private void fireUpdate(List
      > observerList, A argument) {                for (Observer observer : observerList) {            observer.update(this, argument);        }            }    /** Equivalent to fireUpdate(null). */    protected void fireUpdate() {        fireUpdate(null);    }    /** Updates all observers with the given argument. */    protected void fireUpdate(final A argument) {        // lists are copied in order to avoid ConcurrentModification occurs if updating         // an observer triggers insertion of another        List
      > copy;        synchronized (lock) {            copy = new LinkedList
      >(observersRegular);        }        fireUpdate(copy, argument);        if (!observersEDT.isEmpty()) {            final List
      > copyEDT;            synchronized (lock) {                copyEDT = new LinkedList
      >(observersEDT);                }            SwingUtilities.invokeLater(new Runnable() {                @Override                public void run() {                    fireUpdate(copyEDT, argument);                }            });        }        }}

     下面来看Process类：

     成员变量：

     

    MainFrame中的NEW_ACTION属性是负责响应创建新的process动作的，我们以此为入口，分析process类是如何工作的。

    通过前面action的分析我们已经知道，Action中的actionPerformed方法是用来响应事件的，NewAction类的方法很简单，就是调用MainFrame中的newProcess方法来创建一个process窗口

public void newProcess() {        //在创建新的process之前，询问是否要停止正在运行（暂停）的process        if (getProcessState() == Process.PROCESS_STATE_RUNNING || getProcessState() == Process.PROCESS_STATE_PAUSED) {            if (SwingTools.showConfirmDialog("close_running_process",                    ConfirmDialog.YES_NO_OPTION) == ConfirmDialog.NO_OPTION) {                return;            }        }         //关闭当前打开的process        if (close(false)) {            // undoindex标识置为0，undolist置空，undoaction和redoaction禁用            resetUndo();                        //停止当前运行的process（因为是以线程方式运行的，只有正在运行的operator完成之后，process线程才会退出）            stopProcess();            changed = false;             //创建新的process，设置并注册监听            setProcess(new Process(), true);            addToUndoList();            if (!"false".equals(ParameterService.getParameterValue(PROPERTY_RAPIDMINER_GUI_SAVE_ON_PROCESS_CREATION))) {                SaveAction.save(getProcess());            }            SAVE_ACTION.setEnabled(false);        }    }