ActiveMQ Broker发送消息给消费者过程详解

最新推荐文章于 2023-05-21 15:46:34 发布
最新推荐文章于 2023-05-21 15:46:34 发布
阅读量523 收藏
点赞数
分类专栏： ActiveMQ 文章标签： 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]
引言：
从activemq脚本，可以看出启动ActiveMQ实际是启动，bin文件夹下的其实activemq.jar
包中有一个类为Main，这就是active的启动入口,Main主要是加载lib目录和ClassPath，初始化
类加载器，委托给ShellCommand，由ShellCommand根据命令描述去执行，如果是Version和HELP，
则打印信息，若是启动命令，则通过XBeanBrokerFactory创建BrokerService，这个过程主要利用的Spring的bean容器机制，然后启动BrokerService，主要启动持久化适配器，JMX连接，上下文关系器，最后启动所有网络连接，及TcpTransport连接TransportConnector，默认使用的是openwire：tcp，所以我们就看一下TcpTransportServer，TcpTransportServer有TcpTransportFactory创建并配置OpenWire协议转换器，启动TcpTransportServer，就是从ServerSocketFactory获取ServerSocket，并绑定ip和port，监听连接
，并设置ServerSocket的监听器org.apache.activemq.transport.nio.SelectorManager.Listener，这个用的是java nio。
前一篇文章中，说过ActiveMQ启动过程，今天看一下TcpTransportServer与ActiveMQConnection如何交互，如何将消息发送给消费者，从TransportConnector启动开始。

//TransportConnector
//启动TCP监听 
public void start()
        throws Exception
    {
        broker = brokerService.getBroker();
        brokerInfo.setBrokerName(broker.getBrokerName());
        brokerInfo.setBrokerId(broker.getBrokerId());
        brokerInfo.setPeerBrokerInfos(broker.getPeerBrokerInfos());
        brokerInfo.setFaultTolerantConfiguration(broker.isFaultTolerantConfiguration());
        brokerInfo.setBrokerURL(broker.getBrokerService().getDefaultSocketURIString());
	//添加TcpTransportServer的监听器
        getServer().setAcceptListener(new TransportAcceptListener() {
            public void onAccept(final Transport transport)
            {
                try
                {
                    brokerService.getTaskRunnerFactory().execute(new Runnable() {
                        public void run()
                        {
                            try
                            {
                                if(!brokerService.isStopping())
                                {
				   //创建TransportConnector，并启动
                                    Connection connection = createConnection(transport);
                                    connection.start();
				  }
                            }
                        }

                        final Transport val$transport;
                        final _cls1 this$1;
                    {
                        this$1 = _cls1.this;
                        transport = transport1;
                        super();
                    }
                    });
                }
            }
            final TransportConnector this$0;
            {
                this$0 = TransportConnector.this;
                super();
            }
        });
	//启动TcpTransportServer
        getServer().setBrokerInfo(brokerInfo);
        getServer().start();
        DiscoveryAgent da = getDiscoveryAgent();
        if(da != null)
        {
            da.registerService(getPublishableConnectString());
            da.start();
        }
        if(enableStatusMonitor)
        {
            statusDector = new TransportStatusDetector(this);
            statusDector.start();
        }
    }

//创建TransportConnector连接
 protected Connection createConnection(Transport transport)
        throws IOException
    {
        TransportConnection answer = new TransportConnection(this, transport, broker, disableAsyncDispatch ? null : taskRunnerFactory, brokerService.getTaskRunnerFactory());
        boolean statEnabled = getStatistics().isEnabled();
        answer.getStatistics().setEnabled(statEnabled);
        answer.setMessageAuthorizationPolicy(messageAuthorizationPolicy);
        return answer;
    }

