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

Gradle简明教程(3)

hzqiuxm阅读(178)评论(0)

快速牵手JAVA

  • Gradle将把你从传统的构建流程中解放出来,针对不同的语言它有着各种不同的插件,通过插件封装了基本流程

  • 如何使用JAVA插件?只要一行代码

apply plugin: 'java'

这就定义了一个java项目的全部,自动添加很多task
Gradle 会在 src/main/java 目录下寻找产品代码,在 src/test/java 寻找测试代码 。

另外在 src/main/resources 包含了资源的 JAR 文件, src/test/resources 包含了运行测试。
所有的输出都在 build 目录下,JAR 在 build/libs 目录下

  • 外部依赖
    和Maven一样,我们也可以使用maven repository
apply plugin: 'java'

repositories {
    mavenCentral()
}

dependencies {
        compile group: 'org.springframework', name: 'spring-core', version: '4.2.5.RELEASE'
        compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
        testCompile group: 'junit', name: 'junit', version: '4.+'
    }

Maven respository网站上已经提供了各种工具包的依赖,稍微改变下格式描述就可以了
(下面将会介绍到Groovy插件,它更强大是java插件的扩展)

获取依赖

执行 gradle build

bulid结果

  • 需要注意的是一个groovy项目也是一个java项目
apply plugin: 'groovy'

repositories {
    mavenCentral()
}

dependencies {
        compile 'org.codehaus.groovy:groovy-all:2.3.6'
        compile 'commons-logging:commons-logging:1.2'
        compile 'org.springframework:spring-core:4.2.5.RELEASE'
        testCompile 'junit:junit:4.11'
    }

比之前的java插件更强大哦, 而且依赖的描述也更简单了,从respository中直接copy就行了

快速开始Web应用

构建WAR文件
  • 使用war插件来构建war文件
apply plugin: 'war'

当运行 gradle build时就会编译、测试、打包工程一个war文件

  • 运行应用插件
apply plugin: 'jetty'

当你运行 gradle jettyRun 的时候,应用将会运行在一个内嵌的jetty web容器中

gradle的Task执行规则
  • 同个构建可以执行多个task,但每个task只能被执行一次,不管它是在哪个阶段被执行
    task compile << {
        println 'compiling source'
    }

    task compileTest(dependsOn: compile) << {
        println 'compiling unit tests'
    }

    task test(dependsOn: [compile, compileTest]) << {
        println 'running unit tests'
    }

    task dist(dependsOn: [compile, test]) << {
        println 'building the distribution'
    }

执行 gradle dist结果如下

任务执行规则

Gradle简明教程(2)

hzqiuxm阅读(179)评论(0)

下载与安装

  • 官方下载地址: https://gradle.org/gradle-download/
  • 安装就是配置环境变量,增加GRADLE_HOME环境变量,值为gradle-2.12\bin所在目录

    windows下直接在环境变量对话框中定义,类linux系统
    export GRADE_HOME = xxxx/xxxx
    export PATH=$PATH:$GRADLE_HOME/bin

  • 验证是否安装成功

check install
- 来一个gradle的hello world

新建一个文件 build.gradle

task helloWorld{

    task startSession << {
        println 'Welcome to gradle world!'
    }

    3.times {
        task "genGradle$it" << {
            println 'genGradle rocks'
        }
    }

    genGradle0.dependsOn startSession
    genGradle2.dependsOn genGradle1, genGradle0

    task groupGradles(dependsOn: genGradle2)

}
  • 执行:gradle -q groupGradles

run helloworld

程序简单说明

  • 这里的task和Ant的targets是对等的
  • << 符号是doLast的alias,doFirst 和 doLast 可以多次执行调用。他们在开始或结束的 task 动作清单中添加动作。task 执行时,按动作列表的顺序执行的动作。操作符 << 仅仅是 doLast 的别名。
  • -q是代表quiet模式,不生成构建编译过程的日志信息

其他技巧

  • 列出项目中所有的task
gradle -q tasks --all
  • 在执行时排除一个任务
gradle groupGradles -x genGradle0
  • 任务名字采用缩写
gradle groupHello 等价于  gradle gH
gradle groupGradle0 等价于 gradle gG0
  • 常用的命令行选项
