Dependency Injection pour chargement de paramètres de configuration issu d'un fichier externe à l'application.
Bonjour,
Mon application charge des paramètres initiaux dans un objet de configuration appelé Environnement.
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
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
| /**
* Détail d'un environnement.
*/
@XmlRootElement
public class Environnement implements Serializable {
/** Code de cet environnement. */
private CodeEnvironnement m_code;
/** Description de cet environnement. */
private String m_description;
/** Emplacement des images. */
private String m_emplacementImages;
/**
* Renvoyer le code de l'environnement.
* @return Code de l'environnement.
*/
public CodeEnvironnement getCode() {
return m_code;
}
/**
* Renvoyer la description de cet environnement.
* @return Description de l'environnement.
*/
public String getDescription() {
return m_description;
}
/**
* Renvoyer l'emplacement des images.
* @return Emplacement des images.
*/
public String getEmplacementImages() {
return m_emplacementImages;
}
/**
* Fixer le code environnement.
* @param code Code environnement.
*/
public void setCode(CodeEnvironnement code) {
m_code = code;
}
/**
* Fixer la description de l'environnement.
* @param description Description textuelle.
*/
public void setDescription(String description) {
m_description = description;
}
/**
* Fixer l'emplacement où se trouvent les images.
* @param emplacement Emplacement.
*/
public void setEmplacementImages(String emplacement) {
m_emplacementImages = emplacement;
}
} |
Cet objet est chargé depuis un fichier XML placé par un administrateur dans un répertoire de configuration du serveur d'application.
Code:
1
2
3
4
5
6
| <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<environnement>
<code><id>Env1</id></code>
<description>Préparation Test</description>
<emplacementImages>C:/images</emplacementImages>
</environnement> |
Le service de gestion des environnements précharge la description de ces environnements, en utilisant JAXB, et les met à disposition:
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
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
| /**
* Service de gestion des environnements.
*/
@Stateless @LocalBean public class ServiceGestionEnvironnementBean {
/** Premier environnement. */
private Environnement m_preparation;
/** Deuxième environnement. */
private Environnement m_production;
/**
* Obtenir la description des environnements.
*/
@PostConstruct public void initialisation()
{
m_preparation = chargerEnvironnement("preparation");
m_production = chargerEnvironnement("production");
}
/**
* Charger le détail d'un environnement.
* @param clef Clef de l'environnement.
* @return Environnement.
*/
private Environnement chargerEnvironnement(String clef)
{
// JBoss AS 7 ne met plus en classpath le contenu de son répertoire configuration: ceci est un workaround pour l'atteindre.
String home = System.getenv().get("JBOSS_HOME");
if (home == null)
throw(new NoSuchElementException("Définissez la variable d'environnement JBOSS_HOME."));
try
{
File file = new File(home + "/standalone/configuration/environnement_" + clef + ".xml");
JAXBContext ctx = JAXBContext.newInstance(new Class[] {Environnement.class});
Unmarshaller um = ctx.createUnmarshaller();
Environnement environnement = (Environnement)um.unmarshal(file);
return(environnement);
}
catch(JAXBException e)
{
throw(new RuntimeException(e.getMessage(), e));
}
}
/**
* Obtenir le détail de l'environnement de Préparation/Test.
* @return Environnement.
*/
public Environnement obtenirEnvironnementPreparation()
{
if (m_preparation == null)
throw(new RuntimeException("L'environnement de Préparation/Test n'a pas été chargé."));
return(m_preparation);
}
/**
* Obtenir le détail de l'environnement de Production/Publication.
* @return Environnement.
*/
public Environnement obtenirEnvironnementProduction()
{
if (m_production == null)
throw(new RuntimeException("L'environnement de Production/Publication n'a pas été chargé."));
return(m_production);
}
/**
* Obtenir le détail d'un environnement.
* @param code Code de l'environnement.
* @return Environnement.
*/
public Environnement obtenirEnvironnement(CodeEnvironnement code)
{
if (code.equals(CodeEnvironnement.PREPARATION))
return(m_preparation);
if (code.equals(CodeEnvironnement.PRODUCTION))
return(m_production);
throw(new NoSuchElementException(MessageFormat.format("Il n''y a pas d''environnement de code {0} défini", code)));
}
} |
Les modules qui ont besoin de connaitre le détail d'un environnement peuvent alors le faire en appelant obtenirEnvironnement(), obtenirEnvironnementPreparation() ou obtenirEnvironnementProduction().
Mais j'aimerais beaucoup pouvoir présenter le contenu d'un Environnement par le biais d'un simple:
@Inject(clef="preparation") Environnement envPreparation;
(ou une annotation spécifiquement créée, si c'est plus approprié?).
C'est à dire de pouvoir faire dé-sérialiser le contenu d'un document XML situé hors ear/war dans un objet par le biais d'une injection.
Comment dois-je procéder pour mettre en place cette injection de dépendance?
En vous remerciant,
Grunt.
