CSU33012-J-springboot(3).pdf

CSU33012 Software Engineering
J. Introduction to Spring Boot
Goetz Botterweck

Change Log
2023-10-09 First version
2023-10-11 Added Section 5 “Library (More Complex Example using Spring MVC Web Controller, JPA,
Repositories, H2)”
2023-10-18 Using external services, first steps in GitLab
2
CSU33012 Goetz Botterweck

J. Introduction to
Spring Boot
CSU33012 Goetz Botterweck 3

References
Online Courses
(Bowman 2019) Bowman, Mary Ellen. Creating Your First Spring Boot Microservice, 1h
48min, Linked-in Learning, 2019.
https://www.linkedin.com/learning/creating-your-first-spring-boot-microservice/
4
CSU33012 Goetz Botterweck

1. Introduction to Spring
Boot

1.1 Prerequisites

Prerequisites
• Java
• Version 17
• java --version
should print a version number like 17.x.x
• Maven
• mvn --version
should print a version number like 3.9.x
• IDE
• IntelliJ IDEA Ultimate or
• Visual Studio Code
• Spring Tools for VSCode, https://spring.io/tools

Also useful
• Tools for Working with REST APIs
• postman
• https://www.postman.com/downloads/
• mostly app, there is also online version at https://www.postman.com/
• httpie
• https://httpie.io/
• mostly for terminal, there is also beta version of app
• Account on the local GitLab installation
• http://gitlab.scss.tcd.ie/

1.2 Apache Maven

Apache Maven
• Download, https://maven.apache.org/download.cgi
• Install, https://maven.apache.org/install.html
• Unzip
• Make sure that Maven’s bin directory is in your path
• mvn --version
should print a version number like 3.9.x
• Apache in 5 minutes (see below)
https://maven.apache.org/guides/getting-started/maven-in-five-
minutes.html
Image: https://en.m.wikipedia.org/wiki/File:Apache_Maven_logo.svg

Apache Maven
• Tool to build and manage software projects
• Key Features
• Dependency Management
• Building Projects
• Plugin-based Architecture
• Benefits
• Standardized Build Process
• Consistent Project Structures
• Alternative: Gradle

Maven Standard Directory Structure
https://www.baeldung.com/maven-directory-structure

Maven in 5min
https://maven.apache.org/guides/getting-started/maven-in-five-minutes.html
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -
DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -
DinteractiveMode=false
If running in Windows Powershell, Maven will raise a false error
(pom.xml missing). Use cmd.exe or enclose parameters in quotes.
https://stackoverflow.com/questions/16348459/error-the-goal-
you-specified-requires-a-project-to-execute-but-there-is-no-pom

Maven in 5min
cd my-app
mvn package

Maven in 5min – pom.xml
<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>com.mycompany.app</groupId>
<artifactId>my-app</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

Maven in 5min
java -cp target/my-app-1.0-SNAPSHOT.jar com.mycompany.app.App
Later in Spring Boot you can start the jar directly
without classpath, somewhat like
java -jar target/my-app-1.0-SNAPSHOT.jar
Here that does not work.

1.3 Basic Concepts Used in
Spring Boot

Inversion of Control
Previously
• Main program (our program)
• Controls flow of data and
execution
• Calls components
• Sets up references between
components
With Inversion of Control
• Framework (or Container)
• Controls flow of data and
execution
• Is responsible for„plumbing“
everything together
• Our Program
• We only have to specify what we
need
• In Spring Boot
• through annotating parts of a Java
program with tags like
@Service
@SpringBootApplication
• Uses Dependency Injection

Key Concepts in Inversion of Control
• Inversion of Control (IoC)
• Framework (a.k.a. the container) is responsible for handling the start-up,
including the instantiation of components (Beans), connecting them
• Dependency Injection
• Mechanism to implement IoC
• Component does not set up dependency, instead the framework/container
„injects“ them into the component.
• Application Context
• Spring Boot‘s version of framework/container

Inversion of Control Examples
package ie.tcd.scss.learningspring;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
public class LearningSpringApplication {
public static void main(String[] args) {
SpringApplication.run(LearningSpringApplication.class, args);
}
}
Upon starting the
application Spring Boot will
scan for annotations and
instantiate and connect the
necessary components.

Inversion of Control Examples
(Turnquist, p. 6-7)
...
class BookExample {
@Bean
public BookRepository bookRepository(DataSource dataSource) {
return new BookRepository();
}
...
}
• bookRepository needs a DataSource.
• Application context needs to provide one, either has it or will go create one and return it.
• Application context is responsible for management during execution
• bookRepository executes its code while referencing the app context’s DataSource.
• BookRepository is registered in the application context under the name
bookRepository.

