1.命令行下进行war 文件打包。
在Dos 窗口中进入到WEB 应用根目录下(WebRoot下)，执行如下命令，如：
jar cvf EJBClient.war *，再把打包的EJBClient.war拷贝到C:\jboss-5.0.0.GA\server\default\deploy发布。

2.在Ant 任务中进行war文件打包。
build.xml文件如下：
 <?xml version="1.0" encoding="UTF-8"?>
<project name="EJBClient" default="war" basedir=".">
 <property environment="env" />
 <property name="jboss.home" value="${env.JBOSS_HOME}" />
 <property name="jboss.server.config" value="default" />
 <target name="war" description="创建WEB 发布包">
  <war warfile="${basedir}/${ant.project.name}.war" webxml="${basedir}/WebRoot/WEB-INF/web.xml">
   <classes dir="${basedir}/WebRoot/WEB-INF/classes">
    <include name="**/*.class" />
   </classes>
   
   <lib dir="${basedir}/WebRoot/WEB-INF/lib">
    <include name="*.jar" />
   </lib>
   
   <webinf dir="${basedir}/WebRoot">
    <include name="*.*" />
   </webinf>
  </war>
 </target>
 
 <target name="deploy" depends="war" description="发布WAR">
  <copy file="${basedir}\${ant.project.name}.war" todir="${jboss.home}\server\${jboss.server.config}\deploy"/>
 </target>
 
 <target name="undeploy"  description="卸载WAR">
  <delete file="${jboss.home}\server\${jboss.server.config}\deploy\${ant.project.name}.war"/>
 </target>
</project>

这个主要原因就在stateless bean的实现类。

仔细查看后发现，原来我在实现类的每个方法前加入了 @WebMethod(指定暴露给外界的方法)，因此去掉就可以了。

13:41:39,168 WARN  [StatelessBeanContext] EJBTHREE-1337: do not get WebServiceContext property from stateless bean context, it should already have been injected
13:41:39,215 WARN  [InterceptorsFactory] EJBTHREE-1246: Do not use InterceptorsFactory with a ManagedObjectAdvisor, InterceptorRegistry should be used via the bean container
13:41:39,215 WARN  [InterceptorsFactory] EJBTHREE-1246: Do not use InterceptorsFactory with a ManagedObjectAdvisor, InterceptorRegistry should be used via the bean container
13:41:39,230 WARN  [InterceptorRegistry] applicable interceptors is non-existent for public cn.ztf.bean.Order cn.ztf.service.impl.OrderServiceBean.getOrder(java.lang.String)
13:41:39,246 WARN  [InterceptorRegistry] applicable interceptors is non-existent for public java.lang.String cn.ztf.service.impl.OrderServiceBean.getUserName(java.lang.String)
13:41:39,246 WARN  [InterceptorRegistry] applicable interceptors is non-existent for public java.util.List cn.ztf.service.impl.OrderServiceBean.getOrders()
13:41:39,246 WARN  [InterceptorRegistry] applicable interceptors is non-existent for public cn.ztf.bean.Order cn.ztf.service.impl.OrderServiceBean.getOrder(java.lang.String)
13:41:39,261 WARN  [InterceptorRegistry] applicable interceptors is non-existent for public java.lang.String cn.ztf.service.impl.OrderServiceBean.getUserName(java.lang.String)
13:41:39,261 WARN  [InterceptorRegistry] applicable interceptors is non-existent for public java.util.List cn.ztf.service.impl.OrderServiceBean.getOrders()
13:41:39,293 WARN  [StatelessBeanContext] EJBTHREE-1337: do not get WebServiceContext property from stateless bean context, it should already have been injected
13:46:27,043 WARN  [StatelessBeanContext] EJBTHREE-1337: do not get WebServiceContext property from stateless bean context, it should already have been injected
13:46:27,043 WARN  [StatelessBeanContext] EJBTHREE-1337: do not get WebServiceContext property from stateless bean context, it should already have been injected

 
posted @ 2009-03-30 14:33 断点 阅读(647) | 评论 (0)

