CRUD Operations in Java

Author:
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.

Table of Contents

  1. Introduction to CRUD Operations
  2. Performing CRUD Operations using In-Memory Object
  3. Performing CRUD Operations using JDBC with MySQL Database
  4. 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.

Comments

Post a Comment

Leave Comment