Question

如果该类具有每个字段的默认构造函数和设置器，则OpenCSV会愉快地将记录转换为对象。但是，我要为其生成对象的类是用final字段，私有构造函数和Builder定义的。例如，如果我要创建类型为X的对象，其中X的定义为

public class X {
    private final String val;
    private X(final String val) { this.val = val; }
    public Builder builder() { return new Builder(); }

    public static class Builder {
        private String val;
        public Builder withVal(final String val) { this.val = val; return this; }
        public X build() { return new X(val); }
    }
}

我已经看过com.opencsv.bean.MappingStrategy界面，想知道是否可以以某种方式应用它，但是我还没有找到解决方案。有什么想法吗？

Answer 1

com.opencsv.bean.MappingStrategy看起来是解决此问题的好方法，但是由于您拥有最终属性和私有构造函数，因此需要从Java Reflections系统中获得一些帮助。

从AbstractMappingStrategy类继承的OpenCSV的内置映射策略是使用无参数默认构造函数构造Bean，然后找到用于填充值的setter方法。

可以准备一个MappingStrategy实现，该实现将找到一个合适的构造函数，该构造函数的参数与CSV文件中的顺序和映射列的类型相匹配，并将其用于构造bean。即使构造函数是私有的或受保护的，也可以通过反射系统对其进行访问。

例如以下CSV：

number;string
1;abcde
2;ghijk

可以映射到以下类：

public class Something {
    @CsvBindByName
    private final int number;
    @CsvBindByName
    private final String string;

    public Something(int number, String string) {
        this.number = number;
        this.string = string;
    }

    // ... getters, equals, toString etc. omitted
}

使用以下CvsToBean实例：

CsvToBean<Something> beanLoader = new CsvToBeanBuilder<Something>(reader)
    .withType(Something.class)
    .withSeparator(';')
    .withMappingStrategy(new ImmutableClassMappingStrategy<>(Something.class))
    .build();

List<Something> result = beanLoader.parse();

ImmutableClassMappingStrategy的完整代码：

import com.opencsv.bean.AbstractBeanField;
import com.opencsv.bean.BeanField;
import com.opencsv.bean.HeaderColumnNameMappingStrategy;
import com.opencsv.exceptions.CsvConstraintViolationException;
import com.opencsv.exceptions.CsvDataTypeMismatchException;
import com.opencsv.exceptions.CsvRequiredFieldEmptyException;

import java.beans.IntrospectionException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * A {@link com.opencsv.bean.MappingStrategy} implementation which allows to construct immutable beans containing
 * final fields.
 *
 * It tries to find a constructor with order and types of arguments same as the CSV lines and construct the bean using
 * this constructor. If not found it tries to use the default constructor.
 *
 * @param <T> Type of the bean to be returned
 */
public class ImmutableClassMappingStrategy<T> extends HeaderColumnNameMappingStrategy<T> {

    /**
     * Constructor
     * 
     * @param type Type of the bean which will be returned
     */
    public ColumnMappingStrategy(Class<T> type) {
        setType(type);
    }

    @Override
    public T populateNewBean(String[] line) throws InstantiationException, IllegalAccessException, IntrospectionException, InvocationTargetException, CsvRequiredFieldEmptyException, CsvDataTypeMismatchException, CsvConstraintViolationException {
        verifyLineLength(line.length);

        try {
            // try constructing the bean using explicit constructor
            return constructUsingConstructorWithArguments(line);
        } catch (NoSuchMethodException e) {
            // fallback to default constructor
            return super.populateNewBean(line);
        }
    }

    /**
     * Tries constructing the bean using a constructor with parameters for all matching CSV columns
     *
     * @param line A line of input
     *
     * @return
     * @throws NoSuchMethodException in case no suitable constructor is found
     */
    private T constructUsingConstructorWithArguments(String[] line) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Constructor<? extends T> constructor = findSuitableConstructor(line.length);

        // in case of private or protected constructor, try to set it to be accessible
        if (!constructor.canAccess(null)) {
            constructor.setAccessible(true);
        }

        Object[] arguments = prepareArguments(line);

        return constructor.newInstance(arguments);
    }

    /**
     * Tries to find a suitable constructor with exact number and types of parameters in order defined in the CSV file
     *
     * @param columns Number of columns in the CSV file
     * @return Constructor reflection
     * @throws NoSuchMethodException in case no such constructor exists
     */
    private Constructor<? extends T> findSuitableConstructor(int columns) throws NoSuchMethodException {
        Class<?>[] types = new Class<?>[columns];
        for (int col = 0; col < columns; col++) {
            BeanField<T> field = findField(col);
            Class<?> type = field.getField().getType();
            types[col] = type;
        }
        return type.getDeclaredConstructor(types);
    }

    /**
     * Prepare arguments with correct types to be used in the constructor
     *
     * @param line A line of input
     * @return Array of correctly typed argument values
     */
    private Object[] prepareArguments(String[] line) {
        Object[] arguments = new Object[line.length];
        for (int col = 0; col < line.length; col++) {
            arguments[col] = prepareArgument(col, line[col], findField(col));
        }
        return arguments;
    }

    /**
     * Prepare a single argument with correct type
     *
     * @param col Column index
     * @param value Column value
     * @param beanField Field with
     * @return
     */
    private Object prepareArgument(int col, String value, BeanField<T> beanField) {
        Field field = beanField.getField();

        // empty value for primitive type would be converted to null which would throw an NPE
        if ("".equals(value) && field.getType().isPrimitive()) {
            throw new IllegalArgumentException(String.format("Null value for primitive field '%s'", headerIndex.getByPosition(col)));
        }

        try {
            // reflectively access the convert method, as it's protected in AbstractBeanField class
            Method convert = AbstractBeanField.class.getDeclaredMethod("convert", String.class);
            convert.setAccessible(true);
            return convert.invoke(beanField, value);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            throw new IllegalStateException(String.format("Unable to convert bean field '%s'", headerIndex.getByPosition(col)), e);
        }
    }
}

另一种方法可能是将CSV列映射到构建器本身，然后再构建不可变类。

使用OpenCSV，我们如何将记录映射到使用Builder而不使用setter的类？

1 个答案: