Java反射实践:从反射中理解class

0.16字数 1116阅读 292

写在前面

今天在需求评审的时候,遇到了挺有意思的要求。需求是什么样子就不说了。总之完成这个需求需要一个调用系统api的操作。然而这个api因为并不稳定的原因。被谷歌hide掉了。
这个时候我们最直接的方式就是去通过反射去调用这个系统api。(当然这种方式治标不治本,因为既然被hide,就说明这个api很不稳定。所以这个版本可以用,有可能下个版本就没了)
不过这里我们不考虑这个问题,因为如题所说,这次主角是反射。
之前在用反射的时候,其实并没有去思考反射所带来的东西。而这次在用反射的时候,开始去思考为什么要这么用,它和Java的运行机制有什么关系。
我们在看JVM的时候:多少都能了解到Java的类加载机制,那就是我们在new一个对象的时候,JVM会先使用双亲委派机制去加载这个class文件,class文件的代码结构会被封装成Class对象唯一的出现在方法区中。然后才是我们的实例对象创建到堆中。
之前我去上述的理解没有任何概念,仅仅是当做文字给记了下来。直到我今天在使用反射的时候,突然对上述的概念有了实质性的认识。
不过不着急,让我们一点点的深入....

进入正文

声明一个类

首先我们先声明一个class,内部包含了另一个对象,并且写了一些私有/公有/静态的变量及方法,一会将针对这个class进行反射的操作:

这里的日志使用了Log是Android里的打印输出,而非Java中的System.out.print。

public class ReflectModel {
    private ReflectBean mReflectBean;
    private String mContent = "A";
    public int mNum = 1;
    public static int sNum = 666;

    public ReflectModel() {
        LogUtils.d(TAG, "ReflectModel(),无参构造方法执行");
    }

    public ReflectModel(String content) {
        LogUtils.d(TAG, "ReflectModel(String content),一个String参数的构造方法执行");
        mContent = content;
    }

    private ReflectModel(String content, int num) {
        LogUtils.d(TAG, "ReflectModel(String content,int num),俩个参数的私有构造方法执行");
        mContent = content;
        mNum = num;
    }

    public void fun() {
        LogUtils.d(TAG, "我就是一个方法,在本例子中。我是被反射生成的对象调用的->mContent:" + mContent + "-mNum:" + mNum);
    }

    private void printContent() {
        LogUtils.d(TAG, "我就是私有的打印方法->mContent:" + mContent + "-mNum:" + mNum);
    }

    private void setContent(String content) {
        LogUtils.d(TAG, "我就是一个带有一个String参数的私有方法->setContent:" + content);
        mContent = content;
    }

    public void printBean() {
        LogUtils.d(TAG, "我是ReflectBean的打印方法->mName:" + mReflectBean.getName());
    }

    public static void staticFun() {
        LogUtils.d(TAG, "我是静态方法staticFun");
    }
}

内部的ReflectBean类

public class ReflectBean {
    private String mName = "a";

    public ReflectBean(String name) {
        mName = name;
    }

    public String getName() {
        return mName;
    }
}

获取拥有真正对象代码结构的Class:

不知道各位小伙伴们有没有思考过,为什么我们new一个类的时候这么方便,反而到了反射的时候会如此的麻烦?

public void fun() {
        //第一种方式获取Class对象:产生一个Student对象的实例,以及一个唯一的Class对象。
        ReflectModel model1 = new ReflectModel();
        //获取Class对象:这种方式没什么意义,既然有了对象的实例,何必再去反射
        Class modelClass = model1.getClass();

        //第二种方式获取Class对象:需要我们导包,但是有些时候这个类是隐藏的(比如很多系统不稳定的类,@Hide)
        Class modelClass2 = ReflectModel.class;

        Class modelClass3 = null;
        try {
            //第三种方式获取Class对象:类的全路径
            modelClass3 = Class.forName("com.example.mbenben.studydemo.basenote.reflect.ReflectModel");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

将Class实例化


        //开始进行具体内部操作,此时我们仅仅是拿到了ReflectModel的class这个对象,而非是这个ReflectModel对象的实例
        if (modelClass3 != null) {
            //获取ReflectModel.class对应的所有构造方法(public的)
            Constructor[] constructors = modelClass3.getConstructors();
            for (Constructor constructor : constructors) {
                LogUtils.d(TAG, "当前获取的构造方法:" + constructor.getName());
            }
            LogUtils.d(TAG, "----以上是public的----");
            //所有构造方法(包括:私有、受保护、默认、公有)
            constructors = modelClass3.getDeclaredConstructors();
            for (Constructor constructor : constructors) {
                LogUtils.d(TAG, "当前获取的构造方法:" + constructor);
            }

            Object object = null;
            try {
                // 获取共有无参构造函数
                Constructor con = modelClass3.getConstructor(null);
                // 调用此无参构造方法,那么此时我们就会获取到Reflect的实例对象了(默认返回object)
                ReflectModel reflectModel = (ReflectModel) con.newInstance();
                // 有了ReflectModel对象实例,我们就可以正常使用了
                /**
                 * 但是此时我们知道,我们强制类型转成了我们想要的类型,但是我们上文中提到,有些类是hide的。
                 * 因此我们很多情况下,我们被限制只能得到object对象。
                 */
                reflectModel.fun();
                // 获取私有的含有String和int参数的构造方法
                con = modelClass3.getDeclaredConstructor(new Class[]{String.class, int.class});
                // 此时我们获取到了这个private的含参构造方法对象,但是因为private权限原因,我们没办法直接调用newInstance()
                // 我们需要调用下面的方法,无视private修饰符(调用后,我们就可以执行private的构造方法)
                con.setAccessible(true);
                //调用私有俩参构造方法
                object = con.newInstance("B", 2);

反射调用方法

                //上诉提到,如果我们反射的类是hide,此时我们肯定没办法把Object转成ReflectModel类型。因此,我们拿到这个实例后想要调用其方法,还需要使用反射的方式
                // private方法应该使用getDeclaredMethod()去获取
                Method printContent = modelClass3.getDeclaredMethod("printContent", new Class[]{});
                //同样因为private的原因,我们在执行方法时,要先清除权限问题
                printContent.setAccessible(true);
                //使用object实例对象,调用printContent方法,因为没有参数,所以传null
                printContent.invoke(object, null);
                //生成名为setContent的含有一个String参数的方法对象
                Method setContent = modelClass3.getDeclaredMethod("setContent", new Class[]{String.class});
                setContent.setAccessible(true);
                //调用setContent方法,去改变mContent的值
                setContent.invoke(object, "C");
                //再次执行打印操作
                printContent.invoke(object, null);

                //调用静态方法
                Method staticMethod = modelClass3.getMethod("staticFun", new Class[]{});
                //因为静态方法属于类,所以我们不需要传实例对象,因为它在class被加载的时候,就已经被创建了。
                staticMethod.invoke(null, null);

反射调用变量/static

                /**
                 * 反射调用变量
                 */
                //获取所有public变量封装的Field对象
                Field[] fields = modelClass3.getFields();
                //获取所有变量封装的Field对象
                fields = modelClass3.getDeclaredFields();

                //获取private的mContent的变量
                Field content = modelClass3.getDeclaredField("mContent");
                content.setAccessible(true);
                Field num = modelClass3.getField("mNum");
                num.set(object, 3);
                //获取static变量
                Field sNum = modelClass3.getField("sNum");
                LogUtils.d(TAG, "mNum在object实例对象中的值:" + num.get(object) + "-static变量sNum的值:" + sNum.get(null));
                //将object实例的mContent对象,设置为D
                content.set(object, "D");
                printContent.invoke(object, null);

                Field reflectBean = modelClass3.getDeclaredField("mReflectBean");
                Class reflectBeanClass = Class.forName("com.example.mbenben.studydemo.basenote.reflect.ReflectBean");
                Constructor beanCon = reflectBeanClass.getConstructor(new Class[]{String.class});
                Object beanObject = beanCon.newInstance("b");
                //给mReflectBean赋值
                reflectBean.setAccessible(true);
                reflectBean.set(object, beanObject);
                Method printBean = modelClass3.getMethod("printBean", new Class[]{});
                printBean.invoke(object, null);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

继续理解

我们知道JVM在使用一个类的时候,会先去加载这个类。也就是生成唯一的Class对象。这个Class对象拥有我们的java代码的变量,方法结构。但是它并不是一个实例。因此我们在反射的时候,要先获取构造方法对象,也就是Class返回给我们的Constructor。此时我们运行这个对象的newInstance,我们就初始化了这个Class,获取了这个Class的实例。(这也就是为什么我们反射操作会如此的麻烦)
实例化了这个对象之后,虽然只是一个Object对象,但是它和我们真正new的对象没有任何区别,那么此时我们就可以正常的调用方法了。
我们知道,static是属于类,在类被加载的时候就已经出现了。那么此时,反射也侧面证实了这个问题:
在我们反射调用static的变量和方法时,set或者invoke的参数传的是null,也就是说我们没有传递任何对象实例,所以此时我们使用的是这个在类被加载时就被创建的Class对象中的变量和方法,而非操作的实例对象。因此,对static是不是有了一个更为深刻的理解呢?

尾声

时隔很久都还没有写博客了,是因为自己的确不知道该写些写什么,唉,迷茫,好菜...
希望可以对各位看官有所帮助吧。


我是一个应届生,最近和朋友们维护了一个公众号,内容是我们在从应届生过渡到开发这一路所踩过的坑,已经我们一步步学习的记录,如果感兴趣的朋友可以关注一下,一同加油~

个人公众号:IT面试填坑小分队

推荐阅读更多精彩内容

  • pdf下载地址:Java面试宝典 第一章内容介绍 20 第二章JavaSE基础 21 一、Java面向对象 21 ...
  • Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具(例如配置管理,服务发现,断路器,智...
  • Android 自定义View的各种姿势1 Activity的显示之ViewRootImpl详解 Activity...
  • 就像是等一辆公交 我在这个路口 看见它从那个路口走过 离我很近 我还是追不上 我知道 命运的过错不可挽回 ...
  • 电动卷膜器用于控制各类蔬菜大棚,温室大棚、养殖大棚的塑料薄膜卷起或放开。控制大棚内的温度和日照时间,适合各种骨架大...