SpringBoot怎么从容器中获取对象(springboot,开发技术)

希望大家仔细阅读，能够学有所成！

如何从容器中获取对象

有时候在项目中，我们会自己创建一些类，类中需要使用到容器中的一些类。方法是新建类并实现ApplicationContextAware 接口，在类中建立静态对象 ApplicationContext 对象，这个对象就如同xml配置中的 applicationContext.xml，容器中类都可以获取到。

例如@Service、 @Component、@Repository、@Controller 、@Bean 标注的类都能获取到。

/
功能描述：SpringBean管理类

*/
@Component
publicclassSpringContextUtilsimplementsApplicationContextAware{
/
上下文对象实例
/
privatestaticApplicationContextapplicationContext;
@Override
publicvoidsetApplicationContext(ApplicationContextapplicationContext)throwsBeansException{
this.applicationContext=applicationContext;
}
/
获取applicationContext

@return
/
publicstaticApplicationContextgetApplicationContext(){
returnapplicationContext;
}
/*
通过name获取Bean.

@paramname
@return
/
publicstaticObjectgetBean(Stringname){
returngetApplicationContext().getBean(name);
}
/
通过class获取Bean.

@paramclazz
@param<T>
@return
/
publicstatic<T>TgetBean(Class<T>clazz){
try{
returngetApplicationContext().getBean(clazz);
}catch(Exceptione){
returnnull;
}
}
/*
通过name,以及Clazz返回指定的Bean

@paramname
@paramclazz
@param<T>
@return
/
publicstatic<T>TgetBean(Stringname,Class<T>clazz){
returngetApplicationContext().getBean(name,clazz);
}
}/pre><h3>SpringBoot中的容器</h3><h4>容器功能</h4><h5>1、组件添加</h5><p><strong>（1）主要注解</strong></p><p><code>@Configuration</code
告诉SpringBoot这是一个配置类 == 配置文件/p><p>注意：spring5.2以后@Configuration多了一个属性proxyBeanMethods，默认为true</p
@Configuration(proxyBeanMethods=true)
proxyBeanMethods：代理bean的方法
Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】 外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
Lite(proxyBeanMethods = false)/code>【每个@Bean方法被调用多少次返回的组件都是新创建的】</p
组件依赖必须使用Full模式默认。其他默认是否Lite模式
● Full模式与Lite模式
○ 最佳实战
■ 配置 类组件之间无依赖关系用Lite模式加速容器启动过程，减少判断
■ 配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式/p><p>@Bean</p
li><p>给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例</p></li><li><p>配置类里面使用@Bean标注在方法上给容器注册组件，默认是单实例的</p
配置类本身也是组件
（2） 基本使用
bean包：
Pet类：
/*
宠物
/
publicclassPet{
privateStringname;
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicPet(Stringname){
this.name=name;
}
publicPet(){
}
@Override
publicStringtoString(){
return"Pet{"+
"name='"+name+'\''+
'}';
}
}
User类：
/
用户
/
publicclassUser{
privateStringname;
privateIntegerage;
publicUser(){
}
publicUser(Stringname,Integerage){
this.name=name;
this.age=age;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicIntegergetAge(){
returnage;
}
publicvoidsetAge(Integerage){
this.age=age;
}
@Override
publicStringtoString(){
return"User{"+
"name='"+name+'\''+
",age="+age+
'}';
}
}
config包：
MyConfig类
@Configuration(proxyBeanMethods=false)//告诉Spring这是一个配置类
publicclassMyConfig{
@Bean//给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
publicUseruser01(){
returnnewUser("zhangsan",18);
}
@Bean("tom")
publicPettomcatPet(){
returnnewPet("tomcat");
}
}
controller包：
MainApplication类
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com")
publicclassMainApplication{
publicstaticvoidmain(String[]args){
//1、返回我们IOC容器
ConfigurableApplicationContextrun=SpringApplication.run(MainApplication.class,args);
//2、查看容器里面的组件
String[]names=run.getBeanDefinitionNames();
for(Stringname:names){
System.out.println(name);
}
//3、从容器中获取组件
MyConfigbean=run.getBean(MyConfig.class);
System.out.println(bean);
//如果@Configuration(proxyBeanMethods=true)代理对象调用方法。SpringBoot总会检查这个组件是否在容器中有。
//保持组件单实例
Useruser=bean.user01();
Useruser1=bean.user01();
System.out.println("组件为："+(user==user1));
}
}
结果
（3）补充 @Import
给容器导入一个组件
必须写在容器中的组件上
@Import({User.class,DBHelper.class})
给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名



*/
@Import({User.class,DBHelper.class})
@Configuration(proxyBeanMethods=false)//告诉SpringBoot这是一个配置类==配置文件
publicclassMyConfig{
}/pre><p>@Configuration测试代码如下</p
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com")
publicclassMainApplication{
publicstaticvoidmain(String[]args){
//1、返回我们IOC容器
ConfigurableApplicationContextrun=SpringApplication.run(MainApplication.class,args);
//2、查看容器里面的组件
String[]names=run.getBeanDefinitionNames();
for(Stringname:names){
System.out.println(name);
}
//3、从容器中获取组件
MyConfigbean=run.getBean(MyConfig.class);
System.out.println(bean);
//如果@Configuration(proxyBeanMethods=true)代理对象调用方法。SpringBoot总会检查这个组件是否在容器中有。
//保持组件单实例
Useruser=bean.user01();
Useruser1=bean.user01();
System.out.println("组件为："+(user==user1));
//5、获取组件
String[]beanNamesForType=run.getBeanNamesForType(User.class);
System.out.println("======");
for(Strings:beanNamesForType){
System.out.println(s);
}
DBHelperbean1=run.getBean(DBHelper.class);
System.out.println(bean1);
}
}
/p><p>@Conditional</p
条件装配：满足Conditional指定的条件，则进行组件注入
ConditionalOnBean：当容器中存在指定的bean组件时才干某些事情
ConditionalOnMissingBean：当容器中不存在指定的bean组件时才干某些事情
ConditionalOnClass：当容器中有某个类时才干某些事情
ConditionalOnResource：当项目的类路径存在某个资源时，才干什么事
=====================测试条件装配==========================
@Configuration(proxyBeanMethods=false)//告诉SpringBoot这是一个配置类==配置文件
//@ConditionalOnBean(name="tom")
@ConditionalOnMissingBean(name="tom")
publicclassMyConfig{
@Bean//给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
publicUseruser01(){
Userzhangsan=newUser("zhangsan",18);
//user组件依赖了Pet组件
zhangsan.setPet(tomcatPet());
returnzhangsan;
}
@Bean("tom22")
publicPettomcatPet(){
returnnewPet("tomcat");
}
}
测试：
publicstaticvoidmain(String[]args){
//1、返回我们IOC容器
ConfigurableApplicationContextrun=SpringApplication.run(MainApplication.class,args);
//2、查看容器里面的组件
String[]names=run.getBeanDefinitionNames();
for(Stringname:names){
System.out.println(name);
}
booleantom=run.containsBean("tom");
System.out.println("容器中Tom组件："+tom);
booleanuser01=run.containsBean("user01");
System.out.println("容器中user01组件："+user01);
booleantom22=run.containsBean("tom22");
System.out.println("容器中tom22组件："+tom22);
}
/p><h5>2、原生配置文件引入（xml文件引入）</h5><p>@ImportResource</p
导入资源
@ImportResource("classpath:beans.xml")//导入spring的配置文件
@Import({User.class,DBHelper.class})
@Configuration(proxyBeanMethods=false)//告诉Spring这是一个配置类
@ConditionalOnMissingBean(name="tom")
publicclassMyConfig{
======================beans.xml=========================
<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans&quot;
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance&quot;
xmlns:context="http://www.springframework.org/schema/context&quot;
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsd&quot;&gt;
<beanid="haha"class="com.atguigu.boot.bean.User">
<propertyname="name"value="zhangsan"></property>
<propertyname="age"value="18"></property>
</bean>
<beanid="hehe"class="com.atguigu.boot.bean.Pet">
<propertyname="name"value="tomcat"></property>
</bean>
</beans>
测试
======================测试=================
booleanhaha=run.containsBean("haha");
booleanhehe=run.containsBean("hehe");
System.out.println("haha："+haha);//true
System.out.println("hehe："+hehe);//true
3、配置绑定
如何使用Java读取到properties文件中的内容，并且把它封装到JavaBean中，以供随时使用；
(1) @Component + @ConfigurationProperties
properties文件
/*
只有在容器中的组件，才会拥有SpringBoot提供的强大功能
*/
@Component
@ConfigurationProperties(prefix="mycar")
publicclassCar{
privateStringbrand;
privateIntegerprice;
publicStringgetBrand(){
returnbrand;
}
publicvoidsetBrand(Stringbrand){
this.brand=brand;
}
publicIntegergetPrice(){
returnprice;
}
publicvoidsetPrice(Integerprice){
this.price=price;
}
@Override
publicStringtoString(){
return"Car{"+
"brand='"+brand+'\''+
",price="+price+
'}';
}
}
(2) @EnableConfigurationProperties + @ConfigurationProperties
@Configuration(proxyBeanMethods=false)//告诉SpringBoot这是一个配置类==配置文件
@ConditionalOnMissingBean(name="tom")
@ImportResource("classpath:beans.xml")
//@EnableConfigurationProperties(Car.class)
//1、开启Car配置绑定功能
//2、把这个Car这个组件自动注册到容器中
publicclassMyConfig{
 
本文：SpringBoot怎么从容器中获取对象的详细内容，希望对您有所帮助，信息来源于网络。