EJB3.0 企业开发

什么是EJB
Enterprice JavaBean是一个用于分布式业务应用的标准服务端模型。采用Enterprice JavaBean架构编写的应用是可伸的、事务性的、多用户安全的。采用EJB编写的这些应用，可以部署在任何支持Enterprice JavaBeans规范的服务器平台，如jboss、weblogic等。
EJB实际干什么？
EJB实际上是用于编写业务层代码。如果大家对MVC（model-view-controller)结构的应用有所了解的话，我们知道一个基于MVC结构的应用包括显示层、控制层和业务层，假设我们采用EJB开发基于MVC结构的应用，那么EJB就是用于开发应用的业务层。
EJB为我们提供了很多在企业开发中需要使用到的服务，如事务管理/安全/持久化/分布式等，因为这些服务由容器提供，无需我们自行开发，这样大大减小了我们的开发工作量。
EJB3 VS Spring2.5
spring+hibernate同样提供了事务管理/持久化服务，如果你的应用不需要分布式能力，确实没必要使用ejb，因为spring+hibernate提供的有些服务比ejb做的更细致，那么，EJB3存在？因为ejb设计的初中是用于分布场合，而spring一开始就是没有打算提供分布功能，像ejb比较适合用于大型企业，因为大型企业一般都会存在多个信息系统，而这些信息系统又相互关联，为了避免业务功能重复开发，实现最大程度的重用，有必要把业务层独立出来，让多个信息系统共享一个业务中心，这样应用就需要具备分布式能力。
EJB3的分布式特点
非EJB的应用模式 在客户端 -》view、controller、model在同一个web容器中
EJB的应用模式 在客户端 -》view、controller、在web容器中 model在EJB容器中
《EJB3。0实例教程》免费电子版
下载地址：http://www.foshanshop.net

