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