我们再来看TcpTransportServer的启动
getServer().start();
这个启动有两层含义一是启动TcpTransportServer线程，而是启动Service，
先来看第一层含义
//TcpTransportServer 
public void run()
    {
        final ServerSocketChannel chan = serverSocket.getChannel();
        if(chan != null)
            try
            {
	        //如果socket通道存在，则设置通道选择器
                chan.configureBlocking(false);
                selector = SelectorManager.getInstance().register(chan, new org.apache.activemq.transport.nio.SelectorManager.Listener() {
                    public void onSelect(SelectorSelection sel)
                    {
                        try
                        {
                            SocketChannel sc = chan.accept();
                            if(sc != null)
                                if(isStopped() || getAcceptListener() == null)
                                    sc.close();
                                else
                                if(useQueueForAccept)
                                    socketQueue.put(sc.socket());
                                else
                                    handleSocket(sc.socket());
                        }
                    }
                    final ServerSocketChannel val$chan;
                    final TcpTransportServer this$0;
            {
                this$0 = TcpTransportServer.this;
                chan = serversocketchannel;
                super();
            }
                });
                selector.setInterestOps(16);
                selector.enable();
            }
        else
            do
            {
	       //如果socket通道不存在，则serverSocket接受连接，并处理Socket连接
                if(isStopped())
                    break;
                Socket socket = null;
                try
                {
                    socket = serverSocket.accept();
                    if(socket != null)
                        if(isStopped() || getAcceptListener() == null)
                            socket.close();
                        else
                        if(useQueueForAccept)
                            socketQueue.put(socket);
                        else
                            handleSocket(socket);
                }
            } while(true);
    }

protected final void handleSocket(Socket socket)
    {
        boolean closeSocket = true;
        try
        {
            if(currentTransportCount.get() >= maximumConnections)
                throw new ExceededMaximumConnectionsException("Exceeded the maximum number of allowed client connections. See the 'maximumConnections' property on the TCP transport configuration URI in the ActiveMQ configuration file (e.g., activemq.xml)");
            HashMap options = new HashMap();
            options.put("maxInactivityDuration", Long.valueOf(maxInactivityDuration));
            options.put("maxInactivityDurationInitalDelay", Long.valueOf(maxInactivityDurationInitalDelay));
            options.put("minmumWireFormatVersion", Integer.valueOf(minmumWireFormatVersion));
            options.put("trace", Boolean.valueOf(trace));
            options.put("soTimeout", Integer.valueOf(soTimeout));
            options.put("socketBufferSize", Integer.valueOf(socketBufferSize));
            options.put("connectionTimeout", Integer.valueOf(connectionTimeout));
            options.put("logWriterName", logWriterName);
            options.put("dynamicManagement", Boolean.valueOf(dynamicManagement));
            options.put("startLogging", Boolean.valueOf(startLogging));
            options.putAll(transportOptions);
            WireFormat format = wireFormatFactory.createWireFormat();
	    //创建transport
            Transport transport = createTransport(socket, format);
            closeSocket = false;
	    //将transport添加到ServiceSupport监听器列表中
            if(transport instanceof ServiceSupport)
                ((ServiceSupport)transport).addServiceListener(this);
            Transport configuredTransport = transportFactory.serverConfigure(transport, format, options);
	    //TcpTransportServer监听器接受连接transport，
            getAcceptListener().onAccept(configuredTransport);
            currentTransportCount.incrementAndGet();
        }
    }

    protected Transport createTransport(Socket socket, WireFormat format)
        throws IOException
    {
        return new TcpTransport(format, socket);
    }


TcpTransportServer父类栈 

public class TcpTransportServer extends TransportServerThreadSupport
    implements ServiceListener

public abstract class TransportServerThreadSupport extends TransportServerSupport
    implements Runnable

public abstract class TransportServerSupport extends ServiceSupport
    implements TransportServer


再来看Service层的启动 
public abstract class ServiceSupport
    implements Service
{
    private AtomicBoolean started;
    private AtomicBoolean stopping;
    private AtomicBoolean stopped;
    private List serviceListeners;//service监听器

    public void start()
        throws Exception
    {
        boolean success;
        if(!started.compareAndSet(false, true))
            break MISSING_BLOCK_LABEL_93;
        success = false;
        stopped.set(false);
        preStart();
	//doStart为抽象函数，待父类扩展
        doStart();
        success = true;
        started.set(success);
        break MISSING_BLOCK_LABEL_54;
        Exception exception;
        exception;
        started.set(success);
        throw exception;
        ServiceListener l;
	//启动所有Service监听，在TcpServe处理Socket的连接中（handleSocket），
	//将transport添加到ServiceSupport监听器列表中
        for(Iterator i$ = serviceListeners.iterator(); i$.hasNext(); l.started(this))
            l = (ServiceListener)i$.next();

    }
}

而TcpTransport也是service，来看他的启动，也有两层含义，第一启动TcpTransport线程，而启动Service，

先看第一层

