Problème EntityManager sous Hibernate / Tomcat

Version imprimable

Bonjour,

Je suis en train d'apprivoiser Hibernate pour ma culture personnelle.

Je me suis créé des cas de tests de lecture / MAJ dans une base de données MySQL :
- quand je teste sous Junit, tout marche,
- quand je fais des essais via une servlet Tomcat, çà coince :

J'ai le message "No Persistence provider for EntityManager named MonAppli".

Trace :

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
 
No Persistence provider for EntityManager named MonAppli
	at javax.persistence.Persistence.createEntityManagerFactory(Unknown Source)
	at javax.persistence.Persistence.createEntityManagerFactory(Unknown Source)
	at fr.pmo.monappli.DAO.MonAppliDAO.<init>(MonAppliDAO.java:26)
	at fr.pmo.monappli.DAO.liste.ListeDAO.<init>(ListeDAO.java:26)
	at fr.pmo.monappli.DAO.liste.ToutesListeDAO.<init>(ToutesListeDAO.java:20)
	at fr.pmo.monappli.liste.factory.ListeComplete.<init>(ListeComplete.java:32)
	at fr.pmo.monappli.liste.factory.ListeComplete.getInstance(ListeComplete.java:58)
	at fr.pmo.monappli.servlet.DetailMAJServlet.doPost(DetailMAJServlet.java:91)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:710)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:803)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:290)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
	at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:233)
	at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:175)
	at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:128)
	at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:102)
	at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:109)
	at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:286)
	at org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:844)
	at org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler.process(Http11Protocol.java:583)
	at org.apache.tomcat.util.net.JIoEndpoint$Worker.run(JIoEndpoint.java:447)
	at java.lang.Thread.run(Unknown Source)

Mon fichier est présent sous META-INF/persistence.xml :

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
 
<?xml version="1.0" encoding="UTF-8" ?> 
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence">
 
	<!--- Unite de persistence -->
	<persistence-unit name="MonAppli" transaction-type="JTA">
		<provider>org.hibernate.ejb.HibernatePersistence</provider>
 
		<properties>
			<!-- Classes persistentes -->
			<property name="hibernate.archive.autodetection" value="class, hbm" />
 
			<!-- logs SQL			-->
			<property name="hibernate.show_sql" value="true" />
			<property name="hibernate.format_sql" value="true" />
			<property name="use_sql_comments" value="true" />
 
			<!-- connexion JDBC -->
			<!-- Login et Password -->
			<property name="hibernate.connection.username" value="root" />
			<property name="hibernate.connection.password" value="" />
 
			<!-- Driver -->
			<property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />		
 
			<!-- URL -->
			<property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/MonAppli" />
 
			<!-- Dialecte -->
			<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
 
			<!-- proprietes DataSource c3p0 -->
-  			<property name="hibernate.c3p0.min_size" value="5" />
			<property name="hibernate.c3p0.max_size" value="20" />
			<property name="hibernate.c3p0.timeout" value="300" />
			<property name="hibernate.c3p0.max_statements" value="50" />
			<property name="hibernate.c3p0.idle_test_period" value="3000" />
		</properties>
	</persistence-unit>
</persistence>

Sous Junit, je mets la valeur de transaction-type="RESOURCE_LOCAL".
Mais j'ai lu dans un forum que pour l'utilisation en appli web, il fallait la renseigner avec "JTA".

L'appel à l'entitymanager se fait par la classe :

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
 
public class MonAppliDAO {
 
	/** le contexte de persistence */
	protected static EntityManagerFactory emf;	
 
 
	/**
         * constructeur
         *
         * @throws Exception
         */
	public MonAppliDAO() throws Exception {
 
		try {
			if (null == emf) {
				emf = Persistence.createEntityManagerFactory("MonAppli");
			}
		} catch (Exception e) {
			// des erreurs se sont produites
...
		}
	}
}

