Writing better Spring applications using SpringFu

Writing better Spring applications using SpringFu

“Truth can only be found in one place: the code,” Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship.

The way we structure our code has a direct impact on how understandable is it. Code that is easy to follow with no or less hidden functionality is much easier to maintain. It also makes it easier for our fellow programmers to track down bugs in the code. This helps us to avoid Venkat’s Jesus Driven Development.

The way I write Spring applications comprises heavy use of Spring annotations. The problem with this approach is that partial flow of the application is controlled by annotations. The complete flow of my code is not in one place, that is, in my code. I need to look back to the documentation to understand the annotations’ behavior. By reading just the code, it is difficult to predict the flow of control.

Luckily, Spring has a new way to code to and it has been called Spring Functional or SpringFu. In this article, I will use Kotlin to showcase some of the benefits you get from SpringFu.

SpringFu to the rescue

Let’s start with a simple Spring-based application using the annotations approach. The first annotation we meet is @SpringBootApplication and it does many things. Surely this information is not captured in the code when you use this annotation, as you can see in the “Code with annotations” section below. When we proceed further in the code with annotations, @RestController does a series of things which further complicates the readability of code with respect to the control flow.

@RequestMapping, @Autowired, and @Component all add up to the problem I mentioned above. Spring has to use reflection, Kotlin open classes, and all kind of facilities to make this code (magic) work. What if my goal is to read the code—and only the code—to understand the control flow.

Reducing the usage of reflection will also help us in moving towards GraalVM based native code. First, take a look at the code with annotations below and see if you can get the flow of control. You can get a full example at my GitHub repository.

Code with annotations

@SpringBootApplication
class SpringWithAnnotationsApplication
  fun main(args: Array<String>) {
    runApplication<SpringWithAnnotationsApplication>(*args)
  }

@RestController
@RequestMapping("/events")
class EventHandler {
  @Autowired
  lateinit var eventService: EventService

  @GetMapping("/")
  fun getAllEvents () : List<Event> {
    return eventService.getAllEvents()
  }
}

@Component
class EventService {
  fun getAllEvents() : List<Event>{
    return listOf(
                  Event(name = "event1", description = "desc1"),
                  Event(name = "event2", description = "desc2")
                 )
  }
}

data class Event (val name: String, val description: String)

Visit Stack Overflow (some say Stack Overflow is the true technical lead) and you can find many questions about the right way to use annotations. The number and variety of questions will give you an idea of how important code readability is.

“Programs must be written for people to read, and only incidentally for machines to execute,” Abelson and Sussman.

Code with no annotations

Now let’s try to write the same code using the SpringFu approach. The code is more readable and I can follow the full flow by just reading it. The flow of the code below is as follows.

  • I have a main function which loads my appSimple DSL.
  • The AppSimple DSL imports the Spring beans (which I have loaded in the eventBeans DSL) and configures what the server should do using the eventRoutes DSL.

//create an application
//remember no @SpringBootApplication
fun main(args: Array<String>) {
  appSimple.run()
}

//using the application dsl, i define what my service will listen to
val appSimple = application {
  //use the beans i define
  import(eventBeans)
  
  //http server listens for this endpoint
  server {
    import(::eventRoutes)
    codecs {
      jackson()
    }
  }
}

//define beans
val eventBeans = beans {
  bean<EventService>()
  bean<EventHandler>()
}

//define on what endpont i would be listening
//@RestController
//@RequestMapping("/events")
//@GetMapping("/")
fun eventRoutes(handler: EventHandler) = router {
  "/events".nest {
    GET("/", handler::generateResponse)
  }
}

//create the handler for http request
class EventHandler(private val eventService: EventService) {
  fun generateResponse(request: ServerRequest) = ServerResponse.ok().body(
    BodyInserters.fromObject(eventService.getAllEvents())
  )
}

//business logic
// no need to @Component
class EventService {
  fun getAllEvents(): List<Event> {
    return mutableListOf(
                         Event(name = "event1", description = "desc1"),
                         Event(name = "event2", description = "desc2")
    )
  }
}

data class Event(val name: String, val description: String)

No need to open classes

When using annotations, we need to make all classes open in order for Spring to work. See the pom.xml section below from the code. With SpringFu, final classes  are acceptable. Note the usage of the kotlin-maven-plugin below showcasing the use of automatically opening all the classes. This is some additional logic outside of my code and makes things difficult to read.

<plugin>
  <artifactId>kotlin-maven-plugin</artifactId>
  <groupId>org.jetbrains.kotlin</groupId>
  <configuration>
    <args>
      <arg>-Xjsr305=strict</arg>
    </args>
    <compilerPlugins>
      <plugin>spring</plugin>
    </compilerPlugins>
  </configuration>
  <dependencies>
    <dependency>
      <groupId>org.jetbrains.kotlin</groupId>
      <artifactId>kotlin-maven-allopen</artifactId>
      <version>${kotlin.version}</version>
    </dependency>
  </dependencies>
</plugin>

Conclusion

SpringFu is an exciting new project that enables us to write cleaner, more-readable code and offers more control for Spring-based applications. It builds on your existing Java/Kotlin knowledge, which makes the task of learning it a bit easier. One of the exciting goals is to able to write native applications using GraalVM. Be aware that some of the SpringFu components are not production-ready yet.

Kotlin is an exciting new programming language especially if you are coming from a Java background. You can start your Kotlin journey by attending this coursera course.

In addition, you might find these other Spring articles helpful.

For more information about Red Hat OpenShift and other related topics, visit: OpenShift, OpenShift Online.

Share