Spring/SpringBoot--ApplicationContext--使用/用法/介绍/原理

曾经终败给现在 2022-09-12 12:46 176阅读 0赞

原文网址：[Spring/SpringBoot--ApplicationContext--使用/用法/介绍/原理\_IT利刃出鞘的博客-CSDN博客][Spring_SpringBoot--ApplicationContext--_IT_-CSDN]

# **BeanFactory与ApplicationContext的区别** #

> **其他网址**
> 
> [BeanFactory和ApplicationContext的区别\_Java\_pythias\_的博客-CSDN博客][BeanFactory_ApplicationContext_Java_pythias_-CSDN]

> **类图**
> 
> ![70][]
> 
> <table> 
> <tbody> 
> <tr> 
> <td> 项 </td> 
> <td> BeanFactory </td> 
> <td> ApplicationContext </td> 
> </tr> 
> <tr> 
> <td> 说明 </td> 
> <td> 最顶层接口，只提供实例化对象和取对象功能。 主要是getBean()方法。 </td> 
> <td> 继承BeanFactory接口，它是Spring更高级的容器，有很多有用的功能。 1) 国际化（MessageSource） 2) 访问资源（ResourceLoader）。如：URL和文件 3) 载入多个（有继承关系）上下文 ，使得每一个上下文都专注于一个特定的层次。比如应用的web层 &nbsp; 4) 消息发送、响应机制（ApplicationEventPublisher） 5) AOP（拦截器） </td> 
> </tr> 
> <tr> 
> <td> 使用者 </td> 
> <td> 使用者是Spring本身。 </td> 
> <td> 适合Spring的用户使用。不推荐直接用BeanFactory。 </td> 
> </tr> 
> <tr> 
> <td> 装载bean </td> 
> <td> 是延迟初始化的：启动时不实例化Bean，从容器中取Bean时才实例化。 延迟实例化的优点：（BeanFactory） 应用启动的时候占用资源很少；对资源要求较高的应用，比较有优势； </td> 
> <td> 非延迟初始化（启动时实例化所有的Bean）。也可为Bean配置lazy-init=true来让Bean延迟初始化(实例化)。 不延迟实例化的优点： （ApplicationContext） 1. 所有的Bean在启动的时候都加载，系统运行的速度快；&nbsp; 2. 在启动的时候所有的Bean都加载了，我们就能在系统启动的时候，尽早的发现系统中的配置问题&nbsp; 3. 建议web应用，在启动的时候就把所有的Bean都加载了。（把费时的操作放到系统启动中完成）&nbsp; </td> 
> </tr> 
> </tbody> 
> </table>

# 包装为工具 #

可包装一下，这样，需要获得ApplicationContext的类本身就不需要加入Spring容器、也不需要实现ApplicationContextAware了。

import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
     
    @Component
    public class ApplicationContextHolder implements ApplicationContextAware {
        private static ApplicationContext context;
     
        @Override
        public void setApplicationContext(ApplicationContext context) throws BeansException {
            ApplicationContextHolder.context = context;
        }
     
        public static ApplicationContext getContext() {
            return context;
        }
    }

**用法**

> **1.根据class获得bean**
> 
> Xxx xxx = ApplicationContextHolder.getContext().getBean(Xxx.class);
> 
> **2.根据名字获得代理后的bean（常用）**
> 
> Xxx xxx = ApplicationContextHolder.getContext().getBean("userService");
> 
> **3.根据名字获得未代理的bean（即FactoryBean）（不常用）**
> 
> Xxx xxx = ApplicationContextHolder.getContext().getBean("&userService");

# **getBean()与@Autowired异同** #

**ApplicationContext\#getBean()与@Autowired异同**

> <table> 
> <tbody> 
> <tr> 
> <td>项</td> 
> <td>@Autowired</td> 
> <td>getBean()</td> 
> </tr> 
> <tr> 
> <td>单例与多例</td> 
> <td> 默认是单例。 就算是将bean加注解改为多例，此时注入仍为单例。 </td> 
> <td> 默认是单例。 但可将bean加注解改为多例，此时getBean()获取即为多例。 </td> 
> </tr> 
> <tr> 
> <td>范围</td> 
> <td>能获得的bean范围大于getBean()的</td> 
> <td>少于@Autowired的</td> 
> </tr> 
> </tbody> 
> </table>

## 单例与多例 ##

注意：这里可能是因为@Controller注入比较特殊，只有这时将bean加注解改为多例，此时注入仍为单例。不过还需要验证。

### **@Autowired实例** ###

>     package com.example.controller;
>     
>     import com.example.service.UserService;
>     import org.springframework.beans.factory.annotation.Autowired;
>     import org.springframework.web.bind.annotation.GetMapping;
>     import org.springframework.web.bind.annotation.RequestMapping;
>     import org.springframework.web.bind.annotation.RestController;
>     
>     @RestController
>     @RequestMapping("/hello")
>     public class HelloController {
>         @Autowired
>         private UserService userService;
>     
>         @GetMapping("/test1")
>         public String test1() {
>             return userService.toString();
>         }
>     
>         @GetMapping("/test2")
>         public String test2() {
>             return userService.toString();
>         }
>     }
> 
>     package com.example.service;
>     
>     import org.springframework.stereotype.Component;
>     
>     @Component
>     public class UserService {
>     }
> 
> **测试**（都是单例的）
> 
> [http://localhost:8080/test1][http_localhost_8080_test1] 结果：com.example.service.UserService@27a70937  
> [http://localhost:8080/test2][http_localhost_8080_test2] 结果：com.example.service.UserService@27a70937  
> 再次[http://localhost:8080/test2][http_localhost_8080_test2] 结果：com.example.service.UserService@27a70937
> 
> **将UserService改为多例**
> 
>     package com.example.service;
>     
>     import org.springframework.beans.factory.config.ConfigurableBeanFactory;
>     import org.springframework.context.annotation.Scope;
>     import org.springframework.stereotype.Component;
>     
>     @Component
>     @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
>     public class UserService {
>     }
> 
> **测试**（还是单例的）
> 
> [http://localhost:8080/test1][http_localhost_8080_test1] 结果：com.example.service.UserService@12d4c297  
> [http://localhost:8080/test2][http_localhost_8080_test2] 结果：com.example.service.UserService@12d4c297  
> 再次[http://localhost:8080/test2][http_localhost_8080_test2] 结果：com.example.service.UserService@12d4c297

### **ApplicationContext实例** ###

>     package com.example.controller;
>     
>     import com.example.service.UserService;
>     import org.springframework.beans.BeansException;
>     import org.springframework.context.ApplicationContext;
>     import org.springframework.context.ApplicationContextAware;
>     import org.springframework.web.bind.annotation.GetMapping;
>     import org.springframework.web.bind.annotation.RestController;
>     
>     @RestController
>     public class HelloController implements ApplicationContextAware {
>         private ApplicationContext applicationContext;
>     
>         @GetMapping("/test1")
>         public String test1() {
>             UserService userService = applicationContext.getBean(UserService.class);
>             return userService.toString();
>         }
>     
>         @GetMapping("/test2")
>         public String test2() {
>             UserService userService = applicationContext.getBean(UserService.class);
>             return userService.toString();
>         }
>     
>         @Override
>         public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
>             this.applicationContext = applicationContext;
>         }
>     }
> 
>     package com.example.service;
>     
>     import org.springframework.stereotype.Component;
>     
>     @Component
>     public class UserService {
>     }
> 
> **测试**（都是单例的）
> 
> [http://localhost:8080/test1][http_localhost_8080_test1] 结果：com.example.service.UserService@27a70937  
> [http://localhost:8080/test2][http_localhost_8080_test2] 结果：com.example.service.UserService@27a70937  
> 再次[http://localhost:8080/test2][http_localhost_8080_test2] 结果：com.example.service.UserService@27a70937
> 
>     package com.example.service;
>     
>     import org.springframework.beans.factory.config.ConfigurableBeanFactory;
>     import org.springframework.context.annotation.Scope;
>     import org.springframework.stereotype.Component;
>     
>     @Component
>     @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
>     public class UserService {
>     }
> 
> **将UserService改为多例**
> 
>     package com.example.service;
>     
>     import org.springframework.beans.factory.config.ConfigurableBeanFactory;
>     import org.springframework.context.annotation.Scope;
>     import org.springframework.stereotype.Component;
>     
>     @Component
>     @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
>     public class UserService {
>     }
> 
> **测试（是多例了）**
> 
> [http://localhost:8080/test1][http_localhost_8080_test1] 结果：com.example.service.UserService@393b1c  
> [http://localhost:8080/test2][http_localhost_8080_test2] 结果：com.example.service.UserService@23c2e5c2  
> 再次[http://localhost:8080/test2][http_localhost_8080_test2] 结果：com.example.service.UserService@5e743c55

## 范围 ##

**其他网址**

> [踩坑了！使用 @Autowired 注入成功，GetBean 方法却获取不到？！][_Autowired _GetBean]

**结论**

> @Autowired能获得的bean范围大于ApplicationContext.getBean()的 。

### **问题复现** ###

> 假设，想在Controller中直接使用Spring的事件发布器，当然，我们可以自己定义发布器。但其实可以直接从容器获取默认的。
> 
> 本处使用@Autowired是可以注入的，但使用ApplicationContext.getBean()就不可以。

> **@Autowired注入的方式**
> 
>     package com.example.controller;
>     
>     import org.springframework.beans.factory.annotation.Autowired;
>     import org.springframework.context.ApplicationEventPublisher;
>     import org.springframework.web.bind.annotation.GetMapping;
>     import org.springframework.web.bind.annotation.RestController;
>     
>     @RestController
>     public class HelloController {
>         @Autowired
>         ApplicationEventPublisher applicationEventPublisher;
>     
>         @GetMapping("/test1")
>         public String test1() {
>             System.out.println(applicationEventPublisher);
>             return "test1 success";
>         }
>     }
> 
> 访问：[http://localhost:8080/test1][http_localhost_8080_test1]
> 
> 结果（成功注入）
> 
>     org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@5bf0fe62, started on Thu Mar 18 19:10:33 CST 2021

> **ApplicationContext.getBean()方式**
> 
>     package com.example.controller;
>     
>     import org.springframework.beans.BeansException;
>     import org.springframework.context.ApplicationContext;
>     import org.springframework.context.ApplicationContextAware;
>     import org.springframework.context.ApplicationEventPublisher;
>     import org.springframework.web.bind.annotation.GetMapping;
>     import org.springframework.web.bind.annotation.RestController;
>     
>     @RestController
>     public class HelloController implements ApplicationContextAware {
>         private ApplicationEventPublisher applicationEventPublisher;
>     
>         @GetMapping("/test1")
>         public String test1() {
>             System.out.println(applicationEventPublisher);
>             return "test1 success";
>         }
>     
>         @Override
>         public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
>             applicationEventPublisher = applicationContext.getBean(ApplicationEventPublisher.class);
>         }
>     }
> 
> 启动时就报错（找不到这个bean）
> 
>     Description:
>     
>     A component required a bean of type 'org.springframework.context.ApplicationEventPublisher' that could not be found.
>     
>     
>     Action:
>     
>     Consider defining a bean of type 'org.springframework.context.ApplicationEventPublisher' in your configuration.

### 原因初探 ###

> refresh()// AbstractApplicationContext 
> prepareBeanFactory //AbstractApplicationContext 
> beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); 
> beanFactory.registerResolvableDependency(ResourceLoader.class, this); 
> beanFactory.registerResolvableDependency(**ApplicationEventPublisher**.class, this); 
> beanFactory.registerResolvableDependency(ApplicationContext.class, this); 
> // DefaultListableBeanFactory类（实现了ConfigurableListableBeanFactory接口） 
> registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue) 
> resolvableDependencies.put(dependencyType, autowiredValue); //DefaultListableBeanFactory类 
> 
> private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);

> 一些特殊实例对象是存放在DefaultListableBeanFactory\#resolvableDependencies变量中的，在容器启动时，如果发现需要注入这些特定的实例对象，就直接在该变量中获取。通过BeanFactory\#getBean方法不会去DefaultListableBeanFactory\#resolvableDependencies取，所以取不到它。
> 
> 处理注入的代码：findAutowireCandidates //DefaultListableBeanFactory.java
> 
> for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
> Class<?> autowiringType = classObjectEntry.getKey();
> if (autowiringType.isAssignableFrom(requiredType)) {
> Object autowiringValue = classObjectEntry.getValue();
> autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
> if (requiredType.isInstance(autowiringValue)) {
> result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
> break;
> }
> }
> }

**编写程序复现**

>     package com.example.tmp;
>     
>     import org.springframework.beans.BeansException;
>     import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
>     import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
>     import org.springframework.stereotype.Component;
>     
>     @Component
>     public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
>         @Override
>         public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
>             beanFactory.registerResolvableDependency(MyBean.class, new MyBean());
>         }
>     }
> 
>     package com.example.tmp;
>     
>     public class MyBean {
>     }
> 
> **使用@Autowired注入**
> 
>     package com.example.controller;
>     
>     import com.example.tmp.MyBean;
>     import org.springframework.beans.factory.annotation.Autowired;
>     import org.springframework.web.bind.annotation.GetMapping;
>     import org.springframework.web.bind.annotation.RestController;
>     
>     @RestController
>     public class HelloController {
>         @Autowired
>         private MyBean myBean;
>     
>         @GetMapping("/test1")
>         public String test1() {
>             System.out.println(myBean);
>             return "test1 success";
>         }
>     
>     }
> 
> 访问：[http://localhost:8080/test1][http_localhost_8080_test1]
> 
> 后台结果（成功注入）
> 
>     com.example.tmp.MyBean@f08fdce
> 
> **使用ApplicationContext\#getBean()** 
> 
>     package com.example.controller;
>     
>     import com.example.tmp.MyBean;
>     import org.springframework.beans.BeansException;
>     import org.springframework.context.ApplicationContext;
>     import org.springframework.context.ApplicationContextAware;
>     import org.springframework.web.bind.annotation.GetMapping;
>     import org.springframework.web.bind.annotation.RestController;
>     
>     @RestController
>     public class HelloController implements ApplicationContextAware {
>         private MyBean myBean;
>     
>         @GetMapping("/test1")
>         public String test1() {
>             System.out.println(myBean);
>             return "test1 success";
>         }
>     
>         @Override
>         public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
>             myBean = applicationContext.getBean(MyBean.class);
>         }
>     }
> 
> 启动即报错（无法获得bean）
> 
>     Description:
>     
>     A component required a bean of type 'com.example.tmp.MyBean' that could not be found.
>     
>     
>     Action:
>     
>     Consider defining a bean of type 'com.example.tmp.MyBean' in your configuration.

### 源码追踪 ###

**追踪1：追踪“编写程序复现”的getBean**

> getBean(MyBean.class) 
> getBeanFactory().getBean(requiredType) //AbstractApplicationContext.class 
> getBean(Class<T> requiredType) //DefaultListableBeanFactory.java
> 
> 下边的程序都是DefaultListableBeanFactory中的
> 
> getBean(Class<T> requiredType) 
> getBean(requiredType, (Object\[\]) null) 
> resolveBean(ResolvableType.forRawClass(requiredType), args, false) 
> resolveNamedBean(requiredType, args, nonUniqueAsNull) 
> getBeanNamesForType(requiredType); 
> getBeanNamesForType(type, true, true) 
> getBeanNamesForType(resolved, includeNonSingletons, allowEagerInit) 
> resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);

**追踪2：正常的bean通过ApplicationContext.getBean()获取**

> 把上边的程序稍微改造：
> 
> package com.example.tmp;
> 
> import org.springframework.stereotype.Component;
> 
> @Component
> public class MyBean {
> }
> 
> package com.example.controller;
> 
> import com.example.tmp.MyBean;
> import org.springframework.beans.BeansException;
> import org.springframework.context.ApplicationContext;
> import org.springframework.context.ApplicationContextAware;
> import org.springframework.web.bind.annotation.GetMapping;
> import org.springframework.web.bind.annotation.RestController;
> 
> @RestController
> public class HelloController implements ApplicationContextAware {
> private MyBean myBean;
> 
> @GetMapping("/test1")
> public String test1() {
> System.out.println(myBean);
> return "test1 success";
> }
> 
> @Override
> public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
> myBean = applicationContext.getBean(MyBean.class);
> }
> }
> 
> 追踪它，跟上边一样的，也是追踪到了DefaultListableBeanFactory\#getBeanNamesForType(resolved, includeNonSingletons, allowEagerInit)，但这是数据有所变化
> 
> public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
> if (!isConfigurationFrozen() || type == null || !allowEagerInit) {
> return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);
> }
> // includeNonSingletons为true，会使用this.allBeanNamesByType
> //此时，cache一项都没有
> Map<Class<?>, String[]> cache =
> (includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType);
> // type：“class com.example.tmp.MyBean”，此步resolvedBeanNames为null
> String[] resolvedBeanNames = cache.get(type);
> // 此判断为false，不会进入
> if (resolvedBeanNames != null) {
> return resolvedBeanNames;
> }
> //通过type获得bean的名字。结果为：myBean
> resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);
> if (ClassUtils.isCacheSafe(type, getBeanClassLoader())) {
> cache.put(type, resolvedBeanNames);
> }
> return resolvedBeanNames;
> }
> 
> 与“**追踪1：追踪“编写程序复现”的getBean**”的区别在于：doGetBeanNamesForType获取到了bean的名字（也就是说，找到了bean）

