Explore topic-wise InterviewSolutions in Current Affairs.

We can USE the Java 2 PLATFORM, Enterprise EDITION Client ACCESS Services (J2EETM CAS) COM Bridge 1.0, CURRENTLY downloadable from Sun.

We can use the Java 2 Platform, Enterprise Edition Client Access Services (J2EETM CAS) COM Bridge 1.0, currently downloadable from Sun.

Following are some of the main features SUPPORTED in EJB 2.0:
1. Integration of EJB with JMS,
2. MESSAGE Driven Beans,
3. Implement additional Business methods in HOME INTERFACE which are not specific for bean instance, EJB QL.

Following are some of the main features supported in EJB 2.0:
1. Integration of EJB with JMS,
2. Message Driven Beans,
3. Implement additional Business methods in Home interface which are not specific for bean instance, EJB QL.

It MUST be abstract CLASS. The CONTAINER extends it and implements METHODS which are required for managing the relationships.

It must be abstract class. The container extends it and implements methods which are required for managing the relationships.

A server group is a TEMPLATE of an Application Server(and its contents) i.e, it is a logical representation of the application server. It has the same structure and attributes as the REAL Application Server, but it is not associated with any NODE, and does not CORRESPOND to any real server PROCESS running on any node.

A server group is a template of an Application Server(and its contents) i.e, it is a logical representation of the application server. It has the same structure and attributes as the real Application Server, but it is not associated with any node, and does not correspond to any real server process running on any node.

There are two types of scaling: Vertical Scaling and HORIZONTAL Scaling.

Vertical Scaling - When multiple SERVER clones of an application server are defined on the same PHYSICAL m/c, it is called Vertical Scaling. The objective is to use the processing power of that m/c more efficiently.

Horizontal Scaling - When Clones of an application server are defined on multiple physical m/c, it is called Horizontal Scaling. The objective is to use more than one LESS powerful m/c more efficiently.

There are two types of scaling: Vertical Scaling and Horizontal Scaling.

Vertical Scaling - When multiple server clones of an application server are defined on the same physical m/c, it is called Vertical Scaling. The objective is to use the processing power of that m/c more efficiently.

Horizontal Scaling - When Clones of an application server are defined on multiple physical m/c, it is called Horizontal Scaling. The objective is to use more than one less powerful m/c more efficiently.

The COPIES of a server GROUP are called Clones. But unlike a Server Group Clones are ASSOCIATED with a node and are REAL server process RUNNING in that node.

The copies of a server group are called Clones. But unlike a Server Group Clones are associated with a node and are real server process running in that node.

The process of PROPAGATING the changes in the PROPERTIES of a server group during RUNTIME to all the ASSOCIATED clones is called Ripple Effect.

The process of propagating the changes in the properties of a server group during runtime to all the associated clones is called Ripple Effect.

The PROCESS by which the contents in the memory of ONE PHYSICAL m/c are REPLICATED in all the m/c in the cluster is CALLED in-memory replication.

The process by which the contents in the memory of one physical m/c are replicated in all the m/c in the cluster is called in-memory replication.

It MANAGES the EXECUTION of ENTERPRISE beans for J2EE applications. Enterprise beans and their container RUN on the J2EE server.

It manages the execution of enterprise beans for J2EE applications. Enterprise beans and their container run on the J2EE server.

EJB was originally designed around remote invocation using the Java Remote METHOD Invocation (RMI) mechanism, and LATER extended to support to standard CORBA transport for these calls using RMI/IIOP. This design allowed for maximum flexibility in developing applications without consideration for the deployment scenario, and was a strong feature in support of a goal of component reuse in J2EE. Many developers are using EJBs locally, that is, some or all of their EJB calls are between beans in a single container. With this feedback in mind, the EJB 2.0 expert group has created a LOCAL interface mechanism. The local interface may be defined for a BEAN during development, to allow streamlined calls to the bean if a caller is in the same container. This does not involve the overhead involved with RMI like marshalling etc. This facility will thus improve the performance of applications in which co-location is planned. Local interfaces also provide the foundation for container-managed relationships among entity beans with container-managed persistence.

