compoundchannelstatusobserver.java.svn-base

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

package com.infobank.superchannel.observer.implementation;

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

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

/**
 * @author Xiaoguang Sun
 * @version 类说明: 复合式通道插件程序状态观察者
 */
public class CompoundChannelStatusObserver implements ChannelStatusObserver{
  private AtomicInteger averageTimeUsagePerMessage=new AtomicInteger(0);
  private AtomicInteger numberOfSentMessages=new AtomicInteger(0);
  private AtomicInteger numberOfSuccessfulMessages=new AtomicInteger(0);
  private AtomicInteger numberOfFailedMessages=new AtomicInteger(0);

  //所有绑定的观察者
  private List<ChannelStatusObserver> observers=new LinkedList<ChannelStatusObserver>();
  
  //监控界面用户与观察者对象的映射表
  private Hashtable<UUID,ChannelStatusObserver> observersMap=new Hashtable<UUID,ChannelStatusObserver>();
  
  /**
   *  绑定一个监控界面用户以及其观察者
   * @param token 用户访问令牌
   * @param observer 观察者
   * @return 操作是否成功
   */
  public boolean attachObserver(ControllerUserToken token,ChannelStatusObserver 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.averageTimeUsagePerMessage(averageTimeUsagePerMessage.get());
      observer.numberOfSentMessages(numberOfSentMessages.get());
      observer.numberOfFailedMessages(numberOfFailedMessages.get());
      observer.numberOfSuccessfulMessages(numberOfSuccessfulMessages.get());

      return true;
    }
  }

  /**
   * 解除一个监控界面用户以及其观察者的绑定
   * @param token 用户访问令牌
   * @return 操作是否成功
   */
  public boolean detachObserver(ControllerUserToken token){
    synchronized(observers){
      ChannelStatusObserver observer=observersMap.get(token.sid);
      if(observer==null)
        return false;
      observers.remove(observer);
      observersMap.remove(token.sid);
      return true;
    }
  }

  /**
   * 构造函数
   * @param observer 默认的观察者,不属于任何一个监控界面用户,用于完成系统自身日志
   */
  public CompoundChannelStatusObserver(ChannelStatusObserver observer){
    this.observers.add(observer);
  }

  /**
   * 构造函数
   * @param observers 默认的观察者,不属于任何一个监控界面用户,用于完成系统自身日志
   */
  public CompoundChannelStatusObserver(List<ChannelStatusObserver> observers){
    this.observers.addAll(observers);
  }
  
  /**
   *  设置此通道平均发送一条短信所需时间（单位毫秒：1000毫秒＝1秒）
   * @param number 累计发送失败条数
   */
  public void averageTimeUsagePerMessage(int seconds){
    synchronized(observers){
      for(ChannelStatusObserver observer:observers){
        observer.averageTimeUsagePerMessage(seconds);
      }
      averageTimeUsagePerMessage.set(seconds);
    }
  }

  /**
   * 设置此通道累计发送短信息数目
   * @param number 累计发送短信息条数
   */
  public void numberOfSentMessages(int number) {
    synchronized(observers){
      for(ChannelStatusObserver observer:observers){
        observer.numberOfSentMessages(number);
      }
      numberOfSentMessages.set(number);
    }
  }

  /**
   *  设置当前正在发送的短信息
   * @param message 当前正在发送的短信息
   */
  public void deliverMessage(TextMessage message) {
    synchronized(observers){
      for(ChannelStatusObserver observer:observers){
        observer.deliverMessage(message);
      }
    }
  }
  
  /**
   * 记载调试日志信息
   * @param log 调试日志信息
   */
  public void debug(String log) {
    synchronized(observers){
      for(ChannelStatusObserver observer:observers){
        observer.debug(log);
      }
    }
  }

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

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

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

  /**
   * 取得此通道平均发送一条短信所需时间（单位毫秒：1000毫秒＝1秒）
   * @param token 用户访问令牌
   * @return 平均发送一条短信所需时间
   */
  public int getAverageTimeUsagePerMessage(ControllerUserToken token){
    synchronized(observers){
      ChannelStatusObserver observer=observersMap.get(token.sid);
      if(observer!=null){
        return observer.getAverageTimeUsagePerMessage();
      }
      return 0;
    }
  }

  /**
   * 取得此通道累计发送短信息数目
   * @param token 用户访问令牌
   * @return 累计发送短信息条数
   */
  public int getNumberOfSentMessages(ControllerUserToken token){
    synchronized(observers){
      ChannelStatusObserver observer=observersMap.get(token.sid);
      if(observer!=null){
        return observer.getNumberOfSentMessages();
      }
      return 0;
    }
  }
  
  /**
   * 取得此通道累计发送短信息失败条数
   * @param token 用户访问令牌
   * @return 累计发送短信息失败条数
   */
  public int getNumberOfFailedMessages(ControllerUserToken token) {
    synchronized(observers){
      ChannelStatusObserver observer=observersMap.get(token.sid);
      if(observer!=null){
        return observer.getNumberOfFailedMessages();
      }
      return 0;
    }
  }

  /**
   * 取得此通道累计成功发送短信息条数
   * @param token 用户访问令牌
   * @return 累计成功发送短信息条数
   */
  public int getNumberOfSuccessfulMessages(ControllerUserToken token) {
    synchronized(observers){
      ChannelStatusObserver observer=observersMap.get(token.sid);
      if(observer!=null){
        return observer.getNumberOfSuccessfulMessages();
      }
      return 0;
    }
  }

  /**
   * 取得此通道的通用日志记录
   * @param token 用户访问令牌
   * @return 通用日志记录
   */
  public List<GenericLog> getGenericLog(ControllerUserToken token){
    synchronized(observers){
      ChannelStatusObserver observer=observersMap.get(token.sid);
      if(observer!=null){
        return observer.getGenericLog();
      }
      return null;
    }
  }
  
  /**
   * 取得此通道的通用日志记录
   * @param token 用户访问令牌
   * @return 通用日志记录
   */
  public List<TextMessageLog> getDeliverMessageLog(ControllerUserToken token){
    synchronized(observers){
      ChannelStatusObserver observer=observersMap.get(token.sid);
      if(observer!=null){
        return observer.getDeliverMessageLog();
      }
      return null;
    }
  }

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

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

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

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

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

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

  /**
   * 设置此通道累计发送短信息失败条数
   * @param number 累计发送短信息失败条数
   */
  public void numberOfFailedMessages(int number) {
    synchronized(observers){
      for(ChannelStatusObserver observer:observers){
        observer.numberOfFailedMessages(number);
      }
      numberOfFailedMessages.set(number);
    }
  }

  /**
   * 设置此通道累计成功发送短信息条数
   * @param number 累计成功发送短信息条数
   */
  public void numberOfSuccessfulMessages(int number) {
    synchronized(observers){
      for(ChannelStatusObserver observer:observers){
        observer.numberOfSuccessfulMessages(number);
      }
      numberOfSuccessfulMessages.set(number);
    }
  }

  /**
   *  空方法不要使用
   *  @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) {
  }
}