-b 指定构建脚本名字,某人build.gradle
-i 执行时候输出详细日志信息
-q 减少构建出错时打印的日志信息
--help 打印出所有可用的命令行选项
  • 以后台守护进行方式运行gradle
gradle groupGradles --daemon

看看灵活的Groovy例子

  • 编写脚本build.gradle
task upper << {
    println '---- Begin in upper ----'
    String strSome = 'my_nAme'
    println 'Original: ' + strSome
    println 'Upper: ' + strSome.toUpperCase()
    println '---- End in upper ----'
}   

task hello(dependsOn: upper) << {
    println " I'm dependsOn upper"
}

执行下 gradle -q hello

执行结果

defaultTasks 'clean', 'run'

task upper << {
    println '---- Begin in upper ----'
    String strSome = 'my_nAme'
    println 'Original: ' + strSome
    println 'Upper: ' + strSome.toUpperCase()
    println '---- End in upper ----'
}   

task hello(dependsOn: upper) << {
    println " I'm dependsOn upper"
}

task clean << {
    println 'This is a default task clean '
}

task run << {
    println 'This is a default task run '
}

执行 gradle -q 结果
执行结果

  • DAG配置
task destribution <<{
    println "We build the zip with version = $version "
}

task release(dependsOn:'destribution') << {
    println 'We release now ......'
}

gradle.taskGraph.whenReady{
    taskGraph -> 
    if (taskGraph.hasTask(release)) {
        version = '1.0'
    }else{
        version = '1.0-SNAPSHOT'
    }
}

注意执行不同的TASK,输出结果是不一样的
执行结果

Gradle简明教程(1)

hzqiuxm阅读(210)评论(0)

构建工具剖析

四大组成部分
  • 构建文件

    使用脚本语言来表达构建逻辑 最常见的是xml、json格式

  • 构建输入输出

    输入是指构建任务需要的任务或数据,输出是指构建任务的产出结果

  • 构建引擎

    用来解析执行构建文件指令或规则的工具用来解析执行构建文件指令或规则的工具

  • 依赖管理器

    管理构建任务所要依赖的第三方或公共类库

蚂蚁式构建 Ant

发音: [ænt] 蚂蚁的意思

  • Apache Ant是一个用Java编写的开源构建工具
  • 构建文件使用XML来表示的,可以在任何环境下使用
  • 不提供依赖管理器,自行管理
  • 结合Ivy可以实现依赖管理器
  • Ant构建术语

    project、target、task

  • 没有对如何定义构建的结构强加任何限制,对源码、输出目录、target拥有完全灵活的选择

  • 缺点

XML本身较为臃肿与啰嗦
没有建设项目标准,build文件常常会随着项目开发而变得繁杂重复
无法量化被编译的类或执行的TASK
没有Ivy情况下,Ant很难管理依赖

专家构建 Maven

