spring Boot关于Bean的集中注入方式，以及初始化过程

1、创建bean的三种方式

　　使用bean注解直接注入

　　实现FactoryBean

　　在其他类中间接创建

@Configuration
public class MyConfig {

    @Bean
    @Scope("prototype")
    public MyBean createBean(){
        return new MyBean();
    }

public class AppDemo {
    public static void main(String[] args){
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(MyConfig.class);
         System.out.println(context.getBean("Mybean"));
        context.close();
    }
}

public class MyBean {

}

@Scope bean默认为单例的模式，使用Scop而注解可以更换为双例

context.getBean()   可以通过类，和方法名进行获取。方法名需要在Bean中加入方法名称@Bean("createBean")

AnnotationConfigApplicationContext  源码中  有多种注入类的方式，截取其中的2点

　　第二种方式
　　　

public class RunnableFactoryBean implements FactoryBean<jeep> {

    @Override
    public jeep getObject() throws Exception {
       return  new jeep();
    }
    @Override
    public Class<?> getObjectType() {
        return jeep.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

 @Bean
    public RunnableFactoryBean createRunnableFactoryBean(){
        return new RunnableFactoryBean();
    }

其中 FactoryBean 源码如下，默认未单例模式

　

　第三种方式

public class CarFactory {
        public cat createCat(){
            return new cat();
        }
}

　　需要创建一个cat类

       在CarFactory中创建cat

       在配置文件中configration中注入bean

       main方法输出类 

                    ---------------------------------------------------

Bean的初始化方法

@使用Bean直接 @Bean（init-method=“”，destoryMethod=“”）

@使用注解PostContruts，PreDestory

@继承InitialazingBean,DispoableBean 重写其方法

第一种方式

public class Dag {

    public  void init(){
        System.out.println("进行数据的初始化");
    }

    public  void destory(){
        System.out.println("进行数据的销毁工作");
    }
}

　　配置文件添加其下

 @Bean(initMethod="init",destroyMethod = "destory")
   public Dag createDog(){
        return new Dag();
   }

　　直接在main打印输出即可

第二种方法

public class Dog {

    @PostConstruct
    public void init(){
        System.out.println("进行数据的初始化");
    }
    @PreDestroy
    public void destory(){
        System.out.println("方法进行数据的销毁工作");
    }
}

在配置文件中将Dog类进行注入

  @Bean
   public Dog createDogs(){
       return new Dog();
   }

在main中获取Dog的初始化

第三种方法

public class Car implements InitializingBean,DisposableBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("afterPropertiesSet-------");
    }
    @Override
    public void destroy() throws Exception {
        System.out.println("需要关闭容量才会执行的销毁的方法");
    }
}

将Car类注入到容器

  @Bean
    public  Car creatCar(){
        return new Car();
    }

在main中打印输出

-----------

Spring  AnnotationConfigApplicationContext  扫包的方式

　　　　

    public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        this();
        this.register(annotatedClasses);
        this.refresh();
    }

    public AnnotationConfigApplicationContext(String... basePackages) {
        this();
        this.scan(basePackages);
        this.refresh();
    }

用第二种方式进行扫包

AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(“加项目的路径即可”);
列如

AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(“com.demo.example”);

@ 如何排除不要的包
使用  componentScan注解
单独创建一个配置类
添加扫描注解
添加配置注解

@ComponentScan(basePackages="com.example.demo",
        excludeFilters =@ComponentScan.Filter(type= FilterType.ASSIGNABLE_TYPE,classes =cat.class ))
@Configuration
public class MyConfig2 {
    
}

我们来看下@ComponentScan 底层代码有哪些内容

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
    @AliasFor("basePackages")
    String[] value() default {};

    @AliasFor("value")
    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};

    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

    Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;

    ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;

    String resourcePattern() default "**/*.class";

    boolean useDefaultFilters() default true;

    ComponentScan.Filter[] includeFilters() default {};

    ComponentScan.Filter[] excludeFilters() default {};

    boolean lazyInit() default false;

    @Retention(RetentionPolicy.RUNTIME)
    @Target({})
    public @interface Filter {
        FilterType type() default FilterType.ANNOTATION;

        @AliasFor("classes")
        Class<?>[] value() default {};

        @AliasFor("value")
        Class<?>[] classes() default {};

        String[] pattern() default {};
    }
}

public enum FilterType {
    ANNOTATION,
    ASSIGNABLE_TYPE,
    ASPECTJ,
    REGEX,
    CUSTOM;

    private FilterType() {
    }
}

里面包含了包含，以及 排除的方法，需要制定排除的类型有5种方法，怎末用可以看注解或者找度娘
我们选择第二种方法需要排除一个配置类

exCludeFilter=@Filter(type="ASSIGNABLE_TYPE",classes="一个配置类

--------------------------------
AnnotationConfigAppliactionContext 
使用完毕后一定要关掉，否则在生命周期的时候会不执行destory销毁方法。

装载bean的2种方式
@Configration
@Component，controller，service等