第二十五章 类元数据

public interface ClassMetadata {

    /**
     * 类名
     */
    String getClassName();

    /**
     * 是否是接口
     */
    boolean isInterface();

    /**
     * 是否是注解
     */
    boolean isAnnotation();

    /**
     * 是否是超类
     */
    boolean isAbstract();

    /**
     * 是否允许创建,实例化
     */
    default boolean isConcrete() {
        return !(isInterface() || isAbstract());
    }

    /**
     * 是否有final修饰
     */
    boolean isFinal();

    /**
     * 是否独立
     * 1. 不是内部类
     * 2. 不是继承类
     */
    boolean isIndependent();

 
    default boolean hasEnclosingClass() {
        return (getEnclosingClassName() != null);
    }

  
    @Nullable
    String getEnclosingClassName();

    /**
     * 是否有父类
     */
    default boolean hasSuperClass() {
        return (getSuperClassName() != null);
    }

    /**
     * 父类名称
     */
    @Nullable
    String getSuperClassName();

    /**
     * 实现接口列表
     */
    String[] getInterfaceNames();

    /**
     * 成员列表
     */
    String[] getMemberClassNames();

}

public class ClassMetaTest {
   @Test
   void testEnclosingClassName() {
      Class<A> aClass = A.class;
      Class<?> enclosingClass = aClass.getEnclosingClass();
      System.out.println(enclosingClass);

      Class<B> bClass = B.class;
      Class<?> enclosingClass1 = bClass.getEnclosingClass();
      System.out.println(enclosingClass1);

   }

   public static class B {

   }

   public class A {

   }
}

class com.source.hot.ioc.book.ioc.ClassMetaTest
class com.source.hot.ioc.book.ioc.ClassMetaTest

package com.source.hot.ioc.book.ioc;

public class CTest {
}

@Test
void testCtest(){
   System.out.println(CTest.class.getEnclosingClass());
}

null

@Deprecated
public StandardClassMetadata(Class<?> introspectedClass) {
    Assert.notNull(introspectedClass, "Class must not be null");
    this.introspectedClass = introspectedClass;
}

@Override
public String getClassName() {
    return this.introspectedClass.getName();
}

public class StandardClassMetadata implements ClassMetadata {

    /**
     * 被解析的类对象
     */
    private final Class<?> introspectedClass;


    /**
     * Create a new StandardClassMetadata wrapper for the given Class.
     * 构造函数
     * @param introspectedClass the Class to introspect
     * @deprecated since 5.2 in favor of {@link StandardAnnotationMetadata}
     */
    @Deprecated
    public StandardClassMetadata(Class<?> introspectedClass) {
        Assert.notNull(introspectedClass, "Class must not be null");
        this.introspectedClass = introspectedClass;
    }

    /**
     * Return the underlying Class.
     */
    public final Class<?> getIntrospectedClass() {
        return this.introspectedClass;
    }


    @Override
    public String getClassName() {
        return this.introspectedClass.getName();
    }

    @Override
    public boolean isInterface() {
        return this.introspectedClass.isInterface();
    }

    @Override
    public boolean isAnnotation() {
        return this.introspectedClass.isAnnotation();
    }

    @Override
    public boolean isAbstract() {
        return Modifier.isAbstract(this.introspectedClass.getModifiers());
    }

    @Override
    public boolean isFinal() {
        return Modifier.isFinal(this.introspectedClass.getModifiers());
    }

   @Override
   public boolean isIndependent() {
       // 是否存在内部类
      // 是否有 class
      // 是否有 static 修饰
      return (!hasEnclosingClass() ||
            (this.introspectedClass.getDeclaringClass() != null &&
                  Modifier.isStatic(this.introspectedClass.getModifiers())));
   }

    @Override
    @Nullable
    public String getEnclosingClassName() {
       // 内部类名称
        Class<?> enclosingClass = this.introspectedClass.getEnclosingClass();
        return (enclosingClass != null ? enclosingClass.getName() : null);
    }

    @Override
    @Nullable
    public String getSuperClassName() {
        Class<?> superClass = this.introspectedClass.getSuperclass();
        return (superClass != null ? superClass.getName() : null);
    }

    @Override
    public String[] getInterfaceNames() {
        Class<?>[] ifcs = this.introspectedClass.getInterfaces();
        String[] ifcNames = new String[ifcs.length];
        for (int i = 0; i < ifcs.length; i++) {
            ifcNames[i] = ifcs[i].getName();
        }
        return ifcNames;
    }

    @Override
    public String[] getMemberClassNames() {
        LinkedHashSet<String> memberClassNames = new LinkedHashSet<>(4);
        for (Class<?> nestedClass : this.introspectedClass.getDeclaredClasses()) {
            memberClassNames.add(nestedClass.getName());
        }
        return StringUtils.toStringArray(memberClassNames);
    }

}