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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : Sélectionner tout - Visualiser dans une fenêtre à part
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