[MVC] TransactionManager, JPA2 (hibernate) et impossible de catcher la ConstraintViolationException

TransactionManager, JPA2 (hibernate) et impossible de catcher la ConstraintViolationException

Bonjour à tous !

J'ai un gros soucis !
Je suis sur une appli Spring MVC (3.1), JPA2 (hibernate 4).
Et impossible de catcher ConstraintViolationException au niveau du DAO ou autre d'ailleurs ...
La cause mère est un

Code:

com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException: Duplicate entry

A mon avis le soucis vient de l'annotation qui est sur mon service :

Code:

@Transactional(propagation = Propagation.REQUIRED, readOnly = false)

car j'utilise les transactions manager par Spring.
Le seul moyen que j'ai trouver c'est de catcher l'exception au niveau du contrôleur mais bon c'est pas terrible du tout ... car ba du coup je suis obligé de catcher Exception ...

Alors je vous appel au secours !! car je dois livrer bientôt ...

Est ce qu'il y a moyen de gérer ça au niveau du service ou du dao ?

Est ce qu'il faut que je vire le transaction manager gérer par Spring ?
Et comment le remplacer ? si vous des exemples je suis preneur

Merci d'avance !

pose le code de ton entité et ton dao aussi de ton context et la stacktrace en entier.

ok alors voilà la stack 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
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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
Etat HTTP 500 -
 
type Rapport d'exception
 
message
 
description Le serveur a rencontré une erreur interne () qui l'a empêché de satisfaire la requête.
 
exception
 
org.springframework.web.util.NestedServletException: Request processing failed; nested exception is org.springframework.orm.jpa.JpaSystemException: org.hibernate.exception.ConstraintViolationException: Duplicate entry 'bl-grey' for key 'ref'; nested exception is javax.persistence.PersistenceException: org.hibernate.exception.ConstraintViolationException: Duplicate entry 'bl-grey' for key 'ref'
	org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:894)
	org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:789)
	javax.servlet.http.HttpServlet.service(HttpServlet.java:637)
	javax.servlet.http.HttpServlet.service(HttpServlet.java:717)
	org.tuckey.web.filters.urlrewrite.RuleChain.handleRewrite(RuleChain.java:176)
	org.tuckey.web.filters.urlrewrite.RuleChain.doRules(RuleChain.java:145)
	org.tuckey.web.filters.urlrewrite.UrlRewriter.processRequest(UrlRewriter.java:92)
	org.tuckey.web.filters.urlrewrite.UrlRewriteFilter.doFilter(UrlRewriteFilter.java:381)
	org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter.doFilterInternal(OpenEntityManagerInViewFilter.java:147)
	org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
	org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:88)
	org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
 
cause mère
 
org.springframework.orm.jpa.JpaSystemException: org.hibernate.exception.ConstraintViolationException: Duplicate entry 'bl-grey' for key 'ref'; nested exception is javax.persistence.PersistenceException: org.hibernate.exception.ConstraintViolationException: Duplicate entry 'bl-grey' for key 'ref'
	org.springframework.orm.jpa.EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(EntityManagerFactoryUtils.java:326)
	org.springframework.orm.jpa.DefaultJpaDialect.translateExceptionIfPossible(DefaultJpaDialect.java:120)
	org.springframework.orm.jpa.JpaTransactionManager.doCommit(JpaTransactionManager.java:516)
	org.springframework.transaction.support.AbstractPlatformTransactionManager.processCommit(AbstractPlatformTransactionManager.java:754)
	org.springframework.transaction.support.AbstractPlatformTransactionManager.commit(AbstractPlatformTransactionManager.java:723)
	org.springframework.transaction.interceptor.TransactionAspectSupport.commitTransactionAfterReturning(TransactionAspectSupport.java:393)
	org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:120)
	org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:202)
	$Proxy35.merge(Unknown Source)
	com.demkocompany.controller.admin.AdminProductController.post(AdminProductController.java:357)
	sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
	sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	java.lang.reflect.Method.invoke(Method.java:616)
	org.springframework.web.method.support.InvocableHandlerMethod.invoke(InvocableHandlerMethod.java:212)
	org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:126)
	org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:96)
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:617)
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:578)
	org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:80)
	org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:900)
	org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:827)
	org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:882)
	org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:789)
	javax.servlet.http.HttpServlet.service(HttpServlet.java:637)
	javax.servlet.http.HttpServlet.service(HttpServlet.java:717)
	org.tuckey.web.filters.urlrewrite.RuleChain.handleRewrite(RuleChain.java:176)
	org.tuckey.web.filters.urlrewrite.RuleChain.doRules(RuleChain.java:145)
	org.tuckey.web.filters.urlrewrite.UrlRewriter.processRequest(UrlRewriter.java:92)
	org.tuckey.web.filters.urlrewrite.UrlRewriteFilter.doFilter(UrlRewriteFilter.java:381)
	org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter.doFilterInternal(OpenEntityManagerInViewFilter.java:147)
	org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
	org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:88)
	org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
 
cause mère
 
javax.persistence.PersistenceException: org.hibernate.exception.ConstraintViolationException: Duplicate entry 'bl-grey' for key 'ref'
	org.hibernate.ejb.AbstractEntityManagerImpl.convert(AbstractEntityManagerImpl.java:1360)
	org.hibernate.ejb.AbstractEntityManagerImpl.convert(AbstractEntityManagerImpl.java:1288)
	org.hibernate.ejb.TransactionImpl.commit(TransactionImpl.java:78)
	org.springframework.orm.jpa.JpaTransactionManager.doCommit(JpaTransactionManager.java:512)
	org.springframework.transaction.support.AbstractPlatformTransactionManager.processCommit(AbstractPlatformTransactionManager.java:754)
	org.springframework.transaction.support.AbstractPlatformTransactionManager.commit(AbstractPlatformTransactionManager.java:723)
	org.springframework.transaction.interceptor.TransactionAspectSupport.commitTransactionAfterReturning(TransactionAspectSupport.java:393)
	org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:120)
	org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:202)
	$Proxy35.merge(Unknown Source)
	com.demkocompany.controller.admin.AdminProductController.post(AdminProductController.java:357)
	sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
	sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	java.lang.reflect.Method.invoke(Method.java:616)
	org.springframework.web.method.support.InvocableHandlerMethod.invoke(InvocableHandlerMethod.java:212)
	org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:126)
	org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:96)
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:617)
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:578)
	org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:80)
	org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:900)
	org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:827)
	org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:882)
	org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:789)
	javax.servlet.http.HttpServlet.service(HttpServlet.java:637)
	javax.servlet.http.HttpServlet.service(HttpServlet.java:717)
	org.tuckey.web.filters.urlrewrite.RuleChain.handleRewrite(RuleChain.java:176)
	org.tuckey.web.filters.urlrewrite.RuleChain.doRules(RuleChain.java:145)
	org.tuckey.web.filters.urlrewrite.UrlRewriter.processRequest(UrlRewriter.java:92)
	org.tuckey.web.filters.urlrewrite.UrlRewriteFilter.doFilter(UrlRewriteFilter.java:381)
	org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter.doFilterInternal(OpenEntityManagerInViewFilter.java:147)
	org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
	org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:88)
	org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
 
cause mère
 
