par , 20/03/2016 à 23h53 (2972 Affichages)
Lors de précédents billets, j'ai évoqué la migration d'application JEE vers des architectures JavaScript. Les migrations que j'ai expérimentées m'ont permis de porter des applications JEE vers AngularJS pour le front office et Node.js pour le back-office. Comme dans les blogs précédents, je rappelle que ces migrations sont envisageables pour des applications légères.
Dans ce billet, j'aborderai la migration des objets métier. En JEE ces objets métier sont des POJO (Plain Old Java Objects) c'est-à-dire des classes. Aussi ces objets pourront devenir en JavaScript des POJO (Plain Old Javascript Objects) c'est-à-dire encore des classes.
Pour être autorisé à parler de classes en JavaScript, il faut bien entendu implémenter le standard ES6.
Regardons de plus près comment on pourrait migrer un objet Owner qui agrégerait des objets cellules.
Voici une implémentation en Java :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
| public class Cellule {
// attributs
private String name = "";
private Owner owner = null;
// constructeur
public Cellule(String name){
this.setName(name);
}
// méthodes --> setter et getter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Owner getOwner() {
return owner;
}
public void setOwner(Owner owner) {
this.owner = owner;
}
}
public class Owner
{
// attributs
private ArrayList<Cellule> cellules;
// constructeur
public Owner(){
this.cellules = new ArrayList<Cellule>();
}
// méthodes
public int getSize(){
return this.cellules.size();
}
public int addElement(Cellule e){
if(e.getOwner() != this)
e.setOwner(this);
this.cellules.add(e);
return this.cellules.indexOf(e);
}
public Cellule getElementAtIndex(int index){
return this.cellules.get(index);
}
} |
Et maintenant l’implémentation en JavaScript :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| class Cellule {
constructor(name){
// attributs
this.name = name;
this.owner = null;
}
}
class Owner{
constructor(){
// attributs
this.cellules = [];
}
// methodes
getSize(){
return this.cellules.length;
}
addElement(cellule){
if(cellule.owner != this)
cellule.owner = this;
return this.cellules.push(cellule);
}
getElementAtIndex(index){
return this.cellules[index];
}
} |
On remarque que les règles de passage de Java à JavaScript semblent assez simples si on accepte quelques petites entorses aux règles strictes de l'objet et notamment l'encapsulation grâce aux mentions de protection. En effet, en Java les propriétés sont privateset donc seulement accessibles au travers de getter et setter. Tandis qu'en JavaScript, tout est public, mais cela permet de faire l'économie d'écriture des getter et setter.
Cependant, si l'on n'implémente pas l'héritage dans l'organisation des objets métier, on peut sans problème s'abstraire de ces mentions de protection. Et on remarque que l'on n'utilise que rarement l'héritage dans les tiers métier.
Donc, il semble que la migration des objets métier de Java à JavaScript soit assez simple.
Consulter le profil
Marquer ce blog comme lu
