⭐⭐⭐ Spring Boot 项目实战	⭐⭐⭐ Spring Cloud 项目实战
《Dubbo 实现原理与源码解析 —— 精品合集》	《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》	《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》	《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》	《Java 面试题 + Java 学习指南》

摘要: 原创出处 jianshu.com/p/72b19e24a602 「二月_春风」欢迎转载，保留摘要，谢谢！

🙂🙂🙂关注**微信公众号：【芋道源码】**有福利：

RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表

RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址

您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。

新的源码解析文章实时收到通知。每周更新一篇左右。

认真的源码交流微信群。

mac上idea快捷键，command+shift+T根据类生成快捷键。

对spring容器中的类做单元测试

在src/main下建立UserService类，对其进行单于测试，生产其单元测试类（使用command+shift+T快捷键）,生成的test类在src/test下

@Service
public class UserService {

    public Integer addUser(String username){
        System.out.println("user dao adduser [username="+username+"]");
        if(username == null){
            return 0;
        }
        return 1;
    }
}

springboot启动类：

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

测试类：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void addUser() throws Exception {
        Assert.assertEquals(Integer.valueOf(1),userService.addUser("zhihao.miao"));
        Assert.assertEquals(Integer.valueOf(0),userService.addUser(null));
    }

}

盲点扫描

RunWith注解，SpringRunner类，SpringJUnit4ClassRunner类，SpringBootTest注解的解释。

RunWith注解

When a class is annotated with @RunWith or extends a class annotated with @RunWith, JUnit will invoke the class it references to run the tests in that class instead of the runner built into JUnit. We added this feature late in development. While it seems powerful we expect the runner API to change as we learn how people really use it. Some of the classes that are currently internal will likely be refined and become public. 当一个类用@RunWith注释或继承一个用@RunWith注释的类时，JUnit将调用它所引用的类来运行该类中的测试而不是开发者去在junit内部去构建它。我们在开发过程中使用这个特性。

For example, suites in JUnit 4 are built using RunWith, and a custom runner named Suite: 比如说，suites使用RunWith注解构建，

@RunWith(Suite.class)
@SuiteClasses({ATest.class, BTest.class, CTest.class})
public class ABCSuite {
}

SpringRunner注解

SpringRunner is an alias for the SpringJUnit4ClassRunner. SpringRunner是SpringJUnit4ClassRunner的一个别名。

To use this class, simply annotate a JUnit 4 based test class with @RunWith(SpringRunner.class). 使用这个类，简单注解一个JUnit 4 依赖的测试@RunWith(SpringRunner.class).

If you would like to use the Spring TestContext Framework with a runner other than this one, use org.springframework.test.context.junit4.rules.SpringClassRule and org.springframework.test.context.junit4.rules.SpringMethodRule. 如果你想使用Spring测试上下文而不是使用这个，你可以使用org.springframework.test.context.junit4.rules.SpringClassRule和org.springframework.test.context.junit4.rules.SpringMethodRule.

SpringJUnit4ClassRunner

SpringJUnit4ClassRunner is a custom extension of JUnit's BlockJUnit4ClassRunner which provides functionality of the Spring TestContext Framework to standard JUnit tests by means of the TestContextManager and associated support classes and annotations. SpringJUnit4ClassRunner是JUnit's的BlockJUnit4ClassRunner类的一个常规扩展，提供了一些spring测试环境上下文去规范JUnit测试，意味着TestContextManager和支持相关的类和注解。

SpringBootTest注解

Annotation that can be specified on a test class that runs Spring Boot based tests. Provides the following features over and above the regular Spring TestContext Framework: 注解制定了一个测试类运行了Spring Boot环境。提供了以下一些特性：

Uses SpringBootContextLoader as the default ContextLoader when no specific ContextConfiguration#loader() @ContextConfiguration(loader=...) is defined. 当没有特定的ContextConfiguration#loader()（@ContextConfiguration(loader=...)）被定义那么就是SpringBootContextLoader作为默认的ContextLoader。

Automatically searches for a SpringBootConfiguration @SpringBootConfiguration when nested @Configuration is not used, and no explicit #classes() classes are specified. 自动搜索到SpringBootConfiguration注解的文件。