org.hibernate.exception.ConstraintViolationException: Duplicate entry 'bl-grey' for key 'ref'
	org.hibernate.exception.internal.SQLExceptionTypeDelegate.convert(SQLExceptionTypeDelegate.java:75)
	org.hibernate.exception.internal.StandardSQLExceptionConverter.convert(StandardSQLExceptionConverter.java:49)
	org.hibernate.engine.jdbc.spi.SqlExceptionHelper.convert(SqlExceptionHelper.java:125)
	org.hibernate.engine.jdbc.spi.SqlExceptionHelper.convert(SqlExceptionHelper.java:110)
	org.hibernate.engine.jdbc.internal.proxy.AbstractStatementProxyHandler.continueInvocation(AbstractStatementProxyHandler.java:129)
	org.hibernate.engine.jdbc.internal.proxy.AbstractProxyHandler.invoke(AbstractProxyHandler.java:81)
	$Proxy30.executeUpdate(Unknown Source)
	org.hibernate.engine.jdbc.batch.internal.NonBatchingBatch.addToBatch(NonBatchingBatch.java:56)
	org.hibernate.persister.entity.AbstractEntityPersister.update(AbstractEntityPersister.java:3014)
	org.hibernate.persister.entity.AbstractEntityPersister.updateOrInsert(AbstractEntityPersister.java:2916)
	org.hibernate.persister.entity.AbstractEntityPersister.update(AbstractEntityPersister.java:3245)
	org.hibernate.action.internal.EntityUpdateAction.execute(EntityUpdateAction.java:113)
	org.hibernate.engine.spi.ActionQueue.execute(ActionQueue.java:362)
	org.hibernate.engine.spi.ActionQueue.executeActions(ActionQueue.java:354)
	org.hibernate.engine.spi.ActionQueue.executeActions(ActionQueue.java:276)
	org.hibernate.event.internal.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:326)
	org.hibernate.event.internal.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:52)
	org.hibernate.internal.SessionImpl.flush(SessionImpl.java:1127)
	org.hibernate.internal.SessionImpl.managedFlush(SessionImpl.java:325)
	org.hibernate.engine.transaction.internal.jdbc.JdbcTransaction.beforeTransactionCommit(JdbcTransaction.java:101)
	org.hibernate.engine.transaction.spi.AbstractTransactionImpl.commit(AbstractTransactionImpl.java:175)
	org.hibernate.ejb.TransactionImpl.commit(TransactionImpl.java:73)
	org.springframework.orm.jpa.JpaTransactionManager.doCommit(JpaTransactionManager.java:512)
	org.springframework.transaction.support.AbstractPlatformTransactionManager.processCommit(AbstractPlatformTransactionManager.java:754)
	org.springframework.transaction.support.AbstractPlatformTransactionManager.commit(AbstractPlatformTransactionManager.java:723)
	org.springframework.transaction.interceptor.TransactionAspectSupport.commitTransactionAfterReturning(TransactionAspectSupport.java:393)
	org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:120)
	org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:202)
	$Proxy35.merge(Unknown Source)
	com.demkocompany.controller.admin.AdminProductController.post(AdminProductController.java:357)
	sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
	sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	java.lang.reflect.Method.invoke(Method.java:616)
	org.springframework.web.method.support.InvocableHandlerMethod.invoke(InvocableHandlerMethod.java:212)
	org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:126)
	org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:96)
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:617)
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:578)
	org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:80)
	org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:900)
	org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:827)
	org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:882)
	org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:789)
	javax.servlet.http.HttpServlet.service(HttpServlet.java:637)
	javax.servlet.http.HttpServlet.service(HttpServlet.java:717)
	org.tuckey.web.filters.urlrewrite.RuleChain.handleRewrite(RuleChain.java:176)
	org.tuckey.web.filters.urlrewrite.RuleChain.doRules(RuleChain.java:145)
	org.tuckey.web.filters.urlrewrite.UrlRewriter.processRequest(UrlRewriter.java:92)
	org.tuckey.web.filters.urlrewrite.UrlRewriteFilter.doFilter(UrlRewriteFilter.java:381)
	org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter.doFilterInternal(OpenEntityManagerInViewFilter.java:147)
	org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
	org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:88)
	org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
 
cause mère
 
com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException: Duplicate entry 'bl-grey' for key 'ref'
	sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:57)
	sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	java.lang.reflect.Constructor.newInstance(Constructor.java:532)
	com.mysql.jdbc.Util.handleNewInstance(Util.java:409)
	com.mysql.jdbc.Util.getInstance(Util.java:384)
	com.mysql.jdbc.SQLError.createSQLException(SQLError.java:1041)
	com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3566)
	com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3498)
	com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:1959)
	com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2113)
	com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2568)
	com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:2113)
	com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2409)
	com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2327)
	com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2312)
	com.mchange.v2.c3p0.impl.NewProxyPreparedStatement.executeUpdate(NewProxyPreparedStatement.java:105)
	sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
	sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	java.lang.reflect.Method.invoke(Method.java:616)
	org.hibernate.engine.jdbc.internal.proxy.AbstractStatementProxyHandler.continueInvocation(AbstractStatementProxyHandler.java:122)
	org.hibernate.engine.jdbc.internal.proxy.AbstractProxyHandler.invoke(AbstractProxyHandler.java:81)
	$Proxy30.executeUpdate(Unknown Source)
	org.hibernate.engine.jdbc.batch.internal.NonBatchingBatch.addToBatch(NonBatchingBatch.java:56)
	org.hibernate.persister.entity.AbstractEntityPersister.update(AbstractEntityPersister.java:3014)
	org.hibernate.persister.entity.AbstractEntityPersister.updateOrInsert(AbstractEntityPersister.java:2916)
	org.hibernate.persister.entity.AbstractEntityPersister.update(AbstractEntityPersister.java:3245)
	org.hibernate.action.internal.EntityUpdateAction.execute(EntityUpdateAction.java:113)
	org.hibernate.engine.spi.ActionQueue.execute(ActionQueue.java:362)
	org.hibernate.engine.spi.ActionQueue.executeActions(ActionQueue.java:354)
	org.hibernate.engine.spi.ActionQueue.executeActions(ActionQueue.java:276)
	org.hibernate.event.internal.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:326)
	org.hibernate.event.internal.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:52)
	org.hibernate.internal.SessionImpl.flush(SessionImpl.java:1127)
	org.hibernate.internal.SessionImpl.managedFlush(SessionImpl.java:325)
	org.hibernate.engine.transaction.internal.jdbc.JdbcTransaction.beforeTransactionCommit(JdbcTransaction.java:101)
	org.hibernate.engine.transaction.spi.AbstractTransactionImpl.commit(AbstractTransactionImpl.java:175)
	org.hibernate.ejb.TransactionImpl.commit(TransactionImpl.java:73)
	org.springframework.orm.jpa.JpaTransactionManager.doCommit(JpaTransactionManager.java:512)
	org.springframework.transaction.support.AbstractPlatformTransactionManager.processCommit(AbstractPlatformTransactionManager.java:754)
	org.springframework.transaction.support.AbstractPlatformTransactionManager.commit(AbstractPlatformTransactionManager.java:723)
	org.springframework.transaction.interceptor.TransactionAspectSupport.commitTransactionAfterReturning(TransactionAspectSupport.java:393)
	org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:120)
	org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
	org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:202)
	$Proxy35.merge(Unknown Source)
	com.demkocompany.controller.admin.AdminProductController.post(AdminProductController.java:357)
	sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
	sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	java.lang.reflect.Method.invoke(Method.java:616)
	org.springframework.web.method.support.InvocableHandlerMethod.invoke(InvocableHandlerMethod.java:212)
	org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:126)
	org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:96)
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:617)
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:578)
	org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:80)
	org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:900)
	org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:827)
	org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:882)
	org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:789)
	javax.servlet.http.HttpServlet.service(HttpServlet.java:637)
	javax.servlet.http.HttpServlet.service(HttpServlet.java:717)
	org.tuckey.web.filters.urlrewrite.RuleChain.handleRewrite(RuleChain.java:176)
	org.tuckey.web.filters.urlrewrite.RuleChain.doRules(RuleChain.java:145)
	org.tuckey.web.filters.urlrewrite.UrlRewriter.processRequest(UrlRewriter.java:92)
	org.tuckey.web.filters.urlrewrite.UrlRewriteFilter.doFilter(UrlRewriteFilter.java:381)
	org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter.doFilterInternal(OpenEntityManagerInViewFilter.java:147)
	org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
	org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:88)
	org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:76)
 
