Intro to Spring Boot Starters – Spring Boot启动器介绍

最后修改: 2016年 7月 14日


1. Overview


Dependency management is a critical aspects of any complex project. And doing this manually is less than ideal; the more time you spent on it the less time you have on the other important aspects of the project.


Spring Boot starters were built to address exactly this problem. Starter POMs are a set of convenient dependency descriptors that you can include in your application. You get a one-stop-shop for all the Spring and related technology that you need, without having to hunt through sample code and copy-paste loads of dependency descriptors.

Spring Boot启动器正是为了解决这个问题而建立的。启动器POMs是一组方便的依赖描述符,你可以将其纳入你的应用程序中。你可以一站式获得你所需要的所有Spring和相关技术,而不必翻阅样本代码和复制粘贴大量的依赖描述符。

We have more than 30 Boot starters available – let’s see some of them in the following sections.

我们有30多个Boot starters可用–让我们在下面的章节中看看其中的一些。

2. The Web Starter


First, let’s look at developing the REST service; we can use libraries like Spring MVC, Tomcat and Jackson – a lot of dependencies for a single application.

首先,我们来看看开发REST服务;我们可以使用Spring MVC、Tomcat和Jackson等库–对于一个应用程序来说,有很多依赖性。

Spring Boot starters can help to reduce the number of manually added dependencies just by adding one dependency. So instead of manually specifying the dependencies just add one starter as in the following example:

Spring Boot启动器可以帮助减少手动添加的依赖项的数量,只需添加一个依赖项。因此,无需手动指定依赖关系,只需添加一个启动器,如下例所示。


Now we can create a REST controller. For the sake of simplicity we won’t use the database and focus on the REST controller:


public class GenericEntityController {
    private List<GenericEntity> entityList = new ArrayList<>();

