BlogJava-Terry.B.Li 彬-文章分类-JMShttp://www.blogjava.net/libin2722/category/37068.html虚其心，可解天下之问；专其心，可治天下之学；静其心，可悟天下之理；恒其心，可成天下之业。zh-cnTue, 07 Sep 2010 04:04:36 GMTTue, 07 Sep 2010 04:04:36 GMT60JGroupshttp://www.blogjava.net/libin2722/articles/330636.html礼物礼物Wed, 01 Sep 2010 14:43:00 GMThttp://www.blogjava.net/libin2722/articles/330636.htmlhttp://www.blogjava.net/libin2722/comments/330636.htmlhttp://www.blogjava.net/libin2722/articles/330636.html#Feedback0http://www.blogjava.net/libin2722/comments/commentRss/330636.htmlhttp://www.blogjava.net/libin2722/services/trackbacks/330636.html阅读全文

礼物 2010-09-01 22:43 发表评论
]]>JMX Remotinghttp://www.blogjava.net/libin2722/articles/330634.html礼物礼物Wed, 01 Sep 2010 14:34:00 GMThttp://www.blogjava.net/libin2722/articles/330634.htmlhttp://www.blogjava.net/libin2722/comments/330634.htmlhttp://www.blogjava.net/libin2722/articles/330634.html#Feedback0http://www.blogjava.net/libin2722/comments/commentRss/330634.htmlhttp://www.blogjava.net/libin2722/services/trackbacks/330634.html

1 Introduction
    Java Management Extension (JMX) API定义于JSR 3，用于应用程序管理。这些API对于被管理的应用程序来说是本地的。也就是说，在JSR 160发布之前，如果客户端要通过JMX来管理和监控远程的应用程序，并没有标准的做法。JSR 160扩展了JSR 3，提供了标准的API用于连接到支持JMX的远程应用程序。JSR 255将会把JMX升级到2.0，并可能体现在Java 7中。
    目前JSR 160定义了基于RMI（支持RMI/JRMP 和 RMI/IIOP）的连接器，还定义了可选的JMXMP连接器，它基于TCP Socket和Java序列化机制。

 

2 JMX Remoting API
2.1 JMXServiceURL
    JMXServiceURL用于标识JMXConnectorServer，它是采用以下形式的字符串：
    service:jmx:<protocol>://[[[ <host>]: <port>]/ <path>]
    "protocol" 指定了协议，例如：rmi、iiop、jmxmp 或者 soap。"host"、"port" 和 "path"是可选的。JMXServiceURL并不足以描述所有的用于连接到JMXConnectorServer的配置信息（例如配置 RMIClientSocketFactory 和RMIServerSocketFactory），因此在构造JMXConnectorServer 和 JMXConnector的时候，还可能需要通过一个Map实例指定其它属性。

 

2.2 JMXConnectorServer
    JMXConnectorServer 是MBeanServer端的组件，它需要被关联到MBeanServer：可以通过在创建JMXConnectorServer的时候显式指定 MBeanServer；也可以把JMXConnectorServer（本身是一个MBean）注册到MBeanServer中。
    在被关联到MBeanServer之后，需要启动JMXConnectorServer以处理客户端的请求。同样，如果希望停止处理客户端的请求，那么需 要停止JMXConnectorServer。JMXConnectorServer被停止之后，不应该试图重新启动它，而是应该将其丢弃。
    最好通过JMXConnectorServerFactory来创建JMXConnectorServer，例如：

Java代码
  1. // The address of the connector server   
  2. JMXServiceURL address = new JMXServiceURL("service:jmx:rmi://host");  
  3.   
  4. // The environment map, null in this case   
  5. Map environment = null;  
  6.   
  7. // The MBeanServer to which the JMXConnectorServer will be attached to   
  8. MBeanServer server = MBeanServerFactory.createMBeanServer();  
  9.   
  10. // Create the JMXCconnectorServer   
  11. JMXConnectorServer cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(address, environment, server);  
  12.   
  13. // Start the JMXConnectorServer   
  14. cntorServer.start();  

    在以上的例子中，创建JMXConnectorServer的时候指定了MBeanServer。以下是一个将JMXConnectorServer作为MBean注册到MBeanServer的例子：

Java代码
  1. // The address of the connector   
  2. JMXServiceURL address = new JMXServiceURL("service:jmx:rmi://host");  
  3.   
  4. // The environment map, null in this case   
  5. Map environment = null;  
  6.   
  7. JMXConnectorServer cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(address, environment, null);  
  8.   
  9. // The MBeanServer to which the JMXConnectorServer will be registered in   
  10. MBeanServer server = MBeanServerFactory.createMBeanServer();  
  11.   
  12. // Register the JMXConnectorServer in the MBeanServer   
  13. ObjectName cntorServerName = ObjectName.getInstance("connectors:protocol=rmi");  
  14. server.registerMBean(cntorServer, cntorServerName);  
  15.   
  16. // Start the JMXConnectorServer   
  17. cntorServer.start();  
  18.   
  19. // An alternative way to start the JMXConnectorServer via the MBeanServer   
  20. server.invoke(cntorServerName, "start", null, null);  
  21.   
  22. // Yet another way to start the JMXConnectorServer via the MBeanServer   
  23. Object proxy = MBeanServerInvocationHandler.newProxyInstance(server, cntorServerName, JMXConnectorServerMBean.class, true);  
  24. JMXConnectorServerMBean cntorServerMBean = (JMXConnectorServerMBean)proxy;  
  25. cntorServerMBean.start();  

    需要注意的是，在这个例子中使用了三种不同的方式启动JMXConnectorServer：第一种方式是直接调用cntorServer对象的 start方法；第二种方式是通过MBeanServer调用MBean的方法；第三种方式是使用了 MBeanServerInvocationHandler，它继承自InvocationHandler，用于从MBean的管理接口向 MBeanServer中的 MBean 转发方法调用。当调用从newProxyInstance()方法返回的代理对象上的toString()、hashCode() 和equals(Object)等方法时，这些方法调用同样也会被转发到MBeanServer中的MBean ，因此当且仅当 MBean 在其管理接口中声明了这些方法时才能如此操作，否则会抛出异常。

 

2.3 JMXConnector
   JMXConnector是客户端的组件，客户端程序通过它连接到远程的MBeanServer。客户端可以通过JMXConnector获得远程 MBeanServer的MBeanServerConnection 接口，并以类似本地的方式使用它。JMXConnector还支持在远程的MBeanServer上注册本地或者远程的通知监听器，以接收来自远程 MBeanServer的通知。
    最好通过JMXConnectorFactory来创建JMXConnector，例如：

