Используя OpenCSV, как мы можем сопоставить запись с классом, который использует Builder, а не сеттеры? - PullRequest
Новая
       13

Используя OpenCSV, как мы можем сопоставить запись с классом, который использует Builder, а не сеттеры?

0 голосов
/ 07 декабря 2018

OpenCSV успешно преобразует запись в объект, если у этого класса есть конструктор по умолчанию и установщики для каждого из полей.Однако класс, для которого я хочу создать объект, определяется конечными полями, личным конструктором и конструктором.Например, если я хочу создать объект типа 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 и спрашиваю, можно ли это как-то применить, но яеще не нашли решение.Есть идеи?

1 Ответ

0 голосов
/ 09 августа 2019

com.opencsv.bean.MappingStrategy выглядит как хороший способ справиться с этим, но, поскольку у вас есть конечные свойства и закрытый конструктор, вам нужно немного помочь с системой отражения java.

Встроенный OpenCSV-в стратегиях отображения, унаследованных от класса AbstractMappingStrategy, конструируют bean-компонент с использованием конструктора по умолчанию без параметров, а затем находят методы установки для заполнения значений.

Можно подготовить реализацию MappingStrategy, которая вместо этого найдет подходящий конструктор с параметрами, соответствующими порядку и типам отображаемых столбцов из файла CSV, и использует его для построения компонента.Даже если конструктор является личным или защищенным, он может быть доступен через систему отражений.

Например, следующий 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 с самим построителем и впоследствии построить неизменяемый класс.

...