ActiveMQ生产者详解

JMS(ActiveMQ) PTP和PUB/SUB模式实例:[url]http://donald-draper.iteye.com/blog/2347445[/url]
ActiveMQ连接工厂、连接详解:[url]http://donald-draper.iteye.com/blog/2348070[/url]
ActiveMQ会话初始化:[url]http://donald-draper.iteye.com/blog/2348341[/url]
ActiveMQ生产者:[url]http://donald-draper.iteye.com/blog/2348381[/url]
ActiveMQ消费者:[url]http://donald-draper.iteye.com/blog/2348389[/url]
ActiveMQ启动过程详解[url]:http://donald-draper.iteye.com/blog/2348399[/url]
ActiveMQ Broker发送消息给消费者过程详解:[url]http://donald-draper.iteye.com/blog/2348440[/url]
Spring与ActiveMQ的集成:[url]http://donald-draper.iteye.com/blog/2347638[/url]
Spring与ActiveMQ的集成详解一:[url]http://donald-draper.iteye.com/blog/2348449[/url]
Spring与ActiveMQ的集成详解二:[url]http://donald-draper.iteye.com/blog/2348461[/url]
上一篇我们讲到会话的初始化
Session session = connection.createSession(Boolean.TRUE,Session.AUTO_ACKNOWLEDGE); 


会话的创建主要最的工作是,初始化消费者,生产者id产生器,会话消费者,生产者队列,
消息确认模式,是否异步分发,设置连接事务上下文,异步发送会话信息,新建消息会话执行器,会话添加到ActiveMQConnection的会话队列CopyOnWriteArrayList;然后启动消费则,主要是启动消息分发通道,唤醒会话执行器ActiveMQSessionExecutor;最后启动会话执行器ActiveMQSessionExecutor,在启动会话执行器时,如果消息分发通道处于未启动状态,则启动消息分发通道,如果有未消费的消息,唤醒消息执行器,唤醒主要做的做工作是
ActiveMQConnection创建任务执行TaskRunnerFactory,有任务执行工厂TaskRunnerFactory,有任务执行工厂创建执行任务PooledTaskRunner,PooledTaskRunner是ActiveMQSessionExecutor的包装,PooledTaskRunner执行就是执行ActiveMQSessionExecutor
iterate的函数,这个过程主要是ActiveMQSessionExecutor从ActiveMQSession获取会话消费者consumer,然后遍历消费者,消费者通过MessageListener消费消息。ActiveMQConnection与ActiveMQSession,ActiveMQMessageConsumer,ActiveMQMessageProducer的关系,连接管理会话(1-n),会话管理消息者与生产者(1-n)。ActiveMQSession关联一个
ActiveMQSessionExecutor,由会话执行器,消费者消费消息。

今天我们往下看,看看消息队列,生产者,以及发送消息

Queue :消息的目的地;消息发送给谁.  
Queue destination = session.createQueue(qname);
MessageProducer:消息发送者
MessageProducer producer = session.createProducer(destination);
//设置生产者的模式,有两种可选
//DeliveryMode.PERSISTENT 当activemq关闭的时候,队列数据将会被保存
//DeliveryMode.NON_PERSISTENT 当activemq关闭的时候,队列里面的数据将会被清空
producer.setDeliveryMode(DeliveryMode.PERSISTENT);
构造消息,此处写死,项目就是参数,或者方法获取
sendMessage(session, producer);
session.commit();
connection.close();



1.先看消息队列,从下一句开始
Queue  destination = session.createQueue(qname);
public Queue createQueue(String queueName)
throws JMSException
{
checkClosed();
//如果队列名以id开始则创建临时队列,否则创建ActiveMQQueue
if(queueName.startsWith("ID:"))
return new ActiveMQTempQueue(queueName);
else
return new ActiveMQQueue(queueName);
}

来看ActiveMQQueue
//ActiveMQQueue
public class ActiveMQQueue extends ActiveMQDestination
implements Queue
{
public static final byte DATA_STRUCTURE_TYPE = 100;
private static final long serialVersionUID = -3885260014960795889L;
public ActiveMQQueue(String name)
{
//构造父类
super(name);
}
public String getQueueName()
throws JMSException
{
return getPhysicalName();
}
public byte getDestinationType()
{
return 1;
}
protected String getQualifiedPrefix()
{
return "queue://";
}
}

public abstract class ActiveMQDestination extends JNDIBaseStorable
implements DataStructure, Destination, Externalizable, Comparable
{
public static final String PATH_SEPERATOR = ".";
public static final char COMPOSITE_SEPERATOR = 44;
public static final byte QUEUE_TYPE = 1;//队列类型
public static final byte TOPIC_TYPE = 2;//主题类型
public static final byte TEMP_MASK = 4;
public static final byte TEMP_TOPIC_TYPE = 6;
public static final byte TEMP_QUEUE_TYPE = 5;
public static final String QUEUE_QUALIFIED_PREFIX = "queue://";//队列命名目录
public static final String TOPIC_QUALIFIED_PREFIX = "topic://";//主题命名目录
public static final String TEMP_QUEUE_QUALIFED_PREFIX = "temp-queue://";
public static final String TEMP_TOPIC_QUALIFED_PREFIX = "temp-topic://";
public static final String IS_DLQ = "isDLQ";
public static final String TEMP_DESTINATION_NAME_PREFIX = "ID:";
private static final long serialVersionUID = -3885260014960795889L;
protected String physicalName;
protected transient ActiveMQDestination compositeDestinations[];
protected transient String destinationPaths[];
protected transient boolean isPattern;
protected transient int hashValue;
protected Map options;
protected static UnresolvedDestinationTransformer unresolvableDestinationTransformer = new DefaultUnresolvedDestinationTransformer();
protected ActiveMQDestination(String name)
{
setPhysicalName(name);
}
//获取目的地类型
public String getDestinationTypeAsString()
{
switch(getDestinationType())
{
case 1: // '\001'
return "Queue";

case 2: // '\002'
return "Topic";

case 5: // '\005'
return "TempQueue";

case 6: // '\006'
return "TempTopic";

case 3: // '\003'
case 4: // '\004'
default:
throw new IllegalArgumentException((new StringBuilder()).append("Invalid destination type: ").append(getDestinationType()).toString());
}
}
//创建目的地
public static ActiveMQDestination createDestination(String name, byte defaultType)
{
if(name.startsWith("queue://"))
return new ActiveMQQueue(name.substring("queue://".length()));
if(name.startsWith("topic://"))
return new ActiveMQTopic(name.substring("topic://".length()));
if(name.startsWith("temp-queue://"))
return new ActiveMQTempQueue(name.substring("temp-queue://".length()));
if(name.startsWith("temp-topic://"))
return new ActiveMQTempTopic(name.substring("temp-topic://".length()));
switch(defaultType)
{
case 1: // '\001'
return new ActiveMQQueue(name);

case 2: // '\002'
return new ActiveMQTopic(name);

case 5: // '\005'
return new ActiveMQTempQueue(name);

case 6: // '\006'
return new ActiveMQTempTopic(name);

case 3: // '\003'
case 4: // '\004'
default:
throw new IllegalArgumentException((new StringBuilder()).append("Invalid default destination type: ").append(defaultType).toString());
}
}
//将目的地物理名和配置项写入输出流
public void writeExternal(ObjectOutput out)
throws IOException
{
out.writeUTF(getPhysicalName());
out.writeObject(options);
}
//从输入流读取目的地物理名和配置项
public void readExternal(ObjectInput in)
throws IOException, ClassNotFoundException
{
setPhysicalName(in.readUTF());
options = (Map)in.readObject();
}

}


Topic :消息的目的地;消息发送给谁.
Topic  destination = session.createTopic(tname);  

public Topic createTopic(String topicName)
throws JMSException
{
checkClosed();
if(topicName.startsWith("ID:"))
return new ActiveMQTempTopic(topicName);
else
return new ActiveMQTopic(topicName);
}

public class ActiveMQTopic extends ActiveMQDestination
implements Topic
{
public static final byte DATA_STRUCTURE_TYPE = 101;
private static final long serialVersionUID = 7300307405896488588L;
public ActiveMQTopic(String name)
{
super(name);
}
public byte getDataStructureType()
{
return 101;
}
public boolean isTopic()
{
return true;
}
public String getTopicName()
throws JMSException
{
return getPhysicalName();
}
public byte getDestinationType()
{
return 2;
}
protected String getQualifiedPrefix()
{
return "topic://";
}
}

从分析ActiveMQTopic和ActiveMQQueue可以看出本质都是ActiveMQDestination
只是JNDI和数据结构类型不同


2.再来会话创建生产者
MessageProducer producer = session.createProducer(destination); 

先看destination为ActiveMQQueue,再看ActiveMQTopic

destination为ActiveMQQueue
//根据队列目的地创建消息生产者
public MessageProducer createProducer(Destination destination)
throws JMSException
{
checkClosed();
if(destination instanceof CustomDestination)
{
CustomDestination customDestination = (CustomDestination)destination;
return customDestination.createProducer(this);
} else
{
int timeSendOut = connection.getSendTimeout();
return new ActiveMQMessageProducer(this, getNextProducerId(), ActiveMQMessageTransformation.transformDestination(destination), timeSendOut);
}
}

//ActiveMQMessageProducer
public class ActiveMQMessageProducer extends ActiveMQMessageProducerSupport
implements StatsCapable, Disposable
{
protected ProducerInfo info;//生产者信息
protected boolean closed;
private final JMSProducerStatsImpl stats;//生产者状态管理器
private AtomicLong messageSequence;//消息序列号
private final long startTime = System.currentTimeMillis();
private MessageTransformer transformer;//消息转化器
private MemoryUsage producerWindow;//生产者窗口
protected ActiveMQMessageProducer(ActiveMQSession session, ProducerId producerId, ActiveMQDestination destination, int sendTimeout)
throws JMSException
{
super(session);
//创建生产者信息
info = new ProducerInfo(producerId);
//从连接获取生产者窗口信息
info.setWindowSize(session.connection.getProducerWindowSize());
if(destination != null && destination.getOptions() != null)
{
Map options = IntrospectionSupport.extractProperties(new HashMap(destination.getOptions()), "producer.");
IntrospectionSupport.setProperties(info, options);
if(options.size() > 0)
{
String msg = (new StringBuilder()).append("There are ").append(options.size()).append(" producer options that couldn't be set on the producer.").append(" Check the options are spelled correctly.").append(" Unknown parameters=[").append(options).append("].").append(" This producer cannot be started.").toString();
LOG.warn(msg);
throw new ConfigurationException(msg);
}
}
info.setDestination(destination);
if(session.connection.getProtocolVersion() >= 3 && info.getWindowSize() > 0)
{
producerWindow = new MemoryUsage((new StringBuilder()).append("Producer Window: ").append(producerId).toString());
producerWindow.setExecutor(session.getConnectionExecutor());
producerWindow.setLimit(info.getWindowSize());
producerWindow.start();
}
//默认为消息持久化
defaultDeliveryMode = 2;//
defaultPriority = 4;//默认优先级为r4
defaultTimeToLive = 0L;
messageSequence = new AtomicLong(0L);//新建消息序列号
stats = new JMSProducerStatsImpl(session.getSessionStats(), destination);
try
{
//将消息生产者添加到会话,通过会话将生产者信息发送给Server
this.session.addProducer(this);
this.session.syncSendPacket(info);
}
setSendTimeout(sendTimeout);
//设置消息转换器
setTransformer(session.getTransformer());
}
}


//ActiveMQMessageProducerSupport
public abstract class ActiveMQMessageProducerSupport
implements MessageProducer, Closeable
{
protected ActiveMQSession session;//会话
protected boolean disableMessageID;
protected boolean disableMessageTimestamp;
protected int defaultDeliveryMode;//默认传输模式
protected int defaultPriority;//默认优先级
protected long defaultTimeToLive;
protected int sendTimeout;
public ActiveMQMessageProducerSupport(ActiveMQSession session)
{
sendTimeout = 0;
this.session = session;
disableMessageTimestamp = session.connection.isDisableTimeStampsByDefault();
}
}


从上面来看,会话创建消息生产者就是,初始化ActiveMQMessageProducer的生产者信息,生产者状态管理器
,消息序列号,传输模式(默认持久化),消息转化器,生产者窗口,并将生产者信息通过会话发送给Server
再来看destination为ActiveMQTopic的情况
 public TopicPublisher createPublisher(Topic topic)
throws JMSException
{
checkClosed();
if(topic instanceof CustomDestination)
{
CustomDestination customDestination = (CustomDestination)topic;
return customDestination.createPublisher(this);
} else
{
int timeSendOut = connection.getSendTimeout();
return new ActiveMQTopicPublisher(this, ActiveMQMessageTransformation.transformDestination(topic), timeSendOut);
}
}

//ActiveMQTopicPublisher
public class ActiveMQTopicPublisher extends ActiveMQMessageProducer
implements TopicPublisher
{
protected ActiveMQTopicPublisher(ActiveMQSession session, ActiveMQDestination destination, int sendTimeout)
throws JMSException
{
super(session, session.getNextProducerId(), destination, sendTimeout);
}
public Topic getTopic()
throws JMSException
{
return (Topic)super.getDestination();
}
public void publish(Message message)
throws JMSException
{
super.send(message);
}
public void publish(Message message, int deliveryMode, int priority, long timeToLive)
throws JMSException
{
super.send(message, deliveryMode, priority, timeToLive);
}
public void publish(Topic topic, Message message)
throws JMSException
{
super.send(topic, message);
}
public void publish(Topic topic, Message message, int deliveryMode, int priority, long timeToLive)
throws JMSException
{
super.send(topic, message, deliveryMode, priority, timeToLive);
}
}

从上面可以看出,ActiveMQTopicPublisher本质上是ActiveMQMessageProducer,TopicPublisher的消息的发送都是委托给ActiveMQMessageProducer

