barcode font vb.net Stateful session beans in Java

Encode DataMatrix in Java Stateful session beans

variables that you care about and should be saved into permanent storage must either be a Java primitive or implement the java.io. Serializable interface.

The point of the PrePassivate callback is to give the bean a chance to prepare for serialization. This may include copying nonserializable variable values into Serializable variables and clearing unneeded data out of those variables to save total disk space needed to store the bean. Most often the prepassivation step consists of releasing heavy-duty resources such as open database, messaging server, and socket connections that cannot be serialized. A well-behaved bean should ensure that heavy-duty resources are both closed and explicitly set to null before passivation takes place. From the perspective of a bean instance, there isn t much of a difference between being passivated and being destroyed. In both cases, the current instance in memory would cease to exist. As a result, in most cases you ll find that the same actions are performed for both the PreDestroy and PrePassivate callbacks, as we do in listing 3.2. Pretty much the same applies for the PostConstruct PostActivate pair. For both callbacks, the bean needs to do whatever is necessary to make itself ready to service the next incoming request. Nine times out of ten, this means getting hold of resources that either are not instantiated or were lost during the serialization/deserialization process. Again, listing 3.2 is a good example since the java.sql.Connection object cannot be serialized and must be reinstantiated during activation. Destroying a stateful session bean In listing 3.2, the cancelAccountCreation and createAccount methods are marked with the @Remove annotation. Beyond the obvious importance of these methods in implementing vital workflow logic, they play an important role in maintaining application server performance. Calling business methods marked with the @Remove annotation signifies a desire by the client to end the session. As a result, invoking these methods triggers immediate bean destruction. To gain an appreciation for this feature, consider what would happen if it did not exist. If remove methods were not an option, the client would have no way of telling the container when a session should be ended. As a result, every stateful bean instance ever created would always have to be timed out to be passivated (if the container implementation supports passivation) and timed out again to be finally destroyed. In a highly concurrent system, this could have a drastic performance impact. The memory footprint for the server would

constantly be artificially high, not to mention how there would be wasted CPU cycles and disk space used in the unnecessary activation/passivation process. This is why it is critical that you remove stateful bean instances when the client is finished with its work instead of relying on the container to destroy them when they time out. Believe it or not, these are the only few stateful bean specific features that we needed to talk about! Before concluding this section on stateful beans, we ll briefly summarize the differences between stateful and stateless session beans as a handy reference in table 3.2.

Table 3.2 The main differences between stateless and stateful session beans Features Conversational state Pooling Performance problems Lifecycle events No Yes Unlikely PostConstruct, PreDestroy Yes Stateless Yes No Possible PostConstruct, PreDestroy, PrePassivate, PostActivate No Stateful

Timer (discussed in chapter 5) SessionSynchronization for transactions (discussed in chapter 6) Web services Extended PersistenceContext (discussed in chapter 9)

Thus far we have explored how to develop session beans. In the next section, we discuss how session beans are actually accessed and used by clients.

A session bean works for a client and may either be invoked by local clients collocated in the same JVM or by a remote client outside the JVM. In this section we first discuss how a client accesses a session bean and then see how the @EJB annotation is used to inject session bean references. Almost any Java component can be a session bean client. POJOs, servlets, JSPs, or other EJBs can access session beans. In fact, stateless session beans exposed