在TypeScript中获取并设置(get and set in TypeScript)

 通常采用许多不同的选项/方法： 
 
 
 
 阻止就像您展示的API一样。 这是一个非常简单的API，并且仍然可以通过从多线程应用程序中调用API来实现并行性。 
 
 
 在异步操作中接收/注册处理程序 。 这有时与阻塞API一起提供（事实上，可以简单地通过生成后台线程然后在最后调用处理程序来实现阻塞API）。 
 
 
 返回Future或ListenableFuture对象，这使得界面更具惯用性（通过在返回类型位置返回数据），但表示最终结果，而不是立即可用的结果。 然后可以使用Future来阻止或阻止。 
 
 
 就个人而言，我的推荐是： 
 
interface EmployeeDatabase {
   interface StringWhereClause {
     ListQueryBuilder is(String value);
     ListQueryBuilder contains(String value);
     ListQueryBUilder matchesRegex(String regex);
   }

   interface IntWhereClause {
     ListQueryBuilder is(int value);
     ListQueryBuilder isInRange(int min, int max);
     ListQueryBuilder isGreaterThan(int value);
     ListQueryBUilder isLessThan(int value);
     ListQueryBuilder isGreaterThanOrEqualTo(int value);
     ListQueryBUilder isLessThanOrEqualTo(int value);
   }
   // ... matchers for other types of properties ...

   interface ListQueryBuilder {
      // Generic restrict methods
      StringWhereClause whereStringProperty(String propertyName);
      IntWhereClause whereIntProperty(String propertyName);
      // ...

      // Named restrict methods
      StringWhereClause whereName();
      StringWhereClause whereJobTitle();
      IntWhereClause whereEmployeeNumber();
      // ...

      ListQueryBuilder limit(long maximumSize);
      ListQueryBuilder offset(long index);

      ResultSet<Employee> fetch();
   }

   ListQueryBuilder list();
   ListenableFuture<Employee> getById(Key key);
   ListenableFuture<KeyOrError> add(Employee employee);
   ListenableFuture<Status> update(Key key, Employee employee);
   ListenableFuture<Status> delete(Key key);
}
 
 附： 
 
 interface ResultSet<T> {
    Iterable<T> asIterable();
    // ... other methods ...
 }

 interface KeyOrError {
    boolean isError();
    boolean isKey();
    Key getKey();
    Throwable getError();
 }

 interface Status {
   boolean isOk();
   boolean isError();
   Throwable getError();
   void verifyOk();
 }
 
 基本上，这个想法是插入数据库会返回一个Key对象（如果不成功则返回错误）。 此密钥可用于检索，删除或更新数据库中的条目。 这些操作（添加，更新，删除和getById）都有一个结果，在这种情况下使用ListenableFuture<T>而不是类型T ; 此future对象允许您阻止（通过在将来的对象上调用.get() ）或异步检索对象（通过注册在结果准备好时调用的回调）。 
 
 对于list-y操作，可以通过许多不同的方式对列表进行过滤，子选择，排序等。为了防止各种不同重载的组合爆炸，我们使用构建器模式允许应用这些不同的限制。多种组合。 简而言之，构建器接口提供了一种方法来处理零个或多个选项（排序，过滤器，限制等）以应用检索操作，然后调用fetch() ，这将导致执行列表查询并返回ResultSet 。 此操作返回ResultSet而不是ListenableFuture ，因为结果不是一次全部返回（例如，它们可能以流方式从数据库返回）; ResultSet实际上是一个与ListenableFuture具有类似行为的接口，但是对于项目列表（项目可能在不同时间准备好）。 为方便起见，有一种方法可以轻松地迭代ResultSet的内容（例如，通过向ResultSet提供Iterable适配器）; 但是，您可能还希望添加其他方法，以允许您在ResultSet上执行其他类型的异步处理; 例如，您可能需要ListenableFuture<T> reduce(T initialValue, ReduceFunction<T> reducer)来聚合结果集中的元素，并提供表示最终完成的对象。 