3.发送消息
sendMessage(session, producer);
 public static void sendMessage(Session session, MessageProducer producer)  
throws Exception {
for (int i = 1; i <= 5; i++) {//有限制,达到1000就不行
TextMessage message = session.createTextMessage("向ActiveMq发送的Queue消息" + i);
// 发送消息到目的地方
System.out.println("发送消息:" + "ActiveMq 发送的Queue消息" + i);
producer.send(message);
}
}



先看会话创建消息,再看生产者发送消息

会话创建消息
//ActiveMQMessageSession
 public TextMessage createTextMessage(String text)
throws JMSException
{
//创建文本消息
ActiveMQTextMessage message = new ActiveMQTextMessage();
message.setText(text);
//配置消息
configureMessage(message);
return message;
}


创建文本消息
ActiveMQTextMessage message = new ActiveMQTextMessage();

public class ActiveMQTextMessage extends ActiveMQMessage
implements TextMessage
{
public static final byte DATA_STRUCTURE_TYPE = 28;
protected String text;
private void copy(ActiveMQTextMessage copy)
{
super.copy(copy);
copy.text = text;
}

public byte getDataStructureType()
{
return 28;
}
public String getJMSXMimeType()
{
return "jms/text-message";
}
public void setText(String text)
throws MessageNotWriteableException
{
checkReadOnlyBody();
this.text = text;
setContent(null);
}
}

配置消息
configureMessage(message);

protected void configureMessage(ActiveMQMessage message)
throws IllegalStateException
{
checkClosed();
//设置消息MQ连接
message.setConnection(connection);
}

public abstract class Message extends BaseCommand
implements MarshallAware, MessageReference
{
public static final String ORIGINAL_EXPIRATION = "originalExpiration";
public static final int DEFAULT_MINIMUM_MESSAGE_SIZE = 1024;
protected MessageId messageId;//消息id
protected ActiveMQDestination originalDestination;//消息原目的地
protected TransactionId originalTransactionId;//事务原id
protected ProducerId producerId;//生产者id
protected ActiveMQDestination destination;//消息目的地
protected TransactionId transactionId;//事务id
protected long expiration;//失效时间
protected long timestamp;//时间戳
protected long arrival;
protected long brokerInTime;
protected long brokerOutTime;
protected String correlationId;
protected ActiveMQDestination replyTo;//消息回复目的地
protected boolean persistent;//是否持久化
protected String type;
protected byte priority;//优先级
protected String groupID;
protected int groupSequence;
protected ConsumerId targetConsumerId;//消息者id
protected boolean compressed;
protected String userID;
protected ByteSequence content;
protected ByteSequence marshalledProperties;
protected DataStructure dataStructure;//数据结构
protected int redeliveryCounter;//传输计数器
protected int size;
protected Map properties;
protected boolean readOnlyProperties;//读写属性
protected boolean readOnlyBody;
protected transient boolean recievedByDFBridge;
protected boolean droppable;
protected boolean jmsXGroupFirstForConsumer;
private transient short referenceCount;
private transient ActiveMQConnection connection;//连接
transient MessageDestination regionDestination;
transient MemoryUsage memoryUsage;//内存使用情况
private BrokerId brokerPath[];//broker地址
private BrokerId cluster[];//簇地址
}

再来看一下ObjectMessage
public ObjectMessage createObjectMessage(Serializable object)
throws JMSException
{
//创建ObjectMessage
ActiveMQObjectMessage message = new ActiveMQObjectMessage();
//配置消息连接ActiveMQConnection信息
configureMessage(message);
message.setObject(object);
return message;
}

//ActiveMQObjectMessage
public class ActiveMQObjectMessage extends ActiveMQMessage
implements ObjectMessage
{
public static final byte DATA_STRUCTURE_TYPE = 26;
static final ClassLoader ACTIVEMQ_CLASSLOADER = org/apache/activemq/command/ActiveMQObjectMessage.getClassLoader();
protected transient Serializable object;
public byte getDataStructureType()
{
return 26;
}
public String getJMSXMimeType()
{
return "jms/object-message";
}
}

生产者发送消息


//ActiveMQMessageProducerSupport
 public void send(Message message)
throws JMSException
{
send(getDestination(), message, defaultDeliveryMode, defaultPriority, defaultTimeToLive);
}



//ActiveMQMessageProducer发送消息
 public void send(Destination destination, Message message, int deliveryMode, int priority, long timeToLive)
throws JMSException
{
send(destination, message, deliveryMode, priority, timeToLive, null);
}

public void send(Destination destination, Message message, int deliveryMode, int priority, long timeToLive, AsyncCallback onComplete)
throws JMSException
{
checkClosed();
if(destination == null)
if(info.getDestination() == null)
throw new UnsupportedOperationException("A destination must be specified.");
else
throw new InvalidDestinationException("Don't understand null destinations");
ActiveMQDestination dest;
//转换消息目的地
if(destination.equals(info.getDestination()))
dest = (ActiveMQDestination)destination;
else
if(info.getDestination() == null)
dest = ActiveMQDestination.transform(destination);
else
throw new UnsupportedOperationException((new StringBuilder()).append("This producer can only send messages to: ").append(info.getDestination().getPhysicalName()).toString());
if(dest == null)
throw new JMSException("No destination specified");
//转换消息
if(transformer != null)
{
//实际使用ActiveMQConnection的消息转换器
Message transformedMessage = transformer.producerTransform(session, this, message);
if(transformedMessage != null)
message = transformedMessage;
}
//如果生产者窗口不为空,则等待有足够的空间
if(producerWindow != null)
try
{
producerWindow.waitForSpace();
}
catch(InterruptedException e)
{
throw new JMSException("Send aborted due to thread interrupt.");
}
//通过会话发送消息
session.send(this, dest, message, deliveryMode, priority, timeToLive, producerWindow, sendTimeout, onComplete);
//记录消息发送事件
stats.onMessage();
}


通过会话发送消息
session.send(this, dest, message, deliveryMode, priority, timeToLive, producerWindow, sendTimeout, onComplete);


