Alternative a java.lang.reflect.Proxy per la creazione di proxy di classi astratte (piuttosto che interfacce)

Question 1

[ java.lang.reflect.] Proxyfornisce metodi statici per la creazione di classi e istanze proxy dinamiche ed è anche la superclasse di tutte le classi proxy dinamiche create da questi metodi.

Il newProxyMethodmetodo (responsabile della generazione dei proxy dinamici) ha la seguente firma:

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
                             throws IllegalArgumentException

Sfortunatamente, questo impedisce di generare un proxy dinamico che estende una specifica classe astratta (piuttosto che implementare interfacce specifiche). Questo ha senso, considerando che java.lang.reflect.Proxyè "la superclasse di tutti i proxy dinamici", impedendo così a un'altra classe di essere la superclasse.

Pertanto, esistono alternative a java.lang.reflect.Proxyche possono generare proxy dinamici che ereditano da una specifica classe astratta, reindirizzando tutte le chiamate ai metodi astratti al gestore di invocazione?

Ad esempio, supponiamo di avere una classe astratta Dog:

public abstract class Dog {

    public void bark() {
        System.out.println("Woof!");
    }

    public abstract void fetch();

}

C'è una classe che mi permette di fare quanto segue?

Dog dog = SomeOtherProxy.newProxyInstance(classLoader, Dog.class, h);

dog.fetch(); // Will be handled by the invocation handler
dog.bark();  // Will NOT be handled by the invocation handler

Question 2

Può essere fatto usando Javassist (vedi ProxyFactory) o CGLIB .

L'esempio di Adam che utilizza Javassist:

Io (Adam Paynter) ho scritto questo codice usando Javassist:

ProxyFactory factory = new ProxyFactory();
factory.setSuperclass(Dog.class);
factory.setFilter(
    new MethodFilter() {
        @Override
        public boolean isHandled(Method method) {
            return Modifier.isAbstract(method.getModifiers());
        }
    }
);

MethodHandler handler = new MethodHandler() {
    @Override
    public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable {
        System.out.println("Handling " + thisMethod + " via the method handler");
        return null;
    }
};

Dog dog = (Dog) factory.create(new Class<?>[0], new Object[0], handler);
dog.bark();
dog.fetch();

Che produce questo output:

Trama!
Gestire il public abstract void mock.Dog.fetch () tramite il gestore del metodo

Question 3

Quello che puoi fare in questo caso è avere un gestore proxy che reindirizzerà le chiamate ai metodi esistenti della tua classe astratta.

Ovviamente dovrai codificarlo, tuttavia è abbastanza semplice. Per creare il tuo proxy, dovrai dargli un InvocationHandler. Dovrai quindi solo controllare il tipo di metodo nel invoke(..)metodo del tuo gestore di invocazioni. Ma attenzione: dovrai confrontare il tipo di metodo con l'oggetto sottostante associato al tuo gestore e non con il tipo dichiarato della tua classe astratta.

Se prendo come esempio la classe del tuo cane, il metodo invoke del tuo gestore di invocazioni potrebbe assomigliare a questo (con una sottoclasse di cani associata esistente chiamata .. beh ... dog)

public void invoke(Object proxy, Method method, Object[] args) {
    if(!Modifier.isAbstract(method.getModifiers())) {
        method.invoke(dog, args); // with the correct exception handling
    } else {
        // what can we do with abstract methods ?
    }
}

Tuttavia, c'è qualcosa che mi fa riflettere: ho parlato di un dogoggetto. Tuttavia, poiché la classe Dog è astratta, non puoi creare istanze, quindi hai sottoclassi esistenti. Inoltre, come rivela una rigorosa ispezione del codice sorgente del Proxy, potresti scoprire (su Proxy.java:362) che non è possibile creare un Proxy per un oggetto Class che non rappresenta un'interfaccia).

Quindi, a parte la realtà , quello che vuoi fare è perfettamente possibile.