Java代码
  1. // The address of the connector server   
  2. JMXServiceURL address = ...;  
  3.   
  4. // The environment map, null in this case   
  5. Map environment = null;  
  6.   
  7. // Create the JMXCconnectorServer   
  8. JMXConnector cntor = JMXConnectorFactory.connect(address, environment);  
  9.   
  10. // Obtain a "stub" for the remote MBeanServer   
  11. MBeanServerConnection mbsc = cntor.getMBeanServerConnection();  
  12.   
  13. // Call the remote MBeanServer   
  14. String domain = mbsc.getDefaultDomain();  
  15. 也可以先实例化JMXConnector，然后在连接到MBeanServer，例如：  
  16. // The address of the connector server   
  17. JMXServiceURL address = ...;  
  18.   
  19. // The creation environment map, null in this case   
  20. Map creationEnvironment = null;  
  21.   
  22. // Create the JMXCconnectorServer   
  23. JMXConnector cntor = JMXConnectorFactory.newJMXConnector(address, creationEnvironment);  
  24.   
  25. // The connection environment map, null in this case   
  26. // May contain - for example - user's credentials   
  27. Map connectionEnvironment = null;  
  28.   
  29. // Connect   
  30. cntor.connect(connectionEnvironment);  
  31.   
  32. // Obtain a "stub" for the remote MBeanServer   
  33. MBeanServerConnection mbsc = cntor.getMBeanServerConnection();  
  34.   
  35. // Call the remote MBeanServer   
  36. String domain = mbsc.getDefaultDomain();  

    需要注意的是，以上的例子中采用了两个不同的Map对象保存相关的属性：一个用于实例化；另外一个用于连接。MBeanServerConnection 接口在JMX 1.2中定义，用于支持remote API。由于之前版本的MBeanServer接口不能直接被客户端使用（例如其registerMBean(), deserialize(), getClassLoader()等方法对于客户端来说没有意义），因此在JMX 1.2中，MBeanServer接口继承自MBeanServerConnection接口。

    RMIConnector是标准的JMXConnector。由于它使用RMI协议，因此需要一个stub object来处理RMI调用的细节。stub class通常存在于客户端的类路径上，但是stub object通常是从命名服务器处下载，因此RMI客户端需要知道stub object被绑定到RMI server上的路径。JSR 160定义了两种获得stub object的方式：
    第一种方式不需要命名服务器，而是将stub object编码为JMXServiceURL的一部分，即"encoded form"。如果采用RMI/JRMP协议，那么对stub object被序列化之后的所有字节进行Base64编码，然后将编码后的字符添加到JMXServiceURL中，并且以/stub/开始；如果采用 RMI/ IIOP，那么IOR被添加到JMXServiceURL中，并以/ior/开始。以下是个例子：

Java代码
  1. // JRMP encoded form   
  2. service:jmx:rmi://localhost/stub/rO0ABXNyAC5qYXZheC5tYW5hZ2VtZW50LnJlbW90ZS5ybWkuUk1JU2VydmVySW1wbF9TdHViAAAAAAAAAAICAAB4cgAaamF2YS5ybWkuc2VydmVyLlJlbW90ZVN0dWLp/tzJi+FlGgIAAHhyABxqYXZhLnJtaS5zZXJ2ZXIuUmVtb3RlT2JqZWN002G0kQxhMx4DAAB4cHc5AAtVbmljYXN0UmVmMgAADjE2LjE5Mi4xMjAuMTI5AAANcQAAAAAAAAAIAOgIQgAAAPlXjcJugAEAeA==  
  3.   
  4. // IIOP encoded form   
  5. service:jmx:iiop://localhost/ior/IOR:000000000000003b524d493a6a617661782e6d616e6167656d656e742e72656d6f74652e726d692e524d495365727665723a303030303030303030303030303030300000000000010000000000000068000102000000000f31362e3139322e3132302e31323900000d93000000000019afabcb0000000002578f08b80000000800000000000000000a0000000000000100000001000000200000000000010001000000020501000100010020000101090000000100010100  

    第二种方式是在JMXServiceURL中指定命名服务器和stub object被绑定到的JNDI路径，即"JNDI form"。在JMXServiceURL中以/jndi/开始。将JNDI的相关配置传递给RMIConnector的方式有多种。例如URL 'rmi://namingHost:1099/jndiPath'指明命名服务器在名为'namingHost'的主机上并监听1099端口，命名服务 器是rmiregistry，路径是'/jndiPath'。同样URL 'iiop://namingHost:900/jndiPath'指明命名服务器在名为'namingHost'的主机上并监听900端口，命名服务器 是COS命名服务，路径是'/jndiPath'。以下是个例子：

Java代码
  1. // JNDI URL form for JRMP   
  2. service:jmx:rmi://rmiHost/jndi/rmi://namingHost:1099/jndiPath  
  3.   
  4. // JNDI URL form for IIOP   
  5. service:jmx:iiop://rmiHost/jndi/iiop://namingHost:900/jndiPath  

    此外，JNDI属性也可以通过系统属性、类路径上的'jndi.properties'文件、在调用JMXConnector.connect(Map environment)或者JMXConnectorFactory.connect(JMXServiceURL url, Map environment)方法时传递的environment参数等不同方式指定。如果JNDI属性通过这些方式指定，那么JMXServiceURL中 可以使用简短的JNDI格式，即只指定JNDI path。以下是个例子：

Java代码
  1. // JNDI short form for JRMP   
  2. service:jmx:rmi://rmiHost/jndi/jndiPath  
  3.   
  4. // JNDI short form for IIOP   
  5. service:jmx:iiop://rmiHost/jndi/jndiPath  
  6.   
  7. // Code example that uses the JNDI short form specifying JNDI properties via environment Map   
  8. // The JNDI environment   
  9. Map environment = new HashMap();  
  10. environment.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");  
  11. environment.put(Context.PROVIDER_URL, "rmi://namingHost:1099");  
  12. // The JNDI short form JMXServiceURL   
  13. JMXServiceURL url = new JMXServiceURL("service:jmx:rmi://rmiHost/jndi/jndiPath");  
  14. // Connect to the server side   
  15. JMXConnector connector = JMXConnectorFactory.connect(url, environment);  

 

