Как обернуть абстрактную иерархию классов в Java

Question

Я пишу библиотеку (wrapperLibrary), которая оборачивает все классы другой библиотеки (зависимой библиотеки), и я хочу, чтобы интеграторы использовали только классы из wrapperLibrary и НЕ из зависимой библиотеки - оборачивая ее полностью.

Я пытаюсь найти способ обернуть ниже абстрактную иерархию зависимой библиотеки:

public abstract class AOT{
    // Has few abstract methods and few default method implementation
}

public abstract class AMOT extends AOT {
    // Has a new abstract method and few overridden methods
}

public class COTM extends AMOT{
    // Implementation class of the abstract hierarchy
}

Оболочка должна выглядеть следующим образом:

public abstract class AOTWrapper{
    // Has the default method implementation of AOT
}

public abstract class AMOTWrapper extends AOTWrapper {
    // Has the default method implementation of AMOT
}

public class COTMWrapper extends AMOTWrapper{
    // Implementation class of the abstract hierarchy
}

Интеграторы или потребителиWrapperLibrary не должен иметь доступа к AOT / AMOT / COTM.

Также другие классы в зависимой библиотеке имеют AOT / AMOT / COTM в качестве параметров метода или возвращаемых типов.Таким образом, мы должны иметь возможность конвертировать AOTWrapper в AOT по мере необходимости.

Как мы можем этого достичь?

Answer 1

На самом деле это не будет обертка, которая обычно известна как определенный шаблон дизайна.Это требует, чтобы обертка и классы-обертки реализовывали один и тот же интерфейс, но вы фактически можете расширить последний дочерний конкретный класс библиотеки с помощью абстрактного родителя всех оболочек и переопределить все связанные методы, вы понимаете, что в этом случае все оболочки будут наследовать всеметоды libs, но вы можете переопределить ненужные с помощью исключения (например, подобный прием можно найти в некоторых методах java.util.AbstractList).Тогда, вероятно, хорошим решением будет использование фабрики, которая будет правильно создавать ваш экземпляр lib, помещать его в оболочку и предоставлять клиенту в любом контейнере класса, который он предпочтет.Было бы что-то вроде этого:

public class Main {

    public static void main(String[] args) {

        WrapperFactory wrapperFactory = new WrapperFactory();
        COTMWrapper cotmWrapper = wrapperFactory.getWrapper(COTMWrapper.class);
        cotmWrapper.doCOTMStuff();
        cotmWrapper.doSomethingElse();
        AMOTWrapper amotWrapper = cotmWrapper;
        amotWrapper.doAOTStuff();
        AOTWrapper aotWrapper = amotWrapper;
        aotWrapper.doAOTStuff();
        AOT likeNotWrapped = cotmWrapper;
        likeNotWrapped.doSomething();
    }

}
 class WrapperFactory {

    public <T extends AOTWrapper> T  getWrapper(Class<T> type){
        COTM cotm = new COTM();
        return type.cast(new COTMWrapper(cotm));
    }
}

abstract class AOT {
    // Has few abstract methods and few default method implementation
    public abstract void doSomething();

    public void doAOTStuff() {
        // AOT stuff is doing
    }

}

abstract class AMOT extends AOT {
    // Has a new abstract method and few overridden methods
    public abstract void doSomethingElse();

    public void doSomething() {
        // AMOT stuff is doing
    }

}

class COTM extends AMOT {
    // Implementation class of the abstract hierarchy

    public void doSomethingElse() {
        doCOTMStuff();
    }

    public void doCOTMStuff() {
        // COTM stuff is doing
    }
}

abstract class AOTWrapper extends COTM {

    private AOT container;

    public AOTWrapper(AOT container) {
        this.container = container;
    }

    @Override
    public void doAOTStuff() {
        container.doAOTStuff();
    }

     @Override
    public void doCOTMStuff() {
        throw new UnsupportedOperationException();
    }

    @Override
    public void doSomething() {
        throw new UnsupportedOperationException();
    }

    @Override
    public void doSomethingElse() {
        throw new UnsupportedOperationException();
    }
    // Has the default method implementation of AOT
}

abstract class AMOTWrapper extends AOTWrapper {

    private AMOT container;

    public AMOTWrapper(AMOT container) {
        super(container);
        this.container = container;
    }

    @Override
    public void doSomething() {
        container.doSomething();
    }

    // Has the default method implementation of AMOT
}

class COTMWrapper extends AMOTWrapper {

    private COTM container;

    public COTMWrapper(COTM container) {
        super(container);
        this.container = container;
    }

    @Override
    public void doSomethingElse() {
        container.doSomethingElse();
    }

    @Override
    public void doCOTMStuff() {
        container.doCOTMStuff();
        // COTM stuff is doing
    }
//     Implementation class of the abstract hierarchy
}

Другой подход:

public class Main {

    public static void main(String[] args) {

        COTMWrapper cotmWrapper = new COTMWrapper();
        AMOTInter amotWrapper = cotmWrapper;
        amotWrapper.doSomethingElse();
        AOT likeNotWrapped = cotmWrapper;
        likeNotWrapped.doSomething();
    }

}


abstract class AOT {
    // Has few abstract methods and few default method implementation
    public abstract void doSomething();

    public void doAOTStuff() {
        // AOT stuff is doing
    }

}

abstract class AMOT extends AOT {
    // Has a new abstract method and few overridden methods
    public abstract void doSomethingElse();

    public void doSomething() {
        // AMOT stuff is doing
    }

}

class COTM extends AMOT {
    // Implementation class of the abstract hierarchy

    public void doSomethingElse() {
        doCOTMStuff();
    }

    public void doCOTMStuff() {
        // COTM stuff is doing
    }
}

abstract class AOTWrapper extends AOT implements AOTInterface {

    @Override
    public void doAOTStuff() {
        super.doAOTStuff();
    }

    // Has the default method implementation of AOT
}

abstract class AMOTWrapper extends AMOT implements AMOTInter {

       @Override
    public void doSomething() {
        super.doSomething();
    }

    // Has the default method implementation of AMOT
}

class COTMWrapper extends COTM implements COTMInter {

    @Override
    public void doSomethingElse() {
        super.doSomethingElse();
    }

    @Override
    public void doCOTMStuff() {
        super.doCOTMStuff();
    }
//     Implementation class of the abstract hierarchy
}


interface AOTInterface {

    void doSomething();

    void doAOTStuff();
}

interface AMOTInter extends AOTInterface {

    void doSomethingElse();

    void doSomething();
}

interface COTMInter extends AMOTInter {

    void doSomethingElse();

    void doCOTMStuff();
}

Удачи!