note La trace complète de la cause mère de cette erreur est disponible dans les fichiers journaux de Apache Tomcat/6.0.32.
Apache Tomcat/6.0.32

voici mon entité :

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
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
169
170
171
172
 
package com.demkocompany.domain;
 
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.MapKey;
import javax.persistence.OneToMany;
import javax.persistence.OrderBy;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;
 
import com.demkocompany.util.NumberTools;
 
/**
 * Product @author arthur barbaray
 */
 
@Entity
@Table(name = "T_PRODUCT", catalog = "DEMKOSHOP")
public class Product implements Serializable {
 
	/**
         * 
         */
	private static final long serialVersionUID = -5085385311193144189L;
 
	@Id
	@Column(name = "id", unique = true, nullable = false)
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Integer id;
 
	@Column(name = "ref", unique = true)
	private String ref;
 
	@ManyToOne(fetch = FetchType.LAZY)
	@JoinColumn(name = "category_id")
	private Category category;
 
	@Column(name = "ean13", unique = true, nullable = true)
	private String ean13 = null;
 
	@Column(name = "upc", unique = true, nullable = true)
	private String upc = null;
 
	@Column(name = "quantity")
	private Integer quantity;
 
	@Column(name = "minimal_quantity")
	private Integer minimal_quantity;
 
	@Column(name = "price")
	private Double price;
 
	public Product() {
	}
 
	public Product(Integer id) {
		this.id = id;
	}
 
	public Integer getId() {
		return this.id;
	}
 
	public void setId(Integer id) {
		this.id = id;
	}
 
	public String getRef() {
		return this.ref;
	}
 
	public void setRef(String ref) {
		this.ref = ref;
	}
 
	public Category getCategory() {
		return this.category;
	}
 
	public void setCategory(Category category) {
		this.category = category;
	}
 
	public void setOnlineOnly(Boolean online_only) {
		this.online_only = online_only;
	}
 
	public String getEan13() {
		return this.ean13;
	}
 
	public void setEan13(String ean13) {
		this.ean13 = ean13;
	}
 
	public String getUpc() {
		return this.upc;
	}
 
	public void setUpc(String upc) {
		this.upc = upc;
	}
 
	public Integer getQuantity() {
		return this.quantity;
	}
 
	public void setQuantity(Integer quantity) {
		this.quantity = quantity;
	}
 
	public Integer getMinimalQuantity() {
		return this.minimal_quantity;
	}
 
	public void setMinimalQuantity(Integer minimal_quantity) {
		this.minimal_quantity = minimal_quantity;
	}
 
	public Double getPrice() {
		return price;
	}
 
	public void setPrice(Double price) {
		this.price = price;
	}
 
 
 
 
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((id == null) ? 0 : id.hashCode());
		return result;
	}
 
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Product other = (Product) obj;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		return true;
	}
}

donc les champs pouvant causer des violations de contrainte sont "ref", "ean13" et "upc" , là lors de mon test c'est notamment le champ "ref" ....

voici le Dao générique :

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
143
144
145
146
147
 
package com.demkocompany.dao.generic;
 
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;
 
import javax.persistence.EntityExistsException;
import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceContext;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
 
 
public abstract class GenericJpaDao<E, ID extends Serializable> {
 
	protected Class<E> entityClass;
 
	protected EntityManager entityManager;
 
	public EntityManager getEntityManager() {
		return entityManager;
	}
 
	@PersistenceContext
	public void setEntityManager(EntityManager entityManager) {
		this.entityManager = entityManager;
	}
 
