设计概述：

1. 增量请求并不是只对增加的数据进行更新，还要对以前删除的数据进行更新。所以应该返回两个List，一个是新添加数据的List，一个是已删除数据的List。
2. 在实际工作中，在数据库层面，对于新增加数据和删除数据有两种常见的处理方式：
   • 在一张表里进行操作：利用某个字段标记这条数据当前是否有效，例如当删除这条数据，把这个字段设为99，而新增一条数据，此字段为值1。在这种方式下，对于新增加数据和新删除数据只能通过modefie_time来搜索，而非create_time。
   • 在两张表里进行操作：用一张表储存现有数据，一张表储存已删除数据。这样检索新增加数据和新删除数据分别在两张表中进行。我们可以通过create_time检索。
3. 缓存的粒度为1分钟，我们每次访问数据库的时间范围也是这一分钟，在这次访问中数据库返回的关于新添加数据的List与已删除数据的List不会出现数据重叠。但是在前一分钟的List和后一分钟的List之间可能出现数据重叠，如前一分钟添加的数据，下一分钟可能就被删除掉了，或者前一分钟添加的数据，这一分钟又被恢复了。所以我们在从缓存取出每一分钟的数据后，需要对数据进行整合操作。

/**增量包装类*/
public class IncrementDO<T> implements Serializable {

    private static final long serialVersionUID = -6615881328594646517L;

    /** 删除数据列表 **/
    private final List<T> deletedList;

    /** 增加数据列表 **/
    private final List<T> addedList;

    /** 时间戳 **/
    private final Long timestamp;

    public IncrementDO(List<T> deletedList, List<T> addedList, Long timestamp) {
        super();
        this.deletedList = deletedList;
        this.addedList = addedList;
        this.timestamp = timestamp;
    }
    public List<T> getDeletedList() {
        return deletedList;
    }
    public List<T> getAddedList() {
        return addedList;
    }
    public Long getTimestamp() {
        return timestamp;
    }
    @Override
    public String toString() {
        return "IncrementDO[deletedList=" + deletedList.size() + ", addedList=" + 
               addedList.size() + ", timestamp=" + timestamp + "]";
    }
}

public interface ConfigService {
     /**用户拥有在timeStamp之前的正确数据*/
     public IncrementDO<Long> getIncrementUserIds(long timeStamp) 
          throws ServiceException;
}     

public class ConfigServiceImpl implements ConfigService{
     UserManager userManager;
     public IncrementDO<Long> getIncrementUserIds(long timeStamp) 
          throws ServiceException{
          if(timeStamp < 0) {
               throw new ServiceException("timestamp is wrong");
          }
          try{
               return userManager.getIncrementUserIds(timeStamp);
          } catch (ManagerException e) {
               throw new ServiceException(e);
           }
     }
}

/**ibatis sql，用STATUS=1表示数据有效，STATUS=99表示数据已删除*/
<select id="getAddedUserIds" resultClass="java.lang.Long"
     parameterClass="java.util.Map">
     <![CDATA[
     SELECT USER_ID
     FROM user
     WHERE GMT_MODIFIED  >= #begin# and 
          GMT_MODIFIED <= #end# and STATUS = 1
      ]]>
</select>

<select id="getDeletededUserIds" resultClass="java.lang.Long"
     parameterClass="java.util.Map">
     .....
</select>

public interface UserManager{
     /**用户拥有在timeStamp之前的正确数据*/
     public IncrementDO<Long> getIncrementUserIds(long timeStamp) 
          throws ManagerException;
}     
public class UserManagerImpl implement UserManager {
     UserDAO userDAO;LocalCache localCache;
          /**用户拥有在timeStamp之前的正确数据*/
     public IncrementDO<Long> getIncrementUserIds(long timeStamp) 
          throws ManagerException {
          long ts = this.userDAO.getDBTimestamp(); // db 当前时间戳

          Calendar reqTime = Calendar.getInstance();         // 请求时间
          reqTime.setTime(new Date(timestamp));
          reqTime.set(reqTime.get(Calendar.YEAR), reqTime.get(Calendar.MONTH),  
                reqTime.get(Calendar.DAY_OF_MONTH),
                reqTime.get(Calendar.HOUR_OF_DAY),                 
                reqTime.get(Calendar.MINUTE),
                 0); // 秒清零
   
          Calendar curTime = Calendar.getInstance();     // db当前时间
          curTime.setTime(new Date(ts));
          curTime.set(curTime.get(Calendar.YEAR), curTime.get(Calendar.MONTH), 
               curTime.get(Calendar.DAY_OF_MONTH),
         curTime.get(Calendar.HOUR_OF_DAY), 
               curTime.get(Calendar.MINUTE), 
               0); // 秒清零
          
          long diffTime = curTime.getTimeInMillis() - reqTime.getTimeInMillis();
          if (diffTime < 0) {
               throw new ManagerException("timestamp is wrong");
          }

          IncrementDO<Long> tmp;        
          Set<Long> add = new HashSet<Long>();
          Set<Long> del = new HashSet<Long>();
          long minCount = diffTime / (60 * 1000); // 相差分钟数          

          for (long i=0; i< minCount; i++) {     // 遍历相差的分钟数
        tmp = null;
        tmp = this.getSignalMinitIncreamentUserIds(
                        reqTime.getTimeInMillis(), reqTime.getTimeInMillis() + 60000);
        if (tmp != null) {
              del.removeAll(tmp.getAddedList());
              add.addAll(tmp.getAddedList());
              add.removeAll(tmp.getDeletedList());
              del.addAll(tmp.getDeletedList());
        }
        reqTime.add(Calendar.MINUTE, 1);
          }
          IncrementDO<Long> result = new IncrementDO<Long>(
               new ArrayList<Long>(del), 
               new ArrayList<Long>(add), 
               curTime.getTimeInMillis() );
          return result;
     }
     private IncrementDO<Long> getSignalMinitIncreamentUserIds(
         long beginTimestamp, long endTimestamp) throws DAOException {
           IncrementDO<Long> result = (IncrementDO<Long>)  
                localCache.get(Namespace.INC_USERIDS+"_"
                +beginTimestamp + "_" + endTimestamp);
           if (result == null) {
                 List<Long> addList = this.userDAO.getAddedUserIds(
                      beginTimestamp, endTimestamp);
                 List<Long> deletedList = this.userDAO.getDeletedUserIds(
                      beginTimestamp, endTimestamp);
                 result = new IncrementDO<Long>(deletedList, addList, endTimestamp);
                 localCache.put(Namespace.INC_USERIDS+"_"
                      +beginTimestamp + "_" + endTimestamp, result);
           }
           return result;
     }
}