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

Question

如果该类具有每个字段的默认构造函数和 setter ，OpenCSV 会愉快地将记录转换为对象。但是，我希望为其生成对象的类是使用最终字段、私有(private)构造函数和生成器定义的。例如，如果我想创建一个 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 接口(interface)，想知道是否可以以某种方式应用它，但我还没有找到解决方案。有什么想法吗？

Answer 1

com.opencsv.bean.MappingStrategy 看起来是处理这个问题的好方法，但由于您有最终属性和私有(private)构造函数，因此您需要从 java 反射系统获得一些帮助。

OpenCSV 的内置映射策略继承自 AbstractMappingStrategy 类，使用无参数默认构造函数构造 bean，然后查找 setter 方法来填充值。

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

<小时/>

例如以下 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 列映射到构建器本身，然后构建不可变类。