	@SuppressWarnings("unchecked")
	public GenericJpaDao() {
		ParameterizedType genericSuperclass = (ParameterizedType) getClass()
				.getGenericSuperclass();
		this.entityClass = (Class<E>) genericSuperclass
				.getActualTypeArguments()[0];
	}
 
	/**
         * Save an entity
         * 
         * @param entity
         */
	public int persist(E entity) {
		try {
			entityManager.persist(entity);
			return 1;
		} catch (EntityExistsException e) {
			return 0;
		} 
	}
 
	/**
         * Save an entity
         * 
         * @param entity
         */
	public E merge(E entity) {
		try {
			E en = entityManager.merge(entity);
			return en;
		} catch (EntityExistsException e) {
			return null;
		} 
 
	}
 
	/**
         * Delete an entity
         * 
         * @param entity
         */
	public void remove(E entity) {
		entityManager.remove(entity);
	}
 
	/**
         * Find an entity by id
         * 
         * @param id
         * @return Entity
         */
	public E findById(ID id) {
		E entity;
		try {
			entity = entityManager.find(entityClass, id);
		} catch (NoResultException e) {
			entity = null;
		}
		return entity;
	}
 
	/**
         * Find all the entities
         * 
         * @return List<Entity>
         */
	public List<E> findAll() {
		List<E> listEntity;
		try {
			CriteriaBuilder builder = entityManager.getCriteriaBuilder();
			CriteriaQuery<E> criteria = builder.createQuery(entityClass);
			Root<E> eRoot = criteria.from(entityClass);
			criteria.select(eRoot);
			listEntity = entityManager.createQuery(criteria).getResultList();
		} catch (NoResultException e) {
			listEntity = null;
		}
		return listEntity;
	}
 
	/**
         * Find all the entities with limit parameter
         * 
         * @return List<Entity>
         */
	public List<E> findAll(int limitFrom, int limitTo) {
		List<E> listEntity;
		try {
			CriteriaBuilder builder = entityManager.getCriteriaBuilder();
			CriteriaQuery<E> criteria = builder.createQuery(entityClass);
			Root<E> eRoot = criteria.from(entityClass);
			criteria.select(eRoot);
			listEntity = entityManager.createQuery(criteria)
					.setFirstResult(limitFrom).setMaxResults(limitTo)
					.getResultList();
		} catch (NoResultException e) {
			listEntity = null;
		}
		return listEntity;
	}
 
	/**
         * Count all the entities
         * 
         * @return Number of entities
         */
	public Long count() {
		CriteriaBuilder builder = entityManager.getCriteriaBuilder();
		CriteriaQuery<Long> criteria = builder.createQuery(Long.class);
		criteria.select(builder.count(criteria.from(entityClass)));
		Long res = entityManager.createQuery(criteria).getSingleResult();
		return res;
	}
 
}

le DAO Product :

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
 
package com.demkocompany.dao;
 
import java.util.List;
 
import javax.persistence.NoResultException;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.demkocompany.dao.generic.GenericJpaDao;
import com.demkocompany.domain.Category;
import com.demkocompany.domain.Product;
 
public class ProductDao extends GenericJpaDao<Product, Integer> {
 
	// private static final Logger
	private static Logger LOG = LoggerFactory.getLogger(ProductDao.class);
 
	public ProductDao() {
		LOG.info("Init Artist Jpa Dao");
	}
 
}