//ActiveMQSession
protected void send(ActiveMQMessageProducer producer, ActiveMQDestination destination, Message message, int deliveryMode, int priority, long timeToLive, 
MemoryUsage producerWindow, int sendTimeout, AsyncCallback onComplete)
throws JMSException
{
checkClosed();
if(destination.isTemporary() && connection.isDeleted(destination))
throw new InvalidDestinationException((new StringBuilder()).append("Cannot publish to a deleted Destination: ").append(destination).toString());
//获取发送互质锁
synchronized(sendMutex)
{
//开始事务,获取事务id
doStartTransaction();
TransactionId txid = transactionContext.getTransactionId();
//获取生产者序列号
long sequenceNumber = producer.getMessageSequence();
message.setJMSDeliveryMode(deliveryMode);//设置持久化模式
long expiration = 0L;
if(!producer.getDisableMessageTimestamp())
{
//设置消息时间戳及生存时间
long timeStamp = System.currentTimeMillis();
message.setJMSTimestamp(timeStamp);
if(timeToLive > 0L)
expiration = timeToLive + timeStamp;
}
//设置消息失效时间,优先级
message.setJMSExpiration(expiration);
message.setJMSPriority(priority);
message.setJMSRedelivered(false);//不允许消息重传
//转化消息
ActiveMQMessage msg = ActiveMQMessageTransformation.transformMessage(message, connection);
//设置消息目的地
msg.setDestination(destination);
//设置消息id
msg.setMessageId(new MessageId(producer.getProducerInfo().getProducerId(), sequenceNumber));
if(msg != message)
{
message.setJMSMessageID(msg.getMessageId().toString());
message.setJMSDestination(destination);
}
msg.setBrokerPath(null);
msg.setTransactionId(txid);//设置事务id
if(connection.isCopyMessageOnSend())
msg = (ActiveMQMessage)msg.copy();
//设置消息连接
msg.setConnection(connection);
msg.onSend();
//设置消息生产者id
msg.setProducerId(msg.getMessageId().getProducerId());
if(LOG.isTraceEnabled())
LOG.trace((new StringBuilder()).append(getSessionId()).append(" sending message: ").append(msg).toString());
if(onComplete == null && sendTimeout <= 0 && !msg.isResponseRequired() && !connection.isAlwaysSyncSend() && (!msg.isPersistent() || connection.isUseAsyncSend() || txid != null))
{
//如果消息发送回调为空,则异步发送消息
connection.asyncSendPacket(msg);
if(producerWindow != null)
{
int size = msg.getSize();
//增加内存消耗
producerWindow.increaseUsage(size);
}
} else
if(sendTimeout > 0 && onComplete == null)
//否则同步延时发送消息
connection.syncSendPacket(msg, sendTimeout);
else
connection.syncSendPacket(msg, onComplete);
}
}

先看一下会话发送消息新建事务所做的事情
开始事务,获取事务id
doStartTransaction();


protected void doStartTransaction()
throws JMSException
{
if(getTransacted() && !transactionContext.isInXATransaction())
transactionContext.begin();
}

public class TransactionContext
implements XAResource
{ private static final HashMap ENDED_XA_TRANSACTION_CONTEXTS = new HashMap();
private ActiveMQConnection connection;//事务所属连接
private final LongSequenceGenerator localTransactionIdGenerator;
private List synchronizations;
private Xid associatedXid;
private TransactionId transactionId;//事务id
private LocalTransactionEventListener localTransactionEventListener;
private int beforeEndIndex;
public void begin()
throws JMSException
{
if(isInXATransaction())
throw new TransactionInProgressException("Cannot start local transaction. XA transaction is already in progress.");
if(transactionId == null)
{
synchronizations = null;
beforeEndIndex = 0;
//新建本地事务id,和事务信息
transactionId = new LocalTransactionId(getConnectionId(), localTransactionIdGenerator.getNextSequenceId());
TransactionInfo info = new TransactionInfo(getConnectionId(), transactionId, (byte)0);
connection.ensureConnectionInfoSent();
//通过连接异步发送事务信息报
connection.asyncSendPacket(info);
if(localTransactionEventListener != null)
localTransactionEventListener.beginEvent();
LOG.debug("Begin:{}", transactionId);
}
}
}

回到会话异步发送消息

如果消息发送回调为空且无发送延时,则异步发送消息
connection.asyncSendPacket(msg);

//ActiveMQConnection,异步发送消息
public void asyncSendPacket(Command command)
throws JMSException
{
if(isClosed())
{
throw new ConnectionClosedException();
} else
{
//异步发送消息
doAsyncSendPacket(command);
return;
}
}
//异步发送消息
private void doAsyncSendPacket(Command command)
throws JMSException
{
try
{
//这个我们前面看过是transport-》TcpTransport-》MutexTransport-》ResponseCorrelator
transport.oneway(command);
}
catch(IOException e)
{
throw JMSExceptionSupport.create(e);
}
}

//ResponseCorrelator
public class ResponseCorrelator extends TransportFilter
{
private final Map requestMap;
private IntSequenceGenerator sequenceGenerator;
private final boolean debug;
private IOException error;
public ResponseCorrelator(Transport next)
{
//next为MutexTransport
this(next, new IntSequenceGenerator());
}
public void oneway(Object o)
throws IOException
{
Command command = (Command)o;
//设置命令序列化id
command.setCommandId(sequenceGenerator.getNextSequenceId());
command.setResponseRequired(false);
next.oneway(command);
}

//MutexTransport
public class MutexTransport extends TransportFilter
{
private final ReentrantLock writeLock;
private boolean syncOnCommand;
public MutexTransport(Transport next)
{
//next为TcpTransport
super(next);
writeLock = new ReentrantLock();
syncOnCommand = false;
}
//正在发送命令
public void oneway(Object command)
throws IOException
{
//获取写锁
writeLock.lock();
next.oneway(command);
writeLock.unlock();
break MISSING_BLOCK_LABEL_37;
Exception exception;
exception;
writeLock.unlock();
throw exception;
}
}

//TcpTransport

public class TcpTransport extends TransportThreadSupport
implements Transport, Service, Runnable
{
protected final URI remoteLocation;//远程URI
protected final URI localLocation;//本地URI
protected final WireFormat wireFormat;
protected int connectionTimeout;//连接超时时间
protected int soTimeout;
protected int socketBufferSize;//socket的缓存大小
protected int ioBufferSize;//io缓存大小
protected boolean closeAsync;
protected Socket socket;
protected DataOutputStream dataOut;//socket的输出流
protected DataInputStream dataIn;//socket的输入流
protected TimeStampStream buffOut;
protected int trafficClass;
private boolean trafficClassSet;
protected boolean diffServChosen;
protected boolean typeOfServiceChosen;
protected boolean trace;
protected String logWriterName;
protected boolean dynamicManagement;
protected boolean startLogging;
protected int jmxPort;
protected boolean useLocalHost;
protected int minmumWireFormatVersion;
protected SocketFactory socketFactory;
protected final AtomicReference stoppedLatch;
protected volatile int receiveCounter;
private Map socketOptions;
private int soLinger;
private Boolean keepAlive;//是否保活
private Boolean tcpNoDelay;//tcp是否为非延时
private Thread runnerThread;
public void oneway(Object command)
throws IOException
{

checkStarted();
//将命令写到dataOut缓存区中,而dataOut我们在前面分析中TcpTransport的启动中,
//TcpTransport与Broker建立套接字,dataOUt为socket的输出流
wireFormat.marshal(command, dataOut);
//刷新缓存
dataOut.flush();
}
}

我们来看一下wireFormat是什么?
在从连接工厂获取连接中,TcpTransport的构建是从TransportFactory

public abstract class TransportFactory
{
//TRANSPORT_FACTORY_FINDER,transport加载路径
private static final FactoryFinder TRANSPORT_FACTORY_FINDER = new FactoryFinder("META-INF/services/org/apache/activemq/transport/");
//WIREFORMAT_FACTORY加载路径
private static final FactoryFinder WIREFORMAT_FACTORY_FINDER = new FactoryFinder("META-INF/services/org/apache/activemq/wireformat/");
private static final ConcurrentMap TRANSPORT_FACTORYS = new ConcurrentHashMap();
private static final String WRITE_TIMEOUT_FILTER = "soWriteTimeout";
private static final String THREAD_NAME_FILTER = "threadName";
//TransportFactory创建TcpTransport
public Transport doConnect(URI location, Executor ex)
throws Exception
{
return doConnect(location);
}
public Transport doConnect(URI location)
throws Exception
{
Transport rc;
Map options = new HashMap(URISupport.parseParameters(location));
if(!options.containsKey("wireFormat.host"))
options.put("wireFormat.host", location.getHost());
//创建WireFormat
WireFormat wf = createWireFormat(options);
Transport transport = createTransport(location, wf);
rc = configure(transport, wf, options);
if(!options.isEmpty())
throw new IllegalArgumentException((new StringBuilder()).append("Invalid connect parameters: ").append(options).toString());
return rc;
URISyntaxException e;
e;
throw IOExceptionSupport.create(e);
}
//配置Transport
public Transport configure(Transport transport, WireFormat wf, Map options)
throws Exception
{
transport = compositeConfigure(transport, wf, options);
transport = new MutexTransport(transport);
transport = new ResponseCorrelator(transport);
return transport;
}
}

创建WireFormat
WireFormat wf = createWireFormat(options);


