7283499 Ejb Questions

8/3/2019 7283499 Ejb Questions

1/86

EJB QUESTIONS

QUESTION NO : 1

QUESTION STATEMENT : You have written a web application using EJBs on an application server. Now the

requirement to migrate

the EJBs to another application server vendor arises. Which of the following types of Enterprise Java Bean will be most

likely to be difficult to port from one App Server to another?

CHOICES :

a) Stateful Session Bean

b) Stateless Session Bean

c) BMP (Bean Managed Persistence) Entity Bean

d) CMP (Container Managed Persistence) Entity Bean

CORRECT ANSWER : d

EXPLANATION :

Choice D is Correct. EJBs are portable if you write them to be. Session beans and BMP (bean managed

persistence) entity beans usually port quite easily. In contrast, CMP (container managed persistence) entity beans need a

good bit of work.

Quite often, applications that rely on a clustering implementation take longer to port, as clustering is

a big differentiator between vendors and is also not addressed adequately in the EJB specification. The work might not

be in

rewriting code, but in reconfiguring deployment descriptors and container/server configurations. In addition,administration

and configuration tools and mechanisms are vendor-specific, as are things like startup and shutdown scripts andsometimes

build scripts.

--------------------------------------------------------------------

QUESTION NO : 2QUESTION STATEMENT : Which interface should be implemented by a stateful session bean if it needs to

synchronize its

conversational state with the transactional context ?

CHOICES :

a) javax.transaction.UserTransactionb) javax.ejb.SessionSynchronization

1


2/86

c) javax.ejb.EJBContext

d) javax.transaction.TransactionContext

e) javax.ejb.SessionTransaction

CORRECT ANSWER : b

EXPLANATION :

Choice B is Correct. If a bean needs to synchronize its conversational state with the transactional context,

the bean class must implement the javax.ejb.SessionSynchronization interface. This interface contains methods to notify

the

session bean when a transaction begins, when it is about to complete, and when it has completed.The enterprise bean

developer

can use these methods to synchronize the state of the session enterprise bean instance with ongoing transactions.

UserTransaction provides an interface to the transaction manager that allows the application developer to manage the

scope of

a transaction explicitly. So A is not the correct answer. EJBContext interface is the bean classs interface to the container

system. It provides information about the security identity and transaction status. So C is also not the right answer. D

and

E are interfaces which do not exist.

--------------------------------------------------------------------

QUESTION NO : 3QUESTION STATEMENT : For every EJB, you write a Home Interface, Remote Interface and the Bean class. EJB

doesn't require that

the bean class implement these interfaces. Its encouraged that the bean class implement these interfaces. True/False?

CHOICES :

a) True

b) False

CORRECT ANSWER : b

EXPLANATION :

False, its not advisable for Bean class to implement the Remote and Home interface. The Home interface extends

EJBHome and the Remote interface extends EJBObject. These base interfaces (EJBObject and EJBHome) define a lot

of other

methods that are maintained by container automatically. In case the Bean class is implementing the Remote and Home

2


3/86

interfaces, it becomes necessary for it to implement all those methods which are being taken care by the Container. Thus

its

not advisable and discouraged for Bean class to implement Remote and Home interface.

--------------------------------------------------------------------

QUESTION NO : 4

QUESTION STATEMENT : You have an enterprise application that needs to display a large list of categories in order

to let a

user select from that list. The average size of the list is 100. If you decide to use Enterprise Java Beans to retrieve the

data, which of the following EJB types would be the best choice in terms of performance and utilization of resources ?

CHOICES :

a) Stateless Session Beanb) Stateful Session Bean

c) BMP Entity Beand) CMP Entity Bean

CORRECT ANSWER : b

EXPLANATION :

Choice B is Correct. When you are retrieving data to display in a list, you usually need only a small subset

of data. If you use a custom finder method to retrieve a large set of entity beans and utilize only a small set of data

elements, it would be a huge wastage of resources.So instead of retrieving and iterating over a collection of entitybeans,

create a Stateful Session Bean that can retrieve only those pieces of data that are necessary through a simple SQL query.

Also, all entity beans are automatically distributed, transactional and persistent. There is a considerable amount of

overhead associated with each of these services. So in a situation like the above where a huge amount of data just needs

to

be read and not modified, if we use entity beans, it would cause unnecessary overhead. Since the selection made by

each user

needs to be stored for further operations, stateful session beans are preferred over stateless beans.

--------------------------------------------------------------------

QUESTION NO : 5

QUESTION STATEMENT : Which of the following are the differences between a Stateless Session bean and a Stateful

Session Bean?

3


4/86

CHOICES :

a) Stateless beans define instance pooling in their lifecycle and stateful beans do not.

b) Stateful beans can have instance variables while stateless beans cannot.

c) A stateless session bean only has one ejbCreate() method which takes no arguments while a stateful bean can haveany

number of overloaded ejbCreate() methods.

d) Calling the create method of EJBHome does not result in a call to the bean's ejbCreate() method in the case of a

stateless bean while it does in the case of a stateful bean.

e) The EJBObject of a stateless bean can be shared by multiple clients concurrently, but in the case of a stateful bean

each

client has a dedicated EJBObject.

CORRECT ANSWER : acd

EXPLANATION :

Choice A, C and D are Correct. B and E are false. Stateless session beans can have instance variables similar

to stateful beans ,but the state of these variables are not preserved between method invocations as it is in the case of

stateful beans.With session beans of both types, the EJB object is dedicated to one client. A stateless session bean may

be

used by multiple clients one after the other, but the same EJB object is not accessed concurrently by more than 1 client.

Stateless beans have only 2 states in their lifecycle, the Does Not Exist State and Method Ready Pool State. Stateful

beans

are not pooled since each one is dedicated for a particular client only and hence cannot be reused. In stateless session

beans, calling EJBHome's create() method results in the creation of an EJBObject for the bean, but ejbCreate() of the

bean is

not invoked. Since the state is not maintained having arguments for the create() method is illegal. The no-argument

version

of ejbCreate() is invoked by the container after the bean is instantiated.

--------------------------------------------------------------------

QUESTION NO : 6

QUESTION STATEMENT : Which of the following exceptions is thrown by the ejbLoad() method of an entity bean

when the database

row to be loaded is not found ?

CHOICES :

4


5/86

a) NoSuchEntityException

b) EJBException

c) RemoteException

d) ObjectNotFoundExceptione) FinderException

CORRECT ANSWER : a

EXPLANATION :

Choice A is Correct. NoSuchEntityException is a system exception thrown by the ejbLoad() method of an entity

bean when the database row to be loaded is not found and also by the ejbStore() method when the database row to be

updated

cannot be found. This is a system exception which causes the container to rollback the transaction automatically.

EJBException is also a SystemException, but is called by the EJB methods only if any other system problem has

occurred.

RemoteException is never thrown directly by the bean, the container throws this exception if the bean throws an

EJBException.

ObjectNotfoundException is thrown by a finder method if a requested database row could not be found.

FinderException is the

super class of ObjectNotFoundException.

--------------------------------------------------------------------

QUESTION NO : 7

QUESTION STATEMENT : In which of the following cases do we need to use the narrow method of

PortableRemoteObject to get the

correct object type from the object reference returned by the method ?

CHOICES :

a) When an EJB home reference is obtained using the javax.naming.Context.lookup() method

b) When an EJB object reference is obtained using the javax.ejb.Handle.getEJBObject() method

c) When the EJB object reference is obtained using the create() method of the home object

d) When the EJB object reference is obtained using the findByPrimaryKey() method of the home object.

CORRECT ANSWER : ab

EXPLANATION :

Choice A and B are Correct. The PortableRemoteObject.narrow() method is used to explicitly narrow the remote

reference returned by a method to a more specific type as is needed in a typical object oriented environment. The

PortableRemoteObject abstracts the narrowing process so that any underlying protocol (eg: IIOP) can be used for

5


6/86

narrowing.

The narrow method takes 2 arguments : the remote reference that is to be narrowed and the type it should be

narrowed to.The narrow method only needs to be used when a remote reference to an EJB object is returned without a

specific

Remote interface type. In the cases A and B, the methods return a remote reference of type Object. In case A, the

returned

reference needs to be narrowed to the appropriate home interface type. In case B, the returned reference needs to be

narrowed

to the appropriate bean interface type. The create() and findByPrimaryKey methods defined in the home interface do

not

require the use of narrow() because these methods already return the correct EJB object type. So C and D are not the

right

answers.

--------------------------------------------------------------------

QUESTION NO : 8

QUESTION STATEMENT : Which of the following steps in the lifecycle of a Stateful Session bean occur for a

Stateless Session

Bean after the client has invoked the create() method on the EJB home?

CHOICES :

a) Container invokes Class.newInstance() method on the bean class

b) The bean instance is assigned to its EJBObject

c) Container invokes setSessionContext() method on the bean instanced) Container invokes ejbCreate() method on the bean instance

e) Container invokes ejbRemove() method on the bean at the end of its lifecycle

CORRECT ANSWER : be

EXPLANATION :

Choice B and E are Correct. The biggest difference between a Stateful session bean and the other bean types

is that the stateful beans do not use instance pooling since they are dedicated to one client for their entire life. So when

a client invokes the create() method on an EJB home of a stateful bean, the container creates a new instance of the bean

by

calling Class.newInstance(). The bean instance is now assigned to it's EJBObject. The container now invokes

6


7/86

setSessionContext() on the bean, handing it it's reference to the SessionContext. Finally the container invokes

ejbCreate()

which matches with the create() method invoked by the client.

In the case of the Stateless session bean, the container

creates a number of stateless instances and keeps them in the method-ready pooled state.So the Class.newInstance(),

setSessionContext() and ejbCreate() are invoked by the container when the bean moves into the pooled state ready for

serving

any method invocations. These methods are not re-invoked whenever a client requests a remote reference to the bean.So A, C

and D are not correct. So in stateless beans, calling the EJBHome's create() method results only in the assigning of the

EJBObject to the bean and returning the remote reference of the EJBObject to the client. So B is correct. In the case of

both

types of beans, the container invokes ejbRemove() at the end of the lifecycle. So E is also correct.

--------------------------------------------------------------------

QUESTION NO : 9

QUESTION STATEMENT : Which of the following needs to be done to end the client session of a Stateful SessionBean ?

CHOICES :

a) Call the remove() method of the home object passing the primary key of the bean as the argument.

b) Call the bean's remove() method passing the Session Context of the bean as the argument.

c) Call the remove() method of the home object passing the Handle of the bean as the argument.

d) Call the remove() method of the home object passing the primary key of the bean as the argument.

CORRECT ANSWER : c

EXPLANATION :

Choice C is Correct. The EJBHome.remove() method is responsible for deleting a bean.The argument is either the

javax.ejb.Handle in the case of stateful session beans and primary key in the case of entity beans. The Handle isessentially

a serializable pointer to a specific bean. For session beans, the EJBHome.remove() on the bean ends the session's

service to

the client. When EJBHome.remove() is invoked, the remote reference to the session beans becomes invalid and any

conversational state maintained by the bean is lost. If for some reason the bean can't be removed, RemoveException is

7


8/86

thrown

--------------------------------------------------------------------

QUESTION NO : 10

QUESTION STATEMENT : If no matching beans are found, the FindByPrimaryKey method defined in the home

object of an entity bean

will

CHOICES :

a) return a null reference

b) throw javax.ejb.FindException

c) throw javax.ejb.ObjectNotFoundException

d) throw RemoteException

CORRECT ANSWER : c

EXPLANATION :

Choice C is Correct. findByPrimaryKey is a standard method that all home interfaces for entity beans must

support. With Container Managed Persistence, implementations of find methods are generated automatically at

deployment

time.Find methods that return a single remote reference throw a FinderException if an application error occurs and an

ObjectNotFoundException if a matching bean cannot be found.

The ObjectNotFoundException is a subtype of FinderException and

is only thrown by find methods which return single remote references. Find methods that return an Enumeration or

Collection

type return an empty collection of no matching beans can be found or throw a FinderException if an application error

occurs.

--------------------------------------------------------------------

QUESTION NO : 11

QUESTION STATEMENT : Which of the following is NOT true about clients creating and finding enterprise javabeans ?

CHOICES :

a) Every find method in the home interface of an entity bean should corresponding to an ejbFind() method in the bean

itself.

b) Unlike entity beans, session beans do not implement find methods

8


9/86

c) An entity bean need not have a create() method in the home interface.

d) Find methods always return the remote-interface type for the bean

e) For CMP entity beans, implementations of the find methods are generated automatically at deployment time.

CORRECT ANSWER : d

EXPLANATION :

Choice D is Correct. Find methods of an entity bean can be of 2 types : single-entity or multi-entity

Single-entity finder methods return a remote interface type appropriate for that bean. Multi-entity finder methods return

an

Enumeration or Collection type. Every find method in the home interface of an entity bean should corresponding to an

ejbFind() method in the bean itself.

Session beans do not represent an entity in the database, so they do not need find

methods. An entity bean can be designed without a create() method if it is never meant to be created by a client. Then

the

entity can be only by using find() methods on the home interface. For CMP entity beans, implementations of the findmethods

are generated automatically by the container at deployment time.

--------------------------------------------------------------------

QUESTION NO : 12

QUESTION STATEMENT : Which of the following interfaces provide methods to remove ejbs ?

CHOICES :

a) EJBObject

b) EJBContextc) EJBHome

d) Context

e) SessionContext

f) EntityContext

CORRECT ANSWER : ac

EXPLANATION :

Choices A and C are correct. EJBObject and EJBHome interfaces provide the remove() method which can be used to

remove the session bean or entity bean. EJBContext interface is the bean class's interface to the container system. It

provides information about the security identity and transaction status. It also provides access to environment variables

and

9


10/86

the bean's EJBHome. But it does not have methods to create, delete or manipulate beans in any other way. So B is not

the

right choice.

SessionContext and EntityContext are specializations of the EJBContext interface. EntityContext has methods

to get an EntityBean's object reference and primary key. SessionContext provides the session bean instance with an

interface

to the container. So E and F are also incorrect. D is incorrect because Context is the starting point for any JNDI lookup.

This interface represents a naming context, which consists of a set of name-to-object bindings. It contains methods for

examining and updating these bindings. So D is also a wrong choice.

--------------------------------------------------------------------

QUESTION NO : 13QUESTION STATEMENT : In which of the following scenarios would you use BMP in preference to CMP for

developing an entity bean

?

CHOICES :

a) The bean's persistent data is stored in more than one data sourceb) The bean's persistent data is stored in a data source that is not supported by the EJB server that you are using

c) The bean should be defined independently of the database used to store it's state.

d) The bean should be reusable and flexible across applicationse) Deployment tools are inadequate for mapping the bean instance's state to the database.

CORRECT ANSWER : abe

EXPLANATION :

Choice A, B and E are Correct. Container managed beans are the simplest to develop because they allow you to

focus on the business logic, delegating the responsibility of persistence to the EJB container.The advantage of container

managed persistence is that the bean can be defined independent of the database used to store its state. The bean state is

stored independently which makes the bean more reusable and flexible across applications.

You must use BMP if any of the

following is true about an entity bean:-The bean's persistent data is stored in more than one data source or the bean's

persistent data is stored in a data source that is not supported by the EJB server that you are using. Bean managed

persistence is also the alternative to container managed persistence when the deployment tools are inadequate for

mapping

10


11/86


12/86

QUESTION STATEMENT : Which of the following methods should NOT be used in the container managed

transactions?

CHOICES :

a) The commit, setAutoCommit, and rollback methods of java.sql.Connection

b) The getUserTransaction method of javax.ejb.EJBContextc) getRollbackOnly and setRollbackOnly methods of the EJBContext interface

d) Any method of javax.transaction.UserTransaction

CORRECT ANSWER : abd

EXPLANATION :

Choice A, B and D are Correct. When you use container managed transactions, we should not invoke any method

that might interfere with the transaction boundaries set by the container. The commit, setAutoCommit and rollback

methods of

java.sql.Connection are used to control JDBC transactions explicitly. The getUserTransaction method of

javax.ejb.EJBContext

returns a UserTransaction which is used for explicit transaction management using the Java Transaction APIs. So anymethod

involving the UserTransaction interface is prohibited in container managed transactions.

The EJBContext interface provides

the methods SetRollbackOnly and getRollbackOnly. The getRollbackOnly() method returns true if the current

transaction has

been marked for rollback. This can be used to avoid executing work that would not be committed anyway. By invoking

the

setRollbackOnly method of the EJBContext interface, the bean method instructs the container to roll back the

transaction.

This power can be used if the bean detects a condition that would cause inconsistent data to be committed when the

transaction completes. These 2 methods can be used only from transactions which are container managed.

--------------------------------------------------------------------

QUESTION NO : 16

QUESTION STATEMENT : The business method of a session bean has the transaction attribute set to Required. Aclient attempts

to invoke the bean method without a transaction context. What will be the result ?

CHOICES :

a) Container creates a new transaction context and invokes the bean method from within that context.

12


13/86

b) Container invokes bean methods without a transaction context.

c) TransactionRequiredException is thrown to the client.

d) TransactionNotSupportedException is thrown to the client

CORRECT ANSWER : a

EXPLANATION :

Choice A is Correct. The transaction attribute defines the transactional manner in which the container invokes

enterprise bean methods. This attribute is set for individual methods in a bean. Setting the transaction attribute to

Required, directs the container to invoke the bean method within a transaction context. If a client invokes a beanmethod

from within a transaction context, the container invokes the bean method within the client transaction context. If a client

invokes a bean method outside of a transaction context, the container creates a new transaction context and invokes the

bean

method from within that context. The transaction context is passed to any enterprise bean objects or resources that areused

by this bean method.

--------------------------------------------------------------------

QUESTION NO : 17

QUESTION STATEMENT : A method of a stateless session bean which has a transaction attribute of TX_SUPPORTSis invoked by a

client-initiated transaction. The client receives a TransactionRolledbackException. Which are the possible causes ?

CHOICES :

a) The bean method threw a RemoteException

b) The bean method threw an Application Exception

c) The bean method threw an EJBException

d) The bean method threw an Unchecked Exception

CORRECT ANSWER : d

EXPLANATION :D is the correct choice. Regardless of the method's transaction attribute, an unchecked exception causes the

transaction to be rolled back, whether the transaction is container-initiated, client-initiated or bean-managed.Unchecked

exceptions thrown by a bean in the scope of a transaction always causes a rollback. The container catches the

unchecked

13


14/86

exception and rethrows it to the client as a TransactionRolledbackException.

When a transaction is passed from a client to a

bean, the client defines the scope of the transaction. So application exceptions and Remote Exceptions thrown by thebeans do

not automatically cause the transaction to be rolled back. So B and C are not correct. A bean does not throw

RemoteException,

it is always thrown by the container itself in response to some exceptions thrown by the bean.

--------------------------------------------------------------------

QUESTION NO : 18

QUESTION STATEMENT : Which of the following method invocations on the EntityContext would cause

IllegalStateException to be

thrown in the case of an entity bean ?

CHOICES :

a) Invoking getEJBObject() method inside ejbCreate()

b) Invoking getEJBHome() method inside ejbFind()

c) Invoking getEJBObject() method inside ebjActivate()

d) Invoking getPrimaryKey() method inside ejbPostCreate()

e) Invoking getPrimaryKey() method inside ejbFind()

CORRECT ANSWER : ae

EXPLANATION :

A and E are the correct choices. IllegalStateException is thrown by a method of EntityContext interface if the

instance invokes this method while the instance is in a state that does not allow the instance to invoke this method.The

EntityContext is given to the bean instance at the beginning of the lifecycle, before it is made available to service any

clients. As the bean instance is swapped from one EJB object to the next, the information made available through the

entitycontext also will change. Thus though the EntityContext is always available to the bean instance, but the instance

is

not always assigned to an EJBObject.

When ejbCreate() method is being executed, the bean is not associated with an

EJBObject. So calling getEJBObject() within ejbCreate() causes IllegalStateException to be thrown. So A is the right

choice.

Calling getPrimaryKey() method within ejbFind method will throw IllegalStateException because when the bean is not

associated

14


15/86

with an EJBObject, its has no primary key to return. B does not cause the exception because the home object exists

when any

of the bean methods are invoked. C is also a valid invocation because when ejbActivate and ejbPassivate are called, the

bean

is already associated with an EJBObject. Though getPrimaryKey() method cannot be invoked within ejbCreate andejbFind

methods, it is valid to invoke it within ejbPostCreate() method because when this method is called, the bean already has

a

valid primary key.

--------------------------------------------------------------------

QUESTION NO : 19

QUESTION STATEMENT : Which of the following ACID properties specifies that a transaction should be committedonly if all the

tasks in it are completed successfully ?

CHOICES :

a) Atomic

b) Consistent

c) Isolated

d) Durable

CORRECT ANSWER : a

EXPLANATION :

A is the right answer. A transaction is a set of operations that transforms data from one consistent state to

another. The ACID properties that should be followed by a safe transaction are Atomicity, Consistency, Isolation and

Durability.

To be atomic, a transaction must execute completely or not at all. If at least one task in the transaction

fails, the transaction is rolled back. If all the tasks are completed successfully, the transaction is committed. Consistency

refers to the integrity of the underlying data. A transaction must transition persistent data from one consistent state to

another. If a failure occurs during processing, the data must be restored to the state it was in prior to the

transaction.

Isolation means that a transaction should be allowed to execute without interference from other transactions.

Durability means that all the data changes during the course of the transaction must be written to some type of physical

15


16/86

storage before the transaction is successfully completed.This ensures that the changes are not lost if the system crashes.

--------------------------------------------------------------------

QUESTION NO : 20

QUESTION STATEMENT : A web application modeling a chess game is to be developed. The application is to be built

on J2EE

platform using different web components like EJB's, JSP's, Servlets. Which of the following type of EJBs is most suitedfor

representing a game of chess?

CHOICES :

a) CMP Entity Bean

b) BMP Entity Beanc) Stateless Session Bean

d) Stateful Session Bean

CORRECT ANSWER : d

EXPLANATION :

Choice D is correct. Stateless session beans are those which do not maintain its state between client calling

its methods. Every method invocation is treated as a new interaction with the client. On the other hand, stateful session

bean maintains a state that is available to client in the subsequent calls.Entity Beans are convenient components for

business objects which represent the real life entities. For example, A Customer, A Product, An Order, A Line Item, A

Campaign Event, A Quotation etc are some entities that you might have in your CRM application.EJB 2.0 specification

introduced a new type of session bean, which is integrated with a Java Messaging Server (JMS) system.These are calledMessage

Driven Beans (MDB). It is possible that the JMS associated with the application server, on receiving any message,

would

create or invoke a message driven bean.

A 'Game of Chess' would be represented by a stateful session bean because with every

call to its move() method, the state is changed and between the call to this method the state would be maintained.

--------------------------------------------------------------------

QUESTION NO : 21

QUESTION STATEMENT : You are responsible for designing and developing various web applications for your

organization. You

16


17/86

have an option to choose from various technologies and EJB is one of them. In which of the following scenarios listed

below,

EJB is advisable to be used ?

CHOICES :

a) Transaction Management is a concern.

b) You foresee that your application will need to scale beyond initial low usage levels. Also it will need to support

multiple and concurrent users.

c) Your application doesn't require platform independence and migration to another vendor is not a concern.d) You want to separate web-tier from business logic.

e) Your application is a big GUI to a database.


EXPLANATION :

Choice A, B and D are correct. A transaction is a unit-of-work or a set of tasks that are executed together.

Transactions are atomic; in other words, all the tasks in a transaction must be completed together to consider the

transaction a success. Transactions are managed automatically, so as a bean developer you don't need to use any APIs to

explicitly manage a bean's involvement in a transaction. Simply declaring the transactional attribute at deployment time

tells the EJB server how to manage the bean at runtime. Thus choosing EJBs when transaction management is required

is a wise

decision. Thus choice A is correct.

Apart from Transaction Management, the EJB container providers various other facilities

like Concurrency Service which is very useful in scenarios where a resource is simultaneosly shared by more than one

user.

Thus choice B is correct.

EJBs provide standard APIs for application development. The application developed on one

Application Server can be migrated to another one with little modifications. Also being written in Java, EJB's provide

platform independence. A solution like .Net could prove successful in a situation where platform independence is not

required

and being locked to single vendor is also acceptable. Thus choice C is not correct.

If your require your business logic to

be protected by a firewall, then you can deploy the web server and application server on separate machines and stick a

firewall in the middle. Thus choice D is correct.

If your application is just a big GUI to a database--heavy on data logic

17


18/86

but no business logic--you could achieve a deployment easily using JSPs with tag libraries connecting to a database via

JDBC.

Thus EJB is not advisable in this scenario. Thus choice E is not correct.

--------------------------------------------------------------------

QUESTION NO : 22

QUESTION STATEMENT : A stateful session bean which uses bean managed transaction throws IllegalStateException

when trying to

commit the transaction. Which of the following is a possible reason for this ?

CHOICES :

a) The thread which calls the commit() method is no longer associated with a transaction.

b) The transaction manager encountered an unexpected error condition.

c) One of the resources involved in the transaction was unable to perform an update.d) Heuristic decisions were made by one or more resources to roll back the transaction.

e) Heuristic decisions were made by some resources to rollback the transaction and some resources to commit.

CORRECT ANSWER : a

EXPLANATION :

A is the correct answer. Bean-managed transactions are programmatically demarcated within your bean

implementation. The transaction is completely controlled by the application. Bean managed transactions make use of

UserTransaction interface which provides methods like begin,commit and rollback for explicit transaction management.

The

commit() method completes the transaction that is associated with the current thread.

This method can throw several checked

exceptions. IllegalStateException is thrown if the current thread is not associated with a transaction. So A is correct in

this case. SystemException is thrown if the transaction manager (the EJB server) encounters an unexpected error

condition.

TransactionRolledbackException is thrown when the entire transaction is rolled back instead of committed; this can

happen if

one of the resources was unable to perform an update or if the UserTransaction.rollBackOnly() method was called.

HeuristicRollbackException indicates that heuristic decisions were made by one or more resources to roll back the

transaction. HeuristicMixedException indicates that heuristic decisions were made by resources to both roll back and

commit

the transaction; some resources decided to roll back while others decided to commit.

18


19/86

--------------------------------------------------------------------

QUESTION NO : 23

QUESTION STATEMENT : The following sequence of method calls occurred on a CMP entity bean instance when itsbusiness methods

method1 and method2 were invoked from the same method of a client which has initiated a transaction.

entityBean.ejbLoad()

entityBean.method1()

entityBean.method2()entityBean.ejbStore()

Which of the following MUST be true about the bean ?

CHOICES :

a) The business methods are configured with the transaction attribute of 'Never'

b) method1 and method2 are in the same transaction scope

c) method1 and method2 are in different transaction scopesd) The business methods are NOT configured with a transaction attribute of 'Requires New'

CORRECT ANSWER : bd

EXPLANATION :

B and D are the correct answers. In container managed persistence, the ejbLoad() method is always called after

the updation of the bean's container managed fields with data from the database. ejbStore() method is called just before

the

container writes the container-managed fields to the database. So typically, ejbLoad is called before a transaction and

ejbStore after a transaction.

If method1 and method2 had belonged to different transactions, ejbStore() would have been

called after the first business method invocation and ejbLoad() before the second business method call. Since that did

not

happen, B is correct and C is not. The methods method1 and method2 are part of the same transaction scope.

D is true because

if the business methods had been configured with 'Requires New' option each of them would have started a new

transaction of

their own. They would not have been part of the same transaction. If a bean method is configured with a transaction

attribute value of 'Never', if the calling client is part of a transaction, the bean throws a RemoteException. Since in the

above case, the bean did not throw any exception even though the client was part of a transaction, A is not true.

--------------------------------------------------------------------

19


20/86

QUESTION NO : 24

QUESTION STATEMENT : What value should be returned by the ejbCreate() of a CMP entity bean ?

CHOICES :

a) null

b) void

c) Primary Key object reference

d) EJBObject reference

e) Bean reference

CORRECT ANSWER : a

EXPLANATION :

Choice A is correct. The ejbCreate() method returns a null value of the primary key type for the bean.In a

CMP bean, the ejbCreate() method is called just prior to writing the beans container managed fields to the database. In

a

CMP bean, ejbCreate() is only used to initialize the fields of the bean instance. So the return value of the ejbCreate()

method for a CMP bean is ignored.In the case of BMP beans, the ejbCreate() methods are responsible for adding the

new entity

to the database. For BMP beans, it should return the primary key of the newly created entity.

--------------------------------------------------------------------

QUESTION NO : 25

QUESTION STATEMENT : An entity bean needs to invoke a method on another bean, passing itself as one of the

parameters. Which

of the following is the best way of achieving this ?

CHOICES :

a) Pass a this reference as the parameter for the method

b) Call the getPrimaryKey() method of the bean, get the EJBObject using the primary key and pass it as the method

parameter

c) Call the getHandle() method of the bean, get the EJBObject using the handle and pass it as the method parameterd) Call the getEJBObject() method on the EJBContext and pass it as the method parameter

CORRECT ANSWER : d

EXPLANATION :

Choice D is Correct. The getEJBObject() method in the EJBContext interface returns a remote reference to the

bean instance's EJB object.The purpose of this method is to provide the bean instance with a reference to itself when it

20


21/86

needs to pass itself as a method argument.The bean is provided with its entity context by the container by calling the

method

setEntityContext() and EntityContext inherits EJBContext. So only one method invocation is required, which makes Dthe best

option.

It is illegal for a bean instance to pass a this reference to another bean, instead it passes it's remote reference

which the bean instance gets from its context.So A is not the right option. The getHandle() method returns the bean

handle

which is a serializable reference to the EJB object. So it allows us to create an EJB object remote reference by calling

it's

getEjbObject() method.But B is not the right option because getting the handle and then the EJBObject results in 2

method

calls.

The getPrimaryKey() returns a reference to the primary key of the bean. While the primary key can be used to get

the EJBObject using a finder method, this is also not an efficient way because it involves 2 method calls and a jndi look

up

by the client. So D is the right answer.

--------------------------------------------------------------------

QUESTION NO : 26

QUESTION STATEMENT : Which of the following is the last method invoked by the container at the end of the

lifecycle of an

entity bean ?

CHOICES :

a) The unsetEntityContext() method

b) The ejbRemove() method

c) The ejbPassivate() method

d) The ejbStore() method

CORRECT ANSWER : a

EXPLANATION :

Choice A is Correct. When an entity bean instance leaves the instance pool to be garbage collected, the

unsetEntityContext() method is invoked by the container to alert the bean instance that it is about to be destroyed. So A

is

21


22/86

the right answer.

B is not correct because ejbRemove() is called when the client application invokes one of the remove()

methods on the bean's ejbObject or ejbHome. With entity beans, invoking a remove method means that the entity's data

is

deleted from the database. Once the ejbRemove() method has finished, the bean instance is moved back to the instance

pool.

The ejbPassivate() method is called when the EJB container passivates the bean ie; the container may disassociate the

bean

instance from an EJB object when it is not busy. So C is also wrong.

ejbStore() method is called just before the container

writes the container-managed fields to the database. So D is also not the right choice.

--------------------------------------------------------------------

QUESTION NO : 27

QUESTION STATEMENT : Which of the following allows an entity bean instance to obtain its own primary key and a

remote

reference to the EJB object ?

CHOICES :

a) EntityContext

b) InitialContextc) Home object

d) EJBContext

CORRECT ANSWER : a

EXPLANATION :

Choice A is Correct. Entity Context is really the bean instance's interface to the container.The EntityContext

allows the bean instance to obtain its own primary key and a remote reference to the EJB object.The setEntityContext()

method

is called prior to the bean instance's entry into the instance pool.

When a bean instance is associated to an EJB object,

its EntityContext changes so that the primary key and EJBObject obtainable through the entityContext match the

EJBObject the

bean instance is currently associated with.After the bean instance is removed from the instance pool and before the bean

22


23/86

instance is garbage collected, the unsetEntityContext is invoked which indicates that the bean instance's EntityContext

is no

longer implemented by the container.

--------------------------------------------------------------------

QUESTION NO : 28

QUESTION STATEMENT : Which of the following is NOT true about session beans ?

CHOICES :

a) Stateless Session beans are neither passivated nor activated.

b) A session bean does not survive server crashes.

c) Stateless session beans do not participate in instance pooling.

d) None of the above

CORRECT ANSWER : c

EXPLANATION :

Choice C is Correct. Passivation is the process of preserving the conversational state of a Stateful Session

Bean when the client is not using it. Activation is the act of restoring the saved state when the client invokes a method

of

the passivated bean. Stateless session beans do not maintain the conversational state between method invocations. So

they do

not need to be passivated and activated.

Instance pooling is a technique used by EJB servers to create multiple copies of

enterprise beans and then distribute them as needed. It reduces the resources needed at a time.Stateless session beans

and

entity beans participate in instance pooling. Stateful session beans do not participate in pooling because they maintain

the

unique state of each client and hence cannot be reused.

--------------------------------------------------------------------

QUESTION NO : 29

QUESTION STATEMENT : Which of the following are true for primary keys of entity beans ?

CHOICES :

a) Primary keys can be primitive types (int, double, long) etc.

23


24/86

b) All fields in the primary key class must be declared public.

c) The primary key must be serializable

d) The primary key class must implement equals() and hashcode() methods.

CORRECT ANSWER : bcd

EXPLANATION :

Choice B, C and D are Correct. Although primary keys can be primitive wrappers, primary keys cannot be

primitive types, because some of the semantics of Ejb interfaces prohibit the use of primitives.

All fields in the primary

key should be declared public so that the container can read the fields at runtime via java reflection.Since the primary

key

would be used in remote invocations,it should be serializable. It should override equals and hashcode methods so that

they

behave properly when invoked.

--------------------------------------------------------------------

QUESTION NO : 30

QUESTION STATEMENT : A client invokes a method on a Stateful Session bean which resulted inNoSuchObjectException. What are

the possible causes ?

CHOICES :

a) The bean had already been removed by the container

b) The bean had timed outc) The ejb server was restarted after the last method call on the bean

d) The bean is being used by another client

e) The code in the bean method caused an error

f) The method parameters passed to the method are invalid

CORRECT ANSWER : abc

EXPLANATION :

A,B and C are the correct answers. NoSuchObjectException is raised by a session bean in three situations. If

the bean does not exist because it was already removed by the container because of a remove method call or some other

reason,

this exception can be thrown when a method is invoked on the bean. Timeout period for a bean is declared at

deployment time.

24


25/86

If a bean times out, the container can remove the bean instance from the method ready state. In this case also, a method

invocation on the bean results in NoSuchObjectException.

Session beans cannot survive server crashes, so if server is

restarted after the bean creation, when the method invocation happens, this exception is thrown. Case D will neverhappen

because the same stateful session bean can never be accessed by more than one client. If the code in the bean method

caused

an error, or if the parameters passed to the method are invalid, application exceptions or RemoteException is thrown.So D,E

and F are not correct.

--------------------------------------------------------------------

QUESTION NO : 31

QUESTION STATEMENT : Which of the following are true about session beans implementing the

SessionSynchronization interface?

CHOICES :

a) A stateless session bean should not implement the SessionSynchronization interface.

b) The session bean's instance variables can be reset to some initial values if the afterCompletion() method indicatesthat

the transaction was rolled back.c) The session bean's instance variables can be reset to some initial values if the beforeCompletion() method indicates

that

the transaction was rolled back.

d) The session bean should write the cached data to the database in the beforeCompletion() methode) The beforeCompletion() method is always invoked, but the afterCompletion() method may not be invoked always.


EXPLANATION :

Choice A, B and D are Correct. A stateless session bean should not implement the SessionSynchronization

interface because they have no conversational state. So each method invocation of a stateless session bean must make

changes

to the database explicitly. With stateful session beans we might not want to make changes to the database till the

transaction is complete ie; avoid database updates if the transaction is rolled back and postpone updates till the

transaction is committed.

25


26/86

The container invokes the beforeCompletion method after the business method has finished, but just

before the transaction commits. The beforeCompletion method is the last opportunity for the session bean to roll back

the

transaction (by calling setRollbackOnly). If it hasn't already updated the database with the values of the instance

variables, the session bean may do so in the beforeCompletion method. The afterCompletion method indicates that the

transaction has completed. It has a single boolean parameter, whose value is true if the transaction was committed and

false

if it was rolled back. If a rollback occurred, the session bean can refresh its instance variables from the database in the

afterCompletion method. So B is true and C is not.

--------------------------------------------------------------------

QUESTION NO : 32QUESTION STATEMENT : A developer is writing a bean which has methods which read and update certain rows from

a database

table. The only requirement is that no other transaction should be able to make changes to the rows which have been

read by

the bean till the current transaction of the bean is completed. Which would be the BEST transaction isolation level for

the

bean ? Assume that the transaction attribute is set to Required.

CHOICES :

a) Read Only

b) Read Uncommitted

c) Read Committedd) Repeatable Read

e) Serializable

CORRECT ANSWER : d

EXPLANATION :

Choice D is Correct. Since the requirement is that the data read by the transaction once cannot be changed by

other transactions till this transaction is completed ,we should choose Repeatable Read as the isolation level. It prevents

dirty reads and non repeatable reads. So you will be able to read each of the rows that you are modifying and then be

able to

update each row knowing that none of the rows are being modified by any of the concurrent transactions. So if you

choose to

26


27/86

reread the data at any time, the rows would have the same data.

If we use Read Committed or Read Uncommitted, another

concurrent transaction may commit data between your reads. There is no isolation level called Read Only. Serializablelevel

is the slowest and most restrictive. So D is a better option than E.

--------------------------------------------------------------------

QUESTION NO : 33

QUESTION STATEMENT : For Container Managed Transactions, whenever a System exception is thrown from within

an EJB which of

the following is handled automatically by the container ?

CHOICES :

a) Rollback the transaction

b) Throw an EJB Exception(or its subtypes) back to the client

c) Throw a RemoteException(or its subtypes) back to the client

d) Dereference and garbage collect the bean instance

e) Lets the client to recover & execute other methods of the same bean.

CORRECT ANSWER : acd

EXPLANATION :

Choice A, C and D are Correct. System exceptions are RuntimeExceptions, RemoteExceptions and their subtypes.

System exceptions always cause a transaction to roll back when thrown from a bean method. The container

automatically rolls

back the transaction,logs the exception, discards the bean instance and throws a RemoteException or its subtypes whena

System Exception is thrown. The bean instance is dereferenced and garbage collected because the container assumes

that the

instance maybe unstable or corrupted. If the client started the transaction, the SystemException is caught by the

container

and is rethrown as TransactionRolledBackException. In other cases, the container catches the exception and rethrows its

as

RemoteException. EJBException is not thrown as a result of this. The client cannot execute other methods of the same

bean.

--------------------------------------------------------------------

27


28/86

QUESTION NO : 34

QUESTION STATEMENT : You have a CMP entity bean which includes an array of complex numbers which you wantto save in the

database in some appropriate format since the database does not support arrays . Which of the following callback

methods

would be appropriate to place the formatting code ?

CHOICES :

a) ejbCreate

b) ejbPostCreate

c) ejbPassivate

d) ejbActivate

e) ejbStore

CORRECT ANSWER : e

EXPLANATION :

E is the correct answer. The ejbStore method is called when the container decides that it is a good time to

write the entity bean's data to the database. In container-managed persistence, the bean's container-managed fields are

automatically synchronized with the database.

In most cases, we will not need the ejbLoad() and ejbStore methods because

persistence in container-managed beans is uncomplicated. We need to provide the ejbLoad and ejbStore callback

methods in

container-managed beans only if more sophisticated logic is needed when synchronizing container-managed fields.

Data intended

for the database can be reformatted or compressed to conserve space; data just retrieved from the database can be usedto

calculate derived values for nonpersistent properties.

If we want to save an array of complex numbers in the database,

since relational databases do not support arrays, so you need to convert the array into some other format. We can use the

ejbStore() method to convert the data into the appropriate format before saving, since it will be called by the container

at

that time. So E is the correct answer. To read the data back in the form of the array, we can use the ejbLoad() function

also. ejbCreate is not the right place for this, because it is called only when a new record is inserted, same applies for

ejbPostCreate. ejbPassivate is called before the bean is passivated ie; the bean instance returns to the pool. It is not

28


29/86

called before saving the persistent state of the bean. ejbActivate is called when the bean moves from the pooled state to

the

ready state. So this is also not the place where we can put the formatting code.

--------------------------------------------------------------------

QUESTION NO : 35

QUESTION STATEMENT : Which of the following methods is used by a client to find out if a particular enterprise

bean is a

session bean or an entity bean ?

CHOICES :

a) isSession() method of EJBMetaData interface

b) isEntity() method of EJBMetaData interface

c) isSessionBean() method of EJBHome interfaced) isEntityBean() method of EJBHome interface

CORRECT ANSWER : a

EXPLANATION :

A is the correct answer. EJBMetaData interface describes the home interface, remote interface and primary key

classes, and also whether a bean is a session bean or an entity bean. This type of metadata is useful for Java tools like

IDEs used for building applications that use deployed enterprise Beans, and for clients using a scripting language to

access

the enterprise Bean. The isSession method in the EJBMetaData interface returns true if the bean is a session bean and

false

if it is an entity bean.

The EJBMetaData object is obtained by calling the function getEJBMetaData of the EJBHome class.

The EJBMetaData is not a remote interface. The class that implements this interface (this class is typically generated by

container tools) must be serializable, and must be a valid RMI/IDL value type.

--------------------------------------------------------------------

QUESTION NO : 36

QUESTION STATEMENT : One of the methods of a stateful session bean which has a transaction attribute of Supports

is invoked

by a non-transactional client. The stateful bean in turn invokes a method of a stateless session bean which has a

transaction

29


30/86

attribute of Mandatory. What will the possible result ?

CHOICES :

a) The container will throw TransactionNotSupported Exceptionb) The container will throw TransactionRequiredException

c) The container will start a new transaction for the execution of the method of the stateless beand) The container will start a new transaction for the execution of the method of the stateful bean

e) The container will execute all the methods successfully without any transaction

CORRECT ANSWER : b

EXPLANATION :

B is the correct choice. The container will throw a TransactionRequiredException in this case. 'Supports'

transactional attribute means that the bean method will be included in the transaction scope if it is invoked within a

transaction, else it will be executed without a transaction scope.

When the stateful session bean which has a transaction

attribute of 'Supports' is invoked by a non-transactional client, it will also execute without a transaction. So when it

invokes a method of the stateless bean it will not be executing as part of a transaction. But for the second bean, the

transaction attribute is set to Mandatory. This attribute means that the bean method must always be part of the

transaction

scope of the calling client. If the calling client is not part of a transaction, the invocation will fail, throwing a

TransactionRequiredException. So B is the choice in this case.

--------------------------------------------------------------------

QUESTION NO : 37QUESTION STATEMENT : Which of the following EJB transaction isolation attributes ensure that dirty and non-

repeatable reads

do not occur?

CHOICES :

a) Serializableb) Read Committed

c) Read Uncommittedd) Repeatable Read

CORRECT ANSWER : ad

EXPLANATION :

A and D are the correct choices. The isolation level measures concurrent transactions' capacity to view data

30


31/86

that have been updated, but not yet committed, by another transaction. If other transactions were allowed to read data

that

are as-yet uncommitted, those transactions could end up with inconsistent data were the transaction to roll back, or endup

waiting unnecessarily were the transaction to commit successfully.

The isolation attribute values are Read Uncommitted, Read

Committed, Repeatable Read and Serializable. Read Uncommitted: Data that have been updated but not yet committed

by a

transaction may be read by other transactions. These are called dirty reads.Read Committed: Only data that have been

committed by a transaction can be read by other transactions. Repeatable Read: Only data that have been committed by

a

transaction can be read by other transactions, and multiple reads will yield the same result as long as the data have not

been committed. Serializable: This, the highest possible isolation level, ensures a transaction's exclusive read-write

access

to data. It includes the conditions of ReadCommitted and RepeatableRead and stipulates that all transactions run serially

to

achieve maximum data integrity. This yields the slowest performance and least concurrency. Thus dirty reads and

non-repeatable reads can be avoided by using the trasaction isolation attributes of Serializable or Repeatable Read.So A

and

D are correct.

--------------------------------------------------------------------

QUESTION NO : 38

QUESTION STATEMENT : You are adding a Customer EJB to a Telecom Enterprise application. The Operator role

should be allowed

to create a customer. Which of the following method permission settings will enable this ?

CHOICES :

a) Create a Method Permission mapping the Operator role to all the methods in the Customer EJB

b) Create a Method Permission mapping the Operator role to all the home methods of the Customer EJBc) Create a Method Permission mapping the Operator role to the ejbCreate method in the Customer EJB

d) Create a Method Permission mapping the Operator role to the create method in the Customer EJB home

CORRECT ANSWER : bd

EXPLANATION :

31


32/86

B and D are the correct choices. A method permission is a mapping between one or more security roles and one

or more methods that a member of the role can invoke. To create an instance of the Customer bean, the method to be

called by

the client is the create method in the home object of the Customer EJB.

Method permission can be set to all the bean

methods, a particular bean method, all the home methods or a particular home method. So in this case to give the

operator

role the permission to call the create method in the EJB home, we can either set the Method Permission mapping theoperator

role to all the home methods of the Customer bean or only to the create method in the home of Customer EJB.Setting

permission

to all the bean methods or the ejbCreate method of the bean will not help.So A and C are wrong answers.

--------------------------------------------------------------------

QUESTION NO : 39

QUESTION STATEMENT : A JDBC data source resource for a DB2 database has been configured in the deployment

descriptor of a

bean with the logical name of 'mysource'. Which of the following paths would be used to access it from the bean using

JNDI

look up ?

CHOICES :

a) java:comp/env/mysource

b) java:comp/env/jdbc/mysource

c) java:comp/env/db2/jdbc/mysource

d) java:comp/env/jdbc/db2/mysource

CORRECT ANSWER : a

EXPLANATION :

A is the correct answer. All deployed beans,environment properties and external resources like data sources

are mapped to a set of JNDI entries which exist in a namespace called the environment naming context(ENC) or defaultJNDI

context. When developing a bean, the bean developer can identify the types of resources and enterprise beans that will

be

referenced in the bean and bind them to the ENC.

Using java:comp/env namespace within the enterprise bean lets the bean

32


33/86

locate external information without prior knowledge of how the external information is named and organized in the

target

operational environment. Using this naming context will not tie up a bean with the JNDI name of a resource that is

known only

at the time of deployment. The default context exists in the namespace called "java:comp/env" and its subdirectories.When

the bean is deployed all the beans and resources it uses are mapped into this directory. Thus in this case the bean can

look

up the data source using its logical name "mysource" by specifying java:comp/env/mysource.

Though this works, it is

advisable to keep a subcontext which describes the resource type. ( eg: ejb/ for beans, jdbc/ for JDBC DataSource

factory

and so on). So if the resource is given a logical name as jdbc/mysource, to look up the resource, you say

java:comp/env/jdbc/mysource

--------------------------------------------------------------------

QUESTION NO : 40

QUESTION STATEMENT : The env-ref element in the deployment descriptor of an enterprise bean is used to define

CHOICES :

a) references to other beansb) references to external resources

c) references to environment entries

d) references to security roles

CORRECT ANSWER : a

EXPLANATION :

A is the correct answer. The env-ref element in the deployment descriptor is used to define references to

other beans within the JNDI ENC. This makes it much easier for beans to reference other beans, they can use JNDI to

look up a

reference to the home interface for any beans they are interested in. So A is right. For external resources, mapping is

performed by the resource-ref element. To define environmental entries, env-entry element is used.The security-role-ref

element is used to define the secuirity roles that are used by a bean.

--------------------------------------------------------------------

33


34/86

QUESTION NO : 41

QUESTION STATEMENT : Which of the following are valid for bean managed transactions ?

CHOICES :

a) A Stateful Session bean must start and end a transaction within one method, since it serves multiple clients.

b) A Stateful Session bean's transactions can span multiple methods, since it serves only one client.

c) A Stateless Session bean's transactions must start and end in the same method, since it serves multiple clients.

d) A Stateless Session bean's transactions can span multiple methods, since it serves only one client.

CORRECT ANSWER : bc

EXPLANATION :

B and C are the correct answers. Bean managed transactions are explicit transactions managed by the bean, for

which the bean makes use the UserTransaction interface. In EJB, implicit transaction management is provided on the

bean

method level, so transactions execute within the scope of the method. But rarely explicit control on transactions is

required

which is achieved by calling the methods of the UserTransaction interface.

With stateless session beans, transactions that

are managed using the UserTransaction must be started and completed within the same method. This is required

because

stateless session bean instances are shared across multiple clients. With stateful session beans, a transaction can begin in

one method and be committed in another because a stateful bean is not used by more than one client.Thus a statefulbean

instance can associate itself with a transaction across different client-invoked methods.

--------------------------------------------------------------------

QUESTION NO : 42

QUESTION STATEMENT : Which of the following enterprise beans allow multithreaded access ?

CHOICES :

a) Stateful Session Bean

b) Reentrant Entity Beanc) Activated Stateless Session Bean

d) Concurrent Stateless Session Bean

e) BMP Entity Bean

CORRECT ANSWER : b

34


35/86

EXPLANATION :

B is the right answer. Reentrance is when a thread of control attempts to reenter a bean instance.In EJB, bean

instances are non-reentrant by default, that means loopbacks are not allowed. Session beans can never be reentrant and

they

throw a RemoteException if a loopback is attempted. The same is true of a non-reentrant entity bean. Entity beans canbe

configured in the deployment descriptor to allow reentrance at deployment time. If you permit reentrance you also

permit

multithreaded access to the bean instance.

Multithreaded access to a bean instance can result in corrupted data because

threads interfere with each other. So declaring an entity bean as reentrant is discouraged in the EJB specifications,

unless

you have a very good reason of doing so.A, C and D are wrong because session beans cannot be reentrant in any case. E

is

wrong because entity beans are not reentrant unless they are declared so.

--------------------------------------------------------------------

QUESTION NO : 43

QUESTION STATEMENT : Which of the following are valid differences between ejbCreate() and ejbPostCreate()methods of a CMP

entity bean ?

CHOICES :

a) The bean identity is not available to the bean during the call to ejbCreate(), but is available in the ejbPostCreate()

method.

b) The caller's identity is not available to the bean during the call to ejbCreate(), but it is available in the

ejbPostCreate() method

c) ejbCreate() returns null while ejbPostCreate() returns void

d) ejbCreate() should have the same parameters as the calling create() method, but ejbPostCreate() does not take the

same

parameters.

e) ejbCreate() is called before the insertion of a record into the database, while ejbPostCreate() is called after the

record insertion.

CORRECT ANSWER : ace

EXPLANATION :

35


36/86

A,C and E are the correct answers. In a CMP bean, the ejbCreate() method is called just prior to writing the

bean's container managed fields to the database. Values passed in to the ejbCreate() method should be used to initialize

the

fields of the bean instance. Once the ejbCreate() method completes, the new record with these values are written to the

database tables. The EntityContext maintained by the bean instance does not provide it with proper identity till the

ejbCreate() method has completed. So inside the ejbCreate() method, the bean instance doesn't have access to it's

primary key

or EJBObject. So A is correct.

B is not correct because EntityContext methods like getCallerPrincipal() and

isCallerInRole() can be called from ejbCreate() since user details and environment properties are available at this time.

So

B is not correct. C is true because the return value of ejbCreate() is null while ejbPostCreate() does not return anything.

D

is not correct because ejbCreate() and ejbPostCreate() both take the same set of parameters. E is also correct,ejbCreate()

is called prior to insertion of records while ejbPostCreate() is called after that.

--------------------------------------------------------------------

QUESTION NO : 44

QUESTION STATEMENT : Which of the following events take place first after the call of ejbCreate() method on a

CMP entity bean

?

CHOICES :

a) Insertion of a record into the database

b) Calling ejbPostCreate() method

c) EJB object stub returned to the client

d) Associating the EJB Object with the bean instance

CORRECT ANSWER : a

EXPLANATION :

A is the correct choice. In a container-managed bean, the ejbCreate() method is called just prior to writing

the bean's container-managed fields to the database. Values passed in to the ejbCreate() method should be used to

initialize

the fields of the bean instance. Once the ejbCreate() method completes, a new record, based on the container-managed

fields,

36


37/86

is written to the database. Once the record has been inserted into the database, the bean instance is ready to be assigned

to

an EJB object.

Once the bean is assigned to an EJBobject, the bean's identity is available. This is when the ejbPostCreate()

method is invoked. Finally, when the ejbPostCreate() processing is complete, the bean is ready to service client

requests.

The EJB object stub is created and returned to client application, which will use it to invoke business methods on the

enterprise bean. So the order of execution in this case would be A,D,B and C.A is the correct answer because the record

insertion is the first event to take place after ejbCreate().

--------------------------------------------------------------------

QUESTION NO : 45QUESTION STATEMENT : Which of the following features should be avoided in the implementation of Enterprise

Java Beans ?

CHOICES :

a) Declaring static, final fields

b) Loading classes

c) Using file access

d) Loading native libraries

e) thread creation and managementf) Listen to or accepting connections on a socket

CORRECT ANSWER : cdef

EXPLANATION :

Choices C,D,E and F are the correct answers. EJB component providers/developers should be aware of and

strictly follow certain restrictions in the interest of developing reliable and portable EJB components. Nonfinal static

class fields are disallowed because enterprise bean instances will behave differently depending on whether or not they

are

distributed.

It is acceptable practice to use static class fields if those fields are marked as final. Since final fields

cannot be updated, instances of the enterprise bean can be distributed by the container without concern for those fields'

values becoming unsynchronized. So A is incorrect.

Loading classes are allowed, so B is incorrect.C is correct- Enterprise

beans aren't allowed to access files primarily because files are not transactional resources. Allowing EJBs to access files

or directories in the filesystem, or to use file descriptors, would compromise component distributability, and would be a

37


38/86

security hazard.

D is correct because EJBs are not allowed to load native libraries since it affects portability,stability

and security. E is correct- EJBs are not encouraged to use threads because allowing enterprise bean instances to create

and

manage threads would interfere with the container's ability to control its components' lifecycle.F is correct, EJBs are not

allowed to listen to or accept socket connections. If an enterprise bean is listening on a socket, it can't be passivated -

it must always be available. Enterprise beans can be network socket clients, and so they can use other network resources

(including other enterprise bean servers) to do their jobs.

--------------------------------------------------------------------

QUESTION NO : 46

QUESTION STATEMENT : A stateful session bean's conversational state has the following types of variables. Whichof the them

do NOT get restored after passivation and activation of the bean ?

CHOICES :

a) SessionContext

b) EJBContextc) transient variables

d) Handle

e) EJBHomef) EJBObject

CORRECT ANSWER : adef

EXPLANATION :

Choices A,D,E and F are correct. When a stateful bean is passivated, the conversational state of the bean is

written to the secondary storage associated with the EJBObject. When the bean is activated, the saved state is restored.

A

bean's conversational state should consist of only primitive values, objects that are serializable and these special types-

SessionContext, EJBHome, EJBObject, UserTransaction and Context (only when it references the JNDI ENC). So A,E

and F are

correct.

D is correct because Handle is a serializable reference to the EJBObject.Transient variables will not be preserved

when the bean is passivated.So C is not the right option. B is not correct because EJBContext does not implement

38


39/86

Serializable. So it will not be preserved during bean passivation.

--------------------------------------------------------------------

QUESTION NO : 47QUESTION STATEMENT : Which method can be called on the EJBContext to obtain information about the user

making the EJB method

invocation ?

CHOICES :

a) getCallerPrincipal()

b) getPrincipal()

c) getRemoteUser()

d) getUserPrincipal()

CORRECT ANSWER : a

EXPLANATION :Choice A is Correct. The servlet and EJB specifications provide different mechanisms to programmatically

obtain identity information about the user invoking a method on a secure servlet or an EJB. getCallerPrincipal() is the

method in the EJBContext interface used by a bean to track the identity of the client accessing the bean.

To get the name

of the client, we have to only invoke getName() method on the Principal object returned by getCallerPrincipal()

method. B is

not correct because there is no such method called getPrincipal(). C and D are applicable only to servlets. Invoking the

getRemoteUser method on the HttpRequestObject returns the name of the user who is invoking the servlet. The

getUserPrincipal

method on the HttpRequestObject returns the Principal object corresponding to the user who is invoking the servlet.

--------------------------------------------------------------------

QUESTION NO : 48

QUESTION STATEMENT : A developer is creating a Java tool which will have wizards for interacting with anenterprise bean from

a client's perspective. He uses EJBMetaData interface for getting details about the bean. Which of the following

information

is NOT directly obtained using this interface ?

39


40/86

CHOICES :

a) Whether the EJB is a session or an entity bean

b) The home interface class of the EJB

c) The primary key class of the EJBd) The remote interface class of the EJB

e) The bean class of the EJB

CORRECT ANSWER : e

EXPLANATION :

Choice E is Correct. The javax.ejb.EJBMetaData interface has methods to get the home interface, remote

interface and primary key classes of the EJB. It also has a method to get the information about the type of the bean -

whether it's a session bean or an entity bean. There is no way to get the bean class using EJBMetaData because the bean

class

is not part of the client API and hence does not belong to the metadata.

The getEJBMetaData() method of the EJBHome

interface returns an instance of EJBMetaData. A tool can have wizards which use the class definitions provided by the

EJBMetaData with Java reflection to interact with a bean. A class which implements EJBMetaData should be

Serializable, which

allows these tools to save the EJBMetaData object for later use.

--------------------------------------------------------------------

QUESTION NO : 49

QUESTION STATEMENT : When a BMP entity bean instance is activated from the pooled state to the ready state

which of the

following does NOT happen ?

CHOICES :

a) The bean leaves the instance pool to be assigned to an EJB object

b) The non-persistent fields of the bean are deserialized from secondary storage and assigned.

c) Container invokes ejbLoad() to notify the bean that its persistent fields have been synchronizedd) Non-persistent fields contain arbitrary values (dirty values) and need to be reinitialized in the ejbActivate() method.

e) Container invokes setEntityContext() method on the bean.

CORRECT ANSWER : be

EXPLANATION :

Choice B and E are correct. When an entity bean is activated, the bean instance leaves the instance pool to be

40


41/86

assigned to an EJB object. Once assigned to an EJBObject, the ejbActivate() method is called . For entity beans, the

non-persistent fields are not serialized to secondary storage at the time of passivation as done for Stateful Session

Beans.

So at the time of activation, they are not deserialized. These fields contain arbitrary values(dirty values) and must be

reinitialized in the ejbActivate() method.

--------------------------------------------------------------------

QUESTION NO : 50

QUESTION STATEMENT : Which of the following is NOT true about defining methods in a CMP entity bean class ?

CHOICES :

a) The bean class's business methods should throw javax.ejb.RemoteException

b) For every create() method defined in the entity bean's home interface, there must be a correspondingejbPostCreate()

method in the bean instance class.

c) For every create() method defined in the entity bean's home interface, there must be a corresponding ejbCreate()

method

in the bean instance class.

d) The ejbPostCreate() method always returns void.

CORRECT ANSWER : a

EXPLANATION :Choice A is Correct. The bean class's business methods are not required to throw RemoteException. This is

because these methods are not actually invoked remotely, they are invoked by the EJB object. If a communication

failure

occurs, the container will throw the RemoteException for the bean automatically.For every create() method defined in

the home

interface, there should be matching ejbCreate() and ejbPostCreate() methods defined in the bean class.The

ejbPostCreate()

method must have the same parameters as the corresponding Create() method, but returns void.

--------------------------------------------------------------------

QUESTION NO : 51

QUESTION STATEMENT : Which of the following transaction attributes can be specified only for session beans and

also cannot be

41


42/86

specified for individual methods ?

CHOICES :

a) Bean Managed

b) Mandatoryc) Supports

d) Not Supported

CORRECT ANSWER : a

EXPLANATION :

Choice A is correct. The transaction attribute defines the transactional manner in which the container invokes

enterprise bean methods. If the transaction attribute is set to BeanManaged, it notifies the container that the bean class

directly handles transaction demarcation. This attribute value can be specified only for session beans and it cannot be

specified for individual bean methods.

If the transaction attribute is set to Mandatory, it directs the container to always

invoke the bean method within the transaction context associated with the client. If the transaction attribute is set to

Supports, it directs the container to invoke the bean method within a transaction context if the client invokes the bean

method within a transaction. If the transaction attribute is set to NotSupported, it directs the container to invoke bean

methods without a transaction context.

--------------------------------------------------------------------

QUESTION NO : 52QUESTION STATEMENT : Which of the following statements about EJBs is NOT true ?

CHOICES :

a) A single entity bean instance can be shared by multiple clients.

b) Session beans cannot be reentrant and they throw a RemoteException if loopback is attempted.

c) A stateful bean instance is swapped among many EJB objects, it is not possible to predict which instance will service

a

method call.d) Session beans do not survive server crashes

CORRECT ANSWER : c

EXPLANATION :

Choice C is Correct because it is not true. Entity beans represent data in the database that is shared and

42


43/86

needs to be accessed concurrently. So many clients are allowed to use the same entity bean instance simultaneously.

Reentrance is when a thread of control attempts to reenter a bean instance. In EJB, bean instances are reentrant by

default

which means that loopbacks are not allowed. Entity beans can be configured in the deployment descriptor to allowreentrance

at deployment time.

Session beans can never be reentrant, and they throw a RemoteException if a loopback is attempted.

Option C is true for a stateless session bean, not for a stateful bean. Since a stateless session bean does not store a

clients state, it does not matter which bean instance serves a particular client. But in the case of Stateful Beans, it is

not possible to swap the same instance between different clients since a particular instance serves only one client. Since

session beans are not persistent, they do not survive server crashes.

--------------------------------------------------------------------

QUESTION NO : 53

QUESTION STATEMENT : Which of the following is true about comparing beans for identity ?

CHOICES :

a) The EJBObject.isIdentical method returns true if two EJB object references represent the same bean, even if the EJB

object stubs are different object instances.b) For stateful session beans, if 2 EJB objects refer to the same type of bean, they are always considered identical.

c) Even if two entity EJB objects have the same home and same primary key, they may not be identical.

CORRECT ANSWER : a

EXPLANATION :

Choice A is Correct. An EJB object is a distributed object stub and therefore contains a lot of networking and

other state. As a result, references to 2 EJB objects maybe unequal, even if they both represent the same unique bean.

The

EJBObject.isIdentical method returns true if two EJB object references represent the same bean, even if the EJB object

stubs

are different object instances.Since stateless beans do not retain the conversational state, they are considered identical if

they are of the same type. But stateful session beans are not considered to be identical just because they are of the same

type since they maintain the conversational state of the clients. For entiy beans, if they have the same home and primary

43


44/86

key, they are considered to be identical.

--------------------------------------------------------------------

QUESTION NO : 54

QUESTION STATEMENT : The Passivation mechanism of stateful session bean is different from that of entity bean.

True/False?

CHOICES :

a) True

b) False

CORRECT ANSWER : a

EXPLANATION :

Yes, Passivation in stateful session beans is different than for entity beans. In stateful beans, passivation

means the bean's conversational-state is written to a secondary storage (often disk) and the instance is removed frommemory.

The client's reference to the bean is not affected by passivation, it remains alive and usable while the bean is passivated.

When the client invokes a method on a bean that is passivated, the container will activate the bean by instantiating a

new

instance and populating its conversational-state with the state written to secondary s

7283499 Ejb Questions

Documents

Transcript of 7283499 Ejb Questions