【反射】Class类

Class类中包含了类定义的详细信息，可以使用Class类中提供的方法来获取，下面我们先获取Class对象，再介绍Class类中提供的获取类信息的方法。

一、准备工作

在src/test/java目录的cn.horse.reflect.entity包下新建BaseEntity类、UserInfoEntity类；新建EntityAnnotation、InheritedEntityAnnotation、UserInfoEntityAnnotation注解

BaseEntity类：

package cn.horse.reflect.entity;
 
@EntityAnnotation
@InheritedEntityAnnotation
public abstract class BaseEntity {
    @EntityAnnotation
    @InheritedEntityAnnotation
    public Long id;
 
    @InheritedEntityAnnotation
    public BaseEntity() { }
 
    @EntityAnnotation
    @InheritedEntityAnnotation
    public BaseEntity(Long id) {
        this.id = id;
    }
 
    @EntityAnnotation
    @InheritedEntityAnnotation
    public void setId(Long id) {
        this.id = id;
    }
 
    public Long getId() {
        return id;
    }
}

UserInfoEntity类：

package cn.horse.reflect.entity;
 
@UserInfoEntityAnnotation
public class UserInfoEntity extends BaseEntity {
 
    @UserInfoEntityAnnotation
    public String name;
    @UserInfoEntityAnnotation
    private Integer age;
 
    @UserInfoEntityAnnotation
    private UserInfoEntity() {
    }
 
    @UserInfoEntityAnnotation
    public UserInfoEntity(Long id) {
        super(id);
    }
 
    @UserInfoEntityAnnotation
    public UserInfoEntity(Long id, String name, Integer age) {
        super(id);
        this.name = name;
        this.age = age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
    public Integer getAge() {
        return age;
    }
 
    private String getName() {
        return name;
    }
 
    private void check() { }
 
    @UserInfoEntityAnnotation
    @Override
    public void setId(Long id) {
        super.setId(id);
    }
}

EntityAnnotation注解：

package cn.horse.reflect.entity;
 
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
import static java.lang.annotation.ElementType.*;
 
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface EntityAnnotation {
}

InheritedEntityAnnotation注解：

package cn.horse.reflect.entity;
 
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
 
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface InheritedEntityAnnotation {
}

UserInfoEntityAnnotation注解：

package cn.horse.reflect.entity;
 
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
 
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface UserInfoEntityAnnotation {
}

二、获取Class对象的三种方式

在src/test/java目录的cn.horse.reflect包下新建GetClassInstanceTests测试类

GetClassInstanceTests类：

package cn.horse.reflect;
 
import cn.horse.reflect.entity.UserInfoEntity;
import org.junit.jupiter.api.Test;
 
import static org.assertj.core.api.Assertions.assertThat;
 
public class GetClassInstanceTests {
 
    @Test
    public void testGetClassInstanceByBusObjectInstance() {
        assertThat(new UserInfoEntity(1L).getClass()).isNotNull();
    }
 
    @Test
    public void testGetClassInstanceByBusClass() {
        assertThat(UserInfoEntity.class).isNotNull();
    }
 
    @Test
    public void testGetClassInstanceByName() throws ClassNotFoundException {
        assertThat(Class.forName("cn.horse.reflect.entity.UserInfoEntity", false, this.getClass().getClassLoader())).isNotNull();
    }
 
    @Test
    public void testClassInstanceEquals() throws ClassNotFoundException {
        Class forNameType = Class.forName("cn.horse.reflect.entity.UserInfoEntity", false, this.getClass().getClassLoader());
        Class dotClassType = UserInfoEntity.class;
        Class objectGetClassType = new UserInfoEntity(1L).getClass();
        assertThat(forNameType).isEqualTo(dotClassType);
        assertThat(dotClassType).isEqualTo(objectGetClassType);
        assertThat(forNameType).isEqualTo(objectGetClassType);
    }
}

单元测试方法介绍：

testGetClassInstanceByBusObjectInstance：使用对象的实例获取Class对象

testGetClassInstanceByBusClass：使用类获取Class对象

testGetClassInstanceByName：使用全限类名获取Class对象

testClassInstanceEquals：判断三种方法获取到的Class对象是否相等

单元测试中使用了三种方式获取Class对象，三种方式获取到的Class对象是相等的。

三、Class类中方法的使用

在src/test/java目录的cn.horse.reflect包下新建ClassInstanceMethodTests测试类

ClassInstanceMethodTests类：

package cn.horse.reflect;
 
import cn.horse.reflect.entity.*;
import org.junit.jupiter.api.Test;
 
import java.lang.annotation.Annotation;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Locale;
import java.util.stream.Collectors;
 
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 
public class ClassInstanceMethodTests {
 
    @Test
    public void testGetName() {
        assertThat(UserInfoEntity.class.getSimpleName()).isEqualTo("UserInfoEntity");
        assertThat(UserInfoEntity.class.getName()).isEqualTo("cn.horse.reflect.entity.UserInfoEntity");
        assertThat(UserInfoEntity.class.getPackage().getName()).isEqualTo("cn.horse.reflect.entity");
    }
 