1.4 What is Spring Boot?

Spring Boot
• Open-source, Java-based framework
• “Beginners version” of Spring
(based on Spring, makes it easier to get started)
• Conventions over Configuration
• Autoconfiguration
• Upon start application examines the parts of that application
• Adds additional Spring beans to application context
• Standalone
• No deployment, instead web server embedded in the application

1.5 Spring Boot Starters

Spring Boot Starters
https://www.baeldung.com/spring-boot-starters
<?xml version="1.0" encoding="UTF-8"?>
<project …>
...
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
...
</project>
Adding Starter to pom.xml as dependency … … ensures additional libraries are
included and annotations are available
These are what is added to your project,
when you select „Dependencies“ in
Spring Initializr (more later)

Spring Boot Starters – Examples
• Spring Web – applications that offer REST-based APIs, uses Spring
MVC, uses Apache Tomcat as the default embedded container.
• Spring WebFlux – alternative to Spring Web, based on reactive
streams
• See examples in (Larsson 2023)
• See https://www.baeldung.com/spring-mvc-async-vs-webflux
• Spring Data JPA – accessing data via Java Persistence API (JPA)
• Spring Test – testing your application
• Spring Mail – sending emails
Source: https://www.baeldung.com/spring-boot-starters

2. Creating a Web
Application with Spring
Boot

So, what do we need?
• We want to setup a basic project and its file structure
• Based on Java, Maven, Spring Boot
• We want to build a simple web application
(that responds to a HTTP request with a response)
/hello → Hello World!

2.1 Spring Initializr

Spring Initializr
• Fast way to set up a Spring Boot
project
• Build management
• Maven
• Gradle
• Language
• Java
• Kotlin
• Groovy
• Spring Boot Version
• Project Metadata
• Packaging
• Java Version
• Dependencies (to add
functionality)

Spring Initializr
• Fast way to set up a Spring Boot
project
• Build management
• Maven
• Gradle
• Language
• Java
• Kotlin
• Groovy
• Spring Boot Version
• Project Metadata
• Packaging
• Java Version
• Dependencies (to add
functionality)
Spring Initializr
API
start.spring.io
Website
Spring Initializr
Support in
IntelliJ IDEA
„Spring Initializr
Java Support“
vscode-spring-initializr
In VS Code

Spring Initializr
• http://start.spring.io
• Project = Maven
• Language = Java
• Spring Boot = default (3.x)
• Group = ie.tcd.scss
• Artifact = learningspring
• Packaging = Jar
• Java = 17
• Dependencies
• Spring Web
• Generate
• Download and unpack
• Open project in your IDE

Resulting Project in IntelliJ IDEA

HELP.md contains some helpful references

The New App

2.2 Running the Application

Running the Application
Alternative

http://localhost:8080/
Toolbar
“Run Actions”
More run and
debug actions

http://localhost:8080/

Same in Postman
https://www.postman.com/

3. Hello World
(Minimal Spring MVC Web Controller)

3.1 Creating a Test

• Go to src/test/java/ie.tcd.scss.learningspring
• Create new class HelloControllerTest
• Add content on next slide
• Right click src/test/java > Run all tests (Ctrl-Shift-F10)
• Inspect test results

HelloControllerTest
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.web.server.LocalServerPort;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.context.annotation.Profile;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class HelloControllerTest {
@LocalServerPort
private int port;
@Autowired
private TestRestTemplate restTemplate;
@Test
public void helloShouldReturnDefaultMessage() {
ResponseEntity<String> response = this.restTemplate.getForEntity("http://localhost:" + port + "/hello", String.class);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(response.getBody()).contains("Hello, World!");
}
@Test
public void helloShouldReturnDefaultMessageDetailed() {
String url = "http://localhost:" + port + "/hello";
String expectedResult = "Hello, World!";
Class<String> returnType = String.class;
ResponseEntity<String> response = this.restTemplate.getForEntity(url, returnType);
assertThat(response.getBody()).contains(expectedResult);
}
}

HelloControllerTest
import ...
@LocalServerPort
private int port;
@Autowired
...
@Test
public void helloShouldReturnDefaultMessageDetailed() {
String url = "http://localhost:" + port + "/hello";
String expectedResult = "Hello, World!";
Class<String> returnType = String.class;
ResponseEntity<String> response = this.restTemplate.getForEntity(url, returnType);
assertThat(response.getBody()).contains(expectedResult);
}
}
Step-by-step

HelloControllerTest
import ...
@LocalServerPort
private int port;
@Autowired
@Test
public void helloShouldReturnDefaultMessage() {
ResponseEntity<String> response = this.restTemplate.getForEntity("http://localhost:" + port + "/hello", String.class);
assertThat(response.getBody()).contains("Hello, World!");
}
...
}
Same test, but less
intermediate steps

