Wie bekomme ich alle Spring-Managed Beans?

Wie bekomme ich alle frühlingsverwalteten Bohnen?

1. Überblick

In diesem Artikel werden verschiedene Techniken zum Anzeigen aller von Spring verwalteten Bohnen im Container untersucht.

2. Der IoC-Container

Eine Bohne ist die Grundlage einer Spring-verwalteten Anwendung. Alle Beans befinden sich im IOC-Container, der für die Verwaltung ihres Lebenszyklus verantwortlich ist.

Wir können eine Liste aller Bohnen in diesem Container auf zwei Arten erhalten:

Verwenden einerListableBeanFactory-Schnittstelle
Verwendung eines Spring Boot-Aktuators

3. Verwenden derListableBeanFactory-Schnittstelle

The ListableBeanFactory interface provides getBeanDefinitionNames() method, das die Namen aller in dieser Factory definierten Beans zurückgibt. Diese Schnittstelle wird von allen Bean-Fabriken implementiert, die ihre Bean-Definitionen vorab laden, um alle ihre Bean-Instanzen aufzulisten.

Die Liste aller bekannten Subschnittstellen und ihrer implementierenden Klassen finden Sie inthe official documentation.

In diesem Beispiel verwenden wir eine Spring Boot-Anwendung.

Zuerst erstellen wir einige Frühlingsbohnen. Erstellen wir einen einfachen 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";
    }
}

Dieser Controller ist abhängig von einem anderen 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.";
    }
}

Beachten Sie, dass wir hier zwei verschiedene Bohnen erstellt haben:

fooController
fooService

Während der Ausführung dieser Anwendung verwenden wir das ObjektapplicationContextund rufen die MethodegetBeanDefinitionNames()auf, mit der alle Beans in unserem ContainerapplicationContextzurückgegeben werden:

@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);
        }
    }
}

Dadurch werden alle Bohnen aus dem Container vonapplicationContextgedruckt:

fooController
fooService
//other beans

Beachten Sie, dass zusammen mit den von uns definierten Bohnenit will also log all other beans that are in this container. Aus Gründen der Klarheit haben wir sie hier weggelassen, da es ziemlich viele davon gibt.

4. Spring Boot Actuator verwenden

Die Spring Boot Actuator-Funktion bietet Endpunkte, die zur Überwachung der Statistiken unserer Anwendung verwendet werden.

Es enthält viele integrierte Endpunkte, einschließlich /beans.. Hier wird eine vollständige Liste aller von Spring verwalteten Beans in unserer Anwendung angezeigt. Sie finden die vollständige Liste der vorhandenen Endpunkte überon the official docs.

Jetzt drücken wir nur noch die URLhttp://<address>:<management-port>/beans.. Wir können unseren Standardserver-Port verwenden, wenn wir keinen separaten Verwaltungsport angegeben haben. Dies gibt eineJSONAntwort zurück, in der alle Beans im Spring IoC Container angezeigt werden:

[
    {
        "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
        ]
    }
]

Natürlich besteht dies auch aus vielen anderen Bohnen, die sich im selben Frühlingsbehälter befinden, aber der Klarheit halber haben wir sie hier weggelassen.

Wenn Sie mehr über Spring Boot Actuators erfahren möchten, lesen Sie die Anleitung zuSpring Boot Actuator.

5. Fazit

In diesem Artikel haben wir gelernt, wie alle Beans inSpring IoC Container mithilfe derListableBeanFactory-Schnittstelle und der Spring Boot-Aktuatoren angezeigt werden.

Diefull implementation dieses Tutorials finden Sie unterover on Github.

TOC