二者偏重点不同：
Web服务偏重的是这个系统对外提供什么功能；
EJB偏重的是如何使用一个个组件组装这些功能。

例如：一个硬盘，它对外提供的是存储服务，这是web服务的关注点；对于怎样组装这个硬盘，web服务并不关心，而这些是EJB所关注的。

JavaEE为web service提供了两种不同的编程模型：EJB容器模型、Web容器模型。
下面以最新的JAX-WS2.x规范(Java API for XML-based Web Services)介绍Webservice的开发。
注：JAX-WS的下载路径为https://jax-ws.dev.java.net/servlets/ProjectDocumentList?folderID=7796&expandFolder=7796&folderID=11088

EJB容器模型的WEB服务的客户端开发：
注：首先我们需要建立一个无状态SessionBean，然后把此无状态SessionBean发布为web service。

1.在应用的类路径下放入JAX-WS的全部jar文件，并且把引进的jar文件添加到类路径上，即右击项目名-->Properties-->Java Build Path-->Add JARS。
如果你使用的是JDK6，这一步可以省略，因为JDK6已经绑定了JAX-WS。目前JDK6绑定的JAX-WS版本是2.0。

2.把JAX-WS产品lib目录中找到jaxws-api.jar和jaxb-api.jar，把这两个文件copy到JDK_HOME/jre/lib/endorsed目录下。

3.利用Web Service客户端生成工具(wsimport工具的Ant任务类)生成辅助类。
build.xml文件内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<project name="WSClient" default="wsclientgen" basedir=".">
 <property name="src.dir" value="${basedir}/src" />
 
 <path id="build.classpath" description="设置类路径">
  <fileset dir="${basedir}/lib">
   <include name="*.jar"></include>
  </fileset>
 </path>
 
 <target name="wsclientgen" description="生成webservice客户端辅助代码，执行后请刷新项目">
  <taskdef name="wsimport" classname="com.sun.tools.ws.ant.WsImport"
   classpathref="build.classpath"/>
  <wsimport wsdl="http://localhost:8090/WebService/OrderServiceBean?wsdl"
   sourcedestdir="${src.dir}"  package="cn.ztf.ws.client" keep="true"
    verbose="true" destdir="${basedir}/bin"/>
 </target>
</project>

4.借助辅助类调用Web Service。

1.java消息驱动bean属于Java消息服务(Java Message Service，简称JMS)。

2.JMS是用于访问企业消息系统的开发商中心的API。企业消息系统可以协助应用软件通过网络进行消息交互。

3.JMS的编程过程简单概括为：应用程序A-->(消息)-->Jboss JMS-->(消息)-->应用程序B。应用程序A和应用程序B没有直接的代码关联，两者实现了解耦。消息传递系统的中心就是消息。

消息驱动Bean(MDB)是设计用来专门处理基于消息请求的组件，它和无状态Session Bean一样也使用了实例池技术，容器可以使用一定数量的bean实例并发处理成百上千个JMS消息。正因为MDB具有处理大量并发消息的能力，所以非常适合应用在一些消息网关产品。如果一个业务执行的时间很长，而执行结果无需实时向用户反馈时，也很适合使用MDB。如订单成功后给用户发送一封电子邮件或发送一条短信等。

消息有下面几种类型，他们都是派生自Message接口。
StreamMessage：一种主体中包含Java基本值流的消息。其填充和读取均按顺序进行。
MapMessage：一种主体中包含一组名-值对的消息。(没有定义条目顺序)
TextMessage：一种主体中包含Java字符串的消息(例如：XML消息)
ObjectMessage：一种主体中包含序列化Java对象的消息。
BytesMessage：一种主体中包含连续字节流的消息。

