Spring Boot Tutorial for Beginners (Java Framework)

Name: Spring Boot Tutorial for Beginners (Java Framework)
Uploaded: 2019-09-03T13:06:17.000Z
Duration: 3 h 38 min 29 s

Introduction to Spring Boot

Overview of Spring Boot

Nelson introduces the course on Spring Boot, highlighting its efficiency in building Java applications quickly.

He mentions Netflix's decision to switch their backend to Spring Boot due to its robustness and ease of use.

Key Features of Spring Boot

Spring Boot is praised for its ability to facilitate both enterprise application development and rapid prototyping.

The framework supports various types of requests (GET, POST, DELETE, PUT), allowing for comprehensive API development.

Understanding Application Layers

Application Architecture

Nelson explains the architecture involving multiple layers: API layer (controller), service layer (business logic), and database interaction.

He emphasizes the flexibility of dependency injection in switching between different database implementations with minimal code changes.

Client Interaction

Requests from clients (e.g., iOS apps, React apps, Android apps) are processed through these layers before returning responses like JSON payloads or status codes.

Setting Up a Spring Boot Project

Initializing a Project

Viewers are directed to start.spring.io for bootstrapping their application by selecting dependencies and configuring project settings.

Nelson advises using Java 11 or Java 8 based on installed versions while generating the project metadata.

Selecting Dependencies

The importance of choosing appropriate dependencies is highlighted; they allow developers to start coding without extensive configuration.

Specific sections such as web server configurations and security setups are mentioned as user-friendly features provided by Spring Boot.

Working with IntelliJ IDEA

Development Environment Setup

Nelson recommends using IntelliJ IDEA as the IDE for this tutorial, noting its advantages over other IDE options like NetBeans or Eclipse.

Spring Boot Project Setup and API Implementation

Project Structure Overview

The project is opened in IntelliJ, with Maven resolving dependencies. Key files include pom.xml, which contains the group ID, artifact name, and version.

The Java version used is 11, and the main dependency is Spring Boot Starter Web. Spring Boot also includes Spring Boot Starter Tests for unit and integration testing.

The application can be run using the public static void main method in the DemoApplication class. Tomcat starts on port 8080 by default.

Resources are organized into folders: static for web resources, templates for view templates (like Mustache or EJS), and application.properties for configuration settings across different environments (demo, test, production).

Implementing the API Layer

The tutorial outlines a layered architecture: API layer (controllers), service layer (business logic), and database layer (data access).

A new package structure is created in IntelliJ: packages named API, model, service, and a data access object (DAO) package to represent different layers of the application.

Defining the Model

A model class named "Person" will be defined. It includes properties like ID and name to keep it simple while demonstrating functionality.

In IntelliJ, a new class called "Person" is created within the model package. It has private final fields for ID (of type UUID) and name (of type String), along with constructors and getters.

Setting Up Database Interaction

An interface for data access operations will be created within the DAO package. This interface defines allowed operations as a contract for any implementing classes.

Dependency injection will allow switching between different implementations of this interface seamlessly.

How to Implement a Simple Database in Java

Defining Methods for Database Operations

The first method defined is insert, which takes a user ID and a person object, returning an integer indicating success (0 or 1).

A second method, addPerson, is introduced that generates a random user ID if none is provided, allowing for flexibility in data insertion.

Both methods are designed to handle the insertion of person objects into a mock database represented by a list.

Creating the Data Access Object (DAO)

A new class named FakePersonDataAccessService implements the DAO interface, where it initializes a private static list to store person objects.

The insert method adds new persons to this list and always returns 1, indicating successful insertion.

Implementing the Service Layer

A service class called PersonService is created with a method that calls the DAO's insert functionality while ensuring proper dependency injection.

The service allows for both specified and randomly generated IDs when adding persons, showcasing flexibility in usage.

Setting Up the API Controller

An API controller named PersonController is established to manage HTTP requests related to person data.

This controller includes an add method that interacts with the service layer but does not return any values; instead, it focuses on status codes.

Configuring Spring Framework Components

To utilize Spring's dependency injection effectively, annotations like @Repository and @Service are added to their respective classes.

