OpenCSV: Comment créer le fichier CSV à partir de POJO personnalisée avec des en-têtes de colonne et une colonne personnalisée positions?

J'ai eu le même problème. Autant que je sache, il n'existe pas de fonction intégrée dans OpenCSV qui va permettre d'écrire de la fève à la CSV personnalisé avec les noms de colonnes et de la commande.

Il existe deux principaux MappingStrategys qui sont disponibles dans OpenCSV de la boîte:

• HeaderColumnNameMappingStrategy: qui permet de tracer fichier CVS colonnes de haricot champs fondées sur la coutume de nom; lors de l'écriture de la fève à la CSV cela permet de changer les en-tête de colonne nom, mais nous n'avons aucun contrôle sur l'ordre des colonnes
• ColumnPositionMappingStrategy: qui permet à la carte de fichier CSV colonnes de haricot champs de colonne en fonction de la commande; lors de l'écriture de la fève à la CSV, nous pouvons contrôler l'ordre des colonnes, mais nous obtenons un vide en-tête (mise en œuvre renvoie new String[0] comme en-tête)

La seule façon que j'ai trouvée pour réaliser à la fois personnalisé et des noms de colonne de la commande est d'écrire votre propre MappingStrategy.

Première solution: rapide et facile, mais codé en dur

Créer des MappingStrategy:

class CustomMappingStrategy<T> extends ColumnPositionMappingStrategy<T> {
    private static final String[] HEADER = new String[]{"TradeID", "GWML GUID", "MXML GUID", "GWML File", "MxML File", "MxML Counterparty", "GWML Counterparty"};

    @Override
    public String[] generateHeader() {
        return HEADER;
    }
}

Et de l'utiliser dans StatefulBeanToCsvBuilder:

final CustomMappingStrategy<MappingsBean> mappingStrategy = new CustomMappingStrategy<>();
mappingStrategy.setType(MappingsBean.class);

final StatefulBeanToCsv<MappingsBean> beanToCsv = new StatefulBeanToCsvBuilder<MappingsBean>(writer)
    .withMappingStrategy(mappingStrategy)
    .build();
beanToCsv.write(makeFinalMappingBeanList());
writer.close()

Dans MappingsBean classe, nous avons quitté CsvBindByPosition annotations - pour le contrôle de la commande (dans cette solution CsvBindByName les annotations ne sont pas nécessaires). Grâce à la personnalisation de la cartographie de la stratégie de l'en-tête de colonne les noms sont inclus dans le fichier CSV ainsi obtenu.

L'inconvénient de cette solution est que lors du changement de la colonne de la commande par le biais de CsvBindByPosition d'annotation que nous avons de changer manuellement aussi HEADER constante dans notre stratégie de mapping.

Deuxième solution: plus de flexibilité

La première solution fonctionne, mais il n'était pas bon pour moi. Basé sur l'accumulation dans les implémentations de MappingStrategy je suis venu avec encore une autre mise en œuvre:

class CustomMappingStrategy<T> extends ColumnPositionMappingStrategy<T> {
    @Override
    public String[] generateHeader() {
        final int numColumns = findMaxFieldIndex();
        if (!isAnnotationDriven() || numColumns == -1) {
            return super.generateHeader();
        }

        header = new String[numColumns + 1];

        BeanField beanField;
        for (int i = 0; i <= numColumns; i++) {
            beanField = findField(i);
            String columnHeaderName = extractHeaderName(beanField);
            header[i] = columnHeaderName;
        }
        return header;
    }

    private String extractHeaderName(final BeanField beanField) {
        if (beanField == null || beanField.getField() == null || beanField.getField().getDeclaredAnnotationsByType(CsvBindByName.class).length == 0) {
            return StringUtils.EMPTY;
        }

        final CsvBindByName bindByNameAnnotation = beanField.getField().getDeclaredAnnotationsByType(CsvBindByName.class)[0];
        return bindByNameAnnotation.column();
    }
}

Vous pouvez utiliser cette stratégie personnalisée en StatefulBeanToCsvBuilder exactement ce même que dans la première solution (n'oubliez pas d'invoquer mappingStrategy.setType(MappingsBean.class);, sinon, cette solution ne fonctionnera pas).

