DGM调用优化是通过直接调用代替反射调用的方式来提高DGM方法的调用效率。
注：以下分析的Groovy源代码来自Groovy 1.8.0 rc4。
DGM
DGM其实是Groovy社区对DefaultGroovyMethods的简称，完整类名是org.codehaus.groovy.runtime.DefaultGroovyMethods。
DefaultGroovyMethods类中包含了Groovy为JDK的类添加的各种方法，如
[1, 2, 3].each { println it }
中的each方法就是Groovy为Object类添加的方法，用于遍历对象中的所有元素。在Object类的实例上调用each方法，其实调用的是DefaultGroovyMethods类中的
public static <T> T each(T self, Closure closure)
反射调用和直接调用
在Groovy中，用于表示一个方法的是一个MetaMethod(这是一个抽象类)实例，MetaMethod类似于JDK中的Method。而在大多数情况下，这个表示方法的实例会是CachedMethod(MetaMethod的派生类)类型的。调用其代表的方法时，会调用CachedMethod的invoke方法，其代码如下
1 public final Object invoke(Object object, Object[] arguments) {
2 try {
3 return cachedMethod.invoke(object, arguments); // cachedMethod的类型是Method
4 } catch (IllegalArgumentException e) {
5 throw new InvokerInvocationException(e);
6 } catch (IllegalAccessException e) {
7 throw new InvokerInvocationException(e);
8 } catch (InvocationTargetException e) {
9 Throwable cause = e.getCause();
10 throw (cause instanceof RuntimeException && !(cause instanceof MissingMethodException)) ? (RuntimeException) cause : new InvokerInvocationException(e);
11 }
12 }
可见，在Groovy中一般是通过反射的方式调用方法的。
众所周知，在Java中，通过反射来调用方法，比直接调用方法会慢上几倍。因此，DGM调用优化的思想就是通过直接调用来代替反射调用。而要实现直接调用，则需要为DGM中的每个方法生成一个从MetaMethod派生的包装类，该类的invoke方法将直接调用DGM中对应的方法。
DGM调用优化
DGM调用优化的大体流程是这样的：
1. 在编译Groovy自身的Java代码(不是用Groovy写的代码)之后，通过调用DgmConverter类的main方法，为DefaultGroovyMethods的每个方法生成一个包装类，该类继承GeneratedMetaMethod类，而GeneratedMetaMethod类则继承MetaMethod类。该包装类的类名类似于org.codehaus.groovy.runtime.dgm$123($后跟一个数)，在Groovy分发的jar包中可以找到总共918个这样的类，说明DGM中总共有918个方法。这些包装类的代码形式如下(以上面提到的each方法的包装类为例)：
1 public class dgm$123 extends GeneratedMetaMethod {
2 
3 public Object invoke(Object object, Object[] arguments) {
4 return DefaultGroovyMethods.each((Object) object, (Closure) arguments[0]); // 将各参数强制转换为对应的类型后，直接调用DefaultGroovyMethods中对应的方法
5 }
6
7 }
2. 通过调用GeneratedMetaMethod.DgmMethodRecord.saveDgmInfo方法，将哪个DGM方法对应哪个包装类的信息写入META-INF/dgminfo文件中
3. 当运行Groovy程序的时候，在MetaClassRegistryImpl的实例初始化时，通过调用GeneratedMetaMethod.DgmMethodRecord.loadDgmInfo方法，从META-INF/dgminfo文件中读取上一步写入的信息。然后为所有包装类创建GeneratedMetaMethod.Proxy实例作为其代理
4. 在Groovy程序第一次调用DGM方法时，则由GeneratedMetaMethod.Proxy实例载入对应的包装类并实例化，然后调用其invoke方法。这样就实现了包装类的延迟加载，在一定程度上加快了程序初始化加载的速度
那为什么不为用户写的Groovy程序的每一个方法，在运行时动态的创建这样直接调用的包装类，来提高每个方法的调用效率呢？那是因为这样会产生大量的类，由于每个类都是需要占用内存的，所以会对JVM用于存放类信息的PermGen内存区域造成压力，容易产生OutOfMemoryError。而DGM方法是Groovy程序中大量被调用的方法(即热点)，而且数量只有不到1000个，因此适合为其生成包装类。
代码分析
先来看看DgmConverter是如何为DGM方法生成包装类的：
1 public static void main(String[] args) throws IOException, ClassNotFoundException {
2 Class [] classes = new Class [] { // DGM方法事实上是分别位于这几个类中，而不只是在DefaultGroovyMethods类中
3 DefaultGroovyMethods.class,
4 SwingGroovyMethods.class,
5 SqlGroovyMethods.class,
6 XmlGroovyMethods.class,
7 EncodingGroovyMethods.class,
8 DateGroovyMethods.class,
9 ProcessGroovyMethods.class
10 };
11
12 List<CachedMethod> cachedMethodsList = new ArrayList<CachedMethod> ();
13 for (Class aClass : classes) {
14 Collections.addAll(cachedMethodsList, ReflectionCache.getCachedClass(aClass).getMethods()); // 获取这些类中的所有方法
15 }
16 final CachedMethod[] cachedMethods = cachedMethodsList.toArray(new CachedMethod[cachedMethodsList.size()]);
17
18 List<GeneratedMetaMethod.DgmMethodRecord> records = new ArrayList<GeneratedMetaMethod.DgmMethodRecord> ();
19 for (int i = 0, cur = 0; i < cachedMethods.length; i++) {
20 CachedMethod method = cachedMethods[i];
21 if (!method.isStatic() || !method.isPublic()) // DGM方法必须是static和public的
22 continue;
23 if (method.getCachedMethod().getAnnotation(Deprecated.class) != null) // 已过时的DGM方法不处理
24 continue;
25 if (method.getParameterTypes().length == 0) // DGM方法的第一个参数表示该方法应添加到哪个类上，因此DGM方法至少有一个参数
26 continue;
27
28 final Class returnType = method.getReturnType();
29 final String className = "org/codehaus/groovy/runtime/dgm$" + cur;
30
31 // record记录着DGM方法和包装类的对应关系
32 GeneratedMetaMethod.DgmMethodRecord record = new GeneratedMetaMethod.DgmMethodRecord();
33 records.add(record);
34 record.methodName = method.getName();
35 record.returnType = method.getReturnType();
36 record.parameters = method.getNativeParameterTypes();
37 record.className = className;
38
39 // 创建一个继承GeneratedMetaMethod的包装类
40 ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
41 cw.visit(V1_3,ACC_PUBLIC, className,null,"org/codehaus/groovy/reflection/GeneratedMetaMethod", null);
42 createConstructor(cw);
43 final String methodDescriptor = BytecodeHelper.getMethodDescriptor(returnType, method.getNativeParameterTypes());
44 createInvokeMethod(method, cw, returnType, methodDescriptor); // 我们只关注invoke方法的生成
45 createDoMethodInvokeMethod(method, cw, className, returnType, methodDescriptor);
46 createIsValidMethodMethod(method, cw, className);
47 cw.visitEnd();
48
49 // 将包装类写入class文件
50 final byte[] bytes = cw.toByteArray();
51 final FileOutputStream fileOutputStream = new FileOutputStream("target/classes/" + className + ".class");
52 fileOutputStream.write(bytes);
53 fileOutputStream.flush();
54 fileOutputStream.close();
55
56 cur++;
57 }
58
59 GeneratedMetaMethod.DgmMethodRecord.saveDgmInfo (records, "target/classes/META-INF/dgminfo"); // 将DGM方法和包装类的对应关系写入META-INF/dgminfo文件
60 }
我们再来看看用于创建包装类的invoke方法的createInvokeMethod方法：
1 private static void createInvokeMethod(CachedMethod method, ClassWriter cw, Class returnType, String methodDescriptor) {
2 MethodVisitor mv;
3 mv = cw.visitMethod(ACC_PUBLIC, "invoke", "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;", null, null); // 创建一个public Object invoke(Object object, Object[] arguments)方法
4 mv.visitCode();
5 mv.visitVarInsn(ALOAD,1);
6 BytecodeHelper.doCast(mv, method.getParameterTypes()[0].getTheClass()); // 将调用者强制转换为DGM方法第一个参数的类型
7 loadParameters(method,2,mv);
8 mv.visitMethodInsn(INVOKESTATIC, BytecodeHelper.getClassInternalName(method.getDeclaringClass().getTheClass()), method.getName(), methodDescriptor); // 通过invokestatic指令直接调用DGM方法
9 BytecodeHelper.box(mv, returnType);
10 if (method.getReturnType() == void.class) {
11 mv.visitInsn(ACONST_NULL);
12 }
13 mv.visitInsn(ARETURN); // 返回值
14 mv.visitMaxs(0, 0);
15 mv.visitEnd();
16 }
17
18 protected static void loadParameters(CachedMethod method, int argumentIndex, MethodVisitor mv) {
19 CachedClass[] parameters = method.getParameterTypes();
20 int size = parameters.length-1;
21 for (int i = 0; i < size; i++) {
22 mv.visitVarInsn(ALOAD, argumentIndex);
23 BytecodeHelper.pushConstant(mv, i);
24 mv.visitInsn(AALOAD);
25 Class type = parameters[i+1].getTheClass();
26 BytecodeHelper.doCast(mv, type); // 将第i个参数强制转换为DGM方法中第i+1个参数的类型
27 }
28 }
MetaClassRegistryImpl在初始化的时候，会调用自身的registerMethods方法来从META-INF/dgminfo文件中读取DGM方法和包装类的对应关系：
1 private void registerMethods(final Class theClass, final boolean useMethodWrapper, final boolean useInstanceMethods, Map<CachedClass, List<MetaMethod>> map) {
2 if (useMethodWrapper) { // 我们只看useMethodWrapper为true的情况
3 try {
4 List<GeneratedMetaMethod.DgmMethodRecord> records = GeneratedMetaMethod.DgmMethodRecord.loadDgmInfo(); // 从META-INF/dgminfo文件中读取DGM方法和包装类的对应关系
5
6 for (GeneratedMetaMethod.DgmMethodRecord record : records) {
7 Class[] newParams = new Class[record.parameters.length - 1];
8 System.arraycopy(record.parameters, 1, newParams, 0, record.parameters.length-1);
9
10 MetaMethod method = new GeneratedMetaMethod.Proxy(
11 record.className,
12 record.methodName,
13 ReflectionCache.getCachedClass(record.parameters[0]),
14 record.returnType,
15 newParams
16 ); // 为包装类创建GeneratedMetaMethod.Proxy代理
17 final CachedClass declClass = method.getDeclaringClass();
18 List<MetaMethod> arr = map.get(declClass);
19 if (arr == null) {
20 arr = new ArrayList<MetaMethod>(4);
21 map.put(declClass, arr);
22 }
23 arr.add(method);
24 instanceMethods.add(method);
25 }
26 } catch (Throwable e) {
27
28 } else {
29
30 }
31 }
最后来看看GeneratedMetaMethod.Proxy如何实现延迟加载包装类：
1 public static class Proxy extends GeneratedMetaMethod {
2 private volatile MetaMethod proxy;
3 private final String className;
4
5 public Object invoke(Object object, Object[] arguments) {
6 return proxy().invoke(object, arguments);
7 }
8
9 public final synchronized MetaMethod proxy() {
10 // 第一次调用时，通过createProxy创建包装类实例
11 if (proxy == null) {
12 createProxy();
13 }
14 return proxy;
15 }
16
17 private void createProxy() {
18 try {
19 // 载入包装类并进行实例化
20 Class<?> aClass = getClass().getClassLoader().loadClass(className.replace('/','.'));
21 Constructor<?> constructor = aClass.getConstructor(String.class, CachedClass.class, Class.class, Class[].class);
22 proxy = (MetaMethod) constructor.newInstance(getName(), getDeclaringClass(), getReturnType(), getNativeParameterTypes());
23 }
24 catch (Throwable t) {
25 t.printStackTrace();
26 throw new GroovyRuntimeException("Failed to create DGM method proxy : " + t, t);
27 }
28 }
29 }
以上分析有不当之处敬请指出，谢谢大家的阅读。