Clyde学习笔记一（Scope）
Scope相关的接口、类都定义在expr这个包中，官方的说明很简单，只有一句话：expr?- expression evaluation and symbol binding，但scope这个概念却很重要，可以说是整个clyde框架的核心基石之一。那么它到底是个什么概念，又起到了什么作用呢？首先它是一个接口，在这个接口中，最重要的就是下面这个方法：
?
public <T> T get (String name, Class<T> clazz);?
?
再看它的注释：
?
Looks up a symbol in this scope，return the mapping for the requested symbol。
?
在这里，symbol指的就是参数name，这个方法的作用就是找到name这个symbol所对应的值，并且这个值的类型是T。
?
接下来我们再来看下这个方法的实现。scope有两个默认的实现类，分别是SimpleScope和DynamicScope。
?
在SimpleScope中的实现：
?
?
public <T> T get (String name, Class<T> clazz) { return ScopeUtil.get(this, name, clazz); }?那么具体的逻辑是写在了ScopeUtil中，在ScopeUtil.get方法中，有关键的这句：
?
?
Member member = getScoped(object.getClass()).get(name);?
这句话的意思是在object这个类中所有用scoped annotation标注过的属性或方法中找到与name对应的那个。
相关代码如下：
?
?
HashMap<String, Member> members = new HashMap<String, Member>(); Class<?> sclazz = clazz.getSuperclass(); if (sclazz != null) { members.putAll(getScoped(sclazz)); } // add all scoped fields (stripping off the leading underscore, if present) for (Field field : clazz.getDeclaredFields()) { if (field.isAnnotationPresent(Scoped.class)) { field.setAccessible(true); members.put(stripUnderscore(field.getName()), field); } } // add all scoped methods for (Method method : clazz.getDeclaredMethods()) { if (method.isAnnotationPresent(Scoped.class)) { method.setAccessible(true); members.put(method.getName(), method); } }?可以看到每个类都有一个对应的map，这个map中保存了所用用scoped标注过的属性和方法，并且以属性和方法名作为map的key，这个key就是我们前面所说的symbol，即那个name参数。在这里的整个方法还递归的包括了这个类所有的超类，但是要主要到这里的scoped是个annotation，和我们前面提到的scope接口不是同一回事。每个类对应的map还保存在一个全局的map中作为cache，这样就不用每次都反射查找一遍。
?
?
/** Cached scoped members. */ protected static HashMap<Class<?>, HashMap<String, Member>> _scoped = Maps.newHashMap();?
找到对应的属性或方法之后，ScopeUtil的get方法就返回属性的值或者执行方法的结果，在这里相关代码就不展开了。现在回过头来重新审视一下scopeUtil的get方法，那就是：
?
找到在object这个类中所有用scoped annotation标注过的属性或方法中查找属性或方法名为name的那个，并返回属性的值或方法执行的结果，返回类型为T。在simpleScope中，这个object就是它自身。
?
再来看一下dynamicScope的实现：
?
?
public <T> T get (String name, Class<T> clazz) { // first try the dynamic symbols, then the reflective ones Object value = (_symbols == null) ? null : _symbols.get(name); return clazz.isInstance(value) ? clazz.cast(value) : ScopeUtil.get(_owner, name, clazz); }?可以看到，在dynamicScope中，这个object不再是它自己，而是_owner。看一下owner的定义：
?
?
/** The owner of this scope. */ protected Object _owner;
?这也是SimpleScope和DynamicScope最重要的一个区别。
?
现在我们已经初步了解了scope的概念，那么这个scope有什么具体的作用呢？
在scope接口中还有两个方法，addListener，removeListener。
?
?
/** * Adds a listener for changes in scope. The listener will be notified when symbols are * added or removed and whenever the scope hierarchy changes. */ public void addListener (ScopeUpdateListener listener); /** * Removes a listener for changes in scope. */ public void removeListener (ScopeUpdateListener listener);?
?
再来看一下ScopeUpdateListener这个接口，这个接口SimpleScope和DynamicScope都默认实现了，也就是说SimpleScope和DynamicScope都可以作为监听器监听其他的scope，一旦它监听的scope被改变，scopeUpdated方法都会被调用。
?
?
/** * Used to notify objects when the scope has been updated. */public interface ScopeUpdateListener{ /** * Called when the scope has been updated. */ public void scopeUpdated (ScopeEvent event);}?
下面是SimpleScope的scopeUpdate方法的实现。
?
?
public void scopeUpdated (ScopeEvent event) { ScopeUtil.updateBound(this, _parentScope); }再看一下ScopeUtil的updateBound方法：
?
?
/** * Updates the {@link Bound} fields of the specified object using the provided scope. */ public static void updateBound (Object object, Scope scope) { for (Field field : getBound(object.getClass())) { String name = field.getAnnotation(Bound.class).value(); if (name.length() == 0) { name = stripUnderscore(field.getName()); } @SuppressWarnings("unchecked") Class<Object> type = (Class<Object>)field.getType(); try { field.set(object, resolve(scope, name, field.get(object), type)); } catch (IllegalAccessException e) { log.warning("Error accessing bound field.", "field", field, e); } } }?这里也是用的反射找到object类中用Bound annotation标注的属性，并且找到这个属性所bound（绑定）的symbol，resolve出这个symbol的值并赋值给这个属性。
?
再看一下ScopeUtil中resolve方法的实现。
?
?
/** * Attempts to resolve the identified symbol in the given scope. If not found there, * searches the parent of that scope, and so on. * * @return the mapping for the symbol, or <code>defvalue</code> if not found anywhere in the * chain. */ public static <T> T resolve (Scope scope, String name, T defvalue, Class<T> clazz) { // if the name includes a scope qualifier, look for that scope int idx = name.indexOf(':'); if (idx != -1) { String qualifier = name.substring(0, idx); name = name.substring(idx + 1); while (scope != null && !qualifier.equals(scope.getScopeName())) { scope = scope.getParentScope(); } } // rise up through the scopes looking for the requested symbol for (; scope != null; scope = scope.getParentScope()) { T value = scope.get(name, clazz); if (value != null) { return value; } } // no luck; return the default value return defvalue; }?这个方法就是在给定的scope中找到symbol所对应的值，在当前scope中找不到可以递归的在当前scope的parentScope中继续寻找，并且symbol还可以用“：”分隔符指定一个特定的scope。在上面的代码中我们看到了熟悉一句：
?
?
T value = scope.get(name, clazz);?
怎么样，到这里整个拼图中的两块已经连在了一起，并且已经隐约看到了整个scope框架它所需要表达的一个意思，那就是：
?
当一个scope有update时，所有监听该scope的其他scope所拥有的object中，任何绑定到该scope中symbol的属性值都会随着该symbol的值变化而变化。这也正是官方介绍中的symbol binding的概念所在。应该说这个表述非常的抽象，但它却是整个clyde框架的基石，框架中的其他部分有非常多的依赖于这个抽象的概念。回过头来我们再一次看到，在SimpleScope中，object还是它自身，而DynamicScope的object仍然还是它的owner。
?
?
public void scopeUpdated (ScopeEvent event) { ScopeUtil.updateBound(_owner, _parentScope); wasUpdated(); }?每个scope默认的监听对象都是该scope的parentScope。SimpleScope中的构造函数：
?
?
/** * Creates a new simple scope. */ public SimpleScope (Scope parentScope) { if ((_parentScope = parentScope) != null) { _parentScope.addListener(this); } ...... }?
DynamicScope也是如此。
?
下面写一段测试代码来验证一下。
?
?
package com.meidusa.clyde.test;import com.threerings.expr.Bound;import com.threerings.expr.DynamicScope;import com.threerings.expr.Scope;import com.threerings.expr.Scoped;import com.threerings.expr.SimpleScope;public class TestScope {public static class TestScoped extends DynamicScope{public TestScoped(Scope parentScope) {super("test name", parentScope);}@Scopedprotected String scopedString = "before test";public String getScopedString() {return scopedString;}public void setScopedString(String scopedString) {this.scopedString = scopedString;}}public static class TestBounded extends SimpleScope{public TestBounded(Scope parentScope) {super(parentScope);}@Bound("scopedString")protected String boundedString;public String getBoundedString() {return boundedString;}public void setBoundedString(String boundedString) {this.boundedString = boundedString;}}public static void main(String[] args){TestScoped parent = new TestScoped(null);TestBounded child = new TestBounded(parent);System.out.println(child.getBoundedString());parent.setScopedString("after test");parent.wasUpdated();System.out.println(child.getBoundedString());}}?
运行后输出为：
?
?
before testafter test?
?
?
1 楼 feixf1974 2011-08-03 请问Clyde是不是一个做地图和游戏素材的工具？ 2 楼 kevindude 2011-08-07 Clyde是一个基于OpenGL的3D游戏引擎