There are a number of different options / approaches that are often taken:
 
 
 
Blocking like the API you've shown. This is a very simple API to use, and parallelism can still be achieved by invoking the API from within a multithreaded application.
 
 
Receiving/registering handlers in async operations. This is sometimes provided in combination with the blocking API (and, in fact, may be implemented in terms of the blocking API simply by spawning a background thread and then then invoking the handler at the end).
 
 
Returning a Future or ListenableFuture object, which makes the interface more idiomatically Java-esque (by returning data in the return-type position), but representing the eventual result, not an immediately available result. The Future can then be used to block or non-block.
 
 
Personally, my recommendation here would be:
 
interface EmployeeDatabase {
   interface StringWhereClause {
     ListQueryBuilder is(String value);
     ListQueryBuilder contains(String value);
     ListQueryBUilder matchesRegex(String regex);
   }

   interface IntWhereClause {
     ListQueryBuilder is(int value);
     ListQueryBuilder isInRange(int min, int max);
     ListQueryBuilder isGreaterThan(int value);
     ListQueryBUilder isLessThan(int value);
     ListQueryBuilder isGreaterThanOrEqualTo(int value);
     ListQueryBUilder isLessThanOrEqualTo(int value);
   }
   // ... matchers for other types of properties ...

   interface ListQueryBuilder {
      // Generic restrict methods
      StringWhereClause whereStringProperty(String propertyName);
      IntWhereClause whereIntProperty(String propertyName);
      // ...

      // Named restrict methods
      StringWhereClause whereName();
      StringWhereClause whereJobTitle();
      IntWhereClause whereEmployeeNumber();
      // ...

      ListQueryBuilder limit(long maximumSize);
      ListQueryBuilder offset(long index);

      ResultSet<Employee> fetch();
   }

   ListQueryBuilder list();
   ListenableFuture<Employee> getById(Key key);
   ListenableFuture<KeyOrError> add(Employee employee);
   ListenableFuture<Status> update(Key key, Employee employee);
   ListenableFuture<Status> delete(Key key);
}
 
With:
 
 interface ResultSet<T> {
    Iterable<T> asIterable();
    // ... other methods ...
 }

 interface KeyOrError {
    boolean isError();
    boolean isKey();
    Key getKey();
    Throwable getError();
 }

 interface Status {
   boolean isOk();
   boolean isError();
   Throwable getError();
   void verifyOk();
 }
 
Basically, the idea is that insertion into the database returns a Key object (or an error if unsuccessful). This key can be used to retrieve, delete, or update the entry in the database. These operations (add, update, delete, and getById) all have a single result, in which case a ListenableFuture<T> is used instead of type T; this future object allows you to block (by calling .get() on the future object) or to retrieve the object asynchronously (by registering a callback to be invoked when the result is ready).
 
For list-y operations, there are many different ways that a list can be filtered, subselected, sorted, etc. In order to prevent a combinatoric explosion of various different overloads, we use the builder pattern to allow these different restrictions to be applied in multiple combinations. In short, the builder interface provides a way to tack on zero or more options (sorts, filters, limits, etc.) to apply the retrieval operation, before calling fetch() which causes the list query to be executed and returns a ResultSet. This operation returns a ResultSet rather than a ListenableFuture, because the results are not all returned at once (e.g. they may come back from the data base in streaming fashion); the ResultSet is effectively an interface with a similar behavior to a ListenableFuture but for lists of items (where items may be ready at different times). For convenience, it is important to have a way to easily iterate over the contents of the ResultSet (e.g. by providing an Iterable adapter to the ResultSet); however, you will probably also want to add other methods that allow you to perform other types of asynchronous processing on the ResultSet; for example, you might want a ListenableFuture<T> reduce(T initialValue, ReduceFunction<T> reducer) to aggregate the elements in the result set and provide a future object representing the eventual completion of that.