文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

工作中常用到的 Spring 依赖管理技术盘点

2024-12-02 20:48

关注

Spring依赖查找专题

单一类型查找

常见用法如下所示： 

  1. Object getBean(String name) throws BeansException;  
  2. <T> T getBean(Class<T> requiredType) throws BeansException;  
  3. <T> T getBean(String name, Class<T> requiredType) throws BeansException 

ObjectProvider

随着Spring版本的升高，也开始出现了延迟查找的功能。当我们实际需要用到某个bean的时候才将其从容器中进行初始化并且提取出来。 

  1. <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);  
  2. <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType); 

Spring会返回一个ObjectProvider，当查询的时候才会触发bean的创建。

延迟查找的好处在于，如果一个bean需要注入到spring容器中，但是不希望太过早地去进行初始化，那么可以思考使用ObjectProvider的方式来进行初始化。

集合类型查找

Bean的名称查询 

  1. String[] getBeanNamesForType(@Nullable Class> type);   
  2. String[] getBeanNamesForType(@Nullable Class> type, boolean includeNonSingletons, boolean allowEagerInit);  

获取同类型Bean实例列表

  1. getBeansOfType(Class) 

按照注解去查询 

  1. String[] getBeanNamesForAnnotation(Class extends Annotation> annotationType);  
  2. Map<String, Object> getBeansWithAnnotation(Class extends Annotation> annotationType) throws BeansException;  
  3. <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType) throws NoSuchBeanDefinitionException; 

使用依赖查找时候的一些小心得：

对于判断一个bean是否存在，可以采用判断其beandefinition是否存在，一般这样不会触发其中bean的初始化操作，例如：getBeanNamesForType。反观getBeansOfType可能回触发bean的初始化

层次性的bean查找

可能大多数人在实际使用Spring容器的时候对于层次性的bean做计算并没有太多的实战尝试，这里我举个例子：

例如说A容器中包含了Bean A，如果B容器继承了A容器，那么按道理来说也应该能够获得Bean A资源，这种设计可以减少Bean的额外存储。

如果你理解了我上边所说的这个案例之后，再来看看下边的这张图可能就会有更加深入的理解了。

关于层次性的bean获取，我这里给出一个小的demo供大家学习： 

  1. package org.idea.spring.look.up.factory;  
  2. import org.springframework.beans.factory.BeanFactory;  
  3. import org.springframework.beans.factory.HierarchicalBeanFactory;  
  4. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;  
  5. import org.springframework.context.ApplicationContext;  
  6. import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
  7.   
  8. public class SpringHierarchicalLookUpDemo {  
  9.     public static void main(String[] args) {  
  10.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();  
  11.         applicationContext.register(SpringHierarchicalLookUpDemo.class);  
  12.         applicationContext.refresh();  
  13.         ParentIocContainer parentIocContainer = new ParentIocContainer();  
  14.         ApplicationContext parentApplicationContext = parentIocContainer.getAndStartApplicationContext();  
  15.         // ConfigurableListableBeanFactory -> ConfigurableBeanFactory -> HierarchicalBeanFactory  
  16.         ConfigurableListableBeanFactory configurableListableBeanFactory = applicationContext.getBeanFactory();  
  17.         System.out.println("此时的父类BeanFactory为：" + configurableListableBeanFactory.getParentBeanFactory());  
  18.         configurableListableBeanFactory.setParentBeanFactory(parentApplicationContext);  
  19.         System.out.println("此时的父类BeanFactory为：" + configurableListableBeanFactory.getParentBeanFactory());  
  20.         ParentIocContainer.ParentBean parentBean = (ParentIocContainer.ParentBean) configurableListableBeanFactory.getBean("parentBean");  
  21.         System.out.println(parentBean);  
  22.         isContainedBean(configurableListableBeanFactory, "parentBean");  
  23.         displayContainsBean(configurableListableBeanFactory, "parentBean");  
  24.     }  
  25.       
  26.     public static void isContainedBean(HierarchicalBeanFactory beanFactory, String beanName) {  
  27.         System.out.println("getBean is " + beanFactory.getBean(beanName));  
  28.         System.out.printf("contained is [%s] ,beanFactory is [%s],beanName is [%s]\n", beanFactory.containsLocalBean(beanName), beanFactory, beanName);  
  29.     }  
  30.       
  31.     private static void displayContainsBean(HierarchicalBeanFactory beanFactory, String beanName) {  
  32.         System.out.printf("contained is [%s] ,beanFactory is [%s],beanName is [%s]\n", isContainedBeanInHoldApplication(beanFactory, beanName), beanFactory, beanName);  
  33.     }  
  34.       
  35.     public static boolean isContainedBeanInHoldApplication(HierarchicalBeanFactory hierarchicalBeanFactory, String beanName) {  
  36.         BeanFactory parentBeanFactory = hierarchicalBeanFactory.getParentBeanFactory();  
  37.         if (parentBeanFactory instanceof HierarchicalBeanFactory) {  
  38.             HierarchicalBeanFactory parentHierarchicalBeanFactory = HierarchicalBeanFactory.class.cast(parentBeanFactory);  
  39.             if (isContainedBeanInHoldApplication(parentHierarchicalBeanFactory, beanName)) {  
  40.                 return true;  
  41.             }  
  42.         }  
  43.         return hierarchicalBeanFactory.containsBean(beanName);  
  44.     }  
  45. } 

对应的父类容器案例： 

  1. package org.idea.spring.look.up.factory;  
  2. import org.springframework.context.ApplicationContext;  
  3. import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
  4.   
  5. public class ParentIocContainer {  
  6.     public static AnnotationConfigApplicationContext applicationContext = null;  
  7.     class ParentBean {  
  8.         int id;  
  9.         public ParentBean(){  
  10.             System.out.println("this is no arg init");  
  11.         }  
  12.         @Override  
  13.         public String toString() {  
  14.             return "ParentBean{" +  
  15.                     "id=" + id +  
  16.                     '}';  
  17.         }  
  18.     }  
  19.     public ApplicationContext getAndStartApplicationContext(){  
  20.        applicationContext = new AnnotationConfigApplicationContext();  
  21.        applicationContext.register(ParentIocContainer.class);  
  22.        //需要支持无参构造函数  
  23.        applicationContext.registerBean("parentBean",ParentBean.class); 
  24.        applicationContext.refresh();  
  25.        return applicationContext;  
  26.     }  
  27.     public static void main(String[] args) {  
  28.         ParentIocContainer parentIocContainer = new ParentIocContainer();  
  29.         ApplicationContext applicationContext = parentIocContainer.getAndStartApplicationContext();  
  30.         String[] str = applicationContext.getBeanNamesForType(ParentBean.class);  
  31.         for (String beanName : str) {  
  32.             System.out.println(beanName);  
  33.         }  
  34.     } 
  35. } 

从这段代码中可以看出，HierarchicalBeanFactory是一种常见的层次类BeanFactory，并且当我们需要判断一个bean是否存在某个容器上下文中的时候，不妨可以试试使用BeanFacoty自带的这个方法： 

  1. org.springframework.beans.factory.HierarchicalBeanFactory#containsLocalBean  
  2.   
  3. boolean containsLocalBean(String name); 

Spring依赖注入专题

依赖注入的几种模式

手动注入模式：

自动注入的模式：

使用Autowiring的模式进行注入

常见的注入案例：

xml方式注入

例如通过xml配置文件对bean的属性进行注入： 

  1. xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.         https://www.springframework.org/schema/beans/spring-beans.xsd">  
  6.     <bean id="malePerson" class="org.idea.spring.ioc.bean.Person" >  
  7.     <property name="id" value="1">property>  
  8.     <property name="name" value="idea">property>  
  9. bean>  
  10.     <bean class="org.idea.spring.dependency.inject.setter.PersonHolder">  
  11.         <property name="person" ref="malePerson">property>  
  12.     bean>  
  13. beans> 

对应的Person对象 

  1. @Data  
  2. @AllArgsConstructor  
  3. @NoArgsConstructor  
  4. public class Person {  
  5.     Integer id;  
  6.     String name; 
  7. } 

注解的方式注入

例如加入一个@Bean的注解进行注入容器 

  1. @Bean  
  2.   public PersonHolder personHolder(Person person){  
  3.       return new PersonHolder(person);  
  4.   } 

Spring容器内部的api注入

核心是利用了BeanDefinitionBuilder进行一个beanDefinition的构建，然后将这个beanDefinition给注入到Spring容器当中，上下文在启动之后会将之前准备好的BeanDefinition机械能初始化创建。 

  1. import org.idea.spring.ioc.bean.Person;  
  2. import org.springframework.beans.factory.config.BeanDefinition;  
  3. import org.springframework.beans.factory.support.BeanDefinitionBuilder;  
  4. import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
  5. import org.springframework.context.annotation.Bean; 
  6.   
  7. public class ApiDependencyInjectDemo {  
  8.     @Bean  
  9.     public Person myPerson(){  
  10.         return new Person(1,"idea");  
  11.     }  
  12.     public static void main(String[] args) {  
  13.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();  
  14.         applicationContext.register(ApiDependencyInjectDemo.class);  
  15.         BeanDefinition personBeanDefinition = createUserBeanDefinition();  
  16.         applicationContext.registerBeanDefinition("personHolder",personBeanDefinition);  
  17.         applicationContext.refresh();  
  18.         PersonHolder personHolder = applicationContext.getBean(PersonHolder.class);  
  19.         System.out.println(personHolder.getPerson());  
  20.         applicationContext.close();  
  21.     }  
  22.     private static BeanDefinition createUserBeanDefinition() { 
  23.         BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(PersonHolder.class);  
  24.         //注意这里的add方法有多种类型，需要注意下细节点  
  25.         beanDefinitionBuilder.addPropertyReference("person","myPerson");  
  26.         return beanDefinitionBuilder.getBeanDefinition();  
  27.     }  
  28. } 

@Resource,@Autowire,@Qualifier模式注入

这两类的注入在实际使用中频率比较高：

这里有一段案例： 

  1. public class AnnotationDependencyInjectDemo {  
  2.     @Autowired  
  3.     private PersonHolder personHolder2;  
  4.     @Resource  
  5.     private PersonHolder personHolder;  
  6.     public static void main(String[] args) {  
  7.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();  
  8.         applicationContext.register(AnnotationDependencyInjectDemo.class);  
  9.         applicationContext.refresh();  
  10.         AnnotationDependencyInjectDemo annotationDependencyInjectDemo = applicationContext.getBean(AnnotationDependencyInjectDemo.class);  
  11.         System.out.println(annotationDependencyInjectDemo.personHolder);  
  12.         System.out.println(annotationDependencyInjectDemo.personHolder2);  
  13.         //这里面的两个bean都是同一个，因为bean的作用域是一致相同的  
  14.         System.out.println(annotationDependencyInjectDemo.personHolder == annotationDependencyInjectDemo.personHolder2);  
  15.         applicationContext.close();  
  16.     }  
  17.     @Bean  
  18.     public PersonHolder personHolder(){  
  19.         return new PersonHolder(new Person(1,"idea"));  
  20.     }  
  21. } 

如果出现了一个接口对应多个实现类，但是代码中使用的是@Autowire的方式进行依赖注入，此时可以通过新增@Qualifier注解的方式来实现依赖注入的效果。

单纯从实际使用来说，我个人感觉@Resource = @Autowire + @Qualifier

依赖注入和依赖查找

在常见的业务开发当中，我们可能会使用到比较多的依赖注入注解，但是在一些基础组件的开发中，我个人感觉使用依赖查找往往更加具有灵活性。

Spring内部的Bean有哪几种

自定义的bean

例如业务系统中常见的XXXXDao,XXXXService

Spring容器中初始化构建好的Bean

例如Spring容器中的Enviorment对象

Spring容器内部的一些基础服务对象

例如Spring容器内部的BeanFactory对象，这类Bean通常是无法通过getBean接口去直接获取的。

Spring中的BeanDefinition对象

上边我们有提及过到Spring内部提供了相关的Api供开发者进行灵活的依赖注入。但是当我们深入到具体细节进行分析之后，其实是可以发现BeanDefinition对象也是有不同类型差异的。

用户自定义的BeanDeinition对象例如这样一段代码： 

  1. public class ApiDependencyInjectDemo {  
  2.     @Bean  
  3.     public Person myPerson(){  
  4.         return new Person(1,"idea");  
  5.     }  
  6.     public static void main(String[] args) {  
  7.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();  
  8.         applicationContext.register(ApiDependencyInjectDemo.class);  
  9.         BeanDefinition personBeanDefinition = createUserBeanDefinition();  
  10.         applicationContext.registerBeanDefinition("personHolder",personBeanDefinition);  
  11.         applicationContext.refresh();  
  12.         PersonHolder personHolder = applicationContext.getBean(PersonHolder.class);  
  13.         System.out.println(personHolder.getPerson());  
  14.         applicationContext.close();  
  15.     }  
  16.     private static BeanDefinition createUserBeanDefinition() {  
  17.         //spring官方比较推荐的一种注入方式  
  18.         BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(PersonHolder.class);  
  19.         //注意这里的add方法有多种类型，需要注意下细节点  
  20.         beanDefinitionBuilder.addConstructorArgReference("myPerson");  
  21.         return beanDefinitionBuilder.getBeanDefinition();  
  22.     }  
  23. } 

框架内部初始化定义好的BeanDefinition对象

具体体现在Spring容器进行初始化的时候，内部的refresh函数中有个prepareBeanFactory。

点进去这个函数，对它的源代码进行深入解读之后你会发现，其实内部已经注册了一系列的BeanDefinition对象。

在容器初始化之后是否还能注册Bean？

其实是可以的，下边我通过使用BeanDefiniation的案例来和你一起分析一下： 

  1. package org.idea.spring.bean.source;  
  2. import org.springframework.beans.factory.config.BeanDefinition;  
  3. import org.springframework.beans.factory.support.BeanDefinitionBuilder;  
  4. import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
  5. import org.idea.spring.bean.beandefinitionbuilder.User;  
  6.   
  7. public class AddBeanAfterRefreshDemo {  
  8.     public static void main(String[] args) {  
  9.         AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();  
  10.         annotationConfigApplicationContext.register(AddBeanAfterRefreshDemo.class);  
  11.         annotationConfigApplicationContext.refresh();  
  12.         try {  
  13.             User user0 = annotationConfigApplicationContext.getBean(User.class);  
  14.             System.out.println("user0 is " + user0);  
  15.         } catch (Exception b) {  
  16.             b.printStackTrace();  
  17.         }  
  18.         System.out.println("启动后手动注入bean对象");  
  19.         BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(User.class);  
  20.         beanDefinitionBuilder.setScope("prototype"); 
  21.         beanDefinitionBuilder  
  22.                 .addPropertyValue("id", 2)  
  23.                 .addPropertyValue("name", "idea");  
  24.         annotationConfigApplicationContext.registerBeanDefinition("user", beanDefinitionBuilder.getBeanDefinition());  
  25.         //1)  
  26.         User user1 = (User) annotationConfigApplicationContext.getBean("user");  
  27.         BeanDefinition beanDefinition = annotationConfigApplicationContext.getBeanDefinition("user");  
  28.         System.out.println(beanDefinition.getScope());  
  29.         System.out.println(user1);  
  30.         annotationConfigApplicationContext.close();  
  31.     } 
  32. } 

注意，这里面如果将1)部分的代码调整为： 

  1. User user1 = (User) annotationConfigApplicationContext.getBean(User.class); 

则不会实现容器启动后注册了对应的bean，但是依然查询不到预期对象的效果。这是因为在Spring容器底层会有一个Map专门记录不同的beanClass类型对应不同的beanName集合，从而导致第二次查询的时候走了第一次查询时候的缓存。代码位于： 

  1. org.springframework.beans.factory.support.DefaultListableBeanFactory  
  2.   
  3.   private final Map<Class>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);  

 

来源：c知音内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

工作中常用到的 Spring 依赖管理技术盘点

后端开发Spring依赖2024-12-02

人工智能在智能建筑技术管理中的作用

后端开发智能建筑人工智能2024-11-30
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