# Uses of Interface
org.picocontainer.ComponentMonitorStrategy

Packages that use ComponentMonitorStrategy
Package
Description
org.picocontainer
This package contains the core API for PicoContainer, a compact container for working with the dependency injection pattern.
org.picocontainer.adapters
org.picocontainer.behaviors
BehaviorFactories make Behaviors which change aspects of component implementations and instances
org.picocontainer.classname
org.picocontainer.containers
Containers are the main user entry point for PicoContainer.
org.picocontainer.injectors
InjectionFactories make Injectors which implement specific types of dependency injection
org.picocontainer.lifecycle
Alternative implementations of lifecycle strategy for use with a container.
org.picocontainer.monitors
A Monitor is something PicoContainer uses to inform on events in component instantiation and lifecycle.

## Uses of ComponentMonitorStrategy in org.picocontainer

Classes in org.picocontainer that implement ComponentMonitorStrategy
Modifier and Type
Class
Description
`class`
`DefaultPicoContainer`
The Standard `PicoContainer`/`MutablePicoContainer` implementation.
`static class`
`DefaultPicoContainer.LateInstance`

## Uses of ComponentMonitorStrategy in org.picocontainer.adapters

Classes in org.picocontainer.adapters that implement ComponentMonitorStrategy
Modifier and Type
Class
Description
`class`
`AbstractAdapter<T>`
Base class for a ComponentAdapter with general functionality.
`final class`
`InstanceAdapter<T>`
Component adapter which wraps a component instance.

## Uses of ComponentMonitorStrategy in org.picocontainer.behaviors

Classes in org.picocontainer.behaviors that implement ComponentMonitorStrategy
Modifier and Type
Class
Description
`class`
`AbstractBehavior<T>`
Component adapter which decorates another adapter.
`class`
`Automated<T>`
`class`
`Cached<T>`
`ComponentAdapter` implementation that caches the component instance.
`class`
`Decorated<T>`
`class`
`FieldDecorated`
`class`
`Guarded<T>`
behaviour for allows components to be guarded by another component
`class`
`HiddenImplementation<T>`
This component adapter makes it possible to hide the implementation of a real subject (behind a proxy) provided the key is an interface.
`class`
`Intercepted<T>`
`class`
`Locked<T>`
`class`
`PropertyApplicator<T>`
Decorating component adapter that can be used to set additional properties on a component in a bean style.
`class`
`Stored<T>`
`class`
`Synchronized<T>`
Component Adapter that uses java synchronized around getComponentInstance().
`final class`
`ThreadCached<T>`
This behavior supports caches values per thread.

## Uses of ComponentMonitorStrategy in org.picocontainer.classname

Classes in org.picocontainer.classname that implement ComponentMonitorStrategy
Modifier and Type
Class
Description
`class`
`DefaultClassLoadingPicoContainer`
Default implementation of ClassLoadingPicoContainer.

## Uses of ComponentMonitorStrategy in org.picocontainer.containers

Classes in org.picocontainer.containers that implement ComponentMonitorStrategy
Modifier and Type
Class
Description
`class`
`TieringPicoContainer`
`class`
`TransientPicoContainer`

## Uses of ComponentMonitorStrategy in org.picocontainer.injectors

Classes in org.picocontainer.injectors that implement ComponentMonitorStrategy
Modifier and Type
Class
Description
`class`
`AbstractFieldInjector<T>`
`class`
`AbstractInjector<T>`
This ComponentAdapter will instantiate a new object for each call to `ComponentAdapter.getComponentInstance(PicoContainer, Type)`.
`class`
`AnnotatedFieldInjector<T>`
Injection happens after instantiation, and through fields marked as injection points via an Annotation.
`class`
`AnnotatedMethodInjector`
`class`
`CompositeInjector<T>`
`class`
`ConstructorInjector<T>`
Injection will happen through a constructor for the component.
`class`
`IterativeInjector<T>`
Injection will happen iteratively after component instantiation
`class`
`MethodInjector<T>`
Injection will happen through a single method for the component.
`static class`
`MethodInjector.ByMethodName`
`static class`
`MethodInjector.ByReflectionMethod`
`class`
`MultiInjector`
`class`
`NamedFieldInjector<T>`
Injection happens after instantiation, and fields are marked as injection points via a named field.
`class`
`NamedMethodInjector<T>`
`class`
`SetterInjector<T>`
Instantiates components using empty constructors and Setter Injection.
`class`
`SingleMemberInjector<T>`
Injection will happen in a single member function on the component.
`class`
`TypedFieldInjector<T>`
Injection happens after instantiation, and fields are marked as injection points via a field type.

## Uses of ComponentMonitorStrategy in org.picocontainer.lifecycle

Classes in org.picocontainer.lifecycle that implement ComponentMonitorStrategy
Modifier and Type
Class
Description
`class`
`AbstractMonitoringLifecycleStrategy`
Abstract base class for lifecycle strategy implementation supporting a `ComponentMonitor`.
`final class`
`JavaEE5LifecycleStrategy`
Java EE 5 has some annotations PreDestroy and PostConstruct that map to start() and dispose() in our world
`class`
`ReflectionLifecycleStrategy`
Reflection lifecycle strategy.
`class`
`StartableLifecycleStrategy`
Startable lifecycle strategy.

## Uses of ComponentMonitorStrategy in org.picocontainer.monitors

Classes in org.picocontainer.monitors that implement ComponentMonitorStrategy
Modifier and Type
Class
Description
`class`
`AbstractComponentMonitor`
A `monitor` which delegates to another monitor.
`class`
`ComposingMonitor`
The first of a list of composers passed in that responds with an instance for a missing component will be used.