SpringBoot八种bean的加载方式一学就会

文章目录

@[toc]
第一种bean的加载方式-配置文件
第二种加载bean方式-注解和扫描
创建第三方的bean对象

第三种加载bean方式-不使用配置文件
扩展-bean的加载方式扩展FactoryBean<>
扩展-@ImportResource导入配置文件
扩展-proxyBeanMethods属性-产生代理对象

第四种加载bean方式-使用@Import
第五种加载bean方式-registerBean
第六种加载bean方式-实现ImportSelector接口
第七种加载bean方式-实现ImportBeanDefinitionRegistrar
第八种bean的加载方式-实现BeanDefinitionRegistryPostProcessor
实现bean的方式总结

第一种bean的加载方式-配置文件

先创建一个使用maven的spring工程

导入spring核心配置

        <dependency>



            <groupId>org.springframework</groupId>



            <artifactId>spring-context</artifactId>



            <version>5.3.9</version>



        </dependency>

创建一个类

public  class Cat {



    



}
public class Dog {



}

创建一个名为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"



       xsi:schemaLocation=



         "http://www.springframework.org/schema/beans



        http://www.springframework.org/schema/beans/spring-beans.xsd">



 



    <bean id="cat" class="com.service.Cat"/>



<bean id="dog" class="com.service.Dog"/>



 



</beans>

创建一个启动类

package com.app;



 



import com.service.Dog;



import org.springframework.context.ApplicationContext;



import org.springframework.context.support.ClassPathXmlApplicationContext;



 



public class App1 {



    public static void main(String[] args) {



        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");



        Object cat = app.getBean("cat");//根据id获取



        System.out.println(cat);



        Object dog = app.getBean(Dog.class);//根据类获取，当不唯一时会报错



        System.out.println(dog);



 



    }



}

运行结果，这样就可以得到bean的对象了

或者使用可以使用一次性获取所有bean

public class App1 {



    public static void main(String[] args) {



        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");



 



        String[] names = app.getBeanDefinitionNames();



        for (String name : names) {



            System.out.println(name);



        }



    }



}

运行结果

第二种加载bean方式-注解和扫描

使用注解，注解的作用就是替代配置文件的配置，注解有@Component @Service @Repository等

替换配置文件中的<bean id= class=…>

@Component("cat") //起的名



public class Cat {



 



}
@Component



public class Dog {



}

使用完注解还得让spring去扫描到这个注解，在配置文件中的写

<?xml version="1.0" encoding="UTF-8"?>



<beans xmlns="http://www.springframework.org/schema/beans"



       xmlns:context="http://www.springframework.org/schema/context"



       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.xsd







          http://www.springframework.org/schema/context



        http://www.springframework.org/schema/context/spring-context.xsd







">



 



<!--告诉spring扫描哪个包component导入context命名空间-->



    <context:component-scan base-package="com"/>



    



 



</beans>

运行结果

创建第三方的bean对象

先导入对应的坐标

               <dependency>



                    <groupId>com.alibaba</groupId>



                    <artifactId>druid</artifactId>



                    <version>1.1.24</version>



                </dependency>

创建一个类，返回你需要导入的对象即可，加入注解

package com.config;



 



import com.alibaba.druid.pool.DruidDataSource;



import org.springframework.context.annotation.Bean;



import org.springframework.stereotype.Component;



 



@Component



public class DBconfig {



    @Bean



    public DruidDataSource dataSource(){



        DruidDataSource ds =new DruidDataSource();



        return ds;



    }



}

运行结果

第三种加载bean方式-不使用配置文件

创建一个类代替配置文件

package com.config;



 



import org.springframework.context.annotation.ComponentScan;



import org.springframework.context.annotation.Configuration;



 



@Configuration//定义为配置类



@ComponentScan({"com.config","com.service"}) //注解扫描包



public class springConfig {



}

运行类也得修改

package com.app;



 



import com.config.springConfig;



import org.springframework.context.ApplicationContext;



import org.springframework.context.annotation.AnnotationConfigApplicationContext;



import org.springframework.context.support.ClassPathXmlApplicationContext;



 



public class App2 {



    public static void main(String[] args) {



ApplicationContext app=new AnnotationConfigApplicationContext(springConfig.class);



 



        String[] names = app.getBeanDefinitionNames();



        for (String name : names) {



            System.out.println(name);



        }



    }



}

