如何获取所有spring管理的bean

目录
  • 获取所有spring管理的bean
    • IOC容器
    • 使用ListableBeanFactory接口
    • 使用Spring Boot Actuator
    • 小结一下
  • spring管理bean的原理
    • 使用spring时,获取spring注入的bean是这样
    • 那下面我们模拟spring管理bean这个的过程
    • 小结一下

获取所有spring管理的bean

本文我们探索使用不同的方式获取spring容器中所有bean。

IOC容器

bean是基于spring应用的基础,所有bean都驻留在ioc容器中,由容器负责管理bean生命周期

有两种方式可以获取容器中的bean:

- 使用ListableBeanFactory接口

- 使用Spring Boot Actuator

使用ListableBeanFactory接口

ListableBeanFactory接口提供了getBeanDefinitionNames() 方法,能够返回所有定义bean的名称。该接口被所有factory实现,负责预加载bean定义去枚举所有bean实例。官方文档提供所有其子接口及其实现。

下面示例使用Spring Boot 构建:

首先,我们创建一些spring bean,先定义简单的Controller FooController:

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

该Controller依赖另一个spring Bean FooService:

@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.";
    }
}

我们创建了两个不同的bean:

1.fooController

2.fooService

现在我们运行该应用。使用applicationContext 对象调用其 getBeanDefinitionNames() 方法,负责返回applicationContext上下文中所有bean。

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

会输出applicationContext上下文中所有bean:

fooController

fooService

//other beans

需注意除了我们定义的bean外,它还将打印容器中所有其他bean。为了清晰起见,这里省略了很多。

使用Spring Boot Actuator

Spring Boot Actuator提供了用于监视应用程序统计信息的端点(endpoint)。除了/beans,还包括很多其他端点,官方文档有详细说明。

现在我们访问url: http//

:/beans,如果没有指定其他独立管理端口,我们使用缺省端口,结果会返回json,包括容器所有定义的bean信息:

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

当然,结果同样包括很多其他的bean,为了简单起见,这里没有列出。

小结一下

上面介绍了使用ListableBeanFactory 接口和 Spring Boot Actuators 返回spring 容器中所有定义的bean信息。

spring管理bean的原理

Spring容器默认情况下,当服务启动时,解析配置文件,实例化文件中的所有类。

使用spring时,获取spring注入的bean是这样

ApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
              MyService myService1 = (MyService) ctx.getBean("myService");

那下面我们模拟spring管理bean这个的过程

代码如下:

1.第一步,创建java project,引入spring.jar

2.创建spring.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 </beans>

3.创建接口MyService,只需要一个测试方法save

4.创建实现类MyServiceImpl,控制台输出一句话

5.创建一个自己的解析类MyClassPathXmlApplicationContext

主要是构造方法中的两步

// 装载实例化bean
       private Map<String, Object> beanMap = new HashMap<String, Object>();
       // 装载配置文件的属性和值
       private List<MyBeans> beanlist = new ArrayList<MyBeans>();
       public MyClassPathXmlApplicationContext(String filename) {
              //第一步,解析spring配置文件
              readXml(filename);
              //第二步,通过反射,实例化所有注入bean
              initBeans();
       }

       /**
        * 通过反射机制,初始化配置文件中的bean
        */
       private void initBeans() {
              for (MyBeans bean : beanlist) {
                     try {
                            if (bean.getClassName() != null && !"".equals(bean.getClassName())) {
                                   beanMap.put(bean.getId(), Class.forName(bean.getClassName()).newInstance());
                            }
                     } catch (Exception e) {
                            e.printStackTrace();
                     }
              }
       }

       /**
        * 解析配置文件,把解析后的bean设置到实体中,并保持到list
        *
        * @param filename
        */
       private void readXml(String filename) {
              SAXReader reader = new SAXReader();

              Document doc = null;
              URL xmlpath = this.getClass().getClassLoader().getResource(filename);
              try {
                     Map<String, String> nsMap = new HashMap<String, String>();
                     nsMap.put("ns", "http://www.springframework.org/schema/beans");
                     doc = reader.read(xmlpath);
                     XPath xpath = doc.createXPath("//ns:beans//ns:bean");// 创建//ns:beans//ns:bean查询路径
                     xpath.setNamespaceURIs(nsMap);// 设置命名空间
                     List<Element> eles = xpath.selectNodes(doc);// 取得文档下所有节点
                     for (Element element : eles) {
                            String id = element.attributeValue("id");
                            String cn = element.attributeValue("class");
                            //自定义实体bean,保存配置文件中id和class
                            MyBeans beans = new MyBeans(id, cn);
                            beanlist.add(beans);
                     }
              } catch (Exception e) {
                     e.printStackTrace();
              }

       }

       public Object getBean(String beanId) {
              return beanMap.get(beanId);
       }

