Java getBeansOfType（类别<；T>；类型）

我正在尝试为我的一个API编写Junit，在该API中我使用了如下映射：

Map<String, T> beansMap = ctx.getBeansOfType(clazz);

Map beansMap=ctx.getBeansOfType（clazz）；

在哪里

ctx=org.springframework.context.ApplicationContext
clazz=类

---

我需要模拟

ctx.getBeansOfType（clazz）

，并获得这个

Map

的返回，我无法这样做。

一般来说，直接从

应用程序上下文

检索bean被认为是一种不好的做法，因为它引入了耦合。 看看这是为什么

使用字段、构造函数或查找方法注入将消除模拟

ApplicationContext

的需要

无论如何，下面是如何模拟

ApplicationContext.getBeansOfType（clazz）

import org.junit.Test；
导入org.mockito.mockito；
导入org.mockito.invocation.invocationMock；
导入org.mockito.stubing.Answer；
导入org.springframework.context.ApplicationContext；
导入java.util.HashMap；
导入java.util.Map；
导入静态org.junit.Assert.assertFalse；
导入静态org.mockito.Matchers.any；
导入静态org.mockito.mockito.mock；
导入静态org.mockito.mockito.when；
/**
*@author-mpoomarev
*/
公共类蜂鸟测试{
@试验
public void testSomething（）引发异常{
ApplicationContext ApplicationContext=mock（ApplicationContext.class）；
final-Map bean=新的HashMap（）；
当（applicationContext.getBeansOfType（any（Class.Class）））
.thenAnswer（新答案）{
@凌驾
公共映射应答（调用锁调用）
扔掉的{
Class clazz=invocation.getArgumentAt（0，Class.Class）；
beans.put（“beanName”，mock（clazz））；
返豆；
}
} );
Api=新的Api（applicationContext）；
api.perform（）；
assertFalse（“bean不应该是空的”，beans.isEmpty（））；
对于（对象o:beans.values（））{
组件=（组件）o；
Mockito.verify（component.doSomething（）；
}
}
公共静态类Api{
私有最终地图组件；
Api（应用上下文应用上下文）{
this.components=applicationContext.getBeansOfType（Component.class）；
}
作废执行（）{
对于（组件：components.values（））{
成分。剂量测定法（）；
}
}
}
公共接口组件{
无效剂量（）；
}
}

您如何安装ctx？你能展示更多你想测试的课程吗？对新手来说，这是个不错的答案！

ctx = org.springframework.context.ApplicationContext
clazz = Class<T>

import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.springframework.context.ApplicationContext;

import java.util.HashMap;
import java.util.Map;

import static org.junit.Assert.assertFalse;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

/**
 * @author mponomarev
 */
public class ApiTest {
    @Test
    public void testSomething() throws Exception {
        ApplicationContext applicationContext = mock( ApplicationContext.class );
        final Map beans = new HashMap();

        when( applicationContext.getBeansOfType( any( Class.class ) ) )
          .thenAnswer( new Answer<Map<String,Object>>() {
              @Override
              public Map<String,Object> answer( InvocationOnMock invocation )
                throws Throwable {
                  Class clazz = invocation.getArgumentAt( 0, Class.class );
                  beans.put( "beanName", mock( clazz ) );
                  return beans;
              }
          } );

        Api api = new Api( applicationContext );
        api.perform();

        assertFalse( "beans shouldn't be empty", beans.isEmpty() );
        for( Object o : beans.values() ) {
            Component component = (Component)o;
            Mockito.verify( component ).doSomething();
        }
    }

    public static class Api {
        private final Map<String,Component> components;

        Api( ApplicationContext applicationContext ) {
            this.components = applicationContext.getBeansOfType( Component.class );
        }

        void perform() {
            for( Component component : components.values() ) {
                component.doSomething();
            }
        }
    }

    public interface Component {
        void doSomething();
    }
}