Les jar sont chargés depuis maven => extrait de mon pom.xml

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
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
 
	<build>
	    <sourceDirectory>${basedir}/WEB-INF/src</sourceDirectory>
	    <testSourceDirectory>${basedir}/test</testSourceDirectory>
  		<outputDirectory>${basedir}/WEB-INF/classes</outputDirectory>
   		<testOutputDirectory>${basedir}/WEB-INF/classes</testOutputDirectory>
	</build>
 
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<basedir>.</basedir>
		<env>LOCAL</env>
		<maven.test.failure.ignore>true</maven.test.failure.ignore>
		<junit-version>3.8.1</junit-version>
	 	<jta-version>1.1</jta-version>	
		<mysql-version>5.1.18</mysql-version>
		<itext-version>5.3.4</itext-version>
		<commons-lang-version>2.5</commons-lang-version>
		<hibernate-version>3.2.7.ga</hibernate-version>
		<hibernate-annotations-version>3.3.1.ga</hibernate-annotations-version>
		<hibernate-entitymanager-version>3.3.2.ga</hibernate-entitymanager-version>
		<c3p0-version>0.9.2-pre6</c3p0-version>
		<spring-version>3.1.0.RELEASE</spring-version>
	</properties>
 
	<dependencies>
   	    <dependency>
			<groupId>javax.transaction</groupId>
			<artifactId>jta</artifactId>
			<version>${jta-version}</version>
		</dependency>
 
		<!-- Junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit-version}</version>
			<scope>test</scope>
		</dependency>
 
		<!-- MySQL -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql-version}</version>
		</dependency>
 
		<!-- iText -->
		<dependency>
			<groupId>com.itextpdf</groupId>
			<artifactId>itextpdf</artifactId>
			<version>${itext-version}</version>
		</dependency>         
 
		<!-- commons-lang -->
		<dependency>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>${commons-lang-version}</version>
		</dependency>			
 
   		<!-- Hibernate -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate</artifactId>
			<version>${hibernate-version}</version>
		</dependency>
 
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-annotations</artifactId>
			<version>${hibernate-annotations-version}</version>
		</dependency>
 
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
			<version>${hibernate-entitymanager-version}</version>
		</dependency>
 
		<!-- c3p0 -->
		<dependency>
			<groupId>com.mchange</groupId>
			<artifactId>c3p0</artifactId>
			<version>${c3p0-version}</version>			
		</dependency>
 
		<!-- Spring Framework -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring-version}</version>
		</dependency>
 
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring-version}</version>
		</dependency>
 
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${spring-version}</version>
		</dependency>
 
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring-version}</version>
		</dependency>
 
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring-version}</version>
		</dependency>
 
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring-version}</version>
		</dependency>
 
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring-version}</version>
		</dependency>
 
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring-version}</version>
		</dependency>
 
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring-version}</version>
		</dependency>
	</dependencies>

Merci d'avance à ceux qui s'intéresseront à mon problème.

Cdt.

Salut,
avec spring tu ne met pas de transaction de type JTA, à moins de faire un appel au conteneur de servlet(ou server d'app) pour avoir une datasource de son pool, traditionnellement avec spring c'est le conteneur spring qui gère le pool de datasource, par l’intermédiaire de org.apache.commons.dbcp.BasicDataSource.
tel que :

Code:

1
2
3
4
5
6
7
8
9
10
11
    <bean id="dataSource"
          class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close"
          p:driverClassName="${database.driverClassName}"
          p:url="${database.url}"
          p:username="${database.username}"
          p:password="${database.password}"
          p:maxActive="50"
          p:maxIdle="30"
          p:validationQuery="select 1"
          p:initialSize="1"/>

Pour ma part je ne crée même pas de fichier persistence.xml je préfère le style sans xml avec package to scan tel que

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
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:util="http://www.springframework.org/schema/util" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-3.1.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
       http://www.springframework.org/schema/util
       http://www.springframework.org/schema/util/spring-util-3.1.xsd
">
 
    <context:annotation-config/>
    <context:component-scan base-package="fr.pmo"/>
 
    <aop:aspectj-autoproxy proxy-target-class="true"/>
 
    <context:property-placeholder location="classpath*:META-INF/spring/*.properties"/>
 
    <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>
 
    <bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>
 
    <bean id="dataSource"
          class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close"
          p:driverClassName="${database.driverClassName}"
          p:url="${database.url}"
          p:username="${database.username}"
          p:password="${database.password}"
          p:maxActive="50"
          p:maxIdle="30"
          p:validationQuery="select 1"
          p:initialSize="1"/>
 
    <bean id="jpaVendorAdapter"
          class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"
          p:showSql="${database.showSql}"
          p:database="${database.database}"
          p:databasePlatform="${database.hibernate.dialect}"/>
 
    <util:properties id="jpaProperties">
        <prop key="hibernate.hbm2ddl.auto">${database.hibernate.hbm2ddl.auto}</prop>
        <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
        <prop key="hibernate.connection.charSet">UTF-8</prop>
        <prop key="hibernate.cache.provider_class">org.hibernate.cache.NoCacheProvider</prop>
    </util:properties>
 
    <bean id="entityManagerFactory"
          class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
          p:packagesToScan="fr.pmo.package_domain"
          p:dataSource-ref="dataSource"
          p:jpaProperties-ref="jpaProperties"
          p:jpaVendorAdapter-ref="jpaVendorAdapter"/>
 
    <bean id="transactionManager"
          class="org.springframework.orm.jpa.JpaTransactionManager"
          p:entityManagerFactory-ref="entityManagerFactory"/>
 
    <tx:annotation-driven transaction-manager="transactionManager"/>

et tu vois que dans le fichier de config spring j'ai externalisé la conf dans des fichiers properties sur le chemin META-INF/spring/
J’espère avoir été clair sinon n’hésite pas pour plus d'info.

28/12/2012, 17h16
dwp29

Bonjour,

Merci pour cette réponse mais mon problème ne venait pas de Hibernate ou Spring.

L'anomalie vient de Maven / Tomcat / Eclipse :
- Maven crée les jar dans le repositionary local,
- il les ajoute au projet dans Eclipe sous forme de Maven Dependencies (liens vers le repositionary),
- Tomcat ne reconnait pas les jar hors du projet Eclipse ...

Si je recopie tous les jar du repositionary vers le WEB-INF/lib, çà marche !

Maintenant, je ne sais pas comment faire reconnaitre les Dependencies de Maven dans le Tomcat mais çà fera l'objet d'une autre discution ...
28/12/2012, 17h20
Khaled.Noordin

met les dependances qui posent problème en provided et tomcat fera le trie au runtime.