le service (l'implémentation) :

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
 
package com.demkocompany.service;
 
import java.util.List;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
 
import com.demkocompany.dao.ProductDao;
import com.demkocompany.domain.Category;
import com.demkocompany.domain.Product;
 
@Service("ProductManagerImpl")
@Transactional(propagation = Propagation.REQUIRED, readOnly = false)
public class ProductManagerImpl implements ProductManager {
 
	private ProductDao productDao;
 
	@Autowired
	public void setProductDao(ProductDao productDao) {
		this.productDao = productDao;
	}
 
	public ProductManagerImpl() {
		super();
	}
 
	public void create(Product product) {
		productDao.persist(product);
	}
 
	@Override
	public Product merge(Product product) {
		return productDao.merge(product);
	}
 
	@Override
	public void remove(Product product) {
		productDao.remove(product);
	}
 
	@Override
	public Product getById(Integer id) {
		return productDao.findById(id);
	}
 
	@Override
	public List<Product> getAll() {
		return productDao.findAll();
	}
 
	public List<Product> getAll(int limitFrom, int limitTo) {
		return productDao.findAll(limitFrom, limitTo);
	}
 
	@Override
	public List<Product> getByCategory(Category category, int firstResult,
			int maxResult) {
		return productDao.findByCategory(category, firstResult, maxResult);
	}
 
	@Override
	public Long countProduct() {
		return productDao.count();
	}
 
	@Override
	public Long countByCategory(Category category) {
		return productDao.countByCategory(category);
	}
 
}

la config spring (transaction) :

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
 
<?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:tx="http://www.springframework.org/schema/tx"
	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/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">
 
	<context:annotation-config />
 
	<bean
		class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />
	<bean
		class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
 
 
	<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
		<property name="persistenceUnitName" value="generic-dao" />
	</bean>
 
	<bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>
 
	<!-- enable the configuration of transactional behavior based on annotations -->
	<tx:annotation-driven transaction-manager="txManager" />
 
	<bean id="langDao" class="com.demkocompany.dao.LangDao">
	</bean>
 
	<!-- ************************ PRODUCT ************************* -->
	<bean id="productDao" class="com.demkocompany.dao.ProductDao">
	</bean>
 
 
 
</beans>

et c'est donc quand j'appelle la fonction merge du service que ça plante (lorsque que je tente de mettre une "ref" déjà existante dans un autre produit) ....
Le seule truc qui marche c'est de catcher mettre dans un try catch l'appel au merge , au niveau du controleur ! et c'est bien ce qui me pose probleme ...
Car soit il faut que je catch Exception soit JpaSystemException (qui n'a rien a foutre dans un contrôleur) ...

Je suis conscient qu'il faut que je check via des requête que mes "ref" ,"ean13" et "upc" n'existe pas avant de merger.
Mais il doit bien y avoir moyen de catcher la violation de contrainte au niveau du service ou du dao non ?

déjà tu ne fais pas d'injection de dépendance car tu ne travail pas avec des interfaces... ensuite je crois que tu confond merger et updater...après ton générique DAO au lieu de renvoyer des int et cacher la stack d'errur devrait plutôt renvoyer le résultat de son traitement.
Donc ce que je te propose de faire c'est d'vant de faire un save checker par un select pour voir si l'enregistrement que tu veux faire existe pas deja.
Une chose est sur il faut que tu reprenne ton generique dao.

Merci pour ta réactivité.

Cependant je ne capte pas tout a tes remarques ...

car j'utilise déjà des interfaces ... et je fais déjà de l'injection de dépendance ... sauf pour les DAO je n'utilise effectivement pas d'interface ...
bref ...

Sinon je vois pas trop ce que tu veux dire avec "ensuite je crois que tu confond merger et updater"
Update ça n'existe pas avec JPA ... c'est merge ou persist ... a priori persist c'est quand c'est une nouvelle entité ...merge pour updater ...
Enfin toutes les appli sur lesquel j'ai bossé fonctionne comme ça.

Sinon tu me parle d'int , j'en déduis donc que tu as regarder la methode persist.
Hors le persit de JPA renvoie void ... moi je voulais renvoyais qqch et certainement pas l'exception... et étant donné que la référence à l'objet est modifier, on a bien quand même le résultat .. bref ... c'est pas là que ce trouve mon problème.
Là la méthode en question utilise le Merge.

Mon générique DAO est inspirer de générique trouver sur le Net , notamment celui sur le site de JBoss. Mais je suis ouvert a tout autre exemple.

Enfin pour répondre a ta dernière remarque l'enregistrement existe déjà ... là en l’occurrence j'essaye de le modifier en utilisant une "ref" (avec la contrainte unique) qui existe déjà dans un autre enregistrement. afin justement de provoquer une exception ...

maintenant je pense avoir tout dit ;)

Donc la question reste , mais comment catcher cette exception et pas dans le contrôleur ?

juste avant ton operation tu peux faire un truc du genre

Code:

1
2
3
4
5
6
7
8
9
10
11
 
    Boolean isChampUniqueExists(Item i){
        try{
            Query q=em.createQuery("find Item as i where i.uniq = :uniq", Item.class);
            q.setParameter("uniq",i.uniq);
            q.getSingleResult()
        }catch(NoResultException nre){
            return false
        }
        return true;
    }

suivant le resultat tu vois si tu peux mettre a jour ou sauver

oui voilà comme je disais , je suis tout à fait conscient qu'il faut faire ça pour savoir si les champs unique existe ou pas ...

Il n'y a donc pas moyen de catcher une exception de ce type dans le service ...
ou même mieux de pouvoir afficher direct qqch avec les validateurs de form ...
genre paf ... ça me colle direct l'erreur dans le l'objet BindingResult pour afficher un message d'erreur sur le champs du formulaire du "La référence existe déjà" ...
un genre de couplage avec la validation JSR303 mais pour les contraintes de BDD, ça serait le top ;)