2.4 Remote Notification
    JSR 160定义的连接器可以接收到远程MBean发送的通知。通知被传递的细节依赖于连接器使用的协议。要接收通知，客户端必须要通过调用 MBeanServerConnection.addNotificationListener(...)方法来注册一个监听器，这个方法有两个重载的版 本：
    第一个版本接受一个ObjectName实例作为监听器，由于监听器是远程MBeanServer中的一个MBean，因此方法中的filter和handback参数必须被传递到远程的MBeanServer，因此它们必须是可以被序列化的。
    另一个版本接受NotificationListener的实例作为监听器。这个监听器是客户端的本地对象，而且监听器对象不会被传递到远程的 MBeanServer，因此它也不必是可以被序列化的。NotificationFilter是否被传递到远程的MBeanServer取决于 connector使用的协议，handback对象不会被传递到远程MBeanServer。在另一方面，远程的MBean发送的通知必须是可以被序列 化的，因为通知会被传递到客户端。以下是在远程的MBean上注册监听器的例子：

Java代码
  1. // The address of the connector server   
  2. JMXServiceURL address = ...;  
  3.   
  4. // The JMXConnector   
  5. JMXConnector connector = JMXConnectorFactory.connect(address);  
  6.   
  7. // The MBeanServerConnection "stub"   
  8. MBeanServerConnection mbsc = connector.getMBeanServerConnection();  
  9.   
  10. // The MBeanServerDelegate emits notifications about registration/unregistration of MBeans   
  11. ObjectName delegateName = ObjectName.getInstance("JMImplementation:type=MBeanServerDelegate");  
  12.   
  13. NotificationListener listener = new NotificationListener()  
  14. {  
  15.    public void handleNotification(Notification notification, Object handback)  
  16.    {  
  17.       // Do something  
  18.    }  
  19. };  
  20.   
  21. mbsc.addNotificationListener(delegateName, listener, null, null);  

 

3 JMX Remoting Security
    JSR 160提供了一种可插拔的认证机制，它基于JMXAuthenticator接口。JMXAuthenticator接口中只包含如下一个方法，它接受从 客户端得到的身份证明信息作为参数，返回javax.security.auth.Subject对象的一个实例。

Java代码
  1. public  Subject authenticate(Object credentials)  throws  SecurityException  

    以下是在JMXConnectorServer 中使用JMXAuthenticator的例子：

Java代码
  1. // The address of the connector server   
  2. JMXServiceURL address = ...;  
  3.   
  4. // The JMXAuthenticator implementation   
  5. JMXAuthenticator authenticator = ...;  
  6.   
  7. // The environment map   
  8. Map environment = new HashMap();  
  9. environment.put(JMXConnectorServer.AUTHENTICATOR, authenticator);  
  10.   
  11. // The MBeanServer to which the JMXConnectorServer will be attached to   
  12. MBeanServer server = MBeanServerFactory.createMBeanServer();  
  13.   
  14. // Create the JMXCconnectorServer   
  15. JMXConnectorServer cntorServer = JMXConnectorServerFactory.newJMXConnectorServer(address, environment, server);  
  16.   
  17. // Start the JMXConnectorServer   
  18. cntorServer.start();  

    以下是在JMXConnector中使用JMXAuthenticator的例子：

Java代码
  1. // The address of the connector server   
  2. JMXServiceURL address = ...;  
  3.   
  4. // Create the JMXCconnectorServer   
  5. JMXConnector cntor = JMXConnectorFactory.newJMXConnector(address, null);  
  6.   
  7. // The credentials   
  8. Object credentials = ...;  
  9.   
  10. // The connection environment map   
  11. Map environment = new HashMap();  
  12. environment.put(JMXConnector.CREDENTIALS, credentials);  
  13.   
  14. // Connect and invoke an operation on the remote MBeanServer   
  15. try   
  16. {  
  17.    cntor.connect(environment);  
  18. }  
  19. catch  (SecurityException x)  
  20. {  
  21.    // Uh-oh ! Bad credentials !  
  22.    throw x;  
  23. }  
  24.   
  25. // Obtain a stub for the remote MBeanServer   
  26. MBeanServerConnection mbsc = cntor.getMBeanServerConnection();  
  27.   
  28. // Call the remote MBeanServer   
  29. ObjectName delegate = ObjectName.getInstance("JMImplementation:type=MBeanServerDelegate");  
  30. String id = mbsc.getAttribute(delegate, "MBeanServerId");  

    当调用从JMXConnector 得到的MBeanServerConnection 接口上的方法时，最终发生在远程MBeanServer的调用会以认证后的Subject 身份执行。如果使用SecurityManager，那么还可以为不同的Subject指定不同的权限。



礼物 2010-09-01 22:34 发表评论
]]>Spring JMShttp://www.blogjava.net/libin2722/articles/330632.html礼物礼物Wed, 01 Sep 2010 14:33:00 GMThttp://www.blogjava.net/libin2722/articles/330632.htmlhttp://www.blogjava.net/libin2722/comments/330632.htmlhttp://www.blogjava.net/libin2722/articles/330632.html#Feedback0http://www.blogjava.net/libin2722/comments/commentRss/330632.htmlhttp://www.blogjava.net/libin2722/services/trackbacks/330632.html

1 DestinationResolver
    DestinationResolver接口的作用是将指定的目的地名解析为目的地实例。其定义如下：

Java代码
  1. public   interface  DestinationResolver {  
  2.     Destination resolveDestinationName(Session session, String destinationName,   
  3.         boolean pubSubDomain) throws JMSException;  
  4. }  

    参数pubSubDomain用于指定是使用“发布/订阅”模式（解析后的目的地是Topic），还是使用“点对点”模式（解析后的目的地是Queue）。

 

    CachingDestinationResolver接口继承了DestinationResolver，增加了缓存的功能，其接口定义如下：

Java代码
  1. public   interface  CachingDestinationResolver  extends  DestinationResolver {  
  2.     void removeFromCache(String destinationName);  
  3.     void clearCache();  
  4. }  

    在目的地失效的时候，removeFromCache方法会被调用；在JMS provider失效的时候，clearCache方法会被调用。

1.1 DynamicDestinationResolver
    DynamicDestinationResolver实现了DestinationResolver接口。根据指定的目的地名，DynamicDestinationResolver会动态创建目的地实例。针对JMS1.1规范，它采用如下方法创建目的地：

Java代码
  1. session.createTopic(topicName)  
  2. session.createQueue(queueName);  


1.2 JndiDestinationResolver
    JndiDestinationResolver继承自JndiLocatorSupport， 同时实现了CachingDestinationResolver接口。如果在JMS provider中配置了静态目的地，那么JndiDestinationResolver通过JNDI查找的方式获得目的地实例。


    JndiDestinationResolver的fallbackToDynamicDestination属性用于指定在JNDI查找失败后，是否使 用动态目的地，默认值是false。JndiDestinationResolver的cache属性用于指定是否对目的地实例进行缓存，默认值是 true。

 

