Retrofit源码分析（二.基础知识反射认识）

最新推荐文章于 2023-12-28 14:39:41 发布

li_zhu_7520

最新推荐文章于 2023-12-28 14:39:41 发布

阅读量288

点赞数

分类专栏： Android

本文链接：https://blog.csdn.net/li_zhu_7520/article/details/77697164

版权

Android 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

反射

反射位于java.lang.reflect包类，还是那句话，有兴趣的同学可以去瞅瞅，反正代码挺好看的。

下面主要讲的是这几个类，Method，Field，Type（子实现类GenericArrayType，WildcardType，TypeVariable，ParameterizedType）

当然有核心的类Class了，Proxy放在下一章讲。

1.java.lang.reflect.Array 动态创建数组的。示例如下：

        Object obg  = Array.newInstance(String.class,5);
        Array.set(obg,0,"rulang0");
        Array.set(obg,1,"rulang1");
        String[] value = (String[])obg;
        System.out.println(value[1]);//输出：rulang1

2.java.lang.reflect.Constructor 构造函数

/*        *********  _getConstructor()_ 和 _getDeclaredConstructor()_ 区别：*********

        getDeclaredConstructor(Class<?>... parameterTypes)
        这个方法会返回制定参数类型的所有构造器，包括public的和非public的，当然也包括private的。
        getDeclaredConstructors()的返回结果就没有参数类型的过滤了。

        再来看getConstructor(Class<?>... parameterTypes)
        这个方法返回的是上面那个方法返回结果的子集，只返回制定参数类型访问权限是public的构造器。
        getConstructors()的返回结果同样也没有参数类型的过滤。*/

        Class<?> cls = Class.forName("com.rulang.reflect.RuLangDemo");
        Constructor constructor1=cls.getConstructor(new Class[]{});
        System.out.println("修饰符: "+ Modifier.toString(constructor1.getModifiers()));
        System.out.println("构造函数名: "+constructor1.getName());
        System.out.println("参数列表: "+constructor1.getParameterTypes());

        Object obj = constructor1.newInstance();
       // System.out.println("调用默认构造函数生成实例:"+obj.toString());

//        Constructor constructor2 = cls.getConstructor(new Class[]{String.class});

        Constructor constructor2 = cls.getDeclaredConstructor(new Class[]{String.class});//getConstructor
        System.out.println("修饰符: "+Modifier.toString(constructor2.getModifiers()));
        System.out.println("构造函数名: "+constructor2.getName());
        System.out.println("参数列表: "+constructor2.getParameterTypes());

        RuLangDemo obj2 = (RuLangDemo) constructor2.newInstance(new Object[]{"rulang"});


        // Constructor constructor3 = cls.getDeclaredConstructor(new Class[]{String.class});  此处会抱错
        Constructor constructor3 = cls.getDeclaredConstructor(new Class[]{int.class});
        System.out.println("修饰符: "+Modifier.toString(constructor3.getModifiers()));
        System.out.println("构造函数名: "+constructor3.getName());
        System.out.println("参数列表: "+constructor3.getParameterTypes());

        //下面的代码会抱错的，因为是私有构造函数，没法这样处理。
        //RuLangDemo obj3 = (RuLangDemo) constructor3.newInstance(new Object[]{Integer.valueOf(999)});

输出的内容是：