Creating HelloControllerTest

Copying Text from Slides PDF
If text copies from PDF looks garbled
Edit > Find > Replace (Ctrl + R)
Search for: u000B (or select the weird VT character)
Replace with: n
Activate regular expressions .* (Alt + X)
Replace all (Alt + A)

HelloControllerTest in IntelliJ IDEA

3.2 Running the Test

Command Line
mvn test

Running Tests on Command Line
Enter = Just run the command
Ctrl + Enter = Run with IDE integration

Running Tests on Command Line (plain)

Running Tests on Command Line (with Integration)

3.3 Creating the MVC Web
Controller

Create New Class HelloController

HelloController
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@GetMapping("/hello")
public String hello() {
return "Hello, World!";
}
}

HelloController

Run All Tests Again

4. Music Styles
(Storing and Retrieving Info with Spring MVC Web
Controller)

Music Styles
• Can store mapping artist->genre
• The Weeknd → R&B
• Eminem → Hip Hop
• Michael Jackson → Pop
• Adele → Pop
• Can retrieve info on given artist
• In: Eminem
Out: Hip Hop
• Can list all artists for a given genre
• In: Pop
Out: Michael Jackson, Adele

class ArtistInfo
package com.example.musicstyles;
public class ArtistInfo {
private String artist;
private String musicStyle;
public ArtistInfo(String artist, String musicStyle) {
this.artist = artist;
this.musicStyle = musicStyle;
}
public String getArtist() {
return artist;
}
public void setArtist(String artist) {
this.artist = artist;
}
public String getMusicStyle() {
return musicStyle;
}
public void setMusicStyle(String musicStyle) {
this.musicStyle = musicStyle;
}
}
Image: https://unsplash.com/photos/Km5J-KCP1Mw

Spring Initializr
• Project = Maven
• Language = Java
• Artifact = musicstyles
• Packaging = Jar
• Java = 17
• Dependencies
• Spring Web
• Generate

4.1 Creating and Running a
Test

class MusicstylesControllerTest (1 of 2)
package ie.tcd.scss.musicstyles;
import ...
class MusicstylesControllerTest {
@LocalServerPort
private int port;
@Autowired
@Test
void addArtistTest() {
ArtistInfo artistInfo = new ArtistInfo("The Weeknd", "RnB");
ResponseEntity<String> response = restTemplate.postForEntity("http://localhost:" + port + "/api/artists", artistInfo, String.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertEquals("Artist added successfully!", response.getBody());
}
@Test
void getMusicStyleTest() {
ArtistInfo artistInfo = new ArtistInfo("Eminem", "Hip Hop");
restTemplate.postForEntity("http://localhost:" + port + "/api/artists", artistInfo, String.class);
ResponseEntity<String> response = restTemplate.getForEntity("http://localhost:" + port + "/api/artists/Eminem", String.class);
assertEquals("Hip Hop", response.getBody());
}
...
}

class MusicstylesControllerTest (2 of 2)
import …
...
@Test
void getArtistsByMusicStyleTest() {
ArtistInfo artistInfo1 = new ArtistInfo("Adele", "Pop");
ArtistInfo artistInfo2 = new ArtistInfo("Taylor Swift", "Pop");
restTemplate.postForEntity("http://localhost:" + port + "/api/artists", artistInfo1, String.class);
ResponseEntity<List> response = restTemplate.getForEntity("http://localhost:" + port + "/api/musicstyles/Pop/artists", List.class);
assertTrue(response.getBody().contains("Adele"));
assertTrue(response.getBody().contains("Taylor Swift"));
}
@Test
void getNonExistentArtistTest() {
ResponseEntity<String> response = restTemplate.getForEntity("http://localhost:" + port + "/api/artists/NonExistentArtist", String.class);
assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
}
@Test
void getArtistsByNonExistentMusicStyleTest() {
ResponseEntity<List> response = restTemplate.getForEntity("http://localhost:" + port + "/api/musicstyles/NonExistentStyle/artists", List.class);
}
}

