Perché la trama di Compectable di Spring non è compatibile con AspectJ?

Question

Aggiornamento 5: Ho scaricato l'ultimo IDE di Spring ToolsSuite basato sull'ultimo Eclipse. Quando importare il mio progetto come progetto Maven, Eclipse/STS sembra utilizzare gli obiettivi Maven per la costruzione del mio progetto. Ciò significa che AspectJ funziona correttamente in Eclipse.

Aggiornamento 4: Ho appena finito di utilizzare il plug-in Maven + AspectJ per la tessitura in fase di compilazione, aggirando in modo efficace il meccanismo di Eclipse.

Aggiornamento 3: Sembra che il plug-in Eclipse di AspectJ rompa la capacità di Eclipse di pubblicare correttamente su Tomcat. Solo rimuovendo la capacità di AspectJ su un progetto posso farlo pubblicare di nuovo correttamente. Molto noioso.

Aggiornamento 2: Ora funziona in Eclipse. Mi fa molto male a dirlo, ma non ho idea di come sia riuscito a farlo funzionare da build Eclipse o Maven. Sembra essere un problema di compilazione piuttosto che un problema di run-time.

Aggiornamento 1: Sembra che abbia funzionato tramite Maven builds, ma non ho idea di come. Eclipse continua a non funzionare. L'unica cosa che ho cambiato nella pom.xml è stata l'aggiunta di questi (insignificanti?) I parametri di configurazione:

<source>1.6</source> 
<complianceLevel>1.6</complianceLevel> 
<verbose>true</verbose> 
<showWeaveInfo>true</showWeaveInfo> 
<outxml>true</outxml> 

Sono davvero preoccupato che ho una ripetizione del this problem, dove tutto funziona in modo incoerente. Terrò questa domanda aggiornata man mano che imparo di più.

Per quanto riguarda Eclipse, ho fatto dei progressi prendendo gli aspetti binari che desidero tessere - in questo caso spring-aspects.jar - e copiarlo dal mio classpath. Quindi aggiungo questo jar ora esterno al mio Aspect Path . Dopo aver fatto ciò, Eclipse mostra correttamente i marcatori AspectJ nel mio codice. È fastidioso che non posso lasciare spring-aspects.jar nel mio Java Build Path che è gestito da Maven per me tramite il plug-in Maven. Per qualche motivo, tuttavia, il plug-in AspectJ non vede gli aspetti binari a meno che non siano esplicitamente aggiunti al percorso Aspect.

---

post originale: @Configurable è un'annotazione molla che consente dipendenze da iniettare in oggetti istanziati esterno molla (per esempio, di sospensione o una classe di fabbrica).

Stavo usando questa annotazione in precedenza con la tessitura a tempo di caricamento ed è per lo più lavorato. Occasionalmente mi avvio e niente viene iniettato. Questo problema ha generato this StackOverflow question. Non c'erano molte risposte, ma la maggior parte suggeriva di provare la tessitura in compile invece di una maggiore affidabilità.

Ho installato il plug-in AspectJ per Eclipse e Maven. Entrambi producono quelle che sembrano essere classi correttamente compilate. Ho aperto una delle classi in un editor di testo prima della compilation di AspectJ e non ho trovato riferimenti ad AspectJ. L'ho aperto dopo la compilazione di AspectJ e entrambe le versioni generate da Eclipse e Maven hanno un riferimento a org.aspectj.weaver.MethodDeclarationLineNumber. Questo è il motivo per cui presumo che sia stato compilato correttamente.Il problema è che una volta distribuito, nessuna iniezione viene iniettata.

la mia primavera applicationContext.xml non includono i seguenti:

<context:spring-configured /> 

    <context:component-scan base-package="com.myapp" /> 

È quanto sopra tutto ciò che serve per le classi contrassegnati @Configurable di aver DI fatto? Durante la conversione da load-time tessitura per compilare in tempo la tessitura, ho rimosso META-INF/aop.xml, < contesto: load-time tessitore /> dal mio applicationContext.xml, e Tomcat tessitrice di primavera dal mio context.xml.

Come posso approfondire questo problema? Quali sono le possibili cause?

Answer 1

Si lavora per noi su Maven usando compilazione tessitura tempo, prova ad aggiungere il plugin seguenti:

<plugin> 
<groupId>org.apache.maven.plugins</groupId> 
<artifactId>maven-compiler-plugin</artifactId> 
<configuration> 
    <compilerVersion>1.6</compilerVersion> 
    <fork>true</fork> 
    <source>1.6</source> 
    <target>1.6</target> 
</configuration> 
</plugin> 

<plugin> 
<groupId>org.codehaus.mojo</groupId> 
<artifactId>aspectj-maven-plugin</artifactId> 
<executions> 
    <execution> 
     <id>compile</id> 
     <configuration> 
      <source>1.6</source> 
      <target>1.6</target> 
      <verbose>false</verbose> 
      <outxml>true</outxml> 
      <aspectLibraries> 
       <aspectLibrary> 
        <groupId>org.springframework</groupId> 
        <artifactId>spring-aspects</artifactId> 
       </aspectLibrary> 
      </aspectLibraries> 
     </configuration> 
     <goals> 
      <goal>compile</goal> 
     </goals> 
    </execution> 
    <execution> 
     <id>test-compile</id> 
     <configuration> 
      <source>1.6</source> 
      <target>1.6</target> 
      <verbose>false</verbose> 
      <aspectLibraries> 
       <aspectLibrary> 
        <groupId>org.springframework</groupId> 
        <artifactId>spring-aspects</artifactId> 
       </aspectLibrary> 
      </aspectLibraries> 
     </configuration> 
     <goals> 
      <goal>test-compile</goal> 
     </goals> 
    </execution> 
