Java 如何使用BeanUtils转换器进行列表？

此处，请求参数字符串为：

firstName=jack&lastName=lily&gender=1&foods=Steak&foods=Pizza"e=Enter+your+favorite+quote&教育=高中和托福=日

映射类为：

public class Student {
    private String firstName;
    private String lastName;
    private Integer gender;
    private List<String> foods;
    private String quote;
    private String education;
    private String tOfD;

    getXxx()....;
    setXxx()....;
}

公共班级学生{
私有字符串名；
私有字符串lastName；
私人整数性别；
私人清单食品；
私有字符串引用；
私立教育；
私有字符串tOfD；
getXxx（）。。。。；
setXxx（）。。。。；
}

现在，我想编写一个泛型util类来将字符串转换为bean

public final class InjectUtil<T> {
private static final Logger LOGGER = LoggerFactory.getLogger(InjectUtil.class);

public static <T> T converter2Obj(String source, Class<T> tClass) {
    T t = null;
    try {
        t = tClass.newInstance();

        if(source != null && source.length() > 0) {
            String[] fields = source.split("&");
            for(String field : fields) {
                String[] fieldKeyValue = field.split("\\=");
                String fieldKey = fieldKeyValue[0];
                String fieldValue = fieldKeyValue[1];
                // help
            }
        }
    } catch(InstantiationException | IllegalAccessException | InvocationTargetException e) {
        e.printStackTrace();
    }
    return t;
}

public final类InjectUtil{
私有静态最终记录器Logger=LoggerFactory.getLogger（InjectUtil.class）；
公共静态T转换器2obj（字符串源，类tClass）{
T=零；
试一试{
t=tClass.newInstance（）；
if（source！=null&&source.length（）>0）{
String[]fields=source.split（&）；
用于（字符串字段：字段）{
字符串[]fieldKeyValue=field.split（“\\=”）；
字符串fieldKey=fieldKeyValue[0]；
字符串fieldValue=fieldKeyValue[1]；
//帮助
}
}
}catch（实例化异常|非法访问异常|调用目标异常e）{
e、 printStackTrace（）；
}
返回t；
}

}

---

注意帮助，如何使用BeanUtils将“foods=Steak&foods=Pizza”转换为List属性。

您可以按如下方式使用，您需要填充foodList（值为[Steak，Pizza]），然后使用以下方法设置为bean

PropertyUtils.setProperty(studentBean, "foods", foodList);

或

---

您可以如下使用，您需要填充foodList（值为[Steak，Pizza]），然后使用以下方法设置为bean

PropertyUtils.setProperty(studentBean, "foods", foodList);

或

---

下面是一种方法：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.beanutils.BeanUtils;

public final class InjectUtil<T> {
    // private static final Logger LOGGER =
    // LoggerFactory.getLogger(InjectUtil.class);

