Java反射的优雅使用

最新推荐文章于 2024-11-08 23:31:31 发布
最新推荐文章于 2024-11-08 23:31:31 发布
阅读量129 收藏
点赞数
文章标签： java android 安卓
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suniot/article/details/132642092
版权

安卓9开始限制反射的调用，但是带系统签名或者内置系统的应用是可以豁免的 。

或者使用第三方库突破这个限制：

tiann/FreeReflection: A library that lets you use reflection without any restriction above Android P

如何使用

假设有一个Person类

package com.wesley.app;

public class Person {
    private  String name;
    private  int age;

    private static int num = 0;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        num++;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

替换一个实例中的字段

Person person = new Person("Wesley", 25);
try {
    Reflector.with(person).field("age").set(28);
} catch (Reflector.ReflectedException e) {
    e.printStackTrace();
}

调用一个实例中对应的方法

try {
	//无参数
    Reflector.with(person).method("getAge").call();
    //有参数
    Reflector.with(person).method("setAge", int.class).call(26);
} catch (Reflector.ReflectedException e) {
    e.printStackTrace();
}

获取静态变量

try {
    Reflector.on(Person.class).field("num").get();
} catch (Reflector.ReflectedException e) {
    e.printStackTrace();
}

生成实例对象

try {
    Person tom = Reflector.on(Person.class).constructor(String.class, int.class).newInstance("Tom", 18);
} catch (Reflector.ReflectedException e) {
    e.printStackTrace();
}

调用通过反射生成的实例的方法

try {
    Reflector reflector = Reflector.on(Person.class);
    Person tom = reflector.constructor(String.class, int.class).newInstance("Tom", 18);
    
    reflector.field("age").get(tom);
    reflector.method("getAge").callByCaller(tom); 
    //或者
    reflector.bind(tom);
    reflector.field("age").get();
    reflector.method("getAge").call();
} catch (Reflector.ReflectedException e) {
    e.printStackTrace();
}

Reflector工具类

https://github.com/didi/VirtualAPK/blob/master/CoreLibrary/src/main/java/com/didi/virtualapk/utils/Reflector.java

package com.wesley.sdk.helper.util;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * Created by qiaopu on 2018/4/26.
 */
public class Reflector {
    
    public static final String TAG =  "Reflector";
    
    protected Class<?> mType;
    protected Object mCaller;
    protected Constructor mConstructor;
    protected Field mField;
    protected Method mMethod;
    
    public static class ReflectedException extends Exception {
    
        public ReflectedException(String message) {
            super(message);
        }
        public ReflectedException(String message, Throwable cause) {
            super(message, cause);
        }
    
    }
    public static Reflector on(@NonNull String name) throws ReflectedException {
        return on(name, true, Reflector.class.getClassLoader());
    }
    
    public static Reflector on(@NonNull String name, boolean initialize) throws ReflectedException {
        return on(name, initialize, Reflector.class.getClassLoader());
    }
    
    public static Reflector on(@NonNull String name, boolean initialize, @Nullable ClassLoader loader) throws ReflectedException {
        try {
            return on(Class.forName(name, initialize, loader));
        } catch (Throwable e) {
            throw new ReflectedException("Oops!", e);
        }
    }
    
    public static Reflector on(@NonNull Class<?> type) {
        Reflector reflector = new Reflector();
        reflector.mType = type;
        return reflector;
    }
    
    public static Reflector with(@NonNull Object caller) throws ReflectedException {
        return on(caller.getClass()).bind(caller);
    }
    
    protected Reflector() {
    
    }
    
    public Reflector constructor(@Nullable Class<?>... parameterTypes) throws ReflectedException {
        try {
            mConstructor = mType.getDeclaredConstructor(parameterTypes);
            mConstructor.setAccessible(true);
            mField = null;
            mMethod = null;
            return this;
        } catch (Throwable e) {
            throw new ReflectedException("Oops!", e);
        }
    }
    
