使用Log4j、ActiveMQ和Spring实现异步日志

我的团队和我正在创建一个由一组RESTful JSON服务组成的服务平台，该平台中的每个服务在平台中的作用就是分别提供一些独特的功能和/或数据。由于平台中产生的日志四散各处，所以我们想，要是能将这些日志集中化处理一下，并提供一个能够让我们查看、过滤、排序和搜索我们所有的日志的基本型的日常查看工具就好了。我们还想让我们的日志是异步式的，因为我们可不想在写日志的时候（比方说，可能会将日志直接写入数据库），让我们提供的服务因为写日志而暂时被阻挡住。

创新互联主营美兰网站建设的网络公司,主营网站建设方案,app软件定制开发,美兰h5成都微信小程序搭建,美兰网站营销推广欢迎美兰等地区企业咨询

实现这个目标的策略非常简单明了。

  1. 安装ActiveMQ
  2. 创建一个log4j的日志追加器，将日志写入队列（log4j自带了一个这样的追加器，不过现在让我们自己来写一个吧。） 
  3. 写一个消息侦听器，从MQ服务器上所设置的JMS队列中读取日志并将日志持久化

下面让我们分步来看这个策略是如何得以实现的。

安装ActiveMQ

安装一个外部的ActiveMQ服务器简单极了。这个链接http://servicebus.blogspot.com/2011/02/installing-apache-active-mq-on-ubuntu.html是在Ubuntu上安装ActiveMQ的一个非常棒的指南。你还可以选择在你的应用中嵌入一个消息代理，采用Spring就可以非常轻松实现。 我们将在后文中详谈具体的实现方法。

创建一个Lo4j的JMS日志追加器

首先，我们来创建一个log4j的JMS日志追加器。log4j自带了一个这样的追加器（该追加器没有将日志写入一个队列，而是写给了一个话题）

 
 
 
 
    
  
  
  
  
  1. import javax.jms.DeliveryMode;  
    2. 
  
  
  
  
  2. import javax.jms.Destination;  
    3. 
  
  
  
  
  3. import javax.jms.MessageProducer;  
    4. 
  
  
  
  
  4. import javax.jms.ObjectMessage;  
    5. 
  
  
  
  
  5. import javax.jms.Session;  
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. import org.apache.activemq.ActiveMQConnectionFactory;  
    8. 
  
  
  
  
  8. import org.apache.log4j.Appender;  
    9. 
  
  
  
  
  9. import org.apache.log4j.AppenderSkeleton;  
    10. 
  
  
  
  
  10. import org.apache.log4j.Logger;  
    11. 
  
  
  
  
  11. import org.apache.log4j.PatternLayout;  
    12. 
  
  
  
  
  12. import org.apache.log4j.spi.LoggingEvent;  
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14. /**  
    15. 
  
  
  
  
  15.  * JMSQueue appender is a log4j appender that writes LoggingEvent to a queue.  
    16. 
  
  
  
  
  16.  * @author faheem  
    17. 
  
  
  
  
  17.  *  
    18. 
  
  
  
  
  18.  */ 
    19. 
  
  
  
  
  19. public class JMSQueueAppender extends AppenderSkeleton implements Appender{  
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21. private static Logger logger = Logger.getLogger("JMSQueueAppender");  
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23. private String brokerUri;  
    24. 
  
  
  
  
  24. private String queueName;  
    25. 
  
  
  
  
  25.  
    26. 
  
  
  
  
  26. @Override 
    27. 
  
  
  
  
  27. public void close() {  
    28. 
  
  
  
  
  28.  
    29. 
  
  
  
  
  29. }  
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31. @Override 
    32. 
  
  
  
  
  32. public boolean requiresLayout() {  
    33. 
  
  
  
  
  33.     return false;  
    34. 
  
  
  
  
  34. }  
    35. 
  
  
  
  
  35.  
    36. 
  
  
  
  
  36. @Override 
    37. 
  
  
  
  
  37. protected synchronized void append(LoggingEvent event) {  
    38. 
  
  
  
  
  38.  
    39. 
  
  
  
  
  39.    try {  
    40. 
  
  
  
  
  40.  
    41. 
  
  
  
  
  41.      ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(  
    42. 
  
  
  
  
  42.                     this.brokerUri);  
    43. 
  
  
  
  
  43.  
    44. 
  
  
  
  
  44.      // Create a Connection  
    45. 
  
  
  
  
  45.      javax.jms.Connection connection = connectionFactory.createConnection();  
    46. 
  
  
  
  
  46.      connection.start();np  
    47. 
  
  
  
  
  47.  
    48. 
  
  
  
  
  48.      // Create a Session  
    49. 
  
  
  
  
  49.      Session session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);  
    50. 
  
  
  
  
  50.  
    51. 
  
  
  
  
  51.      // Create the destination (Topic or Queue)  
    52. 
  
  
  
  
  52.      Destination destination = session.createQueue(this.queueName);  
    53. 
  
  
  
  
  53.  
    54. 
  
  
  
  
  54.      // Create a MessageProducer from the Session to the Topic or Queue  
    55. 
  
  
  
  
  55.      MessageProducer producer = session.createProducer(destination);  
    56. 
  
  
  
  
  56.      producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);  
    57. 
  
  
  
  
  57.  
    58. 
  
  
  
  
  58.      ObjectMessage message = session.createObjectMessage(new LoggingEventWrapper(event));  
    59. 
  
  
  
  
  59.  
    60. 
  
  
  
  
  60.      // Tell the producer to send the message  
    61. 
  
  
  
  
  61.      producer.send(message);  
    62. 
  
  
  
  
  62.  
    63. 
  
  
  
  
  63.      // Clean up  
    64. 
  
  
  
  
  64.      session.close();  
    65. 
  
  
  
  
  65.      connection.close();  
    66. 
  
  
  
  
  66.   } catch (Exception e) {  
    67. 
  
  
  
  
  67.      e.printStackTrace();  
    68. 
  
  
  
  
  68.   }  
    69. 
  
  
  
  
  69. }  
    70. 
  
  
  
  
  70.  
    71. 
  
  
  
  
  71. public void setBrokerUri(String brokerUri) {  
    72. 
  
  
  
  
  72.     this.brokerUri = brokerUri;  
    73. 
  
  
  
  
  73. }  
    74. 
  
  
  
  
  74.  
    75. 
  
  
  
  
  75. public String getBrokerUri() {  
    76. 
  
  
  
  
  76.     return brokerUri;  
    77. 
  
  
  
  
  77. }  
    78. 
  
  
  
  
  78.  
    79. 
  
  
  
  
  79. public void setQueueName(String queueName) {  
    80. 
  
  
  
  
  80.     this.queueName = queueName;  
    81. 
  
  
  
  
  81. }  
    82. 
  
  
  
  
  82.  
    83. 
  
  
  
  
  83. public String getQueueName() {  
    84. 
  
  
  
  
  84.     return queueName;  
    85. 
  
  
  
  
  85. }  
    86. 
  
  
  
  
  86. } 
    87.