//初始化Socket，及数据输入输出流，已经过，这里不再将 
protected void doStart()
        throws Exception
    {
        //连接
        connect();
        stoppedLatch.set(new CountDownLatch(1));
        super.doStart();
    }

    protected void connect()
        throws Exception
    {
        InetSocketAddress localAddress = null;
        InetSocketAddress remoteAddress = null;
        if(localLocation != null)
            localAddress = new InetSocketAddress(InetAddress.getByName(localLocation.getHost()), localLocation.getPort());
        if(remoteLocation != null)
        {
            String host = resolveHostName(remoteLocation.getHost());
            remoteAddress = new InetSocketAddress(host, remoteLocation.getPort());
        }
        trafficClassSet = setTrafficClass(socket);
        if(socket != null)
        {
            if(localAddress != null)
                socket.bind(localAddress);
            if(remoteAddress != null)
                if(connectionTimeout >= 0)
                    socket.connect(remoteAddress, connectionTimeout);
                else
                    socket.connect(remoteAddress);
        } else
        if(localAddress != null)
            socket = socketFactory.createSocket(remoteAddress.getAddress(), remoteAddress.getPort(), localAddress.getAddress(), localAddress.getPort());
        else
            socket = socketFactory.createSocket(remoteAddress.getAddress(), remoteAddress.getPort());
        initialiseSocket(socket);
        initializeStreams();
    }


再看TcpTransport线程的启动 

public class TcpTransport extends TransportThreadSupport
    implements Transport, Service, Runnable
{
 public void run()
    {
        LOG.trace((new StringBuilder()).append("TCP consumer thread for ").append(this).append(" starting").toString());
        runnerThread = Thread.currentThread();
	//如果TcpTransport
        for(; !isStopped(); doRun());
        ((CountDownLatch)stoppedLatch.get()).countDown();
    }
}
 protected void doRun()
        throws IOException
    {
        try
        {
	    //读取命令
            Object command = readCommand();
	    //处理命令
            doConsume(command);
        }
    }

读取命令 
Object command = readCommand();
 protected Object readCommand()
        throws IOException
    {
        //通过wireFormat解析字节流
        return wireFormat.unmarshal(dataIn);
    }

//OpenWireFormat 
public final class OpenWireFormat
    implements WireFormat
{
    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 synchronized Object unmarshal(ByteSequence sequence)
        throws IOException
    {
        //从二进制字节流读取数据到缓存，记录读取位置
        bytesIn.restart(sequence);
        if(!sizePrefixDisabled)
        {
            int size = bytesIn.readInt();
            if(sequence.getLength() - 4 == size);
            if((long)size > maxFrameSize)
                throw new IOException((new StringBuilder()).append("Frame size of ").append(size / 1048576).append(" MB larger than max allowed ").append(maxFrameSize / 1048576L).append(" MB").toString());
        }
        //解析输入流，转为为command
	Object command = doUnmarshal(bytesIn);
        return command;
    }
}

//DataByteArrayInputStream 
public final class DataByteArrayInputStream extends InputStream
    implements DataInput
{

    private byte buf[];
    private int pos;
    private int offset;
    //从二进制字节流读取数据到缓存，记录读取位置
       public void restart(ByteSequence sequence)
    {
        buf = sequence.getData();
        pos = sequence.getOffset();
    }
}

//OpenWireFormat
解析输入流，转为为command 
public Object doUnmarshal(DataInput dis)
        throws IOException
    {
        //获取命令类型
        byte dataType = dis.readByte();
        if(dataType != 0)
        {
	    //创建命令字节流对应大小的字节流处理器,DataStreamMarshaller为WireFormatInfoMarshaller
            DataStreamMarshaller dsm = dataMarshallers[dataType & 255];
            if(dsm == null)
                throw new IOException((new StringBuilder()).append("Unknown data type: ").append(dataType).toString());
	    //创建命令对应的数据结构
	    Object data = dsm.createObject();
            if(tightEncodingEnabled)
            {
                BooleanStream bs = new BooleanStream();
                bs.unmarshal(dis);
                dsm.tightUnmarshal(this, data, dis, bs);
            } else
            {
	        //解析命令字节流
                dsm.looseUnmarshal(this, data, dis);
            }
            return data;
        } else
        {
            return null;
        }
    }

//WireFormatInfoMarshaller 
 public class WireFormatInfoMarshaller extends BaseDataStreamMarshaller
{
    //创建命令对应的数据结构
    public DataStructure createObject()
    {
        return new WireFormatInfo();
    }
    //设置WireFormat格式下，命令命令对应的魔数，版本信息 
public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn)
        throws IOException
    {
        //解析命令字节流,委托给BaseDataStreamMarshaller
        super.looseUnmarshal(wireFormat, o, dataIn);
        WireFormatInfo info = (WireFormatInfo)o;
	//如果命令字节流属性不为null，则初始化命令字节流
        info.beforeUnmarshall(wireFormat);
        info.setMagic(looseUnmarshalConstByteArray(dataIn, 8));
        info.setVersion(dataIn.readInt());
	//设置命令字节流属性
        info.setMarshalledProperties(looseUnmarshalByteSequence(dataIn));
        info.afterUnmarshall(wireFormat);
    }
}

