JBoss EAP应用服务器部署方法和JBoss 开发JMS消息服务小例子

一、download JBoss-EAP-6.2.0GA： http://jbossas.jboss.org/downloads

JBoss Enterprise Application Platform(JBoss EAP)作为Redhat公司的商业产品是一个更加关注企业级特性和稳定性的实用部署版为了与JBoss Application Server(JBoss AS) 为了使这两个产品有差异化避免用户混淆因此 
RedHat公司在2013年4月将JBoss AS正式更名为WildFly改名后的首个版本为WildFly 8，将接棒JBoss AS 7。RedHat公司表示，新版本不仅是名称上的变化，还带来了如下改进：
1.启动超快
2.模块化设计
3.非常轻量，内存占用非常少

4.更优雅的配置、管理方式
5.严格遵守Java EE7和OSGi规范
目前最新版本是8.1.0.Final http://download.jboss.org/wildfly/8.1.0.Final/wildfly-8.1.0.Final.zip

JBoss AS 7 :http://download.jboss.org/jbossas/7.1/jboss-as-7.1.1.Final/jboss-as-7.1.1.Final.zip

二、安装JBoss EAP 将下载的ZIP包解压到一个目录中例如：E:\jboss-eap-6.2
(1) JBOSS7 启动：
  以standalone模式运行服务器：
  /bin/standalone.sh      (Unix / Linux)  
  \bin\standalone.bat     (Windows) 
如果你需要允许远程和本地都能连接jboss，那么将启动时指定-b参数 standalone.bat -b 0.0.0.0

或者通过修改配置文件的方式：

standalone.bat --server-config standalone-full.xml启动时指定配置文件默认是standalone.xml配置信息。    
  domain模式运行服务器：
  /bin/domain.sh      (Unix / Linux)  
  \bin\domain.bat     (Windows)  
(2) JBOSS7 停止：    
  /bin/jboss-cli.bat --connect --command=:shutdown   或者ctrl + c 组合键
  /bin/jboss-cli.sh --connect --command=:shutdown    或者ctrl + c 组合键
三、启动JBoss EAP 6.2:


启动成功后访问：http://127.0.0.1:8080/ 进入JBoss EAP 6欢迎页面如下图

四、为JBoss EAP 添加一个管理员用户操作如下：

添加用户成功后访问：http://127.0.0.1:9990/console 弹出验证用户对话框，输入上一步中添加的用户名和密码。

验证成功后进入JBoss EAP后台管理页面：

五、接下配置JBoss JMS消息中间件：

(1)首先需要添加一个应用型用户操作如下：

JMS有两种模式 P2P，PUB/SUB

①P2P模型
在P2P模型中，有下列概念：消息队列(Queue)、发送者(Sender)、接收者(Receiver)。每个消息都被发 送到一个特定的队列，接收者从队列中获取消息。队列保留着消息，直到它们被消费或超时。每个消息只有一个消费者 (Consumer)（即一旦被消费，消息就不再在消息队列中）发送者和接收者之间在时间上没有依赖性，也就是说当发送者发送了消息之后，
不管接收者有没有正在运行，它不会影响到消息被发送到队列。接收者在成功接收消息之后需向队列应答成功如果你希望发送的每个消息都应该被成功处理 的话，那么你需要P2P模型。

适用场合：想让接收者进行且只进行一次处理组件之间进行同步通信

②Pub/Sub模型

在Pub/Sub模型中，有下列概念： 主题（Topic）、发布者（Publisher）、订阅者（Subscriber）。
客户端将消息发送到主题。多个发布者将消息发送到Topic，系统将这些消息传递给多个订阅者。
每个消息可以有多个消费者发布者和订阅者之间有时间上的依赖性 。针对某个主题(Topic)的订阅者， 
它必须创建一个订阅之后，才能消费发布者的消息，而且，为了消费消息，订阅者必须保持运行的状态。
当然，为了缓和这种严格的时间相关性，JMS允许订阅者创建一个可持久化的订阅。这样，即使订阅者
没有被激活（运行），它也能接收到发布者的消息。如果你希望发送的消息可以不被做任何处理、
或者被一个消费者处理、或者可以被多个消费者处理 的话，
那么可以采用Pub/Sub模型（也就是说发布者不关心有多少侦听者）。

关于时间的依赖性二种模型的实现结果：
对于p2p 模型的每个消息只能有一个消费者  如果我们定义二个消息接受者的Bean那么只能有一端会接收到消息。
当你把部署在Jboss中的消息接收Bean去掉以后，然后发送消息 此时消息在队列中，
一旦你重新部署他会立刻就接收到刚刚发送的消息 所以它没有时间的依赖性，
pub/sub 模型可以有多个消费者 在这个模型中如果我们定义多个接收消息的Bean当我们
在客户端发送消息的时候二个bean都会接收到消息，所以他有多个消费者 
但是如果你把Jboss部署中的消息接收bean去掉之后，发送消息。然后在重新部署，
那么消息也无法接收到 ，所以说他有时间的依赖性。