修饰符: public
构造函数名: com.rulang.reflect.RuLangDemo
参数列表: [Ljava.lang.Class;@14ae5a5

修饰符: public
构造函数名: com.rulang.reflect.RuLangDemo
参数列表: [Ljava.lang.Class;@6d6f6e28

修饰符: private
构造函数名: com.rulang.reflect.RuLangDemo
参数列表: [Ljava.lang.Class;@135fbaa4

java.lang.reflect.Field

1.getDeclaredField(String name): 是可以获取一个类的其中一个字段

2.getDeclaredFields():是可以获取一个类的所有字段

3.getField(String name): 获取其中一个obj的字段

4.getFields(): 主要是public字段所有的

5.getType()：获取属性声明时类型对象（返回class对象）

6.getGenericType() ：返回属性声的Type类型

7.getName() ：获取属性声明时名字

8.getAnnotations() ：获得这个属性上所有的注释

9.getModifiers() ：获取属性的修饰

10.isEnumConstant() ：判断这个属性是否是枚举类

11.isSynthetic() ：判断这个属性是否是复合类

12.get(Object obj) ：取得obj对象这个Field上的值

13.set(Object obj, Object value) ：向obj对象的这个Field设置新值value

        RuLangDemo demo=new RuLangDemo();
        System.out.println(demo.getmStr());//输出：xixi
        Field field=demo.getClass().getDeclaredField("mStr");
        field.setAccessible(true);
        field.set(demo,"rulang");
        System.out.println(demo.getmStr());//输出：rulang1

4.java.lang.reflect.Method

1.getMethods(): 获得类的public类型的方法

2.getMethod(String name, Class[] params): 获得类的特定方法,name参数指定方法的名字,params参数指定方法的参数类型

3.getDeclaredMethods(): 获取类中所有的方法(public、protected、default、private)

4.getDeclaredMethod(String name, Class[] params): 获得类的特定方法,name参数指定方法的名字,params参数指定方法的参数类型

        RuLangDemo demo=new RuLangDemo();
        System.out.println(demo.getmStr());//输出：xixi
        Method setmStrMethod = demo.getClass().getMethod("setmStr", new Class[]{String.class});
        System.out.println("修饰符: " + Modifier.toString(setmStrMethod.getModifiers()));
        setmStrMethod.setAccessible(true); // 修饰符 如果是私有的，必须设置这个
        setmStrMethod.invoke(demo, "rulang"); // 方法调用哦
        System.out.println(demo.getmStr());//输出：rulang1

5.java.lang.reflect.Type

Type是所有类型的父接口, 如原始类型(raw types 对应 Class)、 

参数化类型(parameterized types 对应 ParameterizedType)、 数组类型        

(array types 对应 GenericArrayType)、 类型变量(type variables 对应 TypeVariable )

基本(原生)类型(primitive types 对应 Class),。

子接口有 ParameterizedType, TypeVariable, GenericArrayType, WildcardType, 实现类有Class。

（1）ParameterizedType  是什么样的呢？

    文档上有说明哦 ParameterizedType represents a parameterized type such as Collection<String>

    Map<String, Object> map;

    Set<String> set;

    Class<?> class;

    List<String> list;     这都是ParameterizedType类型哦


    Type[] getActualTypeArguments(); Map<String,Object> map 这个ParameterizedType返回的是 String 类。

    Object类的全限定类名的 Type Array。

    Type getRawType()Map<String,Object> map 这个 ParameterizedType 返回的是 Map 类的全限定类名的 Type Array。

    Type getOwnerType();Map<String,Object> map 这个 ParameterizedType 的 getOwnerType() 为 null，

    而 Map.Entry<String,String> map 的 getOwnerType() 为 Map 所属于的 Type。

    public class Test {

    private   Map<String,Object> map=null;
    private   Map.Entry<String, String> map1=null;


    public static void main(String[] jiexieQi) throws Exception {
        Field map=Test.class.getDeclaredField("map");
        Field map1=Test.class.getDeclaredField("map1");

        ParameterizedType  mapType = (ParameterizedType) map.getGenericType();
        ParameterizedType  map1Type = (ParameterizedType) map1.getGenericType();

        System.out.println(mapType.getOwnerType());//输出：null
        System.out.println(map1Type.getOwnerType());//输出：interface java.util.Map

        System.out.println(mapType.getActualTypeArguments()[0]);//输出：class java.lang.String
        System.out.println(mapType.getActualTypeArguments()[1]);//输出：class java.lang.Object


    }

（2）TypeVariable：是各种类型变量的公共父接口，就是泛型里面的类似T、E。

     TypeVariable，类型变量，描述类型，表示泛指任意或相关一类类型，也可以说狭义上的泛型（泛指某一类类型），

    一般用大写字母作为变量，比如K、V、E等


    TypeVariable 源码如下：

    public interface TypeVariable<D extends GenericDeclaration> extends Type {
           //获得泛型的上限，若未明确声明上边界则默认为Object
            Type[] getBounds();
            //获取声明该类型变量实体(即获得类、方法或构造器名)
            D getGenericDeclaration();
            //获得名称，即K、V、E之类名称
            String getName();
    }

（3）GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型，比如List<>[]，T[]这种。

public class Test {
    private  List<String> [] listArray; //GenericArrayType 转为Class哦

    public static void main(String[] jiexieQi) throws Exception {
        Field listArray=Test.class.getDeclaredField("listArray");
        Type typeList=listArray.getGenericType();

        GenericArrayTypeImpl ty= (GenericArrayTypeImpl) typeList;
        ParameterizedType uu= (ParameterizedType) ty.getGenericComponentType();
        System.out.println(uu.getTypeName());//输出：java.util.List<java.lang.String>
    }

（4）WildcardType：代表一种通配符类型表达式，类似? super T这样的通配符表达式。

源码如下：
public interface WildcardType extends Type {
    //获得泛型表达式上界（上限）
    Type[] getUpperBounds();
    //获得泛型表达式下界（下限）
    Type[] getLowerBounds();
}

public <T> void test(List<? extends classA > a){}
Method method = Main.class.getMethod("test",List.class);
        Type[] upperBounds = null;
        Type[] lowerBounds = null;
        Type[] types = method.getGenericParameterTypes();
        for(Type type : types){
        Type[] actualTypeArgument = ((ParameterizedType)type).getActualTypeArguments();
            for(Type t : actualTypeArgument){
                WildcardType wildcardType = (WildcardType) t;
                lowerBounds = wildcardType.getLowerBounds();
                upperBounds = wildcardType.getUpperBounds();
                System.out.println("通配符表达式类型是："+ wildcardType);
                if(upperBounds.length != 0){
                    System.out.println("表达式上边界："+Arrays.asList(upperBounds));
                    }
                if(lowerBounds.length != 0){
                    System.out.println("表达式下边界："+Arrays.asList(lowerBounds));
                    }
            }
        }
//输出结果
通配符表达式类型是：? extends com.fcc.test.classA
表达式上边界：[class com.fcc.test.classA]