    @Test
    public void testPrimitive() {
        assertThat(byte.class.isPrimitive()).isTrue();
        assertThat(short.class.isPrimitive()).isTrue();
        assertThat(int.class.isPrimitive()).isTrue();
        assertThat(long.class.isPrimitive()).isTrue();
        assertThat(float.class.isPrimitive()).isTrue();
        assertThat(double.class.isPrimitive()).isTrue();
        assertThat(boolean.class.isPrimitive()).isTrue();
        assertThat(void.class.isPrimitive()).isTrue();
        assertThat(int[].class.isPrimitive()).isFalse();
        assertThat(String.class.isPrimitive()).isFalse();
        assertThat(UserInfoEntity.class.isPrimitive()).isFalse();
    }
 
    @Test
    public void testArray() {
        assertThat(String[].class.isArray()).isTrue();
        assertThat(String[].class.getComponentType()).isEqualTo(String.class);
    }
 
    @Test
    public void testEnum() {
        assertThat(Locale.Category.class.isEnum()).isTrue();
        Collection enumConstantList = Arrays.asList(Locale.Category.class.getEnumConstants());
        List expectedEnumConstantList = Arrays.asList(Locale.Category.values());
        assertThat(enumConstantList.size()).isEqualTo(expectedEnumConstantList.size());
        assertThat(enumConstantList).containsAll(expectedEnumConstantList);
    }
 
    @Test
    public void testAnnotation() {
        assertThat(SuppressWarnings.class.isAnnotation()).isTrue();
    }
 
    @Test
    public void testLocalClass() {
        // 定义局部类
        class LocalClass {
        }
        assertThat(LocalClass.class.isLocalClass()).isTrue();
    }
 
    @Test
    public void testAnonymousClass() {
        Runnable unknownClass = new Runnable() {
            @Override
            public void run() {
            }
        };
        assertThat(unknownClass.getClass().isAnonymousClass()).isTrue();
    }
 
    @Test
    public void testMemberClass() {
        assertThat(UserInfoEntity.class.isMemberClass()).isFalse();
        assertThat(InnerClass.class.isMemberClass()).isTrue();
        assertThat(StaticInnerClass.class.isMemberClass()).isTrue();
 
        // 定义局部类
        class LocalClass {
        }
        assertThat(LocalClass.class.isMemberClass()).isFalse();
 
        // 匿名类
        Runnable unknownClass = new Runnable() {
            @Override
            public void run() {
            }
        };
        assertThat(unknownClass.getClass().isMemberClass()).isFalse();
    }
 
    @Test
    public void testGetModifiers() {
        assertThat(Modifier.isPublic(UserInfoEntity.class.getModifiers())).isTrue();
        assertThat(Modifier.isProtected(UserInfoEntity.class.getModifiers())).isFalse();
        assertThat(Modifier.isPrivate(UserInfoEntity.class.getModifiers())).isFalse();
        assertThat(Modifier.isAbstract(UserInfoEntity.class.getModifiers())).isFalse();
        assertThat(Modifier.isInterface(UserInfoEntity.class.getModifiers())).isFalse();
        assertThat(Modifier.isStatic(UserInfoEntity.class.getModifiers())).isFalse();
        assertThat(Modifier.isFinal(UserInfoEntity.class.getModifiers())).isFalse();
        assertThat(Modifier.isNative(UserInfoEntity.class.getModifiers())).isFalse();
    }
 
    @Test
    public void testStaticInnerClass() {
        assertThat(Modifier.isStatic(StaticInnerClass.class.getModifiers())).isTrue();
    }
 
    @Test
    public void testInnerClass() {
        assertThat(InnerClass.class.isMemberClass() && !Modifier.isStatic(InnerClass.class.getModifiers())).isTrue();
    }
 
    private static class StaticInnerClass { }
    private class InnerClass { }
 
    @Test
    public void testTypeConvert() {
        assertThat(UserInfoEntity.class.isInstance(new UserInfoEntity(1L))).isTrue();
        assertThat(BaseEntity.class.isInstance(new UserInfoEntity(1L))).isTrue();
        assertThat(UserInfoEntity.class.isAssignableFrom(UserInfoEntity.class)).isTrue();
        assertThat(BaseEntity.class.isAssignableFrom(UserInfoEntity.class)).isTrue();
        assertThat(BaseEntity.class.cast(new UserInfoEntity(1L))).isNotNull();
        assertThatExceptionOfType(ClassCastException.class).isThrownBy(() -> BaseEntity.class.cast(1));
    }
 
    @Test
    public void testGetAnnotations() {
        Collectionextends Annotation>> annotationList = Arrays.stream(UserInfoEntity.class.getAnnotations()).map(Annotation::annotationType).collect(Collectors.toList());
        Listextends Annotation>> expectedAnnotationList = Arrays.asList(InheritedEntityAnnotation.class, UserInfoEntityAnnotation.class);
        assertThat(annotationList.size()).isEqualTo(expectedAnnotationList.size());
        assertThat(annotationList).containsAll(expectedAnnotationList);
    }
 
