Task 6 - Web REST services

Step 1

Add the following to the existing project dependencies (dependencies):

<dependencies>

    ... //keep the previously added dependencies unchanged

      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
</dependencies>

The original application initialization in main(), which looked like this:

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

should be changed to:

public static void main(String[] args) {
    new SpringApplicationBuilder(SpringClient.class).web(WebApplicationType.NONE).run(args);
}

Step 2

In this step, you will implement the code for starting the server-side part of the application.

The implementation of the GameStudioServer class will initially contain a main() method, which is very similar to the one in SpringClient before the modification from the previous step:

package sk.tuke.gamestudio.server;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.Configuration;

@SpringBootApplication
@Configuration
@EntityScan("sk.tuke.gamestudio.entity")
public class GameStudioServer {
    public static void main(String[] args) {
        SpringApplication.run(GameStudioServer.class, args);
    }
}

After adding the new dependency to the project (Step 1), the Tomcat web server library will also be downloaded and configured. This server usually runs on port 8080.

If the server starts correctly, the terminal will display a message ending with Started GameStudioServer in ... seconds. When you open a web browser at localhost:8080, you will get a 404 response for now, since there is no content available at that address yet. However, the server was able to respond to the request, which means it is running.

After this step, your application will be split into client and server parts. For simplicity, both parts are still implemented in one shared project.

Step 3

In this step, you will implement a REST service that exposes the service component over the HTTP web protocol. The implementation is straightforward. For the Score service, there will be two methods available: one for retrieving the best scores (GET) and one for storing a score (POST).

The implementation of the REST service methods is simple, because they only use the methods of the injected ScoreService implementation. Spring will handle everything else.

The class implementing the Score service will be named ScoreServiceRest and will look as follows:

package sk.tuke.gamestudio.server.webservice;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import sk.tuke.gamestudio.entity.Score;
import sk.tuke.gamestudio.service.ScoreService;

import java.util.List;

@RestController
@RequestMapping("/api/score")
public class ScoreServiceRest {
    
    @Autowired
    private ScoreService scoreService;

    @GetMapping("/{game}")
    public List<Score> getTopScores(@PathVariable String game) {
        return scoreService.getTopScores(game);
    }

    @PostMapping
    public void addScore(@RequestBody Score score) {
        scoreService.addScore(score);
    }
}

The important annotations in the example are:

• @RestController - marks the component as a REST service,
• @RequestMapping("/api/score") - the service URL on the server, at which the service will be available,
• @PostMapping - the annotated method will represent a REST POST method,
• @GetMapping - the annotated method will represent a REST GET method,
• @PathVariable - marks the method parameter whose value will be filled from a part of the URL; in our case, it is the game name, e.g. from /api/score/mines the value of the parameter will be mines,
• @RequestBody - marks the method parameter that will be filled from the request body.

Example for the ScoreService:

package sk.tuke.gamestudio.server;

import org.springframework.boot.SpringApplication;
// ... dalsie importy

@SpringBootApplication
@Configuration
@EntityScan("sk.tuke.gamestudio.entity")
public class GameStudioServer {
    public static void main(String[] args) {
        SpringApplication.run(GameStudioServer.class, args);
    }
    
    @Bean
    public ScoreService scoreService() {
        return new ScoreServiceJPA();
    }
}

Step 4

You can test the server before moving on. Start it by running the main server class GameStudioServer. The server will start on port 8080.

Prepare HTTP requests to test the services. For example, try GET via a browser at http://localhost:8080/api/score/mines.

Comment

To test REST services, you can create a file with the .http extension, write individual requests into it, and run them directly in IntelliJ IDEA.

Step 5

In this step, we create a REST client service on the client side of the GameStudio application using the already created REST web interface. The example will be described using the Score service.

To use REST methods, we will use an object of type RestTemplate, which can be injected from outside using the @Autowired annotation.

package sk.tuke.gamestudio.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.client.RestTemplate;
import sk.tuke.gamestudio.entity.Score;

import java.util.Arrays;
import java.util.List;

public class ScoreServiceRestClient implements ScoreService {
    private final String url = "http://localhost:8080/api/score";

    @Autowired
    private RestTemplate restTemplate;
    //private RestTemplate restTemplate = new RestTemplate();

    @Override
    public void addScore(Score score) {
        restTemplate.postForEntity(url, score, Score.class);
    }

    @Override
    public List<Score> getTopScores(String gameName) {
        return Arrays.asList(restTemplate.getForEntity(url + "/" + gameName, Score[].class).getBody());
    }
    
    @Override
    public void reset() {
        throw new UnsupportedOperationException("Not supported via web service");
    }
}

When injecting RestTemplate from outside, you also need to create an appropriate method in the SpringClient class, annotated with @Bean, which returns a RestTemplate object.

Step 6

In this step, we will use the created REST clients in the client side of the GameStudio application.

Example for ScoreService:

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

Modify the other service components in the same way.

Since the client and server applications are simplified into one shared project, we need to prevent conflicts when scanning available components.

Use the annotation as follows:

...
@ComponentScan(excludeFilters = @ComponentScan.Filter(type = FilterType.REGEX,
        pattern = "sk.tuke.gamestudio.server.*"))
public class SpringClient {
    ...
}

Start the client by running its main class SpringClient and try to play the game. When using service components, the client sends an HTTP request to the server, which communicates with the database during request processing and sends a response or the requested data back to the client.

Step 7