(2)在JBoss EAP console后台管理页面中创建queue消息队列，参考下图步骤：

进入jboss的管理控制台，找到Profile -> Subsystems -> Messageing -> Destinations -> view

这样就创建一个Queue，到目前为止，还没看到跟安全认证相关的设置，切换到Seurity Settings面板

可以看到，默认情况下，创建的Queue允许"guest"角色 "发送"消息（Send这里是true）、"接收"消息(Consume这里是true)，这就是为什么我们在第一步，要把添加的Jmsqueue这个用户加入guest组的原因了。

如果熟悉配置文件也可以通过直接编辑配置文件的方式配置queue消息队列:

E:\jboss-eap-6.2\standalone\configuration\standalone-full.xml找到

节点

在中间加入以下内容：

1. <hornetq-server>
2. <jms-destinations>
3. <jms-queue name="testQueue">
4. <entry name="java:jboss/exported/jms/queue/test"/>
5. <durable>true</durable>
6. </jms-queue>
7. </jms-destinations>
8. </hornetq-server>

(3)编写测试代码：   P2P模式：消息生产者代码如下：

1. package com.runsun;
2. import java.util.concurrent.CountDownLatch;
3. import java.util.concurrent.TimeUnit;
4. import java.util.logging.Logger;
5. import java.util.Properties;
6. import javax.jms.Connection;
7. import javax.jms.ConnectionFactory;
8. import javax.jms.Destination;
9. import javax.jms.MessageProducer;
10. import javax.jms.Session;
11. import javax.jms.TextMessage;
12. import javax.naming.Context;
13. import javax.naming.InitialContext;
14. /**
15. *

    Description:JMS客户端消息生产者

16. */
17. public class JMSProducer {
18. private static final Logger log = Logger.getLogger(JMSProducer.class.getName());
19. private static final String DEFAULT_MESSAGE = "这是第一条JMS信息.....";
20. private static final String DEFAULT_CONNECTION_FACTORY = "jms/RemoteConnectionFactory";
21. private static final String DEFAULT_DESTINATION = "jms/queue/test";
22. private static final String DEFAULT_MESSAGE_COUNT = "1";
23. private static final String DEFAULT_USERNAME = "Jmsqueue";
24. private static final String DEFAULT_PASSWORD = "queue@123";
25. private static final String INITIAL_CONTEXT_FACTORY = "org.jboss.naming.remote.client.InitialContextFactory";
26. private static final String PROVIDER_URL = "remote://localhost:4447";
27. public static void main(String[] args) throws Exception {
28. Context context=null;
29. Connection connection=null;
30. try {
31. // 设置上下文的JNDI查找
32. log.info("设置JNDI访问环境信息也就是设置应用服务器的上下文信息!");
33. final Properties env = new Properties();
34. env.put(Context.INITIAL_CONTEXT_FACTORY, INITIAL_CONTEXT_FACTORY);//  该KEY的值为初始化Context的工厂类,JNDI驱动的类名
35. env.put(Context.PROVIDER_URL, PROVIDER_URL);//  该KEY的值为Context服务提供者的URL.命名服务提供者的URL
36. env.put(Context.SECURITY_PRINCIPAL, DEFAULT_USERNAME);
37. env.put(Context.SECURITY_CREDENTIALS, DEFAULT_PASSWORD);//应用用户的登录名,密码.
38. // 获取到InitialContext对象.
39. context = new InitialContext(env);
40. log.info("初始化上下文,'JNDI驱动类名','服务提供者URL','应用用户的账户','密码'完毕.");
41. log.info("获取连接工厂!");
42. ConnectionFactory connectionFactory = (ConnectionFactory) context.lookup(DEFAULT_CONNECTION_FACTORY);
43. log.info("获取目的地!");
44. Destination destination = (Destination) context.lookup(DEFAULT_DESTINATION);
45. // 创建JMS连接、会话、生产者和消费者
46. connection = connectionFactory.createConnection(DEFAULT_USERNAME, DEFAULT_PASSWORD);
47. Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
48. MessageProducer producer = session.createProducer(destination);
49. connection.start();
50. int count = Integer.parseInt(DEFAULT_MESSAGE_COUNT);
51. // 发送特定数目的消息
52. TextMessage message = null;
53. for (int i = 0; i < count; i++) {
54. message = session.createTextMessage(DEFAULT_MESSAGE);
55. producer.send(message);
56. log.info("message:"+message);
57. log.info("message:"+DEFAULT_MESSAGE);
58. }
59. // 等待30秒退出
60. CountDownLatch latch = new CountDownLatch(1);
61. latch.await(30, TimeUnit.SECONDS);
62. } catch (Exception e) {
63. log.severe(e.getMessage());
64. throw e;
65. } finally {
66. if (context != null) {
67. context.close();
68. }
69. // 关闭连接负责会话,生产商和消费者
70. if (connection != null) {
71. connection.close();
72. }
73. }
74. }
75. }