EJB was originally designed around remote invocation using the Java Remote Method Invocation (RMI) mechanism, and later extended to support to standard CORBA transport for these calls using RMI/IIOP. This design allowed for maximum flexibility in developing applications without consideration for the deployment scenario, and was a strong feature in support of a goal of component reuse in J2EE. Many developers are using EJBs locally, that is, some or all of their EJB calls are between beans in a single container. With this feedback in mind, the EJB 2.0 expert group has created a local interface mechanism. The local interface may be defined for a bean during development, to allow streamlined calls to the bean if a caller is in the same container. This does not involve the overhead involved with RMI like marshalling etc. This facility will thus improve the performance of applications in which co-location is planned. Local interfaces also provide the foundation for container-managed relationships among entity beans with container-managed persistence.

EJB technology is the CORE of J2EE. It enables developers to write REUSABLE and PORTABLE server-side business logic for the J2EE platform.

EJB technology is the core of J2EE. It enables developers to write reusable and portable server-side business logic for the J2EE platform.

EJB is a specification for J2EE server, not a product; JAVA beans MAY be a GRAPHICAL COMPONENT in IDE.

EJB is a specification for J2EE server, not a product; Java beans may be a graphical component in IDE.

The MAIN technologies in J2EE are: ENTERPRISE JavaBeansTM (EJBsTM), JavaServer PagesTM (JSPsTM), Java Servlets, the Java NAMING and Directory InterfaceTM (JNDITM), the Java Transaction API (JTA), CORBA, and the JDBCTM data ACCESS API.

The main technologies in J2EE are: Enterprise JavaBeansTM (EJBsTM), JavaServer PagesTM (JSPsTM), Java Servlets, the Java Naming and Directory InterfaceTM (JNDITM), the Java Transaction API (JTA), CORBA, and the JDBCTM data access API.

Socket and ServerSocket.
ServerSocket is used for normal TWO-way socket communication.
Socket CLASS allows us to read and write through the sockets. getInputStream() and getOutputStream() are the two METHODS AVAILABLE in Socket class.

Socket and ServerSocket.
ServerSocket is used for normal two-way socket communication.
Socket class allows us to read and write through the sockets. getInputStream() and getOutputStream() are the two methods available in Socket class.

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

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

EJBs can be clients of other EJBs. It just WORKS. Use JNDI to locate the HOME INTERFACE of the other bean, then ACQUIRE an instance reference, and so forth.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The primary key can't be a primitive type--use the primitive wrapper CLASSES, INSTEAD. For EXAMPLE, you can use java.lang.Integer as the primary key class, but not INT (it has to be a class, not a primitive)

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

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

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

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

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

1. Retrieve Home Object reference from Naming Service via JNDI.
2. Return Home Object reference to the CLIENT.
3. Create a new EJB Object through Home Object interface.
4. Create EJB Object from the Ejb Object
5. Return EJB Object reference to the client.
6.  Invoke BUSINESS method using EJB Object reference.
7. DELEGATE REQUEST to BEAN (Enterprise Bean).

1. Transaction_read_uncommitted- Allows a METHOD to read uncommitted data from a DB(fast but not wise).
2. Transaction_read_committed- Guarantees that the data you are getting has been committed.
3. Transaction_repeatable_read - Guarantees that all reads of the DATABASE will be the same during the transaction (good for read and UPDATE OPERATIONS).
4. Transaction_serializable- All the TRANSACTIONS for resource are performed serial.

1. Transaction_read_uncommitted- Allows a method to read uncommitted data from a DB(fast but not wise).
2. Transaction_read_committed- Guarantees that the data you are getting has been committed.
3. Transaction_repeatable_read - Guarantees that all reads of the database will be the same during the transaction (good for read and update operations).
4. Transaction_serializable- All the transactions for resource are performed serial.

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

1. NotSupported - transaction context is unspecified.

2. Required - bean's method invocation is made within a transactional context. If a client is not associated with a transaction, a new transaction is invoked AUTOMATICALLY. 

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

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

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

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

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

1. NotSupported - transaction context is unspecified.

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

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

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

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

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

If a developer doesn't want a Container to manage transactions, it's possible to implement all database operations manually by writing the appropriate JDBC CODE. This often leads to productivity INCREASE, but it makes an ENTITY Bean incompatible with some databases and it enlarges the amount of code to be WRITTEN. All transaction MANAGEMENT is explicitly performed by a developer.

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

Yes. In some cases the data is inserted NOT using JAVA APPLICATION, so you may only need to retrieve the information, PERFORM its processing, but not create your own information of this kind.

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

Session and Entity EJBs consist of 4 and 5 parts respetively:
1. A REMOTE INTERFACE (a client interacts with it),
2. A home interface (USED for creating objects and for declaring business METHODS),
3. A bean object (an object, which actually performs business logic and EJB-specific operations).
4. A deployment descriptor (an XML file containing all information required for maintaining the EJB) or a set of deployment descriptors (if you are using some container-specific features).
5.A Primary Key class - is only Entity bean specific.

Session and Entity EJBs consist of 4 and 5 parts respetively:
1. A remote interface (a client interacts with it),
2. A home interface (used for creating objects and for declaring business methods),
3. A bean object (an object, which actually performs business logic and EJB-specific operations).
4. A deployment descriptor (an XML file containing all information required for maintaining the EJB) or a set of deployment descriptors (if you are using some container-specific features).
5.A Primary Key class - is only Entity bean specific.

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

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

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

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

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

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

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

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

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

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

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

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

Java Beans are usual Java classes which adhere to certain CODING conventions:
► IMPLEMENTS java.io.Serializable interface
► Provides no argument constructor
► Provides getter and SETTER METHODS for accessing it's PROPERTIES.

Java Beans are usual Java classes which adhere to certain coding conventions:
► Implements java.io.Serializable interface
► Provides no argument constructor
► Provides getter and setter methods for accessing it's properties.

Usually this is because of a mistake in the JAR file being LOADED. In the meantime, typical ERRORS include:

► The MANIFEST file uses classes USING the wrong file separator ("/" should be used in all platforms).
► The MANIFEST file refers to classes in a package but the actual .CLASS files are not really in that package.

Usually this is because of a mistake in the JAR file being loaded. In the meantime, typical errors include:

► The MANIFEST file uses classes using the wrong file separator ("/" should be used in all platforms).
► The MANIFEST file refers to classes in a package but the actual .class files are not really in that package.

A bean has the property of PERSISTENCE when its PROPERTIES, fields, and STATE information are saved to and retrieved from storage. Component MODELS provide a mechanism for persistence that enables the state of components to be STORED in a non-volatile place for later retrieval.

A bean has the property of persistence when its properties, fields, and state information are saved to and retrieved from storage. Component models provide a mechanism for persistence that enables the state of components to be stored in a non-volatile place for later retrieval.

Use the Externalizable interface when you need complete control over your BEAN's serialization (for example, when WRITING and reading a specific FILE format). To use the Externalizable interface you need to implement two methods: readExternal and writeExternal. Classes that implement Externalizable must have a no-argument CONSTRUCTOR.

Use the Externalizable interface when you need complete control over your bean's serialization (for example, when writing and reading a specific file format). To use the Externalizable interface you need to implement two methods: readExternal and writeExternal. Classes that implement Externalizable must have a no-argument constructor.

A growing NUMBER of Java object repository sites exist on the Internet in ANSWER to the demand for centralized deployment of applets, classes, and source code in general. Any developer who has spent time hunting through these sites for licensable Java code to incorporate into a program has UNDOUBTEDLY struggled with issues of how to quickly and cleanly integrate code from one particular source into an APPLICATION.

The way in which introspection is implemented provides great advantages, including:
► PORTABILITY - Everything is done in the Java platform, so you can write components once, reuse them everywhere. There are no extra specification files that need to be maintained independently from your component code. There are no platform-specific issues to contend with. Your component is not tied to one component model or one proprietary platform. You get all the advantages of the evolving Java APIs, while maintaining the portability of your components.
► Reuse - By following the JavaBeans design conventions, implementing the appropriate interfaces, and extending the appropriate classes, you provide yourcomponent with reuse potential that possibly exceeds your expectations.

A growing number of Java object repository sites exist on the Internet in answer to the demand for centralized deployment of applets, classes, and source code in general. Any developer who has spent time hunting through these sites for licensable Java code to incorporate into a program has undoubtedly struggled with issues of how to quickly and cleanly integrate code from one particular source into an application.

The way in which introspection is implemented provides great advantages, including:
► Portability - Everything is done in the Java platform, so you can write components once, reuse them everywhere. There are no extra specification files that need to be maintained independently from your component code. There are no platform-specific issues to contend with. Your component is not tied to one component model or one proprietary platform. You get all the advantages of the evolving Java APIs, while maintaining the portability of your components.
► Reuse - By following the JavaBeans design conventions, implementing the appropriate interfaces, and extending the appropriate classes, you provide yourcomponent with reuse potential that possibly exceeds your expectations.