Auto Wiring and Dependency Injection in Spring Boot

Understanding Auto Wiring

The concept of auto wiring is introduced, allowing multiple implementations of an interface to be distinguished using qualifiers.

By naming the qualifier (e.g., "fake DAO"), different implementations can be easily referenced without changing other code components.

Setting Up REST Controllers

The API class must specify HTTP methods (GET, POST, DELETE, PUT) for client requests; currently, it lacks this functionality.

To enable RESTful behavior, the @RestController annotation is applied to the class, allowing it to expose endpoints for client consumption.

Creating a POST Endpoint

Postman is recommended as a tool for testing API endpoints since no front-end application exists yet.

A sample endpoint is defined (/api/v1/person) where JSON data will be sent. The body should contain properties like name and ID formatted correctly.

Configuring Data Transfer Objects

In the Person model class, properties are annotated with @JsonProperty to ensure proper mapping from JSON payload to Java objects.

The controller method responsible for adding a person must use @RequestBody to indicate that it will receive JSON data from the request body.

Testing the Application

After setting up the endpoint and running the application on Tomcat port 8080, a successful response (200 status code) indicates that data was received correctly.

How to Implement GET and POST Requests in Spring Boot

Setting Up the GET Request

The method for handling a GET request is defined as public List<Person> getAllPeople(), which returns a list of persons from the database using personService.getAllPeople().

After starting the server on port 8080, a test with Postman shows that sending a GET request retrieves an array containing one person from the database.

A second POST request is made to add "Nelson Mandela" and "Anna Jones," confirming successful addition with HTTP status 200. A subsequent GET request now returns three people: James Bond, Nelson Mandela, and Anna Jones.

Implementing Update and Delete Functionality

The next steps involve implementing methods for updating (updatePersonById) and deleting (deletePersonById) a person by their ID.

An interface is defined for these methods, including returning an integer for updates and an optional type for selecting a person by ID.

Searching Within the Database

To implement the selection method, Java streams are utilized to filter through the database based on ID. This involves streaming data and applying filters to find matching IDs.

The service layer implements similar logic to retrieve a person by ID using return personService.selectPersonById(id).

Handling Path Variables in Requests

In the controller, a new method handles requests to get a person by ID. It uses path variables to extract IDs from incoming requests.

Custom error messages or codes can be returned if no user is found; however, this example keeps it simple by returning null when not found.

Testing API Endpoints

How to Handle API Requests and Responses

Understanding Object Retrieval and Error Handling

The process begins with retrieving an object by its ID, demonstrating that a valid request returns a single object rather than an array. An invalid ID results in a bad request error.

Adding a new entry (Anna Jones) is illustrated, followed by fetching all entries to confirm the addition. A subsequent GET request with an invalid ID shows that no data exists for that ID.

The importance of not throwing a 404 error when no data is found is emphasized; instead, returning nothing indicates the absence of records in the database.

Implementing CRUD Operations

Deleting and Updating Records

To delete a person, the method checks if the person exists using their ID. If found, it removes them from the database; otherwise, it returns zero indicating failure.

For updating a person's details, the method retrieves the existing record and maps it to new values. It checks if the index of the person to update is valid before proceeding with changes.

Service Layer Integration

The service layer methods are defined for deleting and updating persons. These methods call corresponding functions from data access services while maintaining simplicity for clarity.

The controller exposes these service methods as RESTful APIs. The delete operation uses HTTP DELETE mapping while ensuring proper path variable handling for IDs.

Finalizing API Endpoints

Exposing RESTful Services

In defining endpoints for deletion and updates, attention is given to HTTP methods (DELETE/PUT). Proper annotations ensure that requests are correctly routed through the application’s architecture.

Implementing a REST API with Spring Boot

Setting Up the Update Functionality

The process begins by defining a method to update a person in the request body, utilizing personService.update() and including the user ID in the path.

The server is restarted to test the implementation using Postman, starting with an initial GET request to retrieve existing entries.

Testing Update Functionality

A PUT request is made to change "Nelson Mandela" to "Alex," but it initially fails when retrieving all entries afterward. Debugging is necessary to identify issues.

An attempt is made to delete "Nelson Mandela" successfully, confirming that deletion works as expected. However, updating "Anna Jones" also encounters problems.

Debugging and Fixing Issues

The developer identifies an error in how the index of the person for updating was being calculated; renaming variables helps clarify intent and correct functionality.

After adjustments are made, including passing IDs correctly during updates, testing resumes with successful results for both POST and PUT requests. This confirms that all methods defined in the API are functioning properly.

Enhancing Validation

The discussion shifts towards implementing validation annotations within the Person model to ensure fields like name cannot be blank or null, enhancing data integrity before processing requests.

By enforcing these validations at the model level, errors can be caught early on rather than later in application logic, improving overall robustness of input handling.

Final Testing and Conclusion

Further tests confirm that invalid inputs (like blank names) trigger appropriate error messages while valid inputs succeed without issue, demonstrating effective validation mechanisms at work.

Dependency Injection and Database Switching

Implementing Dependency Injection for Database Management

The speaker introduces the concept of dependency injection, emphasizing its importance in switching database implementations with minimal code changes.

A new class is created to represent a Postgres implementation, demonstrating how to structure the data access layer effectively.

The use of annotations like @Repository is highlighted to specify that this class serves as a Postgres implementation, showcasing Spring's capabilities.

After modifying just one line of code, the application successfully connects to a Postgres database, illustrating the ease of switching databases using dependency injection.

Building and Running the Application

Instructions are provided on how to build a deployable JAR file using Maven, which can be run on any server environment.

The process involves navigating to the target folder and executing commands in Terminal to initiate the JAR file for deployment.

The speaker demonstrates starting the server with Java commands and confirms successful startup by accessing an API endpoint via a web browser.

Overview of API Functionality

The application supports various HTTP methods (GET, POST, DELETE), allowing clients like Postman to interact with it seamlessly through defined controller layers.

Key components such as service layers and data access layers are discussed, highlighting their roles in managing requests and responses efficiently.

Future Plans for Real Database Connection

The speaker expresses intentions to create additional content connecting the application to a real Postgres instance while maintaining simplicity in implementation.

Introduction to PostgreSQL

An overview of PostgreSQL is provided along with resources for learning more about it through free courses available on the speaker's website.

Docker Setup for PostgreSQL

Running a Docker Container

The speaker demonstrates how to open the terminal and run a Docker command to create a container named "Postgres-spring."

An environment variable is set with a simple password, and the Postgres image is specified as "Postgres-Alpine," which is the smallest version available.

The command runs in detached mode, allowing users to continue using the terminal while the container operates in the background.

Exposing Ports and Verifying Container Status

The speaker checks running containers using docker ps, confirming that "Postgres-spring" is active.

The port 5432, which is default for Postgres, is exposed to localhost, enabling external access to the database.

Connecting IntelliJ to PostgreSQL

Instructions are provided on how to revert changes in IntelliJ and connect to the Postgres database by modifying connection details.

The speaker emphasizes deleting application.properties and creating an application.yaml file for defining database connection settings.

Adding Dependencies for Database Connection

To connect with databases, necessary dependencies are added in pom.xml, including Spring Boot starter JDBC and PostgreSQL driver.

Flyway dependency is introduced for managing database migrations alongside other essential libraries needed for SQL operations.

Handling Configuration Errors

Upon running the application, an error regarding data source configuration arises due to missing URL attributes; this indicates further setup is required.

Creating a Data Source Configuration in Spring Boot

Setting Up the Class

A new class is created for configuration, named PostgresDataSource. This class will serve as a configuration point for the data source.

The method within this class returns an instance of IkariDataSource using a builder pattern, specifying its type and building it.

Application Properties Configuration

The application properties file is opened to configure database connection details such as username, URL, and password.

The JDBC URL is set to connect to a PostgreSQL database running on localhost at port 5432. The database name is suggested as spring_boot_postgres_db.

Database Connection Settings

Default username for PostgreSQL (postgres) and password (password) are specified. Additionally, a pool size of 30 connections is defined to optimize query execution without creating new connections each time.

