Participez à la FAQ Spring [FAQ]

**Mickael Baron** · 22/10/2007, 21h18

Bonjour,

La FAQ Spring est ouverte à tous, vous pouvez donc y participer activement. Soit vous pouvez poster vos questions et réponses dans cette enfilade, soit vous pouvez utiliser l'application collaborative d'édition de FAQ.

L'adresse de la FAQ : http://java.developpez.com/faq/spring/

Merci à tous pour vos contributions.

L'équipe Java

**michaelcourcy** · 13/11/2007, 15h25

Si la Session Factory d'hibernate est géré par Spring il est alors possible d'utiliser un filtre mis à disposition par le framework Spring.

Ce filtre commit la transaction après le traitement par la servlet (ou l'action de votre framework préféré), puis recommence une transaction pour la présentation de la jsp ou la techno de vue de votre choix.

Une fois la page rendue le filtre ferme la session. Cette stratégie est aussi utilisé par le framework JBoss Seam.

On configure le filtre dans web.xml :

Code :

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

1
2
3
4
5
6
7
8
9
 
<filter>
	<filter-name>Hibernate Session In View Filter</filter-name>
       <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
	<filter-name>Hibernate Session In View Filter</filter-name>
	<url-pattern>/*</url-pattern>
</filter-mapping>

Invité · 22/11/2007, 09h00

L'interface ApplicationContextAware est reconnue par Spring qui y injecte automatiquement le contexte de l'application courante via la méthode setApplicationContext(ApplicationContext context)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MyClass implement ApplicationContextAware {
 
  ApplicationContext context;
 
  public void setApplicationContext(ApplicationContext context ){
    this.context = context;
  }
 
  public AnotherClass getAnotherBean() {
    return (AnotherClass) context.getBean("anotherBean");
  }
 
}

**Hikage** · 22/11/2007, 09h11

C'est déjà dans la FAQ : http://java.developpez.com/faq/sprin...oncontextaware

;-)

**michaelcourcy** · 22/11/2007, 10h12

Je désapprouve l'utilisation de cette interface car on est couplé avec Spring.

**djo.mos** · 24/11/2007, 09h32

Bonjour.
Spring 2.5 offre enfin une nouvelle méthode d'intégration avec JSF compatible avec la version 1.2 (qui ne repose pas sur le VariableResolver, déprécié depuis JSF 1.2).

une mise à jour de la Q/R Comment utiliser Spring avec JSF ?
serait d'ajouter ce bout de code dans faces-config.xml:

Code xml :

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

1
2
3
4
<application> 
<el-resolver>org.springframework.web.jsf.el.SpringBeanFacesELResolver 
  </el-resolver> 
</application>

Le reste fonctionne exactement de la même façon qu'avec le DelegatingVariableResolver.

**ray_fab** · 18/01/2011, 23h09

Bonjour, Peut-on avoir une intégration de Spring dans Hibernate sans utiliser les fichiers de configurations des 2 frameworks? mais soir en utilsant les fichiers properties soit une annotation? Pourquoi Spring n'a pas pensé à créer une simple annotation pour dans son intégration à Hibernate puis une classe créant l'insatnce d'une SessionFactory, ce qui permet de rendre l'utilisation d'une couche Dao sans configurer la SessionFactory dans le contexte? J'ai une solution. Elle consiste à créer une classe créant l'instance de la SessionFactory puis soit utiliser des fichiers properties soit utiliser une annotation. Merci de la tester et me donner votre avis:
La classe qui permet de créer la SessionFactory est la suivante:

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
public class SWESessionFactory extends AnnotationSessionFactoryBean{
	private static final Log log = LogFactory.getLog(SWESessionFactory.class);
	/*Le nom du fichier de properties contenant les classes*/
	private String annotatedClassesPropertiesFile="annotatedClasses.properties";
	/*Nom du fichier properties pour la connexion en base de données*/
	private String dataBasePropertiesFile="databaseProperties.properties";
	/*Nom du fichier properties pour les propriétés d'hibernate*/
	private String hibernatePropertiesFile="hibernateProperties.properties";
	/**
         * 
         */
	public SWESessionFactory() {
		// TODO Auto-generated constructor stub
		super();
	}
	/**
         * 
         * @param byProperties : si vrai alors la configuration doit être faite par
         * fichiers properties, faux on utilisation l'annotation SWEFactory
         * @return une instance de la session Factory
         */
	public final SessionFactory configure(boolean byProperties){
		if(byProperties)return propertiesConfiguration();
		return annotatedConfiguration();
	}
	/**
         * 
         * @return une instance de la session factory prêt à l'emploi
         * avec une configuration avec des fichiers properties
         */
	@SuppressWarnings("rawtypes")
	private final SessionFactory propertiesConfiguration(){
		log.debug("Initialisation de la sessionFactory par les fichiers de Properties");
		List<Class> classes = null;
		Class[] annotatedClasses;
		classes=loadClasses();
		annotatedClasses=classes.toArray(new Class[classes.size()]);
		setAnnotatedClasses(annotatedClasses);
		setHibernateProperties(loadPropertiesFile(hibernatePropertiesFile));
		setDataSource(loadDataSource(null));
		try {
			log.debug("Chargement de la session Factory");
			return buildSessionFactory();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			log.error("Le chargement de la session Factory a échoué");
			throw new SWEException("Impossible de localiser la SessionFactory",e);
		}
	}
	/**
         * 
         * @return une instance de la session factory prêt à l'emploi
         * Dans ce cas on impose à la classe Dao d'être annotée
         */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	private final SessionFactory annotatedConfiguration(){
		log.debug("Initialisation de la session Factory avec les annotations");
		StackTraceElement stes[]=Thread.currentThread().getStackTrace();
		SWEFactory swef=null;
		for(StackTraceElement ste:stes){
			String className=ste.getClassName();
			Class c=null;
			try {
				log.debug("Détermination de la classe courrente");
				c=getClass().getClassLoader().loadClass(className);
			} catch (ClassNotFoundException e) {
				log.debug("On ne passe pas ici");
				e.printStackTrace();
			}
			if(c.isAnnotationPresent(SWEFactory.class)){
				swef=(SWEFactory) c.getAnnotation(SWEFactory.class);
				log.debug("La classe courrente a été trouvée il déclare bien l'annotation SWEFactory :"+swef);
				break;
			}
		}
		setAnnotatedClasses(swef.annotatedClasses());
		Properties p=new Properties();
		PropertyDataSource pdss[]=swef.dataSource();
		for(PropertyDataSource pds:pdss)p.setProperty(pds.key().name(), pds.value());
		setDataSource(loadDataSource(p));
		p.clear();
		HibernateProperties hps[]=swef.hibernateProperties();
		for(HibernateProperties hp:hps)	p.setProperty(hp.key(), hp.value());
		setHibernateProperties(p);
		try {
			log.debug("Chargement de la session Factory");
			return buildSessionFactory();
		} catch (Exception e) {
			log.error("Le chargement de la session Factory a échoué");
		throw new SWEException("Impossible de localiser la SessionFactory",e);
		}
	}
	/**
         * 
         * @param annotatedClassesPropertiesFile: préciser le nom du fichier properties pour les classes
         */
	public void setAnnotatedPropertiesFile(String annotatedClassesPropertiesFile){
		this.annotatedClassesPropertiesFile=annotatedClassesPropertiesFile;
	}
	/**
         * 
         * @param dataBasePropertiesFile: préciser le nom du fichier properties pour la dataBaseProperties 
         */
	public void setDataBasePropertiesFile(String dataBasePropertiesFile){
		this.dataBasePropertiesFile=dataBasePropertiesFile;
	}
	/**
         * 
         * @param hibernatePropertiesFile: préciser le nom du fichier properties hibernate
         */
	public void setHibernatePropertiesFile(String hibernatePropertiesFile){
		this.hibernatePropertiesFile=hibernatePropertiesFile;
	}
	/**
         * 
         * @return la liste des classes annotées dans le fichier properties
         */
	@SuppressWarnings("rawtypes")
	private final List<Class> loadClasses(){
		List<Class> classes=new ArrayList<Class>();
		Properties p=null;
		log.debug("Localisons du fichier de properties "+annotatedClassesPropertiesFile);
		p = loadPropertiesFile(annotatedClassesPropertiesFile);
		Set<Entry<Object,Object>> set=p.entrySet();
		Iterator<Entry<Object,Object>> it=set.iterator();
		while(it.hasNext()){
			Entry<Object,Object> en=it.next();
			Class<?> c;
			String cls=en.getValue().toString();
			try {
				log.debug("Mise à jour de la classe "+cls);
				c = Class.forName(cls);
			} catch (ClassNotFoundException e) {
				log.error("La classe "+cls+" n'existe pas");
				throw new SWEException("La classe "+cls+" n'existe pas",e);
			}
			classes.add(c);
		}
		return classes;
	}
	/**
         * @param p: contient les propriétés de la base de données qui peut provenir soit
         * du fichier properties sot de l'annotation
         * @return l'instance de la DataSource qui nous permettra  d'établir une connexion 
         * à la base de données
         */
	private final DriverManagerDataSource loadDataSource(Properties p){
		DriverManagerDataSource dataSource=new DriverManagerDataSource();
		p=p==null?loadPropertiesFile(dataBasePropertiesFile):p;
		dataSource.setDriverClassName(p.getProperty("driverClassName"));
		dataSource.setPassword(p.getProperty("password"));
		dataSource.setUrl(p.getProperty("url"));
		dataSource.setUsername(p.getProperty("username"));
		dataSource.setConnectionProperties(p);
		return dataSource;
	}
	private final Properties loadPropertiesFile(String name){
		InputStream in=getClass().getClassLoader().getResourceAsStream(name);
		Properties p=new Properties();
		try {
			p.load(in);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return p;
	}
}

Cette classe peut être utilisée soit par des fichiers properties soit par une annotation dont le code est le suivant:

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
 
@Retention(RetentionPolicy.RUNTIME)
@Target ({ElementType.TYPE})
@Inherited
public @interface SWEFactory {
	@SuppressWarnings("rawtypes")
	public Class[] annotatedClasses();
	public PropertyDataSource[] dataSource();
	public HibernateProperties[] hibernateProperties();
	public @interface PropertyDataSource{
		public enum KEY {url,username,password,driverClassName};
		public KEY key();
		public String value();
	}
	public @interface HibernateProperties{
		public String key();
		public String value();
	}

Testez le sur une couche Dao et tenez moi au courant
Merci!

**ladeche** · 19/01/2011, 09h37

Je voudrais juste ajouter une petite précision à cette FAQ.
Il faudrait simplement préciser que cela fonctionne si on charge le contexte Spring dans un ApplicationContext. Ca ne fonctionne pas si on utilise directement une BeanFactory. Cette précision pourrait être utile pour les débutants à mon sens.