Что такое CRUD и как с их помощью создать приложение на Hibernate

Пройдите тест, узнайте какой профессии подходите

Содержание

Вконтакте

Одноклассники

Скопировать ссылку

Разберем каждую функцию подробно и на примерах.

Елизавета Теряева

Автор статьи

CRUD — это способ управлять данными в программах. Например, в соцсети: написать пост (C), прочитать его (R), отредактировать (U), удалить (D). По сути, это основа работы с данными в приложениях.

Hibernate помогает выполнять CRUD-операции с базой данных удобнее и проще. Вместо того чтобы писать SQL-запросы вручную, разработчик работает с объектами в Java.

В статье разберем, как это работает и что нужно знать перед тем, как создать приложение таким способом.

Что такое CRUD

CRUD используют разработчики, когда создают сайты, приложения и базы данных. Эти операции помогают управлять информацией: добавлять, просматривать, изменять и удалять данные. Без CRUD не получится сделать интернет-магазин, соцсеть или даже простой список задач. Вот как это работает на практике.

C — Create (создать) — добавить нового пользователя в базу данных или создать новый пост в блоге.
R — Read (прочитать) — запросить список всех пользователей или открыть страницу с постом.
U — Update (обновить) — поменять имя пользователя или отредактировать уже опубликованный пост.
D — Delete (удалить) — удалить аккаунт или убрать пост из базы.

Функции CRUD

Функции CRUD — это четыре основные операции, которые разработчики используют для работы с данными в любом приложении. С ними можно создавать, получать, обновлять и удалять информацию в базе данных или другом хранилище.

Разберем каждую функцию подробно и на примерах.

Create

С этой функцией можно добавлять новую запись в таблицу базы данных. В SQL для этого есть команда INSERT.

Например, в базе данных интернет-магазина создают новую запись о товаре — нужно указать его название, цену и описание. Важно: обычные пользователи могут добавлять данные в строки, но только администратор имеет право изменять структуру таблицы, например добавлять новые столбцы.

Read

Эта функция помогает находить и просматривать данные в базе. Она работает как поиск — можно ввести запрос или отфильтровать записи по нужным параметрам. Например, если в базе данных хранятся автомобили, можно найти «Toyota Corolla 1996» или отфильтровать список по марке, модели и году выпуска. В SQL для этого используют команду SELECT.

Update

Эта функция пригодится, если нужно изменить данные в уже существующей записи. Например, в базе данных ресторана хранятся рецепты, где указаны ингредиенты, время приготовления блюда и его цена.

Если шеф-повар решит заменить один из ингредиентов, он обновит нужную запись в таблице. В SQL для этого используют команду UPDATE.

Delete

Эта функция удаляет ненужные записи из базы. В SQL для этого есть команда DELETE. В некоторых системах есть два способа, как можно удалить информацию:

Жесткий — данные полностью исчезают из базы.
Мягкий — запись остается, но помечается как удаленная, чтобы ее можно было восстановить.

Если хотите освоить программирование и сделать его интересной частью своей жизни, в онлайн-университете Skypro есть курсы программирования. Вы сможете не только изучить CRUD, но и получить другие полезные навыки и найти в IT любимую работу.

Что такое Hibernate и для чего его используют

Фреймворк Hibernate появился в 2001 году, когда Гэвин Кинг и его коллеги из компании Cirrus Technologies решили создать удобную альтернативу уже неактуальным механизмам работы с базами данных в EJB2 — Enterprise Java Beans 2. Их цель была простой — хранить данные эффективнее и сделать этот процесс более гибким.

Важные версии:

2003 год — выходит Hibernate 2.0, значительно улучшенная версия.
2005 год — выпуск Hibernate 3.0, который добавил поддержку новых возможностей Java.
2018 год — появляется Hibernate ORM 5.4.0, последняя крупная версия, на которой работает множество современных Java-приложений.

Hibernate помогает Java-приложениям работать с реляционными базами данных — это такой способ хранения данных в виде таблиц. Он относится к ORM — объектно-реляционному отображению. Это значит, что данные из таблиц базы можно использовать как обычные Java-объекты.

Такой способ удобный, потому что разработчику не нужно писать сложные SQL-запросы вручную.

Hibernate связывает классы Java с таблицами в базе данных. Например, если у нас есть класс User, Hibernate автоматически создаст для него таблицу users и будет управлять записями в ней. Разработчик пишет код на Java, а Hibernate сам превращает его в SQL-запросы. Его выбирают, потому что он:

Упрощает работу с базой данных, ему не нужно много SQL-кода.
Позволяет работать с данными в виде объектов, а не строк SQL.
Обновляет и сохраняет данные автоматически.
Упрощает поддержку кода — если структура базы изменится, в коде не нужно переписывать много логики.

Как работать с Hibernate

Чтобы запустить работу с Hibernate, нужно выполнить три шага: создать сущность, настроить фреймворк и начать работу с данными.

Шаг 1. Создать сущность.
Сначала создаем Java-классы, которые будут представлять таблицы базы данных. Например, если в базе есть таблица с пользователями, создаем класс «Пользователь» с полями «имя» и «email». Добавляем специальные аннотации, чтобы Hibernate понимал, как связать класс с таблицей.
Шаг 2. Настроить Hibernate.
Дальше нужно настроить Hibernate: указать, к какой базе подключаться, как обрабатывать данные и какие таблицы использовать. Это делается в конфигурационном файле или прямо в коде с помощью аннотаций.
Шаг 3. Начать работу с данными.
Теперь можно создавать, искать, изменять и удалять записи. Например, добавить нового пользователя, обновить его email или удалить запись. Hibernate сам превращает действия с объектами в SQL-запросы и отправляет их в базу. Разработчику не нужно писать код для работы с SQL вручную.

Как создать CRUD-приложение на Hibernate

Чтобы создать CRUD-приложение на Hibernate, нужно выполнить несколько шагов:

подготовить проект;
подключить базу данных;
создать сущность;
настроить SessionFactory;
написать код для операций Create, Read, Update, Delete;
протестировать их.

Рассмотрим эти шаги подробно.

Подготовить проект.

Сначала создадим Maven-проект и добавим зависимости в pom.xml:

<dependencies>

    

    <dependency>

        <groupId>org.hibernate</groupId>

        <artifactId>hibernate-core</artifactId>

        <version>5.6.15.Final</version>

    </dependency>



    

    <dependency>

        <groupId>mysql</groupId>

        <artifactId>mysql-connector-java</artifactId>

        <version>8.0.33</version>

    </dependency>



    

    <dependency>

        <groupId>jakarta.persistence</groupId>

        <artifactId>jakarta.persistence-api</artifactId>

        <version>3.1.0</version>

    </dependency>

</dependencies>
Настроить Hibernate — hibernate.cfg.xml.

Создадим конфигурационный файл hibernate.cfg.xml в папке resources:
<hibernate-configuration>

    <session-factory>

        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>

        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/testdb</property>

        <property name="hibernate.connection.username">root</property>

        <property name="hibernate.connection.password">password</property>

        <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>

        <property name="hibernate.hbm2ddl.auto">update</property>

        <property name="show_sql">true</property>

    </session-factory>

</hibernate-configuration>

Здесь мы указываем, к какой базе данных подключаемся и какие настройки используем.
Создать сущность — модель данных.

Определим класс User, который будет представлять таблицу в базе:
import jakarta.persistence.*;

@Entity

@Table(name = "users")

public class User {

    @Id

    @GeneratedValue(strategy = GenerationType.IDENTITY)

    private Long id;

    @Column(name = "name")

    private String name;

    @Column(name = "email", unique = true, nullable = false)

    private String email;

    public User() {}

    public User(String name, String email) {

        this.name = name;

        this.email = email;

    }

    public Long getId() { return 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; }

    @Override

    public String toString() {

        return "User{id=" + id + ", name='" + name + "', email='" + email + "'}";

    }

}

Hibernate автоматически создаст таблицу users с полями id, name, email.
Настроить SessionFactory.

Добавим класс для управления сессиями Hibernate:
import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {

        try {

            return new Configuration().configure().buildSessionFactory();

        } catch (Throwable ex) {

            throw new ExceptionInInitializerError(ex);

        }

    }

    public static SessionFactory getSessionFactory() {

        return sessionFactory;

    }

    public static void shutdown() {

        getSessionFactory().close();

    }

}

Этот класс создает единственный объект SessionFactory, который отвечает за соединение с базой данных.
Реализовать CRUD-операции.

