簡介：MetaClass是Mybatis對類級別的元信息的封裝和處理，通過與屬性工具類的結合， 實現了對復雜表達式的解析，實現了獲取指定描述信息的功能

public class MetaClass {

    private ReflectorFactory reflectorFactory;
    private Reflector reflector;


    /**
     * 構造函數私有
     */
    private MetaClass(Class<?> type, ReflectorFactory reflectorFactory) {
        
 
this.reflectorFactory = reflectorFactory;
        this.reflector = reflectorFactory.findForClass(type);
    }

    /**
     * 調用構造方法創建MetaClass
     */
    public static MetaClass forClass(Class<?> type, ReflectorFactory reflectorFactory) {
        return new MetaClass(type, reflectorFactory);
    }

    
 
/**
     * 通過屬性名稱， 獲取屬性的MetaClass(解決成員變量是類的情況)
     */
    public MetaClass metaClassForProperty(String name) {
        Class<?> propType = reflector.getGetterType(name);
        return MetaClass.forClass(propType, reflectorFactory);
    }

    public String findProperty(String name) {
        StringBuilder prop 
 
= buildProperty(name, new StringBuilder());
        return prop.length() > 0 ? prop.toString() : null;
    }

    public String findProperty(String name, boolean useCamelCaseMapping) {
        if (useCamelCaseMapping) {
            name = name.replace("_", "");
        }
        return findProperty(name);
    }

    public String[] getGetterNames() {
        return reflector.getGetablePropertyNames();
    }

    public String[] getSetterNames() {
        return reflector.getSetablePropertyNames();
    }

    public Class<?> getSetterType(String name) {
        PropertyTokenizer prop = new PropertyTokenizer(name);
        if (prop.hasNext()) {
            MetaClass metaProp = metaClassForProperty(prop.getName());
            return metaProp.getSetterType(prop.getChildren());
        } else {
            return reflector.getSetterType(prop.getName());
        }
    }

    public Class<?> getGetterType(String name) {
        PropertyTokenizer prop = new PropertyTokenizer(name);
        if (prop.hasNext()) {
            MetaClass metaProp = metaClassForProperty(prop);
            return metaProp.getGetterType(prop.getChildren());
        }
        // issue #506. Resolve the type inside a Collection Object
        return getGetterType(prop);
    }

    private MetaClass metaClassForProperty(PropertyTokenizer prop) {
        Class<?> propType = getGetterType(prop);
        return MetaClass.forClass(propType, reflectorFactory);
    }

    private Class<?> getGetterType(PropertyTokenizer prop) {
        Class<?> type = reflector.getGetterType(prop.getName());
        if (prop.getIndex() != null && Collection.class.isAssignableFrom(type)) {
            Type returnType = getGenericGetterType(prop.getName());
            if (returnType instanceof ParameterizedType) {
                Type[] actualTypeArguments = ((ParameterizedType) returnType).getActualTypeArguments();
                if (actualTypeArguments != null && actualTypeArguments.length == 1) {
                    returnType = actualTypeArguments[0];
                    if (returnType instanceof Class) {
                        type = (Class<?>) returnType;
                    } else if (returnType instanceof ParameterizedType) {
                        type = (Class<?>) ((ParameterizedType) returnType).getRawType();
                    }
                }
            }
        }
        return type;
    }

    private Type getGenericGetterType(String propertyName) {
        try {
            Invoker invoker = reflector.getGetInvoker(propertyName);
            if (invoker instanceof MethodInvoker) {
                Field _method = MethodInvoker.class.getDeclaredField("method");
                _method.setAccessible(true);
                Method method = (Method) _method.get(invoker);
                return TypeParameterResolver.resolveReturnType(method, reflector.getType());
            } else if (invoker instanceof GetFieldInvoker) {
                Field _field = GetFieldInvoker.class.getDeclaredField("field");
                _field.setAccessible(true);
                Field field = (Field) _field.get(invoker);
                return TypeParameterResolver.resolveFieldType(field, reflector.getType());
            }
        } catch (NoSuchFieldException e) {
        } catch (IllegalAccessException e) {
        }
        return null;
    }

    public boolean hasSetter(String name) {
        PropertyTokenizer prop = new PropertyTokenizer(name);
        if (prop.hasNext()) {
            if (reflector.hasSetter(prop.getName())) {
                MetaClass metaProp = metaClassForProperty(prop.getName());
                return metaProp.hasSetter(prop.getChildren());
            } else {
                return false;
            }
        } else {
            return reflector.hasSetter(prop.getName());
        }
    }

    public boolean hasGetter(String name) {
        PropertyTokenizer prop = new PropertyTokenizer(name);
        if (prop.hasNext()) {
            if (reflector.hasGetter(prop.getName())) {
                MetaClass metaProp = metaClassForProperty(prop);
                return metaProp.hasGetter(prop.getChildren());
            } else {
                return false;
            }
        } else {
            return reflector.hasGetter(prop.getName());
        }
    }

    public Invoker getGetInvoker(String name) {
        return reflector.getGetInvoker(name);
    }

    public Invoker getSetInvoker(String name) {
        return reflector.getSetInvoker(name);
    }

    /**
     * 解析屬性表達式 會去尋找reflector中是否有對應的的屬性
     */
    private StringBuilder buildProperty(String name, StringBuilder builder) {
        // 解析屬性表達式
        PropertyTokenizer prop = new PropertyTokenizer(name);
        // 是否有子表達式
        if (prop.hasNext()) {
            // 查找對應的屬性
            String propertyName = reflector.findPropertyName(prop.getName());
            if (propertyName != null) {
                // 追加屬性名
                builder.append(propertyName);
                builder.append(".");
                // 創建對應的 MetaClass 對象
                MetaClass metaProp = metaClassForProperty(propertyName);
                // 解析子表達式, 遞歸
                metaProp.buildProperty(prop.getChildren(), builder);
            }
        } else {
            // 根據名稱查找屬性
            String propertyName = reflector.findPropertyName(name);
            if (propertyName != null) {
                builder.append(propertyName);
            }
        }
        return builder;
    }

    public boolean hasDefaultConstructor() {
        return reflector.hasDefaultConstructor();
    }

}

理解了這個方法（遞歸， 該類中有很多類似的）， 就可以很好的對這個類進行理解， 以查找(richType.richProperty)為例：

1. 通過 PropertyTokenizer 對表達式進行解析， 得到當前的 name = richType, children = richProperty
2. 從 reflector 中查找該 richType 屬性
3. 將 richType 添加到 builder 中
4. 使用 metaClassForProperty 創建 richType 的 MetaClass。
5. 遞歸調用自身來處理子表達式

退出的條件就是沒有子表達式。 這個就是為了， 我們類中有成員變量是類， 我們可以通過其找到他們的所有類及其屬性。
註意， 在此過程中， ReflectorFactory 一直是同一個， 而其內部緩存了多個 Reflector 對象。

Mybatis框架基礎支持層——反射工具箱之MetaClass（7）