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
Аннотация @MappedSuperclass

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

Аннотация @MappedSuperclass не принимает параметров. Её основная цель — указать, что класс является маппированным суперклассом, и его поля и методы должны быть унаследованы дочерними сущностями.

Пример использования:
@MappedSuperclass
public abstract class BaseEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(name = "created_at")
private LocalDateTime createdAt;

// Геттеры и сеттеры
}

@Entity
public class User extends BaseEntity {
private String name;
private String email;
}


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

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


Механизмы Spring и настройки Spring Boot

JPA и Hibernate: Spring Data JPA использует провайдеров JPA (например, Hibernate) для работы с базой данных. Аннотация
@MappedSuperclass обрабатывается на уровне JPA, но Spring обеспечивает интеграцию через EntityManager и репозитории.
Наследование сущностей: Spring Data JPA поддерживает наследование сущностей, включая использование
@MappedSuperclass. Это позволяет избежать дублирования кода и упрощает управление общими полями.

Настройки Spring Boot
Spring Boot упрощает настройку JPA через свойства конфигурации. Вот несколько ключевых настроек, которые могут влиять на работу @MappedSuperclass:

Генерация схемы базы данных:
Если используется автоматическая генерация схемы (например, через Hibernate), Spring Boot настраивает это через свойство:
spring.jpa.hibernate.ddl-auto=update


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

Интеграция с репозиториями:
Spring Data JPA предоставляет репозитории для работы с сущностями. Дочерние сущности, наследующие от @MappedSuperclass, могут быть использованы в репозиториях как обычные сущности.

Пример репозитория:
public interface UserRepository extends JpaRepository<User, Long> {
}


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

Использование
@MappedSuperclass для общих полей:
Подходит для случаев, когда несколько сущностей имеют общие поля (например, id, createdAt, updatedAt).
Упрощает поддержку кода и уменьшает дублирование.


Использование @Embeddable и @Embedded:
Если требуется повторное использование группы полей в нескольких сущностях, можно использовать аннотации @Embeddable и @Embedded. Это альтернатива @MappedSuperclass.

Использование наследования стратегий JPA:

В JPA также доступны другие стратегии наследования, такие как SINGLE_TABLE, JOINED и TABLE_PER_CLASS. Они могут быть использованы вместо @MappedSuperclass, если требуется более сложная модель наследования.

Пример использования стратегии SINGLE_TABLE:
@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public abstract class BaseEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
}

@Entity
public class User extends BaseEntity {
private String name;
}


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

public class Task120325 {
public static void main(String[] args) {
int i = 0;
while (i++ < 5) {
if (i == 3) return;
System.out.print(i + " ");
}
}
}


#Tasks
Варианты ответа:
Anonymous Quiz
14%
1 2 4 5
5%
1 2 3 4 5
2%
2 3 4 5
80%
1 2
И вся она посвящена твоему коду 😱😅

https://t.me/Java_for_beginner_dev

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

Какой метод преобразует строку в целое число?
Anonymous Quiz
6%
parseString()
15%
Integer.valueOf()
13%
String.toInt()
67%
Integer.parseInt()
Аннотация @OneToOne

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

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

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

Пример:
@OneToOne(targetEntity = Address.class)
private Address address;


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

Пример:
@OneToOne(cascade = CascadeType.ALL)
private Address address;


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

Пример:

@OneToOne(fetch = FetchType.LAZY)
private Address address;


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

Пример:
@OneToOne(optional = false)
private Address address;


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

Пример:
@OneToOne(mappedBy = "user")
private Profile profile;


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

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

Пример:
@OneToOne(orphanRemoval = true)
private Address address;


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


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

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


Ленивая загрузка (Lazy Loading):

Spring Boot поддерживает ленивую загрузку через прокси-объекты Hibernate. Для этого необходимо включить поддержку прокси в настройках:


spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true


Интеграция с репозиториями:
Spring Data JPA предоставляет репозитории для работы с сущностями. Отношения @OneToOne могут быть использованы в репозиториях как обычные поля.

Пример репозитория:
public interface UserRepository extends JpaRepository<User, Long> {
}


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

Одностороннее отношение:
Отношение управляется одной из сущностей. Пример:
@Entity
public class User {
@OneToOne
private Address address;
}


Двустороннее отношение:
Отношение управляется обеими сущностями. Пример:
@Entity
public class User {
@OneToOne(mappedBy = "user")
private Profile profile;
}

@Entity
public class Profile {
@OneToOne
@JoinColumn(name = "user_id")
private User user;
}


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


Ленивая загрузка:
Используется для оптимизации производительности. Пример:
@OneToOne(fetch = FetchType.LAZY)
private Address address;


#Java #Training #Hard #Spring #SpringDataJPA #OneToOne
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