本文介绍了Metaclass在Groovy中的存放方式，并对不同的情况(Per-class Metaclass、POGO Per-instance Metaclass和POJO Per-instance Metaclass)进行了分析。
注：以下分析的Groovy源代码来自Groovy 1.7.1，所有测试代码在Groovy 1.7.1下测试通过。
Metaclass
用过Groovy的程序员都或多或少、直接或间接的接触过Metaclass。简单来说，Metaclass就是Class的Class，Class定义了该类实例的行为，Metaclass则定义了该类及其实例的行为(
http://en.wikipedia.org/wiki/Metaclass)。Groovy通过Metaclass使程序可以在运行时修改/添加类的方法、属性等。
Per-class Metaclass
在Groovy中，每个Class都有一个对应的Metaclass，通过这个Metaclass可以给这个Class添加方法或属性：
1 // 给String类添加了一个名为capitalize的方法
2 String.metaClass.capitalize = { -> delegate[0].toUpperCase() + delegate[1..-1] }
3 // 给String类添加了一个名为spaceCount的只读属性
4 String.metaClass.getSpaceCount = { -> delegate.count(' ') }
5
6 assert "this is groovy".capitalize() == "This is groovy"
7 assert "this is not ruby".spaceCount == 3
除此之外，还可以替换Class对应的Metaclass：
1 def newMetaClass = new ExpandoMetaClass(Integer)
2 newMetaClass.initialize()
3 // 替换Integer类的Metaclass
4 Integer.metaClass = newMetaClass
5 assert Integer.metaClass == newMetaClass
但是，Class对应的Metaclass到底存放在哪里呢？
我们可以知道，Java的Class类中是没有存放Metaclass的属性的，而Groovy中的Class类就是Java中的Class类。那么，Groovy就需要一个全局的Map来存放每个Class对应的Metaclass了，其中每个Entry的key是Class，value则是Metaclass。这个全局的Map不需要对key(Class)进行排序，所以可以使用HashMap；应该通过是否是同一个实例来判断key的相等性，所以应该是一个IdentityHashMap；不应该妨碍Class被回收，而且Class被回收时对应的Metaclass也应该被回收，所以应该是一个WeakHashMap；可能被多个线程同时使用，所以应该是一个ConcurrentHashMap。总的来说，这个全局的Map应该是一个WeakIdentityConcurrentHashMap。
在Groovy中，这个全局的Map其实就是groovy.lang.MetaClassRegistry，不过在实现细节上有所区别(或者说更加复杂)。MetaClassRegistry是一个interface，它在Groovy中的唯一实现是org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl。我们主要来看MetaClassRegistryImpl中的getMetaClass方法，这个方法用于查找Class对应的Metaclass。
1 public final MetaClass getMetaClass(Class theClass) {
2 return ClassInfo.getClassInfo(theClass).getMetaClass();
3 }
我们再来看看ClassInfo的getClassInfo静态方法：
1 public static ClassInfo getClassInfo(Class cls) {
2 // localMapRef的类型是WeakReference<ThreadLocalMapHandler>
3 ThreadLocalMapHandler handler = localMapRef.get();
4 SoftReference<LocalMap> ref=null;
5 if (handler!=null) ref = handler.get();
6 LocalMap map=null;
7 if (ref!=null) map = ref.get();
8 if (map!=null) return map.get(cls);
9 // 只有当localMapRef或ref已被回收时，才会调用下面的代码
10 // globalClassSet的类型是ClassInfoSet
11 return (ClassInfo) globalClassSet.getOrPut(cls,null);
12 }
ClassInfo中使用静态的globalClassSet存储Metaclass，不过并不是直接存储Class到Metaclass的映射，而是Class到ClassInfo的映射，而ClassInfo则包含了Groovy中跟Class相关的内部属性，其中就包括了Metaclass。
globalClassSet的类型是ClassInfoSet，而ClassInfoSet类继承了ManagedConcurrentMap<Class,ClassInfo>类型，而ManagedConcurrentMap其实就是Weak(Soft)IdentityConcurrentHashMap。限于篇幅，我们在这里就不分析ManagedConcurrentMap和ClassInfoSet的代码了。
再回到ClassInfo的getClassInfo方法，其中第3到8行实现了一个基于ThreadLocal的两级cache。我们先来看第5行的“handler.get()”，这里调用了ThreadLocalMapHandler的get方法：
1 private static class ThreadLocalMapHandler extends ThreadLocal<SoftReference<LocalMap>> {
2 SoftReference<LocalMap> recentThreadMapRef; // 最近一次使用的引用
3 
4 public SoftReference<LocalMap> get() {
5 SoftReference<LocalMap> mapRef = recentThreadMapRef;
6 LocalMap recent = null;
7 if (mapRef!=null) recent = mapRef.get();
8 // 如果最近一次使用的引用就是由当前进程创建的，则直接返回该引用，否则才调用ThreadLocal的get方法。这样可以减少在ThreadLocal.get()中查找Map的消耗
9 if (recent != null && recent.myThread.get() == Thread.currentThread()) {
10 return mapRef;
11 } else {
12 SoftReference<LocalMap> ref = super.get();
13 recentThreadMapRef = ref; // 更新最近一次使用的引用
14 return ref;
15 }
16 }
17 }
再来看ClassInfo.getClassInfo(Class)中第8行的“map.get(cls)”，这里调用了LocalMap的get方法：
1 private static final class LocalMap extends HashMap<Class,ClassInfo> { // LocalMap本身就是二级cache
2 private static final int CACHE_SIZE = 5;
3
4 private final ClassInfo[] cache = new ClassInfo[CACHE_SIZE]; // 这是大小为5的一级cache
5
6 public ClassInfo get(Class key) {
7 ClassInfo info = getFromCache(key); // 先在一级cache中查找
8 if (info != null)
9 return info;
10
11 info = super.get(key); // 再在二级cache中查找
12 if (info != null)
13 return putToCache(info); // 写入一级cache
14
15 // 如果在两级cache中都找不到，则在globalClassSet中查找，再将结果写入一级cache
16 return putToCache((ClassInfo) globalClassSet.getOrPut(key,null));
17 }
18
19 }
注意，这里并没有将任何的结果写入到二级cache中，因此二级cache永远是空的。我认为这可能是被遗漏了，也可能是发现了二级cache占用了大量内存(或者效果并不明显)，所以将写入二级cache的语句去掉了，但是忘了去掉在二级cache中查找的语句。
最后，在MetaClassRegistryImpl.getMetaClass(Class)方法中，查找到Class对应的ClassInfo后，再调用ClassInfo的getMetaClass方法获得Class对应的Metaclass。但是ClassInfo.getMetaClass()并不是简单的返回Metaclass，其中还分为对Metaclass的强引用和弱引用两种情况。由于这已经超出了本文讨论的范围，因此不再深入，对此有兴趣的读者可阅读分析相关代码。
POGO Per-instance Metaclass
POGO的全称是Plain Old Groovy Object，一般指的就是用Groovy编写的对象。每个POGO实例都有一个对应的Metaclass，默认情况下该Metaclass与类的Metaclass相同：
1 class POGO {} // 这是一个用Groovy编写的对象
2
3 def pogo = new POGO()
4 assert pogo.metaClass == POGO.metaClass // 默认情况下POGO实例的Metaclass与类的Metaclass相同
5
6 pogo.metaClass.hello = { -> println 'Hello' }
7 assert pogo.metaClass != POGO.metaClass // 修改POGO实例的Metaclass后，该POGO实例将拥有独立的Metaclass
我们通过groovyc编译上面的脚本，再通过javap反汇编POGO类，最后手工反编译字节码，可以得到以下代码：
1 public class POGO implements GroovyObject { // 用Groovy编写的类都实现了GroovyObject接口
2
3 private transient MetaClass metaClass; // 用于存储实例对应的Metaclass
4
5 public MetaClass getMetaClass() { // 实现了GroovyObject.getMetaClass()方法
6 if (metaClass != null)
7 return metaClass;
8 metaClass = $getStaticMetaClass(); // 默认情况下返回类的Metaclass
9 return metaClass;
10 }
11
12 public void setMetaClass(MetaClass metaClass) { // 实现了GroovyObject.setMetaClass(MetaClass)方法
13 this.metaClass = metaClass;
14 }
15
16 protected MetaClass $getStaticMetaClass() {
17 ClassInfo classinfo = $staticClassInfo;
18 if (classinfo == null)
19 $staticClassInfo = classinfo = ClassInfo.getClassInfo(getClass());
20 return classinfo.getMetaClass();
21 }
22
23 }
容易看出，POGO都实现了GroovyObject接口，而该接口中的getMetaClass和setMetaClass方法分别负责实例对应的Metaclass的读和写。而POGO实例对应的Metaclass则直接存放在实例中的metaClass字段中。
POJO Per-instance Metaclass
与POGO类似的，POJO一般指的就是用Java编写的对象。自Groovy 1.6开始，可以为每个POJO实例设置不同的Metaclass了：
1 def s1 = "this is groovy"
2 def s2 = "this is not ruby"
3 assert s1.size() == 14
4 assert s2.size() == 16
5 s1.metaClass.size = { -> 10 } // 只修改s1的Metaclass
6 assert s1.size() == 10
7 assert s2.size() == 16
与Per-class Metaclass的情况一样(其实Class也是一个Java类)，POJO中并没有存放Metaclass的属性，所以需要用一个(或每个类一个)WeakIdentityConcurrentHashMap来存放Object到Metaclass的映射关系。
POJO Per-instance Metaclass是通过MetaClassRegistryImpl的getMetaClass(Object)和setMetaClass(Object, MetaClass)方法实现读和写的，但是这两个方法并没有加入到MetaClassRegistry接口中(可能是为了保持兼容性)。我们主要看一下MetaClassRegistryImpl.getMetaClass(Object)方法：
1 public MetaClass getMetaClass(Object obj) {
2 return ClassInfo.getClassInfo(obj.getClass()).getMetaClass(obj);
3 }
跟getMetaClass(Class)方法一样，先通过ClassInfo.getClassInfo(Class)方法查找ClassInfo实例。接着调用了ClassInfo.getMetaClass(Object)方法，我们来看看这个方法：
1 public MetaClass getMetaClass(Object obj) {
2 final MetaClass instanceMetaClass = getPerInstanceMetaClass(obj);
3 if (instanceMetaClass != null)
4 return instanceMetaClass;
5
6 // 如果没有为该对象设置Metaclass，则返回类的Metaclass，即默认的Metaclass就是类的Metaclass
7 lock();
8 try {
9 return getMetaClassUnderLock();
10 } finally {
11 unlock();
12 }
13 }
14
15 public MetaClass getPerInstanceMetaClass(Object obj) {
16 if (perInstanceMetaClassMap == null)
17 return null;
18
19 return (MetaClass) perInstanceMetaClassMap.get(obj);
20 }
getMetaClass(Object)方法先从perInstanceMetaClassMap属性中查找obj对应的Metaclass，而perInstanceMetaClassMap属性的类型是ManagedConcurrentMap，没错，就是我们上面提到过的Weak(Soft)IdentityConcurrentHashMap的实现。
也就是说，POJO对应的Metaclass是存放在它的Class对应的ClassInfo中的一个ManagedConcurrentMap中的。
总结
总的来说，在各种情况下，Metaclass的存放方式如下：
- Per-class Metaclass：存放在Class对应的ClassInfo中，而Class到ClassInfo的映射关系则存放在ClassInfo中的一个静态的ManagedConcurrentMap中；
- POGO Per-instance Metaclass：直接存放在对象的metaClass字段中。
- POJO Per-instance Metaclass：对象到Metaclass的映射关系存放在该对象的Class对应的ClassInfo中的一个ManagedConcurrentMap中。
以上分析有不当之处敬请指出，谢谢大家的阅读。