jeudi 24 octobre 2019

Java parcourir les fichiers dans un répertoire.

Java 8 : Files.list(repertoire) ou Files.walk(repertoire)  retourne la liste des fichiers dans un répertoire.
Java 7 : Files.walkFileTree() : prend un path
Java 6 : File.listFiles()

Java : La lecture d'un fichier CSV


  1. La lecture d'un fichier CSV en Java :


try(BufferedReader br = new BufferedReader(new FileReader("somefile.txt")) ) {
 String columnNames = br.readline(); // ONLY do this if it exists
String line; while ((line = br.readLine()) != null) {
/* parse each line */ // TODO }
} catch (Exception e) {
 System.err.println(e.getMessage()); // or log error
}
/!\  Si fichier distant : URL url = new URL("http://url/textfile.txt");
Puis, (url.openStream()

Pistes :

  •  Apache Commons CSV parser library
/* parse each line */ 
CSVParser parser = CSVParser.parse(line, CSVFormat.RFC4180); 
for(CSVRecord cr : parser) { 
int id = cr.get(1); // columns start at 1 not 0 !!! 
int year = cr.get(2); 
String city = cr.get(3); 
}

Java : Solution pour éviter que votre méthode retourner null

Collections.emptyList() : retourne une liste immuable prédéfinie, ou bien, List.of() introduit dans la JDK9.

https://blog.octo.com/comment-ne-plus-avoir-de-nullpointerexception-en-java/



Java : Un guide pour choisir la structure de données approprié à votre cas.


L'interface Set modélise un ensemble d'objets dans lequel on ne peut pas trouver de doublons.

Un Set ne peut pas contenir plus d'un objet null.

Implémentations HashSet et LinkedHashSet
  
TreeSet implémente NavigableSet

log(n) time cost for the basic operations (add, remove and contains).

https://dzone.com/articles/the-hidden-contract-between-equals-and-comparable


TreeSet implémente SortedSet, alors que HashSet n'implémente "que" Set.
  
Dit autrement, TreeSet implémente un ensemble ordonné : si tu itères sur les éléments du TreeSet, tu les obtiendras en ordre croissant (selon la méthode compareTo() de Comparable).

Par ailleurs, TreeSet repose sur la méthode compareTo() pour fonctionner. HashSet repose sur la méthode hashCode().

Si tu as besoin d'avoir un ensemble trié -> TreeSet

Sinon -> HashSet (car plus rapide)

List est la solution si on veut garder l'ordre par defaut, mais si on doit réordonner les données il faut utiliser une autre structure comme TreeSet .

Source : http://www.sergiy.ca/guide-to-selecting-appropriate-map-collection-in-java



Java Map/Collection Cheat Sheet

dimanche 20 octobre 2019

Angular 8: le timing des décorateurs @ViewChild @ViewChildren


 Angular 8, il est obligatoire de renseigner une propriété static sur le ViewChild et ContentChlid

https://stackoverflow.com/questions/56359504/how-should-i-use-the-new-static-option-for-viewchild-in-angular-8

Queries timing


The ViewChild and ContentChild decorators now must have a new option called static. Let me explain why with a very simple example using a ViewChild:
*ngIf="true">
#dynamicDiv>dynamic
Let’s get that element in our component and log it in the lifecycle hooks ngOnInit and ngAfterViewInit:
@ViewChild('dynamicDiv') dynamicDiv: ElementRef<HTMLDivElement>;

ngOnInit() {
  console.log('init dynamic', this.dynamicDiv); // undefined
}

ngAfterViewInit() {
  console.log('after view init dynamic', this.dynamicDiv); // div
}
Makes sense as AfterViewInit is called when the template initialization is done.
But in fact, if the queried element is static (not wrapped in an ngIf or an ngFor), then it is available in ngOnInit also:

#staticDiv>static

gives:
@ViewChild('staticDiv') staticDiv: ElementRef<HTMLDivElement>;

ngOnInit() {
  console.log('init static', this.staticDiv); // div
}

ngAfterViewInit() {
  console.log('after view init static', this.staticDiv); // div
}
This was not documented, or recommended, but that’s how it currently works.
With Ivy though, the behavior changes to be more consistent:
ngOnInit() {
  console.log('init static', this.staticDiv); // undefined (changed)
}

ngAfterViewInit() {
  console.log('after view init static', this.staticDiv); // div
}
A new static flag has been introduced to not break existing applications, so if you want to keep the old behavior even when you’ll switch to Ivy, you can write:
@ViewChild('static', { static: true }) static: ElementRef<HTMLDivElement>;
and the behavior will be the same as the current one (the element is also accessible in ngOnInit).
Note that if you add static: true on a dynamic element (wrapped in a condition or a loop), then it will not be accessible in ngOnInit nor in ngAfterViewInit!
static: false will be how Ivy behaves by default.
To not break existing applications and to ease the migration, the Angular team wrote a schematic that automatically analyzes your application, and adds the static flag. It even offers two strategies:
  • one based on your templates, which will make sure that your application works (so it tends to mark queries as static even when they aren’t). You are sure it works, but it exposes you to problems if you wrap your static element in a condition or a loop later.
  • one based on your usage of the query, which is more error-prone (as it is harder for the schematic to figure it out), but will not mark the queries as static if they don’t need to be. So most queries will have static: false, which will be the default in Ivy.
The first strategy is used by default when you run ng update because it is the safest, but you can try the usage strategy by using NG_STATIC_QUERY_USAGE_STRATEGY=true ng update.
You can check out the official guide for more information.
This is what the migration looks like (with a failure in one component):
------ Static Query Migration ------
With Angular version 8, developers need to
explicitly specify the timing of ViewChild and
ContentChild queries. Read more about this here:
https://v8.angular.io/guide/static-query-migration

Some queries could not be migrated automatically. Please go
those manually and apply the appropriate timing.
For more info on how to choose a flag, please see:
https://v8.angular.io/guide/static-query-migration
   home/home.component.ts@43:3: undefined
Note that this only concerns ViewChild and ContentChild, not ViewChildren and ContentChildren (which will work the same way in Ivy and View Engine).

vendredi 4 octobre 2019

Spring Data

Implémentant les opérations de base et le design pattern Repository du DDD (Domain Driven Design),
Spring Data s'interface avec plusieurs sources de données parmi lesquelles JPA, Neo4j, MongoDB, GemFire, Hadoop, ElasticSearch, REST, Redis, Couchbase et quelques autres, via Spring Data Commons
il contient trois interfaces qui prennent deux types de paramètres :

  •  le type de l'entité que l'on manipule et
  •  le type de l'identifiant de l'entité  
  • Repository
  • CrudRepository :  méthodes CRUD pour la source de données sous-jacente (savefindOnefindAll, etc.).
  • PagingAndSortingRepository:un ensemble de méthodes permettant de faire de la pagination et du tri



imageimage

3 different XML design styles: Russian Dolls,Salami Slice,and Venetian Blind

http://timzhao.blogspot.com/2010/09/3-different-xml-design-styles-russian.html
https://mostlybuggy.wordpress.com/2012/06/06/note-to-self-xml-schema-design-patterns-in-a-nutshell/

Le modèle le plus utilisé est : Russian Doll (ou poupée Russe). Ce design pattern propose d’utiliser un seul élément racine global (la grande poupée) pour tous les éléments qu’il contient (les autres poupées s’imbriquent dans la principale). Ainsi, toutes les balises et éléments à l’intérieur de cette racine sont des éléments locaux. Le modèle de conception Russian Doll utilise les caractéristiques suivantes :
  • Le document est composé d’une seule racine globale.
  • Tous les types sont locaux.
  • Le Schema XML associé doit être présent dans un seul fichier.
  • Le Schema est complet car il encapsule les types.
  • C’est le modèle le plus simple à lire et à écrire.

Le design pattern DTO : containers de données

Le design pattern Data Transfer Object (DTO) de préference immuable est un conteneur métier respectant les spécifications fonctionnelles au niveau des constructeurs et des attributs, mais n’implémentant aucune logique métier au niveau de ses méthodes. Une classe DTO est, en effet, uniquement un conteneur permettant de transporter des informations métier.

Chaque classe DTO respecte le standard POJO et offre ainsi la sérialisation permettant la communication avec n’importe quels plate-forme et langage. DTO est un nom générique utilisé pour le transfert des données. Ce type d’objet préserve la simplicité de la sémantique et de la manipulation des classes tout en proposant une communication distante dans une architecture distribuée.
Cette technique consiste à créer une instance DTO contenant toutes les données nécessaires, puis à modifier la signature de la méthode distante pour qu’elle accepte le DTO en tant que paramètre unique. Une fois que l’application appelante a reçu et stocké le DTO en local, celle-ci peut utiliser le DTO comme objet local. Le but étant de créer des objets de transfert afin de récupérer un maximum d’informations ou des informations selon une structure particulière en une seule étape.
La structure de ces objets est composée de l’union des attributs issus des objets métiers dont les informations doivent être manipulées par notre application et accessibles par l’intermédiaire des getters et setters correspondants.