🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

In this tutorial, we will cover CRUD (Create, Read, Update, Delete) operations using Java. We will first explain CRUD operations and then demonstrate how to perform them using an in-memory object. Finally, we will show how to perform CRUD operations using JDBC with a MySQL database.

Introduction to CRUD Operations
Performing CRUD Operations using In-Memory Object
Performing CRUD Operations using JDBC with MySQL Database
Conclusion

1. Introduction to CRUD Operations

CRUD operations are the four basic functions of persistent storage. They are:

Create: Add new records.
Read: Retrieve records.
Update: Modify existing records.
Delete: Remove records.

These operations are essential in any application that deals with data storage.

2. Performing CRUD Operations using In-Memory Object

Let's start by performing CRUD operations using a simple in-memory object. We'll use a list to store our data.

Create an Employee Class

package com.example.crud;

public class Employee {
    private int id;
    private String name;
    private String email;
    private String department;

    public Employee(int id, String name, String email, String department) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.department = department;
    }

    // Getters and setters
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }

    public String getDepartment() { return department; }
    public void setDepartment(String department) { this.department = department; }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", department='" + department + '\'' +
                '}';
    }
}

Create an In-Memory CRUD Service

package com.example.crud;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

public class EmployeeService {
    private List<Employee> employees = new ArrayList<>();

    // Create
    public void addEmployee(Employee employee) {
        employees.add(employee);
    }

    // Read
    public List<Employee> getAllEmployees() {
        return employees;
    }

    public Optional<Employee> getEmployeeById(int id) {
        return employees.stream().filter(emp -> emp.getId() == id).findFirst();
    }

    // Update
    public void updateEmployee(Employee updatedEmployee) {
        getEmployeeById(updatedEmployee.getId()).ifPresent(employee -> {
            employee.setName(updatedEmployee.getName());
            employee.setEmail(updatedEmployee.getEmail());
            employee.setDepartment(updatedEmployee.getDepartment());
        });
    }

    // Delete
    public void deleteEmployee(int id) {
        employees.removeIf(emp -> emp.getId() == id);
    }
}

Test the In-Memory CRUD Operations

package com.example.crud;

public class TestEmployeeService {
    public static void main(String[] args) {
        EmployeeService employeeService = new EmployeeService();

        // Create employees
        Employee emp1 = new Employee(1, "Ravi Kumar", "ravi.kumar@example.com", "IT");
        Employee emp2 = new Employee(2, "Sita Sharma", "sita.sharma@example.com", "Finance");
        employeeService.addEmployee(emp1);
        employeeService.addEmployee(emp2);

        // Read employees
        System.out.println("Employees after creation:");
        employeeService.getAllEmployees().forEach(System.out::println);

        // Update employee
        Employee updatedEmp1 = new Employee(1, "Ravi Kumar Singh", "ravi.singh@example.com", "IT");
        employeeService.updateEmployee(updatedEmp1);

        // Read employees
        System.out.println("Employees after update:");
        employeeService.getAllEmployees().forEach(System.out::println);

        // Delete employee
        employeeService.deleteEmployee(2);

        // Read employees
        System.out.println("Employees after deletion:");
        employeeService.getAllEmployees().forEach(System.out::println);
    }
}

3. Performing CRUD Operations using JDBC with MySQL Database

Next, let's perform the same CRUD operations using JDBC with a MySQL database.

Database Setup

First, create a database and a table in MySQL.

CREATE DATABASE test_db;

USE test_db;

CREATE TABLE employees (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(50) NOT NULL,
    email VARCHAR(50) NOT NULL,
    department VARCHAR(50) NOT NULL
);

Create JDBC Utility Class

package com.example.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class JDBCUtils {
    private static final String URL = "jdbc:mysql://localhost:3306/test_db?useSSL=false";
    private static final String USER = "root";
    private static final String PASSWORD = "root";

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, USER, PASSWORD);
    }

    public static void printSQLException(SQLException ex) {
        for (Throwable e : ex) {
            if (e instanceof SQLException) {
                e.printStackTrace(System.err);
                System.err.println("SQLState: " + ((SQLException) e).getSQLState());
                System.err.println("Error Code: " + ((SQLException) e).getErrorCode());
                System.err.println("Message: " + e.getMessage());
                Throwable t = ex.getCause();
                while (t != null) {
                    System.out.println("Cause: " + t);
                    t = t.getCause();
                }
            }
        }
    }
}

CRUD Operations using JDBC

Create

package com.example.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class InsertEmployee {

    private static final String INSERT_EMPLOYEES_SQL = "INSERT INTO employees (name, email, department) VALUES (?, ?, ?);";

    public void insertRecord(String name, String email, String department) throws SQLException {
        try (Connection connection = JDBCUtils.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(INSERT_EMPLOYEES_SQL)) {
            preparedStatement.setString(1, name);
            preparedStatement.setString(2, email);
            preparedStatement.setString(3, department);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            JDBCUtils.printSQLException(e);
        }
    }
}

Read

package com.example.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class SelectEmployees {

    private static final String SELECT_ALL_EMPLOYEES = "SELECT * FROM employees;";

    public void selectAllRecords() throws SQLException {
        try (Connection connection = JDBCUtils.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(SELECT_ALL_EMPLOYEES)) {
            ResultSet rs = preparedStatement.executeQuery();
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String email = rs.getString("email");
                String department = rs.getString("department");
                System.out.println(id + ", " + name + ", " + email + ", " + department);
            }
        } catch (SQLException e) {
            JDBCUtils.printSQLException(e);
        }
    }
}

Update

package com.example.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class UpdateEmployee {

    private static final String UPDATE_EMPLOYEES_SQL = "UPDATE employees SET name = ?, email = ?, department = ? WHERE id = ?;";

    public void updateRecord(int id, String name, String email, String department) throws SQLException {
        try (Connection connection = JDBCUtils.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(UPDATE_EMPLOYEES_SQL)) {
            preparedStatement.setString(1, name);
            preparedStatement.setString(2, email);
            preparedStatement.setString(3, department);
            preparedStatement.setInt(4, id);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            JDBCUtils.printSQLException(e);
        }
    }
}

Delete

package com.example.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class DeleteEmployee {

    private static final String DELETE_EMPLOYEES_SQL = "DELETE FROM employees WHERE id = ?;";

    public void deleteRecord(int id) throws SQLException {
        try (Connection connection = JDBCUtils.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(DELETE_EMPLOYEES_SQL)) {
            preparedStatement.setInt(1, id);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            JDBCUtils.printSQLException(e);
        }
    }
}

Test CRUD Operations using JDBC

package com.example.jdbc;

import java.sql.SQLException;

public class TestCRUDOperations {

    public static void main(String[] args) {
        InsertEmployee insertEmployee = new InsertEmployee();
        SelectEmployees selectEmployees = new SelectEmployees();
        UpdateEmployee updateEmployee = new UpdateEmployee();
        DeleteEmployee deleteEmployee = new DeleteEmployee();

        try {
            // Insert records
            insertEmployee.insertRecord("Ravi Kumar", "ravi

.kumar@example.com", "IT");
            insertEmployee.insertRecord("Sita Sharma", "sita.sharma@example.com", "Finance");
            insertEmployee.insertRecord("Rahul Jain", "rahul.jain@example.com", "HR");

            // Read records
            System.out.println("Employees after insertion:");
            selectEmployees.selectAllRecords();

            // Update record
            updateEmployee.updateRecord(1, "Ravi Kumar Singh", "ravi.singh@example.com", "IT");

            // Read records
            System.out.println("Employees after updating record with ID 1:");
            selectEmployees.selectAllRecords();

            // Delete record
            deleteEmployee.deleteRecord(3);

            // Read records
            System.out.println("Employees after deleting record with ID 3:");
            selectEmployees.selectAllRecords();

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Conclusion

In this tutorial, we covered the basics of CRUD operations and demonstrated how to perform these operations using an in-memory object and JDBC with a MySQL database. Following these examples, you can understand how to create, read, update, and delete records in Java applications using different storage mechanisms.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide

Guides to Java, Spring Boot, Microservices Best Practices

CRUD Operations in Java

Table of Contents

1. Introduction to CRUD Operations

2. Performing CRUD Operations using In-Memory Object

Create an Employee Class

Create an In-Memory CRUD Service

Test the In-Memory CRUD Operations

3. Performing CRUD Operations using JDBC with MySQL Database

Database Setup

Create JDBC Utility Class

CRUD Operations using JDBC

Create

Read

Update

Delete

Test CRUD Operations using JDBC

Conclusion

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Build REST APIs with Spring Boot 4, Spring Security 7, and JWT

[NEW] Learn Apache Maven with IntelliJ IDEA and Java 25

ChatGPT + Generative AI + Prompt Engineering for Beginners

Spring 7 and Spring Boot 4 for Beginners (Includes 8 Projects)

Building Real-Time REST APIs with Spring Boot - Blog App

Building Microservices with Spring Boot and Spring Cloud

Java Full-Stack Developer Course with Spring Boot and React JS

Build 5 Spring Boot Projects with Java: Line-by-Line Coding

Testing Spring Boot Application with JUnit and Mockito

Spring Boot Thymeleaf Real-Time Web Application - Blog App

Master Spring Data JPA with Hibernate

Spring Boot + Apache Kafka Course - The Practical Guide

Java Testing: Mastering JUnit 5 Framework

Reactive Programming in Java: Spring WebFlux and Testing

Spring Boot + RabbitMQ Course - The Practical Guide

Functional Programming in Java (Includes Java Collections)

ChatGPT for Java Developers: Boost Your Productivity with AI

Guides to Java, Spring Boot, Microservices Best Practices

Comments

Post a Comment

Spring Boot 3 Paid Course Published for Free on my Java Guides YouTube Channel

Spring Boot 3 Paid Course Published for Free
on my Java Guides YouTube Channel