Programmazione orientata agli aspetti in Java SENZA AspectJ?

Question

ok questa domanda non è mai stata richiesta prima sul web, ecco qui: Sto imparando Java (livello principiante-intermedio) e ho deciso di andare avanti al programma di classe provando la programmazione orientata all'aspetto.

Ora questa cosa ha supposto per essere facile da imparare (almeno questo è il consenso web) tanto che gli "aspetti" si dice che siano un po 'le versioni delle classi standard modificato, quindi la mia domanda è: se aspetti sono fondamentalmente classi,

PERCHÉ dobbiamo installare AspectJ per fare AOP in Java?

in quanto aggiunge un ulteriore livello di complessità rendendo il concetto ancora più difficile da comprendere.

Quello che voglio è essere in grado di scrivere un aspetto senza utilizzare AspectJ (o qualsiasi altro componente aggiuntivo), in altre parole voglio fare AOP utilizzando solo Java & BASIC le sue classi java standard. è possibile e se sì, come devo scrivere queste lezioni?

Answer 1

Java non supporta AOP out of the box e non lo consiglierei di implementarlo da solo perché sarà necessario modificare i file di classe mentre vengono caricati. In alternativa, è anche possibile modificare i file di classe rispettati, ma ciò sarebbe ancora più complicato.

AspectJ utilizza un Java Agent per configurare il caricatore di classi di tessitura (che modifica i file di classe al caricamento), ma è anche possibile utilizzare manualmente il proprio caricatore di classi. Se le classi, che si desidera modificare, implementano un'interfaccia, è possibile utilizzare Java Proxies per AOP. Altrimenti dovrai usare una libreria esterna come CGLib, Javassist o ASM (o imparare come funziona il bytecode Java).

Alcuni ulteriori informazioni:

• Come usare Java Proxy: http://java.dzone.com/articles/power-proxies-java
• biblioteche generazione Bytecode: Are there alternatives to cglib?
• bytecode Java: https://en.wikipedia.org/wiki/Java_bytecode

esempio Proxy:

import java.lang.reflect.InvocationHandler; 
import java.lang.reflect.Method; 
import java.lang.reflect.Proxy; 

public class ProxyExample { 

    public static void main(String[] args) { 
     AnInterface obj = new AClass(); 
     AnInterface proxyObj = createProxy(obj); 
     System.out.println(obj.aMethod()); 
     System.out.println(proxyObj.aMethod()); 
    } 

    private static AnInterface createProxy(AnInterface obj) { 
     return (AnInterface) Proxy.newProxyInstance(ProxyExample.class.getClassLoader(), 
       new Class<?>[] {AnInterface.class}, 
       new InvocationHandler() { 
      @Override 
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
       return "proxy: " + method.invoke(obj); 
      } 
     }); 
    } 

    static interface AnInterface { 
     public String aMethod(); 
    } 

    static class AClass implements AnInterface { 
     @Override 
     public String aMethod() { 
      return "string"; 
     } 
    } 

} 

Answer 2

AspectJ è un, per mancanza di una parola migliore, "Aspetto puro". Il criterio è che può essere ampiamente utilizzato in ogni circostanza. Qualsiasi aspetto, su qualsiasi classe, in qualsiasi momento.

Detto questo, la tecnica dell'aspetto delle chiamate al metodo di intercettare e avvolgere, ha trovato la sua strada in modo pervasivo in Java. Tuttavia, questa tendenza verso la specializzazione del concetto di aspetto generico per scopi specifici.

Un "aspetto" molto precoce è stato fatto con le prime funzionalità EJB. Ciò ha comportato l'uso di file XML per aumentare le classi e le interfacce, in modo che il contenitore potesse creare oggetti proxy che avvolgessero i richiami di metodi in contesti di transazione. Questo involucro dei metodi è un concetto di aspetto, ma le prime specifiche EJB offrivano solo la possibilità per il caso di uso molto specifico della gestione delle transazioni.

L'arrivo di annotazioni con Java 1.5 ha aperto questo concetto di ampliamento della programmazione orientata agli aspetti.Non è che tu abbia bisogno di annotazioni per abilitarlo, piuttosto rende le strutture molto più facili da usare, poiché le annotazioni eliminano la configurazione esterna dei metadati (usando, forse, i file XML).

Così, ora, molti sistemi Java utilizzano i concetti della programmazione orientata agli aspetti, in genere attraverso la riflessione e le annotazioni, per implementare determinate funzionalità. Che si tratti di un'iniezione di istanze, di metodi, convalida, ecc.

Il componente chiave di tutto questo è un meccanismo per intercettare la chiamata al metodo. AspectJ ha funzionato cambiando la classe di destinazione al volo, piuttosto che l'interposizione di un intermediario. EJB funziona creando proxy su interfacce (qualcosa che puoi fare da subito in Java), e poi quando un programma chiede al contenitore un'istanza, fornisce un proxy supportato dall'istanza reale.

Quindi, per abilitare AOP "generico", ovunque, sempre, è sicuramente necessario qualcosa di ampio come AspectJ. Ma per ottenere molti dei benefici, non è necessario andare così lontano. Una semplice classe Factory e un'interfaccia possono fare il lavoro prontamente.