Allows custom Environment properties to be defined using the properties() properties attribute}. 允许自动注入Environment类读取配置文件。

Provides support for different #webEnvironment() webEnvironment modes, including the ability to start a fully running container listening on a WebEnvironment#DEFINED_PORT defined or WebEnvironment#RANDOM_PORT random port. 提供一个webEnvironment环境，可以完整的允许一个web环境使用随机的端口或者自定义的端口。

Registers a org.springframework.boot.test.web.client.TestRestTemplate TestRestTemplate bean for use in web tests that are using a fully running container. 注册了TestRestTemplate类可以去做接口调用。

springboot测试步骤

直接在测试类上面加上如下2个注解 @RunWith(SpringRunner.class) @SpringBootTest 就能取到spring中的容器的实例，如果配置了@Autowired那么就自动将对象注入。

在测试环境中获取一个bean，在项目中新建User类，然后在测试模块进行测试

在src/main下新建一个实例User

@Component
public class User {
}

src/test下创建测试类测试：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserTest {


    @Autowired
    public ApplicationContext context;

    @Test
    public void testNotNull(){
        Assert.assertNotNull(context.getBean(User.class));
    }
}

只在测试环境有效的bean

在src/test下新建二个类，我们发现分别使用@TestComponent和@TestConfiguration二个注解修饰，这些类只在测试环境生效

@TestComponent
public class Cat {

    public void index(){
        System.out.println("cat index");
    }
}

@TestConfiguration
public class TestBeanConfiguration {

    @Bean
    public Runnable createRunnable(){
        return () -> System.out.println("=====createRunnable=======");
    }
}

测试类：

@RunWith(SpringRunner.class)
@SpringBootTest(classes = {TestBeanConfiguration.class,Cat.class})
public class TestApplication {

    @Autowired
    public ApplicationContext context;

    @Test
    public void testNotNull(){
        Runnable runnable = context.getBean(Runnable.class);
        runnable.run();
        System.out.println("--------");

        Cat cat = context.getBean(Cat.class);
        cat.index();
    }
}

需要在@SpringBootTest注解的参数classes中加入参数，表示将某些类纳入测试环境的容器中。

TestComponent注解

TestConfiguration注解

配置文件属性的读取

