1:
37:
38:
39: package ;
40:
41: import ;
42: import ;
43: import ;
44: import ;
45: import ;
46: import ;
47: import ;
48: import ;
49: import ;
50: import ;
51: import ;
52: import ;
53:
54:
64: public class BeanContextServicesSupport
65: extends BeanContextSupport
66: implements BeanContextServices
67: {
68: private static final long serialVersionUID = -8494482757288719206L;
69:
70: protected class BCSSChild
71: extends BeanContextSupport.BCSChild
72: {
73: private static final long serialVersionUID = -3263851306889194873L;
74:
75: BCSSChild(Object targetChild, Object peer)
76: {
77: super(targetChild, peer);
78: }
79: }
80:
81: protected class BCSSProxyServiceProvider
82: implements BeanContextServiceProvider,
83: BeanContextServiceRevokedListener
84: {
85: private static final long serialVersionUID = 7078212910685744490L;
86:
87: private BeanContextServiceProvider provider;
88:
89: public Iterator getCurrentServiceSelectors (BeanContextServices bcs,
90: Class serviceClass)
91: {
92: return provider.getCurrentServiceSelectors(bcs, serviceClass);
93: }
94:
95: public Object getService (BeanContextServices bcs,
96: Object requestor,
97: Class serviceClass,
98: Object serviceSelector)
99: {
100: return provider.getService(bcs, requestor, serviceClass,
101: serviceSelector);
102: }
103:
104: public void releaseService (BeanContextServices bcs,
105: Object requestor,
106: Object service)
107: {
108: provider.releaseService(bcs, requestor, service);
109: }
110:
111: public void serviceRevoked (BeanContextServiceRevokedEvent bcsre)
112: {
113: if (provider instanceof BeanContextServiceRevokedListener)
114: ((BeanContextServiceRevokedListener) provider).serviceRevoked(bcsre);
115: }
116: }
117:
118: protected static class BCSSServiceProvider
119: implements Serializable
120: {
121: private static final long serialVersionUID = 861278251667444782L;
122:
123: protected BeanContextServiceProvider serviceProvider;
124:
125: private Class serviceClass;
126:
127: private BCSSServiceProvider(Class serviceClass,
128: BeanContextServiceProvider provider)
129: {
130: this.serviceClass = serviceClass;
131: serviceProvider = provider;
132: }
133:
134: protected BeanContextServiceProvider getServiceProvider()
135: {
136: return serviceProvider;
137: }
138:
139: private Class getServiceClass()
140: {
141: return serviceClass;
142: }
143:
144: }
145:
146:
153: private static abstract class Request
154: {
155: private Object requestor;
156:
157: public Request(Object requestor)
158: {
159: this.requestor = requestor;
160: }
161:
162: public boolean equals(Object obj)
163: {
164: if (obj instanceof Request)
165: {
166: Request req = (Request) obj;
167: return req.getRequestor().equals(requestor);
168: }
169: return false;
170: }
171:
172: public Object getRequestor()
173: {
174: return requestor;
175: }
176:
177: }
178:
179:
185: private static class ServiceRequest
186: extends Request
187: {
188:
189: private BeanContextServiceRevokedListener listener;
190:
191: public ServiceRequest(Object requestor,
192: BeanContextServiceRevokedListener listener)
193: {
194: super(requestor);
195: this.listener = listener;
196: }
197:
198: public boolean equals(Object obj)
199: {
200: if (obj instanceof ServiceRequest)
201: {
202: ServiceRequest sr = (ServiceRequest) obj;
203: return (super.equals(obj) &&
204: sr.getListener().equals(listener));
205: }
206: return false;
207: }
208:
209: public BeanContextServiceRevokedListener getListener()
210: {
211: return listener;
212: }
213: }
214:
215:
221: private static class ServiceLease
222: extends Request
223: {
224:
225: private Object service;
226:
227: public ServiceLease(Object requestor, Object service)
228: {
229: super(requestor);
230: this.service = service;
231: }
232:
233: public boolean equals(Object obj)
234: {
235: if (obj instanceof ServiceLease)
236: {
237: ServiceLease sl = (ServiceLease) obj;
238: return (super.equals(obj) &&
239: sl.getService().equals(service));
240: }
241: return false;
242: }
243:
244: public Object getService()
245: {
246: return service;
247: }
248: }
249:
250:
254: protected transient ArrayList bcsListeners;
255:
256: protected transient BCSSProxyServiceProvider proxy;
257:
258:
261: protected transient int serializable;
262:
263:
267: protected transient HashMap services;
268:
269:
273: private transient HashMap serviceUsers;
274:
275:
278: private transient HashMap serviceRequests;
279:
280:
283: private transient HashMap serviceLeases;
284:
285:
288: public BeanContextServicesSupport ()
289: {
290: super();
291: }
292:
293:
298: public BeanContextServicesSupport (BeanContextServices peer)
299: {
300: super(peer);
301: }
302:
303:
310: public BeanContextServicesSupport(BeanContextServices peer, Locale locale)
311: {
312: super(peer, locale);
313: }
314:
315:
324: public BeanContextServicesSupport(BeanContextServices peer, Locale locale,
325: boolean dtime)
326: {
327: super(peer, locale, dtime);
328: }
329:
330:
340: public BeanContextServicesSupport(BeanContextServices peer, Locale locale,
341: boolean dtime, boolean visible)
342: {
343: super(peer, locale, dtime, visible);
344: }
345:
346:
352: public void addBeanContextServicesListener
353: (BeanContextServicesListener listener)
354: {
355: synchronized (bcsListeners)
356: {
357: if (! bcsListeners.contains(listener))
358: bcsListeners.add(listener);
359: }
360: }
361:
362:
375: public boolean addService (Class serviceClass,
376: BeanContextServiceProvider bcsp)
377: {
378: return addService(serviceClass, bcsp, true);
379: }
380:
381:
395: protected boolean addService (Class serviceClass,
396: BeanContextServiceProvider bcsp,
397: boolean fireEvent)
398: {
399: synchronized (globalHierarchyLock)
400: {
401: synchronized (services)
402: {
403: if (services.containsKey(serviceClass))
404: return false;
405: services.put(serviceClass,
406: createBCSSServiceProvider(serviceClass, bcsp));
407: if (bcsp instanceof Serializable)
408: ++serializable;
409: if (fireEvent)
410: fireServiceAdded(serviceClass);
411: return true;
412: }
413: }
414: }
415:
416:
428: protected void bcsPreDeserializationHook (ObjectInputStream ois)
429: throws ClassNotFoundException, IOException
430: {
431: serializable = ois.readInt();
432: for (int a = 0; a < serializable; ++a)
433: {
434: BCSSServiceProvider bcsssp = (BCSSServiceProvider) ois.readObject();
435: addService(bcsssp.getServiceClass(), bcsssp.getServiceProvider());
436: }
437: }
438:
439:
449: protected void bcsPreSerializationHook (ObjectOutputStream oos)
450: throws IOException
451: {
452: oos.writeInt(serializable);
453: synchronized (services)
454: {
455: Iterator i = services.values().iterator();
456: while (i.hasNext())
457: {
458: BCSSServiceProvider bcsssp = (BCSSServiceProvider) i.next();
459: if (bcsssp.getServiceProvider() instanceof Serializable)
460: oos.writeObject(bcsssp);
461: }
462: }
463: }
464:
465:
475: protected void childJustRemovedHook (Object child,
476: BeanContextSupport.BCSChild bcsc)
477: {
478: if (child instanceof BeanContextChild)
479: {
480: BeanContextChild bcchild = (BeanContextChild) child;
481: Iterator childServices = ((List) serviceUsers.get(bcchild)).iterator();
482: while (childServices.hasNext())
483: releaseService(bcchild, this, childServices.next());
484: serviceUsers.remove(bcchild);
485: }
486: }
487:
488:
496: protected BeanContextSupport.BCSChild createBCSChild (Object targetChild,
497: Object peer)
498: {
499: return new BCSSChild(targetChild, peer);
500: }
501:
502:
512: protected BeanContextServicesSupport.BCSSServiceProvider
513: createBCSSServiceProvider (Class sc, BeanContextServiceProvider bcsp)
514: {
515: return new BCSSServiceProvider(sc, bcsp);
516: }
517:
518:
524: protected final void fireServiceAdded (BeanContextServiceAvailableEvent bcssae)
525: {
526: synchronized (bcsListeners)
527: {
528: int size = bcsListeners.size();
529: for (int i = 0; i < size; ++i)
530: {
531: BeanContextServicesListener bcsl
532: = (BeanContextServicesListener) bcsListeners.get(i);
533: bcsl.serviceAvailable(bcssae);
534: }
535: }
536: }
537:
538:
545: protected final void fireServiceAdded (Class serviceClass)
546: {
547: fireServiceAdded(new BeanContextServiceAvailableEvent(this,
548: serviceClass));
549: }
550:
551:
557: protected final void fireServiceRevoked(BeanContextServiceRevokedEvent event)
558: {
559: synchronized (bcsListeners)
560: {
561: int size = bcsListeners.size();
562: for (int i = 0; i < size; ++i)
563: {
564: BeanContextServicesListener bcsl
565: = (BeanContextServicesListener) bcsListeners.get(i);
566: bcsl.serviceRevoked(event);
567: }
568: List requests = (List) serviceRequests.get(event.getServiceClass());
569: if (requests != null)
570: {
571: Iterator i = requests.iterator();
572: while (i.hasNext())
573: {
574: ServiceRequest r = (ServiceRequest) i.next();
575: r.getListener().serviceRevoked(event);
576: }
577: }
578: }
579: }
580:
581:
588: protected final void fireServiceRevoked (Class serviceClass,
589: boolean revokeNow)
590: {
591: fireServiceRevoked(new BeanContextServiceRevokedEvent(this, serviceClass,
592: revokeNow));
593: }
594:
595:
601: public BeanContextServices getBeanContextServicesPeer ()
602: {
603: return (BeanContextServices) beanContextChildPeer;
604: }
605:
606:
615: protected static final BeanContextServicesListener
616: getChildBeanContextServicesListener(Object child)
617: {
618: if (child instanceof BeanContextServicesListener)
619: return (BeanContextServicesListener) child;
620: else
621: return null;
622: }
623:
624:
630: public Iterator getCurrentServiceClasses ()
631: {
632: synchronized (globalHierarchyLock)
633: {
634: synchronized (services)
635: {
636: return services.keySet().iterator();
637: }
638: }
639: }
640:
641:
654: public Iterator getCurrentServiceSelectors (Class serviceClass)
655: {
656: synchronized (globalHierarchyLock)
657: {
658: synchronized (services)
659: {
660: BeanContextServiceProvider bcsp
661: = ((BCSSServiceProvider)
662: services.get(serviceClass)).getServiceProvider();
663: if (bcsp == null)
664: return null;
665: else
666: return bcsp.getCurrentServiceSelectors(this, serviceClass);
667: }
668: }
669: }
670:
671:
690: public Object getService (BeanContextChild child, Object requestor,
691: Class serviceClass, Object serviceSelector,
692: BeanContextServiceRevokedListener bcsrl)
693: throws TooManyListenersException
694: {
695: synchronized (globalHierarchyLock)
696: {
697: synchronized (services)
698: {
699: Object service;
700: BeanContextServiceProvider provider = ((BCSSServiceProvider)
701: services.get(serviceClass)).getServiceProvider();
702: if (provider != null)
703: {
704: service = provider.getService(this, requestor, serviceClass,
705: serviceSelector);
706: List childServices = (List) serviceUsers.get(child);
707: if (childServices == null)
708: {
709: childServices = new ArrayList();
710: serviceUsers.put(child, childServices);
711: }
712: childServices.add(serviceClass);
713: }
714: else
715: {
716: BeanContextServices peer = getBeanContextServicesPeer();
717: if (peer != null)
718: service = peer.getService(child, requestor, serviceClass,
719: serviceSelector, bcsrl);
720: else
721: service = null;
722: }
723: if (service != null)
724: {
725: ServiceRequest request = new ServiceRequest(requestor, bcsrl);
726: Set requests = (Set) serviceRequests.get(serviceClass);
727: if (requests == null)
728: {
729: requests = new HashSet();
730: serviceRequests.put(serviceClass, requests);
731: }
732: requests.add(request);
733: ServiceLease lease = new ServiceLease(requestor, service);
734: serviceLeases.put(lease, provider);
735: }
736: return service;
737: }
738: }
739: }
740:
741:
747: public boolean hasService (Class serviceClass)
748: {
749: synchronized (globalHierarchyLock)
750: {
751: synchronized (services)
752: {
753: return services.containsKey(serviceClass);
754: }
755: }
756: }
757:
758: public void initialize ()
759: {
760: super.initialize();
761:
762: bcsListeners = new ArrayList();
763: services = new HashMap();
764: serviceUsers = new HashMap();
765: serviceRequests = new HashMap();
766: serviceLeases = new HashMap();
767: }
768:
769:
773: protected void initializeBeanContextResources()
774: {
775:
776: }
777:
778:
784: protected void releaseBeanContextResources()
785: {
786:
787: }
788:
789:
799: public void releaseService (BeanContextChild child, Object requestor,
800: Object service)
801: {
802: synchronized (globalHierarchyLock)
803: {
804: synchronized (services)
805: {
806: ServiceLease lease = new ServiceLease(requestor, service);
807: BeanContextServiceProvider provider = (BeanContextServiceProvider)
808: serviceLeases.get(lease);
809: if (provider != null)
810: provider.releaseService(this, requestor, service);
811: else
812: {
813: BeanContextServices peer = getBeanContextServicesPeer();
814: if (peer != null)
815: peer.releaseService(child, requestor, service);
816: }
817: serviceLeases.remove(lease);
818: }
819: }
820: }
821:
822: public void removeBeanContextServicesListener
823: (BeanContextServicesListener listener)
824: {
825: synchronized (bcsListeners)
826: {
827: bcsListeners.remove(listener);
828: }
829: }
830:
831:
843: public void revokeService (Class serviceClass, BeanContextServiceProvider bcsp,
844: boolean revokeCurrentServicesNow)
845: {
846: synchronized (globalHierarchyLock)
847: {
848: synchronized (services)
849: {
850: fireServiceRevoked(serviceClass, revokeCurrentServicesNow);
851: services.remove(serviceClass);
852: if (bcsp instanceof Serializable)
853: --serializable;
854: }
855: }
856: }
857:
858: public void serviceAvailable (BeanContextServiceAvailableEvent bcssae)
859: {
860: synchronized (services)
861: {
862: Class klass = bcssae.getServiceClass();
863: if (services.containsKey(klass))
864: return;
865: Iterator it = bcsChildren();
866: while (it.hasNext())
867: {
868: Object obj = it.next();
869: if (obj instanceof BeanContextServices)
870: ((BeanContextServices) obj).serviceAvailable(bcssae);
871: }
872: }
873: }
874:
875: public void serviceRevoked (BeanContextServiceRevokedEvent bcssre)
876: {
877: synchronized (services)
878: {
879: Class klass = bcssre.getServiceClass();
880: if (services.containsKey(klass))
881: return;
882: Iterator it = bcsChildren();
883: while (it.hasNext())
884: {
885: Object obj = it.next();
886: if (obj instanceof BeanContextServices)
887: ((BeanContextServices) obj).serviceRevoked(bcssre);
888: }
889: }
890: }
891: }