    @SuppressWarnings("unchecked")
    public <R> R newInstance(@Nullable Object ... initargs) throws ReflectedException {
        if (mConstructor == null) {
            throw new ReflectedException("Constructor was null!");
        }
        try {
            return (R) mConstructor.newInstance(initargs);
        } catch (InvocationTargetException e) {
            throw new ReflectedException("Oops!", e.getTargetException());
        } catch (Throwable e) {
            throw new ReflectedException("Oops!", e);
        }
    }
    
    protected Object checked(@Nullable Object caller) throws ReflectedException {
        if (caller == null || mType.isInstance(caller)) {
            return caller;
        }
        throw new ReflectedException("Caller [" + caller + "] is not a instance of type [" + mType + "]!");
    }
    
    protected void check(@Nullable Object caller, @Nullable Member member, @NonNull String name) throws ReflectedException {
        if (member == null) {
            throw new ReflectedException(name + " was null!");
        }
        if (caller == null && !Modifier.isStatic(member.getModifiers())) {
            throw new ReflectedException("Need a caller!");
        }
        checked(caller);
    }
    
    public Reflector bind(@Nullable Object caller) throws ReflectedException {
        mCaller = checked(caller);
        return this;
    }
    
    public Reflector unbind() {
        mCaller = null;
        return this;
    }
    
    public Reflector field(@NonNull String name) throws ReflectedException {
        try {
            mField = findField(name);
            mField.setAccessible(true);
            mConstructor = null;
            mMethod = null;
            return this;
        } catch (Throwable e) {
            throw new ReflectedException("Oops!", e);
        }
    }
    
    protected Field findField(@NonNull String name) throws NoSuchFieldException {
        try {
            return mType.getField(name);
        } catch (NoSuchFieldException e) {
            for (Class<?> cls = mType; cls != null; cls = cls.getSuperclass()) {
                try {
                    return cls.getDeclaredField(name);
                } catch (NoSuchFieldException ex) {
                    // Ignored
                }
            }
            throw e;
        }
    }
    
    @SuppressWarnings("unchecked")
    public <R> R get() throws ReflectedException {
        return get(mCaller);
    }
    
    @SuppressWarnings("unchecked")
    public <R> R get(@Nullable Object caller) throws ReflectedException {
        check(caller, mField, "Field");
        try {
            return (R) mField.get(caller);
        } catch (Throwable e) {
            throw new ReflectedException("Oops!", e);
        }
    }
    
    public Reflector set(@Nullable Object value) throws ReflectedException {
        return set(mCaller, value);
    }
    
    public Reflector set(@Nullable Object caller, @Nullable Object value) throws ReflectedException {
        check(caller, mField, "Field");
        try {
            mField.set(caller, value);
            return this;
        } catch (Throwable e) {
            throw new ReflectedException("Oops!", e);
        }
    }
    
    public Reflector method(@NonNull String name, @Nullable Class<?>... parameterTypes) throws ReflectedException {
        try {
            mMethod = findMethod(name, parameterTypes);
            mMethod.setAccessible(true);
            mConstructor = null;
            mField = null;
            return this;
        } catch (NoSuchMethodException e) {
            throw new ReflectedException("Oops!", e);
        }
    }
    
    protected Method findMethod(@NonNull String name, @Nullable Class<?>... parameterTypes) throws NoSuchMethodException {
        try {
            return mType.getMethod(name, parameterTypes);
        } catch (NoSuchMethodException e) {
            for (Class<?> cls = mType; cls != null; cls = cls.getSuperclass()) {
                try {
                    return cls.getDeclaredMethod(name, parameterTypes);
                } catch (NoSuchMethodException ex) {
                    // Ignored
                }
            }
            throw e;
        }
    }
    
    public <R> R call(@Nullable Object... args) throws ReflectedException {
        return callByCaller(mCaller, args);
    }
    