class MusicstylesControllerTest (full source)
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.test.web.server.LocalServerPort;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
@LocalServerPort
private int port;
@Autowired
@Test
void addArtistTest() {
ArtistInfo artistInfo = new ArtistInfo("The Weeknd", "RnB");
ResponseEntity<String> response = restTemplate.postForEntity("http://localhost:" + port + "/api/artists", artistInfo, String.class);
assertEquals("Artist added successfully!", response.getBody());
}
@Test
void getMusicStyleTest() {
ArtistInfo artistInfo = new ArtistInfo("Eminem", "Hip Hop");
restTemplate.postForEntity("http://localhost:" + port + "/api/artists", artistInfo, String.class);
ResponseEntity<String> response = restTemplate.getForEntity("http://localhost:" + port + "/api/artists/Eminem", String.class);
assertEquals("Hip Hop", response.getBody());
}
@Test
void getArtistsByMusicStyleTest() {
ArtistInfo artistInfo1 = new ArtistInfo("Adele", "Pop");
ArtistInfo artistInfo2 = new ArtistInfo("Taylor Swift", "Pop");
ResponseEntity<List> response = restTemplate.getForEntity("http://localhost:" + port + "/api/musicstyles/Pop/artists", List.class);
assertTrue(response.getBody().contains("Adele"));
assertTrue(response.getBody().contains("Taylor Swift"));
}
@Test
void getNonExistentArtistTest() {
ResponseEntity<String> response = restTemplate.getForEntity("http://localhost:" + port + "/api/artists/NonExistentArtist", String.class);
}
@Test
void getArtistsByNonExistentMusicStyleTest() {
ResponseEntity<List> response = restTemplate.getForEntity("http://localhost:" + port + "/api/musicstyles/NonExistentStyle/artists", List.class);
}
}

4.2 Testing a REST API with
Postman

Testing a REST API with Postman

4.3 Implementing the
Controller

class MusicstylesController (1 of 2)
import ...
@RestController
@RequestMapping("/api")
public class MusicstylesController {
private final Map<String, String> artistStyleMap = new ConcurrentHashMap<>();
@PostMapping("/artists")
public ResponseEntity<String> addArtist(@RequestBody ArtistInfo artistInfo) {
artistStyleMap.put(artistInfo.getArtist(), artistInfo.getMusicStyle());
return ResponseEntity.ok("Artist added successfully!");
}
@GetMapping("/artists/{artistName}")
public ResponseEntity<String> getMusicStyle(@PathVariable String artistName) {
String musicStyle = artistStyleMap.get(artistName);
if (musicStyle == null) {
return ResponseEntity.status(HttpStatus.NOT_FOUND).body("Artist not found!");
}
return ResponseEntity.ok(musicStyle);
}
...
}

import ...
@RestController
}
}
}
...
}
URL path pattern with path
variable “artistName”

import ...
@RestController
...
@GetMapping("/musicstyles/{musicStyleName}/artists")
public ResponseEntity<List<String>> getArtists(@PathVariable String musicStyleName) {
List<String> artists = artistStyleMap.entrySet().stream()
.filter(entry -> entry.getValue().equalsIgnoreCase(musicStyleName))
.map(Map.Entry::getKey)
.collect(Collectors.toList());
if (artists.isEmpty()) {
return ResponseEntity.status(HttpStatus.NOT_FOUND).body(Collections.emptyList());
}
return ResponseEntity.ok(artists);
}
}

import ...
@RestController
...
}
}
}
Converts artistStyleMap into
stream of its entries
Filter for entries where the
value is <musicStyleName>
ignoring case
Transform each remaining
entry into its key (the artist
name in this case)
Collect the results into a
List<Strings>
Lambda
expression
URL path pattern with path
variable “musicStyleName”

class MusicstylesController (full source)
import org.springframework.web.bind.annotation.*;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
@RestController
}
}
}
}
}
}

4.4 Testing the Controller

Testing the Controller

Testing the Controller With Postman

5. Library
(More Complex Example using Spring MVC Web
Controller, JPA, Repositories, H2)

5.1 Setting up the Initial
Project

• Based on „Explore California“ in (Bowman 2019)
• Simplified and added explanations
• Updated to Spring Boot 3
• Changed namespaces
javax.somepackage → jakarta.somepackage

5.1.1 Creating Project with
start.spring.io

Spring Initializr
• Project = Maven
• Language = Java
• Artifact = library
• Packaging = Jar
• Java = 17
• Dependencies
• Spring Web
• Rest Repositories
• Spring Data JPA
• H2 Database
• Generate

Creating Remote Repository (GitHub or GitLab)
If you want to
push an existing
repository later
do NOT create a
README

5.1.3 Creating Project with IntelliJ
Wizard

Spring Initializr Support in IntelliJ New Project Wizard

New Project

Initial Commit

5.1.4 Adding Remote Repository

5.2 Creating JPA Entities
(Classes to Handle Data)

Domain Model
• Book
• Author
• Library Section

Simplified Domain Model
• Book
• Authors represented as simple
string
• Identifier “id” of type Integer
• Library Section
• Identifier “code” of type String

