«

Spring单元测试控制Bean注入的方法是什么

时间:2024-4-30 09:01     作者:韩俊     分类: Java


本篇内容介绍了“Spring单元测试控制Bean注入的方法是什么”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!

    通过xml文件进行注入

    在配置文件中指定要注入的bean

    <?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="dog" class="com.ttpfx.entity.Dog">
            <property name="name" value="旺财"/>
            <property name="age" value="18"/>
        </bean>
    </beans>

    然后spring加载这个xml文件就可以实现注入

    public class SpringTest1 {
        public static void main(String[] args) {
            ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
            Arrays.stream(ioc.getBeanDefinitionNames()).forEach(System.out::println);
        }
    }

    输出为

    dog

    通过xml加注解方式进行注入

    编写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"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
        <!-- 扫描 com.ttpfx.entity.t2 包下的所有bean-->
        <context:component-scan base-package="com.ttpfx.entity.t2"/>
    </beans>

    然后在要注入的bean上加入Component注解即可(如果里面方法上面有@Bean,那么也会进行处理)

    @Component
    public class Cat {
    }
    public class SpringTest2 {
        public static void main(String[] args) {
            ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext2.xml");
            Arrays.stream(ioc.getBeanDefinitionNames()).forEach(System.out::println);
        }
    }

    输出为

    cat
    org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory

    通过注解进行注入

    可以不使用xml文件,通过@ComponentScan注解来完成定义扫描路径的功能

    @ComponentScan(basePackages = "com.ttpfx.entity.t3")
    public class SpringConfig3 {
    }
    public class SpringTest3 {
        public static void main(String[] args) {
            ApplicationContext ioc = new AnnotationConfigApplicationContext(SpringConfig3.class);
            Arrays.stream(ioc.getBeanDefinitionNames()).forEach(System.out::println);
        }
    }

    使用@ComponentScan也会将自身加入到容器中。我们可以在方法上加入@Bean来进行注入,具体如下

    @Component和@Configuration的区别

    二者用法基本一样,只不过@Configuration可以控制注入的Bean是不是一个代理对象,如果是代理对象,那么调用@Bean方法返回的都是同一个对象,否则就不是同一个对象。

    在默认情况下,@Configuration注入的对象是一个代理对象

    默认情况,proxyBeanMethods = true

    @Configuration(proxyBeanMethods = true)
    public class Cat {
        @Bean
        public Cat bigCat() {
            return new Cat();
        }
    }

    得到这个对象,然后调用bigCat这个方法

    public class SpringTest2 {
        public static void main(String[] args) {
            ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext2.xml");
            Cat cat = ioc.getBean("cat", Cat.class);
            System.out.println(cat);
            Cat bigCat1 = cat.bigCat();
            Cat bigCat2 = cat.bigCat();
            System.out.println("---------------------");
            System.out.println(bigCat1);
            System.out.println(bigCat2);
            System.out.println(bigCat1 == bigCat2);
        }
    }

    这时返回Cat已经是一个代理对象了,bigCat返回的都是同一个对象,就是单例模式的。

    com.ttpfx.entity.t2.Cat$$EnhancerBySpringCGLIB$$bc3ad26b@4c1d9d4b
    ---------------------
    com.ttpfx.entity.t2.Cat@7b227d8d
    com.ttpfx.entity.t2.Cat@7b227d8d
    true

    如果将proxyBeanMethods 改成false,情况如下

    @Configuration(proxyBeanMethods = false)
    public class Cat {
        @Bean
        public Cat bigCat() {
            return new Cat();
        }
    }

    其他代码不变,可以发现没有进行代理。

    com.ttpfx.entity.t2.Cat@62fdb4a6
    ---------------------
    com.ttpfx.entity.t2.Cat@11e21d0e
    com.ttpfx.entity.t2.Cat@1dd02175
    false

    如果使用@Component,那么就相当于@Configuration的proxyBeanMethods 设置为false

    使用FactoryBean

    我们可以让一个类实现FactoryBean,这个接口有一个getObject方法,如果一个使用@Bean标记的方法返回FactoryBean,那么最终返回的是FactoryBean的getObject方法返回的值

    public class PeopleFactory implements FactoryBean<People> {
        @Override
        public People getObject() throws Exception {
            return new People();
        }
        @Override
        public Class<?> getObjectType() {
            return People.class;
        }
        @Override
        public boolean isSingleton() {
            return FactoryBean.super.isSingleton();
        }
    }
    @Component
    public class People {
        @Bean
        public PeopleFactory peopleFactory(){
            return new PeopleFactory();
        }
    }

    此时获取peopleFactory,它的类型如下,是一个People类型

    com.ttpfx.entity.t3.People@587c290d

    通过@Import导入

    可以使用@Import进行导入

    @Import({User.class})
    public class SpringConfig4 {
    }
    public class SpringTest4 {
        public static void main(String[] args) {
            ApplicationContext ioc = new AnnotationConfigApplicationContext(SpringConfig4.class);
            Arrays.stream(ioc.getBeanDefinitionNames()).forEach(System.out::println);
        }
    }

    输出如下,可以发现使用@Import标注的类也会被注入。使用@Import导入的类,名称为全类名,如果重复导入,那么后面覆盖前面。要指定名称,那么就在对应的bean上面使用@Component即可

    org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    springConfig4
    com.ttpfx.entity.t4.User

    手动注入(registerBean)

    可以直接通过GenericApplicationContext这个类的registerBean方法进行注入

    public class SpringTest5 {
        public static void main(String[] args) {
            AnnotationConfigApplicationContext ioc = new AnnotationConfigApplicationContext(SpringConfig5.class);
            Arrays.stream(ioc.getBeanDefinitionNames()).forEach(System.out::println);
            System.out.println("-----------------------");
            ioc.registerBean("monster01", Monster.class);
            Arrays.stream(ioc.getBeanDefinitionNames()).forEach(System.out::println);
        }
    }

    输出如下

    org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    springConfig5
    -----------------------
    org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    springConfig5
    monster01

    通过ImportSelector进行注入

    定义一个类实现ImportSelector

    public class MyImportSelector implements ImportSelector {
        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            return new String[]{"com.ttpfx.entity.t6.Pig"};
        }
    }
    @Import({MyImportSelector.class})
    public class SpringConfig6 {
    }
    public class SpringTest6 {
        public static void main(String[] args) {
            ApplicationContext ioc = new AnnotationConfigApplicationContext(SpringConfig6.class);
            Arrays.stream(ioc.getBeanDefinitionNames()).forEach(System.out::println);
        }
    }

    输出如下,可以发现selectImports返回的String字符串中的内容会进行注入

    org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    springConfig6
    com.ttpfx.entity.t6.Pig

    通过ImportBeanDefinitionRegistrar进行注入

    通过ImportBeanDefinitionRegistrar可以进行注入,只需要在registerBeanDefinitions方法中使用BeanDefinitionRegistry的registerBeanDefinition方法即可

    public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
            ImportBeanDefinitionRegistrar.super.registerBeanDefinitions(importingClassMetadata, registry, importBeanNameGenerator);
        }
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            BeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Manager.class).getBeanDefinition();
            registry.registerBeanDefinition("manager", beanDefinition);
            ImportBeanDefinitionRegistrar.super.registerBeanDefinitions(importingClassMetadata, registry);
        }
    }
    public class SpringTest7 {
        public static void main(String[] args) {
            ApplicationContext ioc = new AnnotationConfigApplicationContext(SpringConfig7.class);
            Arrays.stream(ioc.getBeanDefinitionNames()).forEach(System.out::println);
            Manager bean = ioc.getBean(Manager.class);
            System.out.println(bean);
        }
    }

    代码输出如下

    org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    springConfig7
    manager
    com.ttpfx.entity.t7.Manager@1d8d30f7

    通过BeanDefinitionRegistryPostProcessor进行注入

    实现这个接口,通过方法上面的参数可以进行注入

    public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
            BeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Employee.class).getBeanDefinition();
            registry.registerBeanDefinition("employee", beanDefinition);
        }
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        }
    }
    @Import({MyBeanDefinitionRegistryPostProcessor.class})
    public class SpringConfig8 {
    }
    public class SpringTest8 {
        public static void main(String[] args) {
            ApplicationContext ioc = new AnnotationConfigApplicationContext(SpringConfig8.class);
            Arrays.stream(ioc.getBeanDefinitionNames()).forEach(System.out::println);
            System.out.println("-----------------");
            Employee bean = ioc.getBean(Employee.class);
            System.out.println(bean);
        }
    }

    输出如下,可以发现实现BeanDefinitionRegistryPostProcessor的这个类也被注入了

    org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    org.springframework.context.annotation.internalCommonAnnotationProcessor
    org.springframework.context.event.internalEventListenerProcessor
    org.springframework.context.event.internalEventListenerFactory
    springConfig8
    com.ttpfx.entity.t8.MyBeanDefinitionRegistryPostProcessor
    employee
    -----------------
    com.ttpfx.entity.t8.Employee@58c1670b

    标签: java spring

    热门推荐