    @SuppressWarnings("unchecked")
    public <R> R callByCaller(@Nullable Object caller, @Nullable Object... args) throws ReflectedException {
        check(caller, mMethod, "Method");
        try {
            return (R) mMethod.invoke(caller, args);
        } catch (InvocationTargetException e) {
            throw new ReflectedException("Oops!", e.getTargetException());
        } catch (Throwable e) {
            throw new ReflectedException("Oops!", e);
        }
    }
    
    public static class QuietReflector extends Reflector {
        
        protected Throwable mIgnored;
    
        public static QuietReflector on(@NonNull String name) {
            return on(name, true, QuietReflector.class.getClassLoader());
        }
    
        public static QuietReflector on(@NonNull String name, boolean initialize) {
            return on(name, initialize, QuietReflector.class.getClassLoader());
        }
    
        public static QuietReflector on(@NonNull String name, boolean initialize, @Nullable ClassLoader loader) {
            Class<?> cls = null;
            try {
                cls = Class.forName(name, initialize, loader);
                return on(cls, null);
            } catch (Throwable e) {
//                Log.w(LOG_TAG, "Oops!", e);
                return on(cls, e);
            }
        }
    
        public static QuietReflector on(@Nullable Class<?> type) {
            return on(type, (type == null) ? new ReflectedException("Type was null!") : null);
        }
    
        private static QuietReflector on(@Nullable Class<?> type, @Nullable Throwable ignored) {
            QuietReflector reflector = new QuietReflector();
            reflector.mType = type;
            reflector.mIgnored = ignored;
            return reflector;
        }
    
        public static QuietReflector with(@Nullable Object caller) {
            if (caller == null) {
                return on((Class<?>) null);
            }
            return on(caller.getClass()).bind(caller);
        }
        
        protected QuietReflector() {
            
        }
    
        public Throwable getIgnored() {
            return mIgnored;
        }
    
        protected boolean skip() {
            return skipAlways() || mIgnored != null;
        }
        
        protected boolean skipAlways() {
            return mType == null;
        }
    
        @Override
        public QuietReflector constructor(@Nullable Class<?>... parameterTypes) {
            if (skipAlways()) {
                return this;
            }
            try {
                mIgnored = null;
                super.constructor(parameterTypes);
            } catch (Throwable e) {
                mIgnored = e;
//                Log.w(LOG_TAG, "Oops!", e);
            }
            return this;
        }
    
        @Override
        public <R> R newInstance(@Nullable Object... initargs) {
            if (skip()) {
                return null;
            }
            try {
                mIgnored = null;
                return super.newInstance(initargs);
            } catch (Throwable e) {
                mIgnored = e;
//                Log.w(LOG_TAG, "Oops!", e);
            }
            return null;
        }
    
        @Override
        public QuietReflector bind(@Nullable Object obj) {
            if (skipAlways()) {
                return this;
            }
            try {
                mIgnored = null;
                super.bind(obj);
            } catch (Throwable e) {
                mIgnored = e;
//                Log.w(LOG_TAG, "Oops!", e);
            }
            return this;
        }
    
        @Override
        public QuietReflector unbind() {
            super.unbind();
            return this;
        }
    
        @Override
        public QuietReflector field(@NonNull String name) {
            if (skipAlways()) {
                return this;
            }
            try {
                mIgnored = null;
                super.field(name);
            } catch (Throwable e) {
                mIgnored = e;
//                Log.w(LOG_TAG, "Oops!", e);
            }
            return this;
        }
    
        @Override
        public <R> R get() {
            if (skip()) {
                return null;
            }
            try {
                mIgnored = null;
                return super.get();
            } catch (Throwable e) {
                mIgnored = e;
//                Log.w(LOG_TAG, "Oops!", e);
            }
            return null;
        }
    
        @Override
        public <R> R get(@Nullable Object caller) {
            if (skip()) {
                return null;
            }
            try {
                mIgnored = null;
                return super.get(caller);
            } catch (Throwable e) {
                mIgnored = e;
//                Log.w(LOG_TAG, "Oops!", e);
            }
            return null;
        }
    
