compoundmessagelauncherstatusobserver.java

监控整个SP系统的SMS信息通道的发送情况并且生成日志。 支持权限判断。

package com.infobank.superchannel.observer.implementation;

import java.util.Hashtable;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

import com.infobank.superchannel.observer.ChannelStatusObserver;
import com.infobank.superchannel.observer.DatabaseCacheStatusObserver;
import com.infobank.superchannel.observer.MessageLauncherStatusObserver;
import com.infobank.superchannel.pojo.ControllerUserToken;
import com.infobank.superchannel.pojo.GenericLog;
import com.infobank.superchannel.pojo.MessageBucketLog;
import com.infobank.superchannel.pojo.TextMessage;
import com.infobank.superchannel.pojo.TextMessageLog;

/**
 * @author Xiaoguang Sun
 * @version 类说明: 复合式MessageLauncher服务器状态观察者
 */
public class CompoundMessageLauncherStatusObserver implements
    MessageLauncherStatusObserver {
  private AtomicInteger massMessageQueueSize=new AtomicInteger(0);
  private AtomicInteger generalMessageQueueSize=new AtomicInteger(0);

  private List<MessageLauncherStatusObserver> observers=new LinkedList<MessageLauncherStatusObserver>();
  private Hashtable<UUID,MessageLauncherStatusObserver> observersMap=new Hashtable<UUID,MessageLauncherStatusObserver>();
  
  /**
   * 构造函数
   * @param observer 默认的观察者,不属于任何一个监控界面用户,用于完成系统自身日志
   */
  public CompoundMessageLauncherStatusObserver(MessageLauncherStatusObserver observer){
    this.observers.add(observer);
  }

  /**
   * 构造函数
   * @param observers 默认的观察者,不属于任何一个监控界面用户,用于完成系统自身日志
   */
  public CompoundMessageLauncherStatusObserver(List<MessageLauncherStatusObserver> observers){
    this.observers.addAll(observers);
  }
  
  /**
   *  绑定一个监控界面用户以及其观察者
   * @param token 用户访问令牌
   * @param observer 观察者
   * @return 操作是否成功
   */
  public boolean attachObserver(ControllerUserToken token,MessageLauncherStatusObserver observer){
    synchronized(observers){
      if(observers.contains(observer))
        return false;
      if(observersMap.contains(token.sid))
        return false;
      observers.add(observer);
      observersMap.put(token.sid, observer);
      observer.massMessageQueueSize(massMessageQueueSize.get());
      observer.generalMessageQueueSize(generalMessageQueueSize.get());
      return true;
    }
  }
  
  /**
   * 解除一个监控界面用户以及其观察者的绑定
   * @param token 用户访问令牌
   * @return 操作是否成功
   */
  public boolean detachObserver(ControllerUserToken token){
    synchronized(observers){
      MessageLauncherStatusObserver observer=observersMap.get(token.sid);
      if(observer==null)
        return false;
      observers.remove(observer);
      observersMap.remove(token.sid);
      return true;
    }
  }

  /**
   *  消息状态变更
   * @param message 状态变更的消息
   */
  public void changeMessageStatus(TextMessage message) {
    synchronized(observers){
      for(MessageLauncherStatusObserver observer:observers){
        observer.changeMessageStatus(message);
      }
    }
  }

  /**
   *  设置普通信息队列尺寸
   * @param size 普通信息队列尺寸
   */
  public void generalMessageQueueSize(int size) {
    synchronized(observers){
      for(MessageLauncherStatusObserver observer:observers){
        observer.generalMessageQueueSize(size);
      }
      generalMessageQueueSize.set(size);
    }
  }

  /**
   *  设置批量信息队列尺寸
   * @param size 批量信息队列尺寸
   */
  public void massMessageQueueSize(int size) {
    synchronized(observers){
      for(MessageLauncherStatusObserver observer:observers){
        observer.massMessageQueueSize(size);
      }
      massMessageQueueSize.set(size);
    }
  }

  /**
   *  新的普通消息组到来
   * @param bucket 新普通消息组
   */
  public void newGeneralMessageBucket(Queue<TextMessage> bucket) {
    synchronized(observers){
      for(MessageLauncherStatusObserver observer:observers){
        observer.newGeneralMessageBucket(bucket);
      }
    }
  }

  /**
   *  新的批量消息组到来
   * @param bucket 新批量消息组
   */
  public void newMassMessageBucket(Queue<TextMessage> bucket) {
    synchronized(observers){
      for(MessageLauncherStatusObserver observer:observers){
        observer.newMassMessageBucket(bucket);
      }
    }
  }

  /**
   *  记载调试日志信息
   * @param log 调试日志信息
   */
  public void debug(String log) {
    synchronized(observers){
      for(MessageLauncherStatusObserver observer:observers){
        observer.debug(log);
      }
    }
  }

  /**
   *  记载错误信息
   * @param log 错误信息
   */
  public void error(String log) {
    synchronized(observers){
      for(MessageLauncherStatusObserver observer:observers){
        observer.error(log);
      }
    }
  }

  /**
   *  记载致命错误信息
   * @param log 致命错误信息
   */
  public void fatal(String log) {
    synchronized(observers){
      for(MessageLauncherStatusObserver observer:observers){
        observer.fatal(log);
      }
    }
  }

  /**
   *  记载一般日志信息
   * @param log 一般日志信息
   */
  public void info(String log) {
    synchronized(observers){
      for(MessageLauncherStatusObserver observer:observers){
        observer.info(log);
      }
    }
  }

  /**
   * 获取自上次调用此方法后产生的所有消息状态更新日志
   * @param token 用户访问令牌
   * @return 自上次调用此方法后产生的所有消息状态更新日志
   */
  public List<TextMessageLog> getChangeMessageStatusLog(ControllerUserToken token) {
    synchronized(observers){
      MessageLauncherStatusObserver observer=observersMap.get(token.sid);
      if(observer!=null)
        return observer.getChangeMessageStatusLog();
      return null;
    }
  }

  /**
   * 获取当前普通消息队列尺寸
   * @param token 用户访问令牌
   * @return 当前普通消息队列尺寸
   */
  public int getGeneralMessageQueueSize(ControllerUserToken token) {
    synchronized(observers){
      MessageLauncherStatusObserver observer=observersMap.get(token.sid);
      if(observer!=null)
        return observer.getGeneralMessageQueueSize();
      return 0;
    }
  }

  /**
   * 获取当前批量消息队列尺寸
   * @param token 用户访问令牌
   * @return 当前批量消息队列尺寸
   */
  public int getMassMessageQueueSize(ControllerUserToken token) {
    synchronized(observers){
      MessageLauncherStatusObserver observer=observersMap.get(token.sid);
      if(observer!=null)
        return observer.getMassMessageQueueSize();
      return 0;
    }
  }

  /**
   * 获取自上次调用此方法后产生的所有新普通消息组日志
   * @param token 用户访问令牌
   * @return 自上次调用此方法后产生的所有新普通消息组日志
   */
  public List<MessageBucketLog> getNewGeneralMessageBucketLog(ControllerUserToken token) {
    synchronized(observers){
      MessageLauncherStatusObserver observer=observersMap.get(token.sid);
      if(observer!=null)
        return observer.getNewGeneralMessageBucketLog();
      return null;
    }
  }

  /**
   * 获取自上次调用此方法后产生的所有新批量消息组日志
   * @param token 用户访问令牌
   * @return 自上次调用此方法后产生的所有新批量消息组日志
   */
  public List<MessageBucketLog> getNewMassMessageBucketLog(ControllerUserToken token) {
    synchronized(observers){
      MessageLauncherStatusObserver observer=observersMap.get(token.sid);
      if(observer!=null)
        return observer.getNewMassMessageBucketLog();
      return null;
    }
  }

  /**
   *  取得自上次调用此方发以后新增的所有日志信息
   * @return 自上次调用此方发以后新增的所有日志信息
   */
  public List<GenericLog> getGenericLog(ControllerUserToken token) {
    synchronized(observers){
      MessageLauncherStatusObserver observer=observersMap.get(token.sid);
      if(observer!=null)
        return observer.getGenericLog();
      return null;
    }
  }

  /**
   *  空方法不要使用
   *  @deprecated
   */
  public List<TextMessageLog> getChangeMessageStatusLog() {
    // TODO Auto-generated method stub
    return null;
  }

  /**
   *  空方法不要使用
   *  @deprecated
   */
  public int getGeneralMessageQueueSize() {
    // TODO Auto-generated method stub
    return 0;
  }

  /**
   *  空方法不要使用
   *  @deprecated
   */
  public int getMassMessageQueueSize() {
    // TODO Auto-generated method stub
    return 0;
  }

  /**
   *  空方法不要使用
   *  @deprecated
   */
  public List<MessageBucketLog> getNewGeneralMessageBucketLog() {
    // TODO Auto-generated method stub
    return null;
  }

  /**
   *  空方法不要使用
   *  @deprecated
   */
  public List<MessageBucketLog> getNewMassMessageBucketLog() {
    // TODO Auto-generated method stub
    return null;
  }

  /**
   *  空方法不要使用
   *  @deprecated
   */
  public List<GenericLog> getGenericLog() {
    // TODO Auto-generated method stub
    return null;
  }

  /**
   *  空方法不要使用
   *  @deprecated
   */
  public void warn(String log) {
  }

  /**
   *  空方法不要使用
   *  @deprecated
   */
  public void debug(Exception ex) {
  }

  /**
   *  空方法不要使用
   *  @deprecated
   */
  public void error(Exception ex) {
  }

  /**
   *  空方法不要使用
   *  @deprecated
   */
  public void fatal(Exception ex) {
  }

  /**
   *  空方法不要使用
   *  @deprecated
   */
  public void info(Exception ex) {
  }

  /**
   *  空方法不要使用
   *  @deprecated
   */
  public void warn(Exception ex) {
  }
}