Welcome to Scribd, the world's digital library. Read, publish, and share books and documents. See more
Standard view
Full view
of .
Look up keyword
Like this
0 of .
Results for:
No results containing your search query
P. 1
EJB - 200 Bullet Points from the book” Head first EJB”

EJB - 200 Bullet Points from the book” Head first EJB”

Ratings: (0)|Views: 5|Likes:
Published by api-19965331

More info:

Published by: api-19965331 on Dec 03, 2009
Copyright:Attribution Non-commercial


Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less





\u4e2d\u56fdJava\u5f00\u53d1\u7f51 - 200 Bullet Points from the book\u201d Head first EJB\u201d http://www.cjsdn.net/post/view?bid=4&id=92484&sty=1&tpg=1...
1 of 5
5/15/2006 3:34 AM
\u4e2d\u56fdJava \u5f00\u53d1
\u6ce8\u518c| \u767b\u5f55| \u5e2e\u52a9| \u641c\u7d22| \u6392\u884c\u699c| \u53d1\u5e16\u7edf\u8ba1
\u00bb\u4e2d\u56fdJava \u5f00\u53d1\u7f51 \u00bbJava Certification \u00bb SCB CD
200 Bullet Points from the book\u201d Head first EJB\u201d
j amesfeng2
\u53d1\u8d34: 41
\u79ef\u5206: 10
\u4e8e 2004-05-17 10:52
As I \u2019m progressing on SCBCD I abstract 200 Bullet Points from the book\u201d Head first EJB\u201d.
Hopeful it will benefit to your guys.
1. EJB is a component-based development model
2. components are reusable chunks of functionality you can modify for different applications
without touching java source code
3. One benefit of EJB is WODA-White-One, Deploy-Where, you can deploy your EJB2.0
components to any app server that EJB2.0-compliant.
4. WODA means you have to learn only one, standard API rather than proprietary
vendor-specific API s.
5. EJB architecture uses an EJBObject to intercept client calls to a bean, This give
Server/ Contain a chance to step in and add services
6. EJB services include transaction, security, resources management, networking and
persist ence.
7. Bean become in three flavors: Entity, Session and Message-driven.
8. Entity beans represent a uniquely identifiable thing in a persistent store; usually means a row
in database table.
9. Message-driven beans are JMS messaging service consumers.
10. Session beans can be \u2026 everything else.
11. Session beans can be stateful or stateless.
12. Stateful beans can remember \u201cconversional state\u201d with a client while stateless beans
13. EJB uses Java RMI so that your beans can be accessed by remote clients
14. A remote client, in this context, is an object running in a different JVM, which also means a
different heap.

15. A Remote object stays in its own heap, while client invoke methods on the Remote object\u2019s
proxy, calling a stub.
16. The stub object handles all the low-level networking details in communicating with the

Remote object.

17. When a client wants to call a method in Remote Object, the client calls the same method in
the stub. The stub lives in the same heap as the client.
18. To the client, a remote method call is identical to a local method call, except a remote

method can throw a RemoteException( a checked exception)
19. The stub packages up the method arguments and sends information about the call to a
skeleton on the server. The skeleton object itself is optional, but skeleton\u2019s work must be done
by something on the server, we don\u2019t have to care who- or what \u2013 is actually doing the
skeleton\u2019s work.

20. Arguments and return values must be one of the following: a primitive, a Serializable object, an array or collection off primitive or Serializable objects, or Remote object. I f the value isn\u2019t one of these, you will get a runtime exception.

21. I f an object is passed as an argument or return value, the object is sent as a serialized
copy, and then deserialized on the Remote object\u2019s local heap.
22. I f a remote object is passed as an argument or return value, the object\u2019s stub is sent
23. Beans that are exposed to remote clients have two Remote interface one for the EJBHome
and one for the EJBOjbect.
24. A Remote interface must extend (directly or indirectly) java.rmi.Remote, and all methods
must declare a java.rmi.RemoteException.
25. I n EJB, the interface that extends EJBOjbect is called the Remote Component interface. I t is
where the business methods are declared.
26. The client never calls methods on the bean itself because the bean is NOT a Remote object.
27. The container implements the Remote Component interface by building a class that
\u4e2d\u56fdJava\u5f00\u53d1\u7f51 - 200 Bullet Points from the book\u201d Head first EJB\u201d http://www.cjsdn.net/post/view?bid=4&id=92484&sty=1&tpg=1...
2 of 5
5/15/2006 3:34 AM
implements it. This class is used to make the EJBOjbect for the bean.(The Bean\u2019s bodyguard).
28. The container also creates a stub to the EJBObject.
29. you create the Remote Component I nterface by writing an interface that extends
javax.ejb.EJBObject (an interface that extends java.rmi.Remote)
30. You also create the bean class where the actual business methods are implemented (despite
the fact that the bean class technically doesn\u2019t implement the Remote Component interface)

31. The Home is the factory for the bean. I ts main job is to hand the client a reference to the bean. But remember, the client can never truly get a reference to the bean \u2013 the best the client can do is to get a reference to the bean\u2019s EJBObject.

32. You create the Home interface by writing an interface that extends javax.ejb.EJBHome( and
interface that extends java.rmi.Remote)
33. The container is responsible for implementing the Home interface by building a class that
implements it, and the container also generates the stub for the Home.

34. There is only one Home per deployed bean. For example, a ShoppingCart bean would have a
single ShoppingCart Home, regardless of how many ShoppingCart beans have been created.
35. The methods of the bean are exposed to the client through the component interface.
36. The client can\u2019t directly get a reference to the bean; the client must go through the bean\u2019s
EJBObject, which implement the component interface.

37. The client gets a reference to the bean\u2019s EJBOjbect from the bean\u2019s home.
38. To get the bean\u2019s home, the client does a lookup on JNDI , using the logical name under
which the bean was deployed.

39. To do a JNDI lookup, the client must first get an initialContext, which is the entry point into

the server\u2019s JNDI \u201c virtual directory tree\u201d
40. For a Remote home interface, the stub returned from JNDI must be both cast and narrow.
41. Narrow is \u201cexotic casting\u201d needed for the stub objects that come from a method that does
not return the stub\u2019s client interface. Since the JNDI lookup return type object, the object
returned from the lookup must be narrowed to the bean\u2019s Home interface, and then cast to the

bean\u2019s home interface.

42. Narrow is required for I I OP stub(I I OP is wire protocol for CORBA), because what\u2019s return from the lookup might not be capable of implementing multiple interface, and thus would know only about the methods in type Objects. Narrowing returns an object that implements the home interface.

43. The home interface extends EJBHome, which have four additional methods the client can
see: getEJBMetadata, getHomeHandle, remove(Handle h), remove(Object primarykey), The
remove(Object primarykey) must not be called on Session bean.

44. You expose your bean\u2019s business methods in the component interface.
45. Remote component interface must extend javax.ejb.EJBObject.
46. The client get a reference to the bean\u2019s EJBOjbect by calling a method on the bean\u2019s home

47. Reference to both stateless bean and stateful bean are retrieved from the home\u2019s create()
48. From the EJBObject interface, the client sees five additional methods: getEJBHome,
getHandle, remove, isI dentical and getPrimaryKey
49. Only entity bean clients are allowed to call getPrimaryKey() on the bean\u2019s component
interface. SessionBean clients will get a RemoteException.
50. The getEJBHome() method returns a reference to the bean\u2019s home interface, so that client
doesn\u2019t have to go through a JNDI lookup, if they want to make more beans of that type.
51. The getHandle() method returns a Serializable object that can be used later to reestablish
contact with the server, and get back the stub to the component interface that the client used to
get the handle.
52. The handle has one method, getEjbOjbect(), that returns the Remote stub as type
EJBObject. That means the stub must be cast and narrowed, just as you must do with the home
stub that you get from a JNDI lookup.

53. The isI dentical() method is kind of like doing an equals() method on the server. I t returns
true for two different stateless beans from the same home, false for two different stateful beans
from the same home, and true for references to entities bean with the same primary key.

54. You can expose your bean to local client using a local client view.
55. Local component interfaces must extend javax.ejb.EJBLocalObject. Local home interfaces
must extend javax.ejb.EJBLocalHome.

56. Methods in local client interfaces do not declare RemoteException.
57. Some of interface methods exposed to Remote clients are not exposed to local clients.
58. Local client cannot get handles, since handles are used to re-establish a connection to the

Remote object.
59. EJBMetadata is not used with local clients, since a local client can use reflection to

interrogate the EJB object and Home object.
60. Local home interface have only one remove() method \u2013 the one that takes a primarykey .
the remove() that takes a Handle doesn\u2019t exist in the local home interface, since Handle aren\u2019t