1.3 BeanFactoryDestinationResolver
    BeanFactoryDestinationResolver实现了DestinationResolver接口和BeanFactoryAware接口。它会根据指定的目的地名从BeanFactory中查找目的地实例。以下是相关的代码：

Java代码
  1. public  Destination resolveDestinationName(Session session, String destinationName,   
  2. boolean  pubSubDomain)  throws  JMSException {  
  3.     Assert.state(this.beanFactory != null, "BeanFactory is required");  
  4.     try {  
  5.         return (Destination) this.beanFactory.getBean(destinationName, Destination.class);  
  6.     }  
  7.     catch (BeansException ex) {  
  8.         throw new DestinationResolutionException(  
  9.             "Failed to look up Destinaton bean with name '" + destinationName + "'", ex);  
  10.     }  
  11. }  

 

2 JmsAccessor
    抽象类JmsAccessor是JmsTemplate、SimpleMessageListenerContainer和 DefaultMessageListenerContainer等concrete class的基类。JmsAccessor定义了如下几个用于访问JMS服务的共通属性。

Java代码
  1. private  ConnectionFactory connectionFactory;  
  2. private   boolean  sessionTransacted =  false ;  
  3. private   int  sessionAcknowledgeMode = Session.AUTO_ACKNOWLEDGE;  


    JmsAccessor提供了创建Connection和Session的方法，如下：

Java代码
  1. protected  Connection createConnection()  throws  JMSException {  
  2.     return getConnectionFactory().createConnection();  
  3. }  
  4.   
  5. protected  Session createSession(Connection con)  throws  JMSException {  
  6.     return con.createSession(isSessionTransacted(), getSessionAcknowledgeMode());  
  7. }  

 
2.1 JmsDestinationAccessor
    抽象类JmsDestinationAccessor继承自JmsAccessor，增加了destinationResolver和 pubSubDomain属性。destinationResolver的默认值是DynamicDestinationResolver的实例，也就是 说默认采用动态目的地解析的方式；pubSubDomain用于指定是使用“发布/订阅”模式还是使用“点对点”模式，默认值是false。

    JmsDestinationAccessor提供了用于解析目的地的方法，如下：

Java代码
  1. protected  Destination resolveDestinationName(Session session, String destinationName)   
  2. throws  JMSException {  
  3.     return getDestinationResolver().resolveDestinationName(session, destinationName,   
  4.         isPubSubDomain());  
  5. }  


2.2 AbstractJmsListeningContainer
    AbstractJmsListeningContainer继承自JmsDestinationAccessor，作为所有Message Listener Container的公共基类。它主要提供了JMS connection的生命周期管理的功能，但是没有对消息接收的方式（主动接收方式或者异步接收方式）等做任何假定。该类主要的属性如下：

Java代码
  1. private  String clientId;  
  2. private  Connection sharedConnection;  

    clientId通常用于持久订阅；sharedConnection保存了被共享的JMS connection。

 

    该类定义了如下的抽象方法，以便子类可以决定是否使用共享的JMS connection。

Java代码
  1. protected   abstract   boolean  sharedConnectionEnabled();  

 

2.3 AbstractMessageListenerContainer
    AbstractMessageListenerContainer继承自AbstractJmsListeningContainer，也是作为所有Message Listener Container的公共基类。该类主要的属性如下：

Java代码
  1. private   volatile  Object destination;  
  2. private   volatile  Object messageListener;  
  3. private   boolean  exposeListenerSession =  true ;  

    destination用于指定接收消息的目的地。
    messageListener用于指定处理消息的listener。对于messageListener，它既可以是符合JMS规范的 javax.jms.MessageListener，也可以是Spring特有的 org.springframework.jms.listener.SessionAwareMessageListener。 SessionAwareMessageListener的定义如下：

Java代码
  1. public   interface  SessionAwareMessageListener {  
  2.     void onMessage(Message message, Session session) throws JMSException;  
  3. }  

    跟javax.jms.MessageListener相比，这个接口的onMessage方法增加了一个Session 类型的参数，可以通过这个session发送回复消息（reply message）。


    如果使用了SessionAwareMessageListener 类型的message listener，那么exposeListenerSession参数指定了传入onMessage方法的session参数是否是创建了 MessageConsumer的session，默认值是true。如果是false，那么 AbstractMessageListenerContainer会在connection上新建一个session，并传入onMessage方法。

2.4 AbstractPollingMessageListenerContainer
    AbstractPollingMessageListenerContainer继承自AbstractMessageListenerContainer，它提供了对于主动接收消息(polling)的支持，以及支持外部的事务管理。

Java代码
  1. private   boolean  pubSubNoLocal =  false ;  
  2. private   long  receiveTimeout = DEFAULT_RECEIVE_TIMEOUT;  
  3. private  PlatformTransactionManager transactionManager;  

    如果使用“发布/订阅”模式，那么pubSubNoLocal 属性指定通过某个连接发送到某个Topic的消息，是否应该被投递回这个连接。


    receiveTimeout属性用于指定调用MessageConsumer的receive方法时的超时时间，默认值是1秒。需要注意的是，这个值应该比transactionManager 中指定的事务超时时间略小。


    通常情况下，应该为transactionManager设置一个 org.springframework.transaction.jta.JtaTransactionManager的实例，此外也要设置一个支持 XA的ConnectionFactory。需要注意的是，XA 事务对性能有较大的影响。
    如果只是希望使用local JMS transaction，那么只要设置sessionTransacted为true或者使用JmsTransactionManager即可。实际上， 如果设置了非JTA的transactionManager，那么sessionTransacted属性会自动被设置成true。
    由于local JMS transaction无法同其它local transaction（例如local database transaction）进行协调，因此客户端程序可能需要对重发的消息进行检查。JMS规范要求：JMS provider应该将重发消息的JMSRedelivered属性设置为true。

2.5 SimpleMessageListenerContainer
    SimpleMessageListenerContainer继承自AbstractMessageListenerContainer，使用异步方式 接收消息（也就是通过MessageConsumer上注册MessageListener的方式接收消息）。该类主要的属性如下：

