Разработка интерфейса службы для обеспечения как синхронной, так и асинхронной реализации.

Question

Не уверен, как точно описать это, но я думаю, что я свел воедино то, что я хочу сделать в названии.Чтобы уточнить, я ищу шаблон проектирования, который позволил бы мне реализовать службу, которая в одной ситуации возвращала бы результат вызова синхронно, а в другом случае возвращала сведения о том, как выполнить вызов асинхронно (скажем, заданиеID).

Может быть, просто определив проблему следующим образом, ясно, что то, что я пытаюсь сделать, нарушает идею разработки контракта интерфейса.Может быть направлен в совершенно неверном направлении.

Возможно, я думал о чем-то вроде этого:

public class Data {
  private int id;
  /* getter/setter */
}

public class QueuedData extends Data {
  private int jobId;
  /* getter/setter */
}

public interface MyService {
  public Data fetchData(int id);
}

public class SyncedMyService implements MyService {
  private SyncDao syncDao;
  public Data fetchData(int id) {
    return syncDao.getData(id);
  }
}

public class QueuedMyService implements MyService {
  private JobQueue queue;
  public QueuedData fetchData(int id) {
    int jobId = queue.startGetData(id);
    QueuedData queuedData = createQueuedDate(jobId);
    return queuedData;
  }
}

Это разумный способ выполнить эту задачу?Спасибо за любой совет.(вероятно, есть книга по шаблону дизайна, которую я должен читать)

Answer 1

Это прекрасное использование Наследования.Ваши SynchedMyService и QueuedMyService следуют контракту / правилам, обозначенным MyService.

Также, с помощью метода fetchData (), возвращающего тип Data, вы позволяете себе возможность строить поверх объекта Data и возвращать большесложные объекты (например, QueuedData)

Если вы не хотите иметь логику того, какой из классов создается каждый раз.Посмотрите на шаблон Factory Design , чтобы помочь вам в дальнейшем расширении приложения

Answer 2

Это очень похоже на шаблон Future, используемый в пакете java.util.concurrent.Future представляет результат, который будет доступен в будущем после завершения вычисления в отдельном потоке.Если вычисление уже завершено до того, как требуется результат, возвращается вычисленное значение.Иначе вызов для получения блоков результата до завершения вычислений.

Так что я думаю, что этот шаблон - правильный способ иметь как синхронные, так и асинхронные службы.

Вот как вы можетереализовать решение, используя Future:

public class Data {
  private int id;
  private final String name;

  Data(String name) { this.name = name; }
  public String getName() { return name; }  
}

public class FutureData extends Data {
  private int id;
  private final Future<String> nameFuture;

  FutureData(Future<String> nameFuture) { this.nameFuture = nameFuture; }
  @Override public String getName() { return nameFuture.get(); }  
}

public interface MyService {
  public Data fetchData(int id);
}

public class SyncMyService implements MyService {
  private SyncDao syncDao;
  public Data fetchData(int id) {
    return syncDao.getData(id);
  }
}

public class AsyncMyService implements MyService {
  private static final ExecutorService executor = 
    Executors.newFixedThreadPool(10);

  public FutureData fetchData(final int id) {
    Future<String> future = executor.submit(new Callable<String>() {
      public String call() {
        String name;
        //some long computation that computes the name using the id given
        return name;
      }
    });
    FutureData futureData = new FutureData(future);
    return futureData;
  }
}

Для Кварца просто замените ExecutorService на JobQueue и используйте эквивалент Кварца Future.