Рубрики
Без рубрики

Реализация режима гибернации с помощью Spring Boot и PostgreSQL

Автор оригинала: Robley Gori.

Вступление

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

Именно по этой и многим другим причинам безопасное хранение и обработка данных стали важным аспектом любой создаваемой системы или приложения.

Что такое Объектно-Реляционное сопоставление?

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

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

ORM-это библиотека, которая помогает нам легко взаимодействовать с несколькими базами данных или системами, используя выбранный нами язык. Наш код теперь сопоставлен с конкретным языком запросов баз данных.

Обычно для взаимодействия с базой данных нам необходимо использовать язык, специфичный для конкретной базы данных. Например, для взаимодействия с базой данных MySQL нам необходимо использовать Язык структурированных запросов (SQL), но эти языки могут отличаться от платформы к платформе.

Например, хотя они все еще похожи, синтаксис базы данных Postgres отличается от языка запросов, используемого в базе данных Microsoft SQL . ORM помогает преодолеть это различие и легко подключать ваше программное обеспечение к различным системам баз данных.

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

Однако есть некоторые недостатки, связанные с ORMS, и они включают:

  • ORM имеют тенденцию быть медленными в некоторых ситуациях с точки зрения производительности
  • Для сложных запросов, таких как соединения, ПЗУ иногда не могут заменить необработанные SQL-запросы
  • Из-за абстракций, введенных ORM, разработчик может потерять понимание SQL и того, как управление базами данных осуществляется за кулисами

Зимовать

Hibernate – это платформа, которая позволяет разработчикам легко сохранять данные приложений в реляционных базах данных с помощью JDBC. Это реализация Java Persistence API (JPA), что означает, что ее можно использовать в любой системе, поддерживающей JPA, такой как standard edition (Java SE) и enterprise edition (Java EE).

Hibernate-это легкий инструмент с открытым исходным кодом, который упрощает создание, обработку и доступ к данным из базы данных в приложениях на базе Java. Он работает путем сопоставления объекта, созданного из класса Java, и его атрибутов с данными, хранящимися в базе данных.

Некоторые преимущества использования Hibernate включают:

  • Он имеет открытый исходный код и легкий вес, что означает, что он бесплатен в использовании и сообщество участников постоянно совершенствует его
  • Hibernate использует внутренний кэш, что повышает его производительность
  • Он не зависит от базы данных, что означает, что его можно использовать для доступа к данным и управления ими в различных базах данных
  • Он предоставляет функциональные возможности для упрощения соединений при извлечении данных из нескольких таблиц
  • Автоматически создавая таблицы, разработчик может сосредоточиться на выполнении другой логики
  • Это стабильная структура, которая существует уже 18 лет

Альтернативы

Hibernate-не единственная платформа ORM, которую мы можем использовать в наших приложениях Java, другие включают:

  • JOOQ (Объектно-ориентированные запросы Java) – это легкая библиотека программного обеспечения для сопоставления баз данных
  • JDBI обеспечивает удобный доступ к реляционным данным на Java
  • MyBatis – это платформа SQL-картографа для интеграции реляционных баз данных
  • Ebean , который может использоваться как для приложений на базе Java, так и для приложений на базе Kotlin
  • ORMLite , который является облегченной платформой для сохранения объектов Java в базах данных SQL

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

Реализация режима гибернации с помощью Spring Boot

Настройка проекта

Для этого демонстрационного проекта мы будем использовать базу данных PostgreSQL, а инструкции по установке можно найти здесь для платформ Mac OS, Linux и Windows.

После настройки мы можем создать нашу демонстрационную базу данных, демо телефонов . pgAdmin предоставляет пользовательский интерфейс для взаимодействия с базой данных PostgreSQL, но также можно использовать терминал.

Давайте теперь посмотрим, как работает Hibernate, используя его в примере Spring Boot API, который мы загрузим с помощью инструмента Spring Initializr :

Мы будем использовать Java 8 и Maven для управления зависимостями с несколькими зависимостями:

  • Spring Web Starter чтобы помочь нам создать веб-приложение
  • Spring Data JPA для предоставления API доступа к данным, который будет использоваться в режиме гибернации
  • База данных H2 для включения функций гибернации в наш проект
  • PostgreSQL для подключения к базе данных PostgreSQL

Как только мы нажмем “Создать”, мы получим zip-файл, содержащий проект, и сможем приступить к реализации веб-приложения, для которого требуется база данных. Как только мы распакуем этот zip-файл в нашу рабочую папку, мы сможем проверить, готов ли он к работе, выполнив команду:

$ mvn spring-boot:run

Реализация

Позвольте нам изменить наш application.properties , чтобы включить сведения о нашей базе данных:

# Database Properties
spring.datasource.url=jdbc:postgresql://localhost:5432/phonesdemo
spring.datasource.username=postgres
spring.datasource.password=

# Hibernate Properties
# The SQL dialect makes Hibernate generate better SQL for the chosen database
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQL92Dialect

# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto=update

Hibernate предоставляет консоль H2, которую мы можем использовать для проверки состояния базы данных и даже для ввода данных через пользовательский интерфейс. Мы включаем его, добавив следующую строку в наш application.properties :

spring.h2.console.enabled=true

Git Essentials

Ознакомьтесь с этим практическим руководством по изучению Git, содержащим лучшие практики и принятые в отрасли стандарты. Прекратите гуглить команды Git и на самом деле изучите это!

Затем мы запускаем ваше приложение и переходим к http://localhost:8080/h2-console чтобы проверить, все ли работает. Мы получаем страницу, на которой мы можем проверить, работает ли соединение с нашей базой данных:

В раскрывающемся списке сохраненные настройки мы выберем Generic PostgreSQL , а также обновим URL-адрес JDBC, чтобы он соответствовал имени нашей тестовой базы данных. Затем мы вводим имя пользователя и пароль нашей базы данных и нажимаем “Проверить подключение”, чтобы убедиться, что наше приложение Spring может подключиться к нашей базе данных. Если все хорошо настроено, мы получим сообщение об успехе.

Если мы нажмем “Подключиться”, мы получим эту страницу:

Здесь мы можем перемещаться по нашей базе данных и даже выполнять SQL-запросы.

API, который мы будем создавать, будет использоваться для хранения и управления телефонами и их атрибутами, такими как имя и операционная система. Имея нашу базу данных на месте и подключенную, давайте создадим класс сущностей ( Телефон.java ), который сопоставит атрибуты вашего объекта с базой данных и позволит нам выполнять операции CRUD в базе данных:

// Imports truncated for brevity, refer to GitHub link below for the full code

@Entity
@Table(name = "phones")
@EntityListeners(AuditingEntityListener.class)
public class Phone {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id; // Each phone will be given an auto-generated unique identifier when stored

    @Column(name = "phone_name", nullable = false)
    private String phoneName; // Save the name of the phone

    @Column(name = "os", nullable = false)
    private String os; // Save the operating system running in the phone
    
    // Standard getters and setters
}

Аннотация @Entity сообщает Hibernate, что этот класс представляет сущность, которую следует сохранить.

Аннотация @Table используется для присвоения имени таблице. Если эта аннотация опущена, в таблице будет просто использоваться имя класса/сущности.

Аналогично, аннотации @Column также могут быть опущены, но в столбцах базы данных будут использоваться имена полей, как они есть, и иногда это не является предпочтительным поведением, поскольку имена ваших столбцов могут быть регистром змеи, а имена полей-регистром верблюда, например.

Когда мы сохраним этот файл, перезагрузим наш сервер и проверим нашу базу данных, появится новая таблица под названием телефоны и будут присутствовать столбцы идентификатор , имя телефона и ос .

Данных не будет, но это Hibernate на работе, если таблица, указанная в классе сущностей, не существует, Hibernate создаст ее для нас.

Давайте теперь внедрим контроллер, который поможет нам выполнять операции с нашей базой данных через API:

@RestController
@RequestMapping("/api/v1")
public class PhoneController {
    @Autowired
    private PhoneRepository phoneRepository;

    // GET method to fetch all phones
    @GetMapping("/phones")
    public List getAllPhones() {
        return phoneRepository.findAll();
    }

    // GET method to fetch phone by Id
    @GetMapping("/phones/{id}")
    public ResponseEntity getPhoneById(@PathVariable(value = "id") Long phoneId)
        throws Exception {
        Phone phone = phoneRepository.findById(phoneId)
               .orElseThrow(() -> new Exception("Phone " + phoneId + " not found"));
        return ResponseEntity.ok().body(phone);
    }
  
    // POST method to create a phone
    @PostMapping("/phones")
    public Phone createPhone(@Valid @RequestBody Phone phone) {
        return phoneRepository.save(phone);
    }
  
    // PUT method to update a phone's details
    @PutMapping("/phones/{id}")
    public ResponseEntity updatePhone(
        @Valid @RequestBody Phone phoneDetails
    ) throws Exception {
        Phone phone = phoneRepository.findById(phoneId)
            .orElseThrow(() -> new Exception("Phone " + phoneId + " not found"));

        phone.setPhoneName(phoneDetails.getPhoneName());
        phone.setOs(phoneDetails.getOs());

        final Phone updatedPhone = phoneRepository.save(phone);
        return ResponseEntity.ok(updatedPhone);
    }
  
    // DELETE method to delete a phone
    @DeleteMapping("/phone/{id}")
    public Map deletePhone(throws Exception {
        Phone phone = phoneRepository.findById(phoneId)
            .orElseThrow(() -> new Exception("Phone " + phoneId + " not found"));

        phoneRepository.delete(phone);
        Map response = new HashMap<>();
        response.put("deleted", Boolean.TRUE);
        return response;
    }
}

В нашем классе контроллера мы аннотируем наш класс с помощью @RestController , чтобы указать, что это класс обработчика запросов, который будет обрабатывать функции REST для нашего API. Затем мы определяем методы для обработки каждой из четырех операций RESTful: GET , POST , PUT и DELETE . Эти методы обеспечат нам интерфейс для взаимодействия с нашим API и управления данными.

Наш API, в свою очередь, будет использовать Hibernate для отражения наших операций с указанными данными в нашей базе данных.

Давайте начнем с создания единого телефона через наш API:

Мы получаем ответ от нашего API, но давайте проверим базу данных с помощью консоли H2, чтобы подтвердить:

Как вы можете видеть на скриншоте выше, для извлечения данных из нашей базы данных мы используем команду SQL ВЫБЕРИТЕ * ИЗ телефонов . Чтобы добиться того же в нашем коде с помощью ORM, это так же просто, как использовать строку:

phoneRepository.findAll();

Это более дружелюбно и знакомо нам, так как достигается на том же языке, который мы используем при реализации остальной части нашего проекта.

Вывод

Мы успешно создали объект телефона и сохранили его атрибуты в нашей базе данных PostgreSQL с помощью Hibernate в нашем API весенней загрузки. Мы можем добавлять больше телефонов, удалять телефоны и обновлять данные телефонов, взаимодействуя с API, и режим гибернации будет отражать изменения в нашей базе данных.

Hibernate упростил нам взаимодействие с базой данных из нашего приложения Spring Boot и управление нашими данными. Время разработки также значительно сократилось, так как нам не нужно писать команды SQL для самостоятельного управления данными.

Исходный код этого проекта доступен здесь, на GitHub .