Eclipse: Comment convertir un projet Web en projet AspectJ et le tisser en utilisant le plug-in AJDT?

Question

Ce que je veux faire:

• Je veux utiliser l'annotation @Configured avec le printemps. Il nécessite AspectJ pour être activé. Je pensais que l'utilisation du plugin AJDT pour le tissage de temps de compilation résoudrait ce problème. Avant d'installer le plug-in, les dépendances qui étaient supposées être injectées dans mon objet @Configured restaient nulles.

Qu'est-ce que je l'ai fait:

• installation du plug AJDT: AspectJ Development Tools in pour Eclipse 3.4.
• Cliquez avec le bouton droit de la souris sur mon projet Web et convertissez-le en projet AspectJ.
• Activé le tissage de temps de compilation.

Qu'est-ce qui ne fonctionne pas:

• Quand je démarre le serveur Tomcat 6 maintenant, je reçois une exception *.

Autres informations:

• Je n'ai pas configuré quoi que ce soit dans le AspectJ Construire et pièces AspectJ compilation des propriétés du projet. JDT Weaving sous Préférences dit que le tissage est activé.
• J'ai toujours le chemin de compilation Java et le compilateur Java sous les propriétés du projet. Et ils ont l'air de les avoir déjà configurés (alors que les deux nouvelles entrées ci-dessus ne sont pas configurées).
• L'icône de mon fichier objet @Configured ressemble à n'importe quel autre fichier (c'est-à-dire aucune indication d'un aspect ou d'un autre, ce que je pense qu'il devrait y avoir). Le nom de fichier est MailNotification.java (et pas .aj), mais je suppose que cela devrait fonctionner quand j'utilise une annotation Spring pour AspectJ?
• Je n'ai trouvé aucun tutoriel ou similaire qui enseigne: Comment transformer un projet d'application Web Spring en projet AspectJ et intégrer des aspects dans les fichiers en utilisant le plugin AJDT, le tout dans Eclipse 3.4. S'il y a quelque chose comme ça, je serais très intéressé à le savoir.

Ce que je voudrais savoir:

• Où aller? Je veux juste utiliser l'annotation @Configured de Spring. J'utilise également @Transactional qui, je pense, a également besoin d'AspectJ.
• Si c'est possible je voudrais étudier AspectJ aussi peu que possible tant que mes besoins sont satisfaits. Le sujet semble intéressant, mais énorme, tout ce que je veux faire est d'utiliser les deux annotations de printemps mentionnées ci-dessus.

*** Exception lorsque Tomcat 6 est lancé:

Caused by: java.lang.IllegalStateException: ClassLoader [org.apache.catalina.loader.WebappClassLoader] does NOT provide an 'addTransformer(ClassFileTransformer)' method. Specify a custom LoadTimeWeaver or start your Java virtual machine with Spring's agent: -javaagent:spring-agent.jar 
at org.springframework.context.weaving.DefaultContextLoadTimeWeaver.setBeanClassLoader(DefaultContextLoadTimeWeaver.java:82) 
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1322) 
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:473) 
... 41 more 

Answer 1

Avez-vous ajouté printemps-aspects.jar à votre chemin d'aspect pour le projet?

Dans les propriétés du projet, sous la rubrique « AspectJ Build » -> « Chemin d'aspect » essayez d'ajouter le printemps-aspects.jar et propre construction du projet.

Désolé, vous pourriez avoir déjà fait - mais vous ne l'avez pas mentionné.

Answer 2

Il semble que le tissage de compilation ne fonctionne pas. Essayez d'ajouter les lignes ci-dessous à votre applicationContext.xml

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

Vous voulez probablement ajouter la xsd suivante dans le fichier xml aussi

http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-2.5.xsd

Pour plus de détails voir ici:

http://static.springframework.org/spring/docs/2.5.x/reference/aop.html#aop-aj-ltw

Answer 3

Vous pouvez utiliser @Transactional sans AspectJ. Votre fichier de configuration doit contenir quelque chose comme suit pour le faire fonctionner:

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:aop="http://www.springframework.org/schema/aop" 
xmlns:tx="http://www.springframework.org/schema/tx" 
xmlns:util="http://www.springframework.org/schema/util" 
xsi:schemaLocation=" 
    http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-2.0.xsd 
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-2.0.xsd 
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx-2.0.xsd 
    http://www.springframework.org/schema/util 
    http://www.springframework.org/schema/util/spring-util-2.5.xsd" 
    > 
<tx:annotation-driven/> 

dit printemps pour chercher des annotations @Transactional lors de la création des instances de haricots configurés. Lors de la recherche d'une telle annotation, spring renvoie un proxy dynamique du bean au code de l'application. Ce proxy dynamique garantit que chaque fois que les méthodes annotées sont appelées, Spring est capable de l'intercepter pour fournir le comportement transactionnel voulu. Mais l'AOP basé sur un mandataire vous oblige à coder par rapport à des interfaces et non à des classes concrètes.