Question

我希望在java-8中实现某种类似jQuery的对象，作为容器，可以包含一个或更多对象。

在Jquery中你可以这样做：$('.bla').addClass('ble');。不知道这是否应用于一个或多个对象，但该方法只有一个。

我也很惊讶地发现java-8你可以CompletableFuture.allOf(CompletableFuture<?>... cfs).join()。

无论你传递了多少个对象，你都会得到一个CompletableFuture<Void>，你可以调用任何一个将作用于所有内部对象的实例方法。

尽管如此，its实施对于我的情况来说肯定太复杂了。

我的基地interface看起来像这样

public interface Response< T extends DataTransferObject< ? > > {

    // instance methods

    public boolean isSuccess();
    public String getMessage();

    public default boolean isUndefined() {
        return this.equals(ActionResponse.UNDEF);
    }

    @SuppressWarnings("unchecked")
    public default Response< T > mergeWith(final Response< ? super T > response) {
        return Response.allOf(this, response);
    }

    public default boolean isMultiResponse() {
        return this instanceof ActionResponse.ActionMultiResponse;
    }
    /* -------------------------------------------------------------------------------------------------------------- */

    // factory methods

    @SuppressWarnings("unchecked")
    public static < U extends DataTransferObject< ? > > Response< U > allOf(final Response< ? super U >... responses) {

        Objects.requireNonNull(responses);

        if (responses.length == 0) return ( Response< U > ) ActionResponse.UNDEF;

        return new ActionResponse.ActionMultiResponse< U >(responses);
    }

    public static < U extends DataTransferObject< ? > > Response< U > from(final boolean success, final String message) {
        return new ActionResponse<>(success, message);
    }
}

package-protected class看起来像这样（不完整）：

/* Package-protected implementation for the Response< T > type */
class ActionResponse< T extends DataTransferObject< ? > > implements Response< T > {

    static final Response< ? extends DataTransferObject< ? > > UNDEF = new ActionResponse<>();

    private final boolean success;
    private final String message;

    private ActionResponse() {
        this.success = false;
        this.message = null;
    }

    ActionResponse(final boolean success, final String message) {
        this.success = success;
        this.message = message;
    }

    // getters

    static final class ActionMultiResponse< T extends DataTransferObject< ? > > extends ActionResponse< T > {

        private final String[] messages;

        ActionMultiResponse(final boolean success, final String message) {
            super(success, message);
            this.messages = null;
        }

        ActionMultiResponse(final Response< ? super T >... responses) {

            /* must check if any of the following is already a MultiActionResponse */
            // TODO

            this.messages = new String[responses.length];

            for (int i = 0; i < responses.length; i++) {
                this.messages[i] = responses[i].getMessage();
            }
        }

        @Override
        public String getMessage() {

            if (this.messages == null) return super.getMessage();

            return Arrays.toString(this.messages); // dummy string merger
        }
    }
}

此package之外的类只能访问interface，因为我希望隐藏实现细节，这一点很重要。没有人应该关心给定的实例是single还是multi。

构建Response< T >的唯一方法是通过提供的工厂方法或实例方法Response::mergeWith。 E.g：

Response< SpotDTO > response = Response.from(true, "message");

如果想知道这确实是pattern并且pattern是否有名字？如果是这样，我应该遵循什么准则？

实施此concept的更好方法是什么？

例如，我不认为ActionResponse为String保留message类型而ActionMultiResponse拥有String[]。

我仍然不希望只有一个带有String数组的对象，如果只需要一个对象，则放置它。

Java中的类似JQuery的单/多容器类

0 个答案: