不为有趣之事,何遣有涯之生
不失其所者久,死而不亡者寿

AMQ简明教程(5)

hzqiuxm阅读(395)评论(0)

JMS的API开发步骤

JMS开发的基本步骤

1:创建一个JMS connection factory
2:通过connection factory来创建JMS connection
3:启动JMS connection
4:通过connection创建JMS session
5:创建JMS destination
6:创建JMS producer,或者创建JMS message,并设置destination
7:创建JMS consumer,或者是注册一个JMS message listener
8:发送或者接受JMS message(s)
9:关闭所有的JMS资源(connection, session, producer, consumer等)

下面是JMS的API结构图

对于非持久的Topic消息的发送

基本跟前面发送队列信息是一样的,只是把创建Destination的地方,由创
建队列替换成创建Topic,例如:

Destination destination = session.createTopic("MyTopic");

对于非持久的Topic消息的接收

1:必须要接收方在线,然后客户端再发送信息,接收方才能接收到消息
2:同样把创建Destination的地方,由创建队列替换成创建Topic,例如:

Destination destination = session.createTopic("MyTopic");

3:由于不知道客户端发送多少信息,因此改成while循环的方式了,例如:

Message message = consumer.receive();
while(message!=null) {
TextMessage txtMsg = (TextMessage)message;
System.out.println("收到消息:" + txtMsg.getText());
message = consumer.receive(1000L);
} 

下面是一个详细例子:

package jmstest.topic;

import org.apache.activemq.ActiveMQConnectionFactory;

import javax.jms.*;

/**
 * Created by hzqiuxm on 2015/5/30.
 * 非持久topic消息发送
 */
public class topicSend {

    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.1.55:61616");
        Connection connection = connectionFactory.createConnection();
        connection.start();

        //开启事务,消息确认方式为自动
        Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
        //创建队列
        Destination destination = session.createTopic("my-topic");
        //生产者把消息传送到队列中
        MessageProducer producer = session.createProducer(destination);
        for(int i=0; i<3; i++) {
            TextMessage message = session.createTextMessage("message no persister--"+i);
//            Thread.sleep(1000);
            //通过消息生产者发出消息
            producer.send(message);
        }
        session.commit();
        session.close();
        connection.close();
    }
}
package jmstest.topic;

import org.apache.activemq.ActiveMQConnectionFactory;

import javax.jms.*;

/**
 * Created by hzqiuxm on 2015/5/30.
 * 非持久的topic接收
 */
public class topicReceive {

    public static void main(String[] args) throws Exception {
        ConnectionFactory cf = new ActiveMQConnectionFactory("tcp://192.168.1.55:61616");
        Connection connection = cf.createConnection();
        connection.start();
        //开启事务,

        final Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
        Destination destination = session.createTopic("my-topic");
        MessageConsumer consumer = session.createConsumer(destination);

        Message message = consumer.receive();
        while(message!=null) {
            TextMessage txtMsg = (TextMessage)message;
            System.out.println("收到消息:" + txtMsg.getText());
            message = consumer.receive(1000L);
        }
        session.commit();
        session.close();
        connection.close();
    }
}

先启动生产者,再启动消费者,会发现消费者接受不到消息。
进入MQ的界面中查看:

消息有3条,有一个消费者,但消费的消息为0

再执行一次生产者,进行查看

对于持久的Topic消息的发送

ConnectionFactory connectionFactory = new
ActiveMQConnectionFactory("tcp://192.168.1.106:61616");
Connection connection = connectionFactory.createConnection();
Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
Topic destination = session.createTopic("MyTopic");
MessageProducer producer = session.createProducer(destination);
producer.setDeliveryMode(DeliveryMode.PERSISTENT);
connection.start();
for(int i=0; i<2; i++) {
TextMessage message = session.createTextMessage("messagedd--"+i);
Thread.sleep(1000);
//通过消息生产者发出消息
producer.send(message);
}
session.commit();
session.close();
connection.close();

1:要用持久化订阅,发送消息者要用DeliveryMode.PERSISTENT 模式发现,在连接之前设定
2:一定要设置完成后,再start 这个connection

对于持久的Topic消息的接收

ConnectionFactory cf = new ActiveMQConnectionFactory("tcp://192.168.1.106:61616");
Connection connection = cf.createConnection();
connection.setClientID("cc1");
final Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
Topic destination = session.createTopic("MyTopic");
TopicSubscriber ts = session.createDurableSubscriber(destination, "T1");
connection.start();
Message message = ts.receive();
while(message!=null) {
TextMessage txtMsg = (TextMessage)message;
session.commit();
System.out.println("收到消息:" + txtMsg.getText());
message = ts.receive(1000L);
}
session.close();
connection.close();