    public List<GenericEntity> findAll() {
        return entityList;

    @RequestMapping(value = "/entity", method = RequestMethod.POST)
    public GenericEntity addEntity(GenericEntity entity) {
        return entity;

    public GenericEntity findById(@PathVariable Long id) {
                 filter(entity -> entity.getId().equals(id)).

The GenericEntity is a simple bean with id of type Long and value of type String.


That’s it – with the application running, you can access http://localhost:8080/entity/all and check the controller is working.


We have created a REST application with quite a minimal configuration.


3. The Test Starter


For testing we usually use the following set of libraries: Spring Test, JUnit, Hamcrest, and Mockito. We can include all of these libraries manually, but Spring Boot starter can be used to automatically include these libraries in the following way:

对于测试,我们通常使用以下一组库。Spring Test、JUnit、Hamcrest和Mockito。我们可以手动包含所有这些库,但Spring Boot starter可以用以下方式自动包含这些库。


Notice that you don’t need to specify the version number of an artifact. Spring Boot will figure out what version to use – all you need to specify is the version of spring-boot-starter-parent artifact. If later on you need to upgrade the Boot library and dependencies, just upgrade the Boot version in one place and it will take care of the rest.

注意,你不需要指定一个工件的版本号。Spring Boot会找出要使用的版本–你所需要指定的是spring-boot-starter-parent工件的版本。如果以后你需要升级Boot库和依赖项,只需在一个地方升级Boot版本,它就会处理剩下的事情。

Let’s actually test the controller we created in the previous example.


There are two ways to test the controller:


  • Using the mock environment
  • Using the embedded Servlet container (like Tomcat or Jetty)

In this example we’ll use a mock environment:


@SpringApplicationConfiguration(classes = Application.class)
public class SpringBootApplicationIntegrationTest {
    private WebApplicationContext webApplicationContext;
    private MockMvc mockMvc;

    public void setupMockMvc() {
        mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();

    public void givenRequestHasBeenMade_whenMeetsAllOfGivenConditions_thenCorrect()
      throws Exception { 
        MediaType contentType = new MediaType(MediaType.APPLICATION_JSON.getType(),
        MediaType.APPLICATION_JSON.getSubtype(), Charset.forName("utf8"));
        andExpect(jsonPath("$", hasSize(4))); 

The above test calls the /entity/all endpoint and verifies that the JSON response contains 4 elements. For this test to pass, we also have to initialize our list in the controller class:


public class GenericEntityController {
    private List<GenericEntity> entityList = new ArrayList<>();

        entityList.add(new GenericEntity(1l, "entity_1"));
        entityList.add(new GenericEntity(2l, "entity_2"));
        entityList.add(new GenericEntity(3l, "entity_3"));
        entityList.add(new GenericEntity(4l, "entity_4"));

What is important here is that @WebAppConfiguration annotation and MockMVC are part of the spring-test module, hasSize is a Hamcrest matcher, and @Before is a JUnit annotation. These are all available by importing one this one starter dependency.


4. The Data JPA Starter


Most web applications have some sort of persistence – and that’s quite often JPA.


Instead of defining all of the associated dependencies manually – let’s go with the starter instead:



Notice that out of the box we have automatic support for at least the following databases: H2, Derby and Hsqldb. In our example, we’ll use H2.


Now let’s create the repository for our entity:


public interface GenericEntityRepository extends JpaRepository<GenericEntity, Long> {}

Time to test the code. Here is the JUnit test:


@SpringApplicationConfiguration(classes = Application.class)
public class SpringBootJPATest {
    private GenericEntityRepository genericEntityRepository;

    public void givenGenericEntityRepository_whenSaveAndRetreiveEntity_thenOK() {
        GenericEntity genericEntity = 
        GenericEntity foundedEntity = 
        assertEquals(genericEntity.getValue(), foundedEntity.getValue());

We didn’t spend time on specifying the database vendor, URL connection, and credentials. No extra configuration is necessary as we’re benefiting from the solid Boot defaults; but of course all of these details can still be configured if necessary.


5. The Mail Starter


A very common task in enterprise development is sending email, and dealing directly with Java Mail API usually can be difficult.

在企业开发中,一个很常见的任务是发送电子邮件,而直接与Java Mail API打交道通常会很困难。

Spring Boot starter hides this complexity – mail dependencies can be specified in the following way:

Spring Boot启动器隐藏了这种复杂性–邮件依赖关系可以通过以下方式指定。


Now we can directly use the JavaMailSender, so let’s write some tests.


For the testing purpose, we need a simple SMTP server. In this example, we’ll use Wiser. This is how we can include it in our POM:



The latest version of Wiser can be found on Maven central repository.


Here is the source code for the test:


@SpringApplicationConfiguration(classes = Application.class)
public class SpringBootMailTest {
    private JavaMailSender javaMailSender;

    private Wiser wiser;

    private String userTo = "user2@localhost";
    private String userFrom = "user1@localhost";
    private String subject = "Test subject";
    private String textMail = "Text subject mail";

    public void setUp() throws Exception {
        final int TEST_PORT = 25;
        wiser = new Wiser(TEST_PORT);

    public void tearDown() throws Exception {

    public void givenMail_whenSendAndReceived_thenCorrect() throws Exception {
        SimpleMailMessage message = composeEmailMessage();
        List<WiserMessage> messages = wiser.getMessages();

        assertThat(messages, hasSize(1));
        WiserMessage wiserMessage = messages.get(0);
        assertEquals(userFrom, wiserMessage.getEnvelopeSender());
        assertEquals(userTo, wiserMessage.getEnvelopeReceiver());
        assertEquals(subject, getSubject(wiserMessage));
        assertEquals(textMail, getMessage(wiserMessage));

    private String getMessage(WiserMessage wiserMessage)
      throws MessagingException, IOException {
        return wiserMessage.getMimeMessage().getContent().toString().trim();

    private String getSubject(WiserMessage wiserMessage) throws MessagingException {
        return wiserMessage.getMimeMessage().getSubject();

    private SimpleMailMessage composeEmailMessage() {
        SimpleMailMessage mailMessage = new SimpleMailMessage();
        return mailMessage;

In the test, the @Before and @After methods are in charge of starting and stopping the mail server.


Notice that we’re wiring in the JavaMailSender bean – the bean was automatically created by Spring Boot.

注意,我们正在为JavaMailSenderbean布线–该bean是由Spring Boot自动创建的

Just like any other defaults in Boot, the email settings for the JavaMailSender can be customized in


So we configured the mail server on localhost:25 and we didn’t require authentication.


6. Conclusion


In this article we have given an overview of Starters, explained why we need them and provided examples on how to use them in your projects.


Let’s recap the benefits of using Spring Boot starters:

让我们回顾一下使用Spring Boot启动器的好处。

  • increase pom manageability
  • production-ready, tested & supported dependency configurations
  • decrease the overall configuration time for the project

The actual list of starters can be found here. Source code for the examples can be found here.