| What is the need of Remote and Home interface. Why cant
it be in one? |
| The main reason is because there is a clear
division of roles and responsabilities between the two interfaces. The
home interface is your way to communicate with the container, that is who
is responsable of creating, locating even removing one or more beans. The
remote interface is your link to the bean, that will allow you to remotely
access to all its methods and members. As you can see there are two
distinct elements (the container and the beans) and you need two different
interfaces for accessing to both of them. |
Can I develop an Entity Bean without implementing
the create() method in the home interface? |
| As per the specifications, there can be 'ZERO' or
'MORE' create() methods defined in an Entity Bean. In cases where create()
method is not provided, the only way to access the bean is by knowing its
primary key, and by acquiring a handle to it by using its corresponding
finder method. In those cases, you can create an instance of a bean based
on the data present in the table. All one needs to know is the primary key
of that table. i.e. a set a columns that uniquely identify a single row in
that table. Once this is known, one can use the 'getPrimaryKey()' to get a
remote reference to that bean, which can further be used to invoke
business methods. |
What is the difference between Context,
InitialContext and Session Context? How they are used? |
javax.naming.Context is an interface that provides
methods for binding a name to an object. It's much like the RMI
Naming.bind() method.
javax.naming.InitialContext is a Context and
provides implementation for methods available in the Context interface.
Where as SessionContext is an EJBContext object that is provided
by the EJB container to a SessionBean in order for the SessionBean to
access the information and/or services or the container.
There is
EntityContext too which is also and EJBContext object that'll be provided
to an EntityBean for the purpose of the EntityBean accessing the container
details. In general, the EJBContext (SessionContext and EntityContext),
AppletContext and ServletContext help the corresponding Java objects in
knowing about its 'context' [environment in which they run], and to access
particular information and/or service. Whereas, the javax.naming.Context
is for the purpose of 'NAMING' [by the way of referring to] an object.
|
Why an onMessage call in Message-driven bean is
always a seperate transaction? |
EJB 2.0 specification: "An onMessage call is
always a separate transaction, because there is never a transaction in
progress when the method is called."
When a message arrives, it is
passed to the Message Driven Bean through the onMessage() method, that is
where the business logic goes.
Since there is no guarantee when the
method is called and when the message will be processed, is the container
that is responsible of managing the environment, including
transactions.
|
Why are ejbActivate() and ejbPassivate() included
for stateless session bean even though they are never required as it is a
nonconversational bean? |
To have a consistent interface, so that there is no
different interface that you need to implement for Stateful Session Bean
and Stateless Session Bean.
Both Stateless and Stateful Session
Bean implement javax.ejb.SessionBean and this would not be possible if
stateless session bean is to remove ejbActivate and ejbPassivate from the
interface.
|
Static variables in EJB should not be relied upon as
they may break in clusters.Why? |
Static variables are only ok if they are final. If they
are not final, they will break the cluster. What that means is that if you
cluster your application server (spread it across several machines) each
part of the cluster will run in its own JVM.
Say a method on the
EJB is invoked on cluster 1 (we will have two clusters - 1 and 2) that
causes value of the static variable to be increased to 101. On the
subsequent call to the same EJB from the same client, a cluster 2 may be
invoked to handle the request. A value of the static variable in cluster 2
is still 100 because it was not increased yet and therefore your
application ceases to be consistent. Therefore, static non-final variables
are strongly discouraged in EJBs. |
If I throw a custom ApplicationException from a
business method in Entity bean which is participating in a transaction,
would the transaction be rolled back by container? |
EJB Transaction is automatically rolled back only when a
SystemException (or a subtype of it) is thrown.
Your
ApplicationExceptions can extend from javax.ejb.EJBException, which is a
sub class of RuntimeException. When a EJBException is encountered the
container rolls back the transaction. EJB Specification does not mention
anything about Application exceptions being sub-classes of
EJBException.
You can tell container to rollback the transaction,
by using setRollBackOnly on SessionContext/EJBContext object as per type
of bean you are using. |
Does Stateful Session bean support instance pooling?
|
| Stateful Session Bean conceptually doesn't have instance
pooling. |
Can I map more than one table in a CMP? |
| no, you cannot map more than one table to a single CMP
Entity Bean. CMP has been, in fact, designed to map a single table. |
Can I invoke Runtime.gc() in an EJB? |
| You shouldn't. What will happen depends on the
implementation, but the call will most likely be ignored. |
Can a Session Bean be defined without ejbCreate()
method? |
The ejbCreate() methods is part of the bean's lifecycle,
so, the compiler will not return an error because there is no ejbCreate()
method.
However, the J2EE spec is explicit:
· the home
interface of a Stateless Session Bean must have a single create()
method with no arguments,
while the session bean class must
contain exactly one ejbCreate() method, also without arguments.
·
Stateful Session Beans can have arguments (more than one create method)
|
How to implement an entity bean which the PrimaryKey
is an autonumeric field |
The EJB 2 Spec (10.8.3 - Special case: Unknown primary
key class) says that in cases where the PrimaryKeys are generated
automatically by the underlying database, the bean provider must declare
the findByPrimaryKey method to return java.lang.Object and specify the
Primary Key Class as java.lang.Object in the Deployment Descriptor.
When defining the Primary Key for the Enterprise Bean, the
Deployer using the Container Provider's tools will typically add
additional container-managed fields to the concrete subclass of the entity
bean class.
In this case, the Container must generate the Primary
Key value when the entity bean instance is created (and before
ejbPostCreate is invoked on the instance.) |
What is clustering? |
Clustering is grouping machines together to transparantly
provide enterprise services. Clustering is an essential piece to solving
the needs for today's large websites.
The client does not know the
difference between approaching one server or approaching a cluster of
servers. |
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? |
| 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. |
If my session bean with single method insert record
into 2 entity beans, how can know that the process is done in same
transaction (the attributes for these beans are Required)? |
If your session bean is using bean-managed transactions,
you can ensure that the calls are handled in the same transaction by :
javax.transaction.UserTransaction tran=
null;
try{
tran=ctx.getUserTransaction();
tran.begin();
myBeanHome1.create(....);
myBeanHome2.create(...);
tran.commit();
}catch(...){}
You
may want to check if you're already running in a transaction by calling
tran.getStatus(). |
When should I adopt BMP and when I should use CMP?
|
You can use CMP and BMP beans in the same application...
obviously, a bean can be BMP or CMP, not both at the same time (they are
mutually exclusive).
There is a common approach that is normally
used and considered a good one. You should start developing CMP beans,
unless you require some kind of special bean, like multi-tables, that
cannot be completely realized with a single bean. Then, when you realize
that you need something more or that you would prefer handling the
persistence (performanbce issue are the most common reason), you can
change the bean from a CMP to a BMP. |