> **总体流程**
> 
> getBean(Class<T> requiredType) 
> getBean(requiredType, (Object\[\]) null) 
> resolveBean(ResolvableType.forRawClass(requiredType), args, false) 
> // namedBean有两个属性：beanName(String类型)，beanInstance(泛型，实例对象) 
> NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args, nonUniqueAsNull) 
> String\[\] candidateNames = getBeanNamesForType(requiredType); 
> getBeanNamesForType(type, true, true) 
> getBeanNamesForType(resolved, includeNonSingletons, allowEagerInit) 
> resolvedBeanNames = **doGetBeanNamesForType**(ResolvableType.forRawClass(type), includeNonSingletons, true); 
> // 调用到AbstractBeanFactory\#getBean 
> return new NamedBeanHolder<>(beanName, (T) getBean(beanName, requiredType.toClass(), args)); 
> // 获得MyBean实例对象 
> namedBean.getBeanInstance();

# 获得有某个注解的所有bean #

**其他网址**

> [Spring 获取自定义注解所有类\_wochunyang的专栏-CSDN博客\_spring 获取类注解][Spring _wochunyang_-CSDN_spring]  
> [java中借助Spring获取所有带有指定注解的接口、类、对象-续集\_Lvbey的博客-CSDN博客\_java获取包含某一注解的所有类][java_Spring_-_Lvbey_-CSDN_java]

[Spring_SpringBoot--ApplicationContext--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/120468360
[BeanFactory_ApplicationContext_Java_pythias_-CSDN]: https://blog.csdn.net/pythias_/article/details/82752881
[70]: /images/20220828/74349d6fc33e4904ab3f5e596d70bff3.png
[http_localhost_8080_test1]: http://localhost:8080/test1
[http_localhost_8080_test2]: http://localhost:8080/test2
[_Autowired _GetBean]: https://juejin.im/post/6844903971341991950
[Spring _wochunyang_-CSDN_spring]: https://blog.csdn.net/wochunyang/article/details/91355797
[java_Spring_-_Lvbey_-CSDN_java]: https://blog.csdn.net/Lvbey/article/details/53230978