Dependency Injection pour chargement de paramètres de configuration issu d'un fichier externe à l'application.

**grunt2000** · 13/04/2012, 09h04

Bonjour,

Mon application charge des paramètres initiaux dans un objet de configuration appelé Environnement.

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
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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

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
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.

**manblaizo** · 13/04/2012, 17h51

Envoyé par grunt2000

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é?).
...

Comment dois-je procéder pour mettre en place cette injection de dépendance?

Bonjour,

Une solution serait d'utiliser des CDI Producer Methods combinés à un Qualifier.

Exemple:

-- Le Qualifier:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
import javax.inject.Qualifier;
...
@Qualifier
@Retention(RUNTIME)
@Target({METHOD, FIELD, PARAMETER, TYPE})
public @interface Env {
 
   CodeEnvironnement value();
 
}

-- Les Producer methods:

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
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
import javax.enterprise.inject.Produces;

/**
 * Service de gestion des environnements.
 */
@Singleton 
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");
	}

...

        /**
	 * Obtenir le détail de l'environnement de Préparation/Test.
	 * @return Environnement.
	 */
        @Produces @ApplicationScoped @Env(CodeEnvironnement.PREPARATION)
	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.
	 */
        @Produces @ApplicationScoped @Env(CodeEnvironnement.PRODUCTION)
	public Environnement obtenirEnvironnementProduction()
	{
		if (m_production == null)
			throw(new RuntimeException("L'environnement de Production/Publication n'a pas été chargé."));
 
		return m_production;
	}
...

}

Puis, au point d'injection:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
@Inject @Env(CodeEnvironnement.PREPARATION)
private Environnement envPreparation;

En tout cas, c'est ça l'idée, à toi de l'adapter pour la faire fonctionner, ça devrait répondre à ton besoin.

**grunt2000** · 26/04/2012, 14h12

Tes exemples comme ceux que j'ai pu voir par la suite semblent très clairs.
Cependant, j'ai l'impression que mon JBoss AS 7.1.1 ne parvient pas à injecter ce qu'il devrait.

Et je me demande s'il n'est pas défectueux.

Dependency Injection pour chargement de paramètres de configuration issu d'un fichier externe à l'application.

Java EE

Discussions similaires

Partager

Partager