Question

我有一个大约300个键/字符串值对的HashMap和一个带有大约12个字符串属性的POJO，其名称与键名匹配。

我想知道如何将HashMap值放入POJO？

我开始使用relfection和循环，但不确定如何动态构造setter方法名称，显然反射是一个坏主意但无论如何......但是FWIW：

    public void writeToFile(Map<String, String> currentSale) throws IOException {

    SaleExport saleExport = new SaleExport();

    Field[] fields = saleExport.getClass().getDeclaredFields();

       for (Field field : fields ) {
        System.out.println(field.getName());
        saleExport.set +field(saleExport.get(field));

之前我使用过map struct，但它似乎不支持HashMaps。

更新

这个answer看起来与我想做的相似，但是在没有映射的字段上出现了堆栈错误：

Exception in thread "Thread-2" java.lang.IllegalArgumentException: Unrecognized field "Physical" (class com.SaleExport), not marked as ignorable (6 known properties: "date", "city", "surname", "streetName", "salesNo", "salesSurname"])
 at [Source: UNKNOWN; line: -1, column: -1] (through reference chain: com.SalesExport["Physical"])
    at com.fasterxml.jackson.databind.ObjectMapper._convert(ObjectMapper.java:3738)
    at com.fasterxml.jackson.databind.ObjectMapper.convertValue(ObjectMapper.java:3656)
    at com.CSVExport.writeToFile(CSVExport.java:20)
    at com.JFrameTest.writefiletoDB(JFrameTest.java:135)
    at com.JFrameTest$FileWorkerThread.run(JFrameTest.java:947)

忽略我尝试过的错误：

mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

但是没有映射到任何东西。

Answer 1

尝试使用Dozer映射将HashMap映射到POJO。您也可以查看MapStruct。

Answer 2

您好我不知道这是不是一个好主意，但您可以将地图转换为json并将json转换为您的POJO。你可以使用gson。

Answer 3

你可以通过例如pojo成员变量注入一些东西。像这样的方法。我不是说这是一个很好的方法，但可以这样做。

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

/**
 * @author Ivo Woltring
 */
public class HashMapKeyStuff {

    /**
     * The most simple cdi like method.
     *
     * @param injectable the object you want to inject something in
     * @param fieldname  the fieldname to inject to
     * @param value      the value to assign to the fieldname
     */
    public static void injectField(final Object injectable, final String fieldname, final Object value) {
        try {
            final Field field = injectable.getClass()
                    .getDeclaredField(fieldname);
            final boolean origionalValue = field.isAccessible();
            field.setAccessible(true);
            field.set(injectable, value);
            field.setAccessible(origionalValue);
        } catch (final NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    private void doIt() {
        HashMap<String, String> foo = new HashMap<>();
        foo.put("hello", "world");
        foo.put("message", "You are great");

        MyPOJO pojo = new MyPOJO();
        for (final String key : foo.keySet()) {
            injectField(pojo, key, foo.get(key));
        }
        System.out.println("pojo = " + pojo);
    }

    public static void main(String[] args) {
        new HashMapKeyStuff().doIt();
    }

}

class MyPOJO {
    private String hello;
    private String message;

    public String getHello() {
        return this.hello;
    }


    public String getMessage() {
        return this.message;
    }

    @Override
    public String toString() {
        return "MyPOJO{" +
                "hello='" + hello + '\'' +
                ", message='" + message + '\'' +
                '}';
    }
}

Answer 4

如果我已正确理解你的问题 - 你想根据键将map的值放入Pojo的成员变量中。

尝试以下方法。

主类如下

package org.anuj.collections.map;

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

public class ConverMapToPojo {

    public static void main(String[] args) {
        Map<String, String> map = getMap();
        Set<String> keySet = map.keySet();

        String fieldName = null;
        Pojo pojo = new Pojo();
        Field[] field = Pojo.class.getDeclaredFields();

        for (Field f : field) {
            fieldName = f.getName();
            if (keySet.contains(fieldName)) {
                pojo = setField(fieldName, map.get(fieldName), pojo);
            }
        }
        System.out.println("fName = " + pojo.getfName());
        System.out.println("lName = " + pojo.getlName());
    }

    private static Pojo setField(String fieldName, String value, Pojo pojo) {
        switch (fieldName) {
        case "fName":
            pojo.setfName(value);
            break;
        case "lName":
            pojo.setlName(value);
            break;
        }
        return pojo;
    }

    private static Map<String, String> getMap() {
        Map<String, String> map = new HashMap<String, String>();
        map.put("fName", "stack");
        map.put("lName", "overflow");
        return map;
    }
}

Pojo Class如下 -

public class Pojo {

    private String fName;
    private String lName;

    public String getfName() {
        return fName;
    }

    public void setfName(String fName) {
        this.fName = fName;
    }

    public String getlName() {
        return lName;
    }

    public void setlName(String lName) {
        this.lName = lName;
    }
}

结果出来

fName = stack lName =溢出

Answer 5

我认为你的代码中有正确的想法。我理解您的POJO只包含HashMap中表示的字段的子集，因此您只需遍历字段，在找到它们时从HashMap中填充它们。

public SaleExport toSaleExport(Map<String,String> currentSale) {
    SaleExport saleExport=new SaleExport();
    Field[] fields=SaleExport.class.getDeclaredFields();
    for (Field field : fields) {
        String name=field.getName();
        if (currentSale.containsKey(name)) {
            field.set(saleExport, currentSale.get(name));
        }
    }
    return saleExport;
}

将一些HashMap键/值映射到POJO

5 个答案: