原文： http://zetcode.com/articles/springbootlistbeans/

    在本教程中，我们列出了存储在 Spring 容器中的所有 bean，包括内置和自定义 bean。

    Spring 是流行的 Java 应用框架，而 Spring Boot 是 Spring 的演进，可帮助您以最少的精力创建独立的，生产级的基于 Spring 的应用。

    Spring 核心容器创建并管理 Bean。 可以通过ApplicationContext获得这些 bean。 在以下应用中，我们列出了所有存储的 bean。 该应用是命令行 Spring Boot 应用。

    1. $ tree
    2. .
    3. ├── pom.xml
    4. └── src
    5.     ├── main
    6.     │   ├── java
    7.     │   │   └── com
    8.     │   │       └── zetcode
    9.     │   │           ├── Application.java
    10.     │   │           ├── bean
    11.     │   │           │   └── MyBean.java
    12.     │   │           └── MyRunner.java
    13.     │   └── resources
    14.     └── test
    15.         └── java

    这是 Spring Boot 应用的项目结构。

    pom.xml

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0" 
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
    5. http://maven.apache.org/xsd/maven-4.0.0.xsd">
    7.     <modelVersion>4.0.0</modelVersion>
    8.     <groupId>com.zetcode</groupId>
    9.     <artifactId>SpringBootListBeans</artifactId>
    10.     <version>1.0-SNAPSHOT</version>
    11.     <packaging>jar</packaging>
    12.     <properties>
    13.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    14.         <maven.compiler.source>1.8</maven.compiler.source>
    15.         <maven.compiler.target>1.8</maven.compiler.target>
    16.     </properties>
    18.     <parent>
    19.         <groupId>org.springframework.boot</groupId>
    20.         <artifactId>spring-boot-starter-parent</artifactId>
    21.         <version>1.5.3.RELEASE</version>
    22.     </parent>    
    24.     <dependencies>
    26.         <dependency>
    27.             <groupId>org.springframework.boot</groupId>
    28.             <artifactId>spring-boot-starter</artifactId>
    29.         </dependency>        
    31.     </dependencies>    
    33.     <build>
    34.         <plugins>
    35.             <plugin>
    36.                 <groupId>org.springframework.boot</groupId>
    37.                 <artifactId>spring-boot-maven-plugin</artifactId>
    38.             </plugin>            
    39.         </plugins>
    40.     </build>
    41.     <name>SpringBootListBeans</name>
    42. </project>

    这是 Maven 构建文件。 spring-boot-starter是包括自动配置支持，日志记录和 YAML 在内的核心启动器。 该应用打包到一个 JAR 文件中。

    MyBean.java

    1. package com.zetcode.bean;
    3. import org.springframework.stereotype.Component;
    5. @Component
    6. public class MyBean {
    8.     private final String message = "This is MyBean";
    10.     public String getMessage() {
    12.         return message;
    13.     }
    14. }

    MyBean是由 Spring 创建和管理的自定义 bean。 Spring 自动检测由@Component注解修饰的类，并将其存储在 Spring 容器中。

    MyRunner.java

    1. package com.zetcode;
    3. import com.zetcode.bean.MyBean;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.boot.CommandLineRunner;
    6. import org.springframework.context.ApplicationContext;
    7. import org.springframework.stereotype.Component;
    9. @Component
    10. public class MyRunner implements CommandLineRunner {
    12.     @Autowired
    13.     private ApplicationContext appContext;
    15.     @Autowired
    16.     private MyBean myBean;
    18.     @Override
    19.     public void run(String... args) throws Exception {
    21.         System.out.println(myBean.getMessage());
    23.         System.out.println("List of beans:");
    25.         String[] beans = appContext.getBeanDefinitionNames();
    27.         for (String bean : beans) {
    28.             System.out.println(bean);
    29.         }
    30.     }
    31. }

    CommandLineRunner接口指示当SpringApplication中包含 bean 时应运行它。 它可以用来创建 Spring Boot 命令行应用。

    1. @Component
    2. public class MyRunner implements CommandLineRunner {

    MyRunner也是一个 Spring bean，并在 bean 中列出。

    1. @Autowired
    2. private ApplicationContext appContext;

    ApplicationContext将以@Autowired注解注入到字段中。

    1. @Autowired
    2. private MyBean myBean;

    同样，我们注入自定义 bean。

    1. System.out.println(myBean.getMessage());

    在这里，我们打印存储在自定义 bean 中的消息。

    1. String[] beans = appContext.getBeanDefinitionNames();

    从应用上下文中，我们获得一个带有getBeanDefinitionNames()的 bean 名称数组。

    1. for (String bean : beans) {
    2.     System.out.println(bean);
    3. }

    Bean 名称将打印到控制台。

    Application.java

    1. package com.zetcode;
    3. import org.springframework.boot.SpringApplication;
    4. import org.springframework.boot.autoconfigure.SpringBootApplication;
    6. @SpringBootApplication
    7. public class Application {
    9.     public static void main(String[] args) {
    10.         SpringApplication.run(Application.class, args);
    11.     }
    12. }

    在Application中，设置 Spring Boot 应用。 设置 Spring Boot 应用。 @SpringBootApplication启用自动配置和组件扫描。 Spring 将自动扫描 Bean，并同时拾取MyBean和MyRunner。

    1. $ mvn spring-boot:run -q
    2. ...
    3. This is MyBean
    4. List of beans:
    5. org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    6. org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    7. org.springframework.context.annotation.internalRequiredAnnotationProcessor
    8. org.springframework.context.annotation.internalCommonAnnotationProcessor
    9. org.springframework.context.event.internalEventListenerProcessor
    10. org.springframework.context.event.internalEventListenerFactory
    11. application
    12. org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory
    13. myRunner
    14. myBean
    15. ...

    我们运行该应用。 -q Maven 选项关闭 Maven 消息。

    在本教程中，我们列出了存储在 Spring 容器中的所有 bean。 您可能也对相关教程感兴趣： Spring Boot Bean ， Spring Boot @Qualifier注解，在 Spring Boot 中提供静态内容， Spring Boot DataSourceBuilder教程， Spring Boot iText 教程， Java 教程。