运行结果

扩展-bean的加载方式扩展FactoryBean<>

初始化实现FactoryBean<>接口的类，实现对bean加载到容器之前的批处理操作。

实现了FactoryBean接口创建出来的对象不是本身而是里面的泛型。

创建一个类实现接口

package com.config;




import com.service.Dog;

import org.springframework.beans.factory.FactoryBean;

import org.springframework.context.annotation.Bean;

public class DogFactoryBean implements FactoryBean<Dog> {

    public Dog getObject() throws Exception 

        return new Dog();

    }

//返回对象的类型

    public Class<?> getObjectType() {
        //这里可以做一系列的初始化工作
        return Dog.class;

    }

    //是否是单例，单例则多次获取都是一个对象
    public boolean isSingleton() {

        return false;

    }

}
@Component
public class Dog {

}

启动的主类

import com.config.springConfig;

import org.springframework.context.ApplicationContext;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App2 {
    public static void main(String[] args) {
ApplicationContext app=new AnnotationConfigApplicationContext(springConfig.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {

            System.out.println(name);

        }
        System.out.println(app.getBean("dog1"));
        System.out.println(app.getBean("dog1"));
    }
}

运行结果

产生的是泛型的对象

扩展-@ImportResource导入配置文件

看源码可知道，可以写入多个string类型的数组，使用{}

@ImportResource({"applicationContext2.xml","applicationContext.xml"})
@Configuration
@ComponentScan("com")
@ImportResource({"applicationContext2.xml","applicationContext.xml"})
public class SpringConfig2 {
    @Bean
    public Cat cat(){
        return new Cat();
    }
}

两个配置文件中的bean，排在前面的首先加载，后面的之后加载，同的内容以之后的为主，不同的内容都加载。

扩展-proxyBeanMethods属性-产生代理对象

@Configuration注解中有一属性proxyBeanMethod属性，默认值是true

值为false时

@Configuration(proxyBeanMethods = false)
@ComponentScan("com")
@ImportResource({"applicationContext2.xml","applicationContext.xml"})
public class SpringConfig2 {

    @Bean

    public Cat cat(){
        return new Cat();
    }

}

主方法中

public class app3 {

    public static void main(String[] args) {

        ApplicationContext app=new AnnotationConfigApplicationContext(SpringConfig2.class);

        String[] names = app.getBeanDefinitionNames();

        for (String name : names) {

            System.out.println(name);

        }
        System.out.println("--------");

        System.out.println(app.getBean("springConfig2"))

        SpringConfig2 springConfig2 = app.getBean("springConfig2", SpringConfig2.class);
        System.out.println(springConfig2.cat());
        System.out.println(springConfig2.cat());
        System.out.println(springConfig2.cat());
    }
}

运行结果

产生的是普通对象，每一次调用方法都会new一个新的对象前提是这个方法是被bean管理的对象。

值为true时

不写或写true时

@Configuration(proxyBeanMethods = true)
@ComponentScan("com")
@ImportResource({"applicationContext2.xml","applicationContext.xml"})
public class SpringConfig2 {

    @Bean
    public Cat cat(){
        return new Cat();
    }
}

运行结果

会产生一个代理对象，这个代理对象让我们每次调用方法是都是同一个，前提也是需要被bean容器管理

注：产生的bean对象没指定名称时，默认是方法名或类名首字母小写，如类名是SpringTest则产生的bean是springTest

第四种加载bean方式-使用@Import

翻看@Import源码可知，需要一个类class字节码对象

在类中

import com.service.TestBean1;

import com.service.TestBean2;

import org.springframework.context.annotation.Import;


@Import({TestBean1.class, TestBean2.class})
public class springConfig4 {

}

创建测试的类

public class TestBean1 {
}
public class testBean2 {
}

主类上

public class app4 {

    public static void main(String[] args) {

        ApplicationContext app=new AnnotationConfigApplicationContext(springConfig4.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {

            System.out.println(name);

        }
    }

}

运行结果

全路径名，加入的类即使没有被spring管理也可以产生bean。

第五种加载bean方式-registerBean

使用上下文对象在容器初始化后注入bean

在创建完上下文对象的时候可以加载bean

只能使用 AnnotationConfigApplicationContext获取上下文对象

public class app5 {

    public static void main(String[] args) {

        AnnotationConfigApplicationContext app=new AnnotationConfigApplicationContext(springConfig5.class);
    //加载完成后

        app.registerBean("CaiDog", Dog.class,1 );

        app.registerBean("CaiDog", Dog.class,2);

        app.registerBean("CaiDog", Dog.class,3 );

        String[] names = app.getBeanDefinitionNames();

        for (String name : names) {

            System.out.println(name);
        }

        System.out.println("------");
        System.out.println(app.getBean(Dog.class));
    }

}

Dog类下

@Component
public class Dog {

    int age;

    public Dog(){}

    public Dog(int age){

        this.age=age;

    }

    @Override
    public String toString() {

        return "Dog{" +

                "age=" + age +

                '}';
    }

}

运行结果，当有多个的时候，且bean的名字一致时，以最后的为准。

或者直接使用

app.register(Cat.class);

也可以快速的加载一个bean

第六种加载bean方式-实现ImportSelector接口

这个接口有许多方法用来判定

导入实现了ImportSelector接口的类，实现对导入源的编程式处理

public class MyImportSelector implements ImportSelector {

    public String[] selectImports(AnnotationMetadata annotationMetadata) {//AnnotationMetadata 注解的源数据

     //  做判定条件，是否有这个注解

        boolean flag = annotationMetadata.hasAnnotation("org.springframework.context.annotation.Configuration");

        if (flag){

            return new String[]{"com.service.Dog"};

        }

        return new String[]{"com.service.Cat"};
    }

}
@Import({MyImportSelector.class})

public class SpringConfig6 {

}
public class app6 {

    public static void main(String[] args) {

        ApplicationContext app=new AnnotationConfigApplicationContext(SpringConfig6.class);

        String[] names = app.getBeanDefinitionNames();

        for (String name : names) {

            System.out.println(name);


        }

    }

}

运行结果

第七种加载bean方式-实现ImportBeanDefinitionRegistrar

导入实现ImportBeanDefinitionRegistrar接口的类，通过BeanDefinition的注册器注册实名bean，实现对容器中bean的决定，例如对现有的bean的覆盖，进而达到

import com.service.Dog;

import org.springframework.beans.factory.config.BeanDefinition;

import org.springframework.beans.factory.support.BeanDefinitionBuilder;

import org.springframework.beans.factory.support.BeanDefinitionRegistry;

import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;

import org.springframework.core.type.AnnotationMetadata;

public class MyRegistrar implements ImportBeanDefinitionRegistrar {

    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        BeanDefinition beanDefinition= BeanDefinitionBuilder.rootBeanDefinition(Dog.class).getBeanDefinition();

        registry.registerBeanDefinition("woDog", beanDefinition);

    }

}

@Import({MyRegistrar.class})

public class SpringConfig7 {

}

运行结果

第八种bean的加载方式-实现BeanDefinitionRegistryPostProcessor

导入实现了BeanDefinitionRegistryPostProcessor接口的类，通过BeanDefintion的注册器注册实名bean，实现对容器中bean的最终裁定.(以这个接口加载的bean为主)

@Component

public class DBconfig {

    @Bean

    public DruidDataSource dataSource(){

        DruidDataSource ds =new DruidDataSource();

        return ds;

    }

}
public class MyPostProcessor implements BeanDefinitionRegistryPostProcessor {


    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {


 BeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(DBconfig.class).getBeanDefinition();


    registry.registerBeanDefinition("dataSource",beanDefinition);

    }


    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    }


}

@Import({MyPostProcessor.class})

public class SpringConfig8 {

}

运行结果

实现bean的方式总结

1.xml+

2.xml:context+注解(@Component+4个@Bean

3.配置类+扫描+注解(@Component+4个@Bean)

@Bean定义FactoryBean接口
@ImportResource
@Configuration注解的proxyBeanMethods属性

4.@Import导入bean的类

@Import导入配置类

5.AnnotationConfigApplicationContext调用register方法

6.@Import导入ImportSelector接口

7.@Import导入ImportBeanDefinitionRegistrar接口

8.@Import导入BeanDefinitionRegistryPostProcessor接口