DEV Community: Alexander the dev

Java Spring Boot for Beginners | Part 4 : Database integration with H2 and JPA

Alexander the dev — Sun, 05 Jan 2025 16:12:06 +0000

Title: Getting Started with Database Integration Using H2 and JPA in Java Spring Boot

If you prefer to watch the tutorial
Java Spring Boot for Beginners | Part 4 : Database integration with H2 and JPA

In the world of backend development, integrating with a database is a pivotal aspect of building robust applications. In this blog post, we dive into the integration of databases with Java Spring Boot using H2 and JPA. This tutorial covers essential theoretical concepts and guides you through practical implementation steps.

Why Do You Need a Database?

Databases play a crucial role in applications for various reasons:

Persistent Storage: They ensure data is not lost on application restarts.
Efficient Data Retrieval: Databases provide fast search and retrieval capabilities.
Data Consistency: They maintain data accuracy through constraints and transactions.
Concurrent Access: Databases handle multiple users accessing data simultaneously.
Complex Data Relationships: They allow modeling of intricate relationships between different data types.

Our library management system, for instance, uses a database to store and manage information about books, users, and loans, providing consistency and data manipulation over time.

Understanding H2 Database

H2 is a lightweight, open-source Java SQL database, perfect for development and testing. Its key features include:

In-Memory and File-Mode: Capable of running entirely in memory or as a file-based database.
Embedded Mode: Can be integrated into a Java application without a separate database server.
SQL Compatibility: Runs in MySQL compatibility mode.
Browser-Based Console: Eases database management with a straightforward UI.

Note that H2 is not ideal for production but is excellent for learning purposes due to its simplicity and minimal setup requirements.

Introducing JPA

Java Persistence API (JPA) is a Java specification for managing relational data seamlessly. Its main highlights are:

ORM: JPA acts as an Object-Relational Mapping framework, mapping Java objects to database tables.
Abstraction Layer: Provides a layer over JDBC, simplifying database operations.
Flexibility: Allows switching JPA providers without code changes.
JPQL: Java Persistence Query Language, a platform-independent query language operating on Java objects.

With JPA, you can create repository interfaces for database operations without writing detailed implementation code.

Setting Up the Environment

To follow along, you need to have Java Spring Boot set up. We start by adding dependencies for JPA and H2 in the Build Gradle file. The new dependencies allow you to manage database integration seamlessly.

Configure H2 Database: Switch from application.properties to application.yaml for better readability, setting up the datasource properties, and enabling the H2 console.
Create Schema and Insert Data: Using schema.sql and data.sql files, initialize your database with tables and data entries.
Coding with Entities: Devise entities that mirror your database tables using annotations like @Entity and leverage Lombok to manage getters, setters, and constructors efficiently.
Repository and Services: Develop repository interfaces extending JPA repositories and work on services that utilize these repositories for CRUD operations.

Testing the Integration

Finally, verify the integration using tools like Postman to ensure that your CRUD operations—Create, Read, Update, and Delete—work as expected with your database.

Conclusion

While H2 is excellent for learning and prototyping, making the leap to advanced database solutions is essential for production applications. Stay tuned for updates where we explore better options for production-level applications.

By understanding and implementing these basics of JPA with H2 in Spring Boot, you set a foundation for more complex systems in the future. Happy coding!

Thank you for reading! Don't forget to like and subscribe to our channel to stay updated with the latest tutorials. See you in the next installment!

Understanding Dependency Injection and Components in Java Spring Boot

Alexander the dev — Wed, 23 Oct 2024 17:49:58 +0000

Introduction

Welcome to the third part of our "Java Spring Boot for Beginners" series, dedicated to unraveling the essentials of dependency injection and components. My name is Alex, and today, we will delve deeper into how inversion of control (IoC) and components interplay within Spring Boot.

If you more of a visual person then you can watch the video in my channel https://youtu.be/j8XwEYJsejs

Understanding Dependency Injection

Dependency injection is a fundamental design pattern critical in software engineering, intended to implement inversion of control. It involves injecting class B directly into class A, eliminating the need for class A to create or manage class B on its own. This approach enhances the modularity of your application while making it easier to manage and test.