    public static <T> T converter2Obj(String source, Class<T> tClass) {
        T t = null;

        try {
            t = tClass.newInstance();
            Map<String, Object> params = new HashMap<String, Object>();
            if (source != null && source.length() > 0) {
                String[] fields = source.split("&");
                for (String field : fields) {
                    String[] fieldKeyValue = field.split("\\=");
                    String fieldKey = fieldKeyValue[0];
                    String fieldValue = fieldKeyValue[1];

                    if (params.containsKey(fieldKey)) {

                        //the key does not exist as yet
                        Object keyValueRetrieved = params.get(fieldKey);
                        if (keyValueRetrieved instanceof String) {
                            //key exists , it is single value that has been added now.
                            //change that now to a list to add more values
                            ArrayList<String> values = new ArrayList<String>();
                            values.add(keyValueRetrieved.toString());
                            values.add(fieldValue);
                            params.put(fieldKey, values);
                        } else {
                            //key exists , it is a list already. Add more values
                            ((ArrayList<String>) keyValueRetrieved).add(fieldValue);
                        }
                    } else {
                        params.put(fieldKey, fieldValue);
                    }

                }
            }
            BeanUtils.populate(t, params);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("--------------------------------------------");
        System.out.println(t.toString());
        System.out.println("--------------------------------------------");
        return t;
    }
}

import java.util.ArrayList；
导入java.util.HashMap；
导入java.util.Map；
导入org.apache.commons.beanutils.beanutils；
公共最终类InjectUtil{
//专用静态最终记录器=
//getLogger（InjectUtil.class）；
公共静态T转换器2obj（字符串源，类tClass）{
T=零；
试一试{
t=tClass.newInstance（）；
Map params=新的HashMap（）；
if（source！=null&&source.length（）>0）{
String[]fields=source.split（&）；
用于（字符串字段：字段）{
字符串[]fieldKeyValue=field.split（“\\=”）；
字符串fieldKey=fieldKeyValue[0]；
字符串fieldValue=fieldKeyValue[1]；
if（参数containsKey（现场钥匙））{
//密钥还不存在
对象keyValueRetrieved=params.get（fieldKey）；
if（检索到的KeyValueInstanceof String）{
//键存在，现在添加的是单个值。
//现在将其更改为列表以添加更多值
ArrayList值=新的ArrayList（）；
add（keyValueRetrieved.toString（））；
值。添加（字段值）；
参数put（字段键、值）；
}否则{
//键存在，它已经是一个列表。请添加更多值
（（ArrayList）keyValueRetrieved）。添加（fieldValue）；
}
}否则{
参数put（字段键、字段值）；
}
}
}
BeanUtils.填充（t，参数）；
}捕获（例外e）{
e、 printStackTrace（）；
}
System.out.println（“--------------------------------------------------”）；
System.out.println（t.toString（））；
System.out.println（“--------------------------------------------------”）；
返回t；
}
}

---

您可以进行一些优化，希望这能给您一个想法

以下是一种方法：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.beanutils.BeanUtils;

public final class InjectUtil<T> {
    // private static final Logger LOGGER =
    // LoggerFactory.getLogger(InjectUtil.class);

    public static <T> T converter2Obj(String source, Class<T> tClass) {
        T t = null;

        try {
            t = tClass.newInstance();
            Map<String, Object> params = new HashMap<String, Object>();
            if (source != null && source.length() > 0) {
                String[] fields = source.split("&");
                for (String field : fields) {
                    String[] fieldKeyValue = field.split("\\=");
                    String fieldKey = fieldKeyValue[0];
                    String fieldValue = fieldKeyValue[1];

                    if (params.containsKey(fieldKey)) {

                        //the key does not exist as yet
                        Object keyValueRetrieved = params.get(fieldKey);
                        if (keyValueRetrieved instanceof String) {
                            //key exists , it is single value that has been added now.
                            //change that now to a list to add more values
                            ArrayList<String> values = new ArrayList<String>();
                            values.add(keyValueRetrieved.toString());
                            values.add(fieldValue);
                            params.put(fieldKey, values);
                        } else {
                            //key exists , it is a list already. Add more values
                            ((ArrayList<String>) keyValueRetrieved).add(fieldValue);
                        }
                    } else {
                        params.put(fieldKey, fieldValue);
                    }

                }
            }
            BeanUtils.populate(t, params);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("--------------------------------------------");
        System.out.println(t.toString());
        System.out.println("--------------------------------------------");
        return t;
    }
}

import java.util.ArrayList；
导入java.util.HashMap；
导入java.util.Map；
导入org.apache.commons.beanutils.beanutils；
公共最终类InjectUtil{
//专用静态最终记录器=
//getLogger（InjectUtil.class）；
公共静态T转换器2obj（字符串源，类tClass）{
T=零；
试一试{
t=tClass.newInstance（）；
Map params=新的HashMap（）；
if（source！=null&&source.length（）>0）{
String[]fields=source.split（&）；
用于（字符串字段：字段）{
字符串[]fieldKeyValue=field.split（“\\=”）；
字符串fieldKey=fieldKeyValue[0]；
字符串fieldValue=fieldKeyValue[1]；
if（参数containsKey（现场钥匙））{
//密钥还不存在
对象keyValueRetrieved=params.get（fieldKey）；
if（检索到的KeyValueInstanceof String）{
//键存在，现在添加的是单个值。
//现在将其更改为列表以添加更多值
ArrayList值=新的ArrayList（）；
add（keyValueRetrieved.toString（））；
值。添加（字段值）；
参数put（字段键、值）；
}否则{
//键存在，它已经是一个列表。请添加更多值
（（ArrayList）keyValueRetrieved）。添加（fieldValue）；
}
}否则{
参数put（字段键、字段值）；
}
}
}
BeanUtils.填充（t，参数）；
}捕获（例外e）{
e、 printStackTrace（）；
}
System.out.println（“---------------