used with a local client view.
61. Because of the only remove() in the local home interface requires a primary key argument,
local session bean client can\u2019t remove a bean using the bean\u2019s home; they can call remove() only
\u4e2d\u56fdJava\u5f00\u53d1\u7f51 - 200 Bullet Points from the book\u201d Head first EJB\u201d http://www.cjsdn.net/post/view?bid=4&id=92484&sty=1&tpg=1...
3 of 5
5/15/2006 3:34 AM
on the bean\u2019s component interface.
62. EJBLocalHome has only one method: remove() that takes a primary key, because the
getHomeHandle(), getEJBMetedate(), and remove(Handle) methods that are in EJBHome don\u2019t
apply a local view.
63. The only method in EJBObject that is not also in EJBLocalObject is getHandle().

64. Arguments and return values are passed by value when using a local client view. I n other words, they\u2019re passed in the normal java way(object passed by a copy of reference, primitives passed by a copy of the value).

65. Local client donot need to narrow the Home reference because it\u2019s a normal java reference,
not a stub to a remote object.
66. Local client do not need to catch RemoteExceptions, since local interface methods don\u2019t
declare RemoteException.
67. Container callbacks indicate key milestones in a bean\u2019s life.
68. As a Bean Provider, you\u2019re responsible for implementing the container callbacks in your

69. Container callbacks comes from two places: the SessionBean interface, and the home
interface. The compiler force you to implement the SessionBean interface, but the callbacks
related to the home are your responsibility, and the compiler won\u2019t know, since your bean class

doesn\u2019t implement your home interface.
70. A stateful session bean can be one of three states: does not exist (yes, that\u2019s state),
method- ready, and passivated.

71. When a bean transitions from does not exist to method \u2013 ready, its constructor is called,
followed by setSessionContext(), and finally the bean\u2019s ejbCreate().
72. A bean instance has specific Bean things that it can do, but none are available during the

bean\u2019s constructor, because at that point it is an object but not yet a full bean. I t doesn\u2019t yet
have its beanness.
73. Some of Bean Things a bean can do include: get a reference to its home or EJB object,
learn or affect the status of the transaction, get security information about the client, and access
a resource such as a database.
74. When a stateful bean is passivated, it\u2019s put into secondary storage, possible through
serialization. You must be sure, by the end of your ejbPassivated() method, that your instance
variables are ready for passivation.

75. The Container calls ejbRemove() method on a bean when the client calls remove(), for a stateful bean, or when the container want to reduce the size of pool, for stateless beans. I f a passivate bean time out, the Container will kill the bean without invoking ejbRemove().

76. A bean can also miss an ejbRemove() call if there\u2019s a container crash or the bean throws a
runtime exception.
77. An entity is real thing that exists outside of EJB, in a persistent store, and an entity bean is
an OO representation or realization of an entity.
78. Clients sue entity bean to do database operations, in an OO way. Operation include creating
new entities, deleting entities, updating entity state, and searching for/on entities.
79. An entity bean Remote component interface extends EJBOjbect. There\u2019s not a separate

interface for session beans and entity beans. That means that the client will see all of the
methods in your component interface, plus the five additional methods from EJBObject.
80. Entity Bean Component interface usually contain getters and setters for field values that

correspond to columns in a database table, such as getLastName(), getHomePhone(),
setFirstName(), etc.
81. Entity Bean Component interface methods are usually meant to be run by a specific,
uniquely-identifiable entity. For example, calling getLastName() on the entity with primary key
# 42, returns the last name of the entity in the database with the primary key # 42, James.
82. The rules for how you write an entity bean Remote component interface are the same as
the rules ofr session beans, include: extend EJBObject, declare RemoteExceptions on all
methods, use only RMI -I I OP types ofr arguments and return values, don\u2019t begin method names
with the prefix \u201dejb\u201d etc.
83. An entity bean home interface is substantially different from that of a session bean, because

entity beans are typically found rather than created. I n other words, the client is more likely to try to access an existing entity as opposed to making a new entity( which means a new row in the database).

84. I n an entity home, a create() methodis not required ( since create() method in entity beans are for inserting new entities into the database, and you\u2019re not required to allow your client to do that)

85. Entity bean home interface can have single \u2013 row or multi-row finder methods. Both create
and finder methods return the component interface of a bean, althought multi-entity finders
return a Collection of component interface reference.
86. Every entity bean home is required to have at lease one method \u2013 the findByPrimaryKey()

method tha searches for a particular entity and returns its component interface( i.e. a reference
to that entity\u2019s EJB Object), or throws an exception.
87. Multple-entity finders do not throw an exception if not matching entities are found. They
simply return an empty collection.

You're Reading a Free Preview

/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->