Ratpack与Spring Boot的集成

1. Overview

Previously, we have introduced Ratpack and its integration with Google Guice.

In this quick article, we’ll show how Ratpack can be integrated with Spring Boot.

2. Maven Dependency

Before we continue, let’s add the following dependency into our pom.xml:

<dependency>
    <groupId>io.ratpack</groupId>
    <artifactId>ratpack-spring-boot-starter</artifactId>
    <version>1.4.6</version>
    <type>pom</type>
</dependency>

The ratpack-spring-boot-starter pom dependency automatically adds ratpack-spring-boot and spring-boot-starter into our dependencies.

3. Integrating Ratpack With Spring Boot

We can embed Ratpack in Spring Boot as an alternative to servlet containers provided by Tomcat or Undertow. We only need to annotate a Spring configuration class with @EnableRatpack and declare beans of type Action<Chain>:

@SpringBootApplication
@EnableRatpack
public class EmbedRatpackApp {

    @Autowired 
    private Content content;
 
    @Autowired 
    private ArticleList list;

    @Bean
    public Action<Chain> home() {
        return chain -> chain.get(ctx -> ctx.render(content.body()));
    }

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

For those more familiar with Spring Boot, the Action can act as a web filter and/or controller.

When it comes to serving static files, Ratpack registers handlers automatically for static resources under /public and /static in the @Autowired ChainConfigurers.

However, the current implementation of this “magic” depends on our project settings and development environment. So if we are to achieve stable serving of static resources in different environments, we should specify the baseDir explicitly:

@Bean
public ServerConfig ratpackServerConfig() {
    return ServerConfig
      .builder()
      .findBaseDir("static")
      .build();
}

The code above assumes that we have a static folder under classpath. Also, we name the ServerConfig bean to ratpackServerConfig to override the default bean registered in RatpackConfiguration.

Then we can test our application with ratpack-test:

MainClassApplicationUnderTest appUnderTest
  = new MainClassApplicationUnderTest(EmbedRatpackApp.class);

@Test
public void whenSayHello_thenGotWelcomeMessage() {
    assertEquals("hello baeldung!", appUnderTest
      .getHttpClient()
      .getText("/hello"));
}

@Test
public void whenRequestList_thenGotArticles()  {
    assertEquals(3, appUnderTest
      .getHttpClient()
      .getText("/list")
      .split(",").length);
}

@Test
public void whenRequestStaticResource_thenGotStaticContent() {
    assertThat(appUnderTest
      .getHttpClient()
      .getText("/"), containsString("page is static"));
}

4. Integrating Spring Boot With Ratpack

First, we will register required beans in a Spring configuration class:

@Configuration
public class Config {

    @Bean
    public Content content() {
        return () -> "hello baeldung!";
    }
}

Then we can create a registry easily using the convenience method spring(…) provided by ratpack-spring-boot:

public class EmbedSpringBootApp {

    public static void main(String[] args) throws Exception {
        RatpackServer.start(server -> server
          .registry(spring(Config.class))
          .handlers(chain -> chain.get(ctx -> ctx.render(ctx
            .get(Content.class)
            .body()))));
    }
}

In Ratpack, registries are used for inter-handler communication in request processing. The Context object that we use in handlers implements the Registry interface.

Here, a ListableBeanFactory instance provided by Spring Boot is adapted to a Registry, to back the registry in Handler‘s Context. Thus when we want to get an object of a specific type from Context, the ListableBeanFactory will be used to look up the matching beans.

5. Summary

In this tutorial, we explored how to integrate Spring Boot and Ratpack.

As always, the full implementation is available over on Github.