Spring Garden

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Classe qui initialise l'application SpringGarden.
 */
public class SpringGardenApplication {

    /**
     * Methode main ou commence le flux de l'application.
     */
    public static void main(String[] args) {

        // Demarre le contexte de Spring
        new ClassPathXmlApplicationContext("applicationContext.xml",
                SpringGardenApplication.class);
    }
}

<?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:context="http://www.springframework.org/schema/context"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd 
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!-- ANNOTATIONS POUR L'INJECTION DE DEPENDANCES -->
    <context:annotation-config />

    <!-- ANNOTATIONS POUR LA CREATION DE BEANS -->
    <context:component-scan base-package="org.yannart.springgarden" />

    <!-- ANNOTATIONS POUR AOP -->
    <aop:aspectj-autoproxy />

    <!-- JARDINIER -->
    <bean id="jardinier" class="org.yannart.springgarden.Jardinier" p:nom="Dupond" />

/**
 * Jardinier qui s'occupe du jardin.
 */
public class Jardinier implements IJardinier {
    
    /**
     * Nom du jardinier.
     */
    private String nom;

    @Override
    public String toString() {
        return "Monsieur " + nom;
    }

    //GETTER ET SETTERS
       ...
}

    <!--PLANTES -->
    <bean id="tomate" parent="plante" scope="prototype" p:nomPlante="Tomate" />
    <bean id="patate" parent="plante" scope="prototype" p:nomPlante="Patate" />
    <bean id="choux" parent="plante" scope="prototype" p:nomPlante="Choux" />
    <bean id="pomme" parent="plante" scope="prototype" p:nomPlante="Pomme" />
    <bean id="poire" parent="plante" scope="prototype" p:nomPlante="Poire" />
    <bean id="poireMalade" parent="plante" scope="prototype" p:nomPlante="PoireMalade" />
    <bean id="patateMalade" parent="plante" scope="prototype" p:nomPlante="PatateMalade" />

import org.springframework.stereotype.Component;

/**
 * Classe abstraite que declare les methodes communes a toutes les plantes
 */
@Component
public class Plante implements IPlante {

    /**
     * Nom de la plante.
     */
    private String nomPlante;

    /**
     * Quantité d'eau reçue.
     */
    private int eau;

    /**
     * Quantité d'engrais reçu.
     */
    private int engrais;

    @Override
    public void nourriEau(final int quantite) {
        System.out.println("    - arrose la plante " + nomPlante + " avec "
                + quantite + "ml d'eau");
        eau += quantite;
        System.out.println("     --> " + nomPlante + " a maintenant " + eau
                + "ml d'eau");
    }

    @Override
    public void nourriEngrais(final int quantite) {
        System.out.println("    - met " + quantite + "g d'engrais a la plante "
                + nomPlante);
        engrais += quantite;
        System.out.println("     --> " + nomPlante + " a maintenant " + engrais
                + "g d'engrais");
    }

    @Override
    public String toString() {
        return nomPlante;
    }

    //GETTER ET SETTERS
       ...
}

<!-- POTAGER -->
    <bean id="potager" class="org.yannart.springgarden.Parcelle"
        init-method="melanger">
        <property name="nom" value="Potager" />
        <property name="plantes">
            <list>
                <ref bean="tomate" />
                <ref bean="patate" />
                <ref bean="patateMalade" />
                <ref bean="choux" />
                <ref bean="choux" />
            </list>
        </property>
    </bean>

    <!-- VERGER -->
    <bean id="verger" class="org.yannart.springgarden.Parcelle"
        init-method="melanger">
        <property name="nom" value="Verger" />
        <property name="plantes">
            <list>
                <ref bean="pomme" />
                <ref bean="poireMalade" />
                <ref bean="poire" />
            </list>
        </property>
    </bean>

/**
 * Une parcelle du jardin contient des plantes.
 */
public class Parcelle implements IParcelle {

    /**
     * Plantes de la zone
     */
    private List<IPlante> plantes;

    /**
     * Nom de la zone
     */
    private String nom;

    public void arroser(final int quantite) {
        System.out.println(toString() + ":");

        for (IPlante plante : plantes) {
            plante.nourriEau(quantite);
        }
    }

    public void mettreEngrais(final int quantite) {
        System.out.println(toString() + ":");

        for (IPlante plante : plantes) {
            plante.nourriEngrais(quantite);
        }
    }

