Comment obtenir tous les haricots gérés par Spring?

Comment obtenir tous les haricots à gestion printanière?

1. Vue d'ensemble

Dans cet article, nous allons explorer différentes techniques pour afficher tous les beans gérés par Spring avec le conteneur.

2. Le conteneur IoC

Un haricot est la base d'une application gérée par Spring; tous les haricots résident dans le conteneur IOC, qui est responsable de la gestion de leur cycle de vie.

Nous pouvons obtenir une liste de tous les haricots contenus dans ce conteneur de deux manières:

Utilisation d'une interfaceListableBeanFactory
Utilisation d'un actionneur à démarrage par ressort

3. Utilisation de l'interfaceListableBeanFactory

The ListableBeanFactory interface provides getBeanDefinitionNames() method qui renvoie les noms de tous les beans définis dans cette fabrique. Cette interface est implémentée par toutes les usines de beans qui préchargent leurs définitions de beans pour énumérer toutes leurs instances de beans.

Vous pouvez trouver la liste de toutes les sous-interfaces connues et de ses classes d'implémentation dansthe official documentation.

Pour cet exemple, nous utiliserons une application Spring Boot.

Tout d'abord, nous allons créer des haricots de printemps. Créons un simple Spring ControllerFooController:

@Controller
public class FooController {

    @Autowired
    private FooService fooService;

    @RequestMapping(value="/displayallbeans")
    public String getHeaderAndBody(Map model){
        model.put("header", fooService.getHeader());
        model.put("message", fooService.getBody());
        return "displayallbeans";
    }
}

Ce contrôleur dépend d'un autre Spring BeanFooService:

@Service
public class FooService {

    public String getHeader() {
        return "Display All Beans";
    }

    public String getBody() {
        return "This is a sample application that displays all beans "
          + "in Spring IoC container using ListableBeanFactory interface "
          + "and Spring Boot Actuators.";
    }
}

Notez que nous avons créé deux beans différents ici:

fooController
fooService

Lors de l'exécution de cette application, nous allons utiliser l'objetapplicationContext et appeler sa méthodegetBeanDefinitionNames(), qui retournera tous les beans de notre conteneurapplicationContext:

@SpringBootApplication
public class Application {
    private static ApplicationContext applicationContext;

    public static void main(String[] args) {
        applicationContext = SpringApplication.run(Application.class, args);
        displayAllBeans();
    }

    public static void displayAllBeans() {
        String[] allBeanNames = applicationContext.getBeanDefinitionNames();
        for(String beanName : allBeanNames) {
            System.out.println(beanName);
        }
    }
}

Cela affichera tous les beans du conteneurapplicationContext:

fooController
fooService
//other beans

Notez qu'avec les beans définis par nous,it will also log all other beans that are in this container. Par souci de clarté, nous les avons omis ici car il y en a beaucoup.

4. Utilisation de Spring Boot Actuator

La fonctionnalité Spring Boot Actuator fournit des points de terminaison qui sont utilisés pour surveiller les statistiques de notre application.

Il comprend de nombreux points de terminaison intégrés, y compris /beans. Cela affiche une liste complète de tous les beans gérés par Spring dans notre application. Vous pouvez trouver la liste complète des points de terminaison existants suron the official docs.

Maintenant, nous allons simplement atteindre l'URLhttp://<address>:<management-port>/beans.. Nous pouvons utiliser le port de notre serveur par défaut si nous n'avons spécifié aucun port de gestion distinct. Cela renverra une réponseJSON affichant tous les beans dans le conteneur Spring IoC:

[
    {
        "context": "application:8080",
        "parent": null,
        "beans": [
            {
                "bean": "fooController",
                "aliases": [],
                "scope": "singleton",
                "type": "com.example.displayallbeans.controller.FooController",
                "resource": "file [E:/Workspace/tutorials-master/spring-boot/target
                  /classes/com/example/displayallbeans/controller/FooController.class]",
                "dependencies": [
                    "fooService"
                ]
            },
            {
                "bean": "fooService",
                "aliases": [],
                "scope": "singleton",
                "type": "com.example.displayallbeans.service.FooService",
                "resource": "file [E:/Workspace/tutorials-master/spring-boot/target/
                  classes/com/example/displayallbeans/service/FooService.class]",
                "dependencies": []
            },
            // ...other beans
        ]
    }
]

Bien sûr, cela comprend également de nombreux autres grains résidant dans le même conteneur à ressort, mais pour des raisons de clarté, nous les avons omis ici.

Si vous souhaitez en savoir plus sur les actionneurs Spring Boot, vous pouvez vous diriger vers le guide principal deSpring Boot Actuator.

5. Conclusion

Dans cet article, nous avons appris comment afficher tous les beans dans unSpring IoC Container à l'aide de l'interfaceListableBeanFactory et des actionneurs Spring Boot.

Lesfull implementation de ce tutoriel peuvent être trouvésover on Github.

TOC