运行代码控制台输出内容：

查看JBoss EAP 管理后台页面：

在运行两次：

P2P模式：消息消费者代码如下：

1. package com.runsun;
2. import java.util.Properties;
3. import java.util.concurrent.CountDownLatch;
4. import java.util.concurrent.TimeUnit;
5. import java.util.logging.Logger;
6. import javax.jms.Connection;
7. import javax.jms.ConnectionFactory;
8. import javax.jms.Destination;
9. import javax.jms.MessageConsumer;
10. import javax.jms.Session;
11. import javax.jms.TextMessage;
12. import javax.naming.Context;
13. import javax.naming.InitialContext;
14. public class JMSConsumer {
15. private static final Logger log = Logger.getLogger(JMSConsumer.class.getName());
16. private static final String DEFAULT_CONNECTION_FACTORY = "jms/RemoteConnectionFactory";
17. private static final String DEFAULT_DESTINATION = "jms/queue/test";
18. private static final String DEFAULT_USERNAME = "Jmsqueue";
19. private static final String DEFAULT_PASSWORD = "queue@123";
20. private static final String INITIAL_CONTEXT_FACTORY = "org.jboss.naming.remote.client.InitialContextFactory";
21. private static final String PROVIDER_URL = "remote://localhost:4447";
22. public static void main(String[] args) throws Exception {
23. ConnectionFactory connectionFactory = null;
24. Connection connection = null;
25. Session session = null;
26. MessageConsumer consumer = null;
27. Destination destination = null;
28. TextMessage message = null;
29. Context context = null;
30. try {
31. final Properties env = new Properties();
32. env.put(Context.INITIAL_CONTEXT_FACTORY, INITIAL_CONTEXT_FACTORY);
33. env.put(Context.PROVIDER_URL, PROVIDER_URL);
34. env.put(Context.SECURITY_PRINCIPAL, DEFAULT_USERNAME);
35. env.put(Context.SECURITY_CREDENTIALS, DEFAULT_PASSWORD);
36. context = new InitialContext(env);
37. connectionFactory = (ConnectionFactory) context.lookup(DEFAULT_CONNECTION_FACTORY);
38. destination = (Destination) context.lookup(DEFAULT_DESTINATION);
39. connection = connectionFactory.createConnection(DEFAULT_USERNAME, DEFAULT_PASSWORD);
40. session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
41. consumer = session.createConsumer(destination);
42. connection.start();
43. // 等待30秒退出
44. CountDownLatch latch = new CountDownLatch(1);
45. while (message == null) {
46. log.info("开始从JBOSS端接收信息-----");
47. message = (TextMessage) consumer.receive(5000);
48. latch.await(1, TimeUnit.SECONDS);
49. }
50. log.info("接收到的消息的内容:" + message.getText());
51. } catch (Exception e) {
52. log.severe(e.getMessage());
53. throw e;
54. } finally {
55. if (context != null) {
56. context.close();
57. }
58. if (connection != null) {
59. connection.close();
60. }
61. }
62. }
63. }

运行代码：

Pub/Sub模式测试代码：
编辑standalone-full.xml加入如下的代码：