Spring Boot utilizes an IoC container to manage objects' lifecycle and configuration, which are known as beans. These beans form the backbone of any Spring application. The IoC container is responsible for injecting these into applications as needed, which allows for the efficient sharing of objects and resources.

Why Use Dependency Injection?

The primary advantage of using dependency injection is the decoupling of code. This decoupling significantly eases management, testing, and flexibility, as it allows the swapping of implementations without impacting dependent classes. Moreover, it simplifies testing endeavors by facilitating the mocking of dependencies during both unit and integration tests.

Illustrating Dependency Injection with Spring Boot

To better explain dependency injection, let's examine a simple design scenario involving several classes: BookService, BookRepository, AuthorService, and AuthorRepository. Traditionally, class instances are created using the new keyword, but with Spring Boot, you can use annotations like @Component, @Service, or @Repository to register these classes in the IoC container.

When the BookController needs a BookService, Spring Boot checks the IoC container and provides the existing instance rather than creating a new one. This practice maintains a Singleton pattern by default, meaning that a single instance is shared among all classes requiring it, rather than creating fresh instances.

The true power of this method is seen when multiple components, such as AuthorController and BookService, require the same instance, like AuthorService. Spring Boot manages and shares the same instance across these classes, thereby streamlining resource utilization and maintaining consistency.

Implementing Dependency Injection in Code

To inject dependencies in Spring Boot, you annotate your classes appropriately (e.g., @Service) and use dependency injection through the constructor, ensuring Spring Boot provides the dependencies automatically. By applying this practice, you successfully separate business logic, delegating it from controllers to services, thus enhancing code organization.

For example, the BookController delegates logic to BookService, which might require AuthorService. All dependencies are managed by Spring Boot, freeing developers from the overhead of manual class instantiation.

The BookService class


@Service
public class BookService {

    private final List<Book> books = new ArrayList<>();

    public List<Book> getBooks(){
        return books;
    }

    public Book addBook(@RequestBody Book book) {
        books.add(book);
        return book;
    }

    public Book updateBook(@PathVariable Long id, @RequestBody Book updatedBook) {
        for(var book : books) {
            if(book.getId().equals(id)) {
                book.setTitle(updatedBook.getTitle());
                book.setAuthor(updatedBook.getAuthor());
            }
            return book;
        }
        return null;
    }

    public String deleteBook(@PathVariable Long id) {
        books.removeIf(book -> book.getId().equals(id));
        return "Book with id " + id + "was deleted";
    }
}

and the BookController class


@RestController
@RequestMapping("/books")
public class BookController {
    private final BookService bookService;

    @Autowired
    public BookController(BookService bookService) {
        this.bookService = bookService;
    }

    @GetMapping
    public List<Book> getBooks(){
        return bookService.getBooks();
    }

    @PostMapping
    public Book addBook(@RequestBody Book book) {
        return bookService.addBook(book);
    }

    @PutMapping("/{id}")
    public Book updateBook(@PathVariable Long id, @RequestBody Book updatedBook) {
        return bookService.updateBook(id, updatedBook);
    }

    @DeleteMapping("/{id}")
    public String deleteBook(@PathVariable Long id) {
        return bookService.deleteBook(id);
    }
}

Getting Hands-On with Postman and IntelliJ IDEA

Before putting our knowledge into practice, ensure your Spring Boot application is running. You can use Postman to manage requests for your application, creating collections and executing commands like GET to retrieve book information, POST to create new entries, and PUT/DELETE to update or delete records.

Within IntelliJ IDEA, our initial setup includes a library management tool. As you refine your implementations, you should notice that more complex operations like data handling could be shifted to repositories, marked with @Repository.

Conclusion

In conclusion, using dependency injection in Spring Boot not only promotes clean and manageable code but also enhances testability and flexibility. As we advance to the next session, we'll explore setting up databases to integrate more robust data management within our applications.

Don't forget to like and subscribe to stay updated on our latest tutorials. Thank you for joining this journey, and see you in the next part where we'll dive deeper into repositories and database setup!

Feel free to reach out if you require further insights or have queries about Spring Boot and its functionalities.

Programming basics in Java | Part 2 : Loops, Arrays, Methods, OOP and More!

Alexander the dev — Tue, 15 Oct 2024 12:25:32 +0000

If you prefer to learn by watching: https://youtu.be/JPcqYwUQmqI

Introduction

Welcome to Part 2 of our journey into the world of programming basics in Java. This installment is designed to take you deeper into the core concepts that form the foundation of Java programming. Whether you're a novice stepping into the coding realm or a seasoned professional revisiting the basics, this guide will offer valuable insights. Today, we will cover loops, arrays, methods, user inputs, error handling, and classes, wrapping everything up with a full demo app to cement your understanding.

Understanding Loops in Java

Loops are essential constructs that allow programmers to repeat a block of code multiple times without manual repetition. In Java, we have three main types of loops:

For Loop: This loop executes a block of code for a fixed number of times.
While Loop: This loop executes a block of code as long as a specified condition remains true.
Do-While Loop: This loop ensures the block of code runs at least once before the condition is tested.

Each loop type serves a unique purpose, and understanding when to use each is crucial for efficient programming.

Exploring Arrays

Arrays are fundamental structures for storing and managing collections of data. They allow us to organize multiple elements of the same data type under one variable name, providing powerful ways to access and manipulate elements using indices. Common operations include sorting, searching, inserting, and deleting elements within arrays.

Harnessing the Power of Methods and Functions

Methods, or functions, are reusable blocks of code designed to perform specific tasks. They help in organizing code into manageable segments, making programs more readable and maintainable. In Java, methods can accept parameters and also return values, enabling complex data processing and manipulation.

Diving into Object-Oriented Programming

Java is a robust object-oriented programming (OOP) language. OOP revolves around the concept of creating objects—self-contained units that combine data and functions. Here's an overview of central OOP concepts:

Classes and Objects: A class is a blueprint for creating objects. Each object can hold properties (attributes) and behaviors (methods).
Encapsulation: This principle involves hiding the internal details of an object while providing a public interface, making it easier to manage code complexity.

Through practical examples, you’ll grasp how classes, objects, and encapsulation streamline your Java applications.

The Full Demo: Bringing It All Together

Finally, we assemble the concepts learned into a complete demo application. This practical exercise involves creating and managing a bank account system. You'll implement loops, arrays, methods, and classes to manage accounts and user interactions, solidifying your understanding as you build.

This hands-on demonstration not only consolidates theoretical knowledge but also cultivates the skills necessary for real-world application development.

Conclusion

This comprehensive guide to Java basics is designed to equip you with the foundational knowledge and skills required to tackle more advanced programming challenges. By mastering loops, arrays, methods, and object-oriented principles, you set yourself on the path to becoming a proficient Java developer. Remember to practice consistently and explore further resources to deepen your comprehension of these core concepts. Happy coding!

Programming basics in Java | Part 1 : Introduction and Project Setup

Alexander the dev — Tue, 15 Oct 2024 12:23:17 +0000

If you prefer to learn by watching : https://youtu.be/lIr1tN5gTN0

Introduction

Hello, everyone, and welcome to our beginner-friendly journey into the realm of Java programming. In this introductory article, we’ll explore the essentials to get you started with Java, a versatile programming language favored by developers worldwide. We'll cover key concepts, from setting up your development environment to understanding variables, data types, and basic operators. By the end of this guide, you’ll have the knowledge to build a simple Java application.

Why Java?

Java is the preferred choice for many developers due to its widespread use and flexibility. Since its creation in 1995, Java has become one of the most popular programming languages, powering over three billion devices globally. Whether you're developing desktop software, mobile apps, web applications, or enterprise systems, Java's "write once, run everywhere" philosophy ensures compatibility across platforms.

Setting Up Your Development Environment

To start coding in Java, you'll need to set up your development environment. For this, we recommend using IntelliJ IDEA. You can download the free community edition from JetBrains, which is suitable for creating most applications. Once downloaded, follow the installation instructions and set your project up as shown in the script. For your first project, let's call it "Java Basics," and use Gradle as your build system.

Understanding Java Basics

When you open IntelliJ, you'll see a typical Java class file structure. A class in Java is the blueprint for objects and encapsulates your program's logic. Every Java program must have a main method, which serves as the entry point. We start our journey by running a simple "Hello, World" program, printed using System.out.println.

Variables and Data Types

Java offers a variety of data types to store and manipulate data:

String: For storing text.
int: For storing whole numbers.
float & double: For decimal numbers.
char: For single characters.
boolean: For true/false values.

Variables are containers for data. For example, to store your name and age, you would declare them as:

String name = "Alex";
int age = 37;

Operators in Java

Java supports various operators for arithmetic (addition, subtraction, multiplication, division, and modulus), assignment, comparison, and logical operations. Understanding these will help you perform calculations and manipulate data effectively.

Control Flow with Conditions

Control statements like if, else if, and else help direct your program's flow based on conditions. The switch statement can be used for multiple potential outcomes, such as checking the day of the week or evaluating temperature conditions.

Putting It All Together

In the script, we provided an example of a "Weather Advisor" application that recommends attire based on the current weather conditions using various control statements we've discussed. This simple program consolidates your understanding of variables, data types, and control flow.

Conclusion

By now, you should have a foundational understanding of Java programming. Remember, practice is key to mastering programming concepts. Experiment with different variables, operators, and control flows. Don't hesitate to make mistakes—each one is an opportunity to learn.

Stay tuned for more tutorials, and don't forget to like and subscribe to our channel for updates on new video releases. If you have any questions, feel free to leave a comment. Happy coding!

Java Spring Boot for Beginners: Part 1: Introduction and project setup

Alexander the dev — Tue, 15 Oct 2024 12:11:16 +0000

If you're interested in diving into backend development with Java and Spring Boot, you've come to the right place. Whether you're completely new to programming or have some Java experience, this guide will help you get started with building a library management tool using Spring Boot. We'll walk you through the essentials of backend development, introduce you to frameworks, and guide you through the project setup process.

If you prefer to watch the tutorial you can do so here:https://youtu.be/lIr1tN5gTN0
also, part 2 is here: https://youtu.be/jAc7SSmuV2I

Introduction to Backend Development

Imagine you’re using a library management system or browsing an online bookstore. Everything you see, like buttons, text, and images, is part of the front-end. It’s the part users interact with. However, beneath the surface lies the backend, where the real magic happens. The backend is responsible for storing and retrieving data, implementing business logic, and processing requests. For instance, it determines if a book can be borrowed based on its availability—similar to a restaurant kitchen you don't see but is essential for preparing your meal.

Understanding Frameworks

Building a backend from scratch can be overwhelming; this is where frameworks come in handy. A framework is a set of prebuilt tools and guidelines that help you build applications faster and more efficiently, like following a recipe instead of inventing a dish from scratch. Frameworks provide consistency, time savings, and community support, making them a preferred choice for developers.

Overview of Spring and Spring Boot

The Spring framework is a popular choice for building backend applications in Java. It manages code complexity by handling common tasks. Key concepts include inversion of control, where the framework manages object setup, and dependency injection, where classes request their needed dependencies from the framework. Spring Boot builds on Spring, simplifying the setup process further. It offers auto-configuration, starter dependencies, and standalone applications, making it easier to create production-ready applications quickly.

Setting Up Your First Spring Boot Project

Let's create our first Spring Boot application using the Spring Initializer. Here’s a step-by-step setup guide:

Visit the Spring Initializer:
Open your browser and go to start.spring.io. This web-based tool helps you create a Spring Boot project quickly.
Configure Project Settings:
- Choose "Java" as your language.
- Select the current Spring Boot version (e.g., 3.3.4).
- Set up the project metadata, such as the group (e.g., com.tutorials) and the artifact (e.g., library.management).
- Set the Java version to the latest available (e.g., Java 23).
Add Dependencies:
Click on "Add Dependencies" and search for "Spring Web". This will include all the tools needed for a web application.
Generate and Import the Project:
- Click "Generate" to download the project zip file.
- Unzip the folder and open it in IntelliJ IDEA.
- Use the "File Open" option to locate and select your project folder. After a moment, your libraries should load, revealing the project structure.

Running Your Application

Your main Java file is your entry point. With Spring Boot's @SpringBootApplication annotation, the framework knows where to start. Running the application is as easy as clicking the run button in IntelliJ, and you should soon see "Tomcat started at port 8080" in your console.

Visit localhost:8080 in your browser. You'll see a white label error page, which is normal at this stage and will be addressed in future configuration steps.

Basic Configuration

Inside your project, the application.properties file located in the src/main/resources folder allows you to configure various settings. For example, setting server.port=8090 changes the server port. After saving and restarting the application, Tomcat starts on port 8090. Now, accessing localhost:8090 should display the same error, as expected for now.

Conclusion

Congratulations! You've created a new Spring Boot application for a library management tool. You've covered the basics of backend development, explored frameworks, and set up and configured a basic project. In the next session, we'll delve deeper into project structure and functionality. See you soon!

Java Spring Boot for Beginners: Part 2: Diving into Project Structure, REST Controllers, and Request Handling

Alexander the dev — Tue, 15 Oct 2024 11:38:11 +0000

Welcome to the second installment of our "Java Spring Boot for Beginners" series. If you are eager to enhance your understanding of Java Spring Boot, you're in the right place. My name is Alex, and today we'll be building on what we've learned in the previous session. We're set to delve into project structure organization, develop REST controllers, and handle various HTTP requests.

If you prefer to watch the tutorial you can do so here:https://youtu.be/jAc7SSmuV2I
also, part 1 is here: https://youtu.be/lIr1tN5gTN0

Understanding Project Structure

Having a well-organized project structure is crucial for the maintainability and readability of Java code. Think of it as a neatly arranged library—it makes finding what you need much easier. Our main Java code resides in the source folder, which contains two key folders: main and test. The main package encompasses the primary components of the application, including the com.tutorials.library.Management package, which contains the all-important application entry point.

Our Java project is typically segmented into four types: Controller, Model, Repository, and Service. Let’s explore what these mean:

Controller: Handles incoming requests.
Model: Defines data models such as Book and User.
Repository: Includes interfaces for database operations.
Service: Encompasses the business logic of the application.

Creating REST Controllers

In this session, we're focusing on the Model and Controller. To start, we create a controller class named BookController. Within Spring Boot, a controller is responsible for handling user requests. By adding the @RestController annotation, we inform Spring Boot that this class is meant to handle HTTP requests.

For example, the @GetMapping annotation is used to map HTTP GET requests to a specific handler method, like our getBooks method. This method returns a list of books—initially just a placeholder string, but it demonstrates how the pattern works.

Handling HTTP Requests with Postman

To effectively test all HTTP methods, beyond just GET, you’ll need a tool like Postman. Postman allows us to send HTTP requests and interact with our running service more dynamically than a browser alone, which typically handles only GET requests.

Here's a brief look at the main HTTP methods:

GET: Retrieve information, such as listing books.
POST: Create new resources, like a new book entry.
PUT: Update existing resources, such as a book title.
DELETE: Remove resources, like deleting a book from the database.

By following these methods, we efficiently push and handle data within our Java Spring Boot application.

Building the Book Model

Next, we create a Book class to define our data model. This class has three properties: ID, title, and author. Each property requires getter and setter methods to manipulate data consistently.

Adding Functionality with Controllers

We expand our BookController to implement methods for adding, updating, and deleting books. With @PostMapping, we create a new book entry from a JSON-formatted request body. Similarly, with @PutMapping, we update an existing book, and with @DeleteMapping, we remove a book by ID.

Testing and Debugging

Finally, learning to debug is key. Running your application in debug mode and setting breakpoints helps you inspect and troubleshoot potential issues effectively. Postman aids in validating requests sent to your service, enhancing the testing process.

In our next episode, we'll explore dependency injections and components—integral concepts in Spring Boot—and further refine our library management tool. Until then, happy coding! If you have questions, feel free to comment below or reach out via social media.

See you in the next session! Happy coding, and goodbye for now.