1:需要在连接上设置消费者id,用来识别消费者
2:需要创建TopicSubscriber来订阅
3:要设置好了过后再start 这个connection
4:一定要先运行一次,等于向消息服务中间件注册这个消费者,然后再运行客户端发送信息,这个时候,
无论消费者是否在线,都会接收到,不在线的话,下次连接的时候,会把没有收过的消息都接收下来。

详细例子:

package jmstest.topic;

import org.apache.activemq.ActiveMQConnectionFactory;

import javax.jms.*;

/**
 * Created by Administrator on 2015/6/1.
 * 持久化topic发送者
 */
public class perTopicSend {
    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.1.55:61616");
        Connection connection = connectionFactory.createConnection();

        //开启事务,消息确认方式为自动
        Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
        //创建队列
        Destination destination = session.createTopic("my-topic");
        //生产者把消息传送到队列中
        MessageProducer producer = session.createProducer(destination);

        //设置持久化投递方式后再启动
        producer.setDeliveryMode(DeliveryMode.PERSISTENT);
        connection.start();

        for(int i=0; i<3; i++) {
            TextMessage message = session.createTextMessage("message persister11--"+i);
            //通过消息生产者发出消息
            producer.send(message);
        }
        session.commit();
        session.close();
        connection.close();
    }
}
package jmstest.topic;

import org.apache.activemq.ActiveMQConnectionFactory;

import javax.jms.*;

/**
 * Created by Administrator on 2015/6/1.
 * 持久化topic接收者,要优先生产者运行一次,相当于在MQ上注册一个订阅消息
 */
public class perTopicReceive {
    public static void main(String[] args) throws Exception {
        ConnectionFactory cf = new ActiveMQConnectionFactory("tcp://192.168.1.55:61616");
        Connection connection = cf.createConnection();
        //设置消费者的身份标示
        connection.setClientID("qxm001");

        //开启事务
        final Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
        //设置订阅topic并创建订阅
        Topic destination = session.createTopic("my-topic");
        TopicSubscriber ts = session.createDurableSubscriber(destination,"T1");

        connection.start();

        Message message = ts.receive();
        while(message!=null) {
            TextMessage txtMsg = (TextMessage)message;
            session.commit();
            System.out.println("收到消息:" + txtMsg.getText());
            message = ts.receive(1000L);
        }

        session.close();
        connection.close();
    }
}

首先运行消费者订阅消息

然后停止消费者

我们可以发现在topic和subscribers上可以查看到该消费者,尽管消费者此时已经离线

然后运行消息生产者,查看topic列表,发现消息数目增加了

再次启动消费者:

发现subscribers里显示了接收的消息,但是topic接收消息的DE对列还是未变

这是因为订阅模式中,topic中的消息可以被很多消费者订阅并接收

不管是持久化还是非持久化订阅,都是要消费者先运行才可以!

持久化消息

这是ActiveMQ 的默认传送模式,此模式保证这些消息只被传送一次和成功使用一次。
对于这些消息,可靠性是优先考虑的因素。可靠性的另一个重要方面是确保持久性消息传送至目标后,消息服务在向消费者传送它们之前不会丢失这些消息。
这意味着在持久性消息传送至目标时,消息服务将其放入持久性数据存储。
如果消息服务由于某种原因导致失败,它可以恢复此消息并将此消息传送至相应的消费者。
虽然这样增加了消息传送的开销,但却增加了可靠性。

非持久化消息

保证这些消息最多被传送一次。对于这些消息,可靠性并非主要的考虑因素。
此模式并不要求持久性的数据存储,也不保证消息服务由于某种原因导致失败后消息不会丢失。
有两种方法指定传送模式:
1.使用setDeliveryMode 方法,这样所有的消息都采用此传送模式; 如:

producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

2.使用send 方法为每一条消息设置传送模式

AMQ简明教程(4)

hzqiuxm阅读(361)评论(0)

JMS可靠性机制

消息接收确认

JMS消息只有在被确认之后,才认为已经被成功地消费了。消息的成功消费通常包含三个阶段:
客户接收消息、客户处理消息和消息被确认。
在事务性会话中,当一个事务被提交的时候,确认自动发生。
在非事务性会话中,消息何时被确认取决于创建会话时的应答模式(acknowledgement mode)

该参数有以下三个可选值:
Session.AUTO_ACKNOWLEDGE:当客户(消费者)成功的从receive方法返回的时候,或者从MessageListener.onMessage方法成功返回的时候,会话自动确认客户收到的消息。
Session.CLIENT_ACKNOWLEDGE:客户通过调用消息的acknowledge方法确认消息。需要注意的是,在这种模式中,确认是在会话层上进行,确认一个被消费的消息将自动确认所有已被会话消费的消息。

例如,如果一个消息消费者消费了10 个消息,然后确认第5 个消息,那么所有10 个消息都被确认。

Session.DUPS_ACKNOWLEDGE:该选择只是会话迟钝的确认消息的提交。如果JMSprovider失败,那么可能会导致一些重复的消息。如果是重复的消息,那么JMSprovider 必须把消息头的JMSRedelivered字段设置为true