EJB3的运行环境
EJB3。0应用需要运行在JDK1.5以上版本。
进入http://java.sun.com/javase/downloads/index_jdk5.jsp下载JDK.在页面中找到JDK5。0Update 16(版本在不断更新中，),点击右边的download.
右键点击“我的电脑”-》“属性”-》“高级”-》“环境变量”，在“系统变量”里添加JAVA_HOME变量，值为JDK的安装路征。
在“系统变量”里再添加CLASSPATH变量，值为.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar.
在系统变量栏找到变量名path的选项，点头“编辑”在变量的末尾添加：%JAVA_HOME%\bin;
EJB3.0应用需要运行在EJB容器，下面是一些JAVAEE应用服务器，
JAVAEE应用服务器包含WEB容器和EJB容器
Jboss(4.2.x以上版本） Glassfish Weblogic(10以上版本） sun Application server(9.0以上版本) Oracle Application Server(10g版本) apusic应用服务器
注意：Tomcat目前只是web容器，它不能运行EJB应用。

开始JBoss
进入http://labs.jboss.com/jbossas/downloads/下载页面，解压后，便可以使用。
进入jboss的目录，找到启动脚本run.bat.双击run.bat即可启动jboss,此时启动的配制项为default.
如果安装出现问题，可以在环境变量中追加"%SystemRoot%\system32;%SystemRoot%;".
为了jboss系统正常工作，需要添加环境变量，JBOSS_HOME="D:\Server\jboss-4.2.2.GA".
为了方便输入jboss的命令，添加jboss的bin目录添加到系统路征里，path中，添加：%JBOSSS_HOME%\bin;

EJB中的三种bean
1。会话bean(session bean)
负责与客户端交互，是编写业务逻辑的地方，在会话bean中可以通过jdbc直接操作数据库，但大多数情况下通过实体bean来完成数据库的操作。
2。实体bean(entity bean)
它实际上属于java持久化规范（简化JPA）里的技术，JPA的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在Hibernate、
3。消息驱动bean(message-driven bean)
它是专门用于异步处理java消息的组件，具体处理大量并发消息的能力。
会话bean
无状态会话bean
平常，我们使用最多的是无状态bean，因为它的bean实例可供多个用户使用，所以它的性能比有状态bean高，正因为一个bean实例被多个用户使用，那么，前一个用户设置的值有可能被后一个用户所修改，所以它无法正确保存某个用户设置的值，因此是无状态的。
有状态会话bean
有状态bean平常使用的并不多，因为它的一个bean实例只供一个用户使用，所以性能开销比较大，正因为它的实例只被一个用户使用，那么，用户设置的值是不会被其它用户所修改，所以可以正确保存用户设置的值，因此是有状态的。

如何开发一个无状态会话bean
开发工具：Eclipse IDE for Java EE
下载地址：http://www.eclipse.org/downloads
开发EJB依赖的jar文件
可以在jboss安装路征的client目录下找到，通常会把client目录下的所有jar文件添加到项目的类路征下。

如何开发一个无状态会话bean
接口（接口可以是远程接口或者本地接口）

package cn.com.ejb3;

public interface HelloWorld {
    public String sayHello(String name);
}

实现类

package cn.com.ejb3.impl;

import javax.ejb.Remote;
import javax.ejb.Stateless;

import cn.com.ejb3.HelloWorld;

@Stateless
@Remote(HelloWorld.class)  //远程接口，默认是本地接口
public class HelloWorldBean implements HelloWorld {

	@Override
	public String sayHello(String name) {
		return name+"说：你好，中国！";
	}

}

打包成jar拷贝到jboss-4.2.2.GA\server\default\deploy下：
开发客户端：

package cn.com.test;

import java.util.Properties;

import javax.naming.InitialContext;
import javax.naming.NamingException;

import cn.com.ejb3.HelloWorld;

public class EJBClient {
	public static void main(String[] args) {
		Properties props = new Properties();   //设置JNDI访问环境信息
		props.setProperty("java.naming.factory.initial","org.jnp.interfaces.NamingContextFactory");
		props.setProperty("java.naming.provider.url", "localhost:1099");
		try {
			InitialContext ctx = new InitialContext(props);
			HelloWorld helloWorld = (HelloWorld) ctx
					.lookup("HelloWorldBean/remote");
			System.out.println(helloWorld.sayHello("张三"));
		} catch (NamingException e) {
			e.printStackTrace();
		}
	}
}

设置JNDI访问环境信息
如同数据库一样，根据访问命名服务器的不同，为上下文设置的驱动和URL也是不同的，如下面是访问sun应用服务器的上下文信息：
[quote]Properties props = new Properties();
props.setProperty("java.naming.factory.initial","com.sun.enterprise.naming.SerialInitContextFaction");//链接工厂
props.setProperty("java.naming.provider.url", "localhost:3700");
InitialContext ctx = new InitialContext(props);
HelloWorld helloWorld = (HelloWorld) ctx.lookup("HelloWorldBean/remote");[/quote]如果把EJB应用打包成后缀为*.jar的模块文件，默认的全局JNDI名称是
本地接口：EJB-CLASS-NAME/local
远程接口：EJB—CLASS——NAME/remote
例：把HelloWorld应用打包成HelloWorld.jar文件，它的远程名称是：HelloworldBean/remote
如果把EJB作为模块打包进后缀为*.ear的java EE企业应用文件，默认的全局JNDI名称是
本地接口：EAR-FILE—BASE—NAME/EJB-CLASS-NAME/local
远程接口：EAR-FILE-BASE-NAME/EJB-CLASS-NAME/remote
EAR-FILE-BASE-NAME为ear文件的名称，EJB-CLASS-NAME为EJB的非限定类名。
例：把HelloWorld应用作为EJB模块打包进为HelloWorld.ear的企业应用文件，它的远程接口的JNDI名称是：HelloWord/HelloworldBean/remote
第二个方法：创建新jndi.properties文件

java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.provider.url=localhost:1099

通过InitialContext构造方法，可以直接调用jndi.properties属性文件。

package cn.com.test;

import javax.naming.InitialContext;
import javax.naming.NamingException;
import cn.com.ejb3.HelloWorld;

public class EJBClient {
	public static void main(String[] args) {
		try {
			InitialContext ctx = new InitialContext();
			HelloWorld helloWorld = (HelloWorld) ctx
					.lookup("HelloWorldBean/remote");
			System.out.println(helloWorld.sayHello("张三"));
		} catch (NamingException e) {
			e.printStackTrace();
		}
	}
}

查看JNDI名称，http://127.0.0.1:8080/jmx-console/HtmlAdaptor，查看bean名称
通过ANT来打包、编译、发布、卸载

<?xml version="1.0" encoding="UTF-8"?>
<project name="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" />
      </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" />
          </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>

开发具有location接口的session bean
客户端需要与ejb建立起socket通信，在通信管道上他们之间需要来回发送IIOP协议消息，因为数据要在网络进行传输，存放数据的java对象必须要进行序列化。
————socket通信————>
客户端 EJB
<————IIOP消息——————
通过本地接口调用ejb,直接在内存交互，减少各种性能开销，只有客户端与EJB应用都在同一个JVM内运行的时候，我们才能调用本地接口，只要客户端与ejb发布在同一个jboss内，我们就认为他们在同一个JVM。

package cn.com.ejb.impl;

import javax.ejb.Local;
import javax.ejb.Remote;
import javax.ejb.Stateless;

import cn.com.ejb.HelloWorldLocal;
import cn.com.ejb.HelloWorldRemote;

@Stateless
@Remote(HelloWorldRemote.class)
@Local(HelloWorldLocal.class)
public class HelloWorldBean implements HelloWorldLocal, HelloWorldRemote {

	@Override
	public String sayHello(String name) {
		return name+"说：你好，中国！";
	}

}

import javax.naming.NamingException;

import cn.com.ejb.HelloWorldRemote;

public class EJBClient {

	public static void main(String[] args) {
		Properties props = new Properties();   //设置JNDI访问环境信息
		props.setProperty("java.naming.factory.initial","org.jnp.interfaces.NamingContextFactory");
		props.setProperty("java.naming.provider.url", "localhost:1099");
		try {
			InitialContext ctx = new InitialContext(props);
			HelloWorldRemote helloWorld = (HelloWorldRemote) ctx
					.lookup("HelloWorldBean/remote");
			System.out.println(helloWorld.sayHello("远程访问"));
		} catch (NamingException e) {
			e.printStackTrace();
		}
		}

}

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" import="javax.naming.InitialContext,javax.naming.NamingException,cn.com.ejb.HelloWorldLocal"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<%
try {
	InitialContext ctx = new InitialContext();
	HelloWorldLocal helloWorld = (HelloWorldLocal) ctx
			.lookup("HelloWorldBean/local");
	out.println(helloWorld.sayHello("本地访问"));
} catch (NamingException e) {
	e.printStackTrace();
}
%>
</body>
</html>

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

调用不同的EJB对象，
1、可以通过JNDI查找。
InitialContext ctx = new InitialContext();
OtherBean otherBean = (OtherBean) ctx.lookup("OtherBeanImpl/remote");
2、通过依赖注入
@EJB(beanName="OtherBean") OtherBean otherBean;
配制数据源
将java驱动拷贝到jboss安装目录server\default\lib下，将数据配制文件放入server\default\deploy
在jmx-console/下可以查看数据源,本次学习采用mysql,信息如下：

<jndi-name>MySqlDS</jndi-name>
    <connection-url>jdbc:mysql://localhost:3306/blog?useUnicode=true&characterEncoding=UTF-8</connection-url>
    <driver-class>com.mysql.jdbc.Driver</driver-class>
    <user-name>root</user-name>
    <password>root</password>
	<min-pool-size>3</min-pool-size>
	<max-pool-size>100</max-pool-size>
    <exception-sorter-class-name>org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter</exception-sorter-class-name>

[quote]name=MySqlDS,service=DataSourceBinding
name=MySqlDS,service=LocalTxCM
name=MySqlDS,service=ManagedConnectionFactory
name=MySqlDS,service=ManagedConnectionPool [/quote]选择name=MySqlDS,service=ManagedConnectionPool进入链接池，在些修改，只会对此操作有效，重启将会丢失。
在mysql配制文件修改，长期有效。
<min-pool-size>3</min-pool-size>
<max-pool-size>100</max-pool-size>

实体bean
它属于java持久化规范（简称JPA）里的技术，实体bean通过原数据在javabean和数据库表之间建立起映射关系，然后Java程序员就可以操纵数据库。JPA的出现在主要是为了简化现有的持久化开发工作和整合ORM技术，目前实现的JPA规范的主流产品有Hibernate、TopLink和OpenJPA,在jboss中采用了Hibernate作为其持久战化实现产品。
添加JPA的配制文件persistence.xml
根据JPA规范的要求：在实体bean应用中，我们需要在应用的类路征下的META-INF目录加入持久化配制文件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"
	version="1.0">
	<persistence-unit name="china" transactin-type="JTA">
		<jta-data-source>java:MySqlDS</jta-data-source>
		<properties>
			<!-- 根据源数据生成数据库表结构 -->
			<property name="hibernate.hbm2ddl.auto" value="update" />
			<!-- 显示最终执行的SQL -->
			<property name="hibernate.show_sql" value="truw" />
			<!-- 格式化显示的SQL -->
			<property name="hibernate.format_sql" value="true" />
		</properties>
	</persistence-unit>
</persistence>

实体bean

package cn.com.bean;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="person")
public class Person implements Serializable{

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((id == null) ? 0 : id.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		return true;
	}
	private static final long serialVersionUID = 1L;
	private Integer id;
    private String name;

    public Person() {
	}
	public Person(String name) {
		this.name = name;
	}
	@Id @Column(name="id")@GeneratedValue(strategy=GenerationType.AUTO)
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	@Column(name="name",length=50,nullable=false)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}


}

