SpringBoot怎么从容器中获取对象

目录

1. 引言
2. Spring容器概述
   • 2.1 Spring容器的概念
   • 2.2 Spring容器的类型
   • 2.3 Spring容器的生命周期
3. SpringBoot中的容器管理
   • 3.1 SpringBoot的自动配置
   • 3.2 SpringBoot的依赖注入
   • 3.3 SpringBoot的Bean管理
4. 从容器中获取对象的方式
   • 4.1 使用@Autowired注解
   • 4.2 使用@Resource注解
   • 4.3 使用@Inject注解
   • 4.4 使用ApplicationContext
   • 4.5 使用BeanFactory
   • 4.6 使用@Configuration和@Bean
   • 4.7 使用@Import注解
   • 4.8 使用@Conditional注解
5. SpringBoot中的Bean作用域
   • 5.1 Singleton作用域
   • 5.2 Prototype作用域
   • 5.3 Request作用域
   • 5.4 Session作用域
   • 5.5 Application作用域
   • 5.6 WebSocket作用域
6. SpringBoot中的Bean生命周期
   • 6.1 Bean的初始化
   • 6.2 Bean的销毁
   • 6.3 Bean的后置处理器
7. SpringBoot中的Bean依赖注入
   • 7.1 构造器注入
   • 7.2 Setter注入
   • 7.3 字段注入
   • 7.4 方法注入
8. SpringBoot中的Bean条件化配置
   • 8.1 @ConditionalOnClass
   • 8.2 @ConditionalOnMissingClass
   • 8.3 @ConditionalOnBean
   • 8.4 @ConditionalOnMissingBean
   • 8.5 @ConditionalOnProperty
   • 8.6 @ConditionalOnExpression
9. SpringBoot中的Bean懒加载
   • 9.1 懒加载的概念
   • 9.2 懒加载的配置
   • 9.3 懒加载的优缺点
10. SpringBoot中的Bean循环依赖
    • 10.1 循环依赖的概念
    • 10.2 循环依赖的解决方案
    • 10.3 循环依赖的注意事项
11. SpringBoot中的Bean代理
    • 11.1 JDK动态代理
    • 11.2 CGLIB代理
    • 11.3 代理的选择
12. SpringBoot中的Bean自定义初始化
    • 12.1 使用@PostConstruct注解
    • 12.2 使用InitializingBean接口
    • 12.3 使用@Bean的initMethod属性
13. SpringBoot中的Bean自定义销毁
    • 13.1 使用@PreDestroy注解
    • 13.2 使用DisposableBean接口
    • 13.3 使用@Bean的destroyMethod属性
14. SpringBoot中的Bean自定义作用域
    • 14.1 自定义作用域的实现
    • 14.2 自定义作用域的注册
    • 14.3 自定义作用域的使用
15. SpringBoot中的Bean自定义注解
    • 15.1 自定义注解的定义
    • 15.2 自定义注解的使用
    • 15.3 自定义注解的解析
16. SpringBoot中的Bean自定义配置
    • 16.1 自定义配置类的定义
    • 16.2 自定义配置类的使用
    • 16.3 自定义配置类的扩展
17. SpringBoot中的Bean自定义依赖注入
    • 17.1 自定义依赖注入的实现
    • 17.2 自定义依赖注入的注册
    • 17.3 自定义依赖注入的使用
18. SpringBoot中的Bean自定义生命周期
    • 18.1 自定义生命周期的实现
    • 18.2 自定义生命周期的注册
    • 18.3 自定义生命周期的使用
19. SpringBoot中的Bean自定义代理
    • 19.1 自定义代理的实现
    • 19.2 自定义代理的注册
    • 19.3 自定义代理的使用
20. SpringBoot中的Bean自定义条件化配置
    • 20.1 自定义条件化配置的实现
    • 20.2 自定义条件化配置的注册
    • 20.3 自定义条件化配置的使用
21. SpringBoot中的Bean自定义懒加载
    • 21.1 自定义懒加载的实现
    • 21.2 自定义懒加载的注册
    • 21.3 自定义懒加载的使用
22. SpringBoot中的Bean自定义循环依赖
    • 22.1 自定义循环依赖的实现
    • 22.2 自定义循环依赖的注册
    • 22.3 自定义循环依赖的使用
23. SpringBoot中的Bean自定义初始化
    • 23.1 自定义初始化的实现
    • 23.2 自定义初始化的注册
    • 23.3 自定义初始化的使用
24. SpringBoot中的Bean自定义销毁
    • 24.1 自定义销毁的实现
    • 24.2 自定义销毁的注册
    • 24.3 自定义销毁的使用
25. SpringBoot中的Bean自定义作用域
    • 25.1 自定义作用域的实现
    • 25.2 自定义作用域的注册
    • 25.3 自定义作用域的使用
26. SpringBoot中的Bean自定义注解
    • 26.1 自定义注解的定义
    • 26.2 自定义注解的使用
    • 26.3 自定义注解的解析