//WireFormatInfo 
public class WireFormatInfo
    implements Command, MarshallAware
{
public static final byte DATA_STRUCTURE_TYPE = 1;
    private static final int MAX_PROPERTY_SIZE = 4096;
    private static final byte MAGIC[] = {
        65, 99, 116, 105, 118, 101, 77, 81
    };
    protected byte magic[];
    protected int version;
    protected ByteSequence marshalledProperties;
    protected transient Map properties;
    private transient Endpoint from;
    private transient Endpoint to;
    public void beforeMarshall(WireFormat wireFormat)
        throws IOException
    {
        if(marshalledProperties == null && properties != null)
        {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            DataOutputStream os = new DataOutputStream(baos);
            MarshallingSupport.marshalPrimitiveMap(properties, os);
            os.close();
            marshalledProperties = baos.toByteSequence();
        }
    }
    //设置命令字节流属性
  public void setMarshalledProperties(ByteSequence marshalledProperties)
    {
        this.marshalledProperties = marshalledProperties;
    }
}

//BaseDataStreamMarshaller 
public abstract class BaseDataStreamMarshaller
    implements DataStreamMarshaller
{
   public static final Constructor STACK_TRACE_ELEMENT_CONSTRUCTOR;

    static 
    {
        Constructor constructor = null;
        try
        {
            constructor = java/lang/StackTraceElement.getConstructor(new Class[] {
                java/lang/String, java/lang/String, java/lang/String, Integer.TYPE
            });
        }
        catch(Throwable throwable) { }
        STACK_TRACE_ELEMENT_CONSTRUCTOR = constructor;
    }
    //待扩展
     public void looseUnmarshal(OpenWireFormat openwireformat, Object obj, DataInput datainput)
        throws IOException
    {
    }
}

}

回到TcpTransport处理命令 
doConsume(command);

处理命令 
public void doConsume(Object command)
    {
        if(command != null)
            if(transportListener != null)
	    //如果transport监听器不为空，则处理命令
                transportListener.onCommand(command);
            else
                LOG.error((new StringBuilder()).append("No transportListener available to process inbound command: ").append(command).toString());
    }

public abstract class TransportSupport extends ServiceSupport
    implements Transport
{
     TransportListener transportListener;//transport监听器
     public void doConsume(Object command)
    {
        if(command != null)
            if(transportListener != null)
                transportListener.onCommand(command);
            else
                LOG.error((new StringBuilder()).append("No transportListener available to process inbound command: ").append(command).toString());
    }
}

