spring注解-组件注册

一、@Configuration+@Bean

@Configuration：配置类==配置文件

@Bean：给容器中注册一个Bean；类型为返回值的类型，默认是用方法名作为id

　@Bean("person")
    public Person person01(){
        return new Person();
    }
//等同于在beans.xml配置<bean id="person" class="com.atguigu.bean.Person"/>


二、@ComponentScans+组件标注注解


    

  • 包扫描组件并添加到容器里
    • 

  • componentScan在jdk8是一个可重用的注解，可以指定不同的过滤策略，低版本可以@ComponentScans
    • 





@ComponentScans(
        value = {
                @ComponentScan(value="com.atguigu",includeFilters = {
                        @Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
                        @Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class})
    　　　　　　  },useDefaultFilters = false)    
       }
 )
//等同于在beans.xml配置，在配置includeFilters(只包含)要禁用spring的默认过滤规则(扫描所有)才能生效
<context:component-scan base-package="com.atguigu" use-default-filters="false"></context:component-scan>




属性


ComponentScan


    

  • value:指定要扫描的包
    • 

  • excludeFilters = Filter[]：指定扫描的时候按照什么规则排除那些组件
    • 

  • includeFilters = Filter[]：指定扫描的时候只需要包含哪些组件
    • 

      

    • FilterType.ANNOTATION：按照注解
      • 

    • FilterType.ASSIGNABLE_TYPE：按照给定的类型
      • 

    • FilterType.ASPECTJ：使用ASPECTJ表达式
      • 

    • FilterType.REGEX：使用正则指定
      • 

    • FilterType.CUSTOM：使用自定义规则
      • 

    



自定义过滤规则




public class MyTypeFilter implements TypeFilter {

    /**
     * metadataReader：读取到的当前正在扫描的类的信息
     * metadataReaderFactory:可以获取到其他任何类信息的
     */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
            throws IOException {
        // TODO Auto-generated method stub
        //获取当前类注解的信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        //获取当前正在扫描的类的类信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        //获取当前类资源（类的路径）
        Resource resource = metadataReader.getResource();
        
        String className = classMetadata.getClassName();
        System.out.println("--->"+className);
        if(className.contains("er")){
            return true;
        }
        return false;
    }




 


三、@Scope


@Scope是用来调整bean作用域的，它有4种作用域以及它们的区别如下：


    

  • prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中
    • 

  • singleton：单实例的(默认值)：ioc容器启动会调用方法创建对象放到ioc容器中
    • 

  • request：同一次请求创建一个实例
    • 

  • session：同一个session创建一个实例
    • 





@Scope("prototype")　　//配置@Bean一起使用




懒加载


单实例作用域的bean在容器启动的时候就会进行创建，如果我们想在用到这个bean的时候才去创建它，可以使用@Lazy进行懒加载，这样容器启动就不会创建对象。而是在第一次使用(获取)Bean创建对象并初始化




@Lazy　　//配置@Bean一起使用




 


四、@Conditional


@Conditional({Condition})：按照一定的条件进行判断，如果标注在类上，满足条件这个类中配置的所有组件才能生效；如果标注在方法上，符合条件该方法才生效




@Conditional(LinuxCondition.class)　　//配置@Bean一起使用




在spring中进行条件判断，需要自定义规则；而在springboot中框架都为我们写好了规则。比如@ConditionOnClass、@ConditionOnBean，这些都是通过在自定义类中通过获取上下文进行判断




public class LinuxCondition implements Condition {

    /**
     * ConditionContext：判断条件能使用的上下文（环境）
     * AnnotatedTypeMetadata：注释信息
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // TODO是否linux系统
        //1、能获取到ioc使用的beanfactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        //2、获取类加载器
        ClassLoader classLoader = context.getClassLoader();
        //3、获取当前环境信息
        Environment environment = context.getEnvironment();
        //4、获取到bean定义的注册类
        BeanDefinitionRegistry registry = context.getRegistry();
        
        String property = environment.getProperty("os.name");
        
        //可以判断容器中的bean注册情况，也可以给容器中注册bean
        boolean definition = registry.containsBeanDefinition("person");
        if(property.contains("linux")){
            return true;
        }
        
        return false;
    }

}

//测试时加上虚拟机参数:-Dos.name=linux




 


五、@Import


@Import(XXX.class)


　　导入任意类.class，容器中就会注册这个组件


ImportSelector


　　@Import(MyImportSelector.class)


实现ImportSelector接口，返回值就是导入到容器中的组件全类名




public class MyImportSelector implements ImportSelector {

    //AnnotationMetadata:当前标注@Import注解的类的所有注解信息
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {//方法不要返回null值
        return new String[]{"com.atguigu.bean.Blue","com.atguigu.bean.Yellow"};
    }

}




ImportBeanDefinitionRegistrar


　　@Import(MyImportBeanDefinitionRegistrar.class)


实现ImportBeanDefinitionRegistrar接口，把所有需要添加到容器中的bean，通过调用beanDefinitionRegistry.registerBeanDefinition()手工注册进来




public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    /**
     * AnnotationMetadata：当前类的注解信息
     * BeanDefinitionRegistry:BeanDefinition注册类；
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        
        boolean definition = registry.containsBeanDefinition("com.atguigu.bean.Red");
        boolean definition2 = registry.containsBeanDefinition("com.atguigu.bean.Blue");
        if(definition && definition2){
            //指定Bean定义信息(Bean的类型，Bean的作用域)
            RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
            //注册一个Bean，指定bean名
            registry.registerBeanDefinition("rainBow", beanDefinition);
        }
    }

}




 


六、FactoryBean+@Bean


实现FactoryBean<T>接口




//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {

    //返回一个Color对象，这个对象会添加到容器中
    @Override
    public Color getObject() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("ColorFactoryBean...getObject...");
        return new Color();
    }

    @Override
    public Class<?> getObjectType() {
        // TODO Auto-generated method stub
        return Color.class;
    }

    //是单例？
    //true：这个bean是单实例，在容器中保存一份
    //false：多实例，每次获取都会创建一个新的bean；
    @Override
    public boolean isSingleton() {
        // TODO Auto-generated method stub
        return false;
    }




假如我们要获取bean，默认返回的bean类型是传入的泛型类，而不是ColorFactoryBean




　  @Bean
    public ColorFactoryBean colorFactoryBean(){
        return new ColorFactoryBean();
    }




 


总结


　　给容器中注册组件有以下几种方式：


    

  • @ComponentScan+组件标注注解(@Controller/@Service/@Repository/@Component)[自己写的类]
    • 

  • @Configuration+@Bean[导入的第三方包里面的组件]
    • 

  • @Import[快速给容器中导入一个组件]

      

    • @Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是组件的全类名
      • 

    • ImportSelector：返回需要导入的组件的全类名数组(导入多个组件，bean的id也是组件的全类名)；
      • 

    • ImportBeanDefinitionRegistrar：手动注册bean到容器中(指定bean名)
      • 

    

    • 

  • 使用Spring提供的 FactoryBean(工厂Bean)

      

    • 默认获取到的是工厂bean调用getObject创建的对象
      • 

    • 要获取工厂Bean本身，我们需要给id前面加一个&
      • 

    

    • 



 


注解使用


注解名、属性


　　方法名作为属性名称，返回类型作为参数




 在使用上就是@ComponentScans(value={@ComponentScan(value="com",XXXFilter={})})


    

  • 因为是ComponentScan的数组，所有可以用{}修饰(也可不用，不用就只写一个@ComponentScan)
    • 

  • ComponentScan里的value也是数组，但我们只扫描一个大路径下的包名即可
    • 



 


注解标注位置


@Target({ElementType.TYPE, ElementType.METHOD})


    

  • ElementType.TYPE：标注在类上
    • 

  • ElementType.METHOD：标注在方法上
    • 



 



        

	      

	    

	  

	  

	    
      
        【推广】
        免费学中医，健康全家人
      
	  

    

    

          原文地址：https://www.cnblogs.com/edda/p/13443542.html