消息的传递模型：
JMS支持两种消息传递模型：点对点(point-to-point，简称PTP)和发布/订阅(publish/subscribe，简称pub/sub)。
二者有以下区别：
1.PTP 消息传递模型规定了一条消息只能传递给一个接收方。采用javax.jms.Queue表示。
2.Pub/sub 消息传递模型允许一条消息传递给多个接收方。采用javax.jms.Topic表示。
注意：每种模型都通过扩展公用基类来实现。例如，javax.jms.Queue 和javax.jms.Topic都扩展自javax.jms.Destination 类。

开发步骤如下：
一、配置destinations-service.xml文件。
JBOSS使用一个XML文件配置队列地址，文件的取名格式应遵循*-service.xml，我取名为destinations-service.xml。
jboss默认的全局JNDI名称组成为："queue"+"/"+"目标地址"。
开始JMS编程前，我们需要先配置消息到达的目标地址(Destination)，因为只有目标地址存在了，我们才能发送消息到这个地址。由于每个应用服务器关于目标地址的配置方式都有所不同，下面以jboss为例，配置一个queue类型的目标地址。
<?xml version="1.0" encoding="UTF-8"?>
<server>
   <mbean code="org.jboss.mq.server.jmx.Queue" 

name="jboss.mq.destination:service=Queue,name=ztfQueue">
      <attribute name="JNDIName">queue/ztfQueue</attribute>
      <depends optional-attribute-

name="DestinationManager">jboss.mq:service=DestinationManager</depends>
    </mbean>
   <mbean code="org.jboss.mq.server.jmx.Topic" 

name="jboss.mq.destination:service=Topic,name=ztfTopic">
      <attribute name="JNDIName">topic/ztfTopic</attribute>
      <depends optional-attribute-

name="DestinationManager">jboss.mq:service=DestinationManager</depends>
    </mbean>
</server>
注意：任何队列或主题被部署之前，应用服务器必须先部署Destination Manager Mbean，所有我们通过<depends>节点声明这一依赖。

二、在java类中发送消息(用到jndi.properties)。
一般发送消息有以下步骤：
1.得到一个JNDI初始化上下文(Context)
InitialContext ctx = new InitialContext();

2.根据上下文查找一个连接工厂ConnectionFactory，改连接工厂是由JMS提供的，不需我们自己创建，每个厂商都为它绑定了一个全局JNDI，我们通过它的全局JNDI便获取它；
QueueConnectionFactory factory = (QueueConnectionFactory)ctx.lookup("ConnectionFactory");

3.从连接工厂得到一个连接QueueConnection。
QueueConnection conn = factory.createQueueConnection();

4.通过连接来建立一个会话(Session);
QueueSession session = conn.createQueueSession(false,QueueSession.AUTO_ACKNOWLEDGE);
这句代码意思是：建立不需要事务的并且能自动确立消息已接收的会话。

5.查找目标地址：
Destination destination=(Destination)ctx.lookup("queue/ztfQueue");

6.根据会话以及目标地址来建立消息生产者MessageProducer(QueueSender和TopicPublisher都扩展自MessageProducer接口)：
MessageProducer producer = session.createProducer(destination);
TextMessage msg = session.createTextMessage("您好：荆州，这是我的第一个消息驱动Bean");
producer.send(msg);

三、采用MessageDrivenBean接收消息。
当容器检测到bean守候的目标地址有消息到达时，容器调用onMessage()方法，将消息作为参数传入MDB。MDB在onMessage()中决定如何处理改消息。你可以使用注解指定MDB监听哪一个目标地址(Destination)。当MDB部署时，容器将读取其中的配置信息。

