Le squelette de la classe [Dao] est le suivant :

 

Sélectionnez

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.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.

package arduino.dao;

...

import com.google.gson.Gson;

public class Dao implements IDao {

  // injections Spring
  private IThreadDao recorder;
  private int timeoutConnection;
  private int timeoutRead;
  private Boolean traced;
  // données locales
  // dictionnaire des arduinos
  private Map<String, Arduino> arduinos = new HashMap<String, Arduino>();
  // verrou d'accès à la liste
  final private Object verrou = new Object();
  // mapper Json
  Gson jsonMapper = new Gson();

  // constructeur
  public Dao() {
  }

  // initialisation de la couche [dao]
  @SuppressWarnings("unused")
    private void init() {
    // lance le service d'enregistrement dans un thread à part
    recorder.setDao(this);
    new Thread(recorder).start();
  }

  // liste des Arduinos
  public Collection<Arduino> getArduinos() {
    // accès contrôlé
    synchronized (verrou) {
      return arduinos.values();
    }
  }

  // ajouter un arduino à la liste
  public void addArduino(Arduino arduino) {
    // accès contrôlé
    synchronized (verrou) {
        // on enregistre le nouvel arduino
        arduinos.put(arduino.getId(), arduino);
    }
  }

  // supprimer un arduino de la liste
  public void removeArduino(String id) {
    // accès contrôlé
    synchronized (verrou) {
      arduinos.remove(id);
    }
  }

  // envoyer des commandes [Commande] à un Arduino
  public List<Reponse> sendCommandes(String idArduino, List<Commande> commandes) {
    // on récupère l'arduino
    Arduino arduino = arduinos.get(idArduino);
    // a-t-on trouvé ?
    if (arduino == null) {
      throw new DomotiqueException(String.format("L'arduino [%s] n'existe pas", idArduino), 44);
    }
    // on exécute la liste des commandes
...
    // on rend la liste des réponses [Reponse]
    return réponses;
  }

  // envoyer des commandes Json à un arduino
  public List<String> sendCommandesJson(String idArduino, List<String> commandes) {
    // on récupère l'arduino
    Arduino arduino = arduinos.get(idArduino);
    // a-t-on trouvé ?
    if (arduino == null) {
      throw new DomotiqueException(String.format("L'arduino [%s] n'existe pas", idArduino));
    }
    // on exécute la liste des commandes
...
    // on rend la liste des réponses JSON
    return réponses;
  }

  // pour tracer l'échange avec l'arduino
  private void trace(String message) {
    trace(Level.INFO, String.format("RestServer Dao SendCommandesJson : [%s] : [%s]", new SimpleDateFormat("HH:mm:ss:SS").format(new Date()), message), null);
  }

  // logs
  private void trace(Level level, String message, Exception e) {
    String msg = String.format("Dao : [%s] : [%s]", new SimpleDateFormat("HH:mm:ss:SS").format(new Date()), message);
    if (e == null) {
      Logger.getLogger(Dao.class.getName()).log(level, msg);
    } else {
      Logger.getLogger(Dao.class.getName()).log(level, msg, e);
    }
  }

  // setters pour Spring
  ...
}

• ligne 10 : la couche [DAO] a une référence sur le serveur d'enregistrement ;
• ligne 11 : le délai d'attente maximal qu'attendra la couche [DAO] lorsqu'elle se connecte à un Arduino. Au-delà, elle lancera une exception [DomotiqueException] ;
• ligne 12 : le délai d'attente maximal qu'attendra la couche [DAO] lorsqu'elle atend une réponse d'un Arduino. Au-delà, elle lancera une exception [DomotiqueException] ;
• ligne 13 : un booléen qui indique si la couche [DAO] logue ou pas sur la console ce qu'elle fait ;
• ligne 16 : les Arduinos connectés seront maintenus dans un dictionnaire plutôt qu'une liste. En effet, les clients envoient des commandes à un Arduino identifié par son id. A partir de celui-ci, l'Arduino sera retrouvé plus facilement dans un dictionnaire que dans une liste ;
• ligne 18 : un serveur peut faire assurer le service d'un client par un thread dit de " service ". Ainsi si à un moment donné, il y a n clients, il y a n threads de service. Si dans notre exemple, le service des Arduinos était assuré par des threads de service, alors il serait possible que la méthode [addArduino] de la couche [DAO] soit appelée en même temps par deux ou plusieurs threads de service. On dit alors que la méthode [addArduino] est une ressource critique. L'accès à celle-ci doit être contrôlé afin qu'un seul thread n'y ait accès à la fois. Ici, nous n'avons pas choisi la solution des threads de service parce qu'elle n'était pas indispensable. Nous allons quand même, par souci de pédagogie et parce que c'est simple, synchroniser l'accès aux ressources critiques ;
• ligne 18 : un verrou contrôlera l'accès aux ressources critiques. C'est un simple objet ;
• ligne 45 : un exemple d'utilisation d'un verrou. La syntaxe :

 

Sélectionnez

1.
2.
3.

    synchronized (verrou) {
        ...
}

assure que le code de la ligne 2 ne sera exécuté que par un seul thread à la fois même si celui-ci est interrompu au milieu du code de la ligne 2. Le principe est le suivant :

• un premier thread arrivé en ligne 1. Le verrou est libre. Il le prend et exécute le code de la ligne 2. Il possède le verrou tant qu'il n'a pas passé la ligne 3,
• un second thread arrive. Si le verrou n'a pas été libéré par le thread précédent, il est bloqué. Il va attendre que le verrou se libère ;

On peut faire la même chose avec d'autres méthodes de synchronisation non présentées ici.

• lignes 74-85 : cette méthode est le coeur de la couche [DAO]. Elle envoie à l'Arduino identifié par le 1^er paramètre, la liste des commandes JSON identifiée par le second paramètre. Pour chaque commande, elle reçoit une réponse JSON. La méthode rend la liste des réponses JSON qu'elle a reçues ;
• lignes 60-71 : une méthode analogue mais avec des paramètres différents. Elle transforme sa liste de commande [Commande] en liste de commandes JSON et appelle la méthode [sendCommandesJson]. Elle reçoit une liste de réponses JSON qu'elle transforme en liste de réponses [Reponse].

 : Implémenter la classe [DAO]. Il s'agit d'écrire un client TCP-IP classique. On pourra s'aider du code du client TCP générique déjà utilisé pour des tests.

Exécutez les tests présentés au paragraphe , page .

La couche [DAO] peut être améliorée de diverses façons. En voici deux :

• un Arduino qui se connecte au serveur d'enregistrement est mémorisé. Si un utilisateur déconnecte son câble réseau ou son alimentation, l'Arduino n'est plus accessible mais reste mémorisé dans la couche [DAO]. On peut prévoir un thread qui à intervalles réguliers (10 secondes) essaierait de se connecter au port 102 de tous les Arduinos mémorisés. Lorsque l'un ne répond pas, il est enlevé de la liste des Arduinos mémorisés ;
• les adresses IP et Mac sont fixées par le développeur dans le code des Arduinos. Ainsi il n'est pas impossible de vouloir connecter deux Arduinos qui par erreur auraient la même adresse IP. La méthode [addArduino] de la couche [DAO] peut faire des tests. Si l'Arduino qui arrive, a la même adresse IP ou la même adresse Mac ou la même description qu'un Arduino déjà enregistré, son enregistrement est refusé et une exception [DomotiqueException] est lancée.