方法接口

package cn.com.servser;

import java.util.List;

import cn.com.bean.Person;

public interface PersonService {
    public void save(Person person);
    public void update(Person person);
    public void delete(Integer id);
    public Person getPerson(Integer id);
    public List<Person> list();
}

实现方法

package cn.com.servser.impl;

import java.util.List;

import javax.ejb.Remote;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import cn.com.bean.Person;
import cn.com.servser.PersonService;
@Stateless
@Remote(PersonService.class)
public class PersonServiceBean implements PersonService{
    @PersistenceContext EntityManager em;
	@Override
	public void save(Person person) {
		em.persist(person);
	}

	@Override
	public void update(Person person) {
		em.merge(person);
	}

	@Override
	public void delete(Integer id) {
		em.remove(em.getReference(Person.class, id));
	}

	@Override
	public Person getPerson(Integer id) {
		return em.find(Person.class, id);
	}

	@SuppressWarnings("unchecked")
	@Override
	public List<Person> list() {
		return em.createQuery("select p from Person p").getResultList();
	}

}

打包文件及属性文件

<?xml version="1.0" encoding="UTF-8"?>
<project name="EntityBean" 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" />
      </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}" includes="cn/**">
           <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" />
          </fileset>
       	  <metainf dir="${src.dir}\META-INF"></metainf>
       </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>

测试方法

package junit.test;

import java.util.List;
import javax.naming.InitialContext;
import org.junit.BeforeClass;
import org.junit.Test;
import cn.com.bean.Person;
import cn.com.servser.PersonService;

public class PersonServiceTest {
	private static PersonService personService;

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		try {
			InitialContext ctx = new InitialContext();
			personService = (PersonService) ctx
					.lookup("PersonServiceBean/remote");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@Test
	public void testSave() {
		personService.save(new Person("张三"));
	}

	@Test
	public void testUpdate() {
		Person person = personService.getPerson(1);
		person.setName("李四");
		personService.update(person);
	}

	@Test
	public void testDelete() {
		personService.delete(1);
	}

	@Test
	public void testGetPerson() {
		System.out.println(personService.getPerson(2).getName());
	}

	@Test
	public void testList() {
		List<Person> list = personService.list();
		for (Person person : list) {
			System.out.println(person.getName());
		}
	}

}

Java消息服务（Java Message Service）
Java消息服务（Java Message Service，简称JMS）是用于访问企业消息系统的开发商中立的API。企业消息系统可以协助应用软件通过网络进行消息交互。
JMS的编程过程很简单，概括为：应用程序序A发送一条消息到服务器的某个目的地（Destionation），然后消息服务器把消息转发给应用程序B。因为应用程序A和应用程序B没有直接的代码关联，所以两者实现了解偶。
JMS中的消息
消息传递系统的中心就是消息。一条Message由三个部分组成。
头（header），属性（property）和主体（body）。
消息有下面几种类型，他们都是派生自Message接口。
StreamMessage:一种主体中包含Java基元值流的消息。其填充和读取均按顺序进行。
MapMessage:一种主体中包含一组名——值对的消息。没有定义条目录顺序。
TestMessage:一种主体包含Java字符串的消息（例如：XML消息）。
ObjectMessage:一种主体中包含序列化Java对象的消息。
ByTesMessage:一种主体中包含连续字节流的消息。
消息的传递模型
JMS支持两种消息传递模型，点对象（point-to-point,简称PTP）和发布/订阅（publish/subscribc,简称pub/sub).这两种消息传递模型非常相似，但有以下区别。
PTP消息传递模型规定了一条消息只能传递传递给一个接收方。采用javax.jms.Queue表示。
pub/sub消息传递模型允许一条消息传递给多个接收方。采用java.jms.Topic表示
这两种模型都是通过扩展公用基类来实现。例如：javax.jms.Queue和javax.jms.Topic部扩展自javax.jms.Destination类。
配制目标地址
开始JMS编程前，我们需要配置消息到达的目标地址（Destionation),因为只有目录地址存在了，我们才能发送消息到达这个地址。由于每个应用服务器关于目标地址的配制方式都有所不同，下面一个queue类型的目标地址。

<?xml version="1.0" encoding="UTF-8"?>
<server>
 <mbean code="org.jboss.mq.server.jmx.Queue"
     name="jboss.mq.destination:service=Queue,name=chinaQueue">
   <attribute name="JNDIName">queue/chinaQueuep</attribute>
   <depends optional-attribute-name="DestinationManager">jboss.mq:service=DestinationManager</depends>
   </mbean>
</server>

jboss使用一个XML文件配置队列地址，文件的取名格式应遵守"-service.xml"
<attribute name="JNDIName">属性指定了该目标地址的全局JNDI名称。如果你不指定名称组成。另外在任何队列或主题被部署之前，应用服务器必须先部署Destionation Manager Mbean.所以我们通过<depends>节点声名这一依赖。
将配制文件布置到jboss中，
在java类中发送消息
一般发送消息有以下步骤：
（1）得到一个JNDI初始化上下文（Contex）
InitialContext ctx = new InitialContext();
(2)根据上下文查找一个连接工厂QueueConnectionFactory.该连接工厂是由JMS提供的，不需要我们自己创建，每个厂商都它绑定了一个全局JNDI，我们通过它的全局JNDI便于获取它；
QueueConnectionFactory factory = (QueueConnectionFactory) ctx.lookup("QueueConnectionFactory");
（3）从连接工厂得到一个连接
QueueConnection conn = factory.createQueueConnection();
（4）通过连接来建立一个会话（session）
QueueSession session = conn.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE);
这句话代码意思：建立不需要事务的并且能自动确认消息已接收的会话。
（5）查找目录地址：
Destination destination = (Destination) ctx.lookup("queue/chinaQueuep");
（6）根据会话以及目标地址来建立消息生产者MessageProduce(QueueSender和TOpicPublisher都扩展自MessageProducer接口）
例子对应代码：

package cn.com.app;

import javax.jms.Destination;
import javax.jms.MessageProducer;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSession;
import javax.naming.InitialContext;

public class QueueSender {

	public static void main(String[] args) {
		 try {
			InitialContext ctx = new InitialContext();
			QueueConnectionFactory factory = (QueueConnectionFactory) ctx.lookup("QueueConnectionFactory");
			QueueConnection conn = factory.createQueueConnection();
			QueueSession session = conn.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE);
			Destination destination = (Destination) ctx.lookup("queue/chinaQueuep");
			MessageProducer producer = session.createProducer(destination);
			producer.send(session.createTextMessage("你好！这是一个消息Bean"));
			session.close();
			conn.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

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

package javax.jms;
public interface MessageListener{
  public void onMessage(Message message);
}

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

package cn.com.message;

import javax.ejb.ActivationConfigProperty;
import javax.ejb.MessageDriven;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

@MessageDriven(activationConfig = {
		@ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"),
		@ActivationConfigProperty(propertyName = "destination", propertyValue = "queue/chinaQueuep"),
		@ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
})
public class MessageDrivenBean implements MessageListener {

	@Override
	public void onMessage(Message message) {
      TextMessage msg = (TextMessage) message;
      try {
		System.out.println(msg.getText());
	} catch (JMSException e) {
		e.printStackTrace();
	}
	}
}

发布/订阅消息传递模型
topic配制文件

<mbean code="org.jboss.mq.server.jmx.Topic"
     name="jboss.mq.destination:service=Topic,name=chinaTopic">
   <attribute name="JNDIName">topic/chinaTopic</attribute>
   <depends optional-attribute-name="DestinationManager">jboss.mq:service=DestinationManager</depends>
</mbean>

发送方：

package cn.com.app;

import javax.jms.Destination;
import javax.jms.MessageProducer;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicSession;
import javax.naming.InitialContext;

public class TopicSender {

	public static void main(String[] args) {
		 try {
			InitialContext ctx = new InitialContext();
			TopicConnectionFactory factory = (TopicConnectionFactory) ctx.lookup("TopicConnectionFactory");
			TopicConnection conn = factory.createTopicConnection();
			TopicSession session = conn.createTopicSession(false, TopicSession.AUTO_ACKNOWLEDGE);
			Destination destination = (Destination) ctx.lookup("topic/chinaTopic");
			MessageProducer producer = session.createProducer(destination);
			producer.send(session.createTextMessage("你好！这是一个Topic消息"));
			session.close();
			conn.close();
			System.out.println("发送完成！");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

接收方：

package cn.com.message;

import javax.ejb.ActivationConfigProperty;
import javax.ejb.MessageDriven;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

@MessageDriven(activationConfig = {
		@ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
		@ActivationConfigProperty(propertyName = "destination", propertyValue = "topic/chinaTopic"),
		@ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
})
public class ReceviveBean implements MessageListener {

	@Override
	public void onMessage(Message message) {
		 TextMessage msg = (TextMessage) message;
	      try {
			System.out.println(this.getClass()+msg.getText());
		} catch (JMSException e) {
			e.printStackTrace();
		}
	}

}

package cn.com.message;

import javax.ejb.ActivationConfigProperty;
import javax.ejb.MessageDriven;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

@MessageDriven(activationConfig = {
		@ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
		@ActivationConfigProperty(propertyName = "destination", propertyValue = "topic/chinaTopic"),
		@ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
})
public class ReceviveOtherBean implements MessageListener {

	@Override
	public void onMessage(Message message) {
		 TextMessage msg = (TextMessage) message;
	      try {
			System.out.println(this.getClass()+msg.getText());
		} catch (JMSException e) {
			e.printStackTrace();
		}
	}
}

WEB服务
WEB服务也是一种分布式技术，它与EJB最大的不同是，WEB服务属于行业规范，可以跨平台用语言，而EJB属于java平台的规范，尽管理在理论上是跨平台，但实现起来比复杂，所以其应用范围局限在了java平台。看上去两者好像是互相竞争的关系，其实不是，它们两者的偏重点不一样，WEB服务偏重的是这个系统对外提供什么功能，而EJB偏重的是如何使用一个个组件组装这些功能。就好比一个硬盘，它对外提供的是存储服务，这是WEB服务的关注点，对于怎样组装这个硬盘，怎样构造这些小零件，WEB服务并不关心，但这些是EJB所关注的。
JavaEE为web service提供情报两种不同的编程模型：EJB容器模型及Web容器模型，这里将以最新的JAX-WS2规范(Java API for XML-based Web Service)介绍webservice的开发(查看web服务http://127.0.0.1:8080/jbossws/ 下View a list of deployed services)

package cn.com.service.impl;

import java.util.ArrayList;
import java.util.List;
import javax.ejb.Remote;
import javax.ejb.Stateless;
import javax.jws.WebService;

import cn.com.bean.Order;
import cn.com.service.OrderService;

@WebService(targetNamespace="http://ws.com.cn",name="OrderService",
		serviceName="OrderServiceBean") //修改命名空间、接口、服务名称
@Stateless
@Remote(OrderService.class)
public class OrderServiceBean implements OrderService{
    @WebMethod  需要暴露的方法,如果设计此注解，其它没有设计方法的不暴露
	public String getUserName(String name) {
		return name;
	}

	public Order getOrder(String orderid) {
		Order order = new Order();
		order.setName("张三");
		order.setOrderid("A001");
		return order;
	}

	public List<Order> getOrders() {
		List<Order> list = new ArrayList<Order>();
		Order order = new Order();
		order.setName("张三");
		order.setOrderid("A001");
		list.add(order);
		return list;
	}

}

WEB服务的客户端口开发
开发步骤如下：
1、在应用的类路征下放入JAX-WS的jar文件（下载路征：http://jax-ws.dev.java.net).如果你使用的是JDK6，这一步可以省略，因为JDK6已经绑定了JAX-WS。目前JDK6绑定的JAX-WS版本是2.0。这意味着，当某些应用的JAX-WS版本高于2.0时。就有可能发生版本问题，这时，你需要升级JDK6中的JAX-WS版本，方法如下：
下载最高版本的JAX-WS，在产品lib目录中找到jaxws-api.jar和jaxb-api.jar,把这两个文件copy到JDK6_HOME/jre/lib/endorsed目录下。
如果使用开发工具是myeclipse，这时应用把myeclipse所使用的jdk更改为你系统安装的jdk.
2、利用Web Service客户端生成工具生成辅助类。
3、第三步，借助辅助类调用Web service.

<?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"/>
	     </fileset>
	</path>


   <target name="wsclientgen" description="生成webservice客户端辅助代码，执行后请刷新项目">
        <taskdef name="wsimport" classname="com.sun.tools.ws.ant.WsImport" classpathref="build.classpath"/>
    	<wsimport wsdl="http://localhost:8080/WsHelloWorld/HelloworldBean?wsdl"
    	   sourcedestdir="${src.dir}" package="cn.com.ws.client" keep="true"
    	   verbose="true" destdir="${basedir}/bin" />
    </target>
</project>