一个MDB通常要实现MessageListener接口，在接口定义了onMessage()方法。Bean通过它来处理收到的JMS消息。
@MessageDriven(activationConfig=
{
 @ActivationConfigProperty

(propertyName="destinationType",propertyValue="javax.jms.Queue"),
 @ActivationConfigProperty

(propertyName="destination",propertyValue="queue/ztfQueue"),
 @ActivationConfigProperty(propertyName="acknowledgeMode",propertyValue="Auto-

acknowledge")
})
public class MessageDrivenBean implements MessageListener{
 public void onMessage(Message message) {
  TextMessage msg = (TextMessage)message;
  try {
   System.out.println(msg.getText());
  } catch (JMSException e) {
   e.printStackTrace();
  }
 }
}

四、把工程src下的文件打成jar包(用到build.xml)，在C:\jboss-5.0.0.GA\server\default\deploy进行部署。

五、运行发送消息的java类，此时在console中就可看见结果了。

六、至此，一个MessageDrivenBean开发就成功了。

2.通过注解使实体bean与数据库表相映射。

3.当客户端远程调用EJB时，数据在传送工程中是需要序列化的 ，业务方法是要返回Entitybean对象到客户端，显然Entitybean对象是要进行序列化的过程，所以要实现序列化接口，即对象在交互时需要实现序列化。

4.Entitybean主键值的生成方式。
@GeneratedValue(strategy = GenerationType.IDENTITY)针对Mysql，
@GeneratedValue(strategy = GenerationType.SEQUENCE)针对Oracle,
@GeneratedValue(strategy = GenerationType.AUTO)自动匹配数据库。

5.需要保留一个无参的构造函数，是JPA规范要求的，如果没有，在运行时是要报错的。

6.对象之间的比较，通常采用对象标志属性来进行比较，也就是ID进行比较，因此现在重载hashCode、equals两个方法。

JPA的出现主要是为了简化现有的持久化开发工作和整合ORM技术，目前实现的JPA规范的主流产品有Hibernate、Toplink和OpenJPA，在jboss中采用了Hibernate作为其持久化实现产品。

根据JPA规范的要求：在实体bean应用中，我们需要在应用的类路径下的META-INF目录加入持久化配置文件persistence.xml。
persistence.xml文件用于指定Entitybean使用的数据源及EntityManager对象的默认行为。
persistence.xml的配置说明如下：
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
 http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">
 
 <!--  一个持久化单元是一个Entitybean的集合，JTA代表全局事物。-->
 <persistence-unit name="ztf" transaction-type="JTA">
  <jta-data-source>java:/ztfDS</jta-data-source>
  <properties>
   <!-- 根据元数据生成数据库的表结构。 -->
   <property name="hibernate.hbm2ddl.auto" value="update"/>
   <!-- 显示执行的SQL。 -->
   <property name="hibernate.show_sql" value="true"/>
   <!-- 格式化显示的SQL 。 -->
   <property name="hibernate.format_sql" value="true"/>
   <!-- SQL方言。 -->
   <property name="hibernate.dialect" value="org.hibernate.dialect.Oracle9Dialect"/>
  </properties>
 </persistence-unit>
</persistence>

注意：因为jboss 采用Hibernate，Hibernate 有一项属性hibernate.hbm2ddl.auto，该属性指定实体Bean发布时是否同步数据库结构。

1.如果hibernate.hbm2ddl.auto的值设为create-drop，在实体Bean发布及卸载时将自动创建及删除相应数据库表(注意：Jboss 服务器启动或关闭时也会引发实体Bean 的发布及卸载)。

2.如果hibernate.hbm2ddl.auto的值设为update,以后为了实体bean的改动能反应到数据表，建议使用update，这样实体Bean 添加一个属性时能同时在数据表增加相应字段。

本地接口调用ejb的过程：
通过本地接口调用ejb，直接在内存交互，这样就可以避免因网络通信所造成的各种性能开销。
注意：
1.只有客户端与EJB应用都在同一个JVM内运行的时候，我们才能调用本地接口，否则只能调用远程接口。
2.只要客户端与ejb发布在同一个jboss内，我们就认为它们在同一个JVM。
3.客户端可以调用本地接口；也可调用远程接口；当本地接口与远程接口都有同一个方法时，优先调用本地接口中的方法。

开发一个自己的远程接口的无状态会话bean：
1.需要自己开发的EJB的组件.jar包。
注意：在实现类中加入注解，绑定接口。
@Stateless、@Remote(HelloWorld.class) //为接口。
2.需要自己开发出的EJB的客户端，并把客户端工程打成.war文件。
注意：客户端所要知道的JNDI名称，下面的HelloWorld 为远程接口。
InitialContext ctx = new InitialContext();
HelloWorld helloWorld = (HelloWorld)ctx.lookup("HelloWorldBean/remote");
out.println(helloWorld.sayHello("荆州"));
3.把.jar和.war文件拷贝到jboss的deploy区。
4.打开浏览器，输入自己开发出的EJB客户端的.jsp页面，即可。

开发一个自己的本地接口的无状态会话bean：
1.需要自己开发的EJB的组件.jar包。
注意：在实现类中加入注解，绑定接口。
@Stateless、@Local(HelloWorldLocal.class)//接口。
2.需要自己开发出的EJB的客户端，并把客户端工程打成.war文件。
注意：客户端所要知道的JNDI名称，下面的HelloWorldLocal 为本地接口。
InitialContext ctx = new InitialContext();
HelloWorldLocal helloWorld = (HelloWorldLocal)ctx.lookup("HelloWorldLocalBean/local");
out.println(helloWorld.sayHello("荆州"));
3.把.jar和.war文件拷贝到jboss的deploy区。
4.打开浏览器，输入自己开发出的EJB客户端的.jsp页面，即可。

Bean实例的两种管理技术：
1.无状态bean使用实例池技术管理bean；
2.有状态bean使用激活(activation)管理bean。

Jboss生成的JNDI名称，默认命名规则如下：
如果把EJB应用打包成后题为.jar的模块文件，默认的全局JNDI名称是
本地接口：EJB-CLASS-NAME/local
远程接口：EJB-CLASS-NAME/remote
例如：把EJB-HelloWorld(里面包含接口HelloWorld和实现类HelloWorldBean)应用打包成EJB-HelloWorld.jar文件，它的远程接口的JNDI名称是：HelloWorldBean/remote。

jndi.properties的配置：
java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.provider.url=localhost:1099

下面介绍Elispse 打包向导和Ant 打包任务。
1. Elispse 打包向导
在Elispse 开发环境下，可以通过向导进行打包。右击项目名称，在跳出的菜单中选择Export-->Java-->JAR file，在"选择要导出的资源"时，选择源目录和用到的资源然，后选择一个存放目录及文件名，点"完成"就结束了打包。

2. Ant 打包任务
主要是在Eclipse下，通过配置build.xml进行ANT 打包，来提高开发效率,也是推荐的打包方式。
下面我们看一个简单的打包任务。
<?xml version="1.0" encoding="UTF-8"?>
<project name="EJB-HelloWorld" basedir=".">
<property name="src.dir" value="${basedir}\src" />
<property environment="env" />
<property name="jboss.home" value="${env.JBOSS_HOME}" />
<property name="jboss.server.config" value="default" />
<property name="build.dir" value="${basedir}\build" />

<path id="build.classpath">
<fileset dir="${jboss.home}\client">
<include name="*.jar"></include>
</fileset>
<pathelement location="${build.dir}"/>
</path>

<target name="prepare">
<delete dir="${build.dir}"/>
<mkdir dir="${build.dir}"/>
</target>

<target name="compile" depends="prepare" description="编译 ">
<javac srcdir="${src.dir}" destdir="${build.dir}">
<classpath refid="build.classpath" />
</javac>
</target>

<target name="ejbjar" depends="compile" description="创建EJB发布包">
<jar jarfile="${basedir}\${ant.project.name}.jar" >
<fileset dir="${build.dir}" >
<include name="**/*.class"></include>
</fileset>
</jar>
</target>

<target name="deploy" depends="ejbjar" description="发布EJB">
<copy file="${basedir}\${ant.project.name}.jar" todir="${jboss.home}\server\${jboss.server.config}\deploy"/>
</target>

<target name="undeploy" description="卸载EJB">
<delete file="${jboss.home}\server\${jboss.server.config}\deploy\${ant.project.name}.jar"/>
</target>
</project>

再右健点击此配置文件build.xml，选择Run As-->Ant Build即可！

采用EJB开发基于MVC（包含显示层、控制层和业务层）结构的应用，那么EJB就是用于开发应用的业务层。

开发EJB遵循如下步骤进行：
1.开发构成EJB组件的Java源文件，比如：组件接口、Home接口、企业Bean类、所需的辅助类等。
2.手工完成部署描述符，或者借助与IDE。
3.编译步骤1开发的java源文件.
4.借助于JDK自带的jar使用工具，来创建含有部署描述符和.class文件的EJB-jar文件。
5.通过具体EJb容器提供的部署建议，来完成Ejb-jar文件的部署。
6.配置EJB服务器，使得Ejb-jar含有的Ejb组件能够正常运作。
7.启动EJB服务器。此时，开发者可以验证EJB组件是否部署成功,并运行。
    
EJB3.0规范定义了如下3种EJB组件类型：
1、会话Bean(SessionBean)：无状态会话Bean(Stateless SessionBean)、有状态会话Bean(Stateful SessionBean)。
会话Bean通常有以下属性：
（1）代表单个客户机执行。
（2）可以是事务的。
（3）可以更新共享数据库中的数据。
（4）生存期相对较短。
（5）其生存期通常就是客户机的生存期。
（6）任何持久性数据都有Bean管理。
（7）可以依容器的判断予以删除。
（8）会在EJB服务器失败时被删除。
      EJB容器管理无状态会话Bean的生存周期，其方式是通过创建足够多数量的此种Bean适应客户机工作负荷,并在不需要它们的时候将其删除或者将闲置的Bean写到磁盘上。
      如果会话Bean在方法调用之前需要保留状态信息，则必须使用有状态的会话Bean(Stateful SessionBean)。
     会话Bean在J2EE应用程序中被用来完成一些服务器端的业务操作，例如访问数据库、调用其他EJB组件。
     总之，会话Bean代表一种操作：它检索或者存储数据以满足用户的请求。

2、实体Bean(EntityBean)，通常有以下属性:
（1）代表数据库的数据。
（2）是事务性的。
（3）允许多个用户共同访问。
（4）可以长期存在。
（5）持久性数据可以由容器管理。
（6）在EJB服务器失败后能继续生存。
      实体Bean被用来代表应用数据库中用到的数据。例如在一个电子商务系统中，实体Bean可以被用来代表产品、雇员、信用卡、订单数据等数据对象。
      持久性是实体Bean的一个基本属性。EJB规范允许两种形式的实体持久性:Bean管理的持久性(BMP)和容器管理的持久性(CMP)。
      实体Bean支持多个用户并发的访问数据。EJB规范说明，维护数据的完整性是容器的责任。容器完成这个任务通常的做法是，锁定数据库中的数据，并使访问串行化，或者通过创建多个实体Bean的实例，并允许在基础数据存储中使用并发控制，来管理访问。
     总之，实体Bean代表一种数据集：可以访问这些数据集以满足用户的请求。

3、消息驱动bean(Message DrivenBean)
     消息驱动Bean要与JMS结合使用，以提供消息驱动的异步处理功能。例如电子商务系统的交易确认就可以用消息驱动Bean来实现。
     消息驱动Bean作为JMS队列和主题的监听器部署，当有JMS消息到达，系统就会调用消息驱动Bean去完成业务逻辑方法。
     总之，客户机不能直接调用消息驱动Bean，客户通过发送JMS消息调用消息驱动Bean。