jump to navigation

EJB 2.0 vs 3.0 January 25, 2008

Posted by Coolguy in J2EE, Java.
Tags:
add a comment
  • Entity beans retire.  Come Java persistence API
  • Deployment descriptors retire. Come annotations
  • JNDI lookups are no longer necessary
  • Simple POJO components
  • Less classes and interfaces

EJB Lifecycle January 25, 2008

Posted by Coolguy in J2EE, Java.
Tags:
add a comment

Stateful Session bean:

  • setSessionContext
  • Client calls create. Container calls ejbCreate
  • ejbPassivate
  • ejbActivate
  • Client calls remove. Container calls ejbRemove

Stateless Session bean:

  • ejbCreate
  • setSessionContext
  •  <<Invoke business methods>>
  • Container calls ejbRemove

Entity beans:

  • setEntityContext
  • ejbCreate
  • ejbPostCreate
  • ejbActivate
  • ejbPassivate
  • ejbRemove
  • unsetEntityContext

Message Driven beans:

  • setMessageDrivenContext
  • ejbCreate
  • ejbRemove

Stateful vs Stateless Session beans-Differences January 25, 2008

Posted by Coolguy in J2EE, Java.
Tags:
add a comment

State: Stateful maintains information across sessions while stateless doesn’t. If a transaction would span over two or more bean executions you should use stateful session bean, otherwise use stateless session bean. Stateful beans remember state between

    Scalability: Stateful beans hurt scalability.

    Pooling: Stateless beans, by nature, need not know their clients once the remote business method returns. These beans can therefore be bean-pooled. On the other hand stateful session beans may be requested back(with previous state) by a client using the javax.ejb.Handle reference that the client may have retained. In this case, the bean will need to be re-instated entirely. These beans therefore can only be instance-pooled and never shared between clients.

    Passivation: Stateless  beans are not passivated. SFSB’s are activated/passivated.

      Version 2.X:

      In ejb-jar.xml ‘session-type’ attribute determines whether the bean is stateful or stateless.

      <session-type>Stateless</session-type>

      Version 3.X

      Stateful beans import: import javax.ejb.Stateful

      Stateless beans import: import javax.ejb.Stateless

      Stateful Session Beans – Best practices January 25, 2008

      Posted by Coolguy in J2EE, Java.
      Tags:
      add a comment

      Stateful Session EJB is a server-side object designed to hold data on behalf of a particular client.

      SFSBs should be used to store session-oriented data. They hold the data on behalf of the client. Session-oriented data is used to track a multi-request sequence, ordering, or any associated data that is part of a sequence.

      SFSBs, however, have a limited lifespan and are not intended to survive server crashes. Although SFSBs are allowed to access a database and load data into memory, but the act of caching persistent data lies within the responsibilities of entity beans.

      The EJB specification suggests that a shopping cart for an e-commerce system could be implemented with SFSBs. This is perfectly acceptable if that shopping cart is only intended to be an in-memory implementation that does not need to survive a server crash. In reality, however, most implementations of shopping carts are required to survive server crashes; the data contained within the shopping cart needs to be persistent and transactional — with an in-memory data cache. i:e Using entity beans.

      When to use them ? 

      In very few J2EE systems !!

      Systems that have JSP/servlet front-ends should use HttpSession objects to store session-oriented state. Using both  HttpSession and SFSB is simply duplicating the effort.

      For systems that do not have a servlet/JSP front-end, SFSBs should be used to track session-oriented state similar to the way a web-based system would use an HttpSession object.

      Use SFSB’s along with  HttpSession when:

      Your app server doesn’t offer caching of HttpSession objects. This will mean that you may have to have to limit on number of sessions.  Using SFSB’s in this scenario will increase scalability as a  container can activate/passivate SFSB’s as needed.

      Session Tracking August 23, 2005

      Posted by Coolguy in J2EE.
      add a comment

      Session Tracking Mechanisms

      • Cookies : Session tracking through HTTP cookies is the most used session tracking mechanism and is required to be supported by all servlet containers. The container sends a cookie to the client. The client will then return the cookie on each subsequent request to the server, unambiguously associating the request with a session. The name of the session tracking cookie must be JSESSIONID.
      • SSL Sessions : Secure Sockets Layer, the encryption technology used in the HTTPS protocol, has abuilt-in mechanism allowing multiple requests from a client to be unambiguously identified as being part of a session. A servlet container can easily use this data to define a session.
      • URL Rewriting : When a client will not accept a cookie, URL rewriting may be used by the server as the basis for session tracking. URL rewriting involves adding data, a session ID, to the URL path that is interpreted by the container to associate the request with a session. The session ID must be encoded as a path parameter in the URL string. The name of the parameter must be jsessionid. Here is an example of a URL containing encoded path information:http://www.myserver.com/catalog/index.html;jsessionid=1234
      • A client joins a session when session tracking information has been returned to the server indicating that a session has been established.
      • HttpSession objects must be scoped at the application (or servlet context) level.
      • Object referenced, including the attributes in that object, must never be shared between contexts by the container.
      • A servlet can bind an object attribute into an HttpSession implementation by name. Any object bound into a session is available to any other servlet that belongs to the same ServletContext and handles a request identified as being a part of the same session.
      • Some objects may require notification when they are placed into, or removed from, a session. This information can be obtained by having the object implement the HttpSessionBindingListener interface.
      • This interface defines the following methods that will signal an object being bound into, or being unbound from, a session.• valueBound• valueUnbound
      • The valueBound method must be called before the object is made available via the getAttribute method of the HttpSession interface.
      • The valueUnbound method must be called after the object is no longer available via the getAttributemethod of the HttpSession interface.
      • The default timeout period for sessions is defined by the servlet container and can be obtained via the getMaxInactiveInterval method of the HttpSession interface.
      • This timeout can be changed by the Developer using the setMaxInactiveInterval method of the HttpSession interface. The timeout periods used by these methods are defined in seconds.
      • If the timeout period for a session is set to -1, the session will never expire.
      • The session invalidation will not take effect until all servlets using that session have exited theservice method.
      • The getLastAccessedTime method of the HttpSession interface allows a servlet to determine the last time the session was accessed before the current request.
      • Multiple servlets executing request threads may have active access to a single session object at the same time.
      • Within an application marked as distributable, all requests that are part of a session must be handled by one Java Virtual Machine1 (“JVM”) at a time.
      • The distributed servlet container must support the mechanism necessary for migrating objects that implement Serializable.
      • In distributes systems, the Container Provider can ensure scalability and quality of service featureslike load-balancing and failover by having the ability to move a session object, and its contents, from any active node of the distributed system to a different node of the system.
      • Containers must notify any session attributes implementing the HttpSessionActivationListener during migration of a session. They must notify listeners of passivation prior to serialization of a session, and of activation after deserialization of a session.
      • Developer should always assume that all windows of a client are participating in the same session.

      J2EE Q’s July 21, 2005

      Posted by Coolguy in J2EE, Java.
      Tags:
      add a comment

      What are the different kinds of enterprise beans?

      A: Stateless session bean- An instance of these non-persistent EJBs provides a service without storing an interaction or conversation state between methods. Any instance can be used for any client.

      Stateful session bean- An instance of these non-persistent EJBs maintains state across methods and transactions. Each instance is associated with a particular client.

      Entity bean- An instance of these persistent EJBs represents an object view of the data, usually rows in a database. They have a primary key as a unique identifier. Entity bean persistence can be either container-managed or bean-managed.

      Message-driven bean- An instance of these EJBs is integrated with the Java Message Service (JMS) to provide the ability for message-driven beans to act as a standard JMS message consumer and perform asynchronous processing between the server and the

      Q: What is Session Bean?

      A: A session bean is a non-persistent object that implements some business logic running on the server. One way to think of a session object is as a logical extension of the client program that runs on the server.

      Session beans are used to manage the interactions of entity and other session beans,access resources, and generally perform tasks on behalf of the client.

      There are two basic kinds of session bean: stateless and stateful.

      Stateless session beans are made up of business methods that behave like procedures; they operate only on the arguments passed to them when they are invoked. Stateless beans are called stateless because they are transient; they do not maintain business state between method invocations.Each invocation of a stateless business method is independent from previous invocations. Because stateless session beans are stateless, they are easier for the EJB container to manage, so they tend to process requests faster and use less resources.

      Stateful session beans encapsulate business logic and state specific to a client. Stateful beans are called “stateful” because they do maintain business state between method invocations, held in memory and not persistent. Unlike stateless session beans, clients do not share stateful beans. When a client creates a stateful bean, that bean instance is dedicated to service only that client. This makes it possible to maintain conversational state, which is business state that can be shared by methods in the same stateful bean

      Q: What is Entity Bean?

      A: The entity bean is used to represent data in the database. It provides an object-oriented interface to data that would normally be accessed by the JDBC or some other back-end API. More than that, entity beans provide a component model that allows bean developers to focus their attention on the business logic of the bean, while the container takes care of managing persistence,transactions, and access control.

      There are two basic kinds of entity beans: container-managed ersistence (CMP) andbean-managed persistence (BMP).

      Container-managed persistence beans are the simplest for the bean developer to create and the most difficult for the EJB server to support. This is because all the logic for synchronizing the bean’s state with the database is handled automatically by the container. This means that the bean developer doesn’t need to write any data access logic, while the EJB server is

      supposed to take care of all the persistence needs automatically. With CMP, the container manages the persistence of the entity bean. Vendor tools are used to map the entity fields to the database and absolutely no database access code is written in the bean class.

      The bean-managed persistence (BMP) enterprise bean manages synchronizing its state with the database as directed by the container. The bean uses a database API to read and write its fields to the database, but the container tells it when to do each synchronization operation and manages the transactions for the bean automatically. Bean-managed persistence gives the bean developer the flexibility to perform persistence operations that are too complicated for the container or to use a data source that is not supported by the container

      Q: What are the methods of Entity Bean?

      A: An entity bean consists of 4 groups of methods:

      1. create methods: To create a new instance of a CMP entity bean, and therefore insert data into the database, the create() method on the bean’s home interface must be invoked. They look like this: EntityBeanClass ejbCreateXXX(parameters), where EntityBeanClass is an Entity Bean you are trying to instantiate, ejbCreateXXX(parameters) methods are used for creating Entity Bean instances according to the parameters specified and to some programmer-defined conditions.

      A bean’s home interface may declare zero or more create() methods, each of which must have corresponding ejbCreate() and ejbPostCreate() methods in the bean class. These creation methods are linked at run time, so that when a create() method is invoked on the home interface, the container delegates the invocation to the corresponding ejbCreate() and ejbPostCreate() methods on the bean class.

      2. finder methods: The methods in the home interface that begin with “find” are called the find methods. These are used to query the EJB server for specific entity beans, based on the name of the method and arguments passed. Unfortunately, there is no standard query language defined for find methods, so each vendor will implement the find method differently. In CMP entity beans, the find methods are not implemented with matching methods in the bean class; containers implement them when the bean is deployed in a vendor specific manner. The deployer will use vendor specific tools to tell the container how a particular find method should behave. Some vendors will use object-relational mapping tools to define the behavior of a find method while others will simply require the deployer to enter the appropriate SQL command.

      There are two basic kinds of find methods: single-entity and multi-entity. Single-entity find methods return a remote reference to the one specific entity bean that matches the find request. If no entity beans are found, the method throws an ObjectNotFoundException . Every entity bean must define the single-entity find method with the method name findByPrimaryKey(), which takes the bean’s primary key type as an argument.

      The multi-entity find methods return a collection ( Enumeration or Collection type) of entities that match the find request. If no entities are found, the multi-entity find returns an empty collection.

      3. remove methods: These methods (you may have up to 2 remove methods, or don’t have them at all) allow the client to physically remove Entity beans by specifying either Handle or a Primary Key for the Entity Bean.

      4. home methods: These methods are designed and implemented by a developer, and EJB specification doesn’t have any requirements for them except the need to throw a RemoteException is each home method.

      Q: What are the methods of Entity Bean?What is the difference between Container-Managed Persistent (CMP) bean and Bean-Managed Persistent(BMP) ?

      A: Container-managed persistence beans are the simplest for the bean developer to create and the most difficult for the EJB server to support. This is because all the logic for synchronizing the bean’s state with the database is handled automatically by the container. This means that the bean developer doesn’t need to write any data access logic, while the EJB server is supposed to take care of all the persistence needs automatically. With CMP, the container manages the persistence of the entity bean. A CMP bean developer doesn’t need to worry about JDBC code and transactions, because the Container performs database calls and transaction management instead of the programmer. Vendor tools are used to map the entity fields to the database and absolutely no database access code is written in the bean class. All table mapping is specified in the deployment descriptor. Otherwise, a BMP bean developer takes the load of linking an application and a database on his shoulders.

      The bean-managed persistence (BMP) enterprise bean manages synchronizing its state with the database as directed by the container. The bean uses a database API to read and write its fields to the database, but the container tells it when to do each synchronization operation and manages the transactions for the bean automatically. Bean-managed persistence gives the bean developer the flexibility to perform persistence operations that are too complicated for the container or to use a data source that is not supported by the container.BMP beans are not 100% database-independent, because they may contain database-specific code, but CMP beans are unable to perform complicated DML (data manipulation language) statements. EJB 2.0 specification introduced some new ways of querying database (by using the EJB QL – query language).

      Q: What are the callback methods in Entity beans?

      A: The bean class defines create methods that match methods in the home interface and business methods that match methods in the remote interface. The bean class also implements a set of callback methods that allow the container to notify the bean of events in its life cycle. The callback methods are defined in the javax.ejb.EntityBean interface that is implemented by all entity beans.The EntityBean interface has the following definition. Notice that the bean class implements these methods.

      public interface javax.ejb.EntityBean {

      public void setEntityContext();

      public void unsetEntityContext();

      public void ejbLoad();

      public void ejbStore();

      public void ejbActivate();

      public void ejbPassivate();

      public void ejbRemove();

      }

      The setEntityContext() method provides the bean with an interface to the container called the EntityContext. The EntityContext interface contains methods for obtaining information about the context under which the bean is operating at any particular moment. The EntityContext interface is used to access security information about the caller; to determine the status of the current transaction or to force a transaction rollback; or to get a reference to the bean itself, its home, or its primary key. The EntityContext is set only once in the life of an entity bean instance, so its reference should be put into one of the bean instance’s fields if it will be needed later.

      The unsetEntityContext() method is used at the end of the bean’s life cycle before the instance is evicted from memory to dereference the EntityContext and perform any last-minute clean-up.

      The ejbLoad() and ejbStore() methods in CMP entities are invoked when the entity bean’s state is being synchronized with the database. The ejbLoad() is invoked just after the container has refreshed the bean container-managed fields with its state from the database. The ejbStore() method is invoked just before the container is about to write the bean container-managed fields to the database. These methods are used to modify data as it’s being synchronized. This is common when the data stored in the database is different than the data used in the bean fields.

      The ejbPassivate() and ejbActivate() methods are invoked on the bean by the container just before the bean is passivated and just after the bean is activated, respectively. Passivation in entity beans means that the bean instance is disassociated with its remote reference so that the container can evict it from memory or reuse it. It’s a resource conservation measure the container employs to reduce the number of instances in memory. A bean might be passivated if it hasn’t been used for a while or as a normal operation performed by the container to maximize reuse of resources. Some containers will evict beans from memory, while others will reuse instances for other more active remote references. The ejbPassivate() and ejbActivate() methods provide the bean with a notification as to when it’s about to be passivated (disassociated with the remote reference) or activated (associated with a remote reference).

      Q: What is software architecture of EJB?

      A: Session and Entity EJBs consist of 4 and 5 parts respetively:

      1. A remote interface (a client interacts with it),

      2. A home interface (used for creating objects and for declaring business methods),

      3. A bean object (an object, which actually performs business logic and EJB-specific operations).

      4. A deployment descriptor (an XML file containing all information required for maintaining the EJB) or a set of deployment descriptors (if you are using some container-specific features).

      5.A Primary Key class – is only Entity bean specific

      Q: Can Entity Beans have no create() methods?

      A: Yes. In some cases the data is inserted NOT using Java application, so you may only need to retrieve the information, perform its processing, but not create your own information of this kind

      Q: What is bean managed transaction?

      A: If a developer doesn’t want a Container to manage transactions, it’s possible to implement all database operations manually by writing the appropriate JDBC code. This often leads to productivity increase, but it makes an Entity Bean incompatible with some databases and it enlarges the amount of code to be written. All transaction management is explicitly performed by a developer.

      Q: What are transaction attributes?

      A: The transaction attribute specifies how the Container must manage transactions for a method when a client invokes the method via the enterprise bean’s home or component interface or when the method is invoked as the result of the arrival of a JMS message. (Sun’s EJB Specification) Below is a list of transactional attributes:

      1. NotSupported – transaction context is unspecified.

      2. Required – bean’s method invocation is made within a transactional context. If a client is not associated with a transaction, a new transaction is invoked automatically.

      3. Supports – if a transactional context exists, a Container acts like the transaction attribute is Required, else – like NotSupported.

      4. RequiresNew – a method is invoked in a new transaction context.

      5. Mandatory – if a transactional context exists, a Container acts like the transaction attribute is Required, else it throws a javax.ejb.TransactionRequiredException.

      6. Never – a method executes only if no transaction context is specified.

      Q: What are transaction isolation levels in EJB?

      A: 1. Transaction_read_uncommitted- Allows a method to read uncommitted data from a DB(fast but not wise).

      2. Transaction_read_committed- Guarantees that the data you are getting has been committed.

      3. Transaction_repeatable_read – Guarantees that all reads of the database will be the same during the transaction (good for read and update operations).

      4. Transaction_serializable- All the transactions for resource are performed serial.

      Q: How EJB Invocation happens?

      A: Step 1: Retrieve Home Object reference from Naming Service via JNDI.

      step 2: Return Home Object reference to the client.

      step 3: Create me a new EJB Object through Home Object interface.

      step 4: Create EJB Object from the Ejb Object

      step 5: Return EJB Object reference to the client.

      step 6: Invoke business method using EJB Object reference.

      step 7: Delegate request to Bean (Enterprise Bean).

      Q: Is it possible to share an HttpSession between a JSP and EJB? What happens when I change a value in the HttpSession from inside an EJB?

      A: You can pass the HttpSession as parameter to an EJB method, only if all objects in session are serializable.This has to be consider as ?passed-by-value”, that means that it?s read-only in the EJB. If anything is altered from inside the EJB, it won?t be reflected back to the HttpSession of the Servlet Container.The ?pass-by-reference? can be used between EJBs Remote Interfaces, as they are remote references. While it IS possible to pass an HttpSession as a parameter to an EJB object, it is considered to be ?bad practice ? in terms of object oriented design. This is because you are creating an unnecessary coupling between back-end objects (ejbs) and front-end objects (HttpSession). Create a higher-level of abstraction for your ejb?s api. Rather than passing the whole, fat, HttpSession (which carries with it a bunch of http semantics), create a class that acts as a value object (or structure) that holds all the data you need to pass back and forth between front-end/back-end. Consider the case where your ejb needs to support a non-http-based client. This higher level of abstraction will be flexible enough to support it.

      Q: The EJB container implements the EJBHome and EJBObject classes. For every request from a unique client, does the container create a separate instance of the generated EJBHome and EJBObject classes?

      A: The EJB container maintains an instance pool. The container uses these instances for the EJB Home reference irrespective of the client request. while refering the EJB Object classes the container creates a separate instance for each client request. The instance pool maintainence is up to the implementation of the container. If the container provides one, it is available otherwise it is not mandatory for the provider to implement it. Having said that, yes most of the container providers implement the pooling functionality to increase the performance of the application server. The way it is implemented is again up to the implementer.

      Q: Can the primary key in the entity bean be a Java primitive type such as int?

      A: The primary key can’t be a primitive type–use the primitive wrapper classes, instead. For example, you can use java.lang.Integer as the primary key class, but not int (it has to be a class, not a primitive)

      Q: Can you control when passivation occurs?

      The developer, according to the specification, cannot directly control when passivation occurs. Although for Stateful Session Beans, the container cannot passivate an instance that is inside a transaction. So using transactions can be a a strategy to control passivation.

      The ejbPassivate() method is called during passivation, so the developer has control over what to do during this exercise and can implement the require optimized logic.

      Some EJB containers, such as BEA WebLogic, provide the ability to tune the container to minimize passivation calls.

      Taken from the WebLogic 6.0 DTD -“The passivation-strategy can be either “default” or “transaction”. With the default setting the container will attempt to keep a working set of beans in the cache. With the “transaction” setting, the container will passivate the bean after every transaction (or method call for a non-transactional invocation).

      TOP

      Q: What is the advantage of using Entity bean for database operations, over directly using JDBC API to do database operations? When would I use one over the other?

      A: Entity Beans actually represents the data in a database. It is not that Entity Beans replaces JDBC API. There are two types of Entity Beans Container Managed and Bean Mananged. In Container Managed Entity Bean – Whenever the instance of the bean is created the container automatically retrieves the data from the DB/Persistance storage and assigns to the object variables in bean for user to manipulate or use them. For this the developer needs to map the fields in the database to the variables in deployment descriptor files (which varies for each vendor).

      In the Bean Managed Entity Bean – The developer has to specifically make connection, retrive values, assign them to the objects in the ejbLoad() which will be called by the container when it instatiates a bean object. Similarly in the ejbStore() the container saves the object values back the the persistance storage. ejbLoad and ejbStore are callback methods and can be only invoked by the container. Apart from this, when you use Entity beans you dont need to worry about database transaction handling, database connection pooling etc. which are taken care by the ejb container. But in case of JDBC you have to explicitly do the above features. what suresh told is exactly perfect. ofcourse, this comes under the database transations, but i want to add this. the great thing about the entity beans of container managed, whenever the connection is failed during the transaction processing, the database consistancy is mantained automatically. the container writes the data stored at persistant storage of the entity beans to the database again to provide the database consistancy. where as in jdbc api, we, developers has to do manually

      Q: What is EJB QL?

      A: EJB QL is a Query Language provided for navigation across a network of enterprise beans and dependent objects defined by means of container managed persistence. EJB QL is introduced in the EJB 2.0 specification. The EJB QL query language defines finder methods for entity beans with container managed persistenceand is portable across containers and persistence managers. EJB QL is used for queries of two types of finder methods: Finder methods that are defined in the home interface of an entity bean and which return entity objects. Select methods, which are not exposed to the client, but which are used by the Bean Provider to select persistent values that are maintained by the Persistence Manager or to select entity objects that are related to the entity bean on which the query is defined

      Q: Brief description about local interfaces?

      A: EEJB was originally designed around remote invocation using the Java Remote Method Invocation (RMI) mechanism, and later extended to support to standard CORBA transport for these calls using RMI/IIOP. This design allowed for maximum flexibility in developing applications without consideration for the deployment scenario, and was a strong feature in support of a goal of component reuse in J2EE.

      Many developers are using EJBs locally — that is, some or all of their EJB calls are between beans in a single container.

      With this feedback in mind, the EJB 2.0 expert group has created a local interface mechanism. The local interface may be defined for a bean during development, to allow streamlined calls to the bean if a caller is in the same container. This does not involve the overhead involved with RMI like marshalling etc. This facility will thus improve the performance of applications in which co-location is planned.

      Local interfaces also provide the foundation for container-managed relationships among entity beans with container-managed persistence

      Q: What are the special design care that must be taken when you work with local interfaces?

      A: EIt is important to understand that the calling semantics of local interfaces are different from those of remote interfaces. For example, remote interfaces pass parameters using call-by-value semantics, while local interfaces use call-by-reference.

      This means that in order to use local interfaces safely, application developers need to carefully consider potential deployment scenarios up front, then decide which interfaces can be local and which remote, and finally, develop the application code with these choices in mind.

      While EJB 2.0 local interfaces are extremely useful in some situations, the long-term costs of these choices, especially when changing requirements and component reuse are taken into account, need to be factored into the design decision

      Q: What happens if remove( ) is never invoked on a session bean?

      A: In case of a stateless session bean it may not matter if we call or not as in both cases nothing is done. The number of beans in cache is managed by the container.

      In case of stateful session bean, the bean may be kept in cache till either the session times out, in which case the bean is removed or when there is a requirement for memory in which case the data is cached and the bean is sent to free pool

      Q: What is the difference between Message Driven Beans and Stateless Session beans?

      A: In several ways, the dynamic creation and allocation of message-driven bean instances mimics the behavior of stateless session EJB instances, which exist only for the duration of a particular method call. However, message-driven beans are different from stateless session EJBs (and other types of EJBs) in several significant ways:

      Message-driven beans process multiple JMS messages asynchronously, rather than processing a serialized sequence of method calls.

      Message-driven beans have no home or remote interface, and therefore cannot be directly accessed by internal or external clients. Clients interact with message-driven beans only indirectly, by sending a message to a JMS Queue or Topic.

      Note: Only the container directly interacts with a message-driven bean by creating bean instances and passing JMS messages to those instances as necessary.

      The Container maintains the entire lifecycle of a message-driven bean; instances cannot be created or removed as a result of client requests or other API calls

      Q: How can I call one EJB from inside of another EJB?

      A: EJBs can be clients of other EJBs. It just works. Use JNDI to locate the Home Interface of the other bean, then acquire an instance reference, and so forth.

      Q: What is an EJB Context?

      A: EJBContext is an interface that is implemented by the container, and it is also a part of the bean-container contract. Entity beans use a subclass of EJBContext called EntityContext. Session beans use a subclass called SessionContext. These EJBContext objects provide the bean class with information about its container, the client using the bean and the bean itself. They also provide other functions. See the API docs and the spec for more details

      Core J2EE Patterns: Patterns index page July 20, 2005

      Posted by Coolguy in J2EE.
      add a comment

      Core J2EE Patterns: Patterns index page

      Standard MBeans April 13, 2005

      Posted by Coolguy in J2EE.
      add a comment

      Standard MBeans