6.实体类

package com.mooing.service;
public class MyBeans {
       private String id;
       private String className;
       public MyBeans(String id, String className) {
              this.id = id;
              this.className = className;
       }

       public String getId() {
              return id;
       }

       public void setId(String id) {
              this.id = id;
       }

       public String getClassName() {
              return className;
       }

       public void setClassName(String className) {
              this.className = className;
       }
}

7.测试

MyClassPathXmlApplicationContext ctx = new MyClassPathXmlApplicationContext("spring.xml");
  MyService myService = (MyService) ctx.getBean("myService");
  myService.save();

小结一下

自定义代码同样可以得到使用spring容器实例化的效果,也就是说,实际spring实例化管理bean时,也是经过两大步:

第一:服务启动解析配置文件,并保存配置文件中的元素;

第二:实例化所有元素,并提供获取实例方法。

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

时间: 2021-09-13

Java Spring-IOC容器与Bean管理之基于注解的方式案例详解

Spring-IOC容器-Bean管理-基于注解方式 什么是注解? (1)注解是代码特殊标记,格式:@注解名称(属性名称=属性值, 属性名称=属性值-) (2)使用注解,注解作用在类上面,方法上面,属性上面 (3)使用注解目的:简化 xml 配置 Spring 针对 Bean 管理中创建对象提供注解 下面四个注解功能是一样的,都可以用来创建 bean 实例 (1)@Component (2)@Service (3)@Controller (4)@Repository 基于注解方式实现对象创建 ①

最全总结SpringBean的作用域管理

一.前言 创建 BeanDefinition 时,就等于创建了一个配方,用于创建由 BeanDefinition 所定义的类实例.BeanDefinition 是配方的这种思想很重要,因为这意味着,与使用类一样,也可通过一个配方创建多个对象实例. 有如下优点: 可以控制要插入到从特定 BeanDefinition 创建的对象中的各种依赖项和配置值 可以控制从特定 BeanDefinition 创建的对象的作用域. 这种方式功能强大且灵活,因为开发者可以选择通过配置创建的对象的作用域,而不必在Ja

Spring Bean管理注解方式代码实例

1.使用注解的方式需要配置applicationContext.xml: <?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:context=&qu

Spring Bean基本管理实例详解

