• 分布式-信息方式-ActiveMQ静态网络连接多线程的consumer(消费者)访问集群


    操作如下:

    1:把整个conf文件夹复制一份,比如叫做conf2
    2:修改里面的 activemq.xml文件
    (1)里面的 brokerName不能跟原来的重复
    (2)数据存放的文件名称不能重复,比如:
    <kahaDB directory="${activemq. data}/kahadb "/>

    (3)所有涉及的 transportConnectors的端口,都要跟前面的不一样

    代码如下:

    conf  ----->activemq.xml

    <!--
        Licensed to the Apache Software Foundation (ASF) under one or more
        contributor license agreements.  See the NOTICE file distributed with
        this work for additional information regarding copyright ownership.
        The ASF licenses this file to You under the Apache License, Version 2.0
        (the "License"); you may not use this file except in compliance with
        the License.  You may obtain a copy of the License at
    
        http://www.apache.org/licenses/LICENSE-2.0
    
        Unless required by applicable law or agreed to in writing, software
        distributed under the License is distributed on an "AS IS" BASIS,
        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
        See the License for the specific language governing permissions and
        limitations under the License.
    -->
    <!-- START SNIPPET: example -->
    <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
      http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core.xsd">
    
        <!-- Allows us to use system properties as variables in this configuration file -->
        <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
            <property name="locations">
                <value>file:${activemq.conf}/credentials.properties</value>
            </property>
        </bean>
    
       <!-- Allows accessing the server log -->
        <bean id="logQuery" class="io.fabric8.insight.log.log4j.Log4jLogQuery"
              lazy-init="false" scope="singleton"
              init-method="start" destroy-method="stop">
        </bean>
    
        <!--
            The <broker> element is used to configure the ActiveMQ broker.
        -->
        <broker xmlns="http://activemq.apache.org/schema/core" brokerName="localhost" dataDirectory="${activemq.data}">
    
            <destinationPolicy>
                <policyMap>
                  <policyEntries>
                    <policyEntry topic=">" >
                        <!-- The constantPendingMessageLimitStrategy is used to prevent
                             slow topic consumers to block producers and affect other consumers
                             by limiting the number of messages that are retained
                             For more information, see:
    
                             http://activemq.apache.org/slow-consumer-handling.html
    
                        -->
                      <pendingMessageLimitStrategy>
                        <constantPendingMessageLimitStrategy limit="1000"/>
                      </pendingMessageLimitStrategy>
                    </policyEntry>
                  </policyEntries>
                </policyMap>
            </destinationPolicy>
    
    
            <!--
                The managementContext is used to configure how ActiveMQ is exposed in
                JMX. By default, ActiveMQ uses the MBean server that is started by
                the JVM. For more information, see:
    
                http://activemq.apache.org/jmx.html
            -->
            <managementContext>
                <managementContext createConnector="false"/>
            </managementContext>
    
    
    
    
    
    
          <networkConnectors>
                     <networkConnector name="local network" 
                      uri="static://(tcp://192.168.145.100:61616,tcp://192.168.145.100:61676)"/>
          </networkConnectors>
            <!--
                Configure message persistence for the broker. The default persistence
                mechanism is the KahaDB store (identified by the kahaDB tag).
                For more information, see:
    
                http://activemq.apache.org/persistence.html
            -->
            <persistenceAdapter>
                <kahaDB directory="${activemq.data}/kahadb"/>
            </persistenceAdapter>
    
    
              <!--
                The systemUsage controls the maximum amount of space the broker will
                use before disabling caching and/or slowing down producers. For more information, see:
                http://activemq.apache.org/producer-flow-control.html
              -->
              <systemUsage>
                <systemUsage>
                    <memoryUsage>
                        <memoryUsage percentOfJvmHeap="70" />
                    </memoryUsage>
                    <storeUsage>
                        <storeUsage limit="100 gb"/>
                    </storeUsage>
                    <tempUsage>
                        <tempUsage limit="50 gb"/>
                    </tempUsage>
                </systemUsage>
            </systemUsage>
    
            <!--
                The transport connectors expose ActiveMQ over a given protocol to
                clients and other brokers. For more information, see:
    
                http://activemq.apache.org/configuring-transports.html
            -->
            <transportConnectors>
                <!-- DOS protection, limit concurrent connections to 1000 and frame size to 100MB -->
                <transportConnector name="openwire" uri="tcp://0.0.0.0:61616?maximumConnections=1000&amp;wireFormat.maxFrameSize=104857600"/>
                <transportConnector name="amqp" uri="amqp://0.0.0.0:5672?maximumConnections=1000&amp;wireFormat.maxFrameSize=104857600"/>
                <transportConnector name="stomp" uri="stomp://0.0.0.0:61613?maximumConnections=1000&amp;wireFormat.maxFrameSize=104857600"/>
                <transportConnector name="mqtt" uri="mqtt://0.0.0.0:1883?maximumConnections=1000&amp;wireFormat.maxFrameSize=104857600"/>
                <transportConnector name="ws" uri="ws://0.0.0.0:61614?maximumConnections=1000&amp;wireFormat.maxFrameSize=104857600"/>
            </transportConnectors>
    
            <!-- destroy the spring context on shutdown to stop jetty -->
            <shutdownHooks>
                <bean xmlns="http://www.springframework.org/schema/beans" class="org.apache.activemq.hooks.SpringContextHook" />
            </shutdownHooks>
    
        </broker>
    
        <!--
            Enable web consoles, REST and Ajax APIs and demos
            The web consoles requires by default login, you can disable this in the jetty.xml file
    
            Take a look at ${ACTIVEMQ_HOME}/conf/jetty.xml for more details
        -->
        <import resource="jetty.xml"/>
    
    </beans>
    <!-- END SNIPPET: example -->

    conf2  ----->activemq.xml

    <!--
        Licensed to the Apache Software Foundation (ASF) under one or more
        contributor license agreements.  See the NOTICE file distributed with
        this work for additional information regarding copyright ownership.
        The ASF licenses this file to You under the Apache License, Version 2.0
        (the "License"); you may not use this file except in compliance with
        the License.  You may obtain a copy of the License at
    
        http://www.apache.org/licenses/LICENSE-2.0
    
        Unless required by applicable law or agreed to in writing, software
        distributed under the License is distributed on an "AS IS" BASIS,
        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
        See the License for the specific language governing permissions and
        limitations under the License.
    -->
    <!-- START SNIPPET: example -->
    <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
      http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core.xsd">
    
        <!-- Allows us to use system properties as variables in this configuration file -->
        <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
            <property name="locations">
                <value>file:${activemq.conf}/credentials.properties</value>
            </property>
        </bean>
    
       <!-- Allows accessing the server log -->
        <bean id="logQuery" class="io.fabric8.insight.log.log4j.Log4jLogQuery"
              lazy-init="false" scope="singleton"
              init-method="start" destroy-method="stop">
        </bean>
    
        <!--
            The <broker> element is used to configure the ActiveMQ broker.
        -->
        <broker xmlns="http://activemq.apache.org/schema/core" brokerName="mybroker" dataDirectory="${activemq.data}">
    
            <destinationPolicy>
                <policyMap>
                  <policyEntries>
                    <policyEntry topic=">" >
                        <!-- The constantPendingMessageLimitStrategy is used to prevent
                             slow topic consumers to block producers and affect other consumers
                             by limiting the number of messages that are retained
                             For more information, see:
    
                             http://activemq.apache.org/slow-consumer-handling.html
    
                        -->
                      <pendingMessageLimitStrategy>
                        <constantPendingMessageLimitStrategy limit="1000"/>
                      </pendingMessageLimitStrategy>
                    </policyEntry>
                  </policyEntries>
                </policyMap>
            </destinationPolicy>
    
    
            <!--
                The managementContext is used to configure how ActiveMQ is exposed in
                JMX. By default, ActiveMQ uses the MBean server that is started by
                the JVM. For more information, see:
    
                http://activemq.apache.org/jmx.html
            -->
            <managementContext>
                <managementContext createConnector="false"/>
            </managementContext>
    
            <!--
                Configure message persistence for the broker. The default persistence
                mechanism is the KahaDB store (identified by the kahaDB tag).
                For more information, see:
    
                http://activemq.apache.org/persistence.html
            -->
            <persistenceAdapter>
                <kahaDB directory="${activemq.data}/kahadb2"/>
            </persistenceAdapter>
    
    
              <!--
                The systemUsage controls the maximum amount of space the broker will
                use before disabling caching and/or slowing down producers. For more information, see:
                http://activemq.apache.org/producer-flow-control.html
              -->
              <systemUsage>
                <systemUsage>
                    <memoryUsage>
                        <memoryUsage percentOfJvmHeap="70" />
                    </memoryUsage>
                    <storeUsage>
                        <storeUsage limit="100 gb"/>
                    </storeUsage>
                    <tempUsage>
                        <tempUsage limit="50 gb"/>
                    </tempUsage>
                </systemUsage>
            </systemUsage>
    
            <!--
                The transport connectors expose ActiveMQ over a given protocol to
                clients and other brokers. For more information, see:
    
                http://activemq.apache.org/configuring-transports.html
            -->
            <transportConnectors>
                <!-- DOS protection, limit concurrent connections to 1000 and frame size to 100MB -->
               <transportConnector name="openwire" uri="tcp://0.0.0.0:61676?maximumConnections=1000&amp;wireFormat.maxFrameSize=104857600"/>
                <transportConnector name="amqp" uri="amqp://0.0.0.0:5682?maximumConnections=1000&amp;wireFormat.maxFrameSize=104857600"/>
                <transportConnector name="stomp" uri="stomp://0.0.0.0:61673?maximumConnections=1000&amp;wireFormat.maxFrameSize=104857600"/>
                <transportConnector name="mqtt" uri="mqtt://0.0.0.0:1873?maximumConnections=1000&amp;wireFormat.maxFrameSize=104857600"/>
                <transportConnector name="ws" uri="ws://0.0.0.0:61674?maximumConnections=1000&amp;wireFormat.maxFrameSize=104857600"/>
            </transportConnectors>
    
            <!-- destroy the spring context on shutdown to stop jetty -->
            <shutdownHooks>
                <bean xmlns="http://www.springframework.org/schema/beans" class="org.apache.activemq.hooks.SpringContextHook" />
            </shutdownHooks>
    
        </broker>
    
        <!--
            Enable web consoles, REST and Ajax APIs and demos
            The web consoles requires by default login, you can disable this in the jetty.xml file
    
            Take a look at ${ACTIVEMQ_HOME}/conf/jetty.xml for more details
        -->
        <import resource="jetty.xml"/>
    
    </beans>
    <!-- END SNIPPET: example -->

    3:修改 jetty.xml,主要就是修改端口,比如
    <property name=“port” value=“8181”/>端口必须和前面的不一样

    conf--jetty.xml

    <bean id="jettyPort" class="org.apache.activemq.web.WebConsolePort" init-method="start">
                 <!-- the default port number for the web console -->
            <property name="host" value="0.0.0.0"/>
            <property name="port" value="8161"/>
        </bean>

    conf2--jetty.xml

        <bean id="jettyPort" class="org.apache.activemq.web.WebConsolePort" init-method="start">
                 <!-- the default port number for the web console -->
            <property name="host" value="0.0.0.0"/>
            <property name="port" value="8171"/>
        </bean>

    4:到bin下面,复制一个 activemq,比如叫做 activemq2:
    (1)修改程序的id,不能和前面的重复
    ACTIVEMQ_PIDFILE="$ACTIVEMQ_DATA/activemq2.pid"
    (2)修改配置文件路径
    ACTIVEMQ_CONF="$ACTIVEMQ_BASE/conf2"
    (3)修改端口,里面有个tcp的61616的端口,要改成不一样的,最好跟 activemq.xml里面的tcp的端口一致
    (4)然后就可以执行了,如果执行没有权限的话,就授权: chmod 751 activemq2

    #!/bin/sh
    # ------------------------------------------------------------------------
    # Licensed to the Apache Software Foundation (ASF) under one or more
    # contributor license agreements.  See the NOTICE file distributed with
    # this work for additional information regarding copyright ownership.
    # The ASF licenses this file to You under the Apache License, Version 2.0
    # (the "License"); you may not use this file except in compliance with
    # the License.  You may obtain a copy of the License at
    #
    # http://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing, software
    # distributed under the License is distributed on an "AS IS" BASIS,
    # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    # See the License for the specific language governing permissions and
    # limitations under the License.
    # ------------------------------------------------------------------------
    #
    # This script controls standalone Apache ActiveMQ service processes.
    # To ensure compatibility to macosx and cygwin we do not utilize
    # lsb standard infrastructure for controlling daemons like
    # "start-stop-daemon".
    #
    # See also http://activemq.apache.org/activemq-command-line-tools-reference.html
    # for additional commandline arguments
    #
    # System variables for this script, like ACTIVEMQ_OPTS and ACTIVEMQ_OPTS_MEMORY,
    # can be configured in 'env' script located in this directory.
    #
    # For more information on configuring the script, see http://activemq.apache.org/unix-shell-script.html
    #
    #
    # Authors:
    # Marc Schoechlin <ms@256bit.org>
    
    # ------------------------------------------------------------------------
    
    # Backup invocation parameters
    COMMANDLINE_ARGS="$@"
    EXEC_OPTION=""
    
    # ------------------------------------------------------------------------
    # HELPERS
    
    # a simple helper to get the current user
    setCurrentUser(){
       CUSER=`whoami 2>/dev/null`
       # Solaris hack
       if [ ! $? -eq 0 ]; then
          CUSER=`/usr/ucb/whoami 2>/dev/null`
       fi
    }
    
    # get a canonical path, macosx and slowlaris does not support radlink -f :-)
    pathCanonical() {
        local dst="${1}"
        while [ -h "${dst}" ] ; do
            ls=`ls -ld "${dst}"`
            link=`expr "$ls" : '.*-> (.*)$'`
            if expr "$link" : '/.*' > /dev/null; then
                dst="$link"
            else
                dst="`dirname "${dst}"`/$link"
            fi
        done
        local bas=`basename "${dst}"`
        local dir=`dirname "${dst}"`
        if [ "$bas" != "$dir" ]; then
          dst="`pathCanonical "$dir"`/$bas"
        fi
        echo "${dst}" | sed -e 's#//#/#g' -e 's#/./#/#g' -e 's#/[^/]*/../#/#g'
    }
    
    
    # a simple helper to get the activemq installation dir
    getActiveMQHome(){
      # get the real path to the binary
      local REAL_BIN="`pathCanonical $0`"
      local REAL_DIR="`dirname $REAL_BIN`/../"
      REAL_DIR="`cd $REAL_DIR && pwd -P`"
      if [ -z "$REAL_DIR" ];then
          echo 'ERROR: unable to find real installtion path fo activemq, you have to define ACTIVEMQ_HOME manually in the config' >&2
          exit 1
      fi
      echo "$REAL_DIR"
    
    }
    
    # Active MQ installation dir
    if [ -z "$ACTIVEMQ_HOME" ] ; then
      ACTIVEMQ_HOME="`getActiveMQHome`"
    fi
    
    if [ -z "$ACTIVEMQ_BASE" ] ; then
      ACTIVEMQ_BASE="$ACTIVEMQ_HOME"
    fi
    
    # Active MQ configuration directory
    if [ -z "$ACTIVEMQ_CONF" ] ; then
    
        # For backwards compat with old variables we let ACTIVEMQ_CONFIG_DIR set ACTIVEMQ_CONF
        if [ -z "$ACTIVEMQ_CONFIG_DIR" ] ; then
            ACTIVEMQ_CONF="$ACTIVEMQ_BASE/conf2"
        else
            ACTIVEMQ_CONF="$ACTIVEMQ_CONFIG_DIR"
        fi
    fi
    
    # Configure a user with non root privileges, if no user is specified do not change user
    if [ -z "$ACTIVEMQ_USER" ] ; then
        ACTIVEMQ_USER=""
    fi
    
    # Active MQ data directory
    if [ -z "$ACTIVEMQ_DATA" ] ; then
    
        # For backwards compat with old variables we let ACTIVEMQ_DATA_DIR set ACTIVEMQ_DATA
        if [ -z "$ACTIVEMQ_DATA_DIR" ] ; then
            ACTIVEMQ_DATA="$ACTIVEMQ_BASE/data"
        else
            ACTIVEMQ_DATA="$ACTIVEMQ_DATA_DIR"
        fi
    fi
    
    if [ -z "$ACTIVEMQ_TMP" ] ; then
      ACTIVEMQ_TMP="$ACTIVEMQ_BASE/tmp"
    fi
    
    if [ ! -d "$ACTIVEMQ_DATA" ]; then
       setCurrentUser
       if ( [ -z "$ACTIVEMQ_USER" ] || [ "$ACTIVEMQ_USER" = "$CUSER" ] );then
            mkdir $ACTIVEMQ_DATA
       elif [ "`id -u`" = "0" ];then
          su -c "mkdir $ACTIVEMQ_DATA" - $ACTIVEMQ_USER;
       fi
    fi
    
    # Location of the pidfile
    if [ -z "$ACTIVEMQ_PIDFILE" ]; then
      ACTIVEMQ_PIDFILE="$ACTIVEMQ_DATA/activemq2.pid"
    fi
    
    
    # ------------------------------------------------------------------------
    # LOAD CONFIGURATION
    
    # CONFIGURATION
    # For using instances
    if ( basename $0 | grep "activemq-instance-" > /dev/null);then
      INST="`basename $0|sed 's/^activemq-instance-//;s/.sh$//'`"
      ACTIVEMQ_CONFIGS="/etc/default/activemq-instance-${INST} $HOME/.activemqrc-instance-${INST}"
      echo "INFO: Using alternative activemq configuration files: $ACTIVEMQ_CONFIGS"
    else
      ACTIVEMQ_CONFIGS="/etc/default/activemq $HOME/.activemqrc $ACTIVEMQ_HOME/bin/env"
    fi
    
    # load activemq configuration
    CONFIG_LOAD="no"
    for ACTIVEMQ_CONFIG in $ACTIVEMQ_CONFIGS;do
       if [ -f "$ACTIVEMQ_CONFIG" ] ; then
         ( . $ACTIVEMQ_CONFIG >/dev/null 2>&1 )
         if [ "$?" != "0" ];then
          echo "ERROR: There are syntax errors in '$ACTIVEMQ_CONFIG'"
          exit 1
         else
           echo "INFO: Loading '$ACTIVEMQ_CONFIG'"
           . $ACTIVEMQ_CONFIG
          CONFIG_LOAD="yes"
          break
         fi
       fi
    done
    
    # inform user that default configuration is loaded, no suitable configfile found
    if [ "$CONFIG_LOAD" != "yes" ];then
          echo "INFO: Using default configuration";
          echo "      Configurations are loaded in the following order: $ACTIVEMQ_CONFIGS"
          echo
    fi
    
    # ------------------------------------------------------------------------
    # OS SPECIFIC SUPPORT
    
    OSTYPE="unknown"
    
    case "`uname`" in
      CYGWIN*) OSTYPE="cygwin" ;;
      Darwin*)
               OSTYPE="darwin"
               if [ -z "$JAVA_HOME" ] && [ "$JAVACMD" = "auto" ];then
                 JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Home
               fi
               ;;
    esac
    
    # For Cygwin, ensure paths are in UNIX format before anything is touched
    if [ "$OSTYPE" = "cygwin" ]; then
      [ -n "$ACTIVEMQ_HOME" ] &&
        ACTIVEMQ_HOME="`cygpath --unix "$ACTIVEMQ_HOME"`"
      [ -n "$JAVA_HOME" ] &&
        JAVA_HOME="`cygpath --unix "$JAVA_HOME"`"
      [ -n "$ACTIVEMQ_CLASSPATH" ] &&
        ACTIVEMQ_CLASSPATH="`cygpath --path --unix "$ACTIVEMQ_CLASSPATH"`"
    fi
    
    # Detect the location of the java binary
    if [ -z "$JAVACMD" ] || [ "$JAVACMD" = "auto" ] ; then
      if [ -n "$JAVA_HOME"  ] ; then
        if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
          # IBM's JDK on AIX uses strange locations for the executables
          JAVACMD="$JAVA_HOME/jre/sh/java"
        else
          JAVACMD="$JAVA_HOME/bin/java"
        fi
      fi
    fi
    
    # Hm, we still do not know the location of the java binary
    if [ ! -x "$JAVACMD" ] ; then
        JAVACMD=`which java 2> /dev/null `
        if [ -z "$JAVACMD" ] ; then
            JAVACMD=java
        fi
    fi
    # Stop here if no java installation is defined/found
    if [ ! -x "$JAVACMD" ] ; then
      echo "ERROR: Configuration variable JAVA_HOME or JAVACMD is not defined correctly."
      echo "       (JAVA_HOME='$JAVA_HOME', JAVACMD='$JAVACMD')"
      exit 1
    fi
    
    echo "INFO: Using java '$JAVACMD'"
    
    if [ -z "$ACTIVEMQ_BASE" ] ; then
      ACTIVEMQ_BASE="$ACTIVEMQ_HOME"
    fi
    
    # For Cygwin, switch paths to Windows format before running java if [ "$OSTYPE" = "cygwin" ]; then
    if [ "$OSTYPE" = "cygwin" ];then
      ACTIVEMQ_HOME=`cygpath --windows "$ACTIVEMQ_HOME"`
      ACTIVEMQ_BASE=`cygpath --windows "$ACTIVEMQ_BASE"`
      ACTIVEMQ_CONF=`cygpath --windows "$ACTIVEMQ_CONF"`
      ACTIVEMQ_DATA=`cygpath --windows "$ACTIVEMQ_DATA"`
      ACTIVEMQ_CLASSPATH=`cygpath --path --windows "$ACTIVEMQ_CLASSPATH"`
      [ -n "$JAVA_HOME" ] &&
        JAVA_HOME=`cygpath --windows "$JAVA_HOME"`
      CYGHOME=`cygpath --windows "$HOME"`
      ACTIVEMQ_TMP=`cygpath --windows "$ACTIVEMQ_TMP"`
      if [ -n "$CYGHOME" ]; then
          ACTIVEMQ_CYGWIN="-Dcygwin.user.home="$CYGHOME""
      fi
    fi
    
    # Set default classpath
    # Add instance conf dir before AMQ install conf dir to pick up instance-specific classpath entries first
    ACTIVEMQ_CLASSPATH="${ACTIVEMQ_CONF}:${ACTIVEMQ_CLASSPATH}"
    
    if [ "$OSTYPE" = "cygwin" ];then
      # remove training backslashes to prevent quoting problems
      ACTIVEMQ_CLASSPATH="`echo ${ACTIVEMQ_CLASSPATH}|sed '~s,[\]*$,,g'`"
      ACTIVEMQ_HOME="`echo ${ACTIVEMQ_HOME}|sed '~s,[\]*$,,g'`"
      ACTIVEMQ_BASE="`echo ${ACTIVEMQ_BASE}|sed '~s,[\]*$,,g'`"
      ACTIVEMQ_CONF="`echo ${ACTIVEMQ_CONF}|sed '~s,[\]*$,,g'`"
      ACTIVEMQ_DATA="`echo ${ACTIVEMQ_DATA}|sed '~s,[\]*$,,g'`"
    fi
    
    # Start the ActiveMQ JAR
    #
    #
    # @ARG1 : the name of the PID-file
    #         If specified, this function starts the java process in background as a daemon
    #         and stores the pid of the created process in the file.
    #         Output on stdout/stderr will be supressed if this parameter is specified
    # @RET  : If unless 0 something went wrong
    #
    # Note: This function uses a lot of globally defined variables
    # - if $ACTIVEMQ_USER is set, the function tries starts the java process whith the specified
    #   user
    invokeJar(){
       PIDFILE="$1"
       RET="1"
    
       if [ ! -f "${ACTIVEMQ_HOME}/bin/activemq.jar" ];then
        echo "ERROR: '${ACTIVEMQ_HOME}/bin/activemq.jar' does not exist, define ACTIVEMQ_HOME in the config"
        exit 1
       fi
    
       setCurrentUser
    
       if ( [ -z "$ACTIVEMQ_USER" ] || [ "$ACTIVEMQ_USER" = "$CUSER" ] );then
          DOIT_PREFIX="sh -c "
          DOIT_POSTFIX=";"
       elif [ "`id -u`" = "0" ];then
          DOIT_PREFIX="su -s /bin/sh -c "
          DOIT_POSTFIX=" - $ACTIVEMQ_USER"
          echo "INFO: changing to user '$ACTIVEMQ_USER' to invoke java"
       fi
       # Execute java binary
       if [ -n "$PIDFILE" ] && [ "$PIDFILE" != "stop" ];then
          $EXEC_OPTION $DOIT_PREFIX ""$JAVACMD" $ACTIVEMQ_OPTS $ACTIVEMQ_DEBUG_OPTS 
                  -Dactivemq.classpath="${ACTIVEMQ_CLASSPATH}" 
                  -Dactivemq.home="${ACTIVEMQ_HOME}" 
                  -Dactivemq.base="${ACTIVEMQ_BASE}" 
                  -Dactivemq.conf="${ACTIVEMQ_CONF}" 
                  -Dactivemq.data="${ACTIVEMQ_DATA}" 
                  $ACTIVEMQ_CYGWIN 
                  -jar "${ACTIVEMQ_HOME}/bin/activemq.jar" $COMMANDLINE_ARGS >/dev/null 2>&1 &
                  RET="$?"; APID="$!";
                  echo $APID > "$PIDFILE";
                  echo "INFO: pidfile created : '$PIDFILE' (pid '$APID')";exit $RET" $DOIT_POSTFIX
          RET="$?"
       elif [ -n "$PIDFILE" ] && [ "$PIDFILE" = "stop" ];then
              PID="`cat ${ACTIVEMQ_PIDFILE}`"
              $EXEC_OPTION $DOIT_PREFIX ""$JAVACMD" $ACTIVEMQ_OPTS $ACTIVEMQ_DEBUG_OPTS 
                  -Dactivemq.classpath="${ACTIVEMQ_CLASSPATH}" 
                  -Dactivemq.home="${ACTIVEMQ_HOME}" 
                  -Dactivemq.base="${ACTIVEMQ_BASE}" 
                  -Dactivemq.conf="${ACTIVEMQ_CONF}" 
                  -Dactivemq.data="${ACTIVEMQ_DATA}" 
                  $ACTIVEMQ_CYGWIN 
                  -jar "${ACTIVEMQ_HOME}/bin/activemq.jar" $COMMANDLINE_ARGS --pid $PID &
                  RET="$?"; APID="$!";
                  echo $APID > "$ACTIVEMQ_DATA/stop.pid"; exit $RET" $DOIT_POSTFIX
          RET="$?"
       else
          $EXEC_OPTION $DOIT_PREFIX ""$JAVACMD" $ACTIVEMQ_OPTS $ACTIVEMQ_DEBUG_OPTS 
                  -Dactivemq.classpath="${ACTIVEMQ_CLASSPATH}" 
                  -Dactivemq.home="${ACTIVEMQ_HOME}" 
                  -Dactivemq.base="${ACTIVEMQ_BASE}" 
                  -Dactivemq.conf="${ACTIVEMQ_CONF}" 
                  -Dactivemq.data="${ACTIVEMQ_DATA}" 
                  $ACTIVEMQ_CYGWIN 
                  -jar "${ACTIVEMQ_HOME}/bin/activemq.jar" $COMMANDLINE_ARGS" $DOIT_POSTFIX
          RET="$?"
       fi
       return $RET
    }
    
    # Check if ActiveMQ is running
    #
    # @RET  : 0 => the activemq process is running
    #         1 => process id in $ACTIVEMQ_PIDFILE does not exist anymore
    #         2 => something is wrong with the pid file
    #
    # Note: This function uses globally defined variables
    # - $ACTIVEMQ_PIDFILE : the name of the pid file
    
    
    checkRunning(){
        if [ -f "$ACTIVEMQ_PIDFILE" ]; then
           if  [ -z "`cat $ACTIVEMQ_PIDFILE`" ];then
            echo "ERROR: Pidfile '$ACTIVEMQ_PIDFILE' exists but contains no pid"
            return 2
           fi
           PID="`cat $ACTIVEMQ_PIDFILE`"
           RET="`ps -p $PID|grep java`"
           if [ -n "$RET" ];then
             return 0;
           else
             return 1;
           fi
        else
             return 1;
        fi
    }
    
    checkStopRunning(){
        PID="${PIDFILE}.stop"
        if [ -f "$PID" ]; then
           if  [ -z "`cat $PID`" ];then
            echo "ERROR: Pidfile '$PID' exists but contains no pid"
            return 2
           fi
           THEPID=`cat $PID`
           RET=`ps -p $THEPID|grep java`
           if [ -n "$RET" ];then
             return 0;
           else
             return 1;
           fi
        else
             return 1;
        fi
    }
    
    # Check if ActiveMQ is running
    #
    # @RET  : 0 => the activemq process is running
    #         1 => the activemq process is not running
    #
    # Note: This function uses globally defined variables
    # - $ACTIVEMQ_PIDFILE : the name of the pid file
    
    
    invoke_status(){
        if ( checkRunning );then
             PID=`cat $ACTIVEMQ_PIDFILE`
             echo "ActiveMQ is running (pid '$PID')"
             exit 0
        fi
        echo "ActiveMQ not running"
        exit 1
    }
    
    # Start ActiveMQ if not already running
    #
    # @RET  : 0 => is now started, is already started
    #         !0 => something went wrong
    #
    # Note: This function uses globally defined variables
    # - $ACTIVEMQ_PIDFILE      : the name of the pid file
    # - $ACTIVEMQ_OPTS         : Additional options
    # - $ACTIVEMQ_SUNJMX_START : options for JMX settings
    # - $ACTIVEMQ_SSL_OPTS     : options for SSL encryption
    
    invoke_start(){
        if ( checkRunning );then
          PID=`cat $ACTIVEMQ_PIDFILE`
          echo "INFO: Process with pid '$PID' is already running"
          exit 0
        fi
    
        ACTIVEMQ_OPTS="$ACTIVEMQ_OPTS $ACTIVEMQ_SUNJMX_START $ACTIVEMQ_SSL_OPTS -Djava.awt.headless=true -Djava.io.tmpdir="${ACTIVEMQ_TMP}""
    
        echo "INFO: Starting - inspect logfiles specified in logging.properties and log4j.properties to get details"
        invokeJar $ACTIVEMQ_PIDFILE
        exit "$?"
    }
    
    # Start ActiveMQ in foreground (for debugging)
    #
    # @RET  : 0 => is now started, is already started
    #         !0 => something went wrong
    #
    # Note: This function uses globally defined variables
    # - $ACTIVEMQ_PIDFILE      : the name of the pid file
    # - $ACTIVEMQ_OPTS         : Additional options
    # - $ACTIVEMQ_SUNJMX_START : options for JMX settings
    # - $ACTIVEMQ_SSL_OPTS     : options for SSL encryption
    
    invoke_console(){
        if ( checkRunning );then
          echo "ERROR: ActiveMQ is already running"
          exit 1
        fi
    
        ACTIVEMQ_OPTS="$ACTIVEMQ_OPTS $ACTIVEMQ_SUNJMX_START $ACTIVEMQ_SSL_OPTS -Djava.awt.headless=true -Djava.io.tmpdir="${ACTIVEMQ_TMP}""
    
        COMMANDLINE_ARGS="start `echo $COMMANDLINE_ARGS|sed 's,^console,,'`"
        EXEC_OPTION="exec"
        echo "INFO: Starting in foreground, this is just for debugging purposes (stop process by pressing CTRL+C)"
        invokeJar
        exit "$?"
    }
    
    # Stop ActiveMQ
    #
    # @RET  : 0 => stop was successful
    #         !0 => something went wrong
    #
    # Note: This function uses globally defined variables
    # - $ACTIVEMQ_PIDFILE         : the name of the pid file
    # - $ACTIVEMQ_KILL_MAXSECONDS : the number of seconds to wait for termination of broker after sending
    #                              shutdown signal by jmx interface
    
    invoke_stop(){
        RET="1"
        if ( checkRunning );then
           ACTIVEMQ_OPTS="$ACTIVEMQ_OPTS $ACTIVEMQ_SSL_OPTS"
           COMMANDLINE_ARGS="$COMMANDLINE_ARGS $ACTIVEMQ_SUNJMX_CONTROL"
           invokeJar "stop"
           RET="$?"
           PID=`cat $ACTIVEMQ_PIDFILE`
           echo "INFO: Waiting at least $ACTIVEMQ_KILL_MAXSECONDS seconds for regular process termination of pid '$PID' : "
           FOUND="0"
           i=1
           while [ "$i" != "$ACTIVEMQ_KILL_MAXSECONDS" ]; do
    
             if [ ! checkStopRunning ];then
                if [ ! checkRunning ]; then
                   echo " FINISHED"
                   FOUND="1"
                fi
                break
             fi
    
             if (checkRunning);then
                sleep 1
                printf  "."
             else
                echo " FINISHED"
                FOUND="1"
                break
             fi
             i=`expr $i + 1`
           done
           if [ "$FOUND" -ne "1" ];then
             echo
             echo "INFO: Regular shutdown not successful,  sending SIGKILL to process with pid '$PID'"
             kill -KILL $PID
             RET="1"
           fi
        elif [ -f "$ACTIVEMQ_PIDFILE" ];then
           echo "ERROR: No or outdated process id in '$ACTIVEMQ_PIDFILE'"
           echo
           echo "INFO: Removing $ACTIVEMQ_PIDFILE"
        else
           echo "ActiveMQ not running"
           exit 0
        fi
        rm -f "$ACTIVEMQ_PIDFILE" >/dev/null 2>&1
        rm -f "$ACTIVEMQ_DATA/stop.pid" >/dev/null 2>&1
        exit $RET
    }
    
    # Invoke a task on a running ActiveMQ instance
    #
    # @RET  : 0 => successful
    #         !0 => something went wrong
    #
    # Note: This function uses globally defined variables
    # - $ACTIVEMQ_QUEUEMANAGERURL : The url of the queuemanager
    # - $ACTIVEMQ_OPTS            : Additional options
    # - $ACTIVEMQ_SUNJMX_START    : options for JMX settings
    # - $ACTIVEMQ_SSL_OPTS        : options for SSL encryption
    invoke_task(){
        ACTIVEMQ_OPTS="$ACTIVEMQ_OPTS $ACTIVEMQ_SSL_OPTS"
        # call task in java binary
        if ( checkRunning );then
          if [ "$1" = "browse" ] && [ -n "$ACTIVEMQ_QUEUEMANAGERURL" ];then
             COMMANDLINE_ARGS="$1 $ACTIVEMQ_QUEUEMANAGERURL `echo $COMMANDLINE_ARGS|sed 's,^browse,,'`"
          elif [ "$1" = "query" ]  && [ -n "$ACTIVEMQ_QUEUEMANAGERURL" ];then
             COMMANDLINE_ARGS="$1 $ACTIVEMQ_SUNJMX_CONTROL `echo $COMMANDLINE_ARGS|sed 's,^query,,'`"
          else
             COMMANDLINE_ARGS="$COMMANDLINE_ARGS $ACTIVEMQ_SUNJMX_CONTROL"
          fi
          invokeJar
          exit $?
        else
          invokeJar
          exit 1
        fi
    }
    
    show_help() {
      invokeJar|sed "s,Usage: Main,Usage: $0,"
      cat << EOF
    Tasks provided by the sysv init script:
        restart         - stop running instance (if there is one), start new instance
        console         - start broker in foreground, useful for debugging purposes
        status          - check if activemq process is running
    
    Configuration of this script:
    The configuration of this script is read from the following files:
        $ACTIVEMQ_CONFIGS
        This script searches for the files in the listed order and reads the first available file.
        Modify $ACTIVEMQ_BASE/bin/env or create a copy of that file on a suitable location.
    
        To use additional configurations for running multiple instances on the same operating system
        rename or symlink script to a name matching to activemq-instance-<INSTANCENAME>.
        This changes the configuration location to /etc/default/activemq-instance-<INSTANCENAME> and
        $HOME/.activemqrc-instance-<INSTANCENAME>.
    EOF
      exit 1
    }
    
    # ------------------------------------------------------------------------
    # MAIN
    
    # show help
    if [ -z "$1" ];then
     show_help
    fi
    
    case "$1" in
      status)
        invoke_status
        ;;
      restart)
        if ( checkRunning );then
          $0 stop
        fi
        $0 status
        $0 start
        $0 status
        ;;
      start)
        invoke_start
        ;;
      console)
        invoke_console
        ;;
      stop)
        invoke_stop
        ;;
      *)
        invoke_task
    esac

    代码如下:

    package test.mq.staitsnetwork;
    
     
    
    import javax.jms.Connection;
    import javax.jms.ConnectionFactory;
    import javax.jms.Destination;
    import javax.jms.JMSException;
    import javax.jms.MapMessage;
    import javax.jms.MessageProducer;
    import javax.jms.Session;
    import javax.jms.TextMessage;
    
    import org.apache.activemq.ActiveMQConnectionFactory;
    
    public class Sender {
           public static void main(String[] args) throws JMSException, InterruptedException {
            ConnectionFactory   ConnectionFactory=new ActiveMQConnectionFactory(
                    "tcp://192.168.145.100:61616"
                    );
            Connection connection=ConnectionFactory.createConnection();
            connection.start();
        
            Session session=connection.createSession(Boolean.TRUE, Session.CLIENT_ACKNOWLEDGE);
            Destination destination=session.createQueue("my_queue");
            MessageProducer Producer=session.createProducer(destination);
         
            for(int i=0;i<30;i++){
                 TextMessage message=session.createTextMessage("message----"+i);
                    //Thread.sleep(1000);  
                    Producer.send(message);
            }
             session.commit();
             session.close();
             connection.close();    
        }
    }
    package test.mq.staitsnetwork;
    
    import java.util.Enumeration;
    import javax.jms.Connection;
    import javax.jms.ConnectionFactory;
    import javax.jms.Destination;
    import javax.jms.JMSException;
    import javax.jms.Message;
    import javax.jms.MessageConsumer;
    import javax.jms.MessageListener;
    import javax.jms.Session;
    import javax.jms.TextMessage;
    import org.apache.activemq.ActiveMQConnectionFactory;
    public class Receiver1{
        
        public static void main(String[] args) throws JMSException {
            ConnectionFactory   connectionFactory=new ActiveMQConnectionFactory(
                    "tcp://192.168.145.100:61676"
                    );
            for(int i=0;i<30;i++){
                Thread    t=new MyThread(connectionFactory);
                t.start();
                try {
                    Thread.sleep(1000l);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        
        }
    }
    class MyThread extends Thread{
             private ConnectionFactory   connectionFactory=null;
             public  MyThread(ConnectionFactory   connectionFactory){
             this.connectionFactory = connectionFactory;
             }
           public void run(){
                try {
                    final Connection  connection = connectionFactory.createConnection();
                    connection.start();
                    Enumeration names=connection.getMetaData().getJMSXPropertyNames();
                     
                    final Session session=connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE); 
                    Destination destination=session.createQueue("my_queue");
                    MessageConsumer Consumer=session.createConsumer(destination);
                    Consumer.setMessageListener(new MessageListener() {
                        @Override
                        public void onMessage(Message msg) {
                        TextMessage     txtmsg=(TextMessage) msg; 
                        try {
                            System.out.println("接收信息1--->"+txtmsg.getText());
                        } catch (JMSException e1) {
                            e1.printStackTrace();
                        }
                        try {
                            session.commit();
                        } catch (JMSException e) {
                            e.printStackTrace();
                        }
                        try {
                            session.close();
                        } catch (JMSException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        try {
                            connection.close();
                        } catch (JMSException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        }
                    });
                     
                    
                    
                    
                } catch (JMSException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
           }    
        }
    package test.mq.staitsnetwork;
    
    import java.util.Enumeration;
    import javax.jms.Connection;
    import javax.jms.ConnectionFactory;
    import javax.jms.Destination;
    import javax.jms.JMSException;
    import javax.jms.Message;
    import javax.jms.MessageConsumer;
    import javax.jms.MessageListener;
    import javax.jms.Session;
    import javax.jms.TextMessage;
    import org.apache.activemq.ActiveMQConnectionFactory;
    public class Receiver2{
        
        public static void main(String[] args) throws JMSException {
            ConnectionFactory   connectionFactory=new ActiveMQConnectionFactory(
                    "tcp://192.168.145.100:61616"
                    );
            for(int i=0;i<30;i++){
                Thread    t=new MyThread2(connectionFactory);
                t.start();
                try {
                    Thread.sleep(1000l);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        
        }
    }
    class MyThread2 extends Thread{
             private ConnectionFactory   connectionFactory=null;
             public  MyThread2(ConnectionFactory   connectionFactory){
             this.connectionFactory = connectionFactory;
             }
           public void run(){
                try {
                    final Connection  connection = connectionFactory.createConnection();
                    connection.start();
                    Enumeration names=connection.getMetaData().getJMSXPropertyNames();
                     
                    final Session session=connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE); 
                    Destination destination=session.createQueue("my_queue");
                    MessageConsumer Consumer=session.createConsumer(destination);
                    Consumer.setMessageListener(new MessageListener() {
                        @Override
                        public void onMessage(Message msg) {
                        TextMessage     txtmsg=(TextMessage) msg; 
                        try {
                            System.out.println("接收信息2--->"+txtmsg.getText());
                        } catch (JMSException e1) {
                            e1.printStackTrace();
                        }
                        try {
                            session.commit();
                        } catch (JMSException e) {
                            e.printStackTrace();
                        }
                        try {
                            session.close();
                        } catch (JMSException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        try {
                            connection.close();
                        } catch (JMSException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        }
                    });
                     
                    
                    
                    
                } catch (JMSException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
           }    
        }
  • 相关阅读:
    ftell
    diff
    继承
    类的组合
    拷贝构造函数
    内存管理
    Hibernate学习-Hibernate查询语言HQL
    JAVA解析JSON数据
    Android异步加载
    Android数据存储-文件操作
  • 原文地址:https://www.cnblogs.com/caoyingjielxq/p/9358884.html
Copyright © 2020-2023  润新知