第37行: log4j将一个LoggingEvent对象作为参数对append方法进行调用，这个LoggingEvent对象表示了对logger的一次调用，它封装了每一个日志项的所有信息。

第41和42行：将指向JMS的uri作为参数，创建一个连接工厂对象，在我们的情况下，该uri指向的是我们的ActiveMQ服务器。

第45, 46和49行: 我们同JMS服务器建立一个连接和会话。会话有多种打开模式。在Auto_Acknowledge模式的会话中，消息的应答会自动发生。Client_Acknowledge 模式下，客户端需要对消息的接收和/或处理进行显式地应答。另外还有两种其它的模式。有关细节，请参考文档http://download.oracle.com/javaee/1.4/api/javax/jms/Session.html

第52行: 创建一个队列。将队列的名字作为参数发送给连接

下面让我们看看这里面发生了什么事情。

第19行：We我们实现了的Log4J日志追加器接口，该接口要求我们实现三个方法：requiresLayout, close和append。我们将暂时简化处理过程，实现所需的append方法。在对logger进行调用时这个方法就会被调用。

第56行: 我们将发送模式设置为Non_Persistent。另一个可选的模式是Persistent ，在这种模式下，消息会持久化到一个持久性存储系统中。持久化模式会降低系统速度，但能增加了消息传递的可靠性。

第58行: 这行我们做了很多事。首先我将一个LoggingEvent对象封装到了一个LoggingEventWrapper对象之中。这么做是因为LoggingEvent对象有一些属性不支持序列化，另外还有一个原因是我想记录一些额外的信息，比如IP地址和主机名。接下来，使用JMS的会话对象，我们把一个对象（LoggingEventWrapper对象）做好了发送前的准备。

第61行: 我将该对象发送到了队列中。

