|PREV PACKAGE NEXT PACKAGE||FRAMES NO FRAMES|
|BeanletContext<T>||Provides beanlet instances access to their runtime context.|
|BeanletFactory<T>||Factory for creating beanlet references.|
|BeanletMetaData<T>||Provides information on the beanlet definition.|
|BeanletReference<T>||Represents a reference to a beanlet.|
|Event||Root interface of all events.|
|FactoryBeanlet<T>||Beanlets implementing this interface can act as a factory.|
|Interceptor||Classes implementing this interface can configured to intercept invocations.|
|InvocationContext||Allow interceptor and lifecycle methods to control the behavior of the invocation chain.|
|MetaData||Root interface of all meta data objects.|
Provides instances of
|BeanletApplicationContext||Bootstrap class for the application container.|
|AttributeAccessType||Specifies the access rights for attributes.|
|RetentionPolicy||Beanlet retention policy.|
|WiringMode||Specifies the wiring mode.|
|BeanletApplicationException||Thrown to indicate a general application error.|
|BeanletCreationException||Thrown if an instance for the specified beanlet could not be created, or obtained for some reason.|
|BeanletDefinitionException||Indicates an invalid beanlet definition.|
|BeanletEventException||Generic event exception.|
|BeanletEventNotExecutableException||Thrown if specified event cannot be executed.|
|BeanletException||Indicates that there is an issue with the specified beanlet.|
|BeanletExecutionException||Exception thrown if any exception is raised during event execution.|
|BeanletNotActiveException||Thrown if the specified beanlet has not yet been activated.|
|BeanletNotFoundException||Thrown if no beanlet is registered for the specified name.|
|BeanletNotOfRequiredTypeException||Thrown if required type does not matched found type.|
|BeanletStateException||Indicates that beanlet is not in required state to perform operation.|
|BeanletTypeIsDuplicateException||Indicates that multiple beanlets match the member type.|
|BeanletTypeMismatchException||Thrown if injectant does not match member type.|
|BeanletTypeNotFoundException||Exception thrown if no beanlet type matches member type.|
|BeanletValidationException||Thrown if beanlet validation failed.|
|BeanletWiringException||Thrown if any of the members, for which injection is required, cannot be wired.|
|Annotation Types Summary|
|AroundInvoke||Designates a method to intercept invocations on a beanlet.|
|Attribute||Exposes methods or fields as beanlet attributes.|
|CollectionValue||Represents a collection of values.|
|Dependency||Used to specify an explicit dependency.|
|Entry||Represents a single map entry.|
|ExcludeClassInterceptors||Used to exclude class-level interceptors for a business method.|
|ExcludeDefaultInterceptors||Used to exclude default interceptors for a class or method.|
|Execute||Methods declared with this annotation are executed by one or more background threads.|
|Factory||Beanlets implementing this annotation can act as a factory.|
|IgnoreDependency||Used to ignore the dependencies of the element that is subject to injection.|
|Inject||Members marked with this annotation are injected by the application container during beanlet instance creation.|
|Interceptors||Declares a list of interceptors.|
|Lazy||Beanlets marked with this annotations are not eagerly instantiated.|
|MapValue||Represents a map of key/value entries.|
|Operation||Exposes methods as beanlet operations.|
|Proxy||Specifies interfaces to be exposed by beanlet.|
|ProxyMethod||Methods marked with this annotation are so-called proxy methods.|
|Remove||Applied to a business method of a class.|
|Retention||Indicates what action is to be taken in case an exception is encountered on beanlet invocation.|
|Schedule||Methods declared with this annotation are scheduled to be executed by a background thread.|
|ScopeAnnotation||Annotations marked with the
|Singleton||Beanlets without any scope annotation and beanlets marked with this annotation are called vanilla beanlets.|
|Stateful||Stateful beanlet maintain conversational state between calls on the same object.|
|Stateless||Stateless beanlets do not share any state between subsequent method invocations.|
|StaticFactory||Applied to static methods or static fields to denote a factory.|
|Stop||Defines a stop lifecycle method.|
|SuppressWarnings||Indicates that no warnings need to be generated for the annotated element.|
|Value||Defines an object.|
|Wiring||Allows members to be wired with implicitely selected objects.|
Contains all of the core beanlet interfaces and bootstrap classes.
Singleton. In this case, the container guarantees that only a single instance of this beanlet exists at the same time. It is always this particular instance that is returned when this beanlet is requested.
Statefulbeanlets do not provide direct access to the underlying objects. Instead, clients obtain a stub, which delegates invocations to the underlying instance. In case of stateful beanlets, invocations are always delegated to the same instance.
reentrantby default, which means that only one thread can invoke a method of the beanlet instance at the same time. This feature is provided by the stub, which controls all access to the underlying instance. Stateful beanlets can also be configured to be reentrant.
Statelessbeanlets are the counterpart of stateful beanlets. Stateless beanlet instances are pooled. Methods called on stateless beanlet stubs are delegated to one of a pool of instances. If multiple invocations are made on the same stub reference, different beanlet instances can be used to perform the call.
BY_INFOdependency injection. Use the
BeanletMetaDatainterface to find out if a beanlet is static programmatically.
The static property of a beanlet is derived from the selected beanlet scope, i.e., singleton vanilla beanlets are static, where non-singleton vanilla beanlets are non-static. The following table shows the static property for all core beanlet scopes.
The static property has also effect on the lifecycle management of beanlets as is explained by the next paragraph.
Instance-level lifecycle methods are invoked during the process of creating
or destroying individual beanlet instances. These lifecycle methods are
marked with the
PreDestroy annotations, respectively. These methods are
invoked in an unspecified context. This means that transactions, for
instance, are not supported for these methods.
PostConstruct method is invoked right after dependency
injection. This method has to be completed before any business methods can
be invoked on the instance. The
PreDestroy method is the last method
to be invoked on the beanlet instance. Whether the
is actually invoked depends on the
specified by the beanlet.
Stopmethods of a non-static beanlet can be invoked multiple times, namely once per constructed instance.
Startmethod, the container requests a beanlet instance during deployment and invokes this
Stopmethod is invoked if the beanlet is being undeployed. In other words, the
Stopfor static beanlets are invoked only once.
BeanletReference). The 'beanlet' might actually be a 'beanlet instance' in case of vanilla beanlets, or a 'beanlet stub' for stateful or stateless beanlets.
<beanlet>xml-tag. A 'beanlet definition' embodies all properties that constitute a beanlet, like its name, type, classloader and meta data. The 'beanlet defintion' can be accessed programatically through the
<beanlet>xml-tag. The beanlet type is not necessarily the same as the type of the beanlet instance. The beanlet instance may be a subclass of the expressed beanlet type. More specifically, the type of the beanlet instance can vary for each individual instance. Therefore all properties of the beanlet are derived from the beanlet type, which is static. The beanlet type can be obtained via
|PREV PACKAGE NEXT PACKAGE||FRAMES NO FRAMES|