AI导航网
微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

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

分类：Spring作者：编程之家

本篇内容介绍了“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

    “Spring单元测试控制Bean注入的方法是什么”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注编程之家网站，小编将为大家输出更多高质量的实用文章！

    版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 [email protected] 举报，一经查实，本站将立刻删除。

    相关推荐

    spring的事务传播属性REQUIRED_NESTED的原理介绍
    这篇文章主要介绍了spring的事务传播属性REQUIRED_NESTED的原理介绍，具有一定借鉴价值，需要的朋友可以参考下。下面就和我一起来看看吧。传统事务中回滚点的使...
    一文解析spring中事务的传播机制
    今天小编给大家分享的是一文解析spring中事务的传播机制，相信很多人都不太了解，为了让大家更加了解，所以给大家总结了以下内容，一起往下看吧。一定会有所收获...
    SpringCloud Alibaba和SpringCloud有什么区别
    这篇文章主要介绍了SpringCloudAlibaba和SpringCloud有什么区别，具有一定借鉴价值，需要的朋友可以参考下。下面就和我一起来看看吧。Spring Cloud Netfli...
    Spring Cloud整合XXL-Job的几个步骤
    本篇文章和大家了解一下SpringCloud整合XXL-Job的几个步骤。有一定的参考价值，有需要的朋友可以参考一下，希望对大家有所帮助。第一步：整合pom文件，在S...
    Spring延迟初始化会遇到什么问题
    本篇文章和大家了解一下Spring延迟初始化会遇到什么问题。有一定的参考价值，有需要的朋友可以参考一下，希望对大家有所帮助。List 坑列表 = new ArrayList(2);...
    怎么使用Spring提供的不同缓存注解实现缓存
    这篇文章主要介绍了怎么使用Spring提供的不同缓存注解实现缓存的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇...
    Spring中的@Autowired和@Resource注解怎么使用
    本篇内容主要讲解“Spring中的@Autowired和@Resource注解怎么使用”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学...
    SpringSecurity怎么定义多个过滤器链
    今天小编给大家分享一下SpringSecurity怎么定义多个过滤器链的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家
    Spring的@Conditional注解怎么使用
    这篇文章主要介绍“Spring的@Conditional注解怎么使用”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“Spring的@Con...
    SpringCloud Gateway的熔断限流怎么配置
    这篇文章主要介绍了SpringCloudGateway的熔断限流怎么配置的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇SpringCloud&nb...
      pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native