27. SpringBoot中的Bean自定义配置
    • 27.1 自定义配置类的定义
    • 27.2 自定义配置类的使用
    • 27.3 自定义配置类的扩展
28. SpringBoot中的Bean自定义依赖注入
    • 28.1 自定义依赖注入的实现
    • 28.2 自定义依赖注入的注册
    • 28.3 自定义依赖注入的使用
29. SpringBoot中的Bean自定义生命周期
    • 29.1 自定义生命周期的实现
    • 29.2 自定义生命周期的注册
    • 29.3 自定义生命周期的使用
30. SpringBoot中的Bean自定义代理
    • 30.1 自定义代理的实现
    • 30.2 自定义代理的注册
    • 30.3 自定义代理的使用
31. SpringBoot中的Bean自定义条件化配置
    • 31.1 自定义条件化配置的实现
    • 31.2 自定义条件化配置的注册
    • 31.3 自定义条件化配置的使用
32. SpringBoot中的Bean自定义懒加载
    • 32.1 自定义懒加载的实现
    • 32.2 自定义懒加载的注册
    • 32.3 自定义懒加载的使用
33. SpringBoot中的Bean自定义循环依赖
    • 33.1 自定义循环依赖的实现
    • 33.2 自定义循环依赖的注册
    • 33.3 自定义循环依赖的使用
34. SpringBoot中的Bean自定义初始化
    • 34.1 自定义初始化的实现
    • 34.2 自定义初始化的注册
    • 34.3 自定义初始化的使用
35. SpringBoot中的Bean自定义销毁
    • 35.1 自定义销毁的实现
    • 35.2 自定义销毁的注册
    • 35.3 自定义销毁的使用
36. SpringBoot中的Bean自定义作用域
    • 36.1 自定义作用域的实现
    • 36.2 自定义作用域的注册
    • 36.3 自定义作用域的使用
37. SpringBoot中的Bean自定义注解
    • 37.1 自定义注解的定义
    • 37.2 自定义注解的使用
    • 37.3 自定义注解的解析
38. SpringBoot中的Bean自定义配置
    • 38.1 自定义配置类的定义
    • 38.2 自定义配置类的使用
    • 38.3 自定义配置类的扩展
39. SpringBoot中的Bean自定义依赖注入
    • 39.1 自定义依赖注入的实现
    • 39.2 自定义依赖注入的注册
    • 39.3 自定义依赖注入的使用
40. SpringBoot中的Bean自定义生命周期
    • 40.1 自定义生命周期的实现
    • 40.2 自定义生命周期的注册
    • 40.3 自定义生命周期的使用
41. SpringBoot中的Bean自定义代理
    • 41.1 自定义代理的实现
    • 41.2 自定义代理的注册
    • 41.3 自定义代理的使用
42. SpringBoot中的Bean自定义条件化配置
    • 42.1 自定义条件化配置的实现
    • 42.2 自定义条件化配置的注册
    • 42.3 自定义条件化配置的使用
43. SpringBoot中的Bean自定义懒加载
    • 43.1 自定义懒加载的实现
    • 43.2 自定义懒加载的注册
    • 43.3 自定义懒加载的使用
44. SpringBoot中的Bean自定义循环依赖
    • 44.1 自定义循环依赖的实现
    • 44.2 自定义循环依赖的注册
    • 44.3 自定义循环依赖的使用
45. SpringBoot中的Bean自定义初始化
    • 45.1 自定义初始化的实现
    • 45.2 自定义初始化的注册
    • 45.3 自定义初始化的使用
46. SpringBoot中的Bean自定义销毁
    • 46.1 自定义销毁的实现
    • 46.2 自定义销毁的注册
    • 46.3 自定义销毁的使用
47. SpringBoot中的Bean自定义作用域
    • 47.1 自定义作用域的实现
    • 47.2 自定义作用域的注册
    • 47.3 自定义作用域的使用
48. SpringBoot中的Bean自定义注解
    • 48.1 自定义注解的定义
    • 48.2 自定义注解的使用
    • 48.3 自定义注解的解析
49. SpringBoot中的Bean自定义配置
    • 49.1 自定义配置类的定义
    • 49.2 自定义配置类的使用
    • 49.3 自定义配置类的扩展
50. SpringBoot中的Bean自定义依赖注入
    • 50.1 自定义依赖注入的实现
    • 50.2 自定义依赖注入的注册
    • 50.3 自定义依赖注入的使用
51. SpringBoot中的Bean自定义生命周期
    • 51.1 自定义生命周期的实现
    • 51.2 自定义生命周期的注册
    • 51.3 自定义生命周期的使用
52. SpringBoot中的Bean自定义代理
    • 52.1 自定义代理的实现
    • 52.2 自定义代理的注册
    • 52.3 自定义代理的使用
53. SpringBoot中的Bean自定义条件化配置
    • 53.1 自定义条件化配置的实现
    • 53.2 自定义条件化配置的注册
    • [53.3 自定义条件化配置的使用