EJB Stateless Session Begining
参考：http://www.tusc.com.au/tutorial/html/index.html
一、Enterprise Beans
在EJB（Enterprise Java Beans）中定义了两种不同类别的Enterprise Bean ：
l 会话 Bean (Session Bean)
l 实体Bean (Entity Bean)
1. 会话 Bean (Session Bean)
请把Session Beans看作任务而非持久数据，只有这样，你才能清晰地理解使用它的场合和原因。比如说，Session Bean可能会对数据库内的用户进行检索操作，但并不把用户表示为持久的业务对象。Session Beans可以同其他类型的Java beans通信，这种能力已经超出了数据库事务概念之外。在这种方式下工作的分布式应用程序特别适合于采用Session Beans。
所有的Session Beans都派生于javax.ejb.SessionBean类。就像其名称那样， Session Beans只存在于单一客户会话中。这里的客户可能是Java Servlet、桌面应用程序、别的EJB乃至采用Java Bean的其他事务信息方式。Session Bean的生存期从客户程序发起接触开始，在客户通过调用EJB宿主接口的remove()方法显式破坏bean时终止。会话还会在预先设置的时间终止，而这种时间设置则由EJB容器内确定。考虑到服务器的资源，开发者往往会设法避免处理“超时”设置而在编写客户程序时做相应的延期处理。此外，开发者还应该在EJB容器重新启动的时候小心Session Bean的短暂寿命；客户程序可以重新获得同类bean的引用，但很有可能却不是同一bean。
Session Beans可以是无状态也可以是有状态的，因而两者会显示出不同的行为。Session Bean的状态概念类似于HTTP设置：客户程序和服务器之间的交互（在这种情况下就是bean自身）发生在定义的环境之内。有状态的Session Bean会在多个方法调用的情况下保存客户和bean的有关信息。有状态的Session Bean只能同一个客户程序通讯，而无状态Session bean的实例却可以同时和若干个客户程序通讯。
会话 Bean 是调用它的客户端代码要完成的工作。当客户端与服务器建立联系，那么一个会话 Bean 就建立起来了。根据会话 Bean 的状态不同有分为:
A. 状态会话 Bean (Stateful Session Bean)
B. 无状态会话 Bean (Stateless Session Bean)
1.1 状态会话 Bean (Stateful Session Bean)
当客户机和服务器建立连接之后，状态会话 Bean (Stateful Session Bean) 将一直在客户机和服务器之间保持着用户的某个状态。例如：用户使用银行的ATM时，经过验证之后，用户可以连续执行多次操作，在这个过程当中，用户的合法状态将一直被保留，直到她将信用卡取出，结束这次操作。这时，状态会话 Bean (Stateful Session Bean) 也就被销毁。
1.2无状态会话 Bean (Stateless Session Bean)
当客户机和服务器建立连接之后，无状态会话 Bean (Stateless Session Bean)处理单一的用户请求或商务过程。无状态会话 Bean (Stateless Session Bean)不需要从以前的请求中提取任何状态。例如，用户的用户密码确认。用户输入密码后，发送请求。组件返回真或假来确认用户，一旦过程完成，无状态会话 Bean (Stateless Session Bean) 也宣告结束。
2. 实体Bean (Entity Bean)
实体Bean (Entity Bean)只是数据模型，它不包括商务逻辑。实体Bean (Entity Bean)可以将关系/对象数据库的数据映射到内存中供其它组件使用。实体Bean (Entity Bean)是一直存在的，而且具有很高的容错性能。实体Bean (Entity Bean)能供允许多用户同时访问。
二、会话 Bean (Session Bean)
Ejb的执行过程是被放在一个EJB容器中进行的，所以客户端不会直接调用我们写好的Enterprise Bean ，而是调用EJB容器生成的一个EJBObject (EJB对象)来实现。那么，我们在编写服务器端的Enterprise Bean 时，就要考虑这点。既然客户端不能直接访问，就由EJBObject来代劳，所以在编写服务器端时，就要编写服务器端的一个接口（Remote）用来与客户机联系，实力化EJBObject。要生成EJBObject 就要调有Home 接口，来建立这个实力。
以下是会话 Bean 的代码分析：
A.Enterprise Bean 类：sailorsy.class
1.setSessionContext(SessionContext ctx)方法
它是EJB容器和Enterprise Bean互相作用的关口。
import java.rmi.*;
import javax.ejb.*;
public class sailorsy implements SessionBean{
private SessionContext ctx=null;
public voic setSessionContext(SessionContext ctx){
this.ctx=ctx;
}//setSessionContext
}//class sailorsy
2.ejbCreate(…)方法
它可以初始化Enterprise Bean ,可以定义不同的ejbCreate(…)方法，每个方法所带的参数不同。但是，必许要存在至少一种。
import java.rmi.*;
import javax.ejb.*;
public class sailorsy implements SessionBean{
private SessionContext ctx=null;
public voic setSessionContext(SessionContext ctx){
this.ctx=ctx;
}//setSessionContext
public void ejbCreate() {
}//ejbCreate
}//class sailorsy
3.ejbPassivate()方法
如果初始化的Enterprise Bean 过多，EJB容器将其中的一些挂起（passivate）,释放他们所占用的空间。
import java.rmi.*;
import javax.ejb.*;
public class sailorsy implements SessionBean{
private SessionContext ctx=null;
public voic setSessionContext(SessionContext ctx){
this.ctx=ctx;
}//setSessionContext
public void ejbCreate() {
}//ejbCreate
public void ejbPassivate() {
}//ejbPassivate
}//class sailorsy
4.ejbActivate()方法
和ejbPassivate正好相反，它将被挂起的Bean从新调回。
import java.rmi.*;
import javax.ejb.*;
public class sailorsy implements SessionBean{
private SessionContext ctx=null;
public voic setSessionContext(SessionContext ctx){
this.ctx=ctx;
}//setSessionContext
Creating a Stateless Session Bean
This chapter covers how to create a stateless session EJB component. This bean will be responsible for authenticating the user by communicating with the database using Data Access Object (DAO) which encapsulates Java Database Connectivity (JDBC) code. A DAO has all attributes (fields) and behavior (methods) corresponding to the bean it is being used for.
All customers, supplier and manager of MyStore have been assigned a unique username and userid to access services of MyStore, but in order to access these services all these entities have to first login into the system (MyStore). The method for authentication is named loginUser, which takes two String parameters, username and password and returns the userID if authentication is successful.
Note : This method loginUser is a business method, normally business methods carry out operations or processing on values EJB components. From clients perspective, clients can see only business methods and invoke them on bean.
Tasks :
- Create a J2EE project named MyStore.
- Create a Stateless Session Bean named StoreAccess.
- Add a business method in bean named loginUser with the following signature
public String loginUser (String username, String password)
- Create a DAO named StoreAccessDAOImpl under package au.com.tusc.dao. Generate the DAO interface.
- Implement the method named loginUser, generated in DAO interface, in StoreAccessDAOImpl. Method signature is
public String loginUser (String username, String password)
- Add callback methods and implement them.
- Deploy StoreAccess bean.
- Create your test client named SessionClient under package au.com.tusc.client.
- Run your client and test the bean.
Create J2EE Project :
Now, lets start to write our first component of this tutorial.
Go to File > New > LombozJ2EE Project, project creation wizard will pop up.
Insert Project Name MyStore > Next .
Under Java Settings Check source, should be MyStore/src , libraries pointing to $JAVA_HOME > Go Next as shown in fig below.
Note: This step is shown in chapter1, as there is a bug in eclipse 2.1, so its important that you check your library settings are right.
Under Create J2EE Module, select Web Modules tab > Add.., enter Module name as OnlineStore > OK as shown in figure below.
Under Create J2EE Module, select EJB Modules tab > Add.., enter Module name as MyStoreMgr > OK .
Under Create J2EE Module, select Targeted Servers tab > Select JBOSS 3.2.1 ALL > Add.. > Finish.
Create Stateless Bean :
Go To Package Explorer > Expand Mystore (project) node > select src, right click and menu will pop up.
On pop up menu > New > Lomboz EJB Creation Wizard.
Enter package name au.com.tusc.session, bean name StoreAccess and select bean type as stateless > Finish.
This will create a package named au.com.tusc.session under src and StoreAccessBean under that package as shown in the figure below.
As we can see from the figure below it has created a class level tag @ejb.bean, which has assigned the bean type, name and its JNDI name which will be generated in Home interface. This tag will also generate deployment descriptors in ejb-jar.xml and jboss.xml file as well once you generate your EJB classes, which is covered later on in this chapter.
Note: It will generate the bean name, jndi-name and type of bean in the file. Also, the name of file is appended with word 'Bean' as you gave the name of the bean as StoreAccess only. Again, be careful with naming conventions, specifying the bean name only in the wizard without adding the word 'Bean' to the name as the wizard appends that for you.
Expand MyStoreMgr/META-INF node under Package Explorer. You will find there are seven files which are generated by Lomboz using Xdoclet as shown in the figure below.
Now we are going to generate all the interfaces including Home, Remote, DAO and other helper classes. We will explain why later on, but for the time being just follow the steps.
But before we get too excited, there are a few concepts to cover here.
Go to MyStoreMgr/META-INF > select and open ejbGenerate.xml.
Note: Lomboz uses this file to generate required interfaces and helper classes, so in the event that you have special needs then you will have to customize this file. See ejbdoclet under the Xdoclet documentation.
'ejbGenerate.xml' file is generated only once when you create your EJB module. So any changes made in this file will be reflected even if you modify your bean class and generate your classes again and again.
|
As we can see from the code snippet of file shown in figure at right, there are following tags defined.
<dataobject/> is defined for generating data Objects for holding values of EJB component's persistent fields, which correspond to columns in the associated table in the database.
Note: <dataobject/> has been deprecated in favour of Value Object which is more powerful in terms of relationships (1-1, 1-n and n-m).
<utilobject/> Creates method for generating GUID and for accessing Remote and Local Home objects.
<remoteinterface/> Generates remote interfaces for EJBs.
<localinterface/> Generates local interfaces for EJBs.
<homeinterface /> Generates remote home interfaces for EJBs.
<localhomeinterface/>Generates local home interfaces for EJBs.
<entitypk/>Generates primary key classes for entity EJBs.
<entitybmp/>Creates entity bean classes for BMP entity EJBs.
<entitycmp/>
<session/> Generates session bean class.
Note : There is no tag for generating a DAO.
So, we have to include this <dao/> tag.
For details, please refer ejbdoclet under Xdoclet documentation.
|
|
|
As we can see from the code snippet from this file the following tags are defined.
<jboss/> is a JBOSS specific tag required for JBOSS. You have to specify datasource, datasourcemapping and preferredrelationmapping. As it differs for different databases, so you may have to specify values appropriate to your environment. If these tags are commented out in JBOSS they default to the correct values for the built-in Hypersonic SQL database, but for the moment we'll set them anyway.
|
|
The other two files which are of importance to us are ejb-jar.xml and jboss.xml. The file ejb-jar.xml has all the deployment descriptors for beans and jboss.xml has the JBOSS specific deployment descriptors required by JBOSS.
Note : ejb-jar.xml file is generated every time you generate interface and helper classes for your bean. For the first time, it is empty, and jboss.xml will be generated every time when you will generate your classes for your bean.
Setup DAO :
Now, let's customize ejbGenerate.xml for setting up a DAO.
We have included a <dao> tag specifying the destination directory for the generated DAO interface and what pattern to be used.
Note : For details, please refer ejbdoclet under Xdoclet documentation.
|
We have included the datasource, datasoucremapping and preferredrelationmapping as shown in code snippet of ejbGenerate.xml file on right.
datasource="java:/DefaultDS" is a local JNDI name for data source to be used.
datsourcemapping="Hypersonic SQL" maps data object/value objects and their types to columns and data types associated with these columns.
preferredrelationmapping="foreign-key" defines type of database to be used.
Note : For more details, please refer JBOSS documentation.
Since we are using the Hypersonic database, these parameters are appropriate to that. These parameters relate to the configuration file standardjbosscmp-jdbc.xml which controls the CMP-to-JDBC mappings for JBOSS. This resides in $JBOSS_HOME/server/conf/ , e.g. /opt/jboss/jboss-3.2.1/server/default/conf/.
Code snippet from standardjbosscmp-jdbc.xml is shown in figure at right.
|
|
Note : The way Xdoclet works is bit different from some conventional styles of programming, as the Xdoclet tags will generate these (home and remote) interfaces along with necessary helper classes, which then will used in Bean and DAO Implementation class. However, until these are generated, we cannot write any business methods in Bean and JDBC wrappers in the DAO Implementation class. If this seems confusing then just follow the steps, and hopefully it will become more clear.
Create DAO Interface :
Since we are going to use a DAO to access the database for this Stateless Bean, we have to create a DAOImpl class which will implement that generated DAO interface.
Go to src > add package named au.com.tusc.dao > Add a class StoreAccessDAOImpl in that package.
Now go to your Bean class and declare this tag at the class level (that is at the top) as shown below to generate the DAO interface.
@ejb.dao class="au.com.tusc.session.StoreAccessDAO"
impl-class="au.com.tusc.dao.StoreAccessDAOImpl"
Expand StoreAccessBean node under Package Explorer. Right click and a pop up menu will appear.
On that menu go to Lomboz J2EE > Add EJB to module. Select EJB '[MyStoreMgr]' > OK.
Expand MyStoreMgr node under MyStore Project in Package Explorer. Right click and a menu will pop up.
Go to Lomboz J2EE > Generate EJB Classes as shown in the figure below.
|
EJB interfaces and helper classes are generated under ejbsrc/au.com.tusc.session directory as shown in the figure at the right.
Seven files are generated.
StoreAccess is the remote object interface.
StoreAccessLocal is the local object interface.
StoreAccessSession extends our bean class named StoreAccesBean.
StoreAccessHome is the remote home interface.
StoreAccessLocalHome is the local home interface.
StoreAccessUtil is a helper class which has methods for accessing Home and LocalHome interface along with generating GUID.
StoreAccesDAO is the DAO interface which we will use to implement our StoreAccessDAOImpl under au.com.tusc.dao.
StoreAccessDAO is generated by this tag declared in StoreAccesBean shown below. If you don't declare this tag in that file it won't generate this interface.
@ejb.dao class=au.com.tusc.session.StoreAccessDAO
impl-class=au.com.tusc.dao.StoreAccessDAOImpl
Other files of interest which are generated are ejb-jar.xml and jboss.xml under MyStoreMgr/META-INF.
|
|
|
As shown in the figure on the right, a few descriptors are generated in the ejb-jar.xml file.
These descriptors are generated by the following tag declared in the StoreAccesBean file.
@ejb.bean name ="StoreAccess"
jndi-name="StoreAccessBean"
type="Stateless"
This tag is added by Lomboz's bean creation wizard.
|
|
This tag also generates the following descriptors in jboss.xml as shown in the code snippet below.
So now we know which tags are responsible for generating classes, interfaces and descriptors.
Add Business Method :
Next step is to add a business method in the bean.
Go to StoreAccesBean > Right click > Select New on pop up menu > Select Lomboz Ejb Method Wizard.
Add a business method with the following signature: public String loginUser (String username, String password).
Select Method Type as Business and Interface as Remote as shown in the figure below..
This wizard generates a loginUser method in our bean class, with the method level tag '@ejb.interface' shown below.
This tag is responsible for generating this method in the Remote Interface (in this case it is StoreAccess which will be created once you generate your classes). This tag is covered later on in this chapter.
|
Now, This business method needs to invoke a method on the DAO, which will communicate with the database.
Therefore we add another tag on this method, so that a method with this signature is generated in DAO interface which we can implement in the DAOImpl class. Then this business method can invoke the method in DAOImpl class to get the desired result.
@dao.call name="loginUser"
So add this tag at the method level as shown in the figure at right.
Now generate your EJB classes again as shown in the steps we went through earlier.
Note: OK, OK! For reference these are the steps you have to follow.
Expand 'MyStoreMgr' node under 'MyStore' Project in Package Explorer.
Right click and a pop up menu will appear.
Go to Lomboz J2EE > Generate EJB Classes.
|
|
After generating the classes, we look at first the generated DAO interface and then the generated Session Class.
In StoreAcessDAO two methods are generated.
1. init() by default.
2. loginUser(), generated by tag shown below.
@dao.call name="loginUser"
Note: Please do not edit any class generated by Xdoclect.
In StoreAcessSession two methods of our interest are
1. getDAO() creates instance of DAOImpl calss.
2. loginUser(), calls loginUser method in DAOImpl class, which we have to implement.
Code snippet from 'StoreAccessSession'.
Implement DAO Interface :
Now, we will implement methods in the StoreAccessDAOImpl class.
|
First import the following packages.
javax.naming.InitialContext;
javax.sql.DataSource;
java.sql.Connection;
java.sql.PreparedStatement;
java.sql.ResultSet;
java.sql.SQLException;
Change your class declaration so that StoreAccessDAOImpl implements StoreAccessDAO.
Add a field to store the JDBC resource factory reference.
private DataSource jdbcFactory;
In init() method, locate the reference "jdbc/DefaultDS" using the JNDI API, and store the reference in variable jdbcFactory.
Lookup string is "java:comp/env/jdbc/DefaultDS".
Code Snippet is shown in the figure on the right.
Now add the required code in loginUser().
|
|
|
In method loginUser(), first get the connection to the database using the jdbcFactory.
Create a SQL statement which searches for userid in the table StoreAccess where userid and password is provided for each user.
Return userid if successful, else raise SQLException.
Code snippet is shown in the figure on the right.
Go back to your loginUser method in StoreAccessBean class.
|
|
In StoreAcessBean class under the loginUser method just add some debug statements, as shown below in this code snippet.
Note : We don't have to call the loginUser method in StoreAccessDAOImpl, as it being invoked by the loginUser method in StoreAccessSession class which inherits StoreAccessBean class, that is the StoreAccessSession class has overridden this method.
Code snippet from StoreAccessSession shown below.
Add Callback Methods :
Now, add callback methods to complete this bean as shown below.
- setSessionContext.
- UnsetSessionContext.
Note : These callback methods are invoked by the EJB container.
Add a field to store sessionContext.
protected SessionContext ctx;
Add method setSessionContext with sessionContext as parameter and assign that to the sessionContext variable as shown below in the code snippet.
Similarly add method unsetSessionContext, assign context variable to null as shown above.
Note : StoreAccessSession class inherits the StoreAccessBean abstract class and implements SessionBean, which will override all methods of interface SessionBean. So after finishing the methods in the bean class, generate your EJB classes again. SessionContext methods will be overridden as shown in figure below. Code snippet from StoreAccessSession shown below.
Now let's look at the generated Home and Remote interfaces.
In the case of the Remote interface all business methods declared in the bean are also generated with the same signature. This is due to the class level tag declared in the StoreAccess Bean as discussed above after adding business methods. Code snippet for tag is shown below.
So, loginUser is generated in a Remote Interface called StoreAccess as shown below because of this tag.
In the case of the Home Interface only one method is created named 'create', which is generated by default because of the <homeinterface/> tag in ejbGenerate.xml as shown below.
Also, other then that, it has JNDI_NAME and COMP_NAME (which is the logical name to lookup the component) is also generated, these are generated because of this tag declared at class level in 'StoreAccessBean' class shown below in figure.
Note : For further options associated with these tags please refer to the 'ejbdoclet' documentation in Xdoclet.
Now, all the aspects are pretty much covered, and our bean's functionality is complete. Now for the deployment descriptors..
Deploy Bean :
In order to deploy our bean we have to declare a few tags in the StoreAccessBean class as shown below in the code snippet.
Add the tag shown below in at the class level (at the top).
@ejb.resource-ref res-ref-name="jdbc/DefaultDS"
res-type="javax.sql.Datasource"
res-auth="Container"
This tag will generate deployment descriptors in ejb-jar.xml, as the bean has to know which datasource you are going to connect to, what is its type, etc. This will generate these descriptors as shown in code snippet below.
Add the tag shown below in StoreAccessBean at the class level (at the top).
@jboss.resource-ref res-ref-name="jdbc/DefaultDS" jndi-name="java:/DefaultDS"
This tag will generate deployment descriptors in jboss.xml, as the application server has to know with what jndi-name datasource it has been registered with. This will generate these descriptors as shown in the code snippet below.
Now, everything is complete, and it's time to deploy the bean.
First, regenerate your EJB classes as shown in the steps above for the final time.
Note : We have regenerated the classes again and again, in order to explain every step and its result. Once you are familiar with these steps you will need much fewer of these iterations. Either way, it doesn't matter, as your implementation always remains untouched by this process.
Go to Lomboz J2EE View > expand node MyStore > expand MyStoreMgr > select 'Jboss 3.2.1 ALL' .
Right click > select Debug Sever on the pop up menu as shown in figure below.
Go to MyStoreMgr node in LombozJ2EE view > right click > select Deploy on the pop up menu as shown in the figure below.
And now wait for your deployment result.
If everything goes fine, you will have this message under your console as shown in the figure below.
So, now our bean is deployed successfully, let's create our test client, which will invoke the loginUser method on 'StoreAccessBean'.
Create your Test Client :
Go to Project MytStore node > select src node > right click.
Select New on pop up menu > select Lomboz EJB Test Client Wizard as shown in the figure below.
Select package name au.com.tusc.client, name as SessionClient and select Ejb Home as au.com.tusc.session.StoreAccessHome and Ejb Interface as au.com.tusc.session.StoreAccess as shown in the figure below.
This will generate the required methods for you in your SessionClient class and you have to just invoke the loginUser method on the bean as shown below.
Now the last step is to write code in your client.
So add these lines under the testBean method as shown in figure below.
System.out.println("Request from client : ");
System.out.println("Reply from Server: Your userid is " +
myBean.loginUser("ANDY","PASSWD"));
Test your Client :
Now, in order to test your client, Select SessionClient node > Go at top level menu and select the icon with the 'Running Man'.
On that select 'Run as' > select 'Java Application', as shown below.
Now under your console, if you get your reply for 'ANDY' as 'U2', then your call is successful as shown below.
Note : So our Stateless Session Bean is deployed and tested successfully and from now onwards you should be comfortable using Lomboz. In future we will not go into the detail of the steps for using Lomboz and will concentrate more on other aspects of beans.
小结
通过表示J2EE应用程序中的任务或者行动。Session Beans可以因此而处理大量的状态。尤其是在同其他EJB合用的情况下。理解Session Beans的瞬时现象对开发者的工作会带来莫大的帮助。有状态和无状态Beans的细微差别就如同充分利用其行为一样重要。在掌握以上的概念之后，正确的设计和实现Session Beans必然会显著改进EJB应用程序的功能和效率。