再回到看ActiveMQConnection实现transportListener 
public class ActiveMQConnection
    implements Connection, TopicConnection, QueueConnection, StatsCapable, Closeable, TransportListener, EnhancedConnection
{
 public void onCommand(Object o)
    {
        final Command command = (Command)o;
        if(!closed.get() && command != null)
            try
            {
                command.visit(new CommandVisitorAdapter() {
                    //分发消息
                    public Response processMessageDispatch(MessageDispatch md)
                        throws Exception
                    {
                        waitForTransportInterruptionProcessingToComplete();
			//根据分发消息id，获取消费者，然后消费者，消费消息
                        ActiveMQDispatcher dispatcher = (ActiveMQDispatcher)dispatchers.get(md.getConsumerId());
                        if(dispatcher != null)
                        {
                            Message msg = md.getMessage();
                            if(msg != null)
                            {
                                msg = msg.copy();
                                msg.setReadOnlyBody(true);
                                msg.setReadOnlyProperties(true);
                                msg.setRedeliveryCounter(md.getRedeliveryCounter());
                                msg.setConnection(ActiveMQConnection.this);
                                msg.setMemoryUsage(null);
                                md.setMessage(msg);
                            }
			    //分发消息
                            dispatcher.dispatch(md);
                    }
                    //处理生产者恢复消息
                    public Response processProducerAck(ProducerAck pa)
                        throws Exception
                    {
                        if(pa != null && pa.getProducerId() != null)
                        {
                            ActiveMQMessageProducer producer = (ActiveMQMessageProducer)producers.get(pa.getProducerId());
                            if(producer != null)
                                producer.onProducerAck(pa);
                        }
                        return null;
                    }
                    //处理broker
                    public Response processBrokerInfo(BrokerInfo info)
                        throws Exception
                    {
                        brokerInfo = info;
                        brokerInfoReceived.countDown();
                        optimizeAcknowledge = brokerInfo.isFaultTolerantConfiguration() ? 0 : 1;
                        getBlobTransferPolicy().setBrokerUploadUrl(info.getBrokerUploadUrl());
                        return null;
                    }
                    //处理连接错误
                    public Response processConnectionError(final ConnectionError error)
                        throws Exception
                    {
                        executor.execute(new Runnable() {

                            public void run()
                            {
                                onAsyncException(error.getException());
                            }

                            final ConnectionError val$error;
                            final _cls3 this$1;


                    {
                        this$1 = _cls3.this;
                        error = connectionerror;
                        super();
                    }
                        });
                        return null;
                    }
                    //处理控制命令
                    public Response processControlCommand(ControlCommand command)
                        throws Exception
                    {
                        onControlCommand(command);
                        return null;
                    }
                    //处理连接命令
                    public Response processConnectionControl(ConnectionControl control)
                        throws Exception
                    {
                        onConnectionControl((ConnectionControl)command);
                        return null;
                    }
                    //处理消费控制命令
                    public Response processConsumerControl(ConsumerControl control)
                        throws Exception
                    {
                        onConsumerControl((ConsumerControl)command);
                        return null;
                    }

                    public Response processWireFormat(WireFormatInfo info)
                        throws Exception
                    {
                        onWireFormatInfo((WireFormatInfo)command);
                        return null;
                    }

                    final Command val$command;
                    final ActiveMQConnection this$0;


            {
                this$0 = ActiveMQConnection.this;
                command = command1;
                super();
            }
                });
            }
	//启动所有连接注册的监听器
        TransportListener listener;
        for(Iterator iter = transportListeners.iterator(); iter.hasNext(); listener.onCommand(command))
            listener = (TransportListener)iter.next();

    }

    处理消费控制命令
     protected void onConsumerControl(ConsumerControl command)
    {
        if(command.isClose())
        {
            ActiveMQSession session;
            for(Iterator i$ = sessions.iterator(); i$.hasNext(); session.close(command.getConsumerId()))
                session = (ActiveMQSession)i$.next();

        } else
        {
            Iterator i$;
            ActiveMQSession session;
	    //设置会话消费者抓取数据大小
            for(i$ = sessions.iterator(); i$.hasNext(); session.setPrefetchSize(command.getConsumerId(), command.getPrefetch()))
                session = (ActiveMQSession)i$.next();
            i$ = connectionConsumers.iterator();
            do
            {
                if(!i$.hasNext())
                    break;
                ActiveMQConnectionConsumer connectionConsumer = (ActiveMQConnectionConsumer)i$.next();
                ConsumerInfo consumerInfo = connectionConsumer.getConsumerInfo();
                if(consumerInfo.getConsumerId().equals(command.getConsumerId()))
		    //设置消费抓取数据大小
                    consumerInfo.setPrefetchSize(command.getPrefetch());
            } while(true);
        }
    }


//启动所有连接注册的监听器 
TransportListener listener;
for(Iterator iter = transportListeners.iterator(); iter.hasNext(); listener.onCommand(command))
listener = (TransportListener)iter.next();

在ActiveMQConnection构造中有这么一段 
 protected ActiveMQConnection(final Transport transport, IdGenerator clientIdGenerator, IdGenerator connectionIdGenerator, JMSStatsImpl factoryStats)
        throws Exception
    {
        //transport的监听器为ActiveMQConnection
        this.transport.setTransportListener(this);
        stats = new JMSConnectionStatsImpl(sessions, this instanceof XAConnection);
        this.factoryStats.addConnection(this);
        connectionAudit.setCheckForDuplicates(transport.isFaultTolerant());
    }


实际上调用的是ActiveMQConnection的onCommand
ResponseCorrelator 
public void onCommand(Object o)
    {
        Command command = null;
        if(o instanceof Command)
            command = (Command)o;
        else
            throw new ClassCastException((new StringBuilder()).append("Object cannot be converted to a Command,  Object: ").append(o).toString());
        if(command.isResponse())
        {
            Response response = (Response)command;
            FutureResponse future = null;
            synchronized(requestMap)
            {
                future = (FutureResponse)requestMap.remove(Integer.valueOf(response.getCorrelationId()));
            }
            if(future != null)
                future.set(response);
            else
            if(debug)
                LOG.debug((new StringBuilder()).append("Received unexpected response: {").append(command).append("}for command id: ").append(response.getCorrelationId()).toString());
        } else
        {
            getTransportListener().onCommand(command);
        }
    }



回到ActiveMQConnection的onCommand 
 //分发消息
                    public Response processMessageDispatch(MessageDispatch md)
                        throws Exception
                    {
                        waitForTransportInterruptionProcessingToComplete();
			//根据分发消息id，获取消费者，然后消费者，消费消息
                        ActiveMQDispatcher dispatcher = (ActiveMQDispatcher)dispatchers.get(md.getConsumerId());
                        if(dispatcher != null)
                        {
                            Message msg = md.getMessage();
                            if(msg != null)
                            {
                                msg = msg.copy();
                                msg.setReadOnlyBody(true);
                                msg.setReadOnlyProperties(true);
                                msg.setRedeliveryCounter(md.getRedeliveryCounter());
				//设置分发消息连接
                                msg.setConnection(ActiveMQConnection.this);
                                msg.setMemoryUsage(null);
                                md.setMessage(msg);
                            }
			     //分发消息
                            dispatcher.dispatch(md);
                    }


public class ActiveMQConnectionConsumer
    implements ConnectionConsumer, ActiveMQDispatcher
{
   private ActiveMQConnection connection;//连接
    private ServerSessionPool sessionPool;//会话池
    private ConsumerInfo consumerInfo;//消费者信息
    private boolean closed;
    public void dispatch(MessageDispatch messageDispatch)
    {
        ServerSession serverSession;
        ActiveMQSession session;
        messageDispatch.setConsumer(this);
	//获取护花
        serverSession = sessionPool.getServerSession();
        Session s = serverSession.getSession();
        session = null;
        if(s instanceof ActiveMQSession)
            session = (ActiveMQSession)s;
        else
        if(s instanceof ActiveMQTopicSession)
        {
            ActiveMQTopicSession topicSession = (ActiveMQTopicSession)s;
            session = (ActiveMQSession)topicSession.getNext();
        } else
        if(s instanceof ActiveMQQueueSession)
        {
            ActiveMQQueueSession queueSession = (ActiveMQQueueSession)s;
            session = (ActiveMQSession)queueSession.getNext();
        } else
        {
            connection.onClientInternalException(new JMSException((new StringBuilder()).append("Session pool provided an invalid session type: ").append(s.getClass()).toString()));
            return;
        }
        try
        {
	    //会话分发消息，这个前面已说过，就是
            session.dispatch(messageDispatch);
            serverSession.start();
        }
        catch(JMSException e)
        {
            connection.onAsyncException(e);
        }
        return;
    }
}


//ActiveMQSession 
public void dispatch(MessageDispatch messageDispatch)
    {
        try
        {
	   //会话执行，执行消息分发
            executor.execute(messageDispatch);
        }
    }

//ActiveMQSessionExecutor 
public class ActiveMQSessionExecutor
    implements Task
{
 private final ActiveMQSession session;
    private final MessageDispatchChannel messageQueue;//未消费消息队列
    private boolean dispatchedBySessionPool;
    private volatile TaskRunner taskRunner;
    private boolean startedOrWarnedThatNotStarted;
    void execute(MessageDispatch message)
        throws InterruptedException
    {
        if(!startedOrWarnedThatNotStarted)
        {
            ActiveMQConnection connection = session.connection;
            long aboutUnstartedConnectionTimeout = connection.getWarnAboutUnstartedConnectionTimeout();
            if(connection.isStarted() || aboutUnstartedConnectionTimeout < 0L)
            {
                startedOrWarnedThatNotStarted = true;
            } else
            {
                long elapsedTime = System.currentTimeMillis() - connection.getTimeCreated();
                if(elapsedTime > aboutUnstartedConnectionTimeout)
                {
                    LOG.warn((new StringBuilder()).append("Received a message on a connection which is not yet started. Have you forgotten to call Connection.start()? Connection: ").append(connection).append(" Received: ").append(message).toString());
                    startedOrWarnedThatNotStarted = true;
                }
            }
        }
        if(!session.isSessionAsyncDispatch() && !dispatchedBySessionPool)
        {
	    //如果不是异步分发消息，则直接分发消息
            dispatch(message);
        } else
        {
	    //将分发消息添加到未分发消息队列
            messageQueue.enqueue(message);
            wakeup();
        }
    }
}

我们来看同步，获取会话消费者，遍历消费，消费消息 
void dispatch(MessageDispatch message)
    {
        Iterator i$ = session.consumers.iterator();
        do
        {
            if(!i$.hasNext())
                break;
            ActiveMQMessageConsumer consumer = (ActiveMQMessageConsumer)i$.next();
            ConsumerId consumerId = message.getConsumerId();
            if(!consumerId.equals(consumer.getConsumerId()))
                continue;
            consumer.dispatch(message);
            break;
        } while(true);
    }

上面分发消息这一段，我们在前几篇有说过，这一就不在讲。
总结：
[color=green]TransportConnector的启动，主要为添加TcpTransportServer的监听器TransportAcceptListener，监听器主要任务是接受连接，并启动连接TransportConnector，在启动的过程启动一个TcpTransportServer，并启动TcpTransportServer，TcpTransportServer监听连接请求，如果有连接请求，则创建连接，同时启动连接的Transport，Transport启动过程主要是读取命令，然后交由TransportListener处理，实际为ActiveMQConnection，如果命令为消息分发命令则有ActiveMQConnectionConsumer根据分化消息获取消费者信息，并从ActiveMQConnectionConsumer获取连接会话，然后由会话来分发消息，最后交由会话执行器分发消息。[/color]
ActiveMQ消息传送机制以及ACK机制详解
01-27
ActiveMQ还提供Flow Control机制，允许Broker根据消费者（Consumer）的消费速度调整消息的发送速率，避免消息积压。 2. 消费者（Consumer）：消费者客户端负责接收和处理来自Broker的消息。它可以通过预获取...
ActiveMQ中消费者是如何接收消息的（一）
大步流星
07-27 1315
       事先说明，本博客关于ActiveMQ的文章都是基于ActiveMQ5.10版本。        初步用过ActiveMQ但又没去研究过源码的朋友肯定有些好奇ActiveMQ中消费者是如何接收消息的呢？本文我就和大家一起从源码角度来初步探讨消费者接收消息的过程。        我们知道，消息传送有两种模型：点对点（P2P）和发布订阅（PUB/SUB），队列模式中，消息生产者叫做发送...
activeMQ能发送消息，但是不能获取消息 Received a message on a connection which is not yet started.
weixin_45369440的博客
04-17 851
刚才好不容易能发送消息了，好家伙获取消息又获取不到了！搞了半天报了WARN警告 Received a message on a connection which is not yet started. 一开始我是不以为然的，说什么我获取消息时没有获取启动连接？ 然后百度了半天，很少有我这样的错，无意间看了人家的代码才发现！人家connection有start！ 我也是醉了，毕竟很久没有手写这种连接了！ 而且前面的生产者也没有写start，但是能发送！ 鬼知道！生产者可以，消费者不可以，所以才没有头绪的小马
ActiveMQ中消费者是如何接收消息的（二）
大步流星
08-15 783
       上篇文章大致讲述了同步消费者和异步消费者接收消息的异同（详见《ActiveMQ中消费者是如何接收消息的（一）》http://manzhizhen.iteye.com/blog/2094130 ），但我们还未讲到消息是在什么时候放入消费者ActiveMQMessageConsumer类的“消息容器”unconsumedMessages中的，这很关键，因为为了解耦，消费者类不需要知道...
7. broker响应consumer消费消息
ZXH240651200的博客
11-28 176
在BrokerController.registerProcessor()中 /** * PullMessageProcessor */ this.remotingServer.registerProcessor(RequestCode.PULL_MESSAGE, this.pullMessageProcessor, this.pullMessageExecutor); this.pullMessageProcessor.registerConsumeMessageHook(consumeMess
RocketMq源码分析（七）--消息发送流程
最新发布
Shenkh的Java壁橱
05-21 1115
消息发送根据消息通信模式（同步、异步、单向）决定消息发送次数。在重试发送时，记录上一次发送失败的broker（lastBrokerName），这样在下一次重试时能避免再次往失败的broker发送。执行消息发送时，选择所发送消息topic的一个队列，这个队列不能是上一次重试时使用的队列（lastBrokerName）当向消息：producer向broker发送消息，执行发送后立即返回，也不等待broker结果。如果消息是事务消息，添加事务标记。消息发送请求对象，包含发送消息必要的信息（topic、队列等）
ActiveMQ消息过期时间设置和自动清除解决方案
04-10
为了确保消息处理的高效性，ActiveMQ提供了慢消费者策略来处理那些处理消息速度过慢的消费者。该策略可以通过定期检查所有慢速消费者并在达到一定阈值时中断它们，以提高系统的整体性能。 ##### 配置示例 ```xml ...
activemq消息中间件-视频教程
09-15
4. **API使用**：通过Java API演示如何创建生产者和消费者，发送和接收消息，以及设置消息属性和过滤条件。 5. **消息持久化**：讲解ActiveMQ如何实现消息的持久化，确保在网络故障或服务器重启后仍能恢复未处理的...
ActiveMQ学习笔记（12）----ActiveMQ的集群
Teddies10081008的博客
11-01 184
1. Queue consumer cluster 　　ActiveMQ支持Consumer对消息的高可靠性的负载均衡消费，如果一个Consumer死掉，该消息会转发到其他的Consumer消费的Queue。如果一个Consumer获得消息比其他Consumer快，那么他将获得更多的消息。因此推荐ActiveMQ的Broker和Client使用failover://transport的...
ActiveMQ 发送指定消息
长沙要起风了、
01-04 4659
刚刚接触activemq,网上也有很多资料,需要花很多时间去整理资料和自我尝试,有的能成功,有的也可能是因为自己的步骤原因导致调试失败,所以特意总结了一下自己所学习到的知识,与大家分享一下. activemq发送指定消息给指定的人: 1. 消费者代码package com.clgg.job.activemq.queue; import javax.jms.Connection; im
分布式消息通信 ActiveMQ 原理 分析二
须臾-code
04-19 897
本章重点： 1. unconsumedMessage 源码分析 2. 消费端的 PrefetchSize 3. 消息的确认过程 4. 消息重发机制 5. ActiveMQ 多节点高性能方案 消息消费流程图 unconsumedMessages数据的获取过程 那我们来看看 ActiveMQConnectionFactory. createConnection 里面做了什么 ...
activemq消息接收流程
每天积累一点，一年后你会发现，自己变化很大
09-26 4527
activemq消息接收流程
分布式专题-分布式消息通信之ActiveMQ03-ActiveMQ原理分析(下)
✎ℳ๓₯㎕...雲淡風輕
03-18 369
这一节，我们继续分析一下ActiveMQ的原理。那我们来看看 ActiveMQConnectionFactory. createConnection 里面做了什么事情。
spark on yarn 的那些坑
热门推荐
跟我一起去征服
06-08 9万+
在公司6个节点的测试集群运行得好好的，结果也很正常，然后放上60个节点的预生产环境，我勒个擦，搞了我两天，主要是生产环境的那些家伙不配合，一个问题搞得拖啊拖 ，首先是安全认证问题，截取一两个有意义的吧：       1.没有认证 Caused by: java.io.IOException: javax.security.sasl.SaslException: GSS initiate fa
ActiveMQ连接数过多，导致ActiveMQ无法正常接入数据
司马沉潇的专栏
12-10 7151
ActiveMQ连接数过多，导致ActiveMQ无法正常接入数据
ActiveMQ消息消费流程及优化
fengbird的博客
06-22 1075
ActiveMQ默认情况下是开启事务的吗? MQ默认情况下是没有开启事务的 , MQ将消息推送给消费者后, 消费者会立即向服务器确认该消息已被消费,之后才进行该条消息的处理逻辑 为什么在应用中有事务开启? 这是因为在vz-service-config 中activeMq.xml 中开启了事务,如下: <bean id="defaultMessageQueueListener" class="org.ice.jee.spring.mq.core.handler.JeeSpringQueu..
ActiveMQ消息队列过多导致客户端连接失败
stryang的博客
07-03 7601
一、异常描述 jvm 1 | Exception in thread "ActiveMQ BrokerService[localhost] Task-997" java.lang.OutOfMemoryError: unable to create new native thread jvm 1 | at java.lang.Thread.start0(Native Meth...
activemqwindow搭建和java简单发送实例
weixin_34101784的博客
12-07 498
一、安装 1.官网下载（有linux和windows的） 　　http://activemq.apache.org/download.html 2.下载完解压 　　进入bin文件夹进入win64　　点击activemq.bat执行 3.ActiveMQ默认启动到8161端口，启动完了后在浏览器地址栏输入：http://localhost:8161/admin要求输入用户名密码，...
activeMQ同步异步消息发送策略详解与实现
本文深入探讨了在Java Message Service (JMS)框架下，特别是Apache ActiveMQ中消息发送过程的基本原理和策略。作者以同步发送和异步发送这两种模式为核心，阐述了它们的工作原理以及在实际应用中的优缺点。 在同步...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值