下面所示是LoggingEventWrapper的代码。

 
 
 
 
    
  
  
  
  
  1. import java.io.Serializable;  
    2. 
  
  
  
  
  2. import java.net.InetAddress;  
    3. 
  
  
  
  
  3. import java.net.UnknownHostException;  
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. import org.apache.log4j.EnhancedPatternLayout;  
    6. 
  
  
  
  
  6. import org.apache.log4j.spi.LoggingEvent;  
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8. /**  
    9. 
  
  
  
  
  9.  * Logging Event Wraps a log4j LoggingEvent object. Wrapping is required by some information is lost  
    10. 
  
  
  
  
  10.  * when the LoggingEvent is serialized. The idea is to extract all information required from the LoggingEvent  
    11. 
  
  
  
  
  11.  * object, place it in the wrapper and then serialize the LoggingEventWrapper. This way all required data remains  
    12. 
  
  
  
  
  12.  * available to us.  
    13. 
  
  
  
  
  13.  * @author faheem  
    14. 
  
  
  
  
  14.  *  
    15. 
  
  
  
  
  15.  */ 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17. public class LoggingEventWrapper implements Serializable{  
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19.     private static final String ENHANCED_PATTERN_LAYOUT = "%throwable";  
    20. 
  
  
  
  
  20.     private static final long serialVersionUID = 3281981073249085474L;  
    21. 
  
  
  
  
  21.     private LoggingEvent loggingEvent;  
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23.     private Long timeStamp;  
    24. 
  
  
  
  
  24.     private String level;  
    25. 
  
  
  
  
  25.     private String logger;  
    26. 
  
  
  
  
  26.     private String message;  
    27. 
  
  
  
  
  27.     private String detail;  
    28. 
  
  
  
  
  28.     private String ipAddress;  
    29. 
  
  
  
  
  29.     private String hostName;  
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31.     public LoggingEventWrapper(LoggingEvent loggingEvent){  
    32. 
  
  
  
  
  32.         this.loggingEvent = loggingEvent;  
    33. 
  
  
  
  
  33.  
    34. 
  
  
  
  
  34.         //Format event and set detail field  
    35. 
  
  
  
  
  35.         EnhancedPatternLayout layout = new EnhancedPatternLayout();  
    36. 
  
  
  
  
  36.         layout.setConversionPattern(ENHANCED_PATTERN_LAYOUT);  
    37. 
  
  
  
  
  37.         this.detail = layout.format(this.loggingEvent);  
    38. 
  
  
  
  
  38.     }  
    39. 
  
  
  
  
  39.  
    40. 
  
  
  
  
  40.     public Long getTimeStamp() {  
    41. 
  
  
  
  
  41.         return this.loggingEvent.timeStamp;  
    42. 
  
  
  
  
  42.     }  
    43. 
  
  
  
  
  43.  
    44. 
  
  
  
  
  44.     public String getLevel() {  
    45. 
  
  
  
  
  45.         return this.loggingEvent.getLevel().toString();  
    46. 
  
  
  
  
  46.     }  
    47. 
  
  
  
  
  47.  
    48. 
  
  
  
  
  48.     public String getLogger() {  
    49. 
  
  
  
  
  49.         return this.loggingEvent.getLoggerName();  
    50. 
  
  
  
  
  50.     }  
    51. 
  
  
  
  
  51.  
    52. 
  
  
  
  
  52.     public String getMessage() {  
    53. 
  
  
  
  
  53.         return this.loggingEvent.getRenderedMessage();  
    54. 
  
  
  
  
  54.     }  
    55. 
  
  
  
  
  55.  
    56. 
  
  
  
  
  56.     public String getDetail() {  
    57. 
  
  
  
  
  57.         return this.detail;  
    58. 
  
  
  
  
  58.     }  
    59. 
  
  
  
  
  59.  
    60. 
  
  
  
  
  60.     public LoggingEvent getLoggingEvent() {  
    61. 
  
  
  
  
  61.         return loggingEvent;  
    62. 
  
  
  
  
  62.     }  
    63. 
  
  
  
  
  63.  
    64. 
  
  
  
  
  64.     public String getIpAddress() {  
    65. 
  
  
  
  
  65.         try {  
    66. 
  
  
  
  
  66.             return InetAddress.getLocalHost().getHostAddress();  
    67. 
  
  
  
  
  67.         } catch (UnknownHostException e) {  
    68. 
  
  
  
  
  68.             return "Could not determine IP";  
    69. 
  
  
  
  
  69.         }  
    70. 
  
  
  
  
  70.     }  
    71. 
  
  
  
  
  71.  
    72. 
  
  
  
  
  72.     public String getHostName() {  
    73. 
  
  
  
  
  73.         try {  
    74. 
  
  
  
  
  74.             return InetAddress.getLocalHost().getHostName();  
    75. 
  
  
  
  
  75.         } catch (UnknownHostException e) {  
    76. 
  
  
  
  
  76.             return "Could not determine Host Name";  
    77. 
  
  
  
  
  77.         }  
    78. 
  
  
  
  
  78.     }  
    79. 
  
  
  
  
  79. } 
    80.

#p#

消息侦听器

消息侦听器会对队列（或话题）进行“侦听”。一旦有新消息添加到了队列中，onMessage 方法就会得到调用。

 
 
 
 
    
  
  
  
  
  1. import javax.jms.JMSException;  
    2. 
  
  
  
  
  2. import javax.jms.Message;  
    3. 
  
  
  
  
  3. import javax.jms.MessageListener;  
    4. 
  
  
  
  
  4. import javax.jms.ObjectMessage;  
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. import org.apache.log4j.Logger;  
    7. 
  
  
  
  
  7. import org.springframework.beans.factory.annotation.Autowired;  
    8. 
  
  
  
  
  8. import org.springframework.stereotype.Component;  
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10. @Component 
    11. 
  
  
  
  
  11. public class LogQueueListener implements MessageListener  
    12. 
  
  
  
  
  12. {  
    13. 
  
  
  
  
  13.     public static Logger logger = Logger.getLogger(LogQueueListener.class);  
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15.     @Autowired 
    16. 
  
  
  
  
  16.     private ILoggingService loggingService;  
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18.     public void onMessage( final Message message )  
    19. 
  
  
  
  
  19.     {  
    20. 
  
  
  
  
  20.         if ( message instanceof ObjectMessage )  
    21. 
  
  
  
  
  21.         {  
    22. 
  
  
  
  
  22.             try{  
    23. 
  
  
  
  
  23.                 final LoggingEventWrapper loggingEventWrapper = (LoggingEventWrapper)((ObjectMessage) message).getObject();  
    24. 
  
  
  
  
  24.                 loggingService.saveLog(loggingEventWrapper);  
    25. 
  
  
  
  
  25.             }  
    26. 
  
  
  
  
  26.             catch (final JMSException e)  
    27. 
  
  
  
  
  27.             {  
    28. 
  
  
  
  
  28.                 logger.error(e.getMessage(), e);  
    29. 
  
  
  
  
  29.             } catch (Exception e) {  
    30. 
  
  
  
  
  30.             logger.error(e.getMessage(),e);  
    31. 
  
  
  
  
  31.         }  
    32. 
  
  
  
  
  32.         }  
    33. 
  
  
  
  
  33.     }  
    34. 
  
  
  
  
  34. } 
    35.

第23行: 检查从队列中拿到的对象是否是ObjectMessage的实例

第26行: 从消息中提取出LoggingEventWrapper对象

第27行: 调用服务方法将日志持久化

Spring配置

 
 
 
 
    
  
  
  
  
  1.   
    2. 
  
  
  
  
  2.   
    3. 
  
  
  
  
  3.   
    4. 
  
  
  
  
  4.   
    5. 
  
  
  
  
  5.   
    6. 
  
  
  
  
  6.   
    7. 
  
  
  
  
  7.   
    8. 
  
  
  
  
  8.   
    9. 
  
  
  
  
  9.   
    10. 
  
  
  
  
  10.   
    11. 
  
  
  
  
  11.      
    12. 
  
  
  
  
  12.      
    13. 
  
  
  
  
  13.      
    14. 
  
  
  
  
  14.   
    15. 
  
  
  
  
  15.   
    16. 
  
  
  
  
  16.   
    17. 
  
  
  
  
  17.      
    18. 
  
  
  
  
  18.   
    19. 
  
  
  
  
  19.   
    20. 
  
  
  
  
  20.   
    21. 
  
  
  
  
  21.      
    22. 
  
  
  
  
  22.   
    23. 
  
  
  
  
  23.  
    24.

第5到9行: 使用代理标签建立一个嵌入式消息代理。既然我用的是外部消息代理，所以我就不需要它了。

第12行: 给出你想要连接的队列的名字

第14行: 代理服务器的URI

第15到19行: 连接工厂的设置

第26到28行: 消息侦听器的设置，这里可以指定用于从队列中读取消息的并发现线程的个数

当然，上面的例子做不到让你能够拿来就用。你还需要包含所有的JMS依赖库并实现完成日志持久化任务的服务。但是，我希望本文能够为你提供一个相当不错的思路。

英文原文：Asynchronous logging using Log4j, ActiveMQ and Spring

译文链接：http://www.oschina.net/translate/asynchronous-logging-using-log4j-activemq-and-spring

名称栏目：使用Log4j、ActiveMQ和Spring实现异步日志
当前路径：http://www.shufengxianlan.com/qtweb/news31/212231.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

定制开发知识

同城分类信息

达州电信机房　　 　明安消防器材　　 　高端定制网站设计　　 　服务器租用　　 　成都微信二次开发　　 　软文推广　　 　成都托管服务器　　 　成都移动服务器托管　　 　成都SEO优化公司　　 　重庆企业网站建设　　 　云主机　　 　名片　　 　三台网站建设　　 　成都SEO公司　　 　重庆水土三线托管　　 　400电话申请　　 　企业微信定制　　 　温江服务器租用　　 　梦港之夜　　 　机柜租用