Task 5 - Implementing service components using JPA

Step 1

In the previous exercise, you added Maven to manage your project's dependencies. This time, it will allow downloading and managing libraries for JPA and Spring technologies.

In the configuration file, inside the project element, add the following parent element and the dependency elements inside dependencies, as shown below:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.4</version>
    <relativePath/>
</parent>
...

<dependencies>
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>
</dependencies>

The basic structure of the project should be as follows:

gamestudio // main directory of the project
├── src
│  ├── main // directory with project's source files
│  │  ├── java
│  │  │  └── sk
│  │  │     └── tuke
│  │  │        └── gamestudio  // main package of project GameStudio
│  │  │           ├── entity   // package for entity classes
│  │  │           ├── game     // package for games
│  │  │           ├── server   // application server side package
│  │  │           ├── service  // interfaces and implementation of service components
│  │  │           └── SpringClient.java  // main class for running the client side of the application
│  │  └── resources  // resources of the project (images, configuration files, etc.)
│  │     └── application.properties  // file containing project properties
│  └──  test  // directory with source files of tests
├── .gitignore
├── pom.xml  // Maven configuration file

The project is managed as a Maven project [1] using the pom.xml configuration file. It is also a Spring Boot project [2] and uses the JPA library [3].

If the file is missing, create it in src/main/resources/ as shown in the project structure above.

The file should contain the following properties:

#https://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html
spring.datasource.url=jdbc:postgresql://localhost/gamestudio
spring.datasource.username=postgres
spring.datasource.password=postgres
spring.datasource.driver-class-name=org.postgresql.Driver
spring.datasource.hikari.maximumPoolSize=2
#spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation=true

Update the database connection-related properties, namely url, username, and password, according to your database settings.

Step 2

In this step you will add annotations to entity classes that allow using the Java Persistence API - in short JPA.

An example for the Score entity:

package sk.tuke.gamestudio.entity;

import javax.persistence.GeneratedValue;
import javax.persistence.Id;
...

public class Score implements Serializable {
    @Id
    @GeneratedValue
    private int ident; // identifier for DB entries
    ...
    
    // parameterless constructor which we added now 
    public Score() {}

    // original constructor
    public Score(String player, String game, int points, Date playedOn) {...}

    public int getIdent() { return ident; }
    public void setIdent(int ident) { this.ident = ident; }

    ...
    
}

The entity classes now only need the annotation marking them as entity classes and the named query that will be used in the JPA service component.

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
...

@Entity
@NamedQuery( name = "Score.getTopScores",
             query = "SELECT s FROM Score s WHERE s.game=:game ORDER BY s.points DESC")
@NamedQuery( name = "Score.resetScores",
             query = "DELETE FROM Score")
public class Score implements Serializable {
    ...
}

comment: <> (> For the Rating class, you will need two named queries (for the getRating() method and the getAverageRating() method). In this case, you must use the container annotation @NamedQueries from the same package.)

Step 3

Example implementation of the Score service in JPA:

package sk.tuke.gamestudio.service;

import sk.tuke.gamestudio.entity.Score;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.transaction.Transactional;
. . .

@Transactional
public class ScoreServiceJPA implements ScoreService {
    
   @PersistenceContext
   private EntityManager entityManager;

   @Override
   public void addScore(Score score) throws ScoreException {
      entityManager.persist(score);
   }

   @Override
   public List<Score> getTopScores(String game) throws ScoreException {
       return entityManager.createNamedQuery("Score.getTopScores")
           .setParameter("game", game).setMaxResults(10).getResultList();
   }

    @Override
    public void reset() {
        entityManager.createNamedQuery("Score.resetScores").executeUpdate();
        // alebo:
        // entityManager.createNativeQuery("delete from score").executeUpdate();
    }
}

Explanation:

• The annotation @Transactional defines a new transactional service.
• PersistenceContext - represents something like a cache. It has its own, unshared database connection (more about JPA concepts).
• EntityManager entityManager - an injected entity manager instance representing PersistenceContext; its instance will be automatically injected into this variable.
• entityManager.persist(score) - stores the given entity in the database through the entity manager.
• entityManager.createNamedQuery("Score.getTopScores") - uses the named query defined in the @NamedQuery annotation in class Score to create a database query. Then setParameter("game", game) sets the query parameter, getMaxResults(10) limits the number of returned entries, and getResultList() returns the query result as a list of Score instances.

Step 4

In this step you will integrate the created services into your game.

public class ConsoleUI {
    private Field field;

    @Autowired
    private ScoreService scoreService;

    ...
}

Step 5

In this step, the game will be run together with the new service implementation as a Spring Boot application.

An example of a main class for the Minesweeper game is the following:

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import sk.tuke.gamestudio.game.mines.consoleui.ConsoleUI;
import sk.tuke.gamestudio.game.mines.core.Field;
import sk.tuke.gamestudio.service.ScoreService;
import sk.tuke.gamestudio.service.ScoreServiceJPA;

@SpringBootApplication
@Configuration
public class SpringClient {

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

    @Bean
    public CommandLineRunner runner(ConsoleUI ui) {
        return args -> ui.play();
    }

    @Bean
    public ConsoleUI consoleUI(Field field) {
        return new ConsoleUI(field);
    }

    @Bean
    public Field field() {
        return new Field(9, 9, 1);
    }

    @Bean
    public ScoreService scoreService() {
        return new ScoreServiceJPA();
    }
}

Explanation:

• The annotations @Configuration and @SpringBootApplication mark the main class of the Spring Boot application.
• The main method runs the project as a Spring Boot application and defines its main class as the argument of SpringApplication.run(...).
• All methods annotated with @Bean are components whose instances are automatically created during runtime. Their initialization is defined inside the methods.
• The main component of the application is a CommandLineRunner, which represents any component that runs in a console interface. In our case, it is the ConsoleUI, which will be started by calling play().
• Other defined components are ConsoleUI and Field, where both methods define their initialization.

After completing the required adjustments, run your game and verify its functionality as well as the functionality of the service components. The game should now run through Spring Boot.

Step 6