The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Introduction to Play Framework

Next ►
►

The Play Framework is a powerful, lightweight, and highly scalable web application framework for Scala and Java. It is designed to provide a productive development environment by leveraging modern web development principles and practices. In this section, we will cover the basics of the Play Framework, including its setup, core concepts, and a simple example to get you started.

Key Concepts

  1. Reactive Programming: Play is built on Akka, which allows it to handle asynchronous and non-blocking operations efficiently.
  2. Stateless and RESTful: Play encourages the development of stateless and RESTful applications.
  3. Hot Reloading: Play supports hot reloading, which means you can see the changes in your code without restarting the server.
  4. Built-in Testing: Play comes with built-in testing support, making it easier to write and run tests.

Setting Up Play Framework

Prerequisites

  • Java Development Kit (JDK): Ensure you have JDK 8 or higher installed.
  • Scala: Ensure you have Scala installed.
  • SBT (Scala Build Tool): Ensure you have SBT installed.

Creating a New Play Project

  1. Open a terminal and run the following command to create a new Play project:

    sbt new playframework/play-scala-seed.g8

  2. Navigate to the project directory:

    cd <project-name>

  3. Run the Play application:

    sbt run

  4. Open your browser and navigate to http://localhost:9000 to see the default Play welcome page.

Core Concepts

Routes

Routes define the mapping between HTTP requests and the corresponding actions in your application. The conf/routes file contains these mappings.

Example:

GET     /                           controllers.HomeController.index
POST    /submit                     controllers.HomeController.submit

Controllers

Controllers handle the incoming HTTP requests and generate responses. They are defined in the app/controllers directory.

Example:

package controllers

import javax.inject._
import play.api.mvc._

@Singleton
class HomeController @Inject()(cc: ControllerComponents) extends AbstractController(cc) {

  def index = Action { implicit request: Request[AnyContent] =>
    Ok("Welcome to Play Framework!")
  }

  def submit = Action { implicit request: Request[AnyContent] =>
    Ok("Form submitted!")
  }
}

Views

Views are responsible for rendering the HTML content. Play uses Twirl as its default templating engine. Views are located in the app/views directory.

Example (index.scala.html):

@(message: String)

<!DOCTYPE html>
<html>
  <head>
    <title>Welcome to Play</title>
  </head>
  <body>
    <h1>@message</h1>
  </body>
</html>

Models

Models represent the data and business logic of your application. They are typically defined in the app/models directory.

Example:

package models

case class User(id: Long, name: String, email: String)

Practical Example

Let's create a simple Play application that displays a list of users.

Step 1: Define Routes

Add the following routes to the conf/routes file:

GET     /users                      controllers.UserController.listUsers

Step 2: Create Controller

Create a new controller UserController in the app/controllers directory:

package controllers

import javax.inject._
import play.api.mvc._
import models.User

@Singleton
class UserController @Inject()(cc: ControllerComponents) extends AbstractController(cc) {

  def listUsers = Action { implicit request: Request[AnyContent] =>
    val users = List(
      User(1, "John Doe", "[email protected]"),
      User(2, "Jane Smith", "[email protected]")
    )
    Ok(views.html.users(users))
  }
}

Step 3: Create View

Create a new view users.scala.html in the app/views directory:

@(users: List[models.User])

<!DOCTYPE html>
<html>
  <head>
    <title>User List</title>
  </head>
  <body>
    <h1>Users</h1>
    <ul>
      @for(user <- users) {
        <li>@user.name - @user.email</li>
      }
    </ul>
  </body>
</html>

Step 4: Run the Application

Run the Play application using the following command:

sbt run

Open your browser and navigate to http://localhost:9000/users to see the list of users.

Summary

In this section, we introduced the Play Framework, set up a new Play project, and explored its core concepts such as routes, controllers, views, and models. We also created a simple example application to display a list of users. This should give you a solid foundation to start building web applications using the Play Framework.

Next, we will delve into more advanced topics and tools in the Scala ecosystem.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved