Pour configurer l'inversion de contrôle (IoC) dans Spring à l’aide d’annotations, plusieurs options sont disponibles. Voici une présentation des annotations essentielles permettant d’automatiser le chargement et la liaison des beans.

Activation du support des annotations

Afin que Spring prenne en charge les annotations, il est nécessaire d’ajouter la directive suivante dans le fichier de configuration XML :

<context:annotation-config />

Cette instruction active plusieurs processeurs internes comme AutowiredAnnotationBeanPostProcessor, qui sont responsables de la gestion des annotations telles que @Autowired, @Resource, ou encore @PostConstruct.

@Autowired : injection par type

L’annotation @Autowired permet d’injecter automatiquement un bean en se basant sur son type. Par exemple :

public class UserService {
    private UserDAO userDAO;

    @Autowired
    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public void saveUser(User user) {
        userDAO.save(user);
    }
}

Spring recherche dans le conteneur un bean correspondant au type UserDAO. Si plusieurs beans du même type existent, une ambiguïté survient et provoque une erreur lors du démarrage.

Résolution des conflits avec @Qualifier

Lorsque plusieurs implémentations du même type sont présentes, on peut lever l’ambiguïté grâce à @Qualifier, qui précise le nom exact du bean à injectre :

@Autowired
public void setUserDAO(@Qualifier("userDao") UserDAO userDAO) {
    this.userDAO = userDAO;
}

Dans ce cas, même si deux beans de type UserDAOImpl sont déclarés dans le contexte, Spring ijnectera celui dont l’identifiant est userDao.

@Resource : injection par nom (par défaut)

L’annotation @Resource (issue de Java EE) fonctionne différemment : elle tente d’abord une résolution par nom. Si aucun bean portant ce nom n’est trouvé, elle se rabat sur le type.

@Resource(name = "userDao")
public void setUserDAO(UserDAO userDAO) {
    this.userDAO = userDAO;
}

Cette approche est souvent plus intuitive lorsque le nom du bean est connu à l’avance, car elle évite les erreurs dues à des doublons de type.

@Component : déclaration automatique de beans

Pour éviter de déclarer chaque bean manuellement dans le fichier XML, on peut utiliser @Component sur une classe afin qu’elle soit automatiquement détectée et enregistrée comme bean.

Il faut également activer l’analyse des composants via :

<context:component-scan base-package="ml.orlion" />

Exemple d’utilisation :

@Component("userDao")
public class UserDAOImpl implements UserDAO {
    public void save(User user) {
        System.out.println("Enregistrement de l'utilisateur...");
    }
}

La classe est ainsi intégrée au conteneur Spring sans déclaration explicite dans le fichier XML. Le nom du bean peut être personnalisé ; sinon, il est généré automatiquement à partir du nom de la classe (en notation camelCase).

Annotations supplémentaires pour la gestion du cycle de vie

• @Scope("prototype") : indique que chaque demande de ce bean retournera une nouvelle intsance. Par défaut, les beans sont en mode singleton.
• @PostConstruct : annoter une méthode pour qu’elle soit exécutée après l’initialisation complète du bean. Utile pour effectuer des opérations de configuration.
• @PreDestroy : méthode appelée avant la destruction du bean (dans un contexte de fermeture propre du conteneur).

Exemple :

@Component
@Scope("prototype")
public class UserService {

    @PostConstruct
    public void init() {
        System.out.println("Initialisation du service utilisateur");
    }

    @PreDestroy
    public void cleanup() {
        System.out.println("Nettoyage avant destruction");
    }
}