专栏首页小灰灰Java 反射简单实例

Java 反射简单实例

反射

什么是反射,反射有什么用,反射该怎么用?

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

后续会提供一个基于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<String, String> 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<String, String> 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<String, String> argus = params.getParams();
        try {
            Class<?> clz;
            String value;
            int index = 0;
            for (Map.Entry<String, String> 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<String, Class<?>> 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<String> 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<String, String> map = new HashMap<>(3);
        map.put("target", "invoke");
        map.put("class", "com.mushroom.hui.test.biz.Calculate");
        map.put("method", "add");

        Map<String, String> 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<String, String> map = new HashMap<>(3);
        map.put("target", "invoke");
        map.put("class", "com.mushroom.hui.test.biz.Calculate");
        map.put("method", "array");
        List<String> list = new ArrayList<>();
        list.add("123");
        list.add("hello");
        list.add("world");
        Map<String, String> 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对象,此外就是能否反射执行一个私有的方法

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

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 如何使用线程锁来提高多线程并发效率

           今天对synchronized关键字的用法又有了更高一层的理解,特此记录一下。        一直对自己设计的多通道做单不是狠满意,并发效率低下。...

    赵小忠
  • java项目 远程debug

    AVA项目无法像PHP那样可以随时修改文件内容进行调试,调试可以借助eclipse,本地代码的话很容易在本地debug,但如果代码已经打包部署在linux上呢?...

    千往
  • 这次真的忽略了一些ActiveMQ内心的娇艳

    首先ActiveMQ有俩种消息队列模式:点对点和发布订阅,这俩种都有不可替代的应用场景,前者适用于消息唯一传递的业务,后者适用于分布式环境下进行多面数据同步的...

    赵小忠
  • 多线程之策略模式

    今天给各位分享一种Java23种设计模式中最常见的设计模式--策略模式。为什么将策略模式和多线程绑在一起呢,不知道各位有没有注意过我们在进行多线程编程的时候,创...

    赵小忠
  • 多线程编程:阻塞、并发队列的使用总结

    最近,一直在跟设计的任务调度模块周旋,目前终于完成了第一阶段的调试。今天,我想借助博客园平台把最近在设计过程中,使用队列和集合的一些基础知识给大家总结一下,方便...

    赵小忠
  • 单点登录系统实现

    单点登录系统实现基于SpringBoot 今天的干货有点湿,里面夹杂着我的泪水。可能也只有代码才能让我暂时的平静。通过本章内容你将学到单点登录系统和传统登录系统...

    企鹅号小编
  • java array to list

    背景 想把数组转为list,使用list的判断元素是否存在的方法,结果发现一个坑,int类型的数组失败了  步骤 public static void main...

    千往
  • Java设计模式之模板方法设计模式(银行计息案例)

           不知道为什么,这几天对Java中的设计模式非常感兴趣,恰巧呢这几天公司的开发任务还不算太多,趁着有时间昨天又把模板方法模式深入学习了一下,做了一个...

    赵小忠
  • git命令中带有特殊符号如@

    使用带用户密码clone的方式: git clone https://username:password@remote 当username和password中含...

    千往
  • java匿名内部类

    show the code : package com.test.jwen.httpApiAuto; public class AInter { publ...

    千往

扫码关注云+社区

领取腾讯云代金券