本文实例讲述了Spring Bean基本管理.分享给大家供大家参考,具体如下: 一.使用setter方式完成依赖注入 下面是Bean和beans-config.xml文件. public class HelloBean { private String helloWord; //...省略getter.setter方法 } <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC &

Spring-IOC容器-Bean管理-基于XML方式超详解

目录 Spring-IOC容器-Bean管理-基于XML方式 Spring框架概述 IOC概念和原理 IOC 操作 Bean 管理(set方式注入&&使用有参构造进行注入) IOC 操作 Bean 管理(xml注入其他类型属性) IOC 操作 Bean 管理(xml注入集合属性) IOC 操作 Bean 管理(FactoryBean) IOC 操作 Bean 管理(bean 作用域) IOC 操作 Bean 管理(bean 生命周期) IOC 操作 Bean 管理(XML自动装配) IOC

Spring IoC容器知识点详解

可以把 Spring IoC 容器比作一间餐馆,当你来到餐馆,通常会直接招呼服务员:点菜!至于菜的原料是什么?如何用原料把菜做出来?可能你根本就不关心.IoC 容器也是一样,你只需要告诉它需要某个bean,它就把对应的实例(instance)扔给你,至于这个bean是否依赖其他组件,怎样完成它的初始化,根本就不需要你关心. 作为餐馆,想要做出菜肴,得知道菜的原料和菜谱,同样地,IoC 容器想要管理各个业务对象以及它们之间的依赖关系,需要通过某种途径来记录和管理这些信息.BeanDefinitio

详解Spring IOC 容器启动流程分析

使用 Spring 时,XML 和注解是使用得最多的两种配置方式,虽然是两种完全不同的配置方式,但对于 IOC 容器来说,两种方式的不同主要是在 BeanDefinition 的解析上.而对于核心的容器启动流程,仍然是一致的. AbstractApplicationContext 的 refresh 方法实现了 IOC 容器启动的主要逻辑,启动流程中的关键步骤在源码中也可以对应到独立的方法.接下来以  AbstractApplicationContext 的实现类  ClassPathXmlAp

Spring中Bean的命名方式代码详解

本文主要描述的是关于spring中bean的命名方式,通过简单实例向大家介绍了六种方式,具体如下. 一般情况下,在配置一个Bean时需要为其指定一个id属性作为bean的名称.id在IoC容器中必须是唯一的,此外id的命名需要满足xml对id的命名规范. 在实际情况中,id命名约束并不会给我们带来影响.但是如果用户确实希望用到一些特殊字符来对bean进行命名,那么可以使用bean的name属性来进行命名,name属性没有字符上的限制,几乎可以使用任何字符. 每个Bean可以有一个或多个id,我们

Spring 3.x中三种Bean配置方式比较详解

以前Java框架基本都采用了XML作为配置文件,但是现在Java框架又不约而同地支持基于Annotation的"零配置"来代替XML配置文件,Struts2.Hibernate.Spring都开始使用Annotation来代替XML配置文件了:而在Spring3.x提供了三种选择,分别是:基于XML的配置.基于注解的配置和基于Java类的配置. 下面分别介绍下这三种配置方式:首先定义一个用于举例的JavaBean. package com.chinalife.dao public cl

Spring实例化bean的方式代码详解

通过这篇文章通过实例代码向大家介绍了Spring实例化bean的几种方法,接下来看看具体内容吧. 1.使用类构造器实现实例化(bean的自身构造器) <bean id = "orderService" class="cn.itcast.OrderServiceBean"/> 2.使用静态工厂方法实现实例化 <bean id = "personService" class = "cn.itcast.OrderFactor

浅谈Spring IoC容器的依赖注入原理

本文介绍了浅谈Spring IoC容器的依赖注入原理,分享给大家,具体如下: IoC容器初始化的过程,主要完成的工作是在IoC容器中建立 BeanDefinition 数据映射,并没有看到IoC容器对Bean依赖关系进行注入, 假设当前IoC容器已经载入用户定义的Bean信息,依赖注入主要发生在两个阶段 正常情况下,由用户第一次向IoC容器索要Bean时触发 但我们可以在 BeanDefinition 信息中通过控制 lazy-init 属性来让容器完成对Bean的预实例化,即在初始化的过程中就

使用Java注解模拟spring ioc容器过程解析

使用注解,简单模拟spring ioc容器.通过注解给对象属性注入值. 项目结构 annotation 包,用于存放自定义注解 Component 注解表示该类为组件类,并需要声明名字 package priv.haidnor.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy;

基于Spring中各个jar包的作用及依赖(详解)

先附spring各版本jar包下载链接http://repo.spring.io/release/org/springframework/spring/ spring.jar 是包含有完整发布模块的单个jar 包.但是不包括mock.jar, aspects.jar, spring-portlet.jar, and spring-hibernate2.jar 示例图片为Spring-2.5.6.jar的包目录 下面讲解各个jar包的作用: 1.org.springframework.aop或sp

Spring加载properties文件的两种方式实例详解

在项目中如果有些参数经常需要修改,或者后期可能需要修改,那我们最好把这些参数放到properties文件中,源代码中读取properties里面的配置,这样后期只需要改动properties文件即可,不需要修改源代码,这样更加方便.在Spring中也可以这么做,而且Spring有两种加载properties文件的方式:基于xml方式和基于注解方式.下面分别讨论下这两种方式. 1. 通过xml方式加载properties文件 我们以Spring实例化dataSource为例,我们一般会在beans

基于spring boot 1.5.4 集成 jpa+hibernate+jdbcTemplate(详解)

1.pom添加依赖 <!-- spring data jpa,会注入tomcat jdbc pool/hibernate等 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <