干！货！反射封装给你直接拿去用

发现已经有一个月左右没更新文章了，好吧，真的没什么好写的，一直在努力工作工作工作。突然发现以前好像没写过反射的文章，终于可以偷鸡一回了，这次，纯伸手党福利好吗，封装反射工具类，想用直接拿去用（项目地址在最下方）。

一. 反射调用

我今天找Api的时候发现一篇写得挺好的文章，https://www.jianshu.com/p/9be58ee20dee
这位大佬把大部分常用的方法都列举出来了，我就不重复写了。
并且这篇不打算写原理，纯写调用。

二. 封装

1.获取class对象

在反射中，最主要的就是class对象，无论你想反射获取参数，还是调用方法，都需要先获取到class对象，获取class对象的方法很多，我这里只写了根据name来获取

    public static Class getClass(String clsName){
        try {
            if (!TextUtils.isEmpty(clsName)){
                Class<?> cls = Class.forName(clsName);
                return cls;
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

还有一点，为什么获取Class 对象要单独拿出来做一个方法，因为有一些特殊的场景不一定能用类名来获取到Class 对象，比如一些插件化框架，有提供自己的获取Class 对象的方法，所以需要单独封装成一个方法。

2.调用构造方法

封装调用构造方法，主要用到Constructor

    public static Object getConstructor(Class cls, Class[] paramsType, Object[] params){
        Object result = null;
        try {
            if (cls != null){
                Constructor constructor = cls.getConstructor(paramsType);
                result = constructor.newInstance(params);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

可以简单看看getConstructor和newInstance源码

    public Constructor<T> getConstructor(Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException {
        return getConstructor0(parameterTypes, Member.PUBLIC);
    }

    public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
    {
        if (serializationClass == null) {
            return newInstance0(initargs);
        } else {
            return (T) newInstanceFromSerialization(serializationCtor, serializationClass);
        }
    }

一个是传Class不定参数，另一个是传Object不定参数，所以我这边封装的时候定义了两个数组参数。
调用的时候

            Class[] clsA = new Class[]{String.class};
            Object[] objA = new Object[]{"参数1"};
            BaseReflectUtils.getConstructor(cls, clsA, objA);

其实调用无参的构造方法也可以直接使用newInstance方法

cls.newInstance()
3.获取参数

反射获取参数，也就是调用静态变量，用到Field
可能网上一般会这样写

Field daf = cls.getField(fname);
result = daf.get(null);

但是如果你直接这样使用的话，你会发现，静态参数能正常调用，非静态参数你就拿不到值了，如果稍微了解一点原理的话就知道为什么了。get方法传的参数是对象，哪个对象的参数，静态参数不用对象，所以可以直接传null。那么可以这样写

    public static Object getField(Class cls, String fname){
        return getField(cls, fname, null);
    }

    public static Object getField(Class cls, String fname, Object obj){
        Object result = null;
        try {
            Field daf = cls.getField(fname);
            // 反射静态参数直接传空就行，反射非静态参数要使用相对应的对象
            result = daf.get(obj);
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

静态参数就调第一个方法，非静态就调下面的并传入对象。

4.调用方法

调用方法用的是Method
一般写

            Method method = cls.getMethod(mname, paramsType);
            object = method.invoke(obj, params);

但是要考虑静态和非静态的情况，静态和非静态其实就是像上面一样区别在于是否需要对象。还要考虑是否要传参数，也是和上面一样，区别在于是不是会多出两个参数，所以我这边这样写。

    // 静态无参
    public static Object getMethod(Class cls, String mname){
        return getMethod(cls, mname, null, null, null);
    }

    // 静态有参
    public static Object getMethod(Class cls, String mname, Class[] paramsType, Object[] params){
        return getMethod(cls, mname, paramsType, params, null);
    }

    // 非静态无参
    public static Object getMethod(Class cls, String mname, Object obj){
        return getMethod(cls, mname, null, null, obj);
    }

    public static Object getMethod(Class cls, String mname, Class[] paramsType, Object[] params, Object obj){
        Object object = null;
        try {
            Method method = cls.getMethod(mname, paramsType);
            object = method.invoke(obj, params);
        }catch (Exception e){
            e.printStackTrace();
        }
        return object;
    }

我就只举个栗子，非静态有参数的情况就这样调用

Class cls = BaseReflectUtils.getClass("com.kylim.fstest.TestD");
Object obj = BaseReflectUtils.getConstructor(cls,new Class[0], new Object[0]);
Class[] clsA = new Class[]{int.class};
Object[] objA = new Object[]{101};
String result = (String) BaseReflectUtils.getMethod(cls, "testTwo", clsA, objA, obj);

会发现传的参数有那么一点多，如果你觉得不好看，可以封装个链式调用

    public static class Builder{

        private Class cls;
        private String mname;
        private Class[] paramsType;
        private Object[] params;
        private Object obj;

        public Builder setCls(Class cls) {
            this.cls = cls;
            return this;
        }

        public Builder setMname(String mname) {
            this.mname = mname;
            return this;
        }

        public Builder setParamsType(Class[] paramsType) {
            this.paramsType = paramsType;
            return this;
        }

        public Builder setParams(Object[] params) {
            this.params = params;
            return this;
        }

        public Builder setObj(Object obj) {
            this.obj = obj;
            return this;
        }

        public Object build(){
            // 类名和方法名不能为空
            if (cls == null || TextUtils.isEmpty(mname)){
                return null;
            }

            return getMethod(cls, mname, paramsType, params, obj);
        }

    }

这样调用的时候

            String result = (String) new BaseReflectUtils.Builder().setCls(cls)
                    .setMname("testTwo")
                    .setParamsType(new Class[]{int.class})
                    .setParams(new Object[]{101})
                    .setObj(BaseReflectUtils.getConstructor(cls,new Class[0], new Object[0]))
                    .build();

确实参数会有点多，会让人有一种封不封装没啥区别，首先封装的话有利于之后的扩展，其次，你可以对常用的反射（固定的名字或参数类型这些）就行二次封装。

5. 调用子类

上面已经讲了最基础的调用参数和方法两种，下面就相当于扩展，如果存在子类的情况呢，要如何进行封装。
在反射中获取子类需要用到getClasses方法
可以这样写

    public static Class getChildClass(String clsName, String childClsName){
        try {
            if (!TextUtils.isEmpty(clsName)){
                Class<?> cls = Class.forName(clsName);
                Class[] children = cls.getClasses();
                if (children != null && !TextUtils.isEmpty(childClsName)){
                    for (int i = 0; i < children.length; i++) {
                        if (childClsName.equals(children[i].getSimpleName())){
                            return children[i];
                        }
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

在外部可以调用

 Class cls = KlReflectUtils.getChildClass("com.kylim.fstest.TestE", "ChildTestE");

这样就能获取到对应的Class 对象，有了Class 对象之后，你想怎么反射就可以参照上边。

6. 单例

平时写代码时也会用到单例，反射写得不多的话，可能一碰到单例就有点蒙了。
其实单例也是获取到对象然后调用对象的方法。
假设我写这样的一个单例

public class TestF {

    private static volatile TestF testF;

    public static TestF getInstance() {
        if (testF == null) {
            synchronized (TestF.class) {
                if (testF == null) {
                    testF = new TestF();
                }
            }
        }
        return testF;
    }

    public void testOne(){
        Log.v("testOne", "调用testOne");
    }

}

平时直接引用的情况是这样写

TestF.getInstance().testOne()

在反射中结合我们上面的封装，我们可以这样写

            Class cls = BaseReflectUtils.getClass("com.kylim.fstest.TestF");
            BaseReflectUtils.getMethod(cls, "testOne", BaseReflectUtils.getMethod(cls, "getInstance"));

BaseReflectUtils.getMethod(cls, "getInstance")就是对象

7.Builder模式

最后说一个特殊的栗子，Builder模式有时也会常用，比如参数多的时候，这样对Builder模式的对象进行反射的话就有点蛋疼，我们举个栗子。
假如我写个Builder类

public class TestG {

    private TestG(){

    }

    private TestG(Builder builder){
        Log.v("TestG", "结果："+builder.code+"  "+builder.msg);
    }

    public static class Builder{

        private int code;
        private String msg;

        public Builder setCode(int code) {
            this.code = code;
            return this;
        }

        public Builder setMsg(String msg) {
            this.msg = msg;
            return this;
        }

        public TestG build(){
            return new TestG(this);
        }

    }

}

这个Demo里面假设有两个参数，实际上肯定不止两个，因为两个就没必要用Builder。
那么，我们写反射的时候需要这样写

Class cls = KlReflectUtils.getChildClass("com.kylim.fstest.TestG", "Builder");
// 构造方法
Object obj = BaseReflectUtils.getConstructor(cls, new Class[0], new Object[0]);

// 调用第一个方法
Class[] clsA = new Class[]{int.class};
Object[] objA = new Object[]{200};
Object obj1 =  BaseReflectUtils.getMethod(cls, "setCode", clsA, objA, obj);
// 调用第二个方法
Class[] clsB = new Class[]{String.class};
Object[] objB = new Object[]{"请求成功"};
Object obj2 =  BaseReflectUtils.getMethod(cls, "setMsg", clsB, objB, obj1);
// 调用第三个方法
BaseReflectUtils.getMethod(cls, "build", obj2);

可以看到才2个参数就需要写这么多代码，参数多的话到时候改其中一个，找到都烦了，所以需要封装一下。

    /**
     *  Builder模式的反射
     */
    public static class Builder{

        private Class cls;
        private Object object;

        public Builder(Class cls, Object obj){
            this.cls = cls;
            this.object = obj;
        }

        public Builder setBuilderData(String mname, Class[] paramsType, Object[] params){
            object = BaseReflectUtils.getMethod(cls, mname, paramsType, params, object);
            return this;
        }

        public Object build(){
            return build(null, null);
        }

        public Object build(Class[] paramsType, Object[] params){
            return BaseReflectUtils.getMethod(cls, "build", paramsType, params, object);
        }

    }

我这里用Builder来封装，每个人都可以根据自己的喜好来做
然后我们调用的时候，就可以写成这样

        new KlReflectUtils.Builder(cls, obj)
                .setBuilderData( "setCode", new Class[]{int.class}, new Object[]{200})
                .setBuilderData( "setMsg", new Class[]{String.class}, new Object[]{"请求成功"})
                .build();

如果有10个参数的话就这样

        new KlReflectUtils.Builder(cls, obj)
                .setBuilderData( "setCode", new Class[]{int.class}, new Object[]{200})
                .setBuilderData( "setMsg", new Class[]{String.class}, new Object[]{"请求成功"})
                .setBuilderData( .......)
                .setBuilderData( .......)
                .setBuilderData( .......)
                .setBuilderData( .......)
                .setBuilderData( .......)
                .setBuilderData( .......)
                .setBuilderData( .......)
                .setBuilderData( .......)
                .build();

三. 代码地址

直接上地址，想用的可以直接去拿来用，主要是BaseReflectUtils和KlReflectUtils，BaseReflectUtils是基本的反射的封装，KlReflectUtils是对常用的进行二次封装，其实代码并不多。

https://github.com/994866755/handsomeYe.reflectDemo/tree/master

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 216,402评论 6赞 499
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,377评论 3赞 392
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 162,483评论 0赞 353
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,165评论 1赞 292
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,176评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,146评论 1赞 297
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,032评论 3赞 417
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,896评论 0赞 274
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,311评论 1赞 310
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,536评论 2赞 332
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,696评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,413评论 5赞 343
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,008评论 3赞 325
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,659评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,815评论 1赞 269
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,698评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,592评论 2赞 353