001: //$Id: EventListeners.java 8416 2005-10-16 13:27:54Z epbernard $
002: package org.hibernate.event;
003:
004: import java.io.Serializable;
005: import java.lang.reflect.Field;
006: import java.util.Collections;
007: import java.util.HashMap;
008: import java.util.Map;
009:
010: import org.hibernate.AssertionFailure;
011: import org.hibernate.MappingException;
012: import org.hibernate.cfg.Configuration;
013: import org.hibernate.event.def.DefaultAutoFlushEventListener;
014: import org.hibernate.event.def.DefaultDeleteEventListener;
015: import org.hibernate.event.def.DefaultDirtyCheckEventListener;
016: import org.hibernate.event.def.DefaultEvictEventListener;
017: import org.hibernate.event.def.DefaultFlushEntityEventListener;
018: import org.hibernate.event.def.DefaultFlushEventListener;
019: import org.hibernate.event.def.DefaultInitializeCollectionEventListener;
020: import org.hibernate.event.def.DefaultLoadEventListener;
021: import org.hibernate.event.def.DefaultLockEventListener;
022: import org.hibernate.event.def.DefaultMergeEventListener;
023: import org.hibernate.event.def.DefaultPersistEventListener;
024: import org.hibernate.event.def.DefaultPostLoadEventListener;
025: import org.hibernate.event.def.DefaultPreLoadEventListener;
026: import org.hibernate.event.def.DefaultRefreshEventListener;
027: import org.hibernate.event.def.DefaultReplicateEventListener;
028: import org.hibernate.event.def.DefaultSaveEventListener;
029: import org.hibernate.event.def.DefaultSaveOrUpdateCopyEventListener;
030: import org.hibernate.event.def.DefaultSaveOrUpdateEventListener;
031: import org.hibernate.event.def.DefaultUpdateEventListener;
032: import org.hibernate.event.def.DefaultPersistOnFlushEventListener;
033: import org.hibernate.util.Cloneable;
034:
035: /**
036: * A convience holder for all defined session event listeners.
037: *
038: * @author Steve Ebersole
039: */
040: public class EventListeners extends Cloneable implements Serializable {
041:
042: private LoadEventListener[] loadEventListeners = { new DefaultLoadEventListener() };
043: private SaveOrUpdateEventListener[] saveOrUpdateEventListeners = { new DefaultSaveOrUpdateEventListener() };
044: private MergeEventListener[] mergeEventListeners = { new DefaultMergeEventListener() };
045: private PersistEventListener[] persistEventListeners = { new DefaultPersistEventListener() };
046: private PersistEventListener[] persistOnFlushEventListeners = { new DefaultPersistOnFlushEventListener() };
047: private ReplicateEventListener[] replicateEventListeners = { new DefaultReplicateEventListener() };
048: private DeleteEventListener[] deleteEventListeners = { new DefaultDeleteEventListener() };
049: private AutoFlushEventListener[] autoFlushEventListeners = { new DefaultAutoFlushEventListener() };
050: private DirtyCheckEventListener[] dirtyCheckEventListeners = { new DefaultDirtyCheckEventListener() };
051: private FlushEventListener[] flushEventListeners = { new DefaultFlushEventListener() };
052: private EvictEventListener[] evictEventListeners = { new DefaultEvictEventListener() };
053: private LockEventListener[] lockEventListeners = { new DefaultLockEventListener() };
054: private RefreshEventListener[] refreshEventListeners = { new DefaultRefreshEventListener() };
055: private FlushEntityEventListener[] flushEntityEventListeners = { new DefaultFlushEntityEventListener() };
056: private InitializeCollectionEventListener[] initializeCollectionEventListeners = { new DefaultInitializeCollectionEventListener() };
057:
058: private PostLoadEventListener[] postLoadEventListeners = { new DefaultPostLoadEventListener() };
059: private PreLoadEventListener[] preLoadEventListeners = { new DefaultPreLoadEventListener() };
060:
061: private PreDeleteEventListener[] preDeleteEventListeners = {};
062: private PreUpdateEventListener[] preUpdateEventListeners = {};
063: private PreInsertEventListener[] preInsertEventListeners = {};
064: private PostDeleteEventListener[] postDeleteEventListeners = {};
065: private PostUpdateEventListener[] postUpdateEventListeners = {};
066: private PostInsertEventListener[] postInsertEventListeners = {};
067: private PostDeleteEventListener[] postCommitDeleteEventListeners = {};
068: private PostUpdateEventListener[] postCommitUpdateEventListeners = {};
069: private PostInsertEventListener[] postCommitInsertEventListeners = {};
070:
071: private SaveOrUpdateEventListener[] saveEventListeners = { new DefaultSaveEventListener() };
072: private SaveOrUpdateEventListener[] updateEventListeners = { new DefaultUpdateEventListener() };
073: private MergeEventListener[] saveOrUpdateCopyEventListeners = { new DefaultSaveOrUpdateCopyEventListener() };//saveOrUpdateCopy() is deprecated!
074:
075: private static Map eventInterfaceFromType;
076:
077: static {
078: eventInterfaceFromType = new HashMap();
079:
080: eventInterfaceFromType.put("auto-flush",
081: AutoFlushEventListener.class);
082: eventInterfaceFromType.put("merge", MergeEventListener.class);
083: eventInterfaceFromType
084: .put("create", PersistEventListener.class);
085: eventInterfaceFromType.put("create-onflush",
086: PersistEventListener.class);
087: eventInterfaceFromType.put("delete", DeleteEventListener.class);
088: eventInterfaceFromType.put("dirty-check",
089: DirtyCheckEventListener.class);
090: eventInterfaceFromType.put("evict", EvictEventListener.class);
091: eventInterfaceFromType.put("flush", FlushEventListener.class);
092: eventInterfaceFromType.put("flush-entity",
093: FlushEntityEventListener.class);
094: eventInterfaceFromType.put("load", LoadEventListener.class);
095: eventInterfaceFromType.put("load-collection",
096: InitializeCollectionEventListener.class);
097: eventInterfaceFromType.put("lock", LockEventListener.class);
098: eventInterfaceFromType.put("refresh",
099: RefreshEventListener.class);
100: eventInterfaceFromType.put("replicate",
101: ReplicateEventListener.class);
102: eventInterfaceFromType.put("save-update",
103: SaveOrUpdateEventListener.class);
104: eventInterfaceFromType.put("save",
105: SaveOrUpdateEventListener.class);
106: eventInterfaceFromType.put("update",
107: SaveOrUpdateEventListener.class);
108: eventInterfaceFromType.put("pre-load",
109: PreLoadEventListener.class);
110: eventInterfaceFromType.put("pre-update",
111: PreUpdateEventListener.class);
112: eventInterfaceFromType.put("pre-delete",
113: PreDeleteEventListener.class);
114: eventInterfaceFromType.put("pre-insert",
115: PreInsertEventListener.class);
116: eventInterfaceFromType.put("post-load",
117: PostLoadEventListener.class);
118: eventInterfaceFromType.put("post-update",
119: PostUpdateEventListener.class);
120: eventInterfaceFromType.put("post-delete",
121: PostDeleteEventListener.class);
122: eventInterfaceFromType.put("post-insert",
123: PostInsertEventListener.class);
124: eventInterfaceFromType.put("post-commit-update",
125: PostUpdateEventListener.class);
126: eventInterfaceFromType.put("post-commit-delete",
127: PostDeleteEventListener.class);
128: eventInterfaceFromType.put("post-commit-insert",
129: PostInsertEventListener.class);
130: eventInterfaceFromType = Collections
131: .unmodifiableMap(eventInterfaceFromType);
132: }
133:
134: public Class getListenerClassFor(String type) {
135: Class clazz = (Class) eventInterfaceFromType.get(type);
136:
137: if (clazz == null) {
138: throw new MappingException("Unrecognized listener type ["
139: + type + "]");
140: }
141:
142: return clazz;
143: }
144:
145: public LoadEventListener[] getLoadEventListeners() {
146: return loadEventListeners;
147: }
148:
149: public void setLoadEventListeners(
150: LoadEventListener[] loadEventListener) {
151: this .loadEventListeners = loadEventListener;
152: }
153:
154: public ReplicateEventListener[] getReplicateEventListeners() {
155: return replicateEventListeners;
156: }
157:
158: public void setReplicateEventListeners(
159: ReplicateEventListener[] replicateEventListener) {
160: this .replicateEventListeners = replicateEventListener;
161: }
162:
163: public DeleteEventListener[] getDeleteEventListeners() {
164: return deleteEventListeners;
165: }
166:
167: public void setDeleteEventListeners(
168: DeleteEventListener[] deleteEventListener) {
169: this .deleteEventListeners = deleteEventListener;
170: }
171:
172: public AutoFlushEventListener[] getAutoFlushEventListeners() {
173: return autoFlushEventListeners;
174: }
175:
176: public void setAutoFlushEventListeners(
177: AutoFlushEventListener[] autoFlushEventListener) {
178: this .autoFlushEventListeners = autoFlushEventListener;
179: }
180:
181: public DirtyCheckEventListener[] getDirtyCheckEventListeners() {
182: return dirtyCheckEventListeners;
183: }
184:
185: public void setDirtyCheckEventListeners(
186: DirtyCheckEventListener[] dirtyCheckEventListener) {
187: this .dirtyCheckEventListeners = dirtyCheckEventListener;
188: }
189:
190: public FlushEventListener[] getFlushEventListeners() {
191: return flushEventListeners;
192: }
193:
194: public void setFlushEventListeners(
195: FlushEventListener[] flushEventListener) {
196: this .flushEventListeners = flushEventListener;
197: }
198:
199: public EvictEventListener[] getEvictEventListeners() {
200: return evictEventListeners;
201: }
202:
203: public void setEvictEventListeners(
204: EvictEventListener[] evictEventListener) {
205: this .evictEventListeners = evictEventListener;
206: }
207:
208: public LockEventListener[] getLockEventListeners() {
209: return lockEventListeners;
210: }
211:
212: public void setLockEventListeners(
213: LockEventListener[] lockEventListener) {
214: this .lockEventListeners = lockEventListener;
215: }
216:
217: public RefreshEventListener[] getRefreshEventListeners() {
218: return refreshEventListeners;
219: }
220:
221: public void setRefreshEventListeners(
222: RefreshEventListener[] refreshEventListener) {
223: this .refreshEventListeners = refreshEventListener;
224: }
225:
226: public InitializeCollectionEventListener[] getInitializeCollectionEventListeners() {
227: return initializeCollectionEventListeners;
228: }
229:
230: public void setInitializeCollectionEventListeners(
231: InitializeCollectionEventListener[] initializeCollectionEventListener) {
232: this .initializeCollectionEventListeners = initializeCollectionEventListener;
233: }
234:
235: public FlushEntityEventListener[] getFlushEntityEventListeners() {
236: return flushEntityEventListeners;
237: }
238:
239: public void setFlushEntityEventListeners(
240: FlushEntityEventListener[] flushEntityEventListener) {
241: this .flushEntityEventListeners = flushEntityEventListener;
242: }
243:
244: public SaveOrUpdateEventListener[] getSaveOrUpdateEventListeners() {
245: return saveOrUpdateEventListeners;
246: }
247:
248: public void setSaveOrUpdateEventListeners(
249: SaveOrUpdateEventListener[] saveOrUpdateEventListener) {
250: this .saveOrUpdateEventListeners = saveOrUpdateEventListener;
251: }
252:
253: public MergeEventListener[] getMergeEventListeners() {
254: return mergeEventListeners;
255: }
256:
257: public void setMergeEventListeners(
258: MergeEventListener[] mergeEventListener) {
259: this .mergeEventListeners = mergeEventListener;
260: }
261:
262: public PersistEventListener[] getPersistEventListeners() {
263: return persistEventListeners;
264: }
265:
266: public void setPersistEventListeners(
267: PersistEventListener[] createEventListener) {
268: this .persistEventListeners = createEventListener;
269: }
270:
271: public PersistEventListener[] getPersistOnFlushEventListeners() {
272: return persistOnFlushEventListeners;
273: }
274:
275: public void setPersistOnFlushEventListeners(
276: PersistEventListener[] createEventListener) {
277: this .persistOnFlushEventListeners = createEventListener;
278: }
279:
280: public MergeEventListener[] getSaveOrUpdateCopyEventListeners() {
281: return saveOrUpdateCopyEventListeners;
282: }
283:
284: public void setSaveOrUpdateCopyEventListeners(
285: MergeEventListener[] saveOrUpdateCopyEventListener) {
286: this .saveOrUpdateCopyEventListeners = saveOrUpdateCopyEventListener;
287: }
288:
289: public SaveOrUpdateEventListener[] getSaveEventListeners() {
290: return saveEventListeners;
291: }
292:
293: public void setSaveEventListeners(
294: SaveOrUpdateEventListener[] saveEventListener) {
295: this .saveEventListeners = saveEventListener;
296: }
297:
298: public SaveOrUpdateEventListener[] getUpdateEventListeners() {
299: return updateEventListeners;
300: }
301:
302: public void setUpdateEventListeners(
303: SaveOrUpdateEventListener[] updateEventListener) {
304: this .updateEventListeners = updateEventListener;
305: }
306:
307: public PostLoadEventListener[] getPostLoadEventListeners() {
308: return postLoadEventListeners;
309: }
310:
311: public void setPostLoadEventListeners(
312: PostLoadEventListener[] postLoadEventListener) {
313: this .postLoadEventListeners = postLoadEventListener;
314: }
315:
316: public PreLoadEventListener[] getPreLoadEventListeners() {
317: return preLoadEventListeners;
318: }
319:
320: public void setPreLoadEventListeners(
321: PreLoadEventListener[] preLoadEventListener) {
322: this .preLoadEventListeners = preLoadEventListener;
323: }
324:
325: public PostDeleteEventListener[] getPostDeleteEventListeners() {
326: return postDeleteEventListeners;
327: }
328:
329: public PostInsertEventListener[] getPostInsertEventListeners() {
330: return postInsertEventListeners;
331: }
332:
333: public PostUpdateEventListener[] getPostUpdateEventListeners() {
334: return postUpdateEventListeners;
335: }
336:
337: public void setPostDeleteEventListeners(
338: PostDeleteEventListener[] postDeleteEventListener) {
339: this .postDeleteEventListeners = postDeleteEventListener;
340: }
341:
342: public void setPostInsertEventListeners(
343: PostInsertEventListener[] postInsertEventListener) {
344: this .postInsertEventListeners = postInsertEventListener;
345: }
346:
347: public void setPostUpdateEventListeners(
348: PostUpdateEventListener[] postUpdateEventListener) {
349: this .postUpdateEventListeners = postUpdateEventListener;
350: }
351:
352: public PreDeleteEventListener[] getPreDeleteEventListeners() {
353: return preDeleteEventListeners;
354: }
355:
356: public void setPreDeleteEventListeners(
357: PreDeleteEventListener[] preDeleteEventListener) {
358: this .preDeleteEventListeners = preDeleteEventListener;
359: }
360:
361: public PreInsertEventListener[] getPreInsertEventListeners() {
362: return preInsertEventListeners;
363: }
364:
365: public void setPreInsertEventListeners(
366: PreInsertEventListener[] preInsertEventListener) {
367: this .preInsertEventListeners = preInsertEventListener;
368: }
369:
370: public PreUpdateEventListener[] getPreUpdateEventListeners() {
371: return preUpdateEventListeners;
372: }
373:
374: public void setPreUpdateEventListeners(
375: PreUpdateEventListener[] preUpdateEventListener) {
376: this .preUpdateEventListeners = preUpdateEventListener;
377: }
378:
379: /**
380: * Call <tt>initialize()</tt> on any listeners that implement
381: * <tt>Initializable</tt>.
382: * @see Initializable
383: */
384: public void initializeListeners(Configuration cfg) {
385: Field[] fields = getClass().getDeclaredFields();
386: for (int i = 0; i < fields.length; i++) {
387: Object[] listeners;
388: try {
389: Object listener = fields[i].get(this );
390: if (listener instanceof Object[]) {
391: listeners = (Object[]) listener;
392: } else {
393: continue;
394: }
395:
396: } catch (Exception e) {
397: throw new AssertionFailure("could not init listeners");
398: }
399: int length = listeners.length;
400: for (int index = 0; index < length; index++) {
401: Object listener = listeners[index];
402: if (listener instanceof Initializable) {
403: ((Initializable) listener).initialize(cfg);
404: }
405: }
406:
407: }
408: }
409:
410: public PostDeleteEventListener[] getPostCommitDeleteEventListeners() {
411: return postCommitDeleteEventListeners;
412: }
413:
414: public void setPostCommitDeleteEventListeners(
415: PostDeleteEventListener[] postCommitDeleteEventListeners) {
416: this .postCommitDeleteEventListeners = postCommitDeleteEventListeners;
417: }
418:
419: public PostInsertEventListener[] getPostCommitInsertEventListeners() {
420: return postCommitInsertEventListeners;
421: }
422:
423: public void setPostCommitInsertEventListeners(
424: PostInsertEventListener[] postCommitInsertEventListeners) {
425: this .postCommitInsertEventListeners = postCommitInsertEventListeners;
426: }
427:
428: public PostUpdateEventListener[] getPostCommitUpdateEventListeners() {
429: return postCommitUpdateEventListeners;
430: }
431:
432: public void setPostCommitUpdateEventListeners(
433: PostUpdateEventListener[] postCommitUpdateEventListeners) {
434: this.postCommitUpdateEventListeners = postCommitUpdateEventListeners;
435: }
436:
437: }
|