  protected WireFormat createWireFormat(Map options)
throws IOException
{
//创建WireFormatFactory
WireFormatFactory factory = createWireFormatFactory(options);
//从工厂创建WireFormat
WireFormat format = factory.createWireFormat();
return format;
}

protected WireFormatFactory createWireFormatFactory(Map options)
throws IOException
{
String wireFormat;
wireFormat = (String)options.remove("wireFormat");
if(wireFormat == null)
//获取默认wireFormat类型
wireFormat = getDefaultWireFormatType();
WireFormatFactory wff;
//这个是不是有点与获取TransportFactory工厂有点像
//WIREFORMAT_FACTORY_FINDER,从META-INF/services/org/apache/activemq/wireformat/
//路径下加载相应的default配置文件,然后加载配置文件class属性对应的class
//实际org.apache.activemq.openwire.OpenWireFormatFactory
wff = (WireFormatFactory)WIREFORMAT_FACTORY_FINDER.newInstance(wireFormat);
IntrospectionSupport.setProperties(wff, options, "wireFormat.");
return wff;
Throwable e;
e;
throw IOExceptionSupport.create((new StringBuilder()).append("Could not create wire format factory for: ").append(wireFormat).append(", reason: ").append(e).toString(), e);
}

protected String getDefaultWireFormatType()
{
return "default";
}


//default配置文件内容
class=org.apache.activemq.openwire.OpenWireFormatFactory


public class OpenWireFormatFactory
implements WireFormatFactory
{
private int version;//版本
private boolean stackTraceEnabled;
private boolean tcpNoDelayEnabled;//tcp是否有延时
private boolean cacheEnabled;//是否开启缓存
private boolean tightEncodingEnabled;
private boolean sizePrefixDisabled;
private long maxInactivityDuration;
private long maxInactivityDurationInitalDelay;
private int cacheSize;缓存大小//
private long maxFrameSize;
private String host;//broker ip

public OpenWireFormatFactory()
{
version = 11;
stackTraceEnabled = true;
tcpNoDelayEnabled = true;
cacheEnabled = true;
tightEncodingEnabled = true;
maxInactivityDuration = 30000L;
maxInactivityDurationInitalDelay = 10000L;
cacheSize = 1024;
maxFrameSize = 9223372036854775807L;
host = null;
}

public WireFormat createWireFormat()
{
//创建WireFormat协议信息
WireFormatInfo info = new WireFormatInfo();
info.setVersion(version);
try
{
//设置wireFormat协议下,socket发送消息的缓存,ip,延时等信息
info.setStackTraceEnabled(stackTraceEnabled);
info.setCacheEnabled(cacheEnabled);
info.setTcpNoDelayEnabled(tcpNoDelayEnabled);
info.setTightEncodingEnabled(tightEncodingEnabled);
info.setSizePrefixDisabled(sizePrefixDisabled);
info.setMaxInactivityDuration(maxInactivityDuration);
info.setMaxInactivityDurationInitalDelay(maxInactivityDurationInitalDelay);
info.setCacheSize(cacheSize);
info.setMaxFrameSize(maxFrameSize);
if(host != null)
info.setHost(host);
}
catch(Exception e)
{
IllegalStateException ise = new IllegalStateException("Could not configure WireFormatInfo");
ise.initCause(e);
throw ise;
}
//创建OpenWireFormat
OpenWireFormat f = new OpenWireFormat(version);
f.setMaxFrameSize(maxFrameSize);
f.setPreferedWireFormatInfo(info);
return f;
}
}

//OpenWireFormat
public final class OpenWireFormat
implements WireFormat
{
public static final int DEFAULT_STORE_VERSION = 11;
public static final int DEFAULT_WIRE_VERSION = 11;
public static final int DEFAULT_LEGACY_VERSION = 6;
public static final long DEFAULT_MAX_FRAME_SIZE = 9223372036854775807L;
static final byte NULL_TYPE = 0;
private static final int MARSHAL_CACHE_SIZE = 16383;
private static final int MARSHAL_CACHE_FREE_SPACE = 100;
private DataStreamMarshaller dataMarshallers[];
private int version;
private boolean stackTraceEnabled;
private boolean tcpNoDelayEnabled;//是否有延时
private boolean cacheEnabled;//是否启动缓存
private boolean tightEncodingEnabled;
private boolean sizePrefixDisabled;
private long maxFrameSize;
private short nextMarshallCacheIndex;
private short nextMarshallCacheEvictionIndex;
private Map marshallCacheMap;
private DataStructure marshallCache[];
private DataStructure unmarshallCache[];
private DataByteArrayOutputStream bytesOut;//输出流
private DataByteArrayInputStream bytesIn;
private WireFormatInfo preferedWireFormatInfo;//协议信息
public OpenWireFormat(int i)
{
maxFrameSize = 9223372036854775807L;
marshallCacheMap = new HashMap();
marshallCache = null;
unmarshallCache = null;
bytesOut = new DataByteArrayOutputStream();
bytesIn = new DataByteArrayInputStream();
setVersion(i);
}
}

从上面分析可以看出TcpTransport的协议为OpenWireFormat

再回到TcpTransport发送命令
//将命令写到dataOut缓存区中,而dataOut我们在前面分析中TcpTransport的启动中,
//TcpTransport与Broker建立套接字,dataOUt为socket的输出流,前文中我们分析过dataOut为DataOutputStream

 wireFormat.marshal(command, dataOut);


//OpenWireFormat


 public synchronized void marshal(Object o, DataOutput dataOut)
throws IOException
{
if(cacheEnabled)
runMarshallCacheEvictionSweep();
int size = 1;
if(o != null)
{
//获取数据类型
DataStructure c = (DataStructure)o;
byte type = c.getDataStructureType();
DataStreamMarshaller dsm = dataMarshallers[type & 255];
if(dsm == null)
throw new IOException((new StringBuilder()).append("Unknown data type: ").append(type).toString());
if(tightEncodingEnabled)
{
BooleanStream bs = new BooleanStream();
size += dsm.tightMarshal1(this, c, bs);
size += bs.marshalledSize();
if(!sizePrefixDisabled)
dataOut.writeInt(size);
dataOut.writeByte(type);
bs.marshal(dataOut);
dsm.tightMarshal2(this, c, dataOut, bs);
} else
{
DataOutput looseOut = dataOut;
if(!sizePrefixDisabled)
{
bytesOut.restart();
looseOut = bytesOut;
}
//将类型写到数据输出流
looseOut.writeByte(type);
//将消息信息写到输出流
dsm.looseMarshal(this, c, looseOut);
if(!sizePrefixDisabled)
{
ByteSequence sequence = bytesOut.toByteSequence();
dataOut.writeInt(sequence.getLength());
dataOut.write(sequence.getData(), sequence.getOffset(), sequence.getLength());
}
}
} else
{
if(!sizePrefixDisabled)
dataOut.writeInt(size);
dataOut.writeByte(0);
}
}

将消息信息写到输出流
dsm.looseMarshal(this, c, looseOut);

//WireFormatInfoMarshaller
public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut)
throws IOException
{
WireFormatInfo info = (WireFormatInfo)o;
info.beforeMarshall(wireFormat);
super.looseMarshal(wireFormat, o, dataOut);
looseMarshalConstByteArray(wireFormat, info.getMagic(), dataOut, 8);
dataOut.writeInt(info.getVersion());
looseMarshalByteSequence(wireFormat, info.getMarshalledProperties(), dataOut);
}


做个小节:
生产者发送消息,首先转换消息,然后通过会话发送消息,会话创建事务,并通过连接发送事务信息,最后会话通过连接发送信息,连接发送信息,实际上是通过ResponseCorrelator,ResponseCorrelator设置发送消息的命令id及是否需要回复信息,然后交给MutexTransport,MutexTransport首先获取发送消息命令锁,再通过TcpTransport发送,MutexTransport最后通过OpenWireFormat发送消息。

记录消息发送事件
stats.onMessage();

//JMSEndpointStatsImpl
public class JMSEndpointStatsImpl extends StatsImpl
{
protected CountStatisticImpl messageCount;//消息数统计
protected CountStatisticImpl pendingMessageCount;
protected CountStatisticImpl expiredMessageCount;//过期消息统计
protected TimeStatisticImpl messageWaitTime;//消息等待时间统计
protected TimeStatisticImpl messageRateTime;
public void onMessage()
{
if(enabled)
{
long start = messageCount.getLastSampleTime();
messageCount.increment();//增加消息数
long end = messageCount.getLastSampleTime();
messageRateTime.addTime(end - start);
}
}
}

//CountStatisticImpl
public class CountStatisticImpl extends StatisticImpl
implements CountStatistic
{
private final AtomicLong counter;//消息计数器
private CountStatisticImpl parent;
//生产者,生产消息,增加消息计数器
public void increment()
{
if(isEnabled())
{
counter.incrementAndGet();
updateSampleTime();
if(parent != null)
parent.increment();
}
}
}

4.会话提交
session.commit(); 

//ActiveMQSession
public void commit()
throws JMSException
{
checkClosed();
if(!getTransacted())
throw new IllegalStateException("Not a transacted session");
if(LOG.isDebugEnabled())
LOG.debug((new StringBuilder()).append(getSessionId()).append(" Transaction Commit :").append(transactionContext.getTransactionId()).toString());
//提交事务
transactionContext.commit();
}

//TransactionContext
public void commit()
throws JMSException
{
if(isInXATransaction())
throw new TransactionInProgressException("Cannot commit() if an XA transaction is already in progress ");
try
{
beforeEnd();
}
catch(JMSException e)
{
rollback();
throw e;
}
if(transactionId != null)
{
LOG.debug("Commit: {} syncCount: {}", transactionId, Integer.valueOf(synchronizations == null ? 0 : synchronizations.size()));
TransactionInfo info = new TransactionInfo(getConnectionId(), transactionId, (byte)2);
transactionId = null;
try
{
//发送事务提交信息
syncSendPacketWithInterruptionHandling(info);
if(localTransactionEventListener != null)
localTransactionEventListener.commitEvent();
afterCommit();
}
catch(JMSException cause)
{
LOG.info("commit failed for transaction {}", info.getTransactionId(), cause);
if(localTransactionEventListener != null)
localTransactionEventListener.rollbackEvent();
afterRollback();
throw cause;
}
}
}



5.关闭连接
connection.close(); 


public void close()
throws JMSException
{
boolean interrupted = Thread.interrupted();
if(!closed.get() && !transportFailed.get())
//关闭会话
doStop(false);
synchronized(this)
{
if(!closed.get())
{
closing.set(true);//设置关闭状态
//关闭目的地
if(destinationSource != null)
{
destinationSource.stop();
destinationSource = null;
}
if(advisoryConsumer != null)
{
advisoryConsumer.dispose();
advisoryConsumer = null;
}
//关闭调度器
Scheduler scheduler = this.scheduler;
if(scheduler != null)
try
{
scheduler.stop();
}
catch(Exception e)
{
JMSException ex = JMSExceptionSupport.create(e);
throw ex;
}
long lastDeliveredSequenceId = -1L;
for(Iterator i = sessions.iterator(); i.hasNext();)
{
ActiveMQSession s = (ActiveMQSession)i.next();
s.dispose();
lastDeliveredSequenceId = Math.max(lastDeliveredSequenceId, s.getLastDeliveredSequenceId());
}

ActiveMQConnectionConsumer c;
//移除消费者信息
for(Iterator i = connectionConsumers.iterator(); i.hasNext(); c.dispose())
c = (ActiveMQConnectionConsumer)i.next();

activeTempDestinations.clear();
if(isConnectionInfoSentToBroker)
{
RemoveInfo removeCommand = info.createRemoveCommand();
removeCommand.setLastDeliveredSequenceId(lastDeliveredSequenceId);
try
{
//发送移除命令
doSyncSendPacket(removeCommand, closeTimeout);
}
catch(JMSException e)
{
if(!(e.getCause() instanceof RequestTimedOutIOException))
throw e;
}
//发送关闭命令
doAsyncSendPacket(new ShutdownInfo());
}
started.set(false);
if(sessionTaskRunner != null)
sessionTaskRunner.shutdown();
closed.set(true);
closing.set(false);
}
}
try
{
if(executor != null)
//关闭线程执行器
ThreadPoolUtils.shutdown(executor);
}
catch(Throwable e)
{
LOG.warn((new StringBuilder()).append("Error shutting down thread pool: ").append(executor).append(". This exception will be ignored.").toString(), e);
}
//关闭transport
ServiceSupport.dispose(transport);
//从连接状态管理器移除连接
factoryStats.removeConnection(this);
if(interrupted)
Thread.currentThread().interrupt();
break MISSING_BLOCK_LABEL_506;
Exception exception1;
exception1;
try
{
if(executor != null)
ThreadPoolUtils.shutdown(executor);
}
catch(Throwable e)
{
LOG.warn((new StringBuilder()).append("Error shutting down thread pool: ").append(executor).append(". This exception will be ignored.").toString(), e);
}
ServiceSupport.dispose(transport);
factoryStats.removeConnection(this);
if(interrupted)
Thread.currentThread().interrupt();
throw exception1;
}

//关闭会话
 void doStop(boolean checkClosed)
throws JMSException
{
if(checkClosed)
checkClosedOrFailed();
if(started.compareAndSet(true, false))
synchronized(sessions)
{
ActiveMQSession s;
for(Iterator i = sessions.iterator(); i.hasNext(); s.stop())
s = (ActiveMQSession)i.next();

}
}


总结:

[color=green]ActiveMQTopic和ActiveMQQueue可以看出本质都是ActiveMQDestination
只是JNDI和数据结构类型不同;会话创建消息生产者就是,初始化ActiveMQMessageProducer的生产者信息,生产者状态管理器,消息序列号,传输模式(默认持久化),消息转化器,生产者窗口,并将生产者信息通过会话发送给Server;ActiveMQTopicPublisher本质上是ActiveMQMessageProducer,TopicPublisher的消息的发送都是委托给ActiveMQMessageProducer;生产者发送消息,首先转换消息,然后通过会话发送消息,
会话创建事务,并通过连接发送事务信息,最后会话通过连接发送信息,连接发送信息,实际上是通过ResponseCorrelator,ResponseCorrelator设置发送消息的命令id及是否需要回复信息,然后交给MutexTransport,MutexTransport首先获取发送消息命令锁,再通过TcpTransport发送,MutexTransport最后通过OpenWireFormat发送消息;关闭连接就是关闭执行器,TcpTransport,调度器,移除消费者信息,向broker发送关闭命令。
[/color]


//内存使用
public class MemoryUsage extends Usage
{
public MemoryUsage(String name)
{
this(null, name);
}
//等待空间可利用
public boolean waitForSpace(long timeout)
throws InterruptedException
{
if(parent != null && !((MemoryUsage)parent).waitForSpace(timeout))
return false;
usageLock.readLock().lock();
if(percentUsage < 100)
break MISSING_BLOCK_LABEL_124;
usageLock.readLock().unlock();
usageLock.writeLock().lock();
while(percentUsage >= 100)
waitForSpaceCondition.await(timeout, TimeUnit.MILLISECONDS);
usageLock.readLock().lock();
usageLock.writeLock().unlock();
break MISSING_BLOCK_LABEL_124;
Exception exception;
exception;
usageLock.writeLock().unlock();
throw exception;
boolean flag = percentUsage < 100;
usageLock.readLock().unlock();
return flag;
Exception exception1;
exception1;
usageLock.readLock().unlock();
throw exception1;
}
//内存是否满
public boolean isFull()
{
if(parent != null && ((MemoryUsage)parent).isFull())
return true;
usageLock.readLock().lock();
boolean flag = percentUsage >= 100;
usageLock.readLock().unlock();
return flag;
Exception exception;
exception;
usageLock.readLock().unlock();
throw exception;
}
//增加内存使用量
public void increaseUsage(long value)
{
if(value == 0L)
return;
usageLock.writeLock().lock();
usage += value;
setPercentUsage(caclPercentUsage());
usageLock.writeLock().unlock();
break MISSING_BLOCK_LABEL_61;
Exception exception;
exception;
usageLock.writeLock().unlock();
throw exception;
if(parent != null)
((MemoryUsage)parent).increaseUsage(value);
return;
}
//减少内存使用量
public void decreaseUsage(long value)
{
if(value == 0L)
return;
usageLock.writeLock().lock();
usage -= value;
setPercentUsage(caclPercentUsage());
usageLock.writeLock().unlock();
break MISSING_BLOCK_LABEL_61;
Exception exception;
exception;
usageLock.writeLock().unlock();
throw exception;
if(parent != null)
((MemoryUsage)parent).decreaseUsage(value);
return;
}
}

public abstract class Usage
implements Service
{
//内存使用锁
protected final ReentrantReadWriteLock usageLock = new ReentrantReadWriteLock();
protected final Condition waitForSpaceCondition;//等待条件
protected int percentUsage;//内存使用百分比
protected Usage parent;
protected String name;
private UsageCapacity limiter;
private int percentUsageMinDelta;
private final List listeners = new CopyOnWriteArrayList();
private final boolean debug;
private float usagePortion;
private final List children = new CopyOnWriteArrayList();
private final List callbacks = new LinkedList();
private int pollingTime;
private final AtomicBoolean started = new AtomicBoolean();
private ThreadPoolExecutor executor;
}


