Java - 从字符串（反射）将字段值设置为正确的类型

Question

我有这样的课：

public enum  Type {
    ONE, TWO
}

@Data
public class Car {
    private String name;
    private int year;
    private Type type;
}

我有新对象：

Car car = new Car();

我有这些数据：

Map<String, String> data....

name - BMW
year - 2018
type - TWO

键和值 - 字符串

我需要将此值设置为对象（除了反射，我看不到任何方法）

    Field year = car.getClass().getDeclaredField("year");
    year.setAccessible(true);
    year.set(car, data.get("year"));//2018 as string

我得到例外（不同，我不知道）：

Caused by: java.lang.IllegalArgumentException: Can not set int field com.example.mapper.Car.year to java.lang.String

因此，问题是 - 如何正确地将值转换为要在字段中设置的所需类型？

这是一个简单的例子，因为真正的任务很长。 如果简而言之 - 我得到一个值列表（它们总是一个字符串）和它们更改的字段的名称（也是一个字符串），并且必须使用新值更新对象的字段

Answer 1

尽量小的有效解决方案是使用JSON库作为解决方法，因为它们已经从最常见类型的字符串实现了值实例化。

例如，使用ObjectMapper：

   Map<String,String> data = new HashMap<>();
   data.put("year","2018");
   data.put("name", "BMW");
   data.put("type", "TWO");
   ObjectMapper mapper = new ObjectMapper();
   Car car = mapper.readValue(mapper.writeValueAsString(data), Car.class);

Answer 2

反思确实是要走的路。 您可以使用获得的类型field.getType()然后再检查使用的具体类Class.isAssignableFrom()

final Class<?> type = field.getType();
if (int.class.isAssignableFrom(type)) {
    typedValue = Integer.parseInt(value);
} else if (type.isEnum()) {
    typedValue = Enum.valueOf((Class<Enum>) type, value);
} else {
    // Assume String
    typedValue = value;
}

当然，这几乎可以变得任意复杂，但这里是您提供的值的完整工作示例。 这应该给你一个如何进行的要点：

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

class CarFiller {

    public static void main(String[] args) throws Exception {
        Map<String, String> data = new HashMap<>();
        data.put("name", "BMW");
        data.put("year", "2018");
        data.put("type", "TWO");

        Car car = new Car();
        fillField(car, "name", data);
        fillField(car, "year", data);
        fillField(car, "type", data);

        System.out.println(car);
    }

    private static void fillField(Object instance, String fieldName, Map<String, String> data) throws Exception {
        Field field = instance.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);

        String value = data.get(fieldName);
        Object typedValue = null;
        final Class<?> type = field.getType();
        if (int.class.isAssignableFrom(type)) {
            typedValue = Integer.parseInt(value);
        } else if (type.isEnum()) {
            typedValue = Enum.valueOf((Class<Enum>) type, value);
        } else {
            // Assume String
            typedValue = value;
        }

        field.set(instance, typedValue);
    }

    enum  Type {
        ONE, TWO
    }

    static class Car {
        private String name;
        private int year;
        private Type type;

        public void setName(String name) {
            this.name = name;
        }
        public void setYear(int year) {
            this.year = year;
        }
        public void setType(Type type) {
            this.type = type;
        }

        @Override
        public String toString() {
            return "Car [name=" + name + ", year=" + year + ", type=" + type + "]";
        }       
    }
}

（另见ideone ）

Answer 3

我建议不要在任何可能的地方使用反射。 就像你的确切例子一样。

您可以为Car类中的每个字段创建一个包含BiConsumers的枚举类：

import java.util.Map;
import java.util.function.BiConsumer;

@Data
public class Car {
    private String name;
    private int year;
    private Ttc.Type type;

    static enum CarEnum {
        name((car, value) -> car.setName(value)),
        year((car, value) -> car.setYear(Integer.parseInt(value))),
        type((car, value) -> car.setType(Ttc.Type.valueOf(value)));
        private BiConsumer<Car, String> setValueConsumer;

        CarEnum(BiConsumer<Car, String> setValueConsumer) {
            this.setValueConsumer = setValueConsumer;
        }

        static Car createCar(Map<String, String> data) {
            Car car = new Car();
            data.forEach((key, value) -> valueOf(key).setValueConsumer.accept(car, value));
            return car;
        }
    }
}

然后在下一个方面使用它：

Map<String, String> data = new HashMap<>();
data.put("name", "BMW");
data.put("year", "2018");
data.put("type", "TWO");
Car.CarEnum.createCar(data);

Answer 4

Java是静态类型的。 因此，您需要自己提供正确的类型。 Integer.valueOf接受一个String并返回一个Integer。

int year = Integer.valueOf("2018");

将String转换为Enum的工作方式相同。

Type  type = Type.valueOf("ONE");

Enum.valueOf在后台调用。

当然，您还需要添加一些错误检查。

---

我建议在这种情况下避免使用反射。 你可以使用不同的方法，例如

  class Car
  {
    private final Type type;
    private final String name;
    private final int year;

    private Car(Builder builder)
    {
      this.type = builder.type;
      this.name = builder.name;
      this.year = builder.year;
    }

    static class Builder
    {
      private Type type;
      private String name;
      private int year;

      public Builder setType(String type)
      {
        this.type = Type.valueOf(type);
        return this;
      }

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

      public Builder setYear(String year)
      {
        this.year = Integer.valueOf(year);
        return this;
      }

      public Car build()
      {
        return new Car(this);
      }

    }

  }

您还可以向构建器添加setData方法

      public Builder setData(Map<String, String> data)
      {
        this.year = Integer.valueOf(data.get("year"));
        this.type = Type.valueOf(data.get("type"));
        // etc.
        return this;
      }

然后用Car c = new Car.Builder().setData(data).build();创建一辆Car c = new Car.Builder().setData(data).build(); 。