spring源码分析(一)——bean的注册

扫码关注公众号:Java 技术驿站

发送:vip
将链接复制到本浏览器,永久解锁本站全部文章

【公众号:Java 技术驿站】 【加作者微信交流技术,拉技术群】

1、从容器中获取bean的两种方式

a、xml注册获取

    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    Person bean = (Person) applicationContext.getBean("person");
    System.out.println(bean);

b、注解方式注册的bean

    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    Person bean = applicationContext.getBean(Person.class);
    System.out.println(bean);

2、注解方式注册bean

    @Configuration  //告诉spring这是一个配置类
    public class MainConfig {

        //给容器中注册一个Bean;类型为返回值的类型,id是默认方法名用作id
        @Bean
        public Person person01(){
            return new Person("lisi", 20);
        }
    }

3、包扫描

    @Configuration 
    @ComponentScans(value = {@ComponentScan(value="com.atguigu")  })
    public class MainConfig {
    }

ComponentScans指定扫描的包,然后获取出来的就是这个包下,所有标注有@component、@controller、@service、@repository等注解的类。

@controller、@service、@repository都是@component的派生类

    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    String[] definitionNames = applicationContext.getBeanDefinitionNames();
    for (String name : definitionNames) {
        System.out.println(name);
    }
    @Configuration  
    @ComponentScans(
            value = {
                @ComponentScan(value="com.atguigu",includeFilters = {
    /*          @Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
                @Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),*/
                @Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})
            },useDefaultFilters = false)    }
    )
    //@ComponentScan  value:指定要扫描的包    
    //excludeFilters = Filter[] 指定扫描的时候,按照什么规则,排除哪些组件    排除有controller注解的组件
    //includeFilters = Filter[] 指定扫描的时候,按照什么规则,只需要哪些组件
    //FilterType.ANNOTATION   按照注解方式扫描,上面是只扫描标注controller注解的组件
    //FilterType.ASSIGNABLE_TYPE   按照给定类型 只扫描BookService或其子类或实现类
    //FilterType.ASPECTJ  使用ASPECTJ指定
    //FilterType.REGEX  使用正则指定
    //FilterType.CUSTOM  自定义
    //useDefaultFilters = false   禁用默认的规则,只有设置为false,只包含才生效
    public class MainConfig {

    }

自定义过滤规则,必须实现TypeFilter接口

    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;
        }

    }

4、@Scope注解 调整作用域

    //默认是单实例的
        /**
         * @Scope:调整作用域
         * prototype:多实例的:ioc容器启动并不会去调用方法创建对象放在容器中。
         *                  每次获取的时候才会调用方法创建对象;
         * singleton:单实例的(默认值):ioc容器启动会调用方法创建对象放到ioc容器中。
         *          以后每次获取就是直接从容器(map.get())中拿,
         * request:同一次请求创建一个实例
         * session:同一个session创建一个实例

         */
        @Scope("prototype")
        @Bean("person")
        public Person person(){
            System.out.println("给容器中添加Person....");
            return new Person("张三", 25);
        }

5、@Lazy懒加载

    懒加载:
    单实例bean:默认在容器启动的时候创建对象;懒加载:容器启动不创建对象。第一次使用(获取)Bean创建对象,并初始化;

6、@Conditional注解

    按照一定的条件进行判断,满足条件给容器中注册bean。
    首先要自己写一个类,继承Condition,并实现match方法
    //判断是否linux系统
    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;
        }

    }
    然后在注册bean的时候,在方法上加上@Conditional注解,并制定LinuxCondition的类。
    如果标在类上面,则满足条件的时候,这个配置类里面的bean才会生效。
    //类中组件统一设置。满足当前条件,这个类中配置的所有bean注册才能生效;
    @Conditional({WindowsCondition.class})
    @Configuration
    public class MainConfig2 {

        /**
         * @Conditional({Condition}) : 按照一定的条件进行判断,满足条件给容器中注册bean
         * 
         * 如果系统是windows,给容器中注册("bill")
         * 如果是linux系统,给容器中注册("linus")
         */
        @Conditional({WindowsCondition.class})
        @Bean("bill")
        public Person person01(){
            return new Person("Bill Gates",62);
        }
    }

7、@Import 快速给容器导入一个组件

给容器中注册组件; 1)、包扫描+组件标注注解(@Controller/@Service/@Repository/@Component)[自己写的类] 2)、@Bean[导入的第三方包里面的组件] 3)、@Import[快速给容器中导入一个组件] 1)、@Import(要导入到容器中的组件);容器中就会自动注册这个组件,id默认是全类名 2)、ImportSelector:返回需要导入的组件的全类名数组; 3)、ImportBeanDefinitionRegistrar:手动注册bean到容器中 4)、使用Spring提供的 FactoryBean(工厂Bean); 1)、默认获取到的是工厂bean调用getObject创建的对象 2)、要获取工厂Bean本身,我们需要给id前面加一个& &colorFactoryBean

使用@import注解

    @Configuration
    @Import({Color.class,Red.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})
    //@Import导入组件,id默认是组件的全类名
    public class MainConfig2 {

    }

使用ImportSelector注解

    ImportSelector可以自己定义导入哪些类,返回一个数组,返回要导入的类的全类名,需要实现ImportSelector接口,
    //自定义逻辑返回需要导入的组件
    public class MyImportSelector implements ImportSelector {

        //返回值,就是到导入到容器中的组件全类名
        //AnnotationMetadata:当前标注@Import注解的类的所有注解信息
        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            // TODO Auto-generated method stub
            //importingClassMetadata
            //方法不要返回null值
            return new String[]{"com.atguigu.bean.Blue","com.atguigu.bean.Yellow"};
        }

    }

然后在配置类上,需要导入自己写的导入选择器

    @Import({MyImporxtSelector.class})

ImportBeanDefinitionRegistrar:手动注册bean到容器中。

需要自己写一个注册的规则类,实现ImportBeanDefinitionRegistrar接口,并在配置类上导入这个类

    public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

        /**
         * AnnotationMetadata:当前类的注解信息
         * BeanDefinitionRegistry:BeanDefinition注册类;
         *      把所有需要添加到容器中的bean;调用
         *      BeanDefinitionRegistry.registerBeanDefinition手工注册进来
         */
        @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

    //创建一个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;
        }

    }

在配置类进行注册

         /* 使用Spring提供的 FactoryBean(工厂Bean);
         *  默认获取到的是工厂bean调用getObject创建的对象
         */
        @Bean
        public ColorFactoryBean colorFactoryBean(){
            return new ColorFactoryBean();
        }

获取已经注册的bean

    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
    Object bean2 = applicationContext.getBean("colorFactoryBean");

    Object bean4 = applicationContext.getBean("&colorFactoryBean");

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


来源:http://ddrv.cn

赞(0) 打赏
版权归原创作者所有,任何形式的转载请联系博主:daming_90:Java 技术驿站 » spring源码分析(一)——bean的注册

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