//消息,消息目的转化器
public final class ActiveMQMessageTransformation
{
//转化目的地
public static ActiveMQDestination transformDestination(Destination destination)
throws JMSException
{
ActiveMQDestination activeMQDestination = null;
if(destination != null)
{
if(destination instanceof ActiveMQDestination)
return (ActiveMQDestination)destination;
if(destination instanceof TemporaryQueue)
activeMQDestination = new ActiveMQTempQueue(((Queue)destination).getQueueName());
else
if(destination instanceof TemporaryTopic)
activeMQDestination = new ActiveMQTempTopic(((Topic)destination).getTopicName());
else
if(destination instanceof Queue)
activeMQDestination = new ActiveMQQueue(((Queue)destination).getQueueName());
else
if(destination instanceof Topic)
activeMQDestination = new ActiveMQTopic(((Topic)destination).getTopicName());
}
return activeMQDestination;
}
//转换消息
public static ActiveMQMessage transformMessage(Message message, ActiveMQConnection connection)
throws JMSException
{
if(message instanceof ActiveMQMessage)
return (ActiveMQMessage)message;
ActiveMQMessage activeMessage = null;
if(message instanceof BytesMessage)
{
BytesMessage bytesMsg = (BytesMessage)message;
bytesMsg.reset();
ActiveMQBytesMessage msg = new ActiveMQBytesMessage();
msg.setConnection(connection);
try
{
do
msg.writeByte(bytesMsg.readByte());
while(true);
}
catch(MessageEOFException messageeofexception) { }
catch(JMSException jmsexception) { }
activeMessage = msg;
} else
if(message instanceof MapMessage)
{
MapMessage mapMsg = (MapMessage)message;
ActiveMQMapMessage msg = new ActiveMQMapMessage();
msg.setConnection(connection);
String name;
for(Enumeration iter = mapMsg.getMapNames(); iter.hasMoreElements(); msg.setObject(name, mapMsg.getObject(name)))
name = iter.nextElement().toString();

activeMessage = msg;
} else
if(message instanceof ObjectMessage)
{
ObjectMessage objMsg = (ObjectMessage)message;
ActiveMQObjectMessage msg = new ActiveMQObjectMessage();
msg.setConnection(connection);
msg.setObject(objMsg.getObject());
msg.storeContent();
activeMessage = msg;
} else
if(message instanceof StreamMessage)
{
StreamMessage streamMessage = (StreamMessage)message;
streamMessage.reset();
ActiveMQStreamMessage msg = new ActiveMQStreamMessage();
msg.setConnection(connection);
Object obj = null;
try
{
while((obj = streamMessage.readObject()) != null)
msg.writeObject(obj);
}
catch(MessageEOFException messageeofexception1) { }
catch(JMSException jmsexception1) { }
activeMessage = msg;
} else
if(message instanceof TextMessage)
{
TextMessage textMsg = (TextMessage)message;
ActiveMQTextMessage msg = new ActiveMQTextMessage();
msg.setConnection(connection);
msg.setText(textMsg.getText());
activeMessage = msg;
} else
if(message instanceof BlobMessage)
{
BlobMessage blobMessage = (BlobMessage)message;
ActiveMQBlobMessage msg = new ActiveMQBlobMessage();
msg.setConnection(connection);
if(connection != null)
msg.setBlobDownloader(new BlobDownloader(connection.getBlobTransferPolicy()));
try
{
msg.setURL(blobMessage.getURL());
}
catch(MalformedURLException malformedurlexception) { }
activeMessage = msg;
} else
{
activeMessage = new ActiveMQMessage();
activeMessage.setConnection(connection);
}
copyProperties(message, activeMessage);
return activeMessage;
}

public static void copyProperties(Message fromMessage, Message toMessage)
throws JMSException
{
toMessage.setJMSMessageID(fromMessage.getJMSMessageID());
toMessage.setJMSCorrelationID(fromMessage.getJMSCorrelationID());
toMessage.setJMSReplyTo(transformDestination(fromMessage.getJMSReplyTo()));
toMessage.setJMSDestination(transformDestination(fromMessage.getJMSDestination()));
toMessage.setJMSDeliveryMode(fromMessage.getJMSDeliveryMode());
toMessage.setJMSRedelivered(fromMessage.getJMSRedelivered());
toMessage.setJMSType(fromMessage.getJMSType());
toMessage.setJMSExpiration(fromMessage.getJMSExpiration());
toMessage.setJMSPriority(fromMessage.getJMSPriority());
toMessage.setJMSTimestamp(fromMessage.getJMSTimestamp());
String name;
Object obj;
for(Enumeration propertyNames = fromMessage.getPropertyNames(); propertyNames.hasMoreElements(); toMessage.setObjectProperty(name, obj))
{
name = propertyNames.nextElement().toString();
obj = fromMessage.getObjectProperty(name);
}

}
}



public interface DeliveryMode
{
public static final int NON_PERSISTENT = 1;
public static final int PERSISTENT = 2;
}



package java.io;

import java.io.ObjectOutput;
import java.io.ObjectInput;

/**
* Only the identity of the class of an Externalizable instance is
* written in the serialization stream and it is the responsibility
* of the class to save and restore the contents of its instances.
*
* The writeExternal and readExternal methods of the Externalizable
* interface are implemented by a class to give the class complete
* control over the format and contents of the stream for an object
* and its supertypes. These methods must explicitly
* coordinate with the supertype to save its state. These methods supersede
* customized implementations of writeObject and readObject methods.

*
* Object Serialization uses the Serializable and Externalizable
* interfaces. Object persistence mechanisms can use them as well. Each
* object to be stored is tested for the Externalizable interface. If
* the object supports Externalizable, the writeExternal method is called. If the
* object does not support Externalizable and does implement
* Serializable, the object is saved using
* ObjectOutputStream.
When an Externalizable object is
* reconstructed, an instance is created using the public no-arg
* constructor, then the readExternal method called. Serializable
* objects are restored by reading them from an ObjectInputStream.

*
* An Externalizable instance can designate a substitution object via
* the writeReplace and readResolve methods documented in the Serializable
* interface.

*
* @author unascribed
* @see java.io.ObjectOutputStream
* @see java.io.ObjectInputStream
* @see java.io.ObjectOutput
* @see java.io.ObjectInput
* @see java.io.Serializable
* @since JDK1.1
*/
public interface Externalizable extends java.io.Serializable {
/**
* The object implements the writeExternal method to save its contents
* by calling the methods of DataOutput for its primitive values or
* calling the writeObject method of ObjectOutput for objects, strings,
* and arrays.
*
* @serialData Overriding methods should use this tag to describe
* the data layout of this Externalizable object.
* List the sequence of element types and, if possible,
* relate the element to a public/protected field and/or
* method of this Externalizable class.
*
* @param out the stream to write the object to
* @exception IOException Includes any I/O exceptions that may occur
*/
void writeExternal(ObjectOutput out) throws IOException;

/**
* The object implements the readExternal method to restore its
* contents by calling the methods of DataInput for primitive
* types and readObject for objects, strings and arrays. The
* readExternal method must read the values in the same sequence
* and with the same types as were written by writeExternal.
*
* @param in the stream to read data from in order to restore the object
* @exception IOException if I/O errors occur
* @exception ClassNotFoundException If the class for an object being
* restored cannot be found.
*/
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}


package java.io;

/**
* ObjectOutput extends the DataOutput interface to include writing of objects.
* DataOutput includes methods for output of primitive types, ObjectOutput
* extends that interface to include objects, arrays, and Strings.
*
* @author unascribed
* @see java.io.InputStream
* @see java.io.ObjectOutputStream
* @see java.io.ObjectInputStream
* @since JDK1.1
*/
public interface ObjectOutput extends DataOutput, AutoCloseable {
/**
* Write an object to the underlying storage or stream. The
* class that implements this interface defines how the object is
* written.
*
* @param obj the object to be written
* @exception IOException Any of the usual Input/Output related exceptions.
*/
public void writeObject(Object obj)
throws IOException;

/**
* Writes a byte. This method will block until the byte is actually
* written.
* @param b the byte
* @exception IOException If an I/O error has occurred.
*/
public void write(int b) throws IOException;

/**
* Writes an array of bytes. This method will block until the bytes
* are actually written.
* @param b the data to be written
* @exception IOException If an I/O error has occurred.
*/
public void write(byte b[]) throws IOException;

/**
* Writes a sub array of bytes.
* @param b the data to be written
* @param off the start offset in the data
* @param len the number of bytes that are written
* @exception IOException If an I/O error has occurred.
*/
public void write(byte b[], int off, int len) throws IOException;

/**
* Flushes the stream. This will write any buffered
* output bytes.
* @exception IOException If an I/O error has occurred.
*/
public void flush() throws IOException;

/**
* Closes the stream. This method must be called
* to release any resources associated with the
* stream.
* @exception IOException If an I/O error has occurred.
*/
public void close() throws IOException;
}

你可能感兴趣的:(ActiveMQ,activemq)