Actuellement notre MappingsBean doit contenir à la fois des CsvBindByName et CsvBindByPosition annotations. Le premiers à donner de l'en-tête de colonne nom et le deuxième pour créer de commande de colonnes dans le résultat CSV en-tête. Maintenant, si nous changer (à l'aide d'annotations) soit le nom de la colonne ou de la commande dans MappingsBean classe, que ce changement pourra être répercuté en sortie de fichier CSV.

OriginalL'auteur sebast26

merci pour ce fil de discussion, il a été vraiment très utile pour moi... j'ai amélioré un peu la solution fournie afin d'accepter aussi des POJO où certains champs ne sont pas annotés (pas fait pour être lu/écrit):

public class ColumnAndNameMappingStrategy<T> extends ColumnPositionMappingStrategy<T> {
@Override
public String[] generateHeader(T bean) throws CsvRequiredFieldEmptyException {
super.setColumnMapping(new String[ getAnnotatedFields(bean)]);
final int numColumns = getAnnotatedFields(bean);
final int totalFieldNum = findMaxFieldIndex();
if (!isAnnotationDriven() || numColumns == -1) {
return super.generateHeader(bean);
}
String[] header = new String[numColumns];
BeanField<T> beanField;
for (int i = 0; i <= totalFieldNum; i++) {
beanField = findField(i);
if (isFieldAnnotated(beanField.getField())) {
String columnHeaderName = extractHeaderName(beanField);
header[i] = columnHeaderName;
}
}
return header;
}
private int getAnnotatedFields(T bean) {
return (int) Arrays.stream(FieldUtils.getAllFields(bean.getClass()))
.filter(this::isFieldAnnotated)
.count();
}
private boolean isFieldAnnotated(Field f) {
return f.isAnnotationPresent(CsvBindByName.class) || f.isAnnotationPresent(CsvCustomBindByName.class);
}
private String extractHeaderName(final BeanField beanField) {
if (beanField == null || beanField.getField() == null) {
return StringUtils.EMPTY;
}
Field field = beanField.getField();
if (field.getDeclaredAnnotationsByType(CsvBindByName.class).length != 0) {
final CsvBindByName bindByNameAnnotation = field.getDeclaredAnnotationsByType(CsvBindByName.class)[0];
return bindByNameAnnotation.column();
}
if (field.getDeclaredAnnotationsByType(CsvCustomBindByName.class).length != 0) {
final CsvCustomBindByName bindByNameAnnotation = field.getDeclaredAnnotationsByType(CsvCustomBindByName.class)[0];
return bindByNameAnnotation.column();
}
return StringUtils.EMPTY;
}

}

OriginalL'auteur Rodrigo Broggi

Je voulais atteindre les mêmes résultats que le sujet de démarreur, mais je voulais aussi être en mesure d'importer CSV généré retour à POJO. Aucune des solutions présentées m'ont aidé à le réaliser.

À la réalisation de mes résultats, j'ai besoin de refuser l'aide de @CsvBindByPosition, parce que dans ce cas - ColumnPositionMappingStrategy a été sélectionnée automatiquement. Par documents: cette stratégie nécessite que le fichier ne prend PAS en avoir un en-tête.

Mais si nous écrivons avec openCSV avec la liaison par nom de colonne - nous avoir un en-tête ajouté automatiquement (on peut l'enlever, mais je trouve qu'il est utile).

Ce que j'ai utilisées pour atteindre l'objectif:

HeaderColumnNameMappingStrategy
mappingStrategy.setColumnOrderOnWrite(Comparator<String> writeOrder)

CsvUtils pour lire/écrire csv

