Limit the frequency of java SMS series

4. Clean up expired data

FrequencyFilter.java

/**
 *  On top of the above code ,  Add the following code 
 */
public class FrequencyFilter implements SmsFilter {
  private long cleanMapInterval;
  private Timer timer = new Timer("sms_frequency_filter_clear_data_thread");

  @Override
  public void init() {
    timer.schedule(new TimerTask() {
      @Override
      public void run() {
        cleanSendAddressMap();
      }
    }, cleanMapInterval, cleanMapInterval);
  }

  /**
   *  will sendAddressMap Delete all expired data in 
   */
  private void cleanSendAddressMap() {
    long currentTime = System.currentTimeMillis();
    long expireSendTime = currentTime - sendInterval;

    for(String key : sendAddressMap.keySet()) {
      Long sendTime = sendAddressMap.get(key);
      if(sendTime < expireSendTime) {
        sendAddressMap.remove(key, sendTime);
      }
    }
  }

  @Override
  public void destroy() {
    timer.cancel();
  }
}

This is not a complicated program. Start a timer and execute the cleanSendAddressMap method every cleanMapInterval millisecond to clean up stale data

The cleanSendAddressMap method first gets the current time and gets a time value based on the current time: all those who sent a message after this time cannot now send a message again

Of course, when the last line of sendAddressMap.replace (id, sendTime, currentTime) fails, it may not be replaced by another thread, or it may be deleted by the clean thread

FrequencyFilter.java

private boolean setSendTime(String id) {
  //  Omit the previous code 
  if(sendAddressMap.replace(id, sendTime, currentTime)) {
    return true;
  }
  return sendAddressMap.putIfAbsent(id, currentTime) == null;
}

here, if the substitution is successful, returns true.

If the replacement is not successful, then the other line may have been replaced first (the first case); It could also be deleted by the cleanup thread (in the second case); It can even be deleted by the cleanup thread before another thread inserts a new time value (in the third case).

At this point, the code to limit the sending time is complete. Of course, the program also has a little bug or "feature ":

If a customer with IP "192.168.0.1" requests to send a text message to cell phone number "12345678900" and then requests to send a text message to cell phone number "12345678900" on a machine with sendInterval "192.168.0.2" within sendInterval, the message will not be sent and the last time of cell phone number "12345678900" will be set to the current time.

5. Use instance

Here we provide an Server layer to show how the code from the previous article and this one can be put together :

SmsService.java

public class SmsService{
  private Sms sms;
  private List<SmsFilter> filters;
  private Properties template;

  //  Part of the code has been omitted 

  /**
   *  Send verification code 
   *
   * @param smsEntity  Basic data for sending SMS messages 
   * @return  If the submission is successful ,  return 0.  Otherwise, other values are returned .
   */
  public int sendCaptcha(SmsEntity smsEntity){
    for(SmsFilter filter : filters) {
      if(!filter.filter(smsEntity)){
        return 1;
      }
    }
    if(SmsEntity.REGISTER_TYPE.equals(smsEntity.getType())) {
      sendRegisterSms(smsEntity);
    }
    else{
      return 2;
    }
    return 0;
  }

  /**
   *  Send the registration verification code 
   *
   * @param smsEntity  Basic data for sending SMS messages 
   */
  private void sendRegisterSms(SmsEntity smsEntity) {
    sms.sendMessage(smsEntity.getMobile(),
        template.getProperty("register").replace("{captcha}", smsEntity.getCaptcha()));
  }

}

Then "inject" FrequencyFilter and AsyncSmsImpl from the previous article with set method.

The above is the entire content of this article, I hope to help you learn java programming.