消息持久性

JMS 支持以下两种消息提交模式:
PERSISTENT:指示JMS provider持久保存消息,以保证消息不会因为JMSprovider的失败而丢失
NON_PERSISTENT:不要求JMS provider持久保存消息

消息优先级

可以使用消息优先级来指示JMS provider首先提交紧急的消息。优先级分
10个级别,从0(最低)到9(最高)。如果不指定优先级,默认级别是4。需要注意的是,JMS provider并不一定保证按照优先级的顺序提交消息

消息过期

可以设置消息在一定时间后过期,默认是永不过期

消息的临时目的地

可以通过会话上的createTemporaryQueue 方法和createTemporaryTopic方法来创建临时目的地。
它们的存在时间只限于创建它们的连接所保持的时间。
只有创建该临时目的地的连接上的消息消费者才能够从临时目的地中提取消息
一般会用在生产者将临时队列传给消费者,消费者在临时队列中加入消息传给生产者

持久订阅

首先消息生产者必须使用PERSISTENT提交消息。客户可以通过会话上的
createDurableSubscriber方法来创建一个持久订阅,该方法的第一个参数必须是一个topic。第二个参数是订阅的名称。

JMS provider会存储发布到持久订阅对应的topic上的消息。如果最初创建持久订阅的客户或者任何其它客户,使用相同的连接工厂和连接的客户ID,
相同的主题和相同的订阅名,再次调用会话上的createDurableSubscriber方法,那么该持久订阅就会被激活。

JMS provider会向客户发送客户处于非激活状态时所发布的消息。
持久订阅在某个时刻只能有一个激活的订阅者。持久订阅在创建之后会一直保留,直到应用程序调用会话上的unsubscribe方法。

本地事务

在一个JMS客户端,可以使用本地事务来组合消息的发送和接收。JMS
Session接口提供了commit和rollback方法。事务提交意味着生产的所有消息被发送,消费的所有消息被确认;

事务回滚意味着生产的所有消息被销毁,消费的所有消息被恢复并重新提交,除非它们已经过期。
事务性的会话总是牵涉到事务处理中,commit或rollback方法一旦被调用,一个事务就结束了,而另一个事务被开始。关闭事务性会话将回滚其中的事务。

需要注意的是,如果使用请求/回复机制,即发送一个消息,同时希望在同一个事务中等待接收该消息的回复,那么程序将被挂起,因为直到事务提交,发送操作才会真正执行(谨慎使用,比较耗资源)。
需要注意的还有一个,消息的生产和消费不能包含在同一个事务中。

JMS PTP(Point-to-Point)模型

定义了客户端如何向队列发送消息,从队列接收消息,以及浏览队列中的消息。
PTP模型是基于队列的,生产者发消息到队列,消费者从队列接收消息,队列的存在使得消息的异步传输成为可能。和邮件系统中的邮箱一样,队列可以包含各种消息,JMS Provider 提供工具管理队列的创建、删除。

PTP的一些特点:

1:如果在Session 关闭时,有一些消息已经被收到,但还没有被签收(acknowledged),那么,当消费者下次连接到相同的队列时,这些消息还会被再次接收
2:如果用户在receive 方法中设定了消息选择条件,那么不符合条件的消息会留在队列中,不会被接收到
3:队列可以长久地保存消息直到消费者收到消息。消费者不需要因为担心消息会丢失而时刻和队列保持激活的连接状态,充分体现了异步传输模式的优势 (是持久化的)

JMS Pub/Sub 模型

定义了如何向一个内容节点发布和订阅消息,这些节点被称作topic主题可以被认为是消息的传输中介,发布者(publisher)发布消息到主题,订阅者
(subscribe) 从主题订阅消息。主题使得消息订阅者和消息发布者保持互相独立,不需要接触即可保证消息的传送。

Pub/Sub的一些特点:

1:消息订阅分为非持久订阅和持久订阅非持久订阅

非持久订阅只有当客户端处于激活状态,也就是和JMS Provider保持连接状态才能收到发送到某个主题的消息,而当客户端处于离线状态,这个时间段发到主题的消息将会丢失,永远不会收到。
持久订阅时,客户端向JMS 注册一个识别自己身份的ID,当这个客户端处于离线时,JMS Provider会为这个ID 保存所有发送到主题的消息,
当客户再次连接到JMSProvider时,会根据自己的ID 得到所有当自己处于离线时发送到主题的消息。

2:如果用户在receive 方法中设定了消息选择条件,那么不符合条件的消息不会被接收
3:非持久订阅状态下,不能恢复或重新派送一个未签收的消息。只有持久订阅才能恢复或重新派送一个未签收的消息。
4:当所有的消息必须被接收,则用持久订阅。当丢失消息能够被容忍,则用非持久订阅

AMQ简明教程(3)

hzqiuxm阅读(339)评论(0)

JMS消息结构

JMS 消息由以下几部分组成:消息头,属性和消息体

消息头

包含消息的识别信息和路由信息,消息头包含一些标准的属性如下:
1:JMSDestination:由send方法设置
2:JMSDeliveryMode:由send方法设置
3:JMSExpiration:由send方法设置
4:JMSPriority:由send方法设置
5:JMSMessageID:由send方法设置
6:JMSTimestamp:由客户端设置
7:JMSCorrelationID :由客户端设置
8:JMSReplyTo :由客户端设置
9:JMSType :由客户端设置
10:JMSRedelivered:由JMS Provider设置

标准的JMS 消息头包含以下属性:
1:JMSDestination:消息发送的目的地:主要是指Queue和Topic,自动分配
2:JMSDeliveryMode:传送模式

有两种:持久模式和非持久模式。

一条持久性的消息应该被传送“一次仅仅一次”,这就意味者如果JMS提供者出现故障,该消息并不会丢失,它会在服务器恢复之后再次传递。
一条非持久的消息最多会传送一次,这意味这服务器出现故障,该消息将永远丢失。自动分配

3:JMSExpiration:消息过期时间,等于Destination 的send 方法中的timeToLive值加上发送时刻的GMT 时间值。

如果timeToLive 值等于零,则JMSExpiration 被设为零,表示该消息永不过期。
如果发送后,在消息过期时间之后消息还没有被发送到目的地,则该消息被清除。自动分配

4:JMSPriority:消息优先级,从0-9 十个级别,0-4 是普通消息,5-9 是加急消息。

JMS 不要求JMS Provider 严格按照这十个优先级发送消息,但必须保证加急消息要先于普通消息到达。默认是4级。自动分配

5:JMSMessageID:唯一识别每个消息的标识,由JMS Provider 产生。自动分配
6:JMSTimestamp:一个JMS Provider在调用send()方法时自动设置的。它是消息被发送和消费者实际接收的时间差。自动分配
7:JMSCorrelationID:用来连接到另外一个消息,典型的应用是在回复消息中连接到原消息。

在大多数情况下,JMSCorrelationID用于将一条消息标记为对JMSMessageID标示的上一条消息的应答,
不过,JMSCorrelationID可以是任何值,不仅仅是JMSMessageID。由开发者设置

8:JMSReplyTo:提供本消息回复消息的目的地址。由开发者设置
9:JMSType:消息类型的识别符。由开发者设置
10:JMSRedelivered:如果一个客户端收到一个设置了JMSRedelivered属性的消息,则表示可能客户端曾经在早些时候收到过该消息,
但并没有签收(acknowledged)。如果该消息被重新传送,JMSRedelivered=true 反之,JMSRedelivered =false。

消息体

JMS API定义了5种消息体格式,也叫消息类型,可以使用不同形式发送接收数据,并可以兼容现有的消息格式。

包括:TextMessage、MapMessage、BytesMessage、StreamMessage和ObjectMessage

消息属性

包含以下三种类型的属性:
1:应用程序设置和添加的属性,比如:Message.setStringProperty(“username”,username);
2:JMS定义的属性,使用“JMSX”作为属性名的前缀,connection.getMetaData().getJMSXPropertyNames(), 方法返回所有连接支持的JMSX 属性的名字。
3:JMS供应商特定的属性JMS定义的属性如下:
1:JMSXUserID:发送消息的用户标识,发送时提供商设置
2:JMSXAppID:发送消息的应用标识,发送时提供商设置
3:JMSXDeliveryCount:转发消息重试次数,第一次是1,第二次是2,… ,发送时提供商设置
4:JMSXGroupID:消息所在消息组的标识,由客户端设置
5:JMSXGroupSeq:组内消息的序号第一个消息是1,第二个是2,…,由客户端设置
6:JMSXProducerTXID :产生消息的事务的事务标识,发送时提供商设置
7:JMSXConsumerTXID :消费消息的事务的事务标识,接收时提供商设置
8:JMSXRcvTimestamp :JMS 转发消息到消费者的时间,接收时提供商设置

JMSXUserID:发送消息的用户标识,发送时提供商设置
JMSXAppID:发送消息的应用标识,发送时提供商设置
JMSXDeliveryCount:转发消息重试次数,第一次是1,第二次是2,… ,发送时提供商设置
JMSXGroupID:消息所在消息组的标识,由客户端设置
JMSXGroupSeq:组内消息的序号第一个消息是1,第二个是2,…,由客户端设置
JMSXProducerTXID :产生消息的事务的事务标识,发送时提供商设置
JMSXConsumerTXID :消费消息的事务的事务标识,接收时提供商设置
JMSXRcvTimestamp :JMS 转发消息到消费者的时间,接收时提供商设置
JMSXState:假定存在一个消息仓库,它存储了每个消息的单独拷贝,且这些消息从原始消息被发送时开始。

