| Home >> All >> org >> jboss >> ejb >> [ plugins Javadoc ] |
• org.jboss.ejb.plugins: Javadoc index of package org.jboss.ejb.plugins.
Package Samples:
• org.jboss.ejb.plugins.cmp.jdbc: Package description goes here .
• org.jboss.ejb.plugins.cmp.jdbc.bridge: Package description goes here .
• org.jboss.ejb.plugins.cmp.jdbc.jdbc3: Package description goes here .
• org.jboss.ejb.plugins.cmp.jdbc.metadata: Package description goes here .
• org.jboss.ejb.plugins.cmp.jdbc.mysql: Package description goes here .
• org.jboss.ejb.plugins.jaws.bmp: Package description goes here .
• org.jboss.ejb.plugins.jaws.jdbc: Package description goes here .
• org.jboss.ejb.plugins.jaws.metadata: Package description goes here .
• org.jboss.ejb.plugins.lock: Package description goes here .
• org.jboss.ejb.plugins.cmp.bridge
• org.jboss.ejb.plugins.cmp.ejbql
• org.jboss.ejb.plugins.jaws
• org.jboss.ejb.plugins.jms
• org.jboss.ejb.plugins.keygenerator
• org.jboss.ejb.plugins.keygenerator.uuid
• org.jboss.ejb.plugins.local
• org.jboss.ejb.plugins.cmp.jdbc.keygen
Classes:
• JDBCOptimisticLock: This class is an optmistic lock implementation. It locks tableFields and their values during transaction. Locked tableFields and their values are added to the WHERE clause of the UPDATE SQL statement when entity is stored. The following strategies are supported: - fixed group of tableFields Fixed group of tableFields is used for locking . The tableFields and their values are locked at the beginning of a transaction. The group name must match one of the entity's load-group-name. - modified strategy The tableFields that were modified during transaction are used as lock. All entity's field values ...
• QueuedPessimisticEJBLock: This class is holds threads awaiting the transactional lock to be free in a fair FIFO transactional queue. Non-transactional threads are also put in this wait queue as well. Unlike SimplePessimisticEJBLock which notifies all threads on transaction completion, this class pops the next waiting transaction from the queue and notifies only those threads waiting associated with that transaction. This class should perform better than Simple on high contention loads. Holds all locks for entity beans, not used for stateful. All BeanLocks have a reference count. When the reference count goes to 0, the lock ...
• ByteArrayBlob: The representation (mapping) in the Java TM programming language of an SQL BLOB value to an array of bytes. A ByteArrayBlob contains an internal buffer that contains bytes that may be read from the stream. The Blob interface provides methods for getting the length of an SQL BLOB (Binary Large Object) value, for materializing a BLOB value on the client, and for determining the position of a pattern of bytes within a BLOB value. The ByteArrayBlob has static factory methods for construting an BLOB using either an existing serializable object, or an array of bytes. This is a nice way to store serialized ...
• EntityInstanceInterceptor: The instance interceptors role is to acquire a context representing the target object from the cache. This particular container interceptor implements pessimistic locking on the transaction that is associated with the retrieved instance. If there is a transaction associated with the target component and it is different from the transaction associated with the Invocation coming in then the policy is to wait for transactional commit. We also implement serialization of calls in here (this is a spec requirement). This is a fine grained notify, notifyAll mechanism. We notify on ctx serialization locks ...
• DLQHandler: Places redeliveded messages on a Dead Letter Queue. The Dead Letter Queue handler is used to not set JBoss in an endles loop when a message is resent on and on due to transaction rollback for message receipt. It sends message to a dead letter queue (configurable, defaults to queue/DLQ) when the message has been resent a configurable amount of times, defaults to 10. The handler is configured through the element MDBConfig in container-invoker-conf. The JMS property JBOSS_ORIG_DESTINATION in the resent message is set to the name of the original destination (Destionation.toString()). The JMS property ...
• JDBCCommandFactory: Command factory for the JAWS JDBC layer. This class is primarily responsible for creating instances of the JDBC implementations for the various JPM commands so that the JAWSPersistenceManager (actually an persistence store) can delegate to them in a decoupled manner. This class also acts as the manager for the read-ahead buffer added in version 2.3/2.4. In order to manage this buffer, it must register itself with any transaction that is active when a finder is called so that the data that was read ahead can be discarded before completion of the transaction. The read ahead buffer is managed using ...
• CleanShutdownInterceptor: Track the incoming invocations and when shuting down a container (stop or destroy), waits for current invocations to finish before returning the stop or destroy call. This interceptor can be important in clustered environment where shuting down a node doesn't necessarly mean that an application cannot be reached: other nodes may still be servicing. Consequently, it is important to have a clean shutdown to keep a coherent behaviour cluster-wide. To avoid strange or inefficient behaviour, the facade session bean (if any) should be stopped first thus not blocking invocations in a middle-step (i.e. ...
• JDBCTypeComplex: JDBCTypeComplex provides the mapping between a Java Bean (not an EJB) and a set of columns. This class has a flattened view of the Java Bean, which may contain other Java Beans. This class simply treats the bean as a set of properties, which may be in the a.b.c style. The details of how this mapping is performed can be found in JDBCTypeFactory. This class holds a description of the columns and the properties that map to the columns. Additionally, this class knows how to extract a column value from the Java Bean and how to set a column value info the Java Bean. See JDBCTypeComplexProperty for details ...
• EntityMultiInstanceSynchronizationInterceptor: The role of this interceptor is to synchronize the state of the cache with the underlying storage. It does this with the ejbLoad and ejbStore semantics of the EJB specification. In the presence of a transaction this is triggered by transaction demarcation. It registers a callback with the underlying transaction monitor through the JTA interfaces. If there is no transaction the policy is to store state upon returning from invocation. The synchronization polices A,B,C of the specification are taken care of here. WARNING: critical code , get approval from senior developers before changing.
• EntitySynchronizationInterceptor: The role of this interceptor is to synchronize the state of the cache with the underlying storage. It does this with the ejbLoad and ejbStore semantics of the EJB specification. In the presence of a transaction this is triggered by transaction demarcation. It registers a callback with the underlying transaction monitor through the JTA interfaces. If there is no transaction the policy is to store state upon returning from invocation. The synchronization polices A,B,C of the specification are taken care of here. WARNING: critical code , get approval from senior developers before changing.
• SimpleReadWriteEJBLock: This lock allows multiple read locks concurrently. Once a writer has requested the lock, future read-lock requests whose transactions do not already have the read lock will block until all writers are done -- then all the waiting readers will concurrently go (depending on the reentrant setting / methodLock). A reader who promotes gets first crack at the write lock -- ahead of other waiting writers. If there is already a reader that is promoting, we throw an inconsistent read exception. Of course, writers have to wait for all read-locks to release before taking the write lock.
• CMPFilePersistenceManager: A file-based CMP entity bean persistence manager. Reads and writes entity bean objects to files by using the standard Java serialization mechanism. Enitiy state files are stored under: jboss-server-data-dir / storeDirectoryName / ejb-name . Note, currently the name of the entity must be unique across the server, or unless the store directory is changed, to avoid data collisions. jason: disabled because XDoclet can not handle right now _@_jmx:mbean extends="org.jboss.system.ServiceMBean"
• EntityLockInterceptor: The lock interceptors role is to schedule thread wanting to invoke method on a target bean The policies for implementing scheduling (pessimistic locking etc) is implemented by pluggable locks We also implement serialization of calls in here (this is a spec requirement). This is a fine grained notify, notifyAll mechanism. We notify on ctx serialization locks and notifyAll on global transactional locks. WARNING: critical code , get approval from senior developers before changing.
• JDBCRemoveEntityCommand: JDBCRemoveEntityCommand executes a DELETE FROM table WHERE command. * * @author Dain Sundstrom * @author Rickard Öberg * @author Marc Fleury * @author Joe Shevland * @author Justin Forder * @author Alexey Loubyansky * @version $Revision: 1.17.2.15 $
• AbstractPassivationJob: Abstract class for passivation jobs. Subclasses should implement Executable.execute() > Executable.execute() 55 synchronizing it in some way because the execute method is normally called in the passivation thread, while the cancel method is normally called from another thread. To avoid that subclasses override methods of this class without make them synchronized (except execute of course), they're declared final.
• EntityBridge: EntityBridge follows the Bridge pattern [Gamma et. al, 1995]. In this implementation of the pattern the Abstract is the entity bean class, and the RefinedAbstraction is the entity bean dynamic proxy. This interface can be considered the implementor. Each imlementation of the CMPStoreManager should create a store specifiec implementaion of the bridge. Life-cycle: Undefined. Should be tied to CMPStoreManager. Multiplicity: One per cmp entity bean type.
• JDBCTypeComplexProperty: Immutable class which contins the mapping between a single Java Bean (not an EJB) property and a column. This class has a flattened view of the Java Bean property, which may be several properties deep in the base Java Bean. The details of how a property is mapped to a column can be found in JDBCTypeFactory. This class holds a description of the column and, knows how to extract the column value from the Java Bean and how to set a column value info the Java Bean.
• StatefulSessionFilePersistenceManager: A file-based stateful session bean persistence manager. Reads and writes session bean objects to files by using the standard Java serialization mechanism. Passivated state files are stored under: jboss-server-data-dir / storeDirectoryName / ejb-name - unique-id . Since ejb-name is not unique across deployments we generate a unique-id to make sure that beans with the same EJB name do not collide.
• JDBCCMP1xFieldBridge: JDBCCMP1xFieldBridge is a concrete implementation of JDBCCMPFieldBridge for CMP version 1.x. Getting and setting of instance fields set the corresponding field in bean instance. Dirty checking is performed by storing the current value in the entity persistence context when ever setClean is called, and comparing current value to the original value. Life-cycle: Tied to the EntityBridge. Multiplicity: One for each entity bean cmp field.
• JDBCStoreManager: JDBCStoreManager manages storage of persistence data into a table. Other then loading the initial jbosscmp-jdbc.xml file this class does very little. The interesting tasks are performed by the command classes. Life-cycle: Tied to the life-cycle of the entity container. Multiplicity: One per cmp entity bean. This could be less if another implementaion of EntityPersistenceStore is created and thoes beans use the implementation
• ValueObjectHelper: Provide static method to obtain a private attribute of a value object using its get method, and to set the value of a private attribute using its set method. WARNING : These methods use Reflection so OK to run them at deployment time but at run time, we should better catch the Method get/set at CMPFieldMetaData level. So that the only invoke() method will be called at run time. This still needs to be done.
• EntityBridgeInvocationHandler: EntityBridgeInvocationHandler is the invocation hander used by the CMP 2.x dynamic proxy. This class only interacts with the EntityBridge. The main job of this class is to deligate invocation of abstract methods to the appropriate EntityBridge method. Life-cycle: Tied to the life-cycle of an entity bean instance. Multiplicity: One per cmp entity bean instance, including beans in pool.
• JDBCAbstractCMPFieldBridge: JDBCAbstractCMPFieldBridge is the default implementation of JDBCCMPFieldBridge. Most of the heavy lifting of this command is handled by JDBCUtil. It is left to subclasses to implement the logic for getting and setting instance values and dirty checking, as this is dependent on the CMP version used. Life-cycle: Tied to the EntityBridge. Multiplicity: One for each entity bean cmp field.
• Mapper: Generally, implementations of this interface map instances of one Java type into instances of another Java type. Mappers are used in cases when instances of "enum" types are used as CMP field values. In this case, a mapper represents a mediator and translates instances of "enum" to some id when that can be stored in a column when storing data and back from id to "enum" instance when data is loaded.
• AbstractInstanceCache: Base class for caches of entity and stateful beans. It manages the cache entries through a org.jboss.util.CachePolicy object; the implementation of the cache policy object must respect the following requirements: Have a public constructor that takes a single argument of type AbstractInstanceCache.class or a subclass
| Home | Contact Us | Privacy Policy | Terms of Service |