Equals et Hashcode : Pourquoi et comment les redéfinir

Lorsque l'on veut utiliser des objets, plus précisément des bean entités, dans des collections, il faut redéfinir les méthodes equals() et hashcode(). Il est judicieux de réfléchir à la meilleure façon de les implémenter.

find(), get(), et load()

get(), load() vs find()
- get() et load() retournent un objet.
- find() retourne un liste.

load() vs get()
-l'objet n'existe ni en base ni dans le cache:
   - load() ne retourne jamais null. Il retourne une exception.
   - get() retourne null.
-l'objet existe en base ou dans le cache:
   - load() retourne un proxy des objets dépendants (initialisation paresseuse ou lazy loading).
   - get() retourne retourne toute la grappe de l'objet (i.e. avec les objets dépendants) initialisée. Ce qui entraîne de multiple requêtes (problème du N+1 requêtes).

Hibernate : Avantages / Inconvenients

Avantages
- Génère le code SQL --> L'application est plus portable. On peut changer de base de données sans difficulté.
- Persistance transparente. On peut faire de nos classes métiers des classes persistantes sans ajout de code.
- La récupération des données est optimisé grâce à un système de caches.

Inconvénient 
- Dure de faire des requêtes complexe.

Pourquoi choisir spring ?

Le framework Spring est une boite à outils très riche permettant de structurer, d'améliorer et de simplifier l'écriture d'application JavaEE. Spring est organisé en module.

C’est d’abord un conteneur léger implémentant le design pattern IoC. Il permet de gérer plus facilement les objets et leurs dépendances.  Cela assure une plus grande flexibilité, qui comme le veux le modèle d’architecture à n-couches, rend les composants facilement interchangeable.

Spring favorise aussi l'intégration avec de nombreux autres frameworks, notamment d

ans notre cas avec Hibernate.

Pour une application structurée en trois couches, Spring trouve naturellement sont utilité :

• la couche présentation : Spring MVC
• la couche service : Module de Transactions et de sécurité
• la couche accès aux données : Intégration d’Hibernate

Spring est une solution mature et complète pour couvrir toute la pile applicative du front à la persistance en passant par la couche métier.

Une bonne chose : les annotations

L'absence d'annotation rend les gros projets Spring assez compliqués à appréhender par des nouveaux venus. Le fait d'avoir la configuration séparée du code c'est un peu comme monter un meuble en ayant scotché le plan de montage sur le plafond de la pièce voisine : pas très pratique.

Bonnes pratiques de développement

Pourquoi la méthode en "V", ou de type "waterfall", en cascade, est has-been ? Les fameuses étapes spécification / conception / réalisation / validation, souffrent de problèmes chroniques :

• Les spécifications sont définies au début du projet, alors que c'est là qu'on est sait le moins.
• Les spécifications font rarement la différence entre ce qui est important de ce qui ne l'est pas.
• Les activités sont compartimentées en fonction des spécialités des développeurs, ce qui pose des problèmes de répartition des tâches et limite la circulation des connaissances dans l'équipe.

Les méthodes de l'Extrem Programing ou de l'Agile, apportent un peu de bon sens à tout ça. Voici une compilation des choses à faire ou ne pas faire.

La communication

• Le client est au centre du projet, de l'équipe). C'est le mieux placer pour définir au mieux ses besoins. Il arbitre les priorités (le product owner les défini et les planifie). Il apporte surtout ses connaissances métier à l'équipe.
• Faire travailler tous les développeurs ensemble. Que chacun sache ce que font les autres. Faire circuler l'information. Instaurer le pair programing. S'entre-aider. Faire des revues de codes par roulement. Sans oublier les réunions quotidiennes (stand-up meeting) pour que chacun connaisse l'état du projet.

Feedback

• Mettre en place un système d'intégration continue, style Jenkins, par jouer automatiquement une batteries de tests (unitaires et de régression), d'analyser le code, de connaitre l'état global de l'application.
• Fournir régulièrement des livrables. Il faut pouvoir montrer au client quelque chose de fonctionnel (même partiellement, mais en état de marche), pour qu'il puisse se rendre compte de l'avancement de l'application, et préciser ou corriger ses besoins.

Simplicité

• Il ne faut pas une spécification complète et détaillée du futur système
• Avoir une architecture et un code ouvert à tout changement et évolution, et facilement maintenable.

Tests Unitaires

• Aide à la conception détaillé
• Les écrire avant le code
• Ne doit pas passer au début 
• Doivent passer sans erreur avant d’intégrer le code
• Aide à la non régression, au changement de conception et au remaniement

Initialisation de classe et d'instance

Initialisation de classe

Java permet d'écrire du code d'initialisation de classe qui sera exécuté lors du chargement de la classe (en même temps que l'initialisation des champs statiques).

Ce bloc sert justement à initialiser les variables static. Il est appelé initialiseur statique.

Il est constitué d'un bloc d'instructions (entre accolades) précédé du mot-clé static.

Tests avec une base de données

Transaction et Rollback

Pour tester un composant qui utilise une base de bonnées (DAO par exemple) fait bien se qu'on lui demande (lecture, insertion, modification, delete), il faut à chaque fois insérer des valeurs, les modifier, les effacer, vider la ou les tables). Cela devient très vite fastidieux.

Un moyen de simplifier les choses est de jouer le test dans une transaction.

Tests : quelques définitions

Définitions d'un test

• Un test doit permettre de diagnostiquer un problème.
• Il doit si possible montrer où est le problème.
• Pour faire un test, on doit savoir quel résultat on attend.

On ne doit pas démontrer qu'un programme marche à l'aide des tests. Ils servent à mettre en évidence des erreurs.

UML : définitions objet, classe, associations

Classe
Représente la description abstraite d'un ensemble d'objets ayant les mêmes caractéristiques. On dit aussi qu'une classe est un type d'objet.

Objet
C'est une entité définie par une classe. Un objet possède une identité, un état et un comportement. C'est une instance, ou occurrence, d'une classe.

Association
Représente une relation durable entre deux classes.

Par défaut, l'association est bidirectionnel. Cependant, dans le cas où elle n'est pas bidirectionnelle, le trait est remplacé par un flèche ouverte.

La classe B est utilisée par la classe A.

Cardinalité
Aux extrémités d'une association figure peut figurer une indication de cardinalité, ou multiplicité, pour spécifier le nombre d'objets qui peuvent participé à la relation avec l'objet de l'autre extrémité.

0..1	Aucune ou une instance
1	Une instance exactement
0..* ou *	Aucune ou plusieurs instances
1..*	Une instance ou plusieurs (au moins une)

Agrégation
C'est un cas particulier d'association, non symétrique, c'est-à-dire qu'elle exprime une relation de contenance. On utilise un losange vide du côté de la classe qui initie la relation.

Une instance de la classe proche de ce losange "contient" une ou plusieurs instances de la classe en relation.
- Un panier peut avoir plusieurs articles.
- Un type d'article peut appartenir à plusieurs paniers.

Autre définition
Une relation d'agrégation indique un principe de subordination entre l'agrégat et les agrégées. Ici, l'agrégat est la classe qui regroupe les classes agrégées. Elle indique une "possession" : l'agrégat peut contenir plusieurs objets d'un même type. Par exemple, une classe Panier peut contenir un ou plusieurs objets de type Article.
Une agrégation veut dire:
- une classe (l'agrégée) fait d'une autre (l'agrégat)
- un changement d'état de l'agrégée entraîne un changement de l'agrégat
- de même, une action sur l'agrégée entraîne une action sur  l'agrégat
- un objet agrégé peut appartenir à plusieurs agrégats
- les deux objets de la relation peuvent exister indépendamment l'un de l'autre. La suppression de l'un n’entraîne pas la supression de l'autre.

Composition
C'est un agrégat plus fort (aussi appelée agrégation forte). On utilise un losange plein du côté de la classe qui initie la relation.

Une composition entre les classes A et B signifie que:
- Un instance de B ne peut appartenir qu'à une seule instance de A
- Les objets agrégés sont totalement dépendants de l'agrégat
- B ne peut exister sans A

JavaEE et modèle 3 couches

Le modèle d’application JavaEE repose sur une division des tâches en différentes éléments.

De fait, cette division est d’abord imposée par l’architecture physique de l’application. Lorsque l’on parle de “tiers” (i.e. application n-tiers), on parle de l’architecture technique. En divisant l’application en “tiers”, on répartit les composants applicatifs (et leur charge) sur plusieurs machines/serveurs.

Sur cette division s’appuie l’architecture n-couches, qui elle, découpe l’application de façon logique, en isolant les éléments selon leur tâche.

Dans une architecture en couche, les données circulent de façon linéaire entre la couche de présentation et la couche de données (et vis-versa). La règle du modèle à 3 couches est que le client (couche présentation) ne communique jamais avec la couche d’accès aux données.  Chaque couche est interfacée  avec la couche adjacente, et toutes les communications sont bidirectionnelles et passent toujours par la couche intermédiaire.

Spring MVC - @RequestMapping

Exemple @RequestMapping

Class	Method	Description
	@RequestMapping (value="/order.htm")	Maps to all requests on the order.htm URL.
@RequestMapping ("/order.htm")	@RequestMapping (method=RequestMethod.GET)	Maps to all GET requests to the order.html URL.
@RequestMapping ("/order.*")	@RequestMapping (method={RequestMethod.PUT, RequestMethod.POST})	Maps to all PUT and POST requests to the order.* URL. * means any suffix or extension such as .htm, .doc, .xls, and so on.
@RequestMapping (value="/customer.htm", consumes="application/json")	@RequestMapping (produces="application/xml")	Maps to all requests that post JSON and accept XML as a response.
@RequestMapping (value="/order.htm")	@RequestMapping (params="add-line", method=RequestMethod.POST)	Maps to all POST requests to the order.htm URL that include an addline parameter.
@RequestMapping (value="/order.htm")	@RequestMapping (headers="!VIA")	Maps to all requests to the order.htm URL that don’t include a VIA HTTP Header.

Les modificateurs

Les modificateurs d'accès

Un modificateur indique si les autres classes de l'application pourront accéder ou non à la classe / méthode / membre (appelé par la suite « item »). Il  permet de contrôler la visibilité des différents items et d'empêcher que des actions illégales soient effectuées sur les items.

- public : toutes les classes peuvent accéder à l'item
- protected : seules les classes dérivées et les classes du même package peuvent accéder à l'item
- private : l'item est seulement accessible depuis l'intérieur de la classe où il est défini.
- (par défaut) : sans modificateur d'accès, seules les classes du même package peuvent accéder à l'item.

Introduction à jQuery

Qu’est-ce que jQuery ?

• C'est un  framework Javascript, Open Source, populaire et bien documenté.
• Il est réguliérement mis à jour.
• Normalise les différences entre les navigateurs web.

Snippets Java

Itération inverse

En utilisant un ListIterator, qui dispose de méthodes hasPrevious() et previous() :

List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
ListIterator<Integer> it = nums.listIterator(nums.size());
while(it.hasPrevious()) {
   Integer num = it.previous();
   System.out.println(num);
}