Java for Beginner
673 subscribers
541 photos
155 videos
12 files
827 links
Канал от новичков для новичков!
Изучайте Java вместе с нами!
Здесь мы обмениваемся опытом и постоянно изучаем что-то новое!

Наш YouTube канал - https://www.youtube.com/@Java_Beginner-Dev

Наш канал на RUTube - https://rutube.ru/channel/37896292/
Download Telegram
Please open Telegram to view this post
VIEW IN TELEGRAM
Please open Telegram to view this post
VIEW IN TELEGRAM
Аннотации @OneToMany и @ManyToOne

Аннотации @OneToMany и @ManyToOne используются в Java Persistence API (JPA) для обозначения отношений "один ко многим" и "многие к одному" между сущностями. Они находятся в пакете javax.persistence (или jakarta.persistence в Jakarta EE).

@OneToMany: Указывает, что одна сущность связана с коллекцией других сущностей.
@ManyToOne: Указывает, что множество сущностей связано с одной сущностью.

Эти аннотации часто используются вместе для описания двусторонних отношений.

Параметры и настройки

@OneToMany

targetEntity:

Указывает класс целевой сущности (если он не может быть выведен из типа поля).

Пример:
@OneToMany(targetEntity = Order.class)
private List<Order> orders;


cascade: (#CASCADE)
Определяет каскадные операции, которые должны быть применены к связанным сущностям.
Возможные значения: CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REMOVE, CascadeType.REFRESH, CascadeType.DETACH, CascadeType.ALL.

CascadeType.PERSIST:
Каскадное сохранение. Если сущность сохраняется (например, через EntityManager.persist()), то связанные сущности также будут сохранены.

CascadeType.MERGE:

Каскадное обновление. Если сущность обновляется (например, через EntityManager.merge()), то связанные сущности также будут обновлены.

CascadeType.REMOVE:
Каскадное удаление. Если сущность удаляется (например, через EntityManager.remove()), то связанные сущности также будут удалены.

CascadeType.REFRESH:
Каскадное обновление состояния. Если сущность обновляется из базы данных (например, через EntityManager.refresh()), то связанные сущности также будут обновлены.

CascadeType.DETACH:

Каскадное отсоединение. Если сущность отсоединяется от контекста persistence (например, через EntityManager.detach()), то связанные сущности также будут отсоединены.

CascadeType.ALL:
Каскадное применение всех операций. Включает в себя PERSIST, MERGE, REMOVE, REFRESH, и DETACH. Все операции, применяемые к сущности, будут каскадно применены к связанным сущностям.

Пример:
@OneToMany(cascade = CascadeType.ALL)
private List<Order> orders;


fetch:
Определяет стратегию загрузки связанных сущностей.

Возможные значения: FetchType.EAGER (загрузка сразу) или FetchType.LAZY (ленивая загрузка).
По умолчанию: FetchType.LAZY.

Пример:
@OneToMany(fetch = FetchType.EAGER)
private List<Order> orders;


mappedBy:
Указывает поле в целевой сущности, которое управляет отношением (используется на стороне, которая не владеет отношением).

Пример:
@OneToMany(mappedBy = "customer")
private List<Order> orders;


orphanRemoval:
Указывает, должны ли связанные сущности быть удалены при удалении их из коллекции или установке в null.
По умолчанию: false.

Пример:
@OneToMany(orphanRemoval = true)
private List<Order> orders;



@ManyToOne

Также как и для @OneToMany
targetEntity
cascade
fetch


Но отличается наличием:
optional:
Указывает, может ли связанная сущность быть null.
По умолчанию: true.

Пример:
@ManyToOne(optional = false)
private Customer customer;


Значения по умолчанию

Для @OneToMany:
fetch = FetchType.LAZY
orphanRemoval = false


Для @ManyToOne:
fetch = FetchType.EAGER
optional = true


Жизненный цикл

Применение: Аннотации применяются на этапе маппинга сущностей JPA. Они указывают на отношения между сущностями.
Инициализация: При загрузке сущности из базы данных JPA загружает связанные сущности в зависимости от стратегии загрузки (EAGER или LAZY).
Уничтожение: При удалении сущности JPA учитывает каскадные операции и параметр orphanRemoval.


Варианты настройки

Одностороннее отношение:
Отношение управляется одной из сущностей. Пример:
@Entity
public class Customer {
@OneToMany
private List<Order> orders;
}


Двустороннее отношение:
Отношение управляется обеими сущностями. Пример:
@Entity
public class Customer {
@OneToMany(mappedBy = "customer")
private List<Order> orders;
}

@Entity
public class Order {
@ManyToOne
@JoinColumn(name = "customer_id")
private Customer customer;
}


#Java #Training #Hard #Spring #SpringDataJPA #OneToMany #ManyToOne
Что выведет код?

class A1303 {
void print() {
System.out.println("A");
}
}

class B1303 extends A1303 {
void print() {
System.out.println("B");
}
}

class C1303 extends B1303 {
void print() {
super.print();
System.out.println("C");
}
}

public class Task130325 {
public static void main(String[] args) {
A1303 a = new C1303();
a.print();
}
}


#Tasks
Варианты ответа:
Anonymous Quiz
11%
A
0%
B
18%
C
71%
BC
Please open Telegram to view this post
VIEW IN TELEGRAM
Вопросы с собеседования 👩‍💻

Что произойдёт, если попытаться обратиться к элементу массива за его пределами?
Anonymous Quiz
7%
Вернётся null
87%
Выбросится ArrayIndexOutOfBoundsException
3%
Программа завершится без ошибок
3%
Вернётся случайное значение
Аннотация @ManyToMany

Аннотация @ManyToMany используется в Java Persistence API (JPA) для обозначения отношения "многие ко многим" между двумя сущностями. Она указывает, что множество сущностей одной стороны связано с множеством сущностей другой стороны. Аннотация находится в пакете javax.persistence (или jakarta.persistence в Jakarta EE).

Аннотация @ManyToMany принимает несколько параметров для настройки отношения:

targetEntity:
Указывает класс целевой сущности (если он не может быть выведен из типа поля).

Пример:
@ManyToMany(targetEntity = Role.class)
private List<Role> roles;


cascade: (#CASCADE)
Определяет каскадные операции, которые должны быть применены к связанным сущностям.
Возможные значения: CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REMOVE, CascadeType.REFRESH, CascadeType.DETACH, CascadeType.ALL.

Пример:
@ManyToMany(cascade = CascadeType.ALL)
private List<Role> roles;


fetch:
Определяет стратегию загрузки связанных сущностей.
Возможные значения: FetchType.EAGER (загрузка сразу) или FetchType.LAZY (ленивая загрузка).

По умолчанию: FetchType.LAZY.

Пример:
@ManyToMany(fetch = FetchType.EAGER)
private List<Role> roles;


mappedBy:
Указывает поле в целевой сущности, которое управляет отношением (используется на стороне, которая не владеет отношением).

Пример:
@ManyToMany(mappedBy = "users")
private List<Role> roles;


orphanRemoval:
Указывает, должны ли связанные сущности быть удалены при удалении их из коллекции или установке в null.
По умолчанию: false.

Пример:
@ManyToMany(orphanRemoval = true)
private List<Role> roles;


Значения по умолчанию

Если параметры не указаны, используются значения по умолчанию:
fetch = FetchType.LAZY
orphanRemoval = false


Жизненный цикл

Применение: Аннотация
@ManyToMany применяется на этапе маппинга сущностей JPA. Она указывает, что между двумя сущностями существует отношение "многие ко многим".
Инициализация: При загрузке сущности из базы данных JPA загружает связанные сущности в зависимости от стратегии загрузки (EAGER или LAZY).
Уничтожение: При удалении сущности JPA учитывает каскадные операции и параметр orphanRemoval.


Варианты настройки

Одностороннее отношение:
Отношение управляется одной из сущностей. Пример:
@Entity
public class User {
@ManyToMany
private List<Role> roles;
}


Двустороннее отношение:
Отношение управляется обеими сущностями. Пример:
@Entity
public class User {
@ManyToMany(mappedBy = "users")
private List<Role> roles;
}

@Entity
public class Role {
@ManyToMany
@JoinTable(
name = "user_role",
joinColumns = @JoinColumn(name = "role_id"),
inverseJoinColumns = @JoinColumn(name = "user_id")
)
private List<User> users;
}


Каскадные операции:
Используются для автоматического применения операций к связанным сущностям. Пример:
@ManyToMany(cascade = CascadeType.ALL)
private List<Role> roles;


Ленивая загрузка:
Используется для оптимизации производительности. Пример:
@ManyToMany(fetch = FetchType.LAZY)
private List<Role> roles;


Кастомизация промежуточной таблицы:
С помощью аннотации @JoinTable можно настроить промежуточную таблицу для отношения "многие ко многим". Пример:
@ManyToMany
@JoinTable(
name = "user_role",
joinColumns = @JoinColumn(name = "user_id"),
inverseJoinColumns = @JoinColumn(name = "role_id")
)
private List<Role> roles;


#Java #Training #Hard #Spring #SpringDataJPA #ManyToMany
Please open Telegram to view this post
VIEW IN TELEGRAM
Please open Telegram to view this post
VIEW IN TELEGRAM
Аннотация @JoinColumn

Аннотация @JoinColumn используется в Java Persistence API (JPA) для указания столбца в базе данных, который является внешним ключом (foreign key) и связывает текущую сущность с другой сущностью. Она находится в пакете javax.persistence (или jakarta.persistence в Jakarta EE). Эта аннотация применяется к полям или свойствам сущности, которые представляют собой связи между таблицами, такие как @OneToOne, @OneToMany, @ManyToOne и @ManyToMany.

Аннотация @JoinColumn принимает несколько параметров, которые позволяют настроить маппинг внешнего ключа:

name (тип: String):
Указывает имя столбца в базе данных, который будет использоваться как внешний ключ.
По умолчанию: если параметр не указан, JPA использует имя поля или свойства сущности, дополненное суффиксом _id (например, user_id).


referencedColumnName (тип: String):
Указывает имя столбца в целевой таблице (таблице, на которую ссылается внешний ключ).
По умолчанию: если параметр не указан, JPA использует первичный ключ целевой таблицы.


unique (тип: boolean):
Указывает, должен ли внешний ключ быть уникальным.
По умолчанию: false.

nullable (тип: boolean):
Указывает, может ли внешний ключ иметь значение NULL.
По умолчанию: true.


insertable (тип: boolean):
Указывает, должен ли столбец включаться в SQL-запросы INSERT.
По умолчанию: true.


updatable (тип: boolean):
Указывает, должен ли столбец включаться в SQL-запросы UPDATE.
По умолчанию: true.


columnDefinition (тип: String):
Позволяет указать SQL-определение столбца, которое будет использоваться при генерации схемы базы данных.
По умолчанию: не задано.


table (тип: String):
Указывает таблицу, в которой находится столбец (если сущность маппится на несколько таблиц).
По умолчанию: основная таблица сущности.


foreignKey (тип: ForeignKey):
Позволяет указать определение внешнего ключа для генерации схемы базы данных.
По умолчанию: не задано.


Пример использования:
@ManyToOne
@JoinColumn(name = "user_id", referencedColumnName = "id", nullable = false)
private User user;


Значения по умолчанию

Если аннотация @JoinColumn не указана, JPA использует имя поля или свойства сущности, дополненное суффиксом _id, в качестве имени столбца внешнего ключа.

Жизненный цикл

Применение: Аннотация @JoinColumn применяется на этапе маппинга сущности JPA. Она используется при создании таблиц в базе данных (если используется автоматическая генерация схемы) и при выполнении операций чтения/записи данных.
Инициализация: При загрузке сущности из базы данных JPA использует указанные параметры для маппинга внешнего ключа.
Уничтожение: При сохранении сущности в базу данных JPA использует указанные параметры для генерации SQL-запросов.


Варианты настройки

Использование name и referencedColumnName:
Позволяет явно указать имена столбцов в базе данных, что полезно при работе с существующими схемами.

Использование nullable:
Позволяет контролировать, может ли внешний ключ быть NULL. Например, для обязательных связей можно установить nullable = false.

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

Кастомизация через columnDefinition:
Позволяет указать точное SQL-определение столбца, что полезно для сложных сценариев.

#Java #Training #Hard #Spring #SpringDataJPA #JoinColumn
Что выведет код?

import java.util.TreeMap;

public class Task140325 {
public static void main(String[] args) {
TreeMap<Integer, String> map = new TreeMap<>();
map.put(5, "Five");
map.put(2, "Two");
map.put(8, "Eight");
map.put(1, "One");
System.out.println(map.higherKey(2) + map.lowerKey(5));
}
}


#Tasks
Варианты ответа:
Anonymous Quiz
15%
13
44%
7
0%
6
41%
"EightOne"
Почему-то мне кажется у него получится убедить его... 🧐 😜

https://t.me/Java_for_beginner_dev

#Mems
Please open Telegram to view this post
VIEW IN TELEGRAM
Вопросы с собеседования 👩‍💻

Какой модификатор делает класс недоступным для наследования?
Anonymous Quiz
3%
static
9%
abstract
63%
final
25%
private
Аннотация @JoinTable

Аннотация @JoinTable используется в Java Persistence API (JPA) для указания таблицы связей (join table) между двумя сущностями в случае отношений @ManyToMany или для кастомизации связей @OneToMany и @ManyToOne. Она находится в пакете javax.persistence (или jakarta.persistence в Jakarta EE). Эта аннотация применяется к полям или свойствам сущности, которые представляют собой связи между таблицами, и позволяет настроить таблицу, которая хранит ассоциации между записями двух таблиц.

Аннотация @JoinTable принимает несколько параметров, которые позволяют настроить таблицу связей:

name (тип: String):
Указывает имя таблицы связей в базе данных.
По умолчанию: если параметр не указан, JPA генерирует имя таблицы на основе имен связанных сущностей (например, Entity1_Entity2).

catalog (тип: String):
Указывает каталог базы данных, в котором находится таблица связей.
По умолчанию: каталог по умолчанию для базы данных.


schema (тип: String):
Указывает схему базы данных, в которой находится таблица связей.
По умолчанию: схема по умолчанию для базы данных.


joinColumns (тип: JoinColumn[]):
Указывает столбцы, которые ссылаются на текущую сущность (владельца связи).
Каждый элемент массива является аннотацией
@JoinColumn, которая настраивает соответствующий столбец.
По умолчанию: JPA создает один столбец, ссылающийся на первичный ключ текущей сущности.


inverseJoinColumns (тип: JoinColumn[]):
Указывает столбцы, которые ссылаются на связанную сущность.
Каждый элемент массива является аннотацией
@JoinColumn, которая настраивает соответствующий столбец.
По умолчанию: JPA создает один столбец, ссылающийся на первичный ключ связанной сущности.


uniqueConstraints (тип: UniqueConstraint[]):
Позволяет задать уникальные ограничения для таблицы связей.
Каждый элемент массива является аннотацией
@UniqueConstraint, которая настраивает уникальное ограничение.
По умолчанию: уникальные ограничения не заданы.


indexes (тип: Index[]):
Позволяет задать индексы для таблицы связей.
Каждый элемент массива является аннотацией
@Index, которая настраивает индекс.
По умолчанию: индексы не заданы.


foreignKey (тип: ForeignKey):
Позволяет указать определение внешнего ключа для столбцов, ссылающихся на текущую сущность.
По умолчанию: не задано.


inverseForeignKey (тип: ForeignKey):
Позволяет указать определение внешнего ключа для столбцов, ссылающихся на связанную сущность.
По умолчанию: не задано.


Пример использования:
@ManyToMany
@JoinTable(
name = "user_role",
joinColumns = @JoinColumn(name = "user_id"),
inverseJoinColumns = @JoinColumn(name = "role_id")
)
private Set<Role> roles;


Значения по умолчанию

Если аннотация
@JoinTable не указана, JPA генерирует таблицу связей с именем, основанным на именах связанных сущностей, и создает два столбца: один для ссылки на текущую сущность, другой — на связанную сущность.

Жизненный цикл

Применение: Аннотация @JoinTable применяется на этапе маппинга сущности JPA. Она используется при создании таблиц в базе данных (если используется автоматическая генерация схемы) и при выполнении операций чтения/записи данных.
Инициализация: При загрузке сущности из базы данных JPA использует указанные параметры для маппинга таблицы связей.
Уничтожение: При сохранении сущности в базу данных JPA использует указанные параметры для генерации SQL-запросов.


Варианты настройки

Использование name:
Позволяет явно указать имя таблицы связей, что полезно при работе с существующими схемами.
Использование joinColumns и inverseJoinColumns:
Позволяет настроить столбцы, ссылающиеся на текущую и связанную сущности.
Использование uniqueConstraints:
Позволяет задать уникальные ограничения для таблицы связей, что полезно для предотвращения дублирования записей.


Использование indexes:
Позволяет улучшить производительность запросов к таблице связей.
Использование foreignKey и inverseForeignKey:
Позволяет задать определения внешних ключей для таблицы связей.


#Java #Training #Hard #Spring #SpringDataJPA #JoinTable
Всем доброе утро! 🔆

Как пережили неделю?

За окном уже пахнет весной, поэтому всем рекомендую, если погода позволяет, пойти и подышать воздухом 💪

А насчет завтрашней встречи, пока есть сомнения. Я ничего не готовил, а не готовому идти Вам не хочется 😉

Если все-таки желаете, можно порешать задачки... Ну пишите в комментах 😜

А в остальном всем хорошего дня
🖐
Please open Telegram to view this post
VIEW IN TELEGRAM
Всем привет! 🖐

Решили все-таки сегодня собраться! В 16:00 как всегда в Яндекс.Телемост

@Shikin_Anatoliy попробует написать простой CRUD сервис, а мы ему в случае чего, поможем!

Полезный лайф-кодинг для новичков, приходите будем учиться вместе 💪

На фото админ, пишет пет-проект

Ждем всех!
✌️
Please open Telegram to view this post
VIEW IN TELEGRAM
https://telemost.yandex.ru/j/11766846568901 - встреча создана!

Залетаем!