反射

什么是反射，反射有什么用，反射该怎么用？

一些概念性的东西，这里就不细说了，下面主要给出一个非常简单的反射的调用工具类；

后续会提供一个基于Spring框架的反射工具类，主要用于反射代理bean对象，执行相关的方法

这样有什么好处？

设想一下，你的工程运行在Spring框架上，你需要实时查看某些方法的返回结果的时候，可以怎么办?

在工程上开一个端口，接手外部传入的参数，利用反射去执行某些类的方法，并将结果打印出来，这样的工具是不是很赞？

一个实例工程

1. Params 类

反射相关的信息（类名，方法名，参数对象）---》 有了这些东西才能唯一的指定要执行的目的

传入给程序的是一个String类型的参数，对其进行解析，获取传说

2. ParamUtil 即params 的解析工具，用于获取上面的参数

传入给程序的是一个String类型的参数，对其进行解析，获取params对象; 还有一个方法则是对方法的参数进行解析

这里对于基本类型和封装类型的处理比较初级，可以尝试让两者可以兼容，灵活的处理一些方法

package com.mushroom.hui.common.invoke;import com.alibaba.fastjson.JSON;import org.apache.commons.lang.StringUtils;import org.springframework.util.CollectionUtils;import java.util.HashMap;import java.util.Map;/** * Created by hui on 16/4/10. */public class ParamUtil {    private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(ParamUtil.class);    /**     * 将传入的参数,转换为Params对象     * @param strPamras  {"target":"invoke","class":"com.mushroom.hui.test.biz.Calculate","method":"add","parameter":"10"}     * @return     */    public static Params buildParams(String strPamras) {        if (StringUtils.isBlank(strPamras)) {            return null;        }        try {            Map
    
      map = JSON.parseObject(strPamras, Map.class);            if (CollectionUtils.isEmpty(map)) {                return null;            }            Params params = new Params();            params.setTarget(map.get("target"));            params.setCls(map.get("class"));            params.setMethod(map.get("method"));            String args = map.get("params");            if (StringUtils.isBlank(args)) {                return params;            }            Map
     
       argMap = JSON.parseObject(args, Map.class);            params.setParams(argMap);            return params;        }catch (Exception e) {            logger.error("parse params to object error!");            logger.error("Exception: {}", e);            return  null;        }    }    /**     * 获取反射的方法对应参数信息     * @param params 传入的反射信息     * @param argTypes 参数类型     * @param argValues 参数value     * @return true 表示解析成功; false 表示解析失败     */    public static boolean buildArgInfos(Params params, Class
      [] argTypes, Object[] argValues) {        Map
      
        argus = params.getParams();        try {            Class
        clz;            String value;            int index = 0;            for (Map.Entry
       
         arg : argus.entrySet()) {                clz = getBaseClass(arg.getKey());                argTypes[index] = clz;                value = arg.getValue();                argValues[index++] = JSON.parseObject(value, clz);            }            return true;        } catch (Exception e) {            return false;        }    }    private static Map
        
         > baseClass;    static {        baseClass = new HashMap<>(8);        baseClass.put("short", short.class);        baseClass.put("int", int.class);        baseClass.put("long", long.class);        baseClass.put("byte", byte.class);        baseClass.put("float", float.class);        baseClass.put("double", double.class);        baseClass.put("boolean", boolean.class);        baseClass.put("char", char.class);    }    private static Class
          getBaseClass(String arg) throws ClassNotFoundException {        if (StringUtils.isBlank(arg)) {            return null;        }        if (baseClass.containsKey(arg)) {            return baseClass.get(arg);        } else {            return Class.forName(arg);        }    }}
        
       
      
     
    

3. InvokeUtil 具体的反射执行方法

下面的代码有几个缺陷：

• 要求反射代理的方法必须有无参构造函数
• 对于基本类型和封装类型处理得不够友好

（add(int, int)与add(Integer, Integer) 被认为两个不同的方法，其实一般也确实是两种不同的方法，很明显的与我们的认知是不一样的）

package com.mushroom.hui.common.invoke;import java.lang.reflect.Method;/** * Created by hui on 16/4/10. */public class InvokeUtil {    private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(InvokeUtil.class);    public static Object invoke(String strParams) {        Params params = ParamUtil.buildParams(strParams);        if (params == null || ! params.isValiad()) {            return null;        }        try {            Class clz = Class.forName(params.getCls());            Object obj = clz.newInstance(); // 无参构造函数必须要有            int size = params.getParams().size();            if (size == 0) { // 没有参数                Method method = clz.getMethod(params.getMethod());                Object ans = method.invoke(obj);                return ans;            }            Class
    [] argTypes = new Class
    [size];            Object[] argValues = new Object[size];            if (!ParamUtil.buildArgInfos(params, argTypes, argValues)) {                return null;            }            Method method = clz.getMethod(params.getMethod(), argTypes);            Object ans = method.invoke(obj, argValues);            return ans;        } catch (Exception e) {            e.printStackTrace();        }        return false;    }}

测试方法

