Ошибка подключения к PostgreSQL через Docker в Spring Boot

Пытаюсь запустить Spring Boot приложение с PostgreSQL, поднятым через Docker. Но приложение не может подключиться к базе данных.

[CODE]application.properties:

properties
Копировать
Редактировать
spring.datasource.url=jdbcostgresql://localhost:5432/mydb
spring.datasource.username=postgres
spring.datasource.password=postgres
spring.jpa.hibernate.ddl-auto=update
Docker Compose:

yaml
Копировать
Редактировать
version: '3.8'
services:
postgres:
image: postgres:13
container_name: my_postgres
environment:
POSTGRES_USER: postgres
POSTGRES_PASSWORD: postgres
POSTGRES_DB: mydb
ports:
- "5432:5432"
Spring Boot падает с ошибкой:

makefile
Копировать
Редактировать
org.postgresql.util.PSQLException: Connection to localhost:5432 refused.
Контейнер с базой данных запущен и отвечает через docker ps. В чем может быть проблема?







58. Конфигурация ApplicationContext с помощью аннотаций в Spring
Для конфигурации ApplicationContext с помощью аннотаций Spring предлагает подход Java-based Configuration, который позволяет отказаться от XML-файлов.
Основные аннотации:
• @Configuration: указывает, что класс содержит определения Bean.
• @Bean: помечает метод, возвращающий Bean, который будет управляться Spring.
• @ComponentScan: сообщает контейнеру, где искать компоненты (классы, помеченные аннотациями, такими как @Component, @Service, @Repository, @Controller).
Преимущества аннотаций:
• Упрощение конфигурации.
• Код становится более читаемым и компактным.
• Позволяет объединять конфигурацию и логику в одном месте.
59. Связывание в Spring, аннотация @Autowired
Связывание (Wiring) — это процесс автоматического сопоставления зависимостей между объектами в IoC-контейнере.
Аннотация @Autowired используется для автоматического внедрения зависимостей:
• Она указывает контейнеру, что необходимо найти подходящий Bean и связать его с текущим компонентом.
• Может применяться к полям, конструкторам или методам.
Типы автосвязывания:
• По типу: внедрение осуществляется на основе типа Bean.
• По имени (в XML-конфигурации).
При наличии нескольких подходящих Bean можно использовать аннотацию @Qualifier для указания имени нужного компонента.
60. Архитектурный стиль REST
REST (Representational State Transfer) — это архитектурный стиль для создания веб-сервисов, использующий HTTP-протокол.
Основные принципы REST:
1. Ресурсо-ориентированность: данные представляются как ресурсы (например, users, orders).
2. Унифицированный интерфейс: для работы с ресурсами используются HTTP-методы:
o GET — получение данных.
o POST — создание новых данных.
o PUT — обновление существующих данных.
o DELETE — удаление данных.
3. Без состояния (stateless): сервер не хранит состояния клиента между запросами.
4. Поддержка различных форматов данных: обычно используется JSON или XML.
REST облегчает интеграцию между системами и подходит для микросервисной архитектуры.
61. Spring Web-MVC, основная схема и логика работы
Spring Web-MVC — это модуль Spring для создания веб-приложений на основе шаблона Model-View-Controller (MVC).
Основная схема работы:
1. Клиент отправляет запрос на сервер.
2. DispatcherServlet принимает запрос и направляет его в обработчик.
3. Контроллер (Controller) обрабатывает запрос и взаимодействует с моделью (данными).
4. Результаты передаются в представление (View), которое формирует ответ для клиента.
Основные компоненты:
• DispatcherServlet: центральный компонент, управляющий маршрутизацией запросов.
• Контроллеры: классы, аннотированные @Controller, обрабатывают запросы.
• ViewResolver: отвечает за выбор подходящего представления.
• Model: объект, передающий данные между контроллером и представлением.
62. Класс DispatcherServlet, его функции
DispatcherServlet — это центральный компонент Spring Web-MVC, который управляет обработкой запросов.
Основные функции:
1. Принимает HTTP-запросы и определяет, как их обработать.
2. Передает запросы в контроллеры, согласно конфигурации маппинга.
3. Обрабатывает исключения, если они возникают.
4. Передает данные из контроллеров в представления (например, JSP или HTML).
5. Выполняет интеграцию между компонентами, такими как ViewResolver, HandlerMapping и ModelAndView.
63. Маппинг в Spring
Маппинг (mapping) в Spring — это процесс сопоставления HTTP-запросов с методами контроллеров.
Для маппинга используется аннотация @RequestMapping (и ее сокращенные версии, такие как @GetMapping, @PostMapping):
• @RequestMapping: указывает URL и HTTP-метод, которые должен обрабатывать метод контроллера.
• @PathVariable: позволяет извлекать значения из URL.
• @RequestParam: используется для получения параметров из строки запроса.
HandlerMapping — это компонент Spring, который определяет, какой метод контроллера будет обрабатывать запрос.
Маппинг позволяет организовать логику приложения, распределяя запросы между разными методами и контроллерами.
64. Интерфейсы HttpServletRequest и HttpServletResponse.
Интерфейсы HttpServletRequest и HttpServletResponse являются ключевыми компонентами Java Servlet API, которые используются для обработки HTTP-запросов и формирования HTTP-ответов в веб-приложениях на основе Java.
HttpServletRequest
HttpServletRequest представляет HTTP-запрос и предоставляет методы для получения информации о запросе.
Основные методы:
Параметры запроса:
• String getParameter(String name): Получает значение параметра.
• Map<String, String[]> getParameterMap(): Возвращает все параметры.
Информация о запросе:
• String getMethod(): Возвращает HTTP-метод (GET, POST и т.д.).
• String getRequestURI(): Возвращает URI запроса.
Заголовки:
• String getHeader(String name): Получает значение заголовка.
• Enumeration<String> getHeaderNames(): Возвращает все имена заголовков.
Сессии:
• HttpSession getSession(): Возвращает объект сессии.
HttpServletResponse
HttpServletResponse используется для формирования и отправки HTTP-ответа.
Основные методы:
Статус ответа:
• void setStatus(int sc): Устанавливает статус-код.
• void sendError(int sc): Отправляет ошибку.
Заголовки:
• void setHeader(String name, String value): Устанавливает заголовок.
• void addHeader(String name, String value): Добавляет заголовок.
Тип содержимого:
• void setContentType(String type): Устанавливает MIME-тип.
Запись ответа:
• PrintWriter getWriter(): Получает объект для записи текста.
• ServletOutputStream getOutputStream(): Получает объект для записи бинарных данных.
Перенаправление:
• void sendRedirect(String location): Перенаправляет клиента.