Java代码
  1. private   boolean  pubSubNoLocal =  false ;  
  2. private   int  concurrentConsumers =  1 ;  
  3. private  Set sessions;  
  4. private  Set consumers;  
  5. private  TaskExecutor taskExecutor;  

    如果使用“发布/订阅”模式，那么pubSubNoLocal 属性指定通过某个连接发送到某个Topic的消息，是否应该被投递回这个连接。

 

    SimpleMessageListenerContainer允许创建多个Session和MessageConsumer来接收消息。具体的个数由 concurrentConsumers属性指定。需要注意的是，应该只是在Destination为Queue的时候才使用多个 MessageConsumer（Queue中的一个消息只能被一个Consumer接收），虽然使用多个MessageConsumer会提高消息处理 的性能，但是消息处理的顺序却得不到保证：消息被接收的顺序仍然是消息发送时的顺序，但是由于消息可能会被并发处理，因此消息处理的顺序可能和消息发送的 顺序不同。此外，不应该在Destination为Topic的时候使用多个MessageConsumer，这是因为多个 MessageConsumer会接收到同样的消息。

    SimpleMessageListenerContainer创建的Session和MessageConsumer分别保存在sessions和consumers属性中。


    taskExecutor属性的默认值是null，也就是说，对MessageListener（或者 SessionAwareMessageListener）的回调是在MessageConsumer的内部线程中执行。如果指定了 taskExecutor，那么回调是在TaskExecutor内部的线程中执行。以下是相关的代码：

Java代码
  1. protected  MessageConsumer createListenerConsumer( final  Session session)   
  2. throws  JMSException {  
  3.     Destination destination = getDestination();  
  4.     if (destination == null) {  
  5.         destination = resolveDestinationName(session, getDestinationName());  
  6.     }  
  7.     MessageConsumer consumer = createConsumer(session, destination);  
  8.   
  9.     if (this.taskExecutor != null) {  
  10.         consumer.setMessageListener(new MessageListener() {  
  11.             public void onMessage(final Message message) {  
  12.                 taskExecutor.execute(new Runnable() {  
  13.                     public void run() {  
  14.                         processMessage(message, session);  
  15.                     }  
  16.                 });  
  17.             }  
  18.         });  
  19.     }  
  20.     else {  
  21.         consumer.setMessageListener(new MessageListener() {  
  22.             public void onMessage(Message message) {  
  23.                 processMessage(message, session);  
  24.             }  
  25.         });  
  26.     }  
  27.   
  28.     return consumer;  
  29. }  

    需要注意的是，如果指定了taskExecutor，那么消息在被taskExecutor内部的线程处理前，可能已经被确认过了（外层的 onMessage方法可能已经执行结束了）。因此如果使用事务Session或者Session.CLIENT_ACKNOWLEDGE类型的确认模 式，那么可能会导致问题。

 

    该类的sharedConnectionEnabled方法（在AbstractJmsListeningContainer中定义）总是返回true， 因此SimpleMessageListenerContainer会使用共享的JMS connection。

2.6 DefaultMessageListenerContainer
    DefaultMessageListenerContainer继承自 AbstractPollingMessageListenerContainer，主要使用同步的方式接收消息（也就是通过循环调用 MessageConsumer.receive的方式接收消息）。该类主要的属性如下：

Java代码
  1. private   int  concurrentConsumers =  1 ;  
  2. private   int  maxConcurrentConsumers =  1 ;  
  3. private   int  maxMessagesPerTask = Integer.MIN_VALUE;  
  4. private   int  idleTaskExecutionLimit =  1 ;  
  5. private   final  Set scheduledInvokers =  new  HashSet();  
  6. private  TaskExecutor taskExecutor;  
  7. private   int  cacheLevel = CACHE_AUTO;  

    跟SimpleMessageListenerContainer一样，DefaultMessageListenerContainer也支持创建多个 Session和MessageConsumer来接收消息。跟SimpleMessageListenerContainer不同的 是，DefaultMessageListenerContainer创建了concurrentConsumers所指定个数的 AsyncMessageListenerInvoker（实现了SchedulingAwareRunnable接口），并交给 taskExecutor运行。


    maxMessagesPerTask属性的默认值是Integer.MIN_VALUE，但是如果设置的taskExecutor（默认值是 SimpleAsyncTaskExecutor）实现了SchedulingTaskExecutor接口并且其 prefersShortLivedTasks方法返回true（也就是说该TaskExecutor倾向于短期任务），那么 maxMessagesPerTask属性会自动被设置为10。
    如果maxMessagesPerTask属性的值小于0，那么AsyncMessageListenerInvoker.run方法会在循环中反复尝试 接收消息，并在接收到消息后调用MessageListener（或者SessionAwareMessageListener）；如果 maxMessagesPerTask属性的值不小于0，那么AsyncMessageListenerInvoker.run方法里最多会尝试接收消息 maxMessagesPerTask次，每次接收消息的超时时间由其父类 AbstractPollingMessageListenerContainer的receiveTimeout属性指定。如果在这些尝试中都没有接收 到消息，那么AsyncMessageListenerInvoker的idleTaskExecutionCount属性会被累加。在run方法执行完 毕前会对idleTaskExecutionCount进行检查，如果该值超过了 DefaultMessageListenerContainer.idleTaskExecutionLimit（默认值1），那么这个 AsyncMessageListenerInvoker可能会被销毁。


    所有AsyncMessageListenerInvoker实例都保存在scheduledInvokers中，实例的个数可以在 concurrentConsumers和maxConcurrentConsumers之间浮动。跟 SimpleMessageListenerContainer一样，应该只是在Destination为Queue的时候才使用多个 AsyncMessageListenerInvoker实例。

 

    cacheLevel属性用于指定是否对JMS资源进行缓存，可选的值是CACHE_NONE = 0、CACHE_CONNECTION = 1、CACHE_SESSION = 2、CACHE_CONSUMER = 3和CACHE_AUTO = 4。默认情况下，如果transactionManager属性不为null，那么cacheLevel被自动设置为CACHE_NONE（不进行缓 存），否则cacheLevel被自动设置为CACHE_CONSUMER。


    如果cacheLevel属性值大于等于CACHE_CONNECTION，那么sharedConnectionEnabled方法（在AbstractJmsListeningContainer中定义）返回true，也就是说使用共享的JMS连接。

 

 

3 SingleConnectionFactory
    SingleConnectionFactory实现了ConnectionFactory接口，其createConnection方法总是返回相同的 Connection。可以在SingleConnectionFactory的构造函数中传入Connection对象或者 ConnectionFactory对象，用来创建被代理的连接对象。 SingleConnectionFactory.createConnection方法返回的连接是个代理，它忽略了对stop和close方法的调用 （连接会在SingleConnectionFactory.destroy方法中关闭）。


    SingleConnectionFactory的reconnectOnException属性用来指定是否在连接抛出JMSException的时候，对连接进行重置，重置后如果再调用createConnection方法，那么会返回一个新的连接。


    需要注意的是，AbstractJmsListeningContainer类的抽象方法sharedConnectionEnabled指定了是否在 message listener container内部使用共享的JMS连接。因此通常情况下不需要为单独的message listener container设置SingleConnectionFactory（及其子类）；如果希望在不同的message listener container之间共享JMS连接，那么可以考虑使用SingleConnectionFactory。

3.1 CachingConnectionFactory
    CachingConnectionFactory继承自SingleConnectionFactory，增加了对Session和MessageProducer缓存的功能。该类主要的属性如下：

Java代码
  1. private   int  sessionCacheSize =  1 ;  
  2. private   boolean  cacheProducers =  true ;  

    sessionCacheSize属性指定了被缓存的Session实例的个数（默认值是1），也就是说，如果同时请求的Session个数大于sessionCacheSize，那么这些Session不会被缓存，而是正常的被创建和销毁。


    cacheProducers属性指定了是否对MessageProducer进行缓存，默认值是true。



礼物 2010-09-01 22:33 发表评论
]]>ActiveMQ5.0实战三:使用Spring发送,消费topic和queue消息http://www.blogjava.net/libin2722/articles/249400.html礼物礼物Wed, 31 Dec 2008 14:10:00 GMThttp://www.blogjava.net/libin2722/articles/249400.htmlhttp://www.blogjava.net/libin2722/comments/249400.htmlhttp://www.blogjava.net/libin2722/articles/249400.html#Feedback0http://www.blogjava.net/libin2722/comments/commentRss/249400.htmlhttp://www.blogjava.net/libin2722/services/trackbacks/249400.html简介

实战一 , 实战二介绍了ActiveMQ的基本概念和配置方式.

本篇将通过一个实例介绍使用spring发送,消费topic, queue类型消息的方法. 不懂topic和queue的google 之.

 

如图示, TOPIC和QUEUE分别代表一个topic和一个queue消息通道.

  1. TopicMessageProducer向topic发送消息, TopicConsumerA和TopicConsumerB则从topic消费消息.
  2. QueueMessageProducer向Queue发送消息, QueueConsumer从Queue中消费消息

Spring整合JMS

就像对orm, web的支持一样, spring同样支持jms, 为整合jms到已有的项目提供了很多便利的方法. 本篇主要讲实战, 是所以先从配置开始, spring配置jms基本上需要8个部分.

  1. ConnectionFactory. 和jms服务器的连接, 可以是外部的jms server, 也可以使用embedded ActiveMQ Broker.
  2. Destination. 有topic和queue两种方式.
  3. JmsTemplate. spring提供的jms模板.
  4. MessageConverter. 消息转换器.
  5. MessageProducer. 消息生产者.
  6. MessageConsumer. 消息消费者.
  7. MessageListener. 消息监听器
  8. MessageListenerContainer. 消息监听容器

下面以实例的方式介绍上面8个部分.

1. ConnectionFactory

Xml代码 复制代码
  1. <amq:connectionFactory id="jmsConnectionFactory" brokerURL="vm://localhost" />  

 brokerURL是指要连接的activeMQ server的地址, activeMQ提供了多种brokerURL, 集体可参见文档.一般我们使用嵌套的ActiveMQ server. 配置如下, 这个配置使用消息的存储机制, 服务器重启也不会丢失消息.

Xml代码 复制代码
  1. <!--  embedded ActiveMQ Broker -->  
  2.     <amq:broker useJmx="false" persistent="true">  
  3.         <amq:persistenceAdapter>  
  4.             <amq:amqPersistenceAdapter directory="d:/amq"/>  
  5.         </amq:persistenceAdapter>  
  6.         <amq:transportConnectors>  
  7.             <amq:transportConnector uri="tcp://localhost:61616" />  
  8.                        <amq:transportConnector uri="vm://localhost:0" />  
  9.         </amq:transportConnectors>  
  10.     </amq:broker>  

 2. Destination

 在实例中我们使用了两种destination

Xml代码 复制代码
  1. <!--  ActiveMQ destinations  -->  
  2. <!--  使用topic方式-->  
  3. <amq:topic name="TOPIC" physicalName="JMS-TEST-TOPIC" />  
  4. <!--  使用Queue方式-->  
  5. <amq:queue name="QUEUE" physicalName="JMS-TEST-QUEUE" />  

 3. JmsTemplate

Xml代码 复制代码
  1. <!--  Spring JmsTemplate config -->  
  2.     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">  
  3.         <property name="connectionFactory">  
  4.             <!--  lets wrap in a pool to avoid creating a connection per send -->  
  5.             <bean class="org.springframework.jms.connection.SingleConnectionFactory">  
  6.                 <property name="targetConnectionFactory" ref="jmsConnectionFactory" />  
  7.             </bean>  
  8.         </property>  
  9.         <!-- custom MessageConverter -->  
  10.         <property name="messageConverter" ref="defaultMessageConverter" />  
  11.     </bean>  

  4. MessageConverter

   MessageConverter实现的是org.springframework.jms.support.converter.MessageConverter接口, 提供消息的转换功能. DefaultMessageConverter的实现见附件.

Xml代码 复制代码
  1. <bean id="defaultMessageConverter" class="com.andyao.activemq.DefaultMessageConverter" />  

  5. MessageProducer

   实例拥有两个消息生产者, 消息生产者都是POJO, 实现见附件.

Xml代码 复制代码
  1. <!-- POJO which send Message uses  Spring JmsTemplate -->  
  2.     <bean id="topicMessageProducer" class="com.andyao.activemq.TopicMessageProducer">  
  3.         <property name="template" ref="jmsTemplate" />  
  4.         <property name="destination" ref="TOPIC" />  
  5.     </bean>  
  6.     <bean id="queueMessageProducer" class="com.andyao.activemq.QueuMessageProducer">  
  7.         <property name="template" ref="jmsTemplate" />  
  8.         <property name="destination" ref="QUEUE" />  
  9.     </bean>  

 6. MessageConsumer

 TOPIC通道有两个消息消费者, QUEUE有一个消息消费者

Xml代码 复制代码
  1. <!--  Message Driven POJO (MDP) -->  
  2.     <!-- consumer1 for topic a -->  
  3.     <bean id="topicConsumerA" class="com.andyao.activemq.TopicConsumerA" />  
  4.     <!-- consumer2 for topic a -->  
  5.     <bean id="topicConsumerB" class="com.andyao.activemq.TopicConsumerB" />  
  6.     <!-- consumer for queue -->  
  7.     <bean id="queueConsumer" class="com.andyao.activemq.QueueConsumer" />  

  7. MessageListener