A property editor is a tool for customizing a particular property TYPE. Property editors are activated in the Properties WINDOW. This window determines a property's type, SEARCHES for a relevant property editor, and DISPLAYS the property's CURRENT value in a relevant way.

A property editor is a tool for customizing a particular property type. Property editors are activated in the Properties window. This window determines a property's type, searches for a relevant property editor, and displays the property's current value in a relevant way.

Write the SimpleBean code. Put it in a file NAMED SimpleBean.java, in the directory of your CHOICE. Here's the code:

import java.awt.Color;
import java.beans.XMLDecoder;
import javax.swing.JLabel;
import java.io.SERIALIZABLE;

PUBLIC class SimpleBean extends JLabel
implements Serializable {
public SimpleBean() {
setText( "Hello world!" );
setOpaque( true );
setBackground( Color.RED );
setForeground( Color.YELLOW );
setVerticalAlignment( CENTER );
setHorizontalAlignment( CENTER );
}
}

Write the SimpleBean code. Put it in a file named SimpleBean.java, in the directory of your choice. Here's the code:

import java.awt.Color;
import java.beans.XMLDecoder;
import javax.swing.JLabel;
import java.io.Serializable;

public class SimpleBean extends JLabel
implements Serializable {
public SimpleBean() {
setText( "Hello world!" );
setOpaque( true );
setBackground( Color.RED );
setForeground( Color.YELLOW );
setVerticalAlignment( CENTER );
setHorizontalAlignment( CENTER );
}
}

A Java Bean is a software component WRITTEN in the Java programming language that conforms to the JavaBeans component specification. The JavaBeans APIs became part of the "core" Java APIs as of the 1.1 RELEASE of the JDK. The JavaBeans specification defines a Java-based software component model that ADDS a number of FEATURES to the Java programming language. Some of these features include:

► introspection
► customization
► events
► properties
► persistence

Enterprise JavaBeans (EJBs) are Java-based software components that are built to comply with Java's EJB specification and run inside of an EJB container supplied by a J2EE provider. An EJB container PROVIDES distributed application functionality such as transaction support, persistence and lifecycle management for the EJBs.

A Java Bean is a software component written in the Java programming language that conforms to the JavaBeans component specification. The JavaBeans APIs became part of the "core" Java APIs as of the 1.1 release of the JDK. The JavaBeans specification defines a Java-based software component model that adds a number of features to the Java programming language. Some of these features include:

► introspection
► customization
► events
► properties
► persistence

Enterprise JavaBeans (EJBs) are Java-based software components that are built to comply with Java's EJB specification and run inside of an EJB container supplied by a J2EE provider. An EJB container provides distributed application functionality such as transaction support, persistence and lifecycle management for the EJBs.

JavaBeans components, or Beans, are reusable SOFTWARE components that can be manipulated visually in a builder tool. Beans can be combined to CREATE traditional applications, or their smaller web-oriented brethren, applets. In addition, applets can be designed to work as reusable Beans.

INDIVIDUAL Beans will function quite differently, but typical unifying features that distinguish a Bean are:
► Introspection: enables a builder tool to ANALYZE how a Bean works.
► Customization: enables a developer to use an app builder tool to customize the appearance and behavior of a Bean.
► Events: enables Beans to communicate and connect together.
► Properties: enable developers to customize and program with Beans.
► Persistence: enables developers to customize Beans in an app builder, and then retrieve those Beans, with customized features intact, for FUTURE use.

JavaBeans components, or Beans, are reusable software components that can be manipulated visually in a builder tool. Beans can be combined to create traditional applications, or their smaller web-oriented brethren, applets. In addition, applets can be designed to work as reusable Beans.

Individual Beans will function quite differently, but typical unifying features that distinguish a Bean are:
► Introspection: enables a builder tool to analyze how a Bean works.
► Customization: enables a developer to use an app builder tool to customize the appearance and behavior of a Bean.
► Events: enables Beans to communicate and connect together.
► Properties: enable developers to customize and program with Beans.
► Persistence: enables developers to customize Beans in an app builder, and then retrieve those Beans, with customized features intact, for future use.

Developers are turning to CREATING components RATHER than monolithic applications to free themselves from slow, expensive application development, and to build up a portable, reusable code base. This enables developers to quickly attack new market OPPORTUNITIES, new JOINT development opportunities, and new ways to sell smaller packages of software.

Developers are turning to creating components rather than monolithic applications to free themselves from slow, expensive application development, and to build up a portable, reusable code base. This enables developers to quickly attack new market opportunities, new joint development opportunities, and new ways to sell smaller packages of software.

JavaBeans is a complete component model. It supports the standard component architecture features of PROPERTIES, events, METHODS, and persistence. In ADDITION, JavaBeans provides support for introspection (to allow AUTOMATIC ANALYSIS of a JavaBeanscomponent) and customization (to make it easy to configure a JavaBeans component).

JavaBeans is a complete component model. It supports the standard component architecture features of properties, events, methods, and persistence. In addition, JavaBeans provides support for introspection (to allow automatic analysis of a JavaBeanscomponent) and customization (to make it easy to configure a JavaBeans component).

JavaBeans BRINGS the extraordinary POWER of the Java PLATFORM to component DEVELOPMENT, OFFERING the ideal environment for a developer who wants to extend the concept of reusable component development beyond one platform and one architecture to embrace every platform and every architecture in the industry.

JavaBeans brings the extraordinary power of the Java platform to component development, offering the ideal environment for a developer who wants to extend the concept of reusable component development beyond one platform and one architecture to embrace every platform and every architecture in the industry.

A coalition of industry leaders in component development worked with JavaSoft to create the JavaBeans SPECIFICATION, which was released to the Internet for public comments on September 4, 1996. The "FROZEN" JavaBeans specification combines the work of Apple, Borland, IBM, JustSystem, Microsoft, Netscape, Rogue WAVE, SunSoft and Symantec and many, many others... We're very PLEASED to see the tools community swiftly embracing JavaBeans by announcing support for JavaBeans in their visual application builder tools.

A coalition of industry leaders in component development worked with JavaSoft to create the JavaBeans specification, which was released to the Internet for public comments on September 4, 1996. The "frozen" JavaBeans specification combines the work of Apple, Borland, IBM, JustSystem, Microsoft, Netscape, Rogue Wave, SunSoft and Symantec and many, many others... We're very pleased to see the tools community swiftly embracing JavaBeans by announcing support for JavaBeans in their visual application builder tools.

YES. A large number of COMPANIES, both large and small, have announced their PLANS to DELIVER JavaBeans-based products.

Yes. A large number of companies, both large and small, have announced their plans to deliver JavaBeans-based products.

The JFC (Java Foundation CLASSES) is based UPON the AWT (Abstract WINDOWING Toolkit), which has been part of the Java platform from the beginning. JFC effectively adds a richer SET of visual elements for building JavaBeans COMPONENTS and applications. See the JFC web site for more information.

The JFC (Java Foundation Classes) is based upon the AWT (Abstract Windowing Toolkit), which has been part of the Java platform from the beginning. JFC effectively adds a richer set of visual elements for building JavaBeans components and applications. See the JFC web site for more information.

The most common reason for a "java.lang.ClassFormatError: DUPLICATE name" error is that a .class FILE in the JAR CONTAINS a class whose class name is different from the EXPECTED name. So for example if you have a file called "a/B.class" and it contains a class called "B" or "a.X" instead of the class "a.B" then you will get this error.

The most common causes for this PROBLEM are either forgetting to include a "package a;" statement or having a "package" statement with the wrong name.

The most common reason for a "java.lang.ClassFormatError: Duplicate name" error is that a .class file in the JAR contains a class whose class name is different from the expected name. So for example if you have a file called "a/B.class" and it contains a class called "B" or "a.X" instead of the class "a.B" then you will get this error.

The most common causes for this problem are either forgetting to include a "package a;" statement or having a "package" statement with the wrong name.

JavaBeans does not ADD any security features to the JAVA platform. Rather, JavaBeans components have full access to the broad range of security features that are part of the Java platform. JavaBeans components can be used to build a range of different KINDS of SOLUTIONS from full-fledged Java desktop APPLICATIONS to web-based Applets.

JavaBeans does not add any security features to the Java platform. Rather, JavaBeans components have full access to the broad range of security features that are part of the Java platform. JavaBeans components can be used to build a range of different kinds of solutions from full-fledged Java desktop applications to web-based Applets.