Jakarta Persistence API (JPA)
• Formerly known as Java Persistence API
• Application Programming Interface (set of interfaces) to
• handle data in Java programs
• manage the mapping of Java classes to tables in databases
• Query Language JPQL
• Implementations
• Eclipse Link (reference implementation)
• Hibernate
• Spring Data JPA uses JPA, expects a JPA implementation

https://www.youtube.com/watch?v=4Py9RTVWyvE

H2 Database
• Minimal, fast in-memory database
• Good for early experiments, proof-of-concept implementations
• https://www.h2database.com/
• No need to install!
• https://www.baeldung.com/spring-boot-h2-database

New Package

class Book
package ie.tcd.scss.library.domain;
import jakarta.persistence.*;
@Entity
public class Book {
@Id
@GeneratedValue
private Long id;
@Column
private String title;
@Column
private String authors;
@Column
private Integer publicationYear;
@Column
private Integer price;
@Column
private String isbn;
@Column(length = 500)
private String keywords;
private String description;
@ManyToOne
private LibrarySection librarySection;
}
JPA Annotation
JPA Annotations

class LibrarySection
@Entity
public class LibrarySection {
@Id
private String code;
@Column
private String name;
@OneToMany
private Set<Book> books;
}

Generating Missing Elements
for classes, not needed for enumerations
• Constructors
• One without any arguments – make private, so it does not get used
• One with all arguments (except @GeneratedValue id)
• Getters
• Setters
• except for @GeneratedValue id
• toString()
• equals()
• hashCode()
(Can be avoided with lombok, but for now we use the standard approach.)

Generating Missing Elements