Теперь напишем класс UserDAO, который содержит методы для операций Create, Read, Update, Delete:
import org.hibernate.Session;

import org.hibernate.Transaction;

import java.util.List;

public class UserDAO {

    public void createUser(User user) {

        Transaction transaction = null;

        try (Session session = HibernateUtil.getSessionFactory().openSession()) {

            transaction = session.beginTransaction();

            session.save(user);

            transaction.commit();

        } catch (Exception e) {

            if (transaction != null) transaction.rollback();

            e.printStackTrace();

        }

    }

    public User getUserById(Long id) {

        try (Session session = HibernateUtil.getSessionFactory().openSession()) {

            return session.get(User.class, id);

        }

    }

    public List<User> getAllUsers() {

        try (Session session = HibernateUtil.getSessionFactory().openSession()) {

            return session.createQuery("from User", User.class).list();

        }

    }

    public void updateUser(User user) {

        Transaction transaction = null;

        try (Session session = HibernateUtil.getSessionFactory().openSession()) {

            transaction = session.beginTransaction();

            session.update(user);

            transaction.commit();

        } catch (Exception e) {

            if (transaction != null) transaction.rollback();

            e.printStackTrace();

        }

    }

    public void deleteUser(Long id) {

        Transaction transaction = null;

        try (Session session = HibernateUtil.getSessionFactory().openSession()) {

            transaction = session.beginTransaction();

            User user = session.get(User.class, id);

            if (user != null) {

                session.delete(user);

                System.out.println("Пользователь удален: " + user);

            }

            transaction.commit();

        } catch (Exception e) {

            if (transaction != null) transaction.rollback();

            e.printStackTrace();

        }

    }

}
Протестировать CRUD-операции.

Теперь протестируем всё в Main.java:

public class Main {

    public static void main(String[] args) {

        UserDAO userDAO = new UserDAO();

        // Создаем пользователя

        User newUser = new User("Анна", "anna@mail.com");

        userDAO.createUser(newUser);

        // Получаем всех пользователей

        System.out.println("Список пользователей:");

        userDAO.getAllUsers().forEach(System.out::println);

        // Обновляем пользователя

        newUser.setName("Анна Смирнова");

        userDAO.updateUser(newUser);

        // Получаем пользователя по ID

        User retrievedUser = userDAO.getUserById(newUser.getId());

        System.out.println("Найден пользователь: " + retrievedUser);

        // Удаляем пользователя

        userDAO.deleteUser(newUser.getId());

        HibernateUtil.shutdown();

    }

}

Что на выходе:

Создали Maven-проект и подключили Hibernate.
Настроили соединение с базой данных.
Описали сущность User, которая автоматически связана с таблицей.
Реализовали методы Create, Read, Update, Delete.
Запустили приложение и проверили работу CRUD-операций.

Этот код можно адаптировать под любую базу данных и использовать в реальных Java-приложениях.

Главное

CRUD — это набор операций, с которыми можно создавать, читать, обновлять и удалять данные. Hibernate упрощает эти процессы в Java-приложениях — заменяет SQL-запросы на работу с объектами.
Разработчики используют CRUD, когда создают сайты, приложения и базы данных. Эти операции позволяют добавлять, просматривать, изменять и удалять информацию. Без CRUD не получится создать интернет-магазин, соцсеть или даже простой список задач.
CRUD — это четыре действия, которые помогают работать с данными: создавать, читать, обновлять и удалять. Create добавляет новую запись в базу, например товар в интернет-магазине. Read ищет и просматривает данные, как при поиске автомобиля по параметрам. Update меняет информацию, например если в рецепте заменяют ингредиент. Delete убирает записи — либо навсегда, либо с возможностью восстановления.
Hibernate появился в 2001 году на замену устаревшим методам работы с базами данных. Инструмент автоматически связывает Java-классы с таблицами и превращает операции с объектами в SQL-запросы. Разработчики выбирают его, потому что он упрощает работу с данными, автоматизирует их сохранение и делает код легче в поддержке.
Нужно настроить проект, чтобы создать CRUD-приложение на Hibernate, подключить базу данных и описать сущность, которая будет представлять таблицу. Потом настроить SessionFactory, чтобы управлять соединением, и написать код для CRUD-операций. После — протестировать приложение и адаптировать его под разные проекты.