In this tutorial, you will learn how to develop a simple web application using Spring Boot and Scala.
Scala is one of the most popular JVM-based programming languages. It mixes functional programming and object-oriented programming idioms into a single language.
1. Creating Spring Boot Project
Spring Initializer (http://start.spring.io) doesn’t provide support for Scala yet, but you can create Spring Boot applications using the Scala programming language by configuring appropriate plugins based on the build tool you are using.
If you want to use Maven as a build tool, you can use scala-maven-plugin to compile your Scala code.
2. Add Maven Dependencies
Add the Web, Spring Data JPA, Thymeleaf, and H2 starter dependencies.
<?xml version="1.0" encoding="UTF-8"?>
<project
xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>net.sourcecodeexamples</groupId>
<artifactId>springboot-scala-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>springboot-scala-demo</name>
<description>Demo project for Spring Boot</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.0.RELEASE</version>
<relativePath/>
<!-- lookup parent from repository -->
</parent>
<properties>
<kotlin.compiler.incremental>true</kotlin.compiler.incremental>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
<scala.version>2.11.1</scala.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.scala-lang</groupId>
<artifactId>scala-library</artifactId>
<version>${scala.version}</version>
</dependency>
</dependencies>
<build>
<sourceDirectory>src/main/scala</sourceDirectory>
<testSourceDirectory>src/test/scala</testSourceDirectory>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<version>3.2.1</version>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>testCompile</goal>
</goals>
</execution>
</executions>
<configuration>
<jvmArgs>
<jvmArg>-Xms64m</jvmArg>
<jvmArg>-Xmx1024m</jvmArg>
</jvmArgs>
</configuration>
</plugin>
</plugins>
</build>
</project>
3. User.scala
Create a JPA entity called User.scala and add the following content to it:
import javax.persistence._
import scala.beans.BeanProperty
@Entity
@Table(name = "users")
class User {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@BeanProperty
var id: Long = _
@BeanProperty
var name: String = _
@BeanProperty
var email: String = _
}
You are using the @BeanProperty to generate setters and getters for fields based on the JavaBean naming conventions.
4. UserRepository.scala
Now you’ll see how to create the Spring Data JPA repository for the User entity. As Scala doesn’t have interfaces, you are going to create UserRepository as a trait:
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.repository.query.Param
trait UserRepository extends JpaRepository[User, java.lang.Long] {
def findByEmail(@Param("email") name: String): List[User]
}
5. HomeController.scala
Let's create a Spring MVC controller to show the list of users:
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Controller
import org.springframework.ui.Model
import org.springframework.web.bind.annotation. {
GetMapping
}
@Controller
class HomeController {
@Autowired
var repo: UserRepository = _
@GetMapping(Array("/"))
def home(model: Model): String = {
model.addAttribute("users", repo.findAll())
"home"
}
}
6. data.sql
Here is a data.sql script to populate sample users:
delete from users;
insert into users(id, name, email) values
(1,'admin','admin@gmail.com'),
(2,'code','code@gmail.com'),
(3,'test','test@gmail.com');
7. src/main/resources/templates/home.html
Create the Thymeleaf view home.html to render users:
<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>Users List</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
<table>
<thead>
<tr>
<th>Id</th>
<th>Name</th>
</tr>
</thead>
<tbody>
<tr th:each="user : ${users}">
<td th:text="${user.id}">Id</td>
<td th:text="${user.name}">Name</td>
</tr>
</tbody>
</table>
</body>
</html>
8. Application
Next, you are going to create the application main entry point class. As Scala doesn’t support static methods, you have to create a companion object and write the main() method:
import org.springframework.boot.SpringApplication
import org.springframework.boot.autoconfigure.SpringBootApplication
@SpringBootApplication
class Application {
}
object Application {
def main(args: Array[String]) : Unit = {
SpringApplication.run(classOf[Application], args:_*)
}
}
Now you can run Application.main(), which starts your Spring Boot application and accesses it at http://localhost:8080/. You can also use below command to run this spring boot app:
springboot-scala-demo> mvn spring-boot:run
This shows a list of users.
Comments
Post a Comment