1. package com.runsun;
2. import java.util.Properties;
3. import java.util.concurrent.CountDownLatch;
4. import java.util.concurrent.TimeUnit;
5. import javax.jms.JMSException;
6. import javax.jms.Session;
7. import javax.jms.TextMessage;
8. import javax.naming.Context;
9. import javax.naming.InitialContext;
10. import javax.naming.NamingException;
11. public class JMSSub {
12. private static final String DEFAULT_USERNAME = "Jmsqueue";
13. private static final String DEFAULT_PASSWORD = "queue@123";
14. private static final String INITIAL_CONTEXT_FACTORY = "org.jboss.naming.remote.client.InitialContextFactory";
15. private static final String PROVIDER_URL = "remote://localhost:4447";
16. /**
17. * @param args
18. * @throws NamingException
19. * @throws JMSException
20. * @throws InterruptedException
21. */
22. public static void main(String[] args) throws NamingException, JMSException, InterruptedException {
23. final Properties env = new Properties();
24. env.put(Context.INITIAL_CONTEXT_FACTORY, INITIAL_CONTEXT_FACTORY);
25. env.put(Context.PROVIDER_URL, System.getProperty(Context.PROVIDER_URL, PROVIDER_URL));
26. env.put(Context.SECURITY_PRINCIPAL, System.getProperty("username", DEFAULT_USERNAME));
27. env.put(Context.SECURITY_CREDENTIALS, System.getProperty("password", DEFAULT_PASSWORD));
28. InitialContext context = new InitialContext(env);
29. javax.jms.ConnectionFactory cf = (javax.jms.ConnectionFactory)context.lookup("jms/RemoteConnectionFactory");
30. javax.jms.Connection connection = cf.createConnection(DEFAULT_USERNAME, DEFAULT_PASSWORD);
31. boolean transacted = false;
32. javax.jms.Session session = connection.createSession(transacted, Session.AUTO_ACKNOWLEDGE);
33. javax.jms.Topic topic = session.createTopic("testTopic");
34. javax.jms.MessageConsumer consumer = session.createConsumer(topic);
35. consumer.setMessageListener(new javax.jms.MessageListener() {
36. public void onMessage(javax.jms.Message message)
37. {
38. try {
39. TextMessage tm = (TextMessage)message;
40. System.out.println("received message content: "+tm.getText().toString());
41. System.out.println("getJMSDestination: "+tm.getJMSDestination());
42. System.out.println("getJMSReplyTo: "+tm.getJMSReplyTo());
43. System.out.println("getJMSMessageID: "+tm.getJMSMessageID());
44. System.out.println("getJMSRedelivered: "+tm.getJMSRedelivered());
45. } catch (JMSException e) {
46. e.printStackTrace();
47. }
48. }
49. });
50. connection.start();
51. //等待30秒退出
52. CountDownLatch latch = new CountDownLatch(1);
53. latch.await(100, TimeUnit.SECONDS);
54. }
55. }

1. package com.runsun;
2. import java.io.BufferedReader;
3. import java.io.IOException;
4. import java.io.InputStreamReader;
5. import java.util.Properties;
6. import javax.jms.JMSException;
7. import javax.jms.Session;
8. import javax.jms.TextMessage;
9. import javax.naming.Context;
10. import javax.naming.InitialContext;
11. import javax.naming.NamingException;
12. public class JMSPub {
13. private static final String DEFAULT_USERNAME = "Jmsqueue";
14. private static final String DEFAULT_PASSWORD = "queue@123";
15. private static final String INITIAL_CONTEXT_FACTORY = "org.jboss.naming.remote.client.InitialContextFactory";
16. private static final String PROVIDER_URL = "remote://localhost:4447";
17. public static void main(String[] args) throws NamingException, JMSException, IOException {
18. final Properties env = new Properties();
19. env.put(Context.INITIAL_CONTEXT_FACTORY, INITIAL_CONTEXT_FACTORY);
20. env.put(Context.PROVIDER_URL, System.getProperty(Context.PROVIDER_URL, PROVIDER_URL));
21. env.put(Context.SECURITY_PRINCIPAL, System.getProperty("username", DEFAULT_USERNAME));
22. env.put(Context.SECURITY_CREDENTIALS, System.getProperty("password", DEFAULT_PASSWORD));
23. InitialContext context = new InitialContext(env);
24. javax.jms.ConnectionFactory cf = (javax.jms.ConnectionFactory)context.lookup("jms/RemoteConnectionFactory");
25. javax.jms.Connection connection = cf.createConnection(DEFAULT_USERNAME, DEFAULT_PASSWORD);
26. boolean transacted = false;
27. javax.jms.Session session = connection.createSession(transacted, Session.AUTO_ACKNOWLEDGE);
28. /**
29. * 在standalone-full.xml中找到 节点
30. * 在此节点下找到节点增加
31. *
32. */
33. javax.jms.Topic topic = (javax.jms.Topic)context.lookup("jms/topic/test");
34. javax.jms.MessageProducer producer = session.createProducer(topic);
35. BufferedReader msgStream = new BufferedReader(new InputStreamReader(
36. System.in));
37. String line = null;
38. boolean quitNow = false;
39. do {
40. System.out.print("输入要发送的消息：(数字0退出)");
41. line = msgStream.readLine();
42. if (line != null && line.trim().length() != 0) {
43. TextMessage textMessage = session.createTextMessage();
44. textMessage.setText(line);
45. producer.send(textMessage);
46. quitNow = line.equalsIgnoreCase("0");
47. }
48. } while (!quitNow);
49. }
50. }

运行JMSSub：

订阅者已经在监听消息：

接下来运行JMSPub消息发布者：

JMSPub控制台：

JMSub控制台：