springboot会只会读取到src/test/resources下的配置，不会读到正式环境下的配置文件(跟以前1.4.*版本的不一样，以前是优先读取测试环境配置文件，然后读取正式环境的配置）

@RunWith(SpringRunner.class)
@SpringBootTest
public class EnvTest {

    @Autowired
    public Environment environment;

    @Test
    public void testValue(){
        Assert.assertEquals("zhihao.miao",environment.getProperty("developer.name"));

    }
}

除了在配置文件中设置属性，测试环境加载一些配置信息的二种方式：第一种是使用@SpringBootTest注解，注解参数properties指定其value值，第二种使用EnvironmentTestUtils.addEnvironment方法进行设置。测试：

@RunWith(SpringRunner.class)
@SpringBootTest(properties = {"app.version=1.0"})
public class EnvTest2 {

    @Autowired
    private ConfigurableEnvironment environment;

    @Before
    public void init(){
        EnvironmentTestUtils.addEnvironment(environment,"app.admin.user=zhangsan");
    }

    @Test
    public void testApplication(){
        Assert.assertEquals("1.0",environment.getProperty("app.version"));
        Assert.assertEquals("zhangsan",environment.getProperty("app.admin.user"));
    }
}

Mock方式的测试

正式环境只是一个接口，并没有实现，也并没有纳入spring容器进行管理。

public interface UserDao {
    Integer createUser(String userName);
}

测试

@RunWith(SpringRunner.class)
public class UserDaoTest {

    //使用MockBean是因为此时容器中没有UserMapper这个对象
    @MockBean
    public UserDao userDao;

    //使用BDDMockito对行为进行预测，
    @Before
    public void init(){
        BDDMockito.given(userDao.createUser("admin")).willReturn(1);
        BDDMockito.given(userDao.createUser("")).willReturn(0);
        BDDMockito.given(userDao.createUser(null)).willThrow(NullPointerException.class);
    }

    @Test(expected=NullPointerException.class)
    public void testCreateUser() {
        Assert.assertEquals(Integer.valueOf(1),userDao.createUser("admin")) ;
        Assert.assertEquals(Integer.valueOf(0),userDao.createUser("")) ;
        Assert.assertEquals(Integer.valueOf(1),userDao.createUser(null)) ;
    }
}

对controller进行测试

第一种方式: 定义一个Controller，用作测试：

@RestController
public class UserController {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @GetMapping("/user/home")
    public String home(){
        logger.info("user home");
        return "user home";
    }

    @GetMapping("/user/show")
    public String show(@RequestParam("id") String id){
        logger.info("book show");
        return "show"+id;
    }
}

使用浏览器访问

http://localhost:8080/user/home
http://localhost:8080/user/show?id=100

使用测试类测试

@RunWith(SpringRunner.class)
//指定web环境，随机端口
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class UserControllerTest {

    //这个对象是运行在web环境的时候加载到spring容器中
    @Autowired
    private TestRestTemplate testRestTemplate;

    @Test
    public void testHome(){
        String context = testRestTemplate.getForObject("/user/home",String.class);
        Assert.assertEquals("user home",context);
    }

    @Test
    public void testShow(){
        String context = testRestTemplate.getForObject("/user/show?id=100",String.class);
        Assert.assertEquals("show10",context);
    }
}

第二种方式，使用@WebMvcTest注解

@RunWith(SpringRunner.class)
@WebMvcTest(controllers = UserController.class)
public class UserControllerTest2 {

    @Autowired
    public MockMvc mockMvc;

    @Test
    public void testHome() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/user/home")).andExpect(MockMvcResultMatchers.status().isOk());
        mockMvc.perform(MockMvcRequestBuilders.get("/user/home")).andExpect(MockMvcResultMatchers.status().isOk()).andExpect(MockMvcResultMatchers.content().string("user home"));
    }

    @Test
    public void testShow() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/user/show").param("id", "400")).andExpect(MockMvcResultMatchers.status().isOk());
        mockMvc.perform(MockMvcRequestBuilders.get("/user/show").param("id", "400")).andExpect(MockMvcResultMatchers.status().isOk()).andExpect(MockMvcResultMatchers.content().string("show400"));
    }
}

WebMvcTest

@WebMvcTest 不需要运行在web环境下，但是，需要指定controllers，表示需要测试哪些controllers。这种方式只测试controller，controller里面的一些依赖，需要你自己去mock @WebMvcTest 不会加载整个spring容器。

第三种方式 使用@SpringBootTest()与@AutoConfigureMockMvc结合，@SpringBootTest使用@SpringBootTest加载测试的spring上下文环境，@AutoConfigureMockMvc自动配置MockMvc这个类，

/**
 * @SpringBootTest 不能和  @WebMvcTest 同时使用
 * 如果使用MockMvc对象的话，需要另外加上@AutoConfigureMockMvc注解
 */
@RunWith(SpringRunner.class)
@SpringBootTest()
@AutoConfigureMockMvc
public class UserControllerTest3 {

    @Autowired
    private MockMvc mvc;

    @Test
    public void testHome() throws Exception {
        mvc.perform(MockMvcRequestBuilders.get("/user/home")).andExpect(MockMvcResultMatchers.status().isOk());
        mvc.perform(MockMvcRequestBuilders.get("/user/home")).andExpect(MockMvcResultMatchers.status().isOk()).andExpect(MockMvcResultMatchers.content().string("user home"));
    }

    @Test
    public void testShow() throws Exception {
        mvc.perform(MockMvcRequestBuilders.get("/user/show").param("id", "400")).andExpect(MockMvcResultMatchers.status().isOk());
        mvc.perform(MockMvcRequestBuilders.get("/user/show").param("id", "400")).andExpect(MockMvcResultMatchers.status().isOk()).andExpect(MockMvcResultMatchers.content().string("show400"));
    }
}

一个注解可以使测试类可以自动配置MockMvc这个类。

AutoConfigureMockMvc注解

芋道源码 —— 纯源码解析博客

springboot test