Java开发反射机制的实战经验总结

时间：2021-12-04 22:55:20

前言

我在实际项目当中有经常用到反射机制，故而将学会的反射用法做一些汇总笔记，当做以后复盘所用。

存在这样一个类：

  1. package com.example.demo;
  2. import com.alibaba.fastjson.annotation.JSONField;
  3. public class User {
  4. private String name;
  5. @Value( value ="age_a")
  6. private String age;
  7.  
  8. public String getName() {
  9. return name;
  10. }
  11. public void setName(String name) {
  12. this.name = name;
  13. }
  14. public String getAge() {
  15. return age;
  16. }
  17.  
  18. public void setAge(String age) {
  19. this.age = age;
  20. }
  21. }

一、创建Class的三种方式

1 - Class clazz = Class.forName("com.example.demo.User");

Java开发反射机制的实战经验总结

注意一点，这里的forName("xxx")的类名需要全名，且为接口或类，否则加载不了。

2 - User user = new User();

Class clazz2 = user.getClass();

Java开发反射机制的实战经验总结

3 - Class clazz3 = User.class;

以上三种方式，都可以获取到类User的Class对象，通过Class，即可以开始玩反射了。

二、反射获取类的所有属性和属性类型

  1. Class clazz = User.class;
  2. Field[] fields = clazz.getDeclaredFields();
  3. for (Field field : fields) {
  4. System.out.println("属性名："+field.getName());
  5. System.out.println("属性的类型："+field.getGenericType().getTypeName());
  6. }

打印输出User的属性和属性类型——

属性名：name

属性的类型：java.lang.String

属性名：age

属性的类型：java.lang.String

利用反射获取到类的字段属性后，是不是可以利用反射来创建一个对象呢？答案是肯定的。

例如，可以类似下面代码，通过反射得到的字段属性，进而创建一个对象。

  1. Map<String,Object> fileds = new HashMap<>();
  2. fileds.put("name","张三");
  3. fileds.put("age","10");
  4. Object o = User.class.newInstance();
  5. Field[] fields = o.getClass().getDeclaredFields();
  6. for (Field field : fields) {
  7. //设置后可用反射访问访问私有变量
  8. field.setAccessible(true);
  9. //通过反射给属性赋值
  10. field.set(o,fileds.get(field.getName()));
  11. }
  12. User user1 = (User) o;
  13. System.out.println(user1.toString());

什么场景下可能需要这样做的呢？像一些内部数据与外部数据字段的映射，就可以通过类似的字段反射方式，将源数据映射给目标数据，进而得到可以插入数据库的目标对象。

三、反射动态修改类属性的注解值

注意一点，我们在设置User类时，对其中一个字段加了注解：@Value( value ="age_a")。这是一种设置值的注解，既然是设置值，是否还可以在代码运行过程中，根据不同情况来动态修改呢？

字段上的注解，其实都存放在一个memberValues属性里，这是一个map，可以这样来获取——

  1. Field[] fields = User.class.getDeclaredFields();
  2. for (Field field : fields) {
  3. //设置后可用反射访问访问私有变量
  4. if ("age".equals(field.getName() )){
  5. field.setAccessible(true);
  6. //获取 annotation 这个代理实例所持有的 InvocationHandler
  7. InvocationHandler invocationHandler = Proxy.getInvocationHandler(field.getAnnotation(Value.class));
  8. // 获取 InvocationHandler 的 memberValues 字段
  9. Field memberValues = invocationHandler.getClass().getDeclaredField("memberValues");
  10. memberValues.setAccessible(true);
  11. Map<String, Object> values = (Map<String, Object>) memberValues.get(invocationHandler);
  12. System.out.println(values);
  13. }
  14. }

debug打断点，可以看到——

Java开发反射机制的实战经验总结

这个Map<String,Object>存储的是该@注解里的所有属性值，这里，@Value只有一个value属性——

  1. public @interface Value {
  2. String value();
  3. }

若把它换成类似@JSONField(name="age_a")，把上边的代码稍微修改下，如：

  1. Field[] fields = User.class.getDeclaredFields();
  2. for (Field field : fields) {
  3. if ("age".equals(field.getName() )){
  4. field.setAccessible(true);
  5. InvocationHandler invocationHandler = Proxy.getInvocationHandler(field.getAnnotation(JSONField.class));
  6. ......
  7. }
  8. }

@JSONField注解的内部属性有如下方式——

Java开发反射机制的实战经验总结

再运行刚刚的代码，可以看到，这里Map<String，Object>获取存储到的，便是这个注解里所有的属性与对应的属性值。

Java开发反射机制的实战经验总结

到了这一步，回到先前上边的问题，若要动态改变这个注解的值，怎么处理呢？

其实，很简单，只需要直接进行值设置就可以了，例如——

  1. InvocationHandler invocationHandler = Proxy.getInvocationHandler(field.getAnnotation(Value.class));
  2. Field memberValues = invocationHandler.getClass().getDeclaredField("memberValues");
  3. memberValues.setAccessible(true);
  4. Map<String, Object> values = (Map<String, Object>) memberValues.get(invocationHandler);
  5. values.put("value","new_age");
  6. memberValues.setAccessible(false);

只是，注意一点是，这里的key需要对应上注解里是属性值。

四、反射获取类的方法及调用方式

  1. Object o=User.class.newInstance();
  2. //通过反射获取到User的setAge方法，后面的String.class表示这个setAge方法的参数类型，若有多个，则按顺序列出
  3. //同时，若为其他类型，如List,Long,则为List.class,Long.class
  4. Method m = (Method) o.getClass().getMethod("setAge",String.class);
  5. m.invoke(o,"name");
  6. User user = (User) o;
  7. System.out.println(user);

打印可见，age已为name，说明setAge调用成功了。

Java开发反射机制的实战经验总结

这类使用场景，在代理当中出现比较多。

最后，通过反射实现一个Map转成对象的封装工具——

  1. public Object MapToObject(Object object,Map<String, Object> map) throws IllegalAccessException {
  2. Class cla = object.getClass();
  3. Field[] fields = cla.getDeclaredFields();
  4. for(Field field:fields){
  5. field.setAccessible(true);
  6. if("serialVersionUID".equals(field.getName()))continue;
  7. if(map.get(field.getName())!=null) {
  8. Object value=map.get(field.getName());
  9. value=convertValType(value,field.getType());
  10. field.set(object, value);
  11. }
  12. }
  13. return object;
  14. }
  15.  
  16. private static Object convertValType(Object value, Class<?> fieldTypeClass) {
  17. Object o = null;
  18. if (Long.class.getName().equals(fieldTypeClass.getName())
  19. || long.class.getName().equals(fieldTypeClass.getName())) {
  20. o = Long.parseLong(value.toString());
  21. } else if (Integer.class.getName().equals(fieldTypeClass.getName())
  22. || int.class.getName().equals(fieldTypeClass.getName())) {
  23. o = Integer.parseInt(value.toString());
  24. } else if (Float.class.getName().equals(fieldTypeClass.getName())
  25. || float.class.getName().equals(fieldTypeClass.getName())) {
  26. o = Float.parseFloat(value.toString());
  27. } else if (Double.class.getName().equals(fieldTypeClass.getName())
  28. || double.class.getName().equals(fieldTypeClass.getName())) {
  29. o = Double.parseDouble(value.toString());
  30. } else {
  31. retVal = o;
  32. }
  33. return retVal;
  34. }

总结

到此这篇关于Java反射机制的文章就介绍到这了,更多相关Java开发反射机制内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://www.cnblogs.com/zhujiqian/p/14979486.html

标签：

相关文章