每个拷贝的状态有:1(等待),2(准备),3(到期)或4(保留)。由于状态与生产者和消费者无关,所以它不是由它们来提供。
它只和在仓库中查找消息相关,因此JMS没有提供这种API。由提供商设置

AMQ简明教程(2)

hzqiuxm阅读(342)评论(0)

JMS 概念简介

JMS是什么

JMS Java Message Service,Java消息服务,是Java EE中的一个技术。

JMS规范

JMS定义了Java 中访问消息中间件的接口,并没有给予实现,实现JMS 接口的消息中间件称为JMS Provider,例如ActiveMQ

JMS provider:实现JMS接口和规范的消息中间件
JMS message:JMS的消息,JMS消息由以下三部分组成:
1:消息头:每个消息头字段都有相应的getter和setter方法
2:消息属性:如果需要除消息头字段以外的值,那么可以使用消息属性
3:消息体:封装具体的消息数据

JMS producer:消息生产者,创建和发送JMS消息的客户端应用
JMS consumer:消息消费者,接收和处理JMS消息的客户端应用

消息的消费可以采用以下两种方法之一:
1:同步消费:通过调用消费者的receive方法从目的地中显式提取消息,receive 方法可以一直阻塞到消息到达。
2:异步消费:客户可以为消费者注册一个消息监听器,以定义在消息到达时所采取的动作

JMS domains:消息传递域

JMS规范中定义了两种消息传递域:
点对点(point-to-point,简写成PTP)消息传递域和发布/订阅消息传递域(publish/subscribe,简写成pub/sub)

1:点对点消息传递域的特点如下:
(1)每个消息只能有一个消费者
(2)消息的生产者和消费者之间没有时间上的相关性。无论消费者在生产者发送消息的时候是否处于运行状态,它都可以提取消息。

2:发布/订阅消息传递域的特点如下:
(1)每个消息可以有多个消费者
(2)生产者和消费者之间有时间上的相关性。订阅一个主题的消费者只能消费自它订阅之后发布的消息。

JMS 规范允许客户创建持久订阅,这在一定程度上放松了时间上的相关性要求。
持久订阅允许消费者消费它在未处于激活状态(离线)时发送的消息。

3:在点对点消息传递域中,目的地被称为队列(queue);在发布/订阅消息传递域中,目的地被称为主题(topic)

Connection factory:连接工厂,用来创建连接对象,以连接到JMS的provider
JMS Connection:封装了客户与JMS 提供者之间的一个虚拟的连接

JMS Session:是生产和消费消息的一个单线程上下文会话用于创建消息生产者(producer)、消息消费者(consumer)和消息(message)等。
会话提供了一个事务性的上下文,在这个上下文中,一组发送和接收被组合到了一个原子操作中。

Destination:消息发送到的目的地
Acknowledge:签收
Transaction:事务
JMS client:用来收发消息的Java应用

Non-JMS client:使用JMS provider本地API写的应用,用来替换JMS API实现收发消息的功能,通常会提供其他的一些特性
比如:CORBA、RMI等。

Administered objects:预定义的JMS对象,通常在provider规范中有定义,提供给JMS客户端来访问
比如: ConnectionFactory和Destination

AMQ简明教程(1)

hzqiuxm阅读(345)评论(0)

ActiveMQ简介

ActiveMQ是什么

ActiveMQ是Apache推出的,一款开源的,完全支持JMS1.1和J2EE 1.4规范的JMS
Provider实现的消息中间件(Message Oriented Middleware,MOM)

ActiveMQ能干什么

最主要的功能就是:实现JMS Provider,用来帮助实现高可用、高性能、可伸缩、
易用和安全的企业级面向消息服务的系统

ActiveMQ特点

  • 完全支持JMS1.1和J2EE 1.4规范(持久化,XA消息,事务)
  • 支持多种传送协议:in-VM,TCP,SSL,NIO,UDP,JGroups,JXTA
  • 可插拔的体系结构,可以灵活定制,如:消息存储方式、安全管理等
  • 很容易和Application Server集成使用
  • 多种语言和协议编写客户端。语言: Java,C,C++,C#,Ruby,Perl,Python,PHP
  • 从设计上保证了高性能的集群,客户端-服务器,点对点
  • 可以很容易的和Spring结合使用
  • 支持通过JDBC和journal提供高速的消息持久化
  • 支持与Axis的整合

消息中间件的主要应用场景

在多个系统间进行整合和通讯的时候,通常会要求:
1:可靠传输,数据不能丢失,有的时候,也会要求不能重复传输;
2:异步传输,否则各个系统同步发送接受数据,互相等待,造成系统瓶颈

目前比较知名的消息中间件:

IBM MQSeries
BEA WebLogic JMS Server
Oracle AQ
Tibco
SwiftMQ
AcitveMQ:是免费的java实现的消息中间件
与其他中间件的比较:
http://www.cnblogs.com/liping13599168/articles/1915245.html

下载地址:http://activemq.apache.org/activemq-5111-release.html

maven 依赖地址:

<!--ActiveMQ -->
<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-all</artifactId>
    <version>5.11.1</version>
</dependency>
<dependency>
    <groupId>org.apache.xbean</groupId>
    <artifactId>xbean-spring</artifactId>
    <version>4.0</version>
</dependency>

如果你采用的是springboot框架,你需要添加的依赖如下:

compile ('org.springframework.boot:spring-boot-starter-activemq')

这个依赖已经包含了如下几个依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-jms</artifactId>
</dependency>
<dependency>
   <groupId>org.apache.activemq</groupId>
   <artifactId>activemq-broker</artifactId>
</dependency>

下载并安装ActiveMQ服务器端

1:从http://activemq.apache.org/download.html(http://activemq.apache.org/activemq-5111-release.html)下载最新的ActiveMQ
2:直接解压,然后拷贝到你要安装的位置就好了
启动运行
1:普通启动:到ActiveMQ/bin下面,./activemq start
2:启动并指定日志文件./activemq start > /tmp/activemqlog
检查是否已经启动
ActiveMQ默认采用61616端口提供JMS服务,使用8161端口提供管理控制台服
务,执行以下命令以便检验是否已经成功启动ActiveMQ服务:
1:比如查看61616端口是否打开: netstat -an | grep 61616
2:也可以直接查看控制台输出或者日志文件
3:还可以直接访问ActiveMQ的管理页面:http://192.168.10.55:8161/admin/
默认的用户名和密码是admin/admin
关闭ActiveMQ,可以用./activemq stop
暴力点的可以用ps -ef | grep activemq 来得到进程号,然后kill掉

示例程序

创建一个小工程来测试下消息的发送与接收

此处创建一个maven工程,直接在POM文件中引入2个依赖包

创建2个类

package jmstest.queue;

import org.apache.activemq.ActiveMQConnectionFactory;

import javax.jms.*;

/**
 * Created by hzqiuxm on 2015/5/30.
 */
public class queueSend {

    public static void main(String[] args) throws Exception {
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.1.55:61616");
        Connection connection = connectionFactory.createConnection();
        connection.start();

        //开启事务,消息确认方式为自动
        Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
        //创建队列
        Destination destination = session.createQueue("my-queue");
        //生产者把消息传送到队列中
        MessageProducer producer = session.createProducer(destination);
        for(int i=0; i<3; i++) {
            TextMessage message = session.createTextMessage("message--"+i);
            Thread.sleep(1000);
            //通过消息生产者发出消息
            producer.send(message);
        }
        session.commit();
        session.close();
        connection.close();
    }
}
package jmstest.queue;

import org.apache.activemq.ActiveMQConnectionFactory;

import javax.jms.*;

/**
 * Created by hzqiuxm on 2015/5/30.
 */
public class queueReceive {

    public static void main(String[] args) throws Exception {
        ConnectionFactory cf = new ActiveMQConnectionFactory("tcp://192.168.1.55:61616");
        Connection connection = cf.createConnection();
        connection.start();
        //开启事务,

        final Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
        Destination destination = session.createQueue("my-queue");
        MessageConsumer consumer = session.createConsumer(destination);
        int i=0;
        while(i<3) {
            i++;
            TextMessage message = (TextMessage) consumer.receive();
            session.commit();
            System.out.println("收到消息:" + message.getText());
        }
        session.close();
        connection.close();
    }
}

Docker简明教程(6)

hzqiuxm阅读(291)评论(0)

构建静态网站

网站结构

准备好文件

1 Dockerfile文件

FROM ubuntu:16.04
MAINTAINER James Turnbull "james@example.com"
ENV REFRESHED_AT 2014-06-01

RUN apt-get -qq update && apt-get -qq install nginx

RUN mkdir -p /var/www/html/website
ADD nginx/global.conf /etc/nginx/conf.d/
ADD nginx/nginx.conf /etc/nginx/

EXPOSE 80

2 创新nginx目录,新增2个配置文件

global.conf
server {
        listen          0.0.0.0:80;
        server_name     _;

        root            /var/www/html/website;
        index           index.html index.htm;

        access_log      /var/log/nginx/default_access.log;
        error_log       /var/log/nginx/default_error.log;
}
nginx.conf
user www-data;
worker_processes 4;
pid /run/nginx.pid;
daemon off;

events {  }

