Gain insights into building scalable applications with Thymeleaf and Spring Boot. Delve into Spring Data, Spring Security, and testing methods to ensure maintainable, portfolio-worthy projects.

maven.tar.gz

13SepBackgroundPostGres

DockerCompose14Sep

OptimizedMvn-22Sep

Moving into root - 24 Sep

From GitHub Repo - 12.4 - 24 Sep

Built from Github and running directly without watcher - 30Sep

Watcher - 29 Sep

From usercode directly - Oct 1

DockerCompose14Sep-Chapter09

OptimizedMvn-22Sep-Chapter11

DockerCompose14Sep-Chapter09-copy

Chapter09-Testing

Cypress

Chapter17-Testing

Cypress-copy

Integration Testing

Initial Chapters

Initial Chapters-copy

Watcher

Initial Chapters-Watcher

Integration Testing-copy

In this course, you will learn how to build easily scalable applications with Thymeleaf and Spring Boot. More specifically, you will combine Thymeleaf and Spring Boot with Spring Data and Spring Security. In a nutshell, this course will give you all the basics you need to start developing an application using Thymeleaf and Spring Boot.

Throughout the course, you will be building an application of a fictional basketball team called Thyme Wizards. Additionally, you will also learn to use unit and integration tests to ensure the proper code functionality and build a maintainable codebase that you can expand upon.

By the end, you will have a new project to add to your portfolio and some great new skills that employers will love.

Building Scalable Applications with Thymeleaf and Spring Boot

# Adding properties to `User`
So far, our `User` only has a surrogate primary key (the `id`). Let’s add some more fields like gender, birthday, email and phone number to make things more interesting:

package com.tamingthymeleaf.application.user;
import io.github.wimdeblauwe.jpearl.AbstractEntity;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.Table;
import javax.validation.constraints.NotNull;
import java.time.LocalDate;
@Entity
@Table(name = "tt_user")
public class User extends AbstractEntity<UserId> {
    @NotNull
    private UserName userName; //<.>
    @NotNull
    @Enumerated(EnumType.STRING)
    private Gender gender; //<.>
    @NotNull
    private LocalDate birthday; //<.>
    @NotNull
    private Email email; //<.>
    @NotNull
    private PhoneNumber phoneNumber; //<.>

    protected User() {
    }

    public User(UserId id,
                UserName userName,
                Gender gender,
                LocalDate birthday,
                Email email,
                PhoneNumber phoneNumber) {
        super(id);
        this.userName = userName;
        this.gender = gender;
        this.birthday = birthday;
        this.email = email;
        this.phoneNumber = phoneNumber;
    }

    public UserName getUserName() {
        return userName;
    }

    public Gender getGender() {
        return gender;
    }

    public LocalDate getBirthday() {
        return birthday;
    }

    public Email getEmail() {
        return email;
    }

    public PhoneNumber getPhoneNumber() {
        return phoneNumber;
    }
}


* **`UserName`** is a value object that contains the `firstName` and `lastName` of a user.
* **`Gender`** is an enum for the possible genders of a user in our application.
* The **`birthday`** field uses `LocalDate` to store the day a user was born.
* **`Email`** is a value object that represents an email address.
* **`PhoneNumber`** is a value object that represents a phone number.

# Some useful observations
* All fields are required, so we have annotated them with `javax.validation.constraints.NotNull`
* By default, an `enum` is serialized to the database using its ordinal (an `int`). By adding `@Enumerated(EnumType.STRING)`, Hibernate will write the name of the `enum` to the database.
* For now, only getters have been added. This is usually the preferred pattern.
* The `UserName` class is annotated with `@Embeddable` so that the `firstName` and `lastName` fields are inlined into the `tt_user` database table.
* The value objects `Email` and `PhoneNumber` have a JPA `AttributeConverter` class that knows how to convert from the value object to a String for the database and back. 

For example:

Learn how to add more properties to an Entity.

Adding Properties to User

Getting Started

What are Spring Boot and Thymeleaf?

Thymeleaf Introduction

Thyme Wizards

Fragments

Layouts

Controllers

Internationalization

Database Connection

Displaying Data

Forms

Data Editing

Implement Deletion of an Entity

Security

Security - Users from Database

Testing

Testing Using Cypress

Various Tips and Tricks - I

Various Tips and Tricks - II

Conclusion

Appendix

Adding Properties to User

Adding properties to `User`

Adding Properties to User

Adding properties to User

Adding properties to `User`