Les Apache Commons

Apache Commons est l’un des principaux projets de la fondation Apache.
Il est composé d’un ensemble de bibliothèques open-sources et réutilisables mettant une multitude d’utilitaires à la disposition des développeurs Java.

Le projet est composé de 3 parties :

  • The Commons Proper : Principale partie, elle contient l’ensemble des utilitaires Java.
  • The Commons Sandbox : Repository SVN qui fonctionne comme un workspace pour la collaboration sur les projets en cours, destinés à faire partie des Commons Proper.
  • The Commons Dormant : Projets de Sandbox qui sont inactifs.

Commons Proper est composé de nombreux modules qui regroupent des utilitaires par sujets. On trouve par exemple : Commons Collections, Commons Lang, Commons Logging,  Commons Pool, …

Pour quoi faire ?

Le travail de développeur consiste non seulement à écrire du code, mais également et surtout à réutiliser ce qui existe déjà.
En plus d’être généralement moins couteux en temps et en énergie, la réutilisation réduit le travail redondant et permet d’utiliser du code qui a été pensé et écrit de manière optimale. C’est donc un gain de temps et de performance (à condition de ne pas prendre n’importe quel code …).
Les Apache Commons sont créés avec cette optique. Ils proposent de très nombreux utilitaires pour répondre aux petits problèmes auxquels sont régulièrement confrontés les développeurs. Ils sont simples et rapides à mettre en place et à comprendre et existent pour des sujets divers et variés.

Que ce soit pour travailler sur des Strings ou des Collections, en ligne de commande, pour communiquer avec une base de données, lire des fichiers de configuration, logger, travailler avec des fichiers XML, créer des emails, uploader du contenu, faire des statistiques, … (la liste est longue !) il y a les Apache Commons pour nous simplifier la vie !

Exemples :

Etablir une liste exhaustive de ce que proposent les Apache Commons prendrait beaucoup de temps.
Je vais donc présenter par des exemples quelques une des librairies existantes.

Commons Lang :

Additions au package java.lang : chaines de caractères, calculs, réflexion, sérialization, etc.

1
2
3
4
5
6
7
8
StringUtils.isBlank(" "); // true
StringUtils.leftPad("12345", 10, '0'); // 0000012345
StringUtils.isNumeric("45a4"); // false
StringUtils.swapCase("The dog has a BONE"); // "tHE DOG HAS A bone"
StringUtils.equalsIgnoreCase("bonjour", "BonJouR"); // true
BooleanUtils.toBoolean("truez"); // false
BooleanUtils.isTrue(null); // false
ClassUtils.getPackageName(Main.class); // com.test

ToStringBuilder :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import org.apache.commons.lang.builder.ToStringBuilder;

import org.apache.commons.lang.builder.ToStringStyle;

public class ExampleToStringBuilder {
private String name;
private int counter;
private boolean isOk;
public ExampleToStringBuilder(String name, int counter, boolean isOk) {
this.name = name;
this.counter = counter;
this.isOk = isOk;
}
public String toString() {
return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
}
public static void main(String[] args) {
ExampleToStringBuilder ex = new ExampleToStringBuilder("bonjour", 123, true);
System.out.println(ex);
}
}

Ce qui affiche : “ExampleToStringBuilder[name=bonjour,counter=123,isOk=true]

Il existe le même genre d’outils utilisant la réflexion avec EqualsBuilder ou encore HashCodeBuilder :

1
2
3
4
5
6
7
8
9
10
11
public boolean equals(Object obj) {
if (obj instanceof Person) {
Person other = (Person) obj;
return new EqualsBuilder() //
.append(getId(), other.getId()) //
.append(getName(), other.getName()) //
.append(isFemale(), other.isFemale()) //
.isEquals();
}
return false;
}

Commons Configuration :

Cette librairie propose une manière générique de charger sa configuration en provenance de sources très diverses. Elle permet également un accès typé aux paramètres :

1
2
Double double = config.getDouble("number");
Integer integer = config.getInteger("number");

La configuration peut être chargée en provenance de multiples sources :

  • Properties files
  • XML documents
  • Windows INI files
  • Property list files (plist)
  • JNDI
  • JDBC Datasource
  • System properties
  • Applet parameters
  • Servlet parameters

Commons Collections :

Cette librairie est construite comme une couche supplémentaire sur les Collections du JDK. Elle propose des utilitaires pour travailler avec les collections, mais également de nouvelles interfaces et implémentations.

Parmi les utilitaires, on trouve une classe par interface de Collection du SDK (MapUtils, ListUtils, …).

Pour ce qui est des interfaces, on a notamment Predicate qui est utilisée pour évaluer un objet, c’est-à-dire vérifier qu’il remplit bien certaines conditions, ou encore Transformer, qui permet de transformer un objet en un autre selon des critères définis dans les implémentations.

Il y a aussi de nouvelles Collections comme le Bag qui représente une collection d’objet avec un certain nombre de copies pour chaque élément :

1
2
3
4
Bag bag = new HashBag();
bag.add("ONE", 6); // Ajoute 6 copies de "ONE"
bag.remove("ONE", 2); // Enlève 2 copies de "ONE"
bag.getCount("ONE"); // retourne 4

Une nouvelle hiérarchie totale de Collection est proposée pour les map bidirectionnelles : BidiMap.

1
2
3
4
5
6
BidiMap bidi = new TreeBidiMap();
bidi.put("SIX", "6");
bidi.get("SIX"); // returns "6"
bidi.getKey("6"); // returns "SIX"
bidi.removeValue("6"); // removes the mapping
BidiMap inverse = bidi.inverseBidiMap(); // retourne une map avec les clefs et les valeurs inversées

Et ce n’est encore une fois que de simples exemples parmi tant d’autres possibles !

Conclusion

Les Apaches Commons peuvent être utiles quotidiennement. Il est bon de savoir que ces librairies existent, et d’aller voir régulièrement s’il n’y a pas une méthode correspondant à ce que l’on cherche avant de l’écrire soit même !
Les sources sont également très intéressantes pour regarder comment de simples choses peuvent être faites de manière performante.

Je n’ai donné ici qu’un très bref aperçu de l’étendue de ces librairies, à vous d’aller en voir plus !

VN:R_U [1.9.22_1171]
Rating: 0 (from 0 votes)
Share
Ce contenu a été publié dans Java, Non classé, Trucs & astuces. Vous pouvez le mettre en favoris avec ce permalien.

Une réponse à Les Apache Commons

  1. Ces librairies sont effectivement très populaires et très répandues. Le hic, c’est que ces projets sont pour la plupart restés dormants pendant des années et ont loupé le passage à Java 5 et l’apparition des generics. C’est par exemple ce qui a conduit certains à forker commons-collections en collections-generic.
    Certains projets viennent de se réveiller, mais ils ont fait le choix de se forker : changement de groupId, d’artifactId et de package.
    Par exemple commons-lang devient commons-lang3, commons-digester devient commons-digester3.
    Certes, cette stratégie évitent tout effort de migration, mais bonjour la duplication de code…

    VN:R_U [1.9.22_1171]
    Rating: 0 (from 0 votes)

Laisser un commentaire