    @Test
    public void testGetAnnotationsByType() {
        Collectionextends Annotation>> annotationList = Arrays.stream(UserInfoEntity.class.getAnnotationsByType(InheritedEntityAnnotation.class)).map(Annotation::annotationType).collect(Collectors.toList());
        Listextends Annotation>> expectedAnnotationList = Arrays.asList(InheritedEntityAnnotation.class);
        assertThat(annotationList.size()).isEqualTo(expectedAnnotationList.size());
        assertThat(annotationList).containsAll(expectedAnnotationList);
    }
 
    @Test
    public void testGetAnnotation() {
        assertThat(UserInfoEntity.class.getAnnotation(EntityAnnotation.class)).isNull();
        assertThat(UserInfoEntity.class.getAnnotation(InheritedEntityAnnotation.class)).isNotNull();
        assertThat(UserInfoEntity.class.getAnnotation(UserInfoEntityAnnotation.class)).isNotNull();
    }
 
    @Test
    public void testGetDeclaredAnnotations() {
        Collectionextends Annotation>> annotationList = Arrays.stream(UserInfoEntity.class.getDeclaredAnnotations()).map(Annotation::annotationType).collect(Collectors.toList());
        Listextends Annotation>> expectedAnnotationList = Arrays.asList(UserInfoEntityAnnotation.class);
        assertThat(annotationList.size()).isEqualTo(expectedAnnotationList.size());
        assertThat(annotationList).containsAll(expectedAnnotationList);
    }
 
    @Test
    public void testGetDeclaredAnnotationsByType() {
        Collectionextends Annotation>> annotationList = Arrays.stream(UserInfoEntity.class.getDeclaredAnnotationsByType(UserInfoEntityAnnotation.class)).map(Annotation::annotationType).collect(Collectors.toList());
        Listextends Annotation>> expectedAnnotationList = Arrays.asList(UserInfoEntityAnnotation.class);
        assertThat(annotationList.size()).isEqualTo(expectedAnnotationList.size());
        assertThat(annotationList).containsAll(expectedAnnotationList);
    }
 
    @Test
    public void testGetDeclaredAnnotation() {
        assertThat(UserInfoEntity.class.getDeclaredAnnotation(EntityAnnotation.class)).isNull();
        assertThat(UserInfoEntity.class.getDeclaredAnnotation(InheritedEntityAnnotation.class)).isNull();
        assertThat(UserInfoEntity.class.getDeclaredAnnotation(UserInfoEntityAnnotation.class)).isNotNull();
    }
}

单元测试类中定义了两个内部类：静态内部类StaticInnerClass、内部类InnerClass；

单元测试方法介绍：

testGetName：获取类名称，其中getSimpleName用于获取简略名称，getName用于获取全限类名，getPackage用于获取包对象

testPrimitive：判断是否是基本数据类型，使用isPrimitive方法判断是否是基本数据类型（byte,short,int,long,float,double,Boolean,void）

testArray：判断并获取数组元素类型，使用isArray判断是否是数组类型，使用getComponentType获取数组元素类型

testEnum：判断并获取枚举常量数组，使用isEnum判断是否是枚举类型，使用getEnumConstants获取枚举常量数组

testAnnotation：判断是否是注解类型，使用isAnnotation判断是否是注解类型

testLocalClass：判断是否是局部类，使用isLocalClass判断是否是局部类

testAnonymousClass：判断是否是匿名类，使用isAnonymousClass判断是否是匿名类

testMemberClass：判断是否是成员类，使用isMemberClass判断是否是成员类，内部类、静态内部类都属于成员类，局部类、匿名类都不属于成员类

testGetModifiers：获取修饰符，使用getModifiers获取修饰符，并使用Modifier类提供的静态方法依次判断了是否使用了public、protected、private、abstract、interface、static、final、native等修饰符

testStaticInnerClass：判断是否是静态内部类，使用getModifiers获取修饰符，并使用Modifier类提供的静态方法判断是否使用了static修饰符

testInnerClass：判断是否是内部类，判断是否是成员类并且没有使用static修饰符

testTypeConvert：类型判断与转换，使用isInstance或isAssignableFrom可以判断类型是否可以转换，使用cast可以进行类型的转换。

testGetAnnotations：使用getAnnotations获取当前类及其父类可以被继承的注解

testGetAnnotationsByType：使用getAnnotationsByType从当前类及其父类可以被继承的注解中获取指定类型的注解

testGetAnnotation：使用getAnnotation从当前类及其父类可以被继承的注解中获取指定类型的注解

testGetDeclaredAnnotations：使用getDeclaredAnnotations获取当前类的注解

testGetDeclaredAnnotationsByType：使用getDeclaredAnnotationsByType从当前类的注解中获取指定类型的注解

testGetDeclaredAnnotation：使用getDeclaredAnnotation从当前类的注解中获取指定类型的注解