Что такое 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, нужно выполнить несколько шагов:

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

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

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

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

       <!-- Hibernate Core -->

       <dependency>

           <groupId>org.hibernate</groupId>

           <artifactId>hibernate-core</artifactId>

           <version>5.6.15.Final</version>

       </dependency>

       

       <!-- JDBC-драйвер для базы данных (например, MySQL) -->

       <dependency>

           <groupId>mysql</groupId>

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

           <version>8.0.33</version>

       </dependency>

       

       <!-- JPA API -->

       <dependency>

           <groupId>jakarta.persistence</groupId>

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

           <version>3.1.0</version>

       </dependency>

   </dependencies>

2. Настроить 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>

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

3. Создать сущность — модель данных.

   Определим класс 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.

4. Настроить 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, который отвечает за соединение с базой данных.

5. Реализовать 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();

           }

       }

   }

6. Протестировать 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-операций. После — протестировать приложение и адаптировать его под разные проекты.