tu peux laisser remonter l'exception dans le service ou le controlleur, ce sera pas le même type que dans le code au dessus ce sera une javax.persistence.PersistenceException cette fois ci.

Quand a bean validation et contrainte sur le contenu de la base de données, non c'est pas possible.

Le problème avec un exception jpa dans une couche au dessus de dao c'est que ça crée une adhérence et plus moyen de changer de techno alors que si tu le fais direct dans le dao le service ne sera pas au courant de l’implémentation du dao et de ses exceptions...

Si tu tiens vraiment a gérer ce cas par une exception tu peux créer ton exception qui sera lancé a partir de ton dao.

Le problème si je catch PersitenceException c'est que j'ai quand même une exception TransactionSystemException qui remonte et pas le choix de la catcher dans le controleur ... j'imagine que c'est lié au transaction manager de Spring et donc a l'annotation @Transactionnal que j'ai dans mon service ...
Et pas moyen de capter direct c'est exception dans le service ... j'ai testé et elle arrive quand même dans le controleur ...

d'ailleurs pour avoir ça il faut que fasse un flush après le merge dans mon générique ...
Sinon c'est une JpaSystemException qui remonte jusqu'à mon controleur ... je comprend pas trop pourquoi ...
Toujours est il que dans tous les cas ça me plait pas ...

L'unique solution reste de tester avec une méthode du genre que tu m'as mis en exemple ...
C'est quand meme con qu'il n'y est pas une exception du genre ConstraintsViolationException dans le package javax.persistence ... du même genre que EntityExistsException qui elle, est tout a fait catchable dans le DAO ... bref c'est un manque je trouve ... car le fait de vouloir quand même catcher cette exception même si je test les contraintes avant de faire le merge ne me parait pas complètement débile ... on est jamais trop prudent il me semble ;)

Spring enveloppe les exceptions et ensuite te redonne celle de base a savoir une jpa exception dans ce cas donc si en amont tu catch celle de jpa alors spring ne la renverra plus car elle aura été catché avant.
Et oui c'est pas bête et a faire de vérifier la validité des données avant de les sauver.

justement non ! j'ai beau catcher les exceptions de jpa dans le dao c'est quand meme une TransactionSystemException qui ressort et la cause mère est javax.persistence.RollbackException pourtant je catch cette erreur dans le DAO générique ... j'ai également essayer de la catcher dans le service et c'est pareil ... je pense que c'est qqch spécifique lié au transaction manager de spring ... car j'ai vu d'autre gens sur le net qui semble avoir le même soucis et aucun n'a l'air d'avoir la solution ...