每一个消息消费者都对应一个MessageListener

Xml代码 复制代码
  1. <bean id="topicListenerA" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">  
  2.         <constructor-arg ref="topicConsumerA" />  
  3.         <!--  may be other method -->  
  4.         <property name="defaultListenerMethod" value="receive" />  
  5.         <!-- custom MessageConverter define -->  
  6.         <property name="messageConverter" ref="defaultMessageConverter" />  
  7.     </bean>  
  8.   
  9.     <bean id="topicListenerB" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">  
  10.         <constructor-arg ref="topicConsumerB" />  
  11.         <!--  may be other method -->  
  12.         <property name="defaultListenerMethod" value="receive" />  
  13.         <!-- custom MessageConverter define -->  
  14.         <property name="messageConverter" ref="defaultMessageConverter" />  
  15.     </bean>  
  16.   
  17.     <bean id="queueListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">  
  18.         <constructor-arg ref="queueConsumer" />  
  19.         <!--  may be other method -->  
  20.         <property name="defaultListenerMethod" value="receive" />  
  21.         <!-- custom MessageConverter define -->  
  22.         <property name="messageConverter" ref="defaultMessageConverter" />  
  23.     </bean>  

 8. MessageListenerContainer

 有几个MessageListener既有几个MessageListenerContainer

Xml代码 复制代码
  1. <bean id="topicListenerContainerA" class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
  2.         <property name="connectionFactory" ref="jmsConnectionFactory" />  
  3.         <property name="destination" ref="TOPIC" />  
  4.         <property name="messageListener" ref="topicListenerA" />  
  5.     </bean>  
  6.   
  7.     <bean id="topicListenerContainerB" class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
  8.         <property name="connectionFactory" ref="jmsConnectionFactory" />  
  9.         <property name="destination" ref="TOPIC" />  
  10.         <property name="messageListener" ref="topicListenerB" />  
  11.     </bean>  
  12.        
  13.     <bean id="queueListenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">  
  14.         <property name="connectionFactory" ref="jmsConnectionFactory" />  
  15.         <property name="destination" ref="QUEUE" />  
  16.         <property name="messageListener" ref="queueListener" />  
  17.     </bean>  

  Summary

写spring配置文件的时候, 要把MessageProducer, MessageConsumer,MessageListener,MessageListenerContainer几个地方弄清楚:

  1. 可以有一个或者多个消息生产者向同一个destination发送消息.
  2. queue类型的只能有一个消息消费者.
  3. topic类型的可以有多个消息消费者.
  4. 每个消费者对应一个MessageListener和一个MessageListenerContainer.

 



礼物 2008-12-31 22:10 发表评论
]]>ActiveMQ5.0实战二: 基本配置http://www.blogjava.net/libin2722/articles/249399.html礼物礼物Wed, 31 Dec 2008 14:09:00 GMThttp://www.blogjava.net/libin2722/articles/249399.htmlhttp://www.blogjava.net/libin2722/comments/249399.htmlhttp://www.blogjava.net/libin2722/articles/249399.html#Feedback0http://www.blogjava.net/libin2722/comments/commentRss/249399.htmlhttp://www.blogjava.net/libin2722/services/trackbacks/249399.html简介

上一篇http://www.javaeye.com/topic/15317介绍了ActiveMQ5.0的安装，这一篇将介绍的配置。ActiveMQ包含了很多features（详见http://activemq.apache.org/features.html ），  
不同的需求，不同的环境，需要不同的features，当然需要不同的配置。在这里我只写了最基本的配置，算是抛砖了，希望引出更多关于ActiveMQ的高级配置。
假设已经正确安装ActiveMQ5.0，同时及其IP地址为192.168.1.148，具体使用时可以改为自己的IP。下面讲解的配置实现的features如下：

  1. 客户端可以通过tcp://192.168.1.148连接ActiveMQ。
  2. 消息持久化保存，重启服务器不会丢失消息。
  3. 可以通过http://192.168.1.148:8161/admin监控ActiveMQ服务器

配置

ActiveMQ默认使用的是XML格式配置，从4.0版本开始用MBean的方式实现XML配置，配置文件在${activemq.home}/conf目录下，文件名为activemq.xml。最新的默认配置见
http://svn.apache.org/repos/asf/activemq/trunk/assembly/src/release/conf/activemq.xml 。下面为本篇文章使用的配置，及重要部分的解释。

 

Xml代码 复制代码
  1. <beans  
  2.   xmlns="http://www.springframework.org/schema/beans"  
  3.   xmlns:amq="http://activemq.org/config/1.0"  
  4.   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-2.0.xsd   
  5.   http://activemq.org/config/1.0 http://activemq.apache.org/schema/activemq-core.xsd   
  6.   http://activemq.apache.org/camel/schema/spring>  
  7.     
  8.   <!-- persistent="true"表示要持久化存储消息，和子元素persistenceAdapter结合使用 -->  
  9.   <!-- dataDirectory默认的存储持久化数据的目录 -->  
  10.   <!-- brokerName 设置broker的name，在注意在网络上必须是唯一的-->  
  11.   <!-- 更多参考http://activemq.apache.org/xbean-xml-reference-50.html#XBeanXMLReference5.0-brokerelement -->  
  12.   <broker xmlns="http://activemq.org/config/1.0" brokerName="192.168.1.148" persistent ="true" dataDirectory="${activemq.base}/data" useShutdownHook="false">  
  13.     
  14.     <!-- Destination specific policies using destination names or wildcards -->  
  15.     <!-- wildcards意义见http://activemq.apache.org/wildcards.html -->  
  16.     <destinationPolicy>  
  17.       <policyMap>  
  18.         <policyEntries>  
  19.        <!-- 这里使用了wildcards，表示所有以EUCITA开头的topic -->  
  20.           <policyEntry topic="EUCITA.>" producerFlowControl="false" memoryLimit="10mb">  
  21.             <!-- 分发策略 -->  
  22.         <dispatchPolicy>  
  23.           <!-- 按顺序分发 -->  
  24.               <strictOrderDispatchPolicy/>  
  25.             </dispatchPolicy>  
  26.         <!--  恢复策略-->  
  27.             <subscriptionRecoveryPolicy>  
  28.           <!-- 只恢复最后一个message -->  
  29.               <lastImageSubscriptionRecoveryPolicy/>  
  30.             </subscriptionRecoveryPolicy>  
  31.           </policyEntry>  
  32.         </policyEntries>  
  33.       </policyMap>  
  34.     </destinationPolicy>  
  35.   
  36.     <!-- The transport connectors ActiveMQ will listen to -->  
  37.     <transportConnectors>  
  38.        <transportConnector name="openwire" uri="tcp://192.168.1.148:61616" discoveryUri="multicast://default"/>  
  39.        <transportConnector name="ssl"     uri="ssl://192.168.1.148:61617"/>  
  40.        <transportConnector name="stomp"   uri="stomp://192.168.1.148:61613"/>  
  41.        <transportConnector name="xmpp"    uri="xmpp://192.168.1.148:61222"/>  
  42.     </transportConnectors>  
  43.       
  44.     <!-- 消息持久化方式 -->  
  45.     <persistenceAdapter>  
  46.       <amqPersistenceAdapter directory="${activemq.base}/data"/>  
  47.     </persistenceAdapter>  
  48. </broker>  
  49.   
  50.   <!-- lets create a command agent to respond to message based admin commands on the ActiveMQ.Agent topic -->  
  51.     <commandAgent xmlns="http://activemq.org/config/1.0"/>  
  52.      
  53.   <!-- An embedded servlet engine for serving up the Admin console -->  
  54.   <jetty xmlns="http://mortbay.com/schemas/jetty/1.0">  
  55.     <connectors>  
  56.       <nioConnector port="8161" />  
  57.     </connectors>  
  58.   
  59.     <handlers>  
  60.       <webAppContext contextPath="/admin" resourceBase="${activemq.base}/webapps/admin" logUrlOnStart="true" />        
  61.       <webAppContext contextPath="/demo" resourceBase="${activemq.base}/webapps/demo" logUrlOnStart="true" />          
  62.     </handlers>  
  63.   </jetty>    
  64. </beans>  

注释

关于XML配置中元素的具体信息可以参考http://activemq.apache.org/xbean-xml-reference-50.html 下面介绍本篇配置使用的一些重要元素。

DispathPolicy

ActiveMQ支持3中不同的分发策略（避免翻译了以后误解，这里用原文）：

  1. <roundRobinDispatchPolicy>：Simple dispatch policy that sends a message to every subscription that matches the message.
  2. <simpleDispatchPolicy>：Simple dispatch policy that sends a message to every subscription that matches the message.
  3. <strictOrderDispatchPolicy>：Dispatch policy that causes every subscription to see messages in the same order.

SubscriptionRecoveryPolicy

ActiveMQ支持6种恢复策略，可以自行选择使用不同的策略

  1. <fixedCountSubscriptionRecoveryPolicy>： keep a fixed count of last messages.
  2. <fixedSizedSubscriptionRecoveryPolicy>： keep a fixed amount of memory available in RAM for message history which is evicted in time order.
  3. <lastImageSubscriptionRecoveryPolicy>：only keep the last message.
  4. <noSubscriptionRecoveryPolicy>：disable recovery of messages.
  5. <queryBasedSubscriptionRecoveryPolicy>：perform a user specific query mechanism to load any messages they may have missed.
  6. <timedSubscriptionRecoveryPolicy>：keep a timed buffer of messages around in memory and use that to recover new subscriptions.

PersistenceAdapter

http://activemq.apache.org/persistence 讲解了关于persistence的信息。ActiveMQ5.0使用AMQ Message Store 持久化消息，这种方式提供了很好的性能（The AMQ Message Store is an embeddable transactional message storage solution that is extremely fast and reliable.） 默认使用该存储方式即可，如果想使用JDBC来存储，可以查找文档配置。 

Summary

本篇文章只提供了基本配置信息。如果需要更多的文章，可以查看ActiveMQ的文档。

讲了安装和简单的配置，下一篇将介绍和Sping的整合，以及多个queue，多个topic，多个producer，多个consumer的配置，使用。



礼物 2008-12-31 22:09 发表评论
]]>ActiveMQ5.0实战一: 安装配置ActiveMQ5.0http://www.blogjava.net/libin2722/articles/249398.html礼物礼物Wed, 31 Dec 2008 14:09:00 GMThttp://www.blogjava.net/libin2722/articles/249398.htmlhttp://www.blogjava.net/libin2722/comments/249398.htmlhttp://www.blogjava.net/libin2722/articles/249398.html#Feedback0http://www.blogjava.net/libin2722/comments/commentRss/249398.htmlhttp://www.blogjava.net/libin2722/services/trackbacks/249398.html简介

  ActiveMQ 是开源的JMS实现，Geronimo应用服务器就是使用的ActiveMQ提供JMS服务。ActiveMQ5.0相比以前版本提供了一些非常有用的新功能：

  1. AMQ Message Store (Faster Persistence!)
  2. Cursors (To handle very large number of stored messages)
  3. Blob Messages
  4. Command Agent
  5. Enterprise Integration Patterns via Camel Integration
  6. Logging a warning if you forget to start a Connection
  7. Message Transformation
  8. Mirrored Queues
  9. Flow Control 

鉴于目前关于ActiveMQ5.0的文章比较少，故准备写一系列ActiveMQ的使用方面的文章。本篇先从安装开始。 

安装

  1. 在http://activemq.apache.org/download.html 下载5.0.0发行包，解压到需要安装ActiveMQ的文件夹，记为/path/to/activemq。
  2. unix环境activemq文件夹需要执行权限，执行如下命令  chmod -R 755 /path/to/activemq 

启动

  1. window环境运行/path/to/activemq/bin/activemq.bat
  2. unix环境运行/path/to/activemq/bin/activemq

测试

ActiveMQ默认使用的TCP连接端口是61616, 通过查看该端口的信息可以测试ActiveMQ是否成功启动

  1. window环境运行  netstat -an|find "61616"
  2. unix环境运行netstat -an|grep 61616

监控

ActiveMQ5.0版本默认启动时，启动了内置的jetty服务器，提供一个demo应用和用于监控ActiveMQ的admin应用。

admin：http://127.0.0.1:8161/admin/

demo：http://127.0.0.1:8161/demo/

 

点击demo应用中的“ Market data publisher ”，就会发一些测试的消息。转到admin页面的topics menu下面（queue和topic的区别见 http://andyao.javaeye.com/blog/153173 ），可以看到消息在增长。

配置

ActiveMQ5.0的配置文件在/path/to/activemq/conf目录下面。主要配置文件为activemq.xml，具体的配置将在后续文章中详细说明。



礼物 2008-12-31 22:09 发表评论
]]>