class Book (Full Source)
import java.util.Objects;
@Entity
public class Book {
@Id
@GeneratedValue
private Long id;
@Column
private String title;
@Column
private String authors;
@Column
private Integer publicationYear;
@Column
private Integer price;
@Column
private String isbn;
private String keywords;
private String description;
@ManyToOne
private LibrarySection librarySection;
public Book(String title, String authors, Integer publicationYear, Integer price, String isbn, String keywords,
String description, LibrarySection librarySection) {
this.title = title;
this.authors = authors;
this.publicationYear = publicationYear;
this.price = price;
this.isbn = isbn;
this.keywords = keywords;
this.description = description;
this.librarySection = librarySection;
}
protected Book() {
}
public Long getId() {
return id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthors() {
return authors;
}
public void setAuthors(String authors) {
this.authors = authors;
}
public Integer getPublicationYear() {
return publicationYear;
}
public void setPublicationYear(Integer publicationYear) {
this.publicationYear = publicationYear;
}
public Integer getPrice() {
return price;
}
public void setPrice(Integer price) {
this.price = price;
}
public String getIsbn() {
return isbn;
}
public void setIsbn(String isbn) {
this.isbn = isbn;
}
public String getKeywords() {
return keywords;
}
public void setKeywords(String keywords) {
this.keywords = keywords;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public LibrarySection getLibrarySection() {
return librarySection;
}
public void setLibrarySection(LibrarySection librarySection) {
this.librarySection = librarySection;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Book book = (Book) o;
return Objects.equals(id, book.id) && Objects.equals(title, book.title) && Objects.equals(authors, book.authors) && Objects.equals(publicationYear,
book.publicationYear) && Objects.equals(price, book.price) && Objects.equals(isbn, book.isbn) && Objects.equals(keywords, book.keywords) &&
Objects.equals(description, book.description) && Objects.equals(librarySection, book.librarySection);
}
@Override
public int hashCode() {
return Objects.hash(id, title, authors, publicationYear, price, isbn, keywords, description, librarySection);
}
@Override
public String toString() {
return "Book{" +
"id=" + id +
", title='" + title + ''' +
", authors='" + authors + ''' +
", publicationYear=" + publicationYear +
", price=" + price +
", isbn='" + isbn + ''' +
", keywords='" + keywords + ''' +
", description='" + description + ''' +
", librarySection=" + librarySection +
'}';
}
}

class LibrarySection (Full Source)
import java.util.Objects;
@Entity
public class LibrarySection {
@Id
private String code;
@Column
public LibrarySection(String code, String name) {
this.code = code;
this.name = name;
}
protected LibrarySection() {
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
LibrarySection that = (LibrarySection) o;
return Objects.equals(code, that.code) && Objects.equals(name, that.name);
}
@Override
public int hashCode() {
return Objects.hash(code, name);
}
@Override
public String toString() {
return "LibrarySection{" +
"code='" + code + ''' +
", name='" + name + ''' +
'}';
}
}

5.3 Creating Spring Data
Repositories

Creating Spring Data Repositories
• We declare an interface that extends
public interface CrudRepository<T, I>
(CRUD = Create, Read, Update, Delete)
• T = Data type that the repository manages, e.g., Book
• I = Data type of the entity ID, e.g., Integer
• Spring Data automatically provides all necessary methods to operate
on that Repository

For instance after declaring
public interface BookRepository extends
CrudRepository<Book, Integer>
We automatically get
Book save(Book b)
Iterable<Book> saveAll(Iterable<Book> iterable)

interface BookRepository
package ie.tcd.scss.library.repo;
import ie.tcd.scss.library.domain.Book;
import org.springframework.data.repository.CrudRepository;
public interface BookRepository extends CrudRepository<Book, Long> {
}
Basic default functionality
is available automatically.
If we need additional
methods, we need to
declare them as part of
the interface.

interface LibrarySectionRepository
package ie.tcd.scss.library.repo;
import ie.tcd.scss.library.domain.LibrarySection;
import org.springframework.data.repository.CrudRepository;
public interface LibrarySectionRepository extends CrudRepository<LibrarySection, String> {
}

Spring Data JPA Repository Interfaces
public interface BookRepository extends
CrudRepository<Book, Integer>
Book save(Book b)
Iterable<Book> saveAll(Iterable<Book> iterable)
void deleteById(Integer id)
void delete(Book book)
void delete(Iterable<Book> iterable)
Void deleteAll()
Optional<Book> findById(Integer id)
boolean existsById(Integer integer)
Iterable<Book> findAll()
Iterable<Book> findAllById(Iterable<Integer> iterable)
long count()

5.4 Creating Services (with
Injected Repositories)

class BookService
package ie.tcd.scss.library.service;
public class BookService {
}

Details of Service
• Service class tagged @Service
• Private variable(s) holding reference(s) to all needed repositories
• Final
• Constructor
• expects references to repositories
• is „autowired“ by tag @Autowired
• Methods
• createBook()
• Create a new book
• lookup() – return (an Iterable with) all books
• total()– return total number of books

class BookService (Overview)
import ...
@Service
private final BookRepository bookRepository;
private final LibrarySectionRepository librarySectionRepository;
@Autowired
public BookService(BookRepository bookRepository, LibrarySectionRepository librarySectionRepository) {
this.bookRepository = bookRepository;
this.librarySectionRepository = librarySectionRepository;
}
public Book createBook(String title, String authors, Integer publicationYear, Integer price, String isbn,
String keywords, String description, String librarySectionCode) {
... find librarySection
return bookRepository.save(new Book(...));
}
public Iterable<Book> lookup() {...}
public long total() {...}
}

How Does Autowiring and Depdendency Injection Work?
• Defining Beans
• Classes eligible for autowiring must be marked with tags like
@Component, @Service, @Repository, @Controller
• @Autowired annotation
• Instructs Spring to “inject” the dependency automatically
• Field Injection
• Constructor Injection – recommend, what we used above
• Setter Injection

• Component Scanning
• Dependency Injection
• When a bean (e.g., BookService) is created, Spring checks (e.g. by looking
at constructor) if there are any dependencies that need to be injected.
• In the case of our BookService, it needs an instance of BookRepository
and an instance of LibrarySectionRepository
• Spring will search among the beans in its context for one that matches the
required type (e.g., BookRepository). If it finds a match, it will inject that
bean into the dependent one (BookService). Otherwise exception.

Much more details at https://www.baeldung.com/spring-dependency-
injection

class BookService (Full Source)
import ie.tcd.scss.library.repo.BookRepository;
import ie.tcd.scss.library.repo.LibrarySectionRepository;
import org.springframework.stereotype.Service;
import java.util.Optional;
@Service
private final BookRepository bookRepository;
@Autowired
public BookService(BookRepository bookRepository, LibrarySectionRepository librarySectionRepository) {
this.bookRepository = bookRepository;
}
public Book createBook(String title, String authors, Integer publicationYear, Integer price, String isbn,
String keywords, String description, String librarySectionCode) {
LibrarySection librarySection = librarySectionRepository
.findById(librarySectionCode)
.orElseThrow(() -> new RuntimeException("Library Section does not exist: " + librarySectionCode));
return bookRepository.save(new Book(title, authors, publicationYear, price, isbn, keywords, description,
librarySection));
}
public Iterable<Book> lookup() {
return bookRepository.findAll();
}
public long total() {
return bookRepository.count();
}
}

class LibrarySectionService
import ie.tcd.scss.library.repo.LibrarySectionRepository;
@Service
public class LibrarySectionService {
@Autowired LibrarySectionService(LibrarySectionRepository librarySectionRepository) {
}
public LibrarySection createLibrarySection(String code, String name) {
return librarySectionRepository
.findById(code)
.orElse(librarySectionRepository.save(new LibrarySection(code, name)));
}
public Iterable<LibrarySection> lookup() {
return librarySectionRepository.findAll();
}
public long total() {
return librarySectionRepository.count();
}
}

5.5 Filling the Database
With Some Test Data

class LibraryApplication (Overview)
package ie.tcd.scss.library;
import ...
public class LibraryApplication implements CommandLineRunner {
@Autowired
private LibrarySectionService librarySectionService;
@Autowired
private BookService bookService;
SpringApplication.run(LibraryApplication.class, args);
}
@Override
public void run(String... args) throws Exception {
createLibrarySections();
createBooks();
}
private void createLibrarySections() {
librarySectionService.createLibrarySection("Scifi", "Science Fiction Books");
librarySectionService.createLibrarySection("Fiction", "Fiction Books");
...
}
private void createBooks() {
bookService.createBook("The Hobbit", "J.R.R. Tolkien", 2023, 99, "ISBN 978-123456", "hobbit, tolkien, fantasy",
"A book about a hobbit", "Fiction");
bookService.createBook("The Hitchhiker's Guide to the Galaxy", "Douglas Adams", 1978, 49, "ISBN 978-456789", "comedy, bbc, scifi",
"A book about life and all the rest", "Scifi");
}
}
Field injection
Required by CommandLineRunner

class LibraryApplication (Full Source)
package ie.tcd.scss.library;
import ie.tcd.scss.library.service.BookService;
import ie.tcd.scss.library.service.LibrarySectionService;
import org.springframework.boot.CommandLineRunner;
public class LibraryApplication implements CommandLineRunner {
@Autowired
private LibrarySectionService librarySectionService;
@Autowired
SpringApplication.run(LibraryApplication.class, args);
}
@Override
public void run(String... args) throws Exception {
createLibrarySections();
createBooks();
}
private void createLibrarySections() {
librarySectionService.createLibrarySection("Scifi", "Science Fiction Books");
librarySectionService.createLibrarySection("Fiction", "Fiction Books");
librarySectionService.createLibrarySection("Non-fiction", "Non-Fiction Books");
librarySectionService.createLibrarySection("CS", "Computer Science Books");
}
private void createBooks() {
bookService.createBook("The Hobbit", "J.R.R. Tolkien", 2023, 99,
"ISBN 978-123456", "hobbit, tolkien, fantasy",
"A book about a hobbit", "Fiction");
bookService.createBook("The Hitchhiker's Guide to the Galaxy", "Douglas Adams", 1978, 49,
"ISBN 978-456789", "comedy, bbc, scifi",
"A book about life and all the rest", "Scifi");
}
}

5.6 Adding Controller
(Using DTOs)

• Why Create BookController?
• To provide REST access to business logic, e.g.,
create Books and add them into a LibrarySection in one go
• We need to get extra data (code of LibrarySection)
• Two approaches
• Get extra data in request parameters
• Get extra data in Data Transfer Object (DTO)
• i.e., one class/object that can hold all data needed during the request

class BookController (using Request Parameter)
package ie.tcd.scss.library.controller;
@RestController
@RequestMapping(path = "/booksController")
public class BookController {
@Autowired
public BookController(BookService bookService) {
this.bookService = bookService;
}
protected BookController() {
}
@PostMapping
@ResponseStatus(HttpStatus.CREATED)
public void createBook(@RequestBody Book book, @RequestParam String librarySectionCode) {
bookService.createBook(book.getTitle(), book.getAuthors(), book.getPublicationYear(), book.getPrice(),
book.getIsbn(), book.getKeywords(), book.getDescription(), librarySectionCode);
}
}

class BookControllerWithDto (Using DTOs)
@RestController
@RequestMapping(path = "/booksControllerWithDto")
public class BookControllerWithDto {
@Autowired
public BookControllerWithDto(BookService bookService) {
this.bookService = bookService;
}
protected BookControllerWithDto() {
}
@PostMapping
@ResponseStatus(HttpStatus.CREATED)
public void createBook(@RequestBody BookDto bookDto) {
Book book = bookDto.getBook();
String librarySectionCode = bookDto.getLibrarySectionCode();
bookService.createBook(book.getTitle(), book.getAuthors(), book.getPublicationYear(), book.getPrice(),
book.getIsbn(), book.getKeywords(), book.getDescription(), librarySectionCode);
}
}

class BookDto
public class BookDto {
private Book book;
private String librarySectionCode;
public BookDto(Book book, String librarySectionCode) {
this.book = book;
this.librarySectionCode = librarySectionCode;
}
protected BookDto() {
}
public Book getBook() {
return book;
}
public void setBook(Book book) {
this.book = book;
}
public String getLibrarySectionCode() {
return librarySectionCode;
}
public void setLibrarySectionCode(String librarySectionCode) {
this.librarySectionCode = librarySectionCode;
}
}

5.7 Testing the
Application and ist API

5.8 First Steps in GitLab
CI/CD

GitLab Pipelines

GitLab Pipelines
https://docs.gitlab.com/runner/install/

5.9 Accessing an External
Service via HTTP REST

• Source available at
https://gitlab.scss.tcd.ie/botterwg/demo-gitlabanalysis

5.8.2 Retrieving Data as String

class GitHubAnalysisApplication
package ie.tcd.scss.githubanalysis;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
public class GitHubAnalysisApplication {
SpringApplication.run(GitHubAnalysisApplication.class, args);
}
@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}
}

class GitHubController
package ie.tcd.scss.githubanalysis.controller;
import ie.tcd.scss.githubanalysis.service.GitHubService;
import org.springframework.web.bind.annotation.PathVariable;
@RestController
public class GitHubController {
private final GitHubService gitHubService;
public GitHubController(GitHubService gitHubService) {
this.gitHubService = gitHubService;
}
@GetMapping("/github/user/{username}")
public String getGitHubUserProfile(@PathVariable String username) {
return gitHubService.getGitHubUserProfile(username);
}
}

class GitHubService
package ie.tcd.scss.githubanalysis.service;
@Service
public class GitHubService {
private final RestTemplate restTemplate;
public GitHubService(RestTemplate restTemplate) {
this.restTemplate = restTemplate;
}
public String getGitHubUserProfile(String username) {
String apiUrl = "https://api.github.com/users/" + username;
return this.restTemplate.getForObject(apiUrl, String.class);
}
}

5.8.2 Retrieving Data in
Structured Form

class GitHubUser
package ie.tcd.scss.githubanalysis.model;
public class GitHubUser {
private String login;
private int id;
private String url;
private String company;
private String blog;
private int followers;
private int following;
... getter/setter ...
}

class GitHubUser (full source)
package ie.tcd.scss.githubanalysis.model;
public class GitHubUser {
private String login;
private int id;
private String url;
private String company;
private String blog;
private int followers;
private int following;
public GitHubUser() {
}
public GitHubUser(String login, int id, String url, String name, String company, String blog, int followers, int following) {
this.login = login;
this.id = id;
this.url = url;
this.name = name;
this.company = company;
this.blog = blog;
this.followers = followers;
this.following = following;
}
public String getLogin() {
return login;
}
public void setLogin(String login) {
this.login = login;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
public String getBlog() {
return blog;
}
public void setBlog(String blog) {
this.blog = blog;
}
public int getFollowers() {
return followers;
}
public void setFollowers(int followers) {
this.followers = followers;
}
public int getFollowing() {
return following;
}
public void setFollowing(int following) {
this.following = following;
}
}

class GitHubService
package ie.tcd.scss.githubanalysis.service;
import ie.tcd.scss.githubanalysis.model.GitHubUser;
@Service
public class GitHubService {
private final RestTemplate restTemplate;
public GitHubService(RestTemplate restTemplate) {
this.restTemplate = restTemplate;
}
public String getGitHubUserProfileString(String username) {
return this.restTemplate.getForObject(apiUrl, String.class);
}
public GitHubUser getGitHubUserProfile(String username) {
return this.restTemplate.getForObject(apiUrl, GitHubUser.class);
}
}

class GitHubController
package ie.tcd.scss.githubanalysis.controller;
import ie.tcd.scss.githubanalysis.service.GitHubService;
import org.springframework.web.bind.annotation.PathVariable;
import ie.tcd.scss.githubanalysis.model.GitHubUser;
@RestController
public class GitHubController {
private final GitHubService gitHubService;
public GitHubController(GitHubService gitHubService) {
this.gitHubService = gitHubService;
}
@GetMapping("/github/user/{username}")
public GitHubUser getGitHubUserProfile(@PathVariable String username) {
return gitHubService.getGitHubUserProfile(username);
}
@GetMapping("/github/userString/{username}")
public String getGitHubUserProfileString(@PathVariable String username) {
return gitHubService.getGitHubUserProfileString(username);
}
}

5.9 RESTful APIs with
Spring Data REST

RESTful APIs
• Hypermedia-driven APIs
• Roy Fielding (2000)
• Hypermedia as the Engine of the Application State (HATEOAS)
• Expose application state via API
• Expose the API‘s documentation
• Navigation between resources
• Spring Data REST provides that out of the box!

CSU33012-J-springboot(3).pdf

Recommended

Recommended

More Related Content

Similar to CSU33012-J-springboot(3).pdf

Similar to CSU33012-J-springboot(3).pdf (20)

Recently uploaded

Recently uploaded (20)

CSU33012-J-springboot(3).pdf