发音:['mevn] 内行,专家的意思(我接触的人中大部分都读错了)
- 使用约定优于配置的思想,规定了标准的目录布局
- 基于生命周期的思想,通过三套生命周期来管理构建过程
- 构建文件也是使用XML来表示的,可以在任何环境下使用
- 核心功能可以通过开发定制的插件来扩展,社区插件很丰富
- 脚本中可以定义外部依赖库,一般会搭建Nexus结合maven中心仓库来管理
- 缺点

默认的结构和生命周期可能会不适合你的项目
自己定制扩展比较复杂,需要了解Mojos(内部扩展API)

我们想要的构建
  • 具有表达式、声明式、可维护的构建语言
  • 标准化的项目布局和生命周期,但是具有完全的灵活性和对默认值的完全可配置性
  • 定制逻辑灵活易用
  • 支持构建多个项目组成的项目结构
  • 支持依赖管理
  • 可以很好的和Ant、Maven集成
  • 高效且有良好的扩展性

是的它就是Gradle,下一代的构建工具

AMQ简明教程(9)

hzqiuxm阅读(171)评论(0)

AMQ消息存储持久化

概述

ActiveMQ不仅支持persistent和non-persistent两种方式,还支持消息的恢复( recovery )方式。

PTP

Queue的存储是很简单的,就是一个FIFO的Queue

PUB/SUB

对于持久化订阅主题,每一个消费者将获得一个消息的复制。

ActiveMQ提供了一个插件式的消息存储,类似于消息的多点传播,主要实现了如下几种:
1:AMQ消息存储-基于文件的存储方式,是以前的默认消息存储
2:KahaDB消息存储-提供了容量的提升和恢复能力,是现在的默认存储方式
3:JDBC消息存储-消息基于JDBC存储的
4:Memory 消息存储-基于内存的消息存储

KahaDB Message Store概述

KahaDB是目前默认的存储方式,可用于任何场景,提高了性能和恢复能力。消息存储使用一个事务日志和仅仅用一个索引文件来存储它所有的地址。

KahaDB是一个专门针对消息持久化的解决方案,它对典型的消息使用模式进行了优化。

在Kaha中,数据被追加到data logs中。当不再需要log文件中的数据的时候,log文件会被丢弃。

KahaDB基本配置例子

<persistenceAdapter>
<kahaDB directory="${activemq.data}/kahadb"/>
</persistenceAdapter>

可用的属性有:
1:director:KahaDB存放的路径,默认值activemq-data
2:indexWriteBatchSize: 批量写入磁盘的索引page数量,默认值1000
3:indexCacheSize:内存中缓存索引page的数量,默认值10000
4:enableIndexWriteAsync:是否异步写出索引,默认false
5:journalMaxFileLength:设置每个消息data log的大小,默认是32MB
6:enableJournalDiskSyncs:设置是否保证每个没有事务的内容,被同步写入磁盘,JMS持久化的时候需要,默认为true
7:cleanupInterval:在检查到不再使用的消息后,在具体删除消息前的时间,默认30000
8:checkpointInterval:checkpoint的间隔时间,默认5000
9:ignoreMissingJournalfiles:是否忽略丢失的消息日志文件,默认false
10:checkForCorruptJournalFiles:在启动的时候,将会验证消息文件是否损坏,默认false
11:checksumJournalFiles:是否为每个消息日志文件提供checksum,默认false
12:archiveDataLogs: 是否移动文件到特定的路径,而不是删除它们,默认false
13:directoryArchive:定义消息已经被消费过后,移动data log到的路径,默认null
14:databaseLockedWaitDelay:获得数据库锁的等待时间(used by shared master/slave),默认10000
15:maxAsyncJobs:设置最大的可以存储的异步消息队列,默认值10000,可以和concurrentMessageProducers 设置成一样的值
16:concurrentStoreAndDispatchTransactions:是否分发消息到客户端,同时事务存储消息,默认true
17:concurrentStoreAndDispatchTopics:是否分发Topic消息到客户端,同时进行存储,默认true
18:concurrentStoreAndDispatchQueues:是否分发queue消息到客户端,同时进行存储,默认true

在Java中内嵌使用Broker,使用KahaDB的例子

public class EmbeddedBrokerUsingKahaDBStoreExample {
BrokerService createEmbeddedBroker() throws Exception {
BrokerService broker = new BrokerService();
File dataFileDir = new File("target/amq-in-action/kahadb");
KahaDBStore kaha = new KahaDBStore();
kaha.setDirectory(dataFileDir);
// Using a bigger journal file
kaha.setJournalMaxFileLength(1024*100);
// small batch means more frequent and smaller writes
kaha.setIndexWriteBatchSize(100);
// do the index write in a separate thread
kaha.setEnableIndexWriteAsync(true);
broker.setPersistenceAdapter(kaha);
//create a transport connector
broker.addConnector("tcp://localhost:61616");
//start the broker
broker.start();
return broker;
}
}

AMQ Message Store概述

AMQ Message Store是ActiveMQ5.0缺省的持久化存储,它是一个基于文件、事务存储设计为快速消息存储的一个结构,该结构是以流的形式来进行消息交互的。

这种方式中,Messages被保存到data logs中,同时被reference store进行索引以提高存取速度。

Date logs由一些单独的data log文件组成,缺省的文件大小是32M,如果某个消息的大小超过了data log文件的大小,那么可以修改配置以增加
data log文件的大小。如果某个data log文件中所有的消息都被成功消费了,那么这个data log文件将会被标记,以便在下一轮的清理中被删除或者归档。

AMQ Message Store配置示例:

<broker brokerName="broker" persistent="true" useShutdownHook="false">
<persistenceAdapter>
<amqPersistenceAdapter directory="${activemq.base}/data"
maxFileLength="32mb"/>
</persistenceAdapter>
</broker>

使用JDBC来持久化消息

ActiveMQ支持使用JDBC来持久化消息,预定义的表如下:
1:消息表,缺省表名为ACTIVEMQ_MSGS,queue和topic都存在里面,结构如下:

2:ACTIVEMQ_ACKS表存储持久订阅的信息和最后一个持久订阅接收的消息ID,结构如下:

3:锁定表,缺省表名为ACTIVEMQ_LOCK,用来确保在某一时刻,只能有一个
ActiveMQ broker实例来访问数据库,结构如下:

使用JDBC来持久化消息的配置示例:

<beans>
<broker brokerName="test-broker" persistent=true
xmlns="http://activemq.apache.org/schema/core">
<persistenceAdapter>
<jdbcPersistenceAdapter dataSource=“#mysql-ds"/>
</persistenceAdapter>
</broker>
<bean name="mysql-ds" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName"><value>org.gjt.mm.mysql.Driver</value></property>
<property
name="url"><value>jdbc:mysql://192.168.1.100:3306/test?useUnicode=true&characterEncodi
ng=UTF-8</value></property>
<property name="username"> <value>root</value> </property>
<property name="password" value="cc"/>
</bean>

JDBC Message Store with ActiveMQ Journal

这种方式克服了JDBC Store的不足,使用快速的缓存写入技术,大大提高了性能。配置示例如下:
<beans>
<broker brokerName="test-broker" xmlns="http://activemq.apache.org/schema/core">
<persistenceFactory>
<journalPersistenceAdapterFactory
journalLogFiles="4"
journalLogFileSize="32768"
useJournal="true"
useQuickJournal="true"
dataSource="#derby-ds"
dataDirectory="activemq-data" />
</persistenceFactory>
</broker>
</beans>

JDBC Store和JDBC Message Store with ActiveMQ Journal的区别
1:Jdbc with journal的性能优于jdbc
2:Jdbc用于master/slave模式的数据库分享
3:Jdbc with journal不能用于master/slave模式
4:一般情况下,推荐使用jdbc with journal

Memory Message Store

内存消息存储主要是存储所有的持久化的消息在内存中。这里没有动态的缓存存在,所以
你必须注意设置你的broker所在的JVM和内存限制

Memory Message Store配置示例:

<beans>
<broker brokerName="test-broker" persistent="false"
xmlns="http://activemq.apache.org/schema/core">
<transportConnectors>
<transportConnector uri="tcp://localhost:61635"/>
</transportConnectors>
</broker>
</beans>

在Java中内嵌使用Broker,使用Memory的例子:

public void createEmbeddedBroker() throws Exception {
BrokerService broker = new BrokerService();
broker.setPersistent(false);
broker.addConnector("tcp://localhost:61616");
broker.start();
}

AMQ简明教程(8)

hzqiuxm阅读(192)评论(0)

AMQ传输协议

连接到ActiveMQ

Connector:ActiveMQ提供的,用来实现连接通讯的功能。包括:client-tobroker、broker-to-broker。ActiveMQ允许客户端使用多种协议来连接
配置Transport Connector,在conf/activemq.xml里面,大致如下:

<transportConnectors>
<transportConnector name="openwire" uri="tcp://localhost:61616"
discoveryUri="multicast://default"/>
<transportConnector name="ssl" uri="ssl://localhost:61617"/>
<transportConnector name="stomp" uri="stomp://localhost:61613"/>
<transportConnector name="xmpp" uri="xmpp://localhost:61222"/>
</transportConnectors>

ActiveMQ支持的client-broker通讯协议如下:
1:TCP:这个也是缺省使用的协议
2:NIO
3:UDP
4:SSL
5:Http(s)
6:VM:如果客户端和broker在一个虚拟机内的话,通过VM协议通讯在VM内通讯,从而减少网络传输的开销

Transmission Control Protocol (TCP)

1:这是默认的Broker配置,TCP的Client监听端口是61616。
2:在网络传输数据前,必须要序列化数据,消息是通过一个叫wire protocol的来序列化成字节流。

默认情况下,ActiveMQ把wire protocol叫做OpenWire,它的目的是促使网络上的效率和数据快速交互。

3:TCP连接的URI形式:tcp://hostname:port?key=value&key=value,加粗部分是必须的
4:TCP传输的优点:
(1) TCP协议传输可靠性高,稳定性强
(2)高效性:字节流方式传递,效率很高
(3)有效性、可用性:应用广泛,支持任何平台
5:所有关于Transport协议的可配置参数,可以参见:
http://activemq.apache.org/configuring-version-5-transports.html

New I/O API Protocol(NIO)

1:NIO协议和TCP协议类似,但NIO更侧重于底层的访问操作。它允许开发人员对同一资源可有更多的client调用和服务端有更多的负载。
2:适合使用NIO协议的场景:

(1)可能有大量的Client去链接到Broker上一般情况下,大量的Client去链接Broker是被操作系统的线程数所限制的。因此,NIO的实现比TCP需要更少的线程去运行,所以建议使用NIO协议
(2)可能对于Broker有一个很迟钝的网络传输NIO比TCP提供更好的性能

3:NIO连接的URI形式:nio://hostname:port?key=value
4:Transport Connector配置示例:

<transportConnectors>
<transportConnector
name="tcp"
uri="tcp://localhost:61616?trace=true" />
<transportConnector
name="nio"
uri="nio://localhost:61618?trace=true" />
</transportConnectors>

上面的配置,示范了一个TCP协议监听61616端口,一个NIO协议监听61618端口

User Datagram Protocol(UDP)

1:UDP和TCP的区别
(1)TCP是一个原始流的传递协议,意味着数据包是有保证的,换句话说,数据包是不会被复制和丢失的。UDP,另一方面,它是不会保证数据包的传递的
(2)TCP也是一个稳定可靠的数据包传递协议,意味着数据在传递的过程中不会被丢失。这样确保了在发送和接收之间能够可靠的传递。相反,UDP仅仅是一个链接协议,所以它没有可靠性之说
2:从上面可以得出:TCP是被用在稳定可靠的场景中使用的;UDP通常用在快速数据传递和不怕数据丢失的场景中,还有ActiveMQ通过防火墙时,只能用UDP
3:UDP连接的URI形式:udp://hostname:port?key=value
4:Transport Connector配置示例:

<transportConnectors>
<transportConnector
name="udp"
uri="udp://localhost:61618?trace=true" />
</transportConnectors>

Secure Sockets Layer Protocol (SSL)

1:连接的URI形式:ssl://hostname:port?key=value
2:Transport Connector配置示例:

<transportConnectors>
<transportConnector name="ssl" uri="ssl://localhost:61617?trace=true"/>
</transportConnectors>

Hypertext Transfer Protocol (HTTP/HTTPS)

1:像web和email等服务需要通过防火墙来访问的,Http可以使用这种场合
2:连接的URI形式:http://hostname:port?key=value或者https://hostname:port?key=value
3:Transport Connector配置示例:

<transportConnectors>
<transportConnector name="http"
uri="http://localhost:8080?trace=true" />
</transportConnectors>

VM Protocol(VM)

1:VM transport允许在VM内部通信,从而避免了网络传输的开销。这时候采用的连接不是socket连接,而是直接的方法调用。
2:第一个创建VM连接的客户会启动一个embed VM broker,接下来所有使用相同的
broker name的VM连接都会使用这个broker。当这个broker上所有的连接都关闭的时候,这个broker也会自动关闭。
3:连接的URI形式:vm://brokerName?key=value
4:Java中嵌入的方式:
vm:broker:(tcp://localhost:6000)?brokerName=embeddedbroker&persistent=false ,
定义了一个嵌入的broker名称为embededbroker以及配置了一个tcptransprotconnector在监听端口6000上
5:使用一个加载一个配置文件来启动broker
vm://localhost?brokerConfig=xbean:activemq.xml

总结

一般就用于中间件,所以只会在TCP和NIO中选用,VM的使用常见有限,一般是为了一次性大量发送消息,所以和客户端部署在一起

AMQ简明教程(7)

hzqiuxm阅读(177)评论(0)

AMQ结合spring

Spring提供了对JMS的支持,需要添加Spring支持jms的包,如下:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jms</artifactId>
    <version>4.1.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-pool</artifactId>
    <version>5.11.1</version>
</dependency>

然后需要在Spring的配置文件中,配置jmsTemplate,示例如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory"
          destroy-method="stop">
        <property name="connectionFactory">
            <bean class="org.apache.activemq.ActiveMQConnectionFactory">
                <property name="brokerURL">
                    <value>tcp://192.168.1.55:61616</value>
                </property>
            </bean>
        </property>
        <property name="maxConnections" value="100"></property>
    </bean>
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="jmsFactory" />
        <property name="defaultDestination" ref="destination" />
        <property name="messageConverter">
            <bean class="org.springframework.jms.support.converter.SimpleMessageConverter" />
        </property>
    </bean>
    <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg index="0" value="spring-queue" />
    </bean>

</beans>

queue消息发送

package com.qiuxm.myweb.service.jms;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Service;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import javax.jms.TextMessage;

/**
 * Created by Administrator on 2015/6/2.
 */

@Service
public class QueueSender {

    @Autowired
    private JmsTemplate jt = null;

    public static void main(String[] args)  throws Exception{
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        QueueSender ct = (QueueSender)ctx.getBean("queueSender");
        ct.jt.send(new MessageCreator() {
            public Message createMessage(Session s) throws JMSException {
                TextMessage msg = s.createTextMessage("Spring msg===");
                return msg;
            }
        });
    }

}

queue消息接收

package com.qiuxm.myweb.service.jms;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Service;

/**
 * Created by Administrator on 2015/6/2.
 */

@Service
public class QueueReceive {

    @Autowired
    private JmsTemplate jt = null;
    public static void main(String[] args) throws Exception {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        QueueReceive ct = (QueueReceive)ctx.getBean("queueReceive");

        String msg = (String)ct.jt.receiveAndConvert();

        System.out.println("msg==="+msg);
    }
}

如果topic的话,首先需要修改spring的配置:
先添加topic的配置,当然,需要修改jmsTemplate配置里面的defaultDestination,如果不想修改这个配置,那么直接把Destination注入程序,在程序里面选择发送的Destination也可以配置其他的客户端发送和接收跟队列基本是一样的。

如果想要在Spring中配置消费者的话,就不需要再启动接收的客户端了
当然,需要写一个类来实现消息监听
这样测试的时候,只需要启动消息生产者就好了

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory"
          destroy-method="stop">
        <property name="connectionFactory">
            <bean class="org.apache.activemq.ActiveMQConnectionFactory">
                <property name="brokerURL">
                    <value>tcp://192.168.1.55:61616</value>
                </property>
            </bean>
        </property>
        <property name="maxConnections" value="100"></property>
    </bean>
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="jmsFactory" />
        <property name="defaultDestination" ref="destinationTopic" />
        <property name="messageConverter">
            <bean class="org.springframework.jms.support.converter.SimpleMessageConverter" />
        </property>
    </bean>

    <bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg index="0" value="spring-queue" />
    </bean>

    <bean id="destinationTopic" class="org.apache.activemq.command.ActiveMQTopic">
        <constructor-arg index="0" value="spring-topic" />
    </bean>

    <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="jmsFactory" />
        <property name="destination" ref="destinationTopic" />
        <property name="messageListener" ref="messageListener" />
    </bean>

    <bean id="messageListener"
          class="com.qiuxm.myweb.web.controller.lister.MyMessageListener">
    </bean>

</beans>
package com.qiuxm.myweb.web.controller.lister;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

/**
 * Created by Administrator on 2015/6/2.
 */
public class MyMessageListener implements MessageListener {
    public void onMessage(Message arg0) {
        TextMessage msg = (TextMessage)arg0;
        try {
            System.out.println("receive txt msg==="+msg.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

ActiveMQ结合Spring开发最佳实践和建议
1:Camel框架支持大量的企业集成模式,可以大大简化集成组件间的大量服务和复杂的消息流。而Spring框架更注重简单性,仅仅支持基本的最佳实践。

2:Spring消息发送的核心架构是JmsTemplate,隔离了像打开、关闭Session和Producer的繁琐操作,因此应用开发人员仅仅需要关注实际的业务逻辑。但是
JmsTemplate损害了ActiveMQ的PooledConnectionFactory对session和消息producer的缓存机制而带来的性能提升。

3:新的Spring里面,可以设置org.springframework.jms.connection.CachingConnectionFactory的sessionCacheSize ,或者干脆使用ActiveMQ的PooledConnectionFactory

4:不建议使用JmsTemplate的receive()调用,因为在JmsTemplate上的所有调用都是同步的,这意味着调用线程需要被阻塞,直到方法返回,这对性能影响很大

5:请使用DefaultMessageListenerContainer,它允许异步接收消息并缓存session和消息consumer,而且还可以根据消息数量动态的增加或缩减监听器的数量

AMQ简明教程(6)

hzqiuxm阅读(225)评论(0)

ActiveMQ构建应用

Broker介绍

Broker:相当于一个ActiveMQ服务器实例
命令行启动参数示例如下:
1:activemq start :使用默认的activemq.xml来启动
2:activemq start xbean:file:../conf/activemq-2.xml :使用指定的配置文件来启动
3:如果不指定file,也就是xbean:activemq-2.xml,那么xml必须在classpath下面

用ActiveMQ来构建Java应用
这里主要将用ActiveMQ Broker作为独立的消息服务器来构建JAVA应用。
ActiveMQ也支持在vm中通信基于嵌入式的broker,能够无缝的集成其它java应用

嵌入式Broker启动

1:Broker Service启动broker ,示例如下:

BrokerService broker = new BrokerService();
broker.setUseJmx(true);
broker.addConnector("tcp://localhost:61616");
broker.start();

2:BrokerFactory启动broker ,示例如下:

String Uri = "properties:broker.properties";
BrokerService broker1 = BrokerFactory.createBroker(new URI(Uri));
broker1.addConnector("tcp://localhost:61616");
broker1.start();

broker.properties的内容示例如下:

useJmx=true
persistent=false
brokerName=Cheese 

利用Spring集成Broker

Spring的配置文件如下:

<beans>
<bean id="admins" class="org.apache.activemq.security.AuthenticationUser">
<constructor-arg index="0" value="admin" />
<constructor-arg index="1" value="password" />
<constructor-arg index="2" value="admins,publisher,consumers" />
</bean>
<bean id="publishers" class="org.apache.activemq.security.AuthenticationUser">
<constructor-arg index="0" value="publisher" />
<constructor-arg index="1" value="password" />
<constructor-arg index="2" value="publisher,consumers" />
</bean>
<bean id="consumers" class="org.apache.activemq.security.AuthenticationUser">
<constructor-arg index="0" value="consumer" />
<constructor-arg index="1" value="password" />
<constructor-arg index="2" value="consumers" />
</bean>
<bean id="guests" class="org.apache.activemq.security.AuthenticationUser">
<constructor-arg index="0" value="guest" />
<constructor-arg index="1" value="password" />
<constructor-arg index="2" value="guests" />
</bean>
<bean id="simpleAuthPlugin" class="org.apache.activemq.security.SimpleAuthenticationPlugin">
<property name="users">
<util:list>
<ref bean="admins" />
<ref bean="publishers" />
<ref bean="consumers" />
<ref bean="guests" />
</util:list>
</property>
</bean>
<bean id="broker" class="org.apache.activemq.broker.BrokerService" init-method="start" destroy-method="stop">
<property name="brokerName" value="myBroker" />
<property name="persistent" value="false" />
<property name="transportConnectorURIs">
<list>
<value>tcp://localhost:61616</value>
</list>
</property>
<property name="plugins">
<list>
<ref bean="simpleAuthPlugin"/>
</list>
</property>
</bean>
</beans>

或者配置BrokerFactoryBean,示例如下:

<beans>
<bean id="broker" class="org.apache.activemq.xbean.BrokerFactoryBean">
<property name="config" value="resources/activemq-simple.xml"/>
<property name="start" value="true" />
</bean>
</beans>

ActiveMQ的启动:

1:可以通过在应用程序中以编码的方式启动broker,例如: broker.start();
如果需要启动多个broker,那么需要为broker设置一个名字。例如:

BrokerService broker = new BrokerService();
broker.setName("fred");
broker.addConnector("tcp://localhost:61616");
broker.start();

2:还可以通过spring来启动,前面已经演示过了

AMQ简明教程(5)

hzqiuxm阅读(233)评论(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阅读(230)评论(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阅读(217)评论(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。由提供商设置

欢迎加入紫牛小筑

进入小筑关于作者