</executions> 
<dependencies> 
    <dependency> 
     <groupId>org.aspectj</groupId> 
     <artifactId>aspectjweaver</artifactId> 
     <version>1.6.4</version> 
    </dependency> 
</dependencies> 
</plugin> 

suo fatto come due fasi di esecuzione separati per consentire di aggiungere diverse librerie di aspetto per i test di unità e la compilazione.

avrete anche bisogno dei seguenti dipendenze aggiunto per la libreria di primavera-aspetti:

<dependency> 
     <groupId>org.springframework</groupId> 
     <artifactId>spring-aspects</artifactId> 
     <scope>compile</scope> 
    </dependency> 

Answer 2

Ho configurato correttamente la tessitura a tempo di caricamento nella mia app, se questa è un'alternativa per voi.

Il mio ambiente:

• JDK-1.6
• Primavera-2.5.6
• JPA con EclipseLink-1.1.0

dettagli di configurazione: configurazione XML

Primavera :

<context:annotation-config/> 
<context:spring-configured/> 
<context:load-time-weaver/> 

<bean id="baseEntity" class="package.name.BaseEntity" scope="prototype"> 
    <property name="historyHandler" ref="historyHandler" /> 
</bean> 

<bean id="historyHandler" class="package.name.HistoryJpaHandler" scope="prototype"> 
    <property name="historyDao" ref="historyDao" /> 
</bean> 

<bean id="historyDao" class="package.name.HistoryJpaDao"> 
    <property name="entityManagerFactory" ref="entityManagerFactory" /> 
</bean> 

annotazioni primavera

@Configurable("baseEntity") 
public abstract class BaseEntity 

@Configurable("historyHandler") 
public class HistoryJpaHandler extends SessionEventAdapter implements HistoryHandler 

Java VM parametri

<JAVA_HOME>/bin/java -javaagent:/full/path/to/spring-agent-2.5.6.jar 

istanze di historyHandler e baseEntitty sono creati da ecliselink. historyHandler in baseEntitty e historyDao nella storiaHandler è impostato dal time-load del carico.

È possibile impostare il parametro VM nella configurazione di esecuzione di Eclipse o in catalina.sh/bat di Tomcats.

Answer 3

Per quanto riguarda i problemi di classpath Eclipse sono interessati, si potrebbe trovare questo utile.

Il m2eclipse plugin ha un AJDT integration facoltativo. L'integrazione legge la sezione aspectLibraries della configurazione di aspectj-maven-plugin e contribuisce con i vasi al percorso di Aspect di Eclipse.

Answer 4

creando un campo di una classe @configurable Autowired genera NullPointerException se non si configura correttamente la molla per questa annotazione. seguire questi passaggi per fare annotazioni @configurable funzionano correttamente

Questo metodo viene chiamato AspectJ costruire tempo tessitura di iniettare i fagioli di primavera alle classi non-molla-made.

Il primo passo è quello di installare questi plugin in Eclipse:

Da questi due siti di aggiornamento installare qualsiasi eclissi suggerisce:

http://download.eclipse.org/tools/ajdt/43/update 
http://dist.springsource.org/release/AJDT/configurator/ 

Dopo l'installazione, fare clic destro sul progetto e Do:

Configure > Convert to Aspectj 
Maven > Update 

Successivamente, è necessario aggiungere questi alla vostra pom.xml:

Under Dipendenze Aggiungi:

<dependency> 
    <groupId>org.springframework</groupId> 
    <artifactId>spring-aspects</artifactId> 
    <version>4.0.2.RELEASE</version> 
</dependency> 

sotto plugins Aggiungi:

 <plugin> 
      <groupId>org.codehaus.mojo</groupId> 
      <artifactId>aspectj-maven-plugin</artifactId> 
      <version>1.5</version> 
      <configuration> 
       <showWeaveInfo>true</showWeaveInfo> 
       <source>1.7</source> 
       <target>1.7</target> 
       <Xlint>ignore</Xlint> 
       <complianceLevel>1.7</complianceLevel> 
       <encoding>UTF-8</encoding> 
       <verbose>false</verbose> 
       <aspectLibraries> 
        <aspectLibrary> 
         <groupId>org.springframework</groupId> 
         <artifactId>spring-aspects</artifactId> 
        </aspectLibrary> 
       </aspectLibraries> 
      </configuration> 
      <executions> 
       <execution> 
        <goals> 
         <goal>compile</goal> 
         <goal>test-compile</goal> 
        </goals> 
       </execution> 
      </executions> 
      <dependencies> 
       <dependency> 
        <groupId>org.aspectj</groupId> 
        <artifactId>aspectjrt</artifactId> 
        <version>1.7.0</version> 
       </dependency> 
       <dependency> 
        <groupId>org.aspectj</groupId> 
        <artifactId>aspectjtools</artifactId> 
        <version>1.7.0</version> 
       </dependency> 
      </dependencies> 
     </plugin> 

Importante: NON usare qualsiasi <pluginManagment> tag sotto <build> tag. tua pom.xml ha bisogno di essere qualcosa di simile:

<project ....> 
    .... 
    <dependencies> 
     <dependency> 
        .... 
     </dependency> 
       .... 
    </dependencies> 
    <build> 
     <plugins> 
      <plugin> 
          .... 
      </plugin> 
         .... 
     </plugins> 
    </build> 
</project> 

infine aggiungere <context:spring-configured /> al file di configurazione dell'applicazione contesto primavera.

Ora è possibile annotare una classe POJO come @Configurable e iniettare i bean a molla utilizzando l'annotazione @Autowired. in questo modo ogni volta che crei una nuova istanza di quel POJO verrà configurato automaticamente (ad es. iniettato con dipendenze).