[Service Component Architecture] questions concernant les specifications SCA
Bonjour
je suis en train de lire les spécifications SCA.
J'utilise la solution Tuscany et je me base sur leurs exemples écrits en Java.
Il y a plusieurs points qui me posent problème.
1/ annotation @Reference
on peut definir un service auquel un composant fait appel a l'aide de la balise
@Reference mais de differentes manieres. Via l'injection sur l'attribut d'une classe, via l'injection "setter method". ou via un parametre dans le constructeur
(ref. Java Common Annotation and API p.26, Java Component Implementation Specification p.4)
Exemple Calculator:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| public class CalculatorServiceImpl implements CalculatorService {
protected AddService addService;
protected SubtractService subtractService;
//injection setter method
@Reference
public void setAddService(AddService addService) {
this.addService = addService;
}
@Reference
public void setSubtractService(SubtractService subtractService) {
this.subtractService = subtractService;
}
public double add(double n1, double n2) {
return addService.add(n1, n2);
}
public double subtract(double n1, double n2) {
return subtractService.subtract(n1, n2);
}
} |
ou bien
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| public class CalculatorServiceImpl implements CalculatorService {
// injection sur attribut
@Reference
protected AddService addService;
@Reference
protected SubtractService subtractService;
public void setAddService(AddService addService) {
this.addService = addService;
}
public void setSubtractService(SubtractService subtractService) {
this.subtractService = subtractService;
}
public double add(double n1, double n2) {
return addService.add(n1, n2);
}
public double subtract(double n1, double n2) {
return subtractService.subtract(n1, n2);
}
} |
Pourquoi choisir une manière plutôt qu'une autre ?
2/ annotation @Service
Un service peut etre defini de deux manieres (ref Java Component Implementation p.2 )
Au travers d'une interface ou bien d'une implémentation.
Exemple:
Code:
1
2
3
4
5
6
7
8
| //interface HelloService definit 'hello'
@Service (HelloService.class)
Public class HelloServiceImpl implements HelloService {
public String hello(String message) {
…
}
} |
Code:
1
2
3
4
5
6
7
8
| //implementation du service 'hello'
@Service (HelloServiceImpl.class)
Public class HelloServiceImpl implements AnotherInterface {
public String hello(String message) {
…
}
} |
Pourquoi en privilégier une ?
Si vous avez les idées claires sur ces aspects, je suis preneur.
Merci