        @Override
        public QuietReflector set(@Nullable Object value) {
            if (skip()) {
                return this;
            }
            try {
                mIgnored = null;
                super.set(value);
            } catch (Throwable e) {
                mIgnored = e;
//                Log.w(LOG_TAG, "Oops!", e);
            }
            return this;
        }
    
        @Override
        public QuietReflector set(@Nullable Object caller, @Nullable Object value) {
            if (skip()) {
                return this;
            }
            try {
                mIgnored = null;
                super.set(caller, value);
            } catch (Throwable e) {
                mIgnored = e;
//                Log.w(LOG_TAG, "Oops!", e);
            }
            return this;
        }
    
        @Override
        public QuietReflector method(@NonNull String name, @Nullable Class<?>... parameterTypes) {
            if (skipAlways()) {
                return this;
            }
            try {
                mIgnored = null;
                super.method(name, parameterTypes);
            } catch (Throwable e) {
                mIgnored = e;
//                Log.w(LOG_TAG, "Oops!", e);
            }
            return this;
        }
    
        @Override
        public <R> R call(@Nullable Object... args)  {
            if (skip()) {
                return null;
            }
            try {
                mIgnored = null;
                return super.call(args);
            } catch (Throwable e) {
                mIgnored = e;
//                Log.w(LOG_TAG, "Oops!", e);
            }
            return null;
        }
    