package com.mushroom.hui.test.biz;import java.util.List;/** * Created by yihui on 16/4/10. */public class Calculate {    public int add(int num) {        return num << 2;    }    public String array(List
    
      list, int size) {        String str = list.toString();        return str + " size: " + size;    }}package com.mushroom.hui.test.invoke;import com.alibaba.fastjson.JSON;import com.mushroom.hui.common.invoke.InvokeUtil;import com.mushroom.hui.common.invoke.ParamUtil;import com.mushroom.hui.common.invoke.Params;import org.junit.Test;import java.lang.reflect.Method;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;/** * Created by hui on 16/4/10. */public class InvokeTest {    private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(InvokeTest.class);    @Test    public void invokeTest() {        String clz = "com.mushroom.hui.test.biz.Calculate";        String mtd = "add";        try {            Class cls = Class.forName(clz);            Method[] methods = cls.getDeclaredMethods();            Method method = cls.getMethod(mtd, int.class);            Object ans = method.invoke(cls.newInstance(), 20);            logger.info("The ans is : {}", ans);        } catch (Exception e) {            e.printStackTrace();            logger.warn("e: {}", e);        }    }    private String getAddArg() {        Map
     
       map = new HashMap<>(3);        map.put("target", "invoke");        map.put("class", "com.mushroom.hui.test.biz.Calculate");        map.put("method", "add");        Map
      
        args = new HashMap<>();        args.put("java.lang.Integer", "10");        map.put("params", JSON.toJSONString(args));        String strParams = JSON.toJSONString(map);        System.out.println(strParams);        return strParams;    }    private String getArrayArg() {        Map
       
         map = new HashMap<>(3);        map.put("target", "invoke");        map.put("class", "com.mushroom.hui.test.biz.Calculate");        map.put("method", "array");        List
        
          list = new ArrayList<>();        list.add("123");        list.add("hello");        list.add("world");        Map
         
           args = new HashMap<>(); args.put("java.util.List", JSON.toJSONString(list)); args.put("int", "100"); map.put("params", JSON.toJSONString(args)); String strParams = JSON.toJSONString(map); System.out.println(strParams); return strParams; } @Test public void paramsTest() { // invoke Object obj = InvokeUtil.invoke(getAddArg()); System.out.println(obj); obj = InvokeUtil.invoke(getArrayArg()); System.out.println(obj); }}
         
        
       
      
     
    

实例场景 & 代码分析

上面贴出了代码，但是这些代码是干嘛用的，为什么要这么用，这样拥有什么好处呢，又可以用在什么地方呢

从上面的代码出发，一个一个分析

1. Params 类

Params类中存储了一些有意思的东西，我们主要的聚焦点放在 cls，method和params上，这三个也是我们必须的参数

• cls： 表示的是要反射调用的类，比如 com.mushroom.hui.test.biz.Calculate, 全路径的类名
• method：待反射类中的方法名
• params：是一个map，存的是方法参数的value以及类型

有上面的三个东西，就可以利用jdk的放射相关类来完成调用，大致的流程是：

• 根据 cls 可以创建一个指定类的对象
• 根据method和cls以及参数类型来获取method对象
• 通过执行method的invoke方法就可以完成改方法的调用

2. ParamUtil 类

其实通过上面的说明，我们也就知道实现反射的大致流程了，util类则只是一个工具类，将String封装为上面的Params对象，解析参数的类型和value

我们设定的传入字符串形式的参数，其格式为：

{    "target": "invoke",    "class": "com.mushroom.hui.test.biz.Calculate",    "method": "array",    "params": {        "int": "100",        "java.util.List": [            "123",            "hello",            "world"        ]    }}

从json字符串反序列化，从上面的结构中可以很容易的创建一个Parmas对象，对此我们可以很容易的get到 class, method

而对于方法的参数 params，则稍稍有点特殊

因为在具体的确定Method对象的时候，我们需要知道参数的类型；而在执行方法的时候，我们则是需要参数的value

因此，我们需要从上面的json串中获得 参数类型列表 & 参数value列表

也就是com.mushroom.hui.common.invoke.ParamUtil#buildArgInfos的目的，具体怎么玩的可以看上面的代码

需要注意的一点是基本类型和封装类型之间是有区别的，特别是在获取Method对象的时候

todo:如何优化一下基本类型和封装类型，保证两者最终的效果一致？

3. InvokeUtil 具体的反射调用工具类

这个类的作用其实很清晰了，传入参数，返回反射调用的结果，基本流程就是上面列的：

• 根据Json字符串获取Params对象
• 根绝Params对象 创建反射实例对象；方法的Method对象，参数类型&参数值
• 具体执行
• 返回结果

注意一下没有参数和有参数是区分开来的，why？

4. Test类

上面三个类完成了一个简单的反射工具，那么如何进行测试呢？

首先是构造一个参数，然后调用 InvokeUtil的方法即可，这里没什么技术点，就不多说了

5. 这个东西有什么用？

框架层面对于反射用的比较多，这个就不多说了；我们接下来给一个简单的应用场景

假设你有一个java应用，对外提供rpc接口，假设现在某一个接口返回的数据不对了，那么你可以怎么办，远程debug（线程阻塞，会被打死的）

用反射就是一个思路，开一个端口，接受请求，将要执行的对象的方法和参数丢进去，查看输出结果，这样就不会局限于rpc接口的调用了，可以愉快的调用各种内部接口了

后续

spring框架是有一个beanFactory, 可以用这个东西来创建一个bean对象，此外就是能否反射执行一个私有的方法

参数的指定能否更加灵活一些呢？