001 package org.picocontainer.gems.containers; 002 003 import java.util.Collection; 004 import java.util.List; 005 006 import org.apache.commons.logging.Log; 007 import org.apache.commons.logging.LogFactory; 008 import org.picocontainer.ComponentAdapter; 009 import org.picocontainer.MutablePicoContainer; 010 import org.picocontainer.Parameter; 011 import org.picocontainer.PicoContainer; 012 import org.picocontainer.PicoVerificationException; 013 import org.picocontainer.PicoVisitor; 014 015 /** 016 * 017 * @author Michael Rimov 018 */ 019 public class CommonsLoggingTracingContainerDecorator implements MutablePicoContainer { 020 021 /** 022 * Wrapped container. 023 */ 024 private final MutablePicoContainer delegate; 025 026 /** 027 * Logger instance used for writing events. 028 */ 029 private transient Log log; 030 031 /** 032 * Serialized log category. 033 */ 034 private final String logCategory; 035 036 /** 037 * Default typical wrapper that wraps another MutablePicoContainer. 038 * @param delegate Container to be decorated. 039 * @throws NullPointerException if delegate is null. 040 */ 041 public CommonsLoggingTracingContainerDecorator(final MutablePicoContainer delegate) { 042 this(delegate, PicoContainer.class.getName()); 043 } 044 045 046 /** 047 * Alternate constructor that allows specification of the Logger to 048 * use. 049 * @param delegate Container to be decorated. 050 * @param log specific Log4j Logger to use. 051 * @throws NullPointerException if delegate or log is null. 052 */ 053 public CommonsLoggingTracingContainerDecorator(final MutablePicoContainer delegate, final String loggingCategory) { 054 if (delegate == null) { 055 throw new NullPointerException("delegate"); 056 } 057 058 if (loggingCategory == null) { 059 throw new NullPointerException("loggingCategory"); 060 } 061 062 log = LogFactory.getLog(loggingCategory); 063 064 this.delegate = delegate; 065 logCategory = loggingCategory; 066 } 067 068 069 /** 070 * Standard message handling for cases when a null object is returned 071 * for a given key. 072 * @param componentKey 073 * @param target 074 */ 075 protected void onKeyDoesntExistInContainer(final Object componentKey, final Log target) { 076 log.info("Could not find component " 077 + ((componentKey != null) ? componentKey.toString() : " null ") 078 + " in container or parent container."); 079 } 080 081 /** 082 * {@inheritDoc} 083 * @param visitor 084 * @see org.picocontainer.PicoContainer#accept(org.picocontainer.PicoVisitor) 085 */ 086 public void accept(final PicoVisitor visitor) { 087 if (log.isDebugEnabled()) { 088 log.debug("Visiting Container " + delegate 089 + " with visitor " + visitor); 090 } 091 delegate.accept(visitor); 092 } 093 094 /** 095 * {@inheritDoc} 096 * @param child 097 * @return 098 * @see org.picocontainer.MutablePicoContainer#addChildContainer(org.picocontainer.PicoContainer) 099 */ 100 public boolean addChildContainer(final PicoContainer child) { 101 if (log.isDebugEnabled()) { 102 log.debug("Adding child container: " + child + " to container " + delegate); 103 } 104 return delegate.addChildContainer(child); 105 } 106 107 /** 108 * {@inheritDoc} 109 * @see org.picocontainer.Disposable#dispose() 110 */ 111 public void dispose() { 112 if (log.isDebugEnabled()) { 113 log.debug("Disposing container " + delegate); 114 } 115 delegate.dispose(); 116 } 117 118 /** 119 * {@inheritDoc} 120 * @param componentKey 121 * @return 122 * @see org.picocontainer.PicoContainer#getComponentAdapter(java.lang.Object) 123 */ 124 public ComponentAdapter getComponentAdapter(final Object componentKey) { 125 if (log.isDebugEnabled()) { 126 log.debug("Locating component adapter with key " + componentKey); 127 } 128 129 ComponentAdapter adapter = delegate.getComponentAdapter(componentKey); 130 if (adapter == null) { 131 onKeyDoesntExistInContainer(componentKey, log); 132 } 133 return adapter; 134 } 135 136 /** 137 * {@inheritDoc} 138 * @param componentType 139 * @return ComponentAdapter or null. 140 * @see org.picocontainer.PicoContainer#getComponentAdapterOfType(java.lang.Class) 141 */ 142 public ComponentAdapter getComponentAdapterOfType(final Class componentType) { 143 if (log.isDebugEnabled()) { 144 log.debug("Locating component adapter with type " + componentType); 145 } 146 147 ComponentAdapter ca = delegate.getComponentAdapterOfType(componentType); 148 149 if (ca == null) { 150 onKeyDoesntExistInContainer(ca, log); 151 } 152 return ca; 153 } 154 155 /** 156 * {@inheritDoc} 157 * @return Collection or null. 158 * @see org.picocontainer.PicoContainer#getComponentAdapters() 159 */ 160 public Collection getComponentAdapters() { 161 if (log.isDebugEnabled()) { 162 log.debug("Grabbing all component adapters for container: " + delegate); 163 } 164 return delegate.getComponentAdapters(); 165 } 166 167 /** 168 * {@inheritDoc} 169 * @param componentType 170 * @return List of ComponentAdapters 171 * @see org.picocontainer.PicoContainer#getComponentAdaptersOfType(java.lang.Class) 172 */ 173 public List getComponentAdaptersOfType(final Class componentType) { 174 if (log.isDebugEnabled()) { 175 log.debug("Grabbing all component adapters for container: " 176 + delegate + " of type: " + componentType.getName()); 177 } 178 return delegate.getComponentAdaptersOfType(componentType); 179 } 180 181 /** 182 * {@inheritDoc} 183 * @param componentKey 184 * @return 185 * @see org.picocontainer.PicoContainer#getComponentInstance(java.lang.Object) 186 */ 187 public Object getComponentInstance(final Object componentKey) { 188 189 if (log.isDebugEnabled()) { 190 log.debug("Attempting to load component instance with key: " 191 + componentKey 192 + " for container " 193 + delegate); 194 195 } 196 197 Object result = delegate.getComponentInstance(componentKey); 198 if (result == null) { 199 onKeyDoesntExistInContainer(componentKey, log); 200 } 201 202 return result; 203 } 204 205 /** 206 * {@inheritDoc} 207 * @param componentType 208 * @return 209 * @see org.picocontainer.PicoContainer#getComponentInstanceOfType(java.lang.Class) 210 */ 211 public Object getComponentInstanceOfType(final Class componentType) { 212 if (log.isDebugEnabled()) { 213 log.debug("Attempting to load component instance with type: " 214 + componentType 215 + " for container " 216 + delegate); 217 218 } 219 220 Object result = delegate.getComponentInstanceOfType(componentType); 221 if (result == null) { 222 if (log.isInfoEnabled()) { 223 log.info("No component of type " + componentType.getName() 224 + " was found in container: " + delegate); 225 } 226 } 227 228 return result; 229 } 230 231 /** 232 * {@inheritDoc} 233 * @return 234 * @see org.picocontainer.PicoContainer#getComponentInstances() 235 */ 236 public List getComponentInstances() { 237 if (log.isDebugEnabled()) { 238 log.debug("Retrieving all component instances for container " 239 + delegate); 240 } 241 return delegate.getComponentInstances(); 242 } 243 244 /** 245 * {@inheritDoc} 246 * @param componentType 247 * @return 248 * @see org.picocontainer.PicoContainer#getComponentInstancesOfType(java.lang.Class) 249 */ 250 public List getComponentInstancesOfType(final Class componentType) { 251 if (log.isDebugEnabled()) { 252 log.debug("Loading all component instances of type " + componentType 253 + " for container " + delegate); 254 } 255 List result = delegate.getComponentInstancesOfType(componentType); 256 if (result == null || result.size() == 0) { 257 if (log.isInfoEnabled()) { 258 log.info("Could not find any components " 259 + " in container or parent container."); 260 } 261 } 262 263 return result; 264 } 265 266 /** 267 * {@inheritDoc} 268 * @return 269 * @see org.picocontainer.PicoContainer#getParent() 270 */ 271 public PicoContainer getParent() { 272 if (log.isDebugEnabled()) { 273 log.debug("Retrieving the parent for container " + delegate); 274 } 275 276 return delegate.getParent(); 277 } 278 279 /** 280 * {@inheritDoc} 281 * @return 282 * @see org.picocontainer.MutablePicoContainer#makeChildContainer() 283 */ 284 public MutablePicoContainer makeChildContainer() { 285 if (log.isDebugEnabled()) { 286 log.debug("Making child container for container " + delegate); 287 } 288 289 //Wrap the new delegate 290 return new Log4jTracingContainerDecorator( delegate.makeChildContainer()); 291 } 292 293 /** 294 * {@inheritDoc} 295 * @param componentAdapter 296 * @return 297 * @see org.picocontainer.MutablePicoContainer#registerComponent(org.picocontainer.ComponentAdapter) 298 */ 299 public ComponentAdapter registerComponent(final ComponentAdapter componentAdapter) { 300 if (log.isDebugEnabled()) { 301 log.debug("Registering component adapter " + componentAdapter); 302 } 303 304 return delegate.registerComponent(componentAdapter); 305 } 306 307 /** 308 * {@inheritDoc} 309 * @param componentImplementation 310 * @return 311 * @see org.picocontainer.MutablePicoContainer#registerComponentImplementation(java.lang.Class) 312 */ 313 public ComponentAdapter registerComponentImplementation(final Class componentImplementation) { 314 if (log.isDebugEnabled()) { 315 log.debug("Registering component implementation " + componentImplementation.getName()); 316 } 317 318 return delegate.registerComponentImplementation(componentImplementation); 319 } 320 321 /** 322 * {@inheritDoc} 323 * @param componentKey 324 * @param componentImplementation 325 * @param parameters 326 * @return 327 * @see org.picocontainer.MutablePicoContainer#registerComponentImplementation(java.lang.Object, java.lang.Class, org.picocontainer.Parameter[]) 328 */ 329 public ComponentAdapter registerComponentImplementation(final Object componentKey, final Class componentImplementation, 330 final Parameter[] parameters) { 331 if (log.isDebugEnabled()) { 332 log.debug("Registering component implementation with key " 333 + componentKey 334 + " and implementation " 335 + componentImplementation.getName() 336 + " using parameters " 337 + parameters); 338 } 339 340 return delegate.registerComponentImplementation(componentKey, componentImplementation, parameters); 341 } 342 343 /** 344 * {@inheritDoc} 345 * @param componentKey 346 * @param componentImplementation 347 * @return 348 * @see org.picocontainer.MutablePicoContainer#registerComponentImplementation(java.lang.Object, java.lang.Class) 349 */ 350 public ComponentAdapter registerComponentImplementation(final Object componentKey, final Class componentImplementation) { 351 if (log.isDebugEnabled()) { 352 log.debug("Registering component implementation with key " 353 + componentKey 354 + " and implementation " 355 + componentImplementation.getName()); 356 } 357 358 return delegate.registerComponentImplementation(componentKey, componentImplementation); 359 } 360 361 /** 362 * {@inheritDoc} 363 * @param componentKey 364 * @param componentInstance 365 * @return 366 * @see org.picocontainer.MutablePicoContainer#registerComponentInstance(java.lang.Object, java.lang.Object) 367 */ 368 public ComponentAdapter registerComponentInstance(final Object componentKey, final Object componentInstance) { 369 if (log.isDebugEnabled()) { 370 log.debug("Registering component instance with key " 371 + componentKey 372 + " and instance " 373 + componentInstance + "(class: " 374 + ((componentInstance != null) ? componentInstance.getClass().getName() : " null ")); 375 } 376 377 return delegate.registerComponentInstance(componentKey, componentInstance); 378 } 379 380 /** 381 * {@inheritDoc} 382 * @param componentInstance 383 * @return 384 * @see org.picocontainer.MutablePicoContainer#registerComponentInstance(java.lang.Object) 385 */ 386 public ComponentAdapter registerComponentInstance(final Object componentInstance) { 387 if (log.isDebugEnabled()) { 388 log.debug("Registering component instance " 389 + componentInstance + "(class: " 390 + ((componentInstance != null) ? componentInstance.getClass().getName() : " null ")); 391 } 392 393 return delegate.registerComponentInstance(componentInstance); 394 } 395 396 /** 397 * {@inheritDoc} 398 * @param child 399 * @return 400 * @see org.picocontainer.MutablePicoContainer#removeChildContainer(org.picocontainer.PicoContainer) 401 */ 402 public boolean removeChildContainer(final PicoContainer child) { 403 if (log.isDebugEnabled()) { 404 log.debug("Removing child container: " + child 405 + " from parent: " + delegate); 406 } 407 return delegate.removeChildContainer(child); 408 } 409 410 /** 411 * {@inheritDoc} 412 * @see org.picocontainer.Startable#start() 413 */ 414 public void start() { 415 if (log.isInfoEnabled()) { 416 log.info("Starting Container " + delegate); 417 } 418 419 delegate.start(); 420 } 421 422 /** 423 * {@inheritDoc} 424 * @see org.picocontainer.Startable#stop() 425 */ 426 public void stop() { 427 if (log.isInfoEnabled()) { 428 log.info("Stopping Container " + delegate); 429 } 430 delegate.stop(); 431 } 432 433 /** 434 * {@inheritDoc} 435 * @param componentKey 436 * @return 437 * @see org.picocontainer.MutablePicoContainer#unregisterComponent(java.lang.Object) 438 */ 439 public ComponentAdapter unregisterComponent(final Object componentKey) { 440 if (log.isDebugEnabled()) { 441 log.debug("Unregistering component " + componentKey + " from container " + delegate); 442 } 443 444 return delegate.unregisterComponent(componentKey); 445 } 446 447 /** 448 * {@inheritDoc} 449 * @param componentInstance 450 * @return 451 * @see org.picocontainer.MutablePicoContainer#unregisterComponentByInstance(java.lang.Object) 452 */ 453 public ComponentAdapter unregisterComponentByInstance(final Object componentInstance) { 454 if (log.isDebugEnabled()) { 455 log.debug("Unregistering component by instance (" + componentInstance + ") from container " + delegate); 456 } 457 458 return delegate.unregisterComponentByInstance(componentInstance); 459 } 460 461 /** 462 * {@inheritDoc} 463 * @throws PicoVerificationException 464 * @deprecated 465 * @see org.picocontainer.PicoContainer#verify() 466 */ 467 public void verify() throws PicoVerificationException { 468 log.info("Verifying container"); 469 log.warn("Using deprecated function PicoContainer.verify(). Please use VerifyingVisitor instead."); 470 delegate.verify(); 471 } 472 473 474 /** 475 * Retrieves the log instance used by this decorator. 476 * @return Logger instance. 477 */ 478 public Log getLoggerUsed() { 479 return this.log; 480 } 481 482 private void readObject(final java.io.ObjectInputStream s) 483 throws java.io.IOException, java.lang.ClassNotFoundException { 484 s.defaultReadObject(); 485 log = LogFactory.getLog(this.logCategory); 486 } 487 }