        @Override
        public <R> R callByCaller(@Nullable Object caller, @Nullable Object... args) {
            if (skip()) {
                return null;
            }
            try {
                mIgnored = null;
                return super.callByCaller(caller, args);
            } catch (Throwable e) {
                mIgnored = e;
//                Log.w(LOG_TAG, "Oops!", e);
            }
            return null;
        }
    }
}
锋风Fengfeng
关注
通过Java反射让Android优雅起来
weixin_44595763的博客
06-28 172
Android也可以这样优雅 一、前言 本编我介绍如何利用Java反射原理去设计IOC注入，遵循享元模式设置IOC容器，并且如何利用Java反射的原理对MVP繁琐的回调方法进行优化。这是我写的一个多芬音乐的例子dfMusic。 希望大家参数这篇优秀文章 IOC注入. 二、IOC注入 要想让人容易理解，最好的办法是举个栗子，所有废话不多说展示代码。 public class FragmentMy extends BaseFragment { //下面的代码，与findViewById是等价的
如何优雅的使用反射（一）
lmy19940716的博客
09-27 408
如何优雅的使用反射（一） 如何优雅的使用反射   相信每一位接触过Java的同学对于反射都不陌生。作为一种从更高维度操纵代码的方式，反射通常被用于实现Java上的Hook技术。   然而反射的使用方式也不难，随便一Google 就有一堆文章。所以本文将不再累述反射的Api与原理等概念，而是从使用者的角度出发，站在Coder的角度上去观察如何优雅的写出反射代码。 常见的反射写法 public class ReflexDemo { private int mId
java 反射的使用_Java反射的两种使用方法(推荐)
weixin_34394265的博客
02-12 347
1.创建User.javapackage com.tao.test;public class User {private String name;private int id;public User() {}public String getName() {return name;}public void setName(String name) {this.name = name;}public...
推荐一个简化反射操作代码的优雅写法
qwe851023的博客
09-19 588
Java 中反射的写法和相关第三方封装库虽然很多，但还是钟爱于 JOOR，啥都不说，先上链接 https://github.com/jOOQ/jOOR。 这个库用了好几年了，就一个字，爽！为什么呢？因为其小巧精致，小巧到只有一个 Java 文件，精致到写出来的代码很优雅。 首先我们回顾下 Java 原生提供的反射写法，比如我们想要调 DataManager 的静态方法 get，如下： tr...
由VirtualAPK了解插件化原理（一）
milan-xiao-tiejiang的博客
04-05 399
上篇了解了热修复原理，热修复技术主要用来修复bug，插件化则主要解决应用越来越庞大以及功能模块的解耦。插件化处理两部分业务，一种是自身的业务模块，一种是接入其他的应用业务。这种方式在淘宝、支付宝、美团、滴滴、360 等航母应用上十分常见。代表方案有阿里的 Atlas、360 的 RePlugin、滴滴的 VirtualAPK 等。 插件化的apk分为宿主和插件两部分组成，先被安装到手机中的apk...
Java8之反射
CRUD工程师
02-12 979
参考资料： 《Java 基础 - 反射机制详解》 《Java中Class对象详解》 《java基础：深入理解Class对象与反射机制》 《java反射机制》 《Java基础之—反射》
Java中反射的基本使用
xiaoko81
05-27 211
开宗明义 反射的优点和好处: 反射可以很灵活的操作一个类，甚至这种方式在某种方面我愿称之为优雅。 Step 1.准备一个类，取名为ConstructorCollector public class ConstructorCollector { ConstructorCollector() { System.out.println("====初始化 No Args========"); } ConstructorCollector(int intArgs, Str
java反射 数组类型_Java反射-数组
weixin_39779537的博客
02-12 1193
通过反射使用数组有时会比较棘手。特别是需要获得一个特定类型数组的Class对象，如int[]等。本文将讨论如何通过反射创建数组和获得他们的Class对象。注意：本文在阅读Eyal Lupu的博客"Two Side Notes About Arrays and Reflection"后已更新，他的博客是本文第一个版本的评论。当前版本考虑了他的评论内容。java.lang.reflect.Array数...
java反射介绍、使用、获取成员变量、获取成员方法执行
wang_yi_l的博客
08-06 1920
反射在java中是非常强大的一个技术，很多框架内部都使用到了反射。 一、反射是什么，如何理解？ 反射中包含了一个“反”字，要理解“反”的意思，就要知道“正”的意思。一般情况下我们使用某个类的时候都知道这是什么类，用来做什么，如何初始化，有什么属性和方法，例如有一个User类： public class User { private Long userId; private String userName; public String sex; public User(){
Java 反射佳实践
12-22
jOOR是一个简洁的Java反射API，它提供了一种更优雅的方式来处理反射任务。例如，使用jOOR，上述代码可以简化为： ```java // 使用jOOR简化反射创建对象 public static <T> T create(HttpRequest httpRequest) { ...
java反射和注解开发（备java基础，javaee框架原理）
06-09
Java反射和注解是Java开发中的重要特性，它们在现代Java EE框架中起着至关重要的作用。本文将深入探讨这两个概念及其在实际开发中的应用。 首先，Java反射机制允许程序在运行时动态地获取类的信息并操作类的对象。...
Java利用反射机制简化使用DAO
mo7984130的博客
12-18 300
Java利用反射机制简化使用DAO
java面试：反射和动态代理的区别
iOS逆向与安全
02-28 185
原因：spring 在扫描bean的时候会扫描方法上是否包含@Transactional注解，如果包含，spring会为这个bean动态地生成一个子类（即代理类，proxy），代理类是继承原来那个bean的。然而，如果这个有注解的方法是被同一个类中的其他方法调用的，那么该方法的调用并没有通过代理类，而是直接通过原来的那个bean，所以就不会启动transaction，看到的现象就是@Transactional注解无效。反射用于获取某个包下面类的信息：比如获取特定包下的枚举信息，提供接口给前端使用。
java spring 反射调用方法参数_java通过反射调用有参数的方法
weixin_42591908的博客
02-13 1749
public static void eachCfg(Class Initclass,String taskType){Field[] fields = Initclass.getDeclaredFields(); //获取属性try {for (Field field : fields) {field.setAccessible(true);if(field.getType().toStri...
spring循环依赖解决方式
qq_36400213的博客
11-04 889
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
JAVA-01-变量
LJH_laura_li的博客
11-08 158
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 38
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
JAVA学习接口案例实例
最新发布
shangan_3的博客
11-08 98
【代码】JAVA学习接口案例实例。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 417
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值