Handling Migration Issues

Upon starting the application, an error indicates that migrations cannot be found. To resolve this, folders named db and migrations need to be created for managing database schema changes.

Flyway is introduced as a tool for managing database migrations effectively. Users are encouraged to read through its documentation for better understanding.

Creating Migration Files

A terminal command sequence demonstrates how to create necessary directories (db/migrations) using command line tools instead of GUI methods.

A migration SQL file named V1__person_table.sql is created with SQL commands to define a table structure including columns like ID (UUID type) and Name (VARCHAR).

Database Creation Process

Getting Started with PostgreSQL and Spring Boot

Connecting to PostgreSQL

The speaker demonstrates how to access a PostgreSQL container and run commands using psql, emphasizing the importance of learning PostgreSQL for both professional and personal projects.

After listing existing databases, the speaker creates a new database named "demoDB" and confirms its creation by executing the command l.

The speaker connects to the newly created database using c demoDB and verifies that they are connected successfully.

Database Structure and Application Setup

The speaker checks for existing relations in the database using commands like d and dt, noting that initially there are no tables present.

An error occurs when starting the application due to a misspelling in migration configuration. Correcting this allows successful application startup, indicating that migrations were applied correctly.

Working with Tables

After applying migrations, two tables appear in the database, including one called "person." The structure of this table is described, highlighting fields such as ID (UUID type) and name (character varying).

The speaker attempts to insert data into the "person" table but encounters an issue with UUID generation. They explain how to create an extension necessary for generating UUIDs.

Inserting Data into Tables

Once the UUID extension is installed, the speaker successfully inserts records into the "person" table, demonstrating how to use SQL syntax correctly.

After inserting two entries ("Maria Jones" and "Tom Smith"), they confirm successful insertion by querying all records from the "person" table.

Integrating Spring Boot with PostgreSQL

How to Use JDBC Template API in Spring Boot

Introduction to JDBC Template API

The speaker introduces the JDBC Template API, emphasizing its utility over traditional methods of selecting data from a database.

The method query is highlighted as essential for executing SQL statements and requires two parameters: an SQL statement and a row mapper.

Defining SQL Queries

A string variable for the SQL query is defined, using specific column names (ID, name) instead of SELECT *, which enhances clarity and performance.

The speaker explains how to implement a row mapper using a lambda function that transforms the result set into Java objects (specifically, Person objects).

Handling Result Sets

The process of retrieving values from the result set is detailed, including converting data types appropriately (e.g., converting strings to UUID).

The speaker discusses refactoring code for better readability by extracting variables for ID and name from the result set.

Returning Data from Database

A list of people is returned from the database instead of fake data, demonstrating successful integration with Postgres DB.

After refreshing the application in Chrome, real data retrieval is confirmed, showcasing Spring Boot's efficiency in handling database operations.

Implementing Additional Methods

The speaker transitions to implementing another method: selecting a person by ID. This involves modifying the SQL query to include a WHERE clause.

It’s explained that queryForObject should be used instead of query when expecting a single object as output.

Finalizing Database Interaction

An optional return type is introduced to handle cases where no matching record exists in the database.

Successful testing confirms that querying by ID works correctly; this demonstrates effective use of Docker, Postgres, Flyway, and Spring JDBC together.

Conclusion on Using Spring Boot with Databases

Spring Boot Development Insights

Implementing Logic in Spring Boot

The speaker encourages viewers to implement logic for inserting, deleting, and updating data using SQL, emphasizing the straightforward nature of these tasks.

Viewers are invited to subscribe for more content related to Spring Boot and web development, highlighting a full-stack course that covers essential skills.

Skills for Job Readiness

The speaker asserts that knowledge of Spring Boot is highly sought after in the job market, particularly for roles requiring Java developers.

Key skills mentioned include dependency injection, database connectivity, testing (both unit and integration), and user interface development.

Course Overview and Benefits

The upcoming full-stack web development course will cover comprehensive topics necessary for software developers, with practical deployment on Amazon Elastic Beanstalk.