    public void listerPlantes() {
        System.out.println(toString() + ":");

        for (IPlante plante : plantes) {
            System.out.println("    " + plante.getDetail());
        }
    }

    public void melanger() {
        Collections.shuffle(plantes);
    }

    @Override
    public String toString() {
        return nom;
    }

    //GETTERS ET SETTERS
     ...

    <!-- JARDIN -->
    <bean id="jardin" class="org.yannart.springgarden.Jardin" init-method="jardiner">
        <property name="jardinier" ref="jardinier" />
        <property name="parcelles">
            <list>
                <ref bean="potager" />
                <ref bean="verger" />
            </list>
        </property>
        <!-- Les doses sont aléatoires -->
        <property name="doseEau" value="#{ T(java.lang.Math).random() * 100 }" />
        <property name="doseEngrais" value="#{ T(java.lang.Math).random() * 50 }" />
    </bean>

import java.util.List;

/**
 * Jardin qui contient differentes zones.
 */
public class Jardin implements IJardin {

    /**
     * Parcelles du jardin.
     */
    List<IParcelle> parcelles;

    /**
     * Jardinier du jardin.
     */
    IJardinier jardinier;

    /**
     * Dose d'engrais par plante.
     */
    int doseEngrais;

    /**
     * Dose d'eau par plante.
     */
    int doseEau;

    public void jardiner(){

        // Montre le contenu du jardin
        System.out.println("\nJARDIN DE DEPART");
        this.listerParcelles();
 
        // Arrose tout le jardin
        System.out.println("\nON ARROSE LE JARDIN");
        this.arroser();

        // Met de l'engrais a tout le jardin
        System.out.println("\nON MET DE L'ENGRAIS DANS LE JARDIN");
        this.mettreEngrais();

        // Montre le contenu du jardin
        System.out.println("\nJARDIN A LA FIN");
        this.listerParcelles();
    }
    
    public void arroser() {
        System.out.println(jardinier + " arrose le Jardin");
        for (IParcelle parcelle : parcelles) {
            parcelle.arroser(doseEau);
        }
    }

    public void mettreEngrais() {
        System.out.println(jardinier + " met de l'engrais");
        for (IParcelle parcelle : parcelles) {
            parcelle.mettreEngrais(doseEngrais);
        }
    }

    public void listerParcelles() {
        System.out.println("Le Jardin de " + jardinier + " contient:");
        for (IParcelle parcelle : parcelles) {
            parcelle.listerPlantes();
        }
    }

    //GETTERS ET SETTERS
}

import org.springframework.stereotype.Component;

/**
 * Mauvaise herbe.
 */
@Component
public class MauvaiseHerbe extends Plante {

    /**
     * Construit une plante de mauvaise herbe.
     */
    public MauvaiseHerbe() {
        super.setNomPlante("MauvaiseHerbe");
    }

    @Override
    public void nourriEau(int quantite) {
        System.out.println("    ** La mauvaise herbe vole l'eau !! **");
        super.nourriEau(quantite);
    }

    @Override
    public void nourriEngrais(int quantite) {
        System.out.println("    ** La mauvaise herbe vole l'engrais !! **");
        super.nourriEngrais(quantite);
    }
}

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import javax.annotation.Resource;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

/**
 * Cette classe implémente tout le mal de la mauvaise herbe ;-).
 */
@Aspect
@Component
public class MauvaiseHerbeAspect {

    /**
     * Mauvaise herbe qui vole les nutriments.
     */
    @Resource
    IPlante mauvaiseHerbe;

    /**
     * Advice associé à l'exécution d'une méthode avec le préfixe "nourri" d'un
     * bean avec le suffixe "Malade".
     * 
     * @param joinPoint
     *            référence au point de jonction de l'aspect.
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    @Around("execution(* nourri*(..)) && bean(*Malade)")
    public void mauvaiseHerbeAdvice(final ProceedingJoinPoint joinPoint)
            throws IllegalAccessException, InvocationTargetException {

        // On sait que l'objet destin de l'appel est une Plante
        IPlante plante = (IPlante) joinPoint.getTarget();

        // On sait que le JoinPoint est une méthode
        Method method = ((MethodSignature) joinPoint.getSignature())
                .getMethod();

        System.out.println("    * mauvaise herbe sent la methode "
                + method.getName() + " sur " + plante.getNomPlante());

        // Ce qu'allait recevoir la plante est reçu par la mauvaise herbe
        method.invoke(mauvaiseHerbe, joinPoint.getArgs());
    }
}