65. Архитектурный стиль CRUD, его соответствие REST и HTTP.
Архитектурный стиль CRUD
CRUD (Create, Read, Update, Delete) — это базовый архитектурный стиль, который описывает четыре основные операции, выполняемые над данными в приложениях. Эти операции соответствуют основным действиям, которые можно выполнять с ресурсами в системах управления базами данных (СУБД) и веб-приложениях.
Основные операции CRUD:
• Create (Создание): Добавление нового ресурса или записи в систему.
• Read (Чтение): Получение данных о ресурсе или записи.
• Update (Обновление): Изменение существующего ресурса или записи.
• Delete (Удаление): Удаление ресурса или записи из системы.
Соответствие CRUD, REST и HTTP
REST (Representational State Transfer) — это архитектурный стиль, который использует HTTP-протокол для взаимодействия с ресурсами. В RESTful API CRUD-операции соответствуют HTTP-методам следующим образом:
• Create: соответствует методу POST. Используется для создания нового ресурса.
• Read: соответствует методу GET. Используется для получения данных о ресурсе.
• Update: соответствует методу PUT (или PATCH). Используется для обновления существующего ресурса.
• Delete: соответствует методу DELETE. Используется для удаления ресурса.
Пример соответствия:
• POST /users — создание нового пользователя (Create).
• GET /users/1 — получение информации о пользователе с ID 1 (Read).
• PUT /users/1 — обновление информации о пользователе с ID 1 (Update).
• DELETE /users/1 — удаление пользователя с ID 1 (Delete).
66. Шаблон Data Access Object (DAO).
Шаблон Data Access Object (DAO)
Шаблон DAO (Data Access Object) — это структурный шаблон проектирования, который используется для абстракции и инкапсуляции доступа к данным. Он разделяет бизнес-логику приложения и логику доступа к данным, что упрощает управление и тестирование кода.
Основные компоненты DAO:
• DAO интерфейс: Определяет методы для выполнения CRUD-операций.
• DAO реализация: Реализует интерфейс и содержит конкретные операции доступа к данным (например, с использованием JDBC, Hibernate и т.д.).
• Модель данных: Представляет сущности, с которыми работает DAO (например, класс User ).
67. Основные понятия Объектно-реляционного отображения (ORM - Object-Relational Mapping).
Объектно-реляционное отображение (ORM, Object-Relational Mapping) — это концепция и технология, позволяющая разработчикам работать с базами данных, используя объектно-ориентированные подходы. ORM служит мостом между объектно-ориентированным программированием и реляционными базами данных, позволяя разработчикам манипулировать данными в виде объектов, а не в виде строк и таблиц.
Основные понятия ORM
• Объект: В контексте ORM объект — это экземпляр класса, который представляет сущность в приложении. Например, класс User может представлять пользователя в системе.
• Сущность: Сущность — это объект, который имеет уникальный идентификатор и может быть сохранен в базе данных. Сущности обычно соответствуют таблицам в реляционной базе данных.
• Свойства (атрибуты): Свойства объекта соответствуют столбцам таблицы в базе данных. Например, класс User может иметь свойства id, name, email, которые соответствуют столбцам в таблице users.
• Сессия: Сессия — это объект, который управляет взаимодействием между приложением и базой данных. Она используется для выполнения операций CRUD (Create, Read, Update, Delete) и управления транзакциями.
• Транзакция: Транзакция — это последовательность операций, которые выполняются как единое целое. Если одна из операций не удается, все изменения могут быть отменены, что обеспечивает целостность данных.
• Запросы: ORM позволяет выполнять запросы к базе данных с использованием объектно-ориентированного синтаксиса, что упрощает работу с данными. Запросы могут быть выполнены с помощью методов, предоставляемых ORM-фреймворком.
• Отображение (Mapping): Отображение — это процесс связывания объектов с таблицами базы данных. ORM-фреймворки используют метаданные (например, аннотации или XML-конфигурации) для определения, как классы и их свойства соответствуют таблицам и столбцам.
68. Спецификация Java Persistence API (JPA).
Спецификация Java Persistence API (JPA)
Java Persistence API (JPA) — это спецификация, которая определяет стандартный способ работы с объектно-реляционным отображением (ORM) в Java-приложениях. JPA позволяет разработчикам управлять персистентными данными, используя объектно-ориентированные подходы.
Основные компоненты JPA
• Сущности (Entities): Классы, представляющие таблицы в базе данных. Аннотируются с помощью @Entity, @Table, @Id и других.
• Контекст персистентности (Persistence Context): Среда, в которой управляются сущности. Отслеживает изменения и синхронизирует их с базой данных.
• EntityManager: Основной интерфейс JPA для управления сущностями. Методы: persist(), find(), merge(), remove().
• Запросы (Queries): JPA поддерживает JPQL (Java Persistence Query Language) для выполнения запросов к сущностям, а также нативные SQL-запросы.
• Транзакции: JPA управляет транзакциями, обеспечивая целостность данных.
• Кэширование: Поддержка кэширования для повышения производительности.
Основные аннотации JPA
• @Entity: Обозначает класс как сущность.
• @Table: Указывает таблицу, соответствующую сущности.
• @Id: Указывает первичный ключ.
• @GeneratedValue: Определяет стратегию генерации ключа.
• @Column: Указывает параметры для столбца.
• @OneToMany, @ManyToOne, и другие: Определяют отношения между сущностями.
69. Архитектура ORM Java Persistence API (JPA).
Архитектура ORM Java Persistence API (JPA)
Java Persistence API (JPA) — это спецификация, которая определяет архитектуру для работы с объектно-реляционным отображением (ORM) в Java-приложениях. JPA позволяет разработчикам управлять персистентными данными, используя объектно-ориентированные подходы, и обеспечивает абстракцию над реляционными базами данных. Рассмотрим основные компоненты и архитектурные элементы JPA.
Основные компоненты архитектуры JPA
• Сущности (Entities): Сущности представляют собой классы, которые соответствуют таблицам в базе данных. Каждый экземпляр сущности соответствует строке в таблице. Сущности аннотируются с помощью аннотаций JPA, таких как @Entity, @Table, @Id, и других.
• EntityManager: EntityManager — это основной интерфейс JPA, который управляет жизненным циклом сущностей. Он предоставляет методы для выполнения операций CRUD (Create, Read, Update, Delete). EntityManager работает в контексте персистентности и отслеживает изменения в сущностях.
• Контекст персистентности (Persistence Context): Контекст персистентности — это среда, в которой управляются сущности. Он отслеживает состояние сущностей и синхронизирует их с базой данных. Контекст может быть управляемым контейнером (например, в Java EE) или программным (например, в Java SE).
• Транзакции: JPA управляет транзакциями, обеспечивая целостность данных. Транзакции могут быть управляемыми контейнером или программно. Используются методы begin(), commit(), и rollback() для управления транзакциями.
• Запросы (Queries): JPA поддерживает JPQL (Java Persistence Query Language) для выполнения запросов к сущностям. JPQL позволяет писать запросы, используя объектно-ориентированный синтаксис. Также поддерживаются нативные SQL-запросы, что позволяет выполнять сложные операции, которые могут быть трудными для реализации с помощью JPQL.
• Кэширование: JPA поддерживает кэширование, что позволяет улучшить производительность приложения, уменьшая количество обращений к базе данных. Кэш может быть как на уровне сущностей, так и на уровне запросов.
• Провайдеры JPA: JPA является спецификацией, и для ее реализации существуют различные провайдеры, такие как Hibernate, EclipseLink, OpenJPA и другие. Каждый провайдер может иметь свои особенности и расширения, но все они соответствуют спецификации JPA.
70. Основные аннотации Java Persistence API (JPA).
Основные аннотации Java Persistence API (JPA)
Java Persistence API (JPA) использует аннотации для определения метаданных, которые описывают, как классы и их свойства соответствуют таблицам и столбцам в реляционной базе данных.
1. Аннотации для определения сущностей
• @Entity: Обозначает класс как сущность, которая будет отображаться в таблице базы данных.
• @Table: Указывает, какая таблица в базе данных соответствует сущности. Можно задать имя таблицы и другие параметры.
2. Аннотации для идентификаторов
• @Id: Указывает, какой атрибут является первичным ключом сущности.
• @GeneratedValue: Определяет стратегию генерации значений для первичного ключа (например, автоинкремент).
3. Аннотации для свойств
• @Column: Указывает дополнительные параметры для столбца, такие как имя, уникальность и длина.
• @Transient: Указывает, что поле не должно быть сохранено в базе данных.
4. Аннотации для отношений
• @OneToOne: Определяет отношение "один к одному" между двумя сущностями. @OneToMany: Определяет отношение "один ко многим".
• @ManyToOne: Определяет отношение "многие к одному".
• @ManyToMany: Определяет отношение "многие ко многим".
5. Аннотации для управления жизненным циклом
• @PrePersist: Метод, вызываемый перед сохранением сущности.
• @PostPersist: Метод, вызываемый после сохранения сущности.
• @PreUpdate: Метод, вызываемый перед обновлением сущности.
• @PostRemove: Метод, вызываемый после удаления сущности.
71. Библиотека Hibernate, основные аннотации.
Библиотека Hibernate и основные аннотации
Hibernate — это один из самых популярных фреймворков для объектно-реляционного отображения (ORM) в Java. Он реализует спецификацию Java Persistence API (JPA) и предоставляет дополнительные возможности для работы с базами данных. Hibernate упрощает взаимодействие между объектами Java и реляционными базами данных, позволяя разработчикам сосредоточиться на бизнес-логике, а не на SQL-запросах.
Основные аннотации Hibernate
Hibernate использует аннотации, которые могут быть как частью JPA, так и специфичными для Hibernate. Вот некоторые из них:
• @Entity: Обозначает класс как сущность, которая будет отображаться в таблице базы данных.
• @Table: Указывает, какая таблица в базе данных соответствует сущности. Можно задать имя таблицы и другие параметры.
• @Id: Указывает, какой атрибут является первичным ключом сущности.
• @GeneratedValue: Определяет стратегию генерации значений для первичного ключа (например, автоинкремент).
• @Column: Указывает дополнительные параметры для столбца, такие как имя, уникальность и длина.
• @OneToOne: Определяет отношение "один к одному" между двумя сущностями.
• @OneToMany: Определяет отношение "один ко многим".
• @ManyToOne: Определяет отношение "многие к одному".
• @ManyToMany: Определяет отношение "многие ко многим".
• @Fetch: Определяет стратегию загрузки для ассоциаций (например, FetchType.LAZY или FetchType.EAGER).
• @Cascade: Указывает, какие операции каскадно применяются к связанным сущностям (например, CascadeType.ALL).
• @Transient: Указывает, что поле не должно быть сохранено в базе данных.
72. Объявление сущности и таблицы в Hibernate.
В Hibernate сущности представляют собой классы, которые отображаются на таблицы в реляционной базе данных. Для объявления сущности и соответствующей таблицы используются аннотации.
Объявление сущности
Аннотация @Entity указывает, что класс является сущностью, а аннотация @Table задает имя таблицы, соответствующей этой сущности.
Объявление сущности и таблицы в Hibernate позволяет разработчикам легко связывать классы Java с таблицами в базе данных, упрощая управление персистентными данными.
73. Интерфейс Session в Hibernate.
Интерфейс Session в Hibernate
Интерфейс Session в Hibernate является основным инструментом для взаимодействия с базой данных. Он управляет жизненным циклом сущностей, транзакциями и запросами.
Основные функции интерфейса Session
• Управление сущностями: Сохранение, обновление, удаление и извлечение сущностей.
• Управление транзакциями: Начало, завершение и откат транзакций.
• Кэширование: Использует кэш первого уровня для хранения сущностей в памяти.
• Запросы: Выполнение запросов с использованием HQL и Criteria API.
Основные методы интерфейса Session
• save(Object entity): Сохраняет сущность в базе данных.
• update(Object entity): Обновляет существующую сущность.
• delete(Object entity): Удаляет сущность из базы данных.
• Get(Class<T> clazz, Serializable id): Извлекает сущность по идентификатору.
• beginTransaction(): Начинает новую транзакцию.
• createQuery(String hql): Создает HQL-запрос.
• close(): Закрывает сессию и освобождает ресурсы.
74. Ассоциация сущностей в Hibernate.
Ассоциация сущностей в Hibernate
Ассоциации сущностей в Hibernate описывают, как различные сущности связаны друг с другом в реляционной базе данных. Основные типы ассоциаций включают "один к одному", "один ко многим", "многие к одному" и "многие ко многим".
• Один к одному (One-to-One) Одна сущность связана с одной другой сущностью. Например, у пользователя может быть один профиль.
• Один ко многим (One-to-Many) Одна сущность может быть связана с несколькими другими сущностями. Например, один пользователь может иметь несколько заказов.
• Многие к одному (Many-to-One) Несколько сущностей могут ссылаться на одну и ту же сущность. Например, несколько заказов могут принадлежать одному пользователю.
• Многие ко многим (Many-to-Many) Одна сущность может быть связана с несколькими другими сущностями, и наоборот. Например, пользователи могут иметь несколько ролей.
Ассоциации сущностей в Hibernate позволяют моделировать взаимосвязи между объектами, что упрощает управление данными и поддерживает целостность базы данных.
75. Spring Boot: определение, характеристики, преимущества.
Определение
Spring Boot — это фреймворк на основе Spring, который упрощает разработку и развертывание Java-приложений, позволяя быстро создавать автономные и производительные приложения.
Характеристики
• Автоконфигурация: Автоматическая настройка приложения на основе зависимостей.
• Стартовые зависимости: Наборы зависимостей для различных задач (например, spring-boot-starter-web).
• Встроенные серверы: Поддержка встроенных серверов (Tomcat, Jetty), что упрощает запуск приложений.
• Простота развертывания: Легкое упаковывание в исполняемые JAR-файлы.

0