A while back I had tried out a small Spring Boot  based sample application with Scala as the language and found that the combination works out quite nicely — no big surprises there actually as Scala programs ultimately run in the JVM. I have now updated the sample with the latest version of Spring Boot and some of the supporting libraries.

To very quickly revisit the sample, it is a very simple web application with a UI to manage a "Hotel" domain object managed via JPA, represented in scala the following way:

import javax.persistence.Id
import javax.persistence.GeneratedValue
import java.lang.Long
import javax.persistence.Entity
import scala.beans.BeanProperty
import org.hibernate.validator.constraints.NotEmpty

@Entity
class Hotel {

 @Id
 @GeneratedValue
 @BeanProperty
 var id: Long = _

 @BeanProperty
 @NotEmpty
 var name: String = _

 @BeanProperty
 @NotEmpty
 var address: String = _

 @BeanProperty
 @NotEmpty
 var zip: String = _
}

JPA annotations carry over quite well, one wrinkle may be the additional @BeanProperty annotation though, this is required for JPA implementations as this makes the scala compiler generate the normal Java Beans type getters and setters instead of the scala default getters and setters which don't follow the Java Bean conventions.

Spring Data  makes it ridiculously simple to manage this domain type, all it requires is a marker interface and it generates a runtime implementation:

import org.springframework.data.repository.CrudRepository
import mvctest.domain.Hotel
import java.lang.Long

trait HotelRepository extends CrudRepository[Hotel, Long]

Now I have a toolkit available for managing the Hotel domain:

//save or update a hotel
hotelRepository.save(hotel)

//find one hotel
hotelRepository.findOne(id)

//find all hotels
val hotels = hotelRepository.findAll()

//delete a hotel
hotelRepository.delete(id)

And finally a controller to manage the UI flow with this repository:

@Controller
@RequestMapping(Array("/hotels"))
class HotelController @Autowired()(private val hotelRepository: HotelRepository) {

 @RequestMapping(method = Array(RequestMethod.GET))
 def list(model: Model) = {
 val hotels = hotelRepository.findAll()
 model.addAttribute("hotels", hotels)
 "hotels/list"
 }

 @RequestMapping(Array("/edit/{id}"))
 def edit(@PathVariable("id") id: Long, model: Model) = {
 model.addAttribute("hotel", hotelRepository.findOne(id))
 "hotels/edit"
 }

 @RequestMapping(method = Array(RequestMethod.GET), params = Array("form"))
 def createForm(model: Model) = {
 model.addAttribute("hotel", new Hotel())
 "hotels/create"
 }

 @RequestMapping(method = Array(RequestMethod.POST))
 def create(@Valid hotel: Hotel, bindingResult: BindingResult) = {
 if (bindingResult.hasErrors()) {
 "hotels/create"
 } else {
 hotelRepository.save(hotel)
 "redirect:/hotels"
 }
 }

 @RequestMapping(value = Array("/update"), method = Array(RequestMethod.POST))
 def update(@Valid hotel: Hotel, bindingResult: BindingResult) = {
 if (bindingResult.hasErrors()) {
 "hotels/edit"
 } else {
 hotelRepository.save(hotel)
 "redirect:/hotels"
 }
 }

 @RequestMapping(value = Array("/delete/{id}"))
 def delete(@PathVariable("id") id: Long) = {
 hotelRepository.delete(id)
 "redirect:/hotels"
 }
}

There are some wrinkles here too but should mostly make sense, the way the repository is autowired is a little non-intuitive and the way an explicit Array type has to be provided for request mapping paths and methods may be confusing.

Beyond these small concerns the code just works, do play with it, I would love any feedback on ways to improve this sample. Here is the git location of this sample.