hornetq 入门（1）
Hornetq 版本2.4.0final 需要JDK7及以上
step1.启动服务端
1.1准备配置文件（配置说明参考官网手册）
hornetq-configuration.xml
<configuration xmlns="urn:hornetq"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="urn:hornetq /schema/hornetq-configuration.xsd">
<!--
<broadcast-groups> <broadcast-group name="my-broadcast-group">
<local-bind-address>192.168.0.215</local-bind-address>
<local-bind-port>11212</local-bind-port>
<group-address>255.255.255.0</group-address>
<group-port>9876</group-port>
<broadcast-period>2000</broadcast-period> </broadcast-group>
</broadcast-groups>
-->
<name>HornetQ.main.config</name> <bindings-directory>F:/hornetq/data/messaging/bindings</bindings-directory> <large-messages-directory>F:/hornetq/data/messaging/largemessages</large-messages-directory> <paging-directory>F:/hornetq/data/messaging/paging</paging-directory> <!--离线消息固化到文件-->
<journal-directory>F:/hornetq/journal</journal-directory>
<journal-min-files>10</journal-min-files>
<!-- 缓存大小 -->
<id-cache-size>9000</id-cache-size>
<jmx-management-enabled>true</jmx-management-enabled>
<!-- 消息计数器 -->
<message-counter-enabled>true</message-counter-enabled>
<!-- keep history for a week -->
<message-counter-max-day-history>7</message-counter-max-day-history>
<!-- sample the queues every minute (60000ms) -->
<message-counter-sample-period>60000</message-counter-sample-period>
<persistence-enabled>true</persistence-enabled>
<!-- 通知将从JMS话题 "notificationsTopic"上接收
<management-notification-address>jms.queue.notificationsQueue</management-notification-address>
-->
<!--不配置这个的话会有一个安全警告-->
<cluster-user>HORNETQ.CLUSTER.ADMIN.USER</cluster-user>
<cluster-password>test65525</cluster-password> <!-- Connectors -->
<connectors>
<connector name="connector-netty">
<factory-class>org.hornetq.core.remoting.impl.netty.NettyConnectorFactory
</factory-class>
<param key="use-nio" value="true" />
<param key="host" value="localhost"/>
<param key="port" value="11212" />
</connector> <!-- SSL connector -->
<connector name="netty-ssl-connector">
<factory-class>org.hornetq.core.remoting.impl.netty.NettyConnectorFactory</factory-class>
<param key="host" value="localhost"/>
<param key="port" value="5500"/>
<param key="ssl-enabled" value="true"/>
<param key="key-store-path" value="F:/ssl/keystore"/>
<param key="key-store-password" value="test"/>
</connector>
</connectors> <!-- Acceptors -->
<acceptors>
<acceptor name="netty">
<factory-class>org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory
</factory-class>
<!-- -->
<param key="use-nio" value="true" />
<param key="host" value="0.0.0.0,127.0.0.1,localhost"></param>
<param key="port" value="11212" />
</acceptor> <!-- SSL connector -->
<acceptor name="netty-ssl-acceptor">
<factory-class>org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory</factory-class>
<param key="host" value="localhost"/>
<param key="port" value="5500"/>
<param key="ssl-enabled" value="true"/>
<param key="key-store-path" value="F:/ssl/keystore"/>
<param key="key-store-password" value="test"/>
<param key="trust-store-path" value="F:/ssl/truststore"/>
<param key="trust-store-password" value="test"/>
</acceptor>
</acceptors> <!-- Other config -->
<address-settings>
<address-setting match="jms.queue.#">
<redelivery-delay>5000</redelivery-delay>
<!-- 没有导致远程queue查找不到 -->
<expiry-address>jms.queue.expiryQueue</expiry-address>
<!-- 没有导致远程queue查找不到 -->
<last-value-queue>true</last-value-queue>
<max-size-bytes>100000</max-size-bytes>
<page-size-bytes>20000</page-size-bytes>
<redistribution-delay>0</redistribution-delay>
<address-full-policy>PAGE</address-full-policy>
<!-- 死信地址-->
<send-to-dla-on-no-route>true</send-to-dla-on-no-route>
<dead-letter-address>jms.queue.deadLetterQueue</dead-letter-address>
<max-delivery-attempts>3</max-delivery-attempts>
</address-setting>
</address-settings> <security-settings>
<!--security for example queue-->
<security-setting match="jms.queue.#">
<permission type="createDurableQueue" roles="guest" />
<permission type="deleteDurableQueue" roles="guest" />
<permission type="createNonDurableQueue" roles="guest" />
<permission type="deleteNonDurableQueue" roles="guest" />
<permission type="consume" roles="guest" />
<permission type="send" roles="guest" />
</security-setting>
</security-settings> </configuration>
hornetq-jms.xml
<configuration xmlns="urn:hornetq"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="urn:hornetq /schema/hornetq-jms.xsd"> <connection-factory name="ConnectionFactory">
<connectors>
<!--对应hornetq-configuration.xml 里面的connectors-->
<connector-ref connector-name="connector-netty" />
</connectors>
<entries>
<entry name="ConnectionFactory" />
<entry name="/ConnectionFactory" />
<entry name="XAConnectionFactory" />
<entry name="/XAConnectionFactory" />
<entry name="java:/ConnectionFactory"/>
<entry name="java:/XAConnectionFactory"/>
</entries> <retry-interval>1000</retry-interval>
<retry-interval-multiplier>1.5</retry-interval-multiplier>
<max-retry-interval>60000</max-retry-interval>
<reconnect-attempts>1000</reconnect-attempts>
<confirmation-window-size>1048576</confirmation-window-size>
</connection-factory> <!--jms address-->
<queue name="notificationsQueue">
<entry name="/queue/notificationsQueue"></entry>
</queue>
<queue name="testQueue">
<entry name="/queue/testQueue"/>
<selector string="color='red'"/>
<durable>true</durable>
</queue>
<!-- the dead letter queue where dead messages will be sent-->
<queue name="deadLetterQueue">
<entry name="/queue/deadLetterQueue"/>
</queue> </configuration>
1.2 启动hornetq服务
public static void startHornetqServer(){
try {
//config hornetq-configuration.xml
FileConfiguration config = new FileConfiguration();
config.start();
//HornetQServer
HornetQServer server=HornetQServers.newHornetQServer(config);
//JNPServer
StandaloneNamingServer standalone=new StandaloneNamingServer(server);
standalone.setBindAddress("0.0.0.0");
standalone.setRmiBindAddress("0.0.0.0");
standalone.start();
//JMSServer hornetq-jms.xml
jmsServer=new JMSServerManagerImpl(server);
jmsServer.start();
//start hornetq core server
server.start();
System.out.println(jmsServer.isStarted());
} catch (Exception e) {
e.printStackTrace();
}
}
step2.发送消息客户端
/**
* @param args
*/
public static void main(String[] args) {
try {
Properties prop = new Properties();
prop.setProperty("java.naming.factory.initial","org.jnp.interfaces.NamingContextFactory");
prop.setProperty("java.naming.provider.url", "jnp://127.0.0.1:1099");
prop.setProperty("java.naming.factory.url.pkgs","org.jboss.naming:org.jnp.interfaces");
prop.setProperty(Context.SECURITY_PRINCIPAL,"guest");
prop.setProperty(Context.SECURITY_CREDENTIALS, "guest"); Context ctx = new InitialContext(prop);
System.out.println("+++++++1111ssssssss");
//查找目标地址
Destination destination = (Destination)ctx.lookup("/queue/notificationsQueue");
System.out.println("+++++++2222"+destination); //根据上下文查找一个连接工厂 QueueConnectionFactory 。
//该连接工厂是由JMS提供的，不需我们自己创建，每个厂商都为它绑定了一个全局JNDI，我们通过它的全局JNDI便可获取它；
//ConnectionFactory 对应hornetq-jms.xml里面的 connection-factory name="ConnectionFactory"
ConnectionFactory factory = (ConnectionFactory)ctx.lookup("ConnectionFactory");
System.out.println("+++++++3333"+factory);
//从连接工厂得到一个连接 create QueueConnection
Connection conn = factory.createConnection();
System.out.println("+++++++4444"+conn);
conn.start(); //通过连接来建立一个会话(Session);
javax.jms.Session session = conn.createSession(true,Session.AUTO_ACKNOWLEDGE); //根据会话以及目标地址来建立消息生产者MessageProducer （QueueSender和TopicPublisher都扩展自MessageProducer接口）
MessageProducer producer = session.createProducer(destination);
TextMessage msg = session.createTextMessage("ffffffffffffffffffffffffffffffffffffffffffffff小心呈现出");
BytesMessage byteMessage=session.createBytesMessage();
byteMessage.writeBytes("testddddddddd".getBytes("utf-8"));
producer.send(msg);
producer.send(byteMessage);
System.out.println("send over !!!!!");
session.close();
conn.close();
System.out.println("send down===");
} catch (Exception e) {
e.printStackTrace();
} }
step3.接受消息客户端
public MessageReceive(String ...destinationJNDI){
QueueConnectionFactory factory=(QueueConnectionFactory)getJNDIRemoteObj("ConnectionFactory");
try {
if(factory==null)
return;
connection = factory.createConnection();
session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
connection.start();
for (int i = 0; i < destinationJNDI.length; i++) {
destination = (Queue) getJNDIRemoteObj(destinationJNDI[i]);
if(destination==null)
continue;
producer = session.createConsumer(destination);
//接受消息
producer.setMessageListener(new ReceiveMessage());
}
} catch (JMSException e) {
e.printStackTrace();
}
}
public static Object getJNDIRemoteObj(String jndiName) {
try {
Properties prop = new Properties();
prop.setProperty("java.naming.factory.initial","org.jnp.interfaces.NamingContextFactory");
prop.setProperty("java.naming.provider.url", "jnp://127.0.0.1:1099");
prop.setProperty("java.naming.factory.url.pkgs","org.jboss.naming:org.jnp.interfaces");
prop.setProperty(Context.SECURITY_PRINCIPAL,"guest");
prop.setProperty(Context.SECURITY_CREDENTIALS, "guest");
Context context = new InitialContext(prop);
return context.lookup(jndiName);
} catch (NamingException e) {
e.printStackTrace();
}
return null;
}
public class ReceiveMessage implements MessageListener {
@SuppressWarnings("deprecation")
@Override
public void onMessage(Message message) {
System.out.println("Received notification:"+new Date().toLocaleString());
try
{
// Enumeration propertyNames = message.getPropertyNames();
// while (propertyNames.hasMoreElements())
// {
// String propertyName = (String)propertyNames.nextElement();
// System.err.format(" %s: %s\n", propertyName, message.getObjectProperty(propertyName));
// }
HornetQDestination des=(HornetQDestination) message.getJMSDestination();
if(message instanceof TextMessage){
TextMessage mesg=(TextMessage)message;
System.out.println(des.getAddress()+"==received:"+mesg.getText());
}else if(message instanceof BytesMessage){
BytesMessage mesg=(BytesMessage)message;
ByteArrayOutputStream out=new ByteArrayOutputStream(((Long)mesg.getBodyLength()).intValue());
try {
byte[] r=new byte[2048];
int i=0;
while((i=mesg.readBytes(r))!=-1)
out.write(r,0,i);
System.out.println(des.getClass()+"==received:"+new String(out.toByteArray(),"utf-8"));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(message instanceof HornetQObjectMessage){
HornetQObjectMessage object=(HornetQObjectMessage)message;
Object msgObj=object.getObject();
if(msgObj instanceof ErrorMessageBO){
ErrorMessageBO messageBO=(ErrorMessageBO)msgObj;
String msg=messageBO.getMessageContent();
System.err.println("error:==>"+msg);
}
}
}
catch (JMSException e)
{
e.printStackTrace();
}
System.out.println("----------end--------------");
}
hornetq 入门（1）的更多相关文章
- JMS(Java消息服务)入门教程
什么是Java消息服务 Java消息服务指的是两个应用程序之间进行异步通信的API,它为标准消息协议和消息服务提供了一组通用接口,包括创建.发送.读取消息等,用于支持JAVA应用程序开发.在J2EE中 ...
- Spring Boot从入门到精通之：一、Spring Boot简介及快速入门
Spring Boot Spring Boot 简介 Spring Boot是由Pivotal团队提供的全新框架,其设计目的是用来简化新Spring应用的初始搭建以及开发过程.该框架使用了特定的方式来 ...
- Netty入门教程——认识Netty
什么是Netty? Netty 是一个利用 Java 的高级网络的能力,隐藏其背后的复杂性而提供一个易于使用的 API 的客户端/服务器框架. Netty 是一个广泛使用的 Java 网络编程框架(N ...
- Angular2入门系列教程7-HTTP（一）-使用Angular2自带的http进行网络请求
上一篇:Angular2入门系列教程6-路由(二)-使用多层级路由并在在路由中传递复杂参数 感觉这篇不是很好写,因为涉及到网络请求,如果采用真实的网络请求,这个例子大家拿到手估计还要自己写一个web ...
- ABP入门系列（1）——学习Abp框架之实操演练
作为.Net工地搬砖长工一名,一直致力于挖坑(Bug)填坑(Debug),但技术却不见长进.也曾热情于新技术的学习,憧憬过成为技术大拿.从前端到后端,从bootstrap到javascript,从py ...
- Oracle分析函数入门
一.Oracle分析函数入门 分析函数是什么?分析函数是Oracle专门用于解决复杂报表统计需求的功能强大的函数,它可以在数据中进行分组然后计算基于组的某种统计值,并且每一组的每一行都可以返回一个统计 ...
- Angular2入门系列教程6-路由（二）-使用多层级路由并在在路由中传递复杂参数
上一篇:Angular2入门系列教程5-路由(一)-使用简单的路由并在在路由中传递参数 之前介绍了简单的路由以及传参,这篇文章我们将要学习复杂一些的路由以及传递其他附加参数.一个好的路由系统可以使我们 ...
- Angular2入门系列教程5-路由（一）-使用简单的路由并在在路由中传递参数
上一篇:Angular2入门系列教程-服务 上一篇文章我们将Angular2的数据服务分离出来,学习了Angular2的依赖注入,这篇文章我们将要学习Angualr2的路由 为了编写样式方便,我们这篇 ...
- Angular2入门系列教程4-服务
上一篇文章 Angular2入门系列教程-多个组件,主从关系 在编程中,我们通常会将数据提供单独分离出来,以免在编写程序的过程中反复复制粘贴数据请求的代码 Angular2中提供了依赖注入的概念,使得 ...
随机推荐
- jemter转换报告生成html格式报告
前言: 结合上篇,因为使用Jenkins做集成,jmeter的结果肯定需要生产一个报告,如果按原本的jmt格式生成,肯定是不行的,现在就需要对报告格式进行转换 使用工具: ant:jmeter可以通过 ...
- 10 Best TV Series Based On Hacking And Technology
Technology is rapidly becoming the key point in human lives. Here we have discussed top TV shows whi ...
- NodeJS学习之异步编程
NodeJS -- 异步编程 NodeJS最大的卖点--事件机制和异步IO,对开发者并不透明 代码设计模式 异步编程有很多特有的代码设计模式,为了实现同样的功能,使用同步方式和异步方式编写代码会有很大 ...
- Java之累加和
所谓累加算法,就是数学中数列求的算法,这都是司空见惯了的.下面我们用java求: package com.cdp.leijiahe; import java.util.Scanner; public ...
- AJAX之JSON
AJAX=Asynchronous JavaScript and XML(异步的JavaScript 和XML). AJAX不是新的编程语言,而是一种是用现代标准的新方法,用于创建快速动态网页的技术. ...
- js 获取url 参数
$(function () { var WeixinCode = GetQueryString("WeixinCode"); $("#ProXQ").attr( ...
- python基础:day3作业
修改haproxy配置文件 基本功能:1.获取记录2.添加记录3.删除记录 代码结构:三个函数一个主函数 知识点:1.python简单数据结构的使用:列表.字典等 2.python两个模块的使用:os ...
- Coarse-Grained lock 粗粒度锁
用一个锁Lock一组相关的对象 有时,需要按组来修改多个对象. 这样,在需要锁住其中一个的时候,必须连带地将其他的对象都上锁. 为每一个对象都加上一个锁是很繁琐的. 粗粒度锁是覆盖多个对象的单个锁. ...
- java synchronized关键字浅探
synchronized 是 java 多线程编程中用于使线程之间的操作串行化的关键字.这种措施类似于数据库中使用排他锁实现并发控制,但是有所不同的是,数据库中是对数据对象加锁,而 java 则是对将 ...
- LeetCode Weekly Contest 12
1. 第一题 看完题目后,肯定先对houses和heaters排序,然后考虑贪心可以么,我那时候没有想出来,然后看到可以O(n)的判断一个半径是否满足要求,就对半径[0,1e9]进行二分,然后就a了. ...