import com.opencsv.CSVWriter;
import com.opencsv.bean.*;
import org.springframework.web.multipart.MultipartFile;
import java.io.*;
import java.util.List;
public class CsvUtils {
private CsvUtils() {
}
public static <T> String convertToCsv(List<T> entitiesList, MappingStrategy<T> mappingStrategy) throws Exception {
try (Writer writer = new StringWriter()) {
StatefulBeanToCsv<T> beanToCsv = new StatefulBeanToCsvBuilder<T>(writer)
.withMappingStrategy(mappingStrategy)
.withQuotechar(CSVWriter.NO_QUOTE_CHARACTER)
.build();
beanToCsv.write(entitiesList);
return writer.toString();
}
}
@SuppressWarnings("unchecked")
public static <T> List<T> convertFromCsv(MultipartFile file, Class clazz) throws IOException {
try (Reader reader = new BufferedReader(new InputStreamReader(file.getInputStream()))) {
CsvToBean<T> csvToBean = new CsvToBeanBuilder<T>(reader).withType(clazz).build();
return csvToBean.parse();
}
}
}

POJO pour l'import/export

public class LocalBusinessTrainingPairDTO {
//this is used for CSV columns ordering on exporting LocalBusinessTrainingPairs
public static final String[] FIELDS_ORDER = {"leftId", "leftName", "rightId", "rightName"};
@CsvBindByName(column = "leftId")
private int leftId;
@CsvBindByName(column = "leftName")
private String leftName;
@CsvBindByName(column = "rightId")
private int rightId;
@CsvBindByName(column = "rightName")
private String rightName;
//getters/setters omitted, do not forget to add them
}

Personnalisé comparateur de Chaîne prédéfinie de la commande:

public class OrderedComparatorIgnoringCase implements Comparator<String> {
private List<String> predefinedOrder;
public OrderedComparatorIgnoringCase(String[] predefinedOrder) {
this.predefinedOrder = new ArrayList<>();
for (String item : predefinedOrder) {
this.predefinedOrder.add(item.toLowerCase());
}
}
@Override
public int compare(String o1, String o2) {
return predefinedOrder.indexOf(o1.toLowerCase()) - predefinedOrder.indexOf(o2.toLowerCase());
}
}

Commandé l'écriture pour POJO (réponse à la question initiale)

public static void main(String[] args) throws Exception {
List<LocalBusinessTrainingPairDTO> localBusinessTrainingPairsDTO = new ArrayList<>();
LocalBusinessTrainingPairDTO localBusinessTrainingPairDTO = new LocalBusinessTrainingPairDTO();
localBusinessTrainingPairDTO.setLeftId(1);
localBusinessTrainingPairDTO.setLeftName("leftName");
localBusinessTrainingPairDTO.setRightId(2);
localBusinessTrainingPairDTO.setRightName("rightName");
localBusinessTrainingPairsDTO.add(localBusinessTrainingPairDTO);
//Creating HeaderColumnNameMappingStrategy
HeaderColumnNameMappingStrategy<LocalBusinessTrainingPairDTO> mappingStrategy = new HeaderColumnNameMappingStrategy<>();
mappingStrategy.setType(LocalBusinessTrainingPairDTO.class);
//Setting predefined order using String comparator
mappingStrategy.setColumnOrderOnWrite(new OrderedComparatorIgnoringCase(LocalBusinessTrainingPairDTO.FIELDS_ORDER));
String csv = convertToCsv(localBusinessTrainingPairsDTO, mappingStrategy);
System.out.println(csv);
}

Lire CSV exporté retour à POJO (plus original de la réplique)

Important: CSV peut être non ordonnée, car nous sommes toujours à l'aide de la liaison par nom:

public static void main(String[] args) throws Exception {
//omitted code from writing
String csv = convertToCsv(localBusinessTrainingPairsDTO, mappingStrategy);
//Exported CSV should be compatible for further import
File temp = File.createTempFile("tempTrainingPairs", ".csv");
temp.deleteOnExit();
BufferedWriter bw = new BufferedWriter(new FileWriter(temp));
bw.write(csv);
bw.close();
MultipartFile multipartFile = new MockMultipartFile("tempTrainingPairs.csv", new FileInputStream(temp));
List<LocalBusinessTrainingPairDTO> localBusinessTrainingPairDTOList = convertFromCsv(multipartFile, LocalBusinessTrainingPairDTO.class);
}

De conclure:

1. On peut lire CSV de POJO, quel que soit l'ordre des colonnes - parce que nous sommes
   à l'aide de @CsvBindByName
2. Nous pouvons contrôler l'ordre des colonnes sur écrire à l'aide de
   personnalisé comparateur de

OriginalL'auteur Антон Кумпан