http {
  sendfile on;
  tcp_nopush on;
  tcp_nodelay on;
  keepalive_timeout 65;
  types_hash_max_size 2048;
  include /etc/nginx/mime.types;
  default_type application/octet-stream;
  access_log /var/log/nginx/access.log;
  error_log /var/log/nginx/error.log;
  gzip on;
  gzip_disable "msie6";
  include /etc/nginx/conf.d/*.conf;
}

开始构建

1 执行

docker build -t hzqiuxm/nginx

查看下构建历史

docker history hzqiuxm/nginx

可以对照镜像看到,history的命令从新构建的hzqiuxm/nginx镜像的最后一层开始,追溯到最开的ubuntu镜像

2 构建一个nginx容器

docker run -d -p 80 --name website -v $PWD/website:/var/www/html/website hzqiuxm/nginx nginx

可以看到启动的容器的80端口被映射到了宿主机的32768端口,我们可以输入IP:端口访问该网站

如果要修改的话,只要修改宿主机website下的index.html文件即可,修改后刷新页面即可看到效果

知识点扩展

  • 容器之间的连接有3种方法,一般只推荐Docker Networking (其他二种分别是内部网络和Docker链接)
  • Docker Network可以在不同宿主机容器间通讯(根据创建网络的方式不同来实现)

Docker简明教程(5)

hzqiuxm阅读(326)评论(0)

镜像构建

使用commit命令创建镜像(不推荐)

虽然不推荐,但还是要了解下

  • 登录到DockerHub
docker login

如果没有账号前往docker.com官网进行注册

  • 创建一个需要提交的容器
docker run -i -t ubuntu /bin/bash
apt-get -y update
apt-get -y install apache2
  • 退出创建的容器
exit
  • 提交定制了apache2的容器
docker commit b729d5a05235 hzqiuxm/apache2

用Dockerfile构建镜像 (推荐)

优点: 具备可重复性,透明性,幂等性
- 编写脚本Dockerfile
制定一个目录下创建一个文件Dockerfile

# Version: 0.0.1
FROM unbuntu:14.04
MAINTAINER James Turnbull "hzqiuxm@163.com"
RUN apt-get update && apt-get install -y nginx
RUN echo 'Hi I am in your contaniner' \
    >/usr/share/nginx/html/index.html
EXPOSE 80
  • 执行脚本
docker build -t="hzqiuxm/static_web" .
注意后面的. 表示当前目录

  • 推送镜像到自己的DockerHub
docker push hzqiuxm/static_web

构建关键点

  • Dockerfile构建缓存保证每次从失败的步骤继续
  • Dockerfile新指令

自动构建

除了上述二种方式,我们可以可以把GitHub或BitBucket中含有Dockerfile文件的仓库连接到DockerHub即可

删除镜像

docker rmi hzqiuxm/static_web

只会删除本地的镜像

运行自己的Docker Registry

  • 利用DockerHub提供的私有仓库(小项目推荐)
  • 在防火墙后面运行自己的Registry(大项目推荐)

Docker简明教程(4)

hzqiuxm阅读(320)评论(0)

Container简单操作

启动

  • 直接启动
docker run -t -i docker.io/ubuntu /bin/bash
  • 根据以前的Container的ID来启动
docker ps -a

docket start 11414221a8bc
docker ps -a

停止

  • 交互模式下直接
exit

或者

docker stop

暂停

旧版本中有,新版本中舍弃了,不建议使用,听过就好

清除

sudo docker rm containerID

创建镜像Image

  • 进入交互模式
docker run -t -i docker.io/ubuntu /bin/bash
  • 更新下安装源
apt-get update

  • 安装vim
apt-get install -y vim
  • 制作新镜像
docker commit 2653ad309080 dockerlearning/ubuntu_vim

  • 查看镜像
docker images

后台运行Container

docker run -t -i docker.io/ubuntu /bin/bash \

日志查看

docker logs -f container_name/id

列出容器进程

docker top container_name/id

查看端口绑定情况

docker port container_name port

参考链接

https://www.dockerbook.com/code/index.html

Docker简明教程(3)

hzqiuxm阅读(343)评论(0)

Docker介绍番外篇,Docker诞生

冷藏厂乱入

谈起Docker,禁不住想起小黑羊小时候在冷藏厂打工的经历.....
为什么冷藏厂会乱入?因为小黑羊说那简直是虚拟化和Docker活生生的例子。

先建个库房

要造冷藏厂,你得先造一个库房对吧?
下面这个库房敞亮不?

能造库房的包工头很多,比如华为、惠普、Dell、联想、曙光、浪潮之类的。
他们给了这些库房一个高大上的名字:物理服务器

库房变成冷藏厂

鱼呀、肉啊就可以存到库房了吗?当然不行!
你需要低温才可以保鲜!不然会发臭坏掉的......

所以我们需要购置制冷机,目前市场上主流的制冷机有两大系列Windows制冷机和Linux制冷机。

配备了制冷机的库房就摇生一变成了冷藏厂了,这样你就可以把你的鸡鸭鱼肉虾、蔬菜、水果都装进来保鲜了

那是不是就皆大欢喜了?NO!NO!NO!相信你也一定注意到了一个问题:各种库藏品都很矫情,放在一起很容易串味儿的,没人喜欢吃咸鱼味的鸡腿或者鸡腿榴莲味的虾吧?而且它们对温度要求也不一致,怎么办?

聪明的泥瓦匠

有个叫VMware的泥瓦匠想了个办法,他把库房隔成很多叫做“虚拟机”的小房间,“密封”起来,每个房间放一个制冷机,这就是冷库虚拟化。
这样就不怕串味儿,每个小房间的温度独立可控,鱼呀虾呀表示很Happy。

世界清净了,后来还有几个泥瓦匠也学会了库房分隔术,到处给人修冷库。
泥瓦匠Vmware用的砌墙工具叫ESXi,泥瓦匠Citrix用的砌墙工具叫Xen Server,泥瓦匠Microsoft用的砌墙工具叫Hyper-V,还有一些草根泥瓦匠用的工具叫KVM

这下总皆大欢喜了吧?然而并没有,这世界上矫情的人太多,如此完美的方案他们还是吹毛求疵瞎BB:

万恶的资本家老板最后问道:还能不能想点别的更好的办法?

Docker横空出世

于是——晴天霹雳一声响,新秀Docker来登场。

制冷机Linux是个喜欢动脑筋的好青年,它发明了一种叫“LXC”的“软隔离”技术,冷库分隔成叫做“容器”的小单间,但每个房间不需要单独安装制冷机,只要布些导冷管和温控阀门,这样看起来就达到目的了。

后来有人把“LXC”这种“软隔离”技术发扬光大,用一堆“GO”零件进行改装,可以大幅提高冷库的建设和改进速度,于是Docker横空出世了。
Docker被业内称为容器管理引擎,其实它就是一套给冷库快速建“单间”和铺“导冷管”的装置,源于LXC,但是更智能。

比如,有些“冷库”的使用者不知道储存“冷冻大虾”的单间该建成什么样,“导冷管”该怎么排布。Docker就建了一个“样板间”展览中心,小白们仿照“样板间”在自家冷库里可以原样造一个出来,这种“样板间”被称为“Docker镜像”,展览中心被称为“Docker Hub”。Docker Hub,你懂滴!


(来自对小黑羊微信公众号文章的整理与改编)

Docker简明教程(2)

hzqiuxm阅读(332)评论(0)

Docker概念理解

容器概念理解

容器是一种虚拟化的方案

特点

  • 它是操作系统级别的虚拟化
  • 只能运行相同或相似内核的系统中
  • 依赖linux内核NameSpace和Cgroups(Control Group)特性

相对于虚拟机的优点

  • 虚拟机是利用软件模拟硬件,需要安装操作系统,依赖库,应用;而容器把其中的大头操作系统给去掉了,所以非常轻量化,占用系统资源(硬盘,内存,CPU)会少很多
  • 安装方便,启动速度快

什么是Docker?

  • 将应用程序自动部署到容器的轻量级引擎技术

特点

  • Go语言编写,遵从Apache2.0开源协议
  • 目标是消除各环境差异,实现快速开发测试部署软件生命周期
  • 提倡面向服务的编程,每个容器最好只部署一个微服务

适用场景

  • 适用Docker容器进行开发、测试、部署
  • 创建隔离的环境,很适合个性化的SaaS服务
  • 搭建测试环境

四个核心概念理解

  • Image
    在Docker 中非常非常重要的概念,它是Docker 的核心,Docker 所创建运行的
    Container 完全基于Image 运行,并且它是只读的,我们在下一个册子会去解释,现在您
    只需要记住Image 在Docker 中非常的重要。

  • Repository
    存放Image 的地方,其中Docker Hub 下面就有非常多非常多的Repository,每个
    Repository 有很多很多的Image。

  • Registry
    Registry 其实很容易和Repository 混淆,Docker Hub 在我的理解是一个Registry,
    也就是说Registry 不直接存放Image,Image 是由Registry 下面的若干个Repository 去
    存放的,可能后文中我们会去搭建一个private Registry 存放image,你可以理解我们的
    Registry 下有一个默认的Repository 去存放。

  • Container
    Container 是一个可读写的空间,是由若干个Image 组成的,我们的应用以后都会运
    行在Container 中,同样在后文中我们会为大家介绍如何创建容器,如何启动运行容器。

三层概念

  • Docker Layer 是一个宏观的layer, 包括了若干个read-only 的Images 和一个writable 和readable 的Container layer.
  • Image Layer 是最下面的层(我指的不是Kernel)那些read-only 的Images.
  • Container Layer 是一个可读可写的Layer,我们不仅可以用yum/apt-get 安装软件,而且可以部署我们的服务,产生或者修改一些新的文件.

DockerC/S架构

欢迎加入紫牛小筑

进入小筑关于作者