Ссылочные типы данных в Java

Ссылочные типы данных (reference types) являются неотъемлемой частью объектно-ориентированной модели Java. В отличие от примитивов, они представляют объекты и хранят ссылки (адреса) на область памяти, где находится фактическое содержимое.

1. Концепция и философия

Java — строго объектно-ориентированный язык, и ссылки — основа его динамической природы.

Зачем нужны ссылочные типы:
Инкапсуляция данных и поведения. Объекты объединяют данные и методы, действующие над ними.
Гибкость. Ссылочные типы позволяют моделировать сложные структуры (например, графы, деревья, коллекции).
Полиморфизм и наследование. Через ссылки возможна работа с объектами по интерфейсам и абстрактным типам.

List<String> names = new ArrayList<>(); // ссылка на объект ArrayList

2. Представление и поведение ссылок

Ссылочная переменная не содержит сам объект, а только указатель на него.

String a = "Hello";
String b = a;
Обе переменные a и b ссылаются на один и тот же объект "Hello" в куче (heap). Изменение объекта (если он мутабелен) через одну ссылку отразится на другой.

Пример с мутабельным объектом:

List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = list1;
list1.add(10);
System.out.println(list2); // [10]

3. Классы, интерфейсы и массивы

К ссылочным типам относятся:
Классы (например, String, Object, Scanner, ArrayList)
Интерфейсы (например, List, Runnable, Serializable)
Массивы (int[], String[], Object[][]) — в Java массивы — это объекты!
Специальный тип null — означает отсутствие объекта

4. Работа JVM с ссылками

При работе со ссылочными типами:
Объекты размещаются в куче (heap).
Ссылки могут храниться в стеке вызовов, в полях объектов, в массиве и т.д.
JVM использует сборку мусора (GC) для очистки неиспользуемых объектов.

class User {
    String name;
}

User user1 = new User();
User user2 = user1;
user1 = null; // объект всё ещё доступен через user2

5. Особенности ссылочных типов

a) Сравнение ссылок

String a = new String("Java");
String b = new String("Java");
System.out.println(a == b);      // false — разные объекты
System.out.println(a.equals(b)); // true — сравнение содержимого
== сравнивает ссылки, а equals() — содержимое (если метод переопределён корректно).

b) NullPointerException

String s = null;
System.out.println(s.length()); // исключение
Поэтому рекомендуется использовать Objects.requireNonNull, Optional, или делать явные проверки на null.

6. Автоматическая работа с памятью

Одно из главных преимуществ Java — автоматическое управление памятью. Не нужно вручную освобождать объекты, как в C/C++.

Но важно помнить:
Объекты "висят" в памяти, пока есть активные ссылки.
Циклические ссылки не мешают сборке мусора (в отличие от простых reference counting-систем).

7. Массивы как ссылочные типы

Массивы в Java — полноценные объекты.

int[] nums = {1, 2, 3};
System.out.println(nums.length); // 3
Массивы имеют поля и методы (length — поле, а не метод), и их тип — int[], String[] и т.д.

8. Использование в обобщениях

Ссылочные типы активно применяются в дженериках (обобщениях).

List<Integer> list = new ArrayList<>();

Нельзя использовать примитивы в параметрах типа:

List<int> wrongList; // ошибка
Поэтому применяются классы-обёртки: Integer, Double, Boolean и т.д.

9. Влияние на производительность

Работа со ссылками может быть дороже, чем с примитивами:
Дополнительные обращения к памяти
Участие в GC
Наличие виртуального вызова методов (vtable)
Частые создания объектов (например, при упаковке/распаковке)

Оптимизации:
Избегать ненужных аллокаций
Использовать StringBuilder вместо + в циклах
Применять ObjectPool, если объекты часто переиспользуются

#Java #для_новичков #beginner #reference_types

Интеграция Liquibase с другими инструментами

Maven / Gradle

Maven

Добавьте зависимость в pom.xml:

<dependency>
    <groupId>org.liquibase</groupId>
    <artifactId>liquibase-core</artifactId>
    <version>4.25.0</version>
</dependency>

Конфигурация через pom.xml:

<plugin>
    <groupId>org.liquibase</groupId>
    <artifactId>liquibase-maven-plugin</artifactId>
    <version>4.25.0</version>
    <configuration>
        <changeLogFile>src/main/resources/db/changelog/db.changelog-master.yaml</changeLogFile>
        <url>jdbc:postgresql://localhost:5432/mydb</url>
        <username>user</username>
        <password>pass</password>
    </configuration>
</plugin>

Запуск миграций:

mvn liquibase:update

Gradle

Добавьте в build.gradle:

plugins {
    id 'org.liquibase.gradle' version '2.2.0'
}

dependencies {
    liquibaseRuntime 'org.liquibase:liquibase-core:4.25.0'
    liquibaseRuntime 'org.postgresql:postgresql:42.6.0'
}

liquibase {
    changeLogFile 'src/main/resources/db/changelog/db.changelog-master.yaml'
    url 'jdbc:postgresql://localhost:5432/mydb'
    username 'user'
    password 'pass'
}

Запуск:

gradle liquibaseUpdate

Spring Boot (автоконфигурация)

Spring Boot автоматически настраивает Liquibase, если он обнаружен в classpath.

Настройки в application.yml:

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: user
    password: pass
  liquibase:
    change-log: classpath:db/changelog/db.changelog-master.yaml
    enabled: true
    contexts: dev  # Фильтрация по контексту

Поведение:
Миграции запускаются при старте приложения.
Можно отключить через spring.liquibase.enabled=false.

Расширенные функции Liquibase

Динамические свойства (property)

Позволяют выносить повторяющиеся значения в переменные.

Пример (YAML):

databaseChangeLog:
  - property:
      name: default.schema
      value: public
  - changeSet:
      id: 1
      author: dev
      changes:
        - createTable:
            tableName: ${default.schema}.users
            columns:
              - column:
                  name: id
                  type: INT

В liquibase.properties:

default.schema=public

Через командную строку:

liquibase update -Ddefault.schema=public

Контексты (contexts) и фильтрация changeSet’ов

Контексты позволяют выбирать, какие changeSet’ы применять в определённых окружениях.

Пример (YAML):

- changeSet:
    id: 2
    author: dev
    context: "dev,test"  # Будет выполнен только в dev и test
    changes:
      - insert:
          tableName: users
          columns:
            - column:
                name: username
                value: "test_user"

- changeSet:
    id: 3
    author: dev
    context: "prod"  # Только в production
    changes:
      - createIndex:
          tableName: users
          indexName: idx_user_email
          columns:
            - column:
                name: email

Как передать контекст?

Через командную строку:

liquibase update --contexts="dev"

В Spring Boot:

spring:
  liquibase:
    contexts: dev

#Java #middle #Liquibase

Best Practices

Организация changelog-файлов

Рекомендуемая структура:

src/main/resources/db/changelog/
├── db.changelog-master.yaml  # Главный файл
├── changes/
│   ├── 001-create-tables.yaml
│   ├── 002-add-indexes.yaml
│   └── 003-insert-data.yaml
└── rollback/
    ├── 001-rollback.yaml    # Ручные откаты

Главный файл (db.changelog-master.yaml):

databaseChangeLog:
  - includeAll:
      path: db/changelog/changes/
      relativeToChangelogFile: true

Почему так?

Удобно управлять версиями.
Легко находить изменения.

Тестирование миграций

Стратегии:
Локальная проверка:

liquibase validate  # Проверка синтаксиса
liquibase update    # Применение в test-DB

Интеграционные тесты (JUnit + Testcontainers):

@Testcontainers
@SpringBootTest
class LiquibaseMigrationTest {
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15");

    @Test
    void testMigrations() {
        // Spring Boot автоматически применит миграции
        assertTrue(true);  # Если не упало — значит, успешно
    }
}

Работа в команде (избежание конфликтов)

Правила:
Именование changeSet’ов:
Используйте id: <дата>-<номер> (например, id: 20240315-1).
Указывайте автора (author: github_username).

Порядок изменений:
Не зависеть от порядка выполнения (например, не предполагать, что таблица A уже существует при создании B).

Использование preConditions:

- changeSet:
    id: 20240315-1
    author: dev
    preConditions:
      - tableExists:
          tableName: users
    changes:
      - addColumn:
          tableName: users
          column:
            name: phone
            type: VARCHAR(20)

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

#Java #middle #Liquibase

Настройка OAuth2 для Gmail

Для Gmail предпочтительно использовать OAuth2.

Пример конфигурации:

@Configuration
public class MailConfig {

    @Bean
    public JavaMailSender javaMailSender() {
        JavaMailSenderImpl mailSender = new JavaMailSenderImpl();
        mailSender.setHost("smtp.gmail.com");
        mailSender.setPort(587);
        mailSender.setUsername("your.email@gmail.com");

        Properties props = mailSender.getJavaMailProperties();
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.starttls.enable", "true");
        props.put("mail.smtp.auth.mechanisms", "XOAUTH2");

        // Настройка OAuth2 токена через Google API Client Library
        // Подробности: https://developers.google.com/identity/protocols/oauth2
        return mailSender;
    }
}

Примечание: Зарегистрируйте приложение в Google Cloud Console и используйте библиотеку google-auth-library-oauth2-http для получения accessToken.

Создание сервиса отправки почты

Создадим сервис EmailService для отправки писем.

@Service
public class EmailService {

    @Autowired
    private JavaMailSender mailSender;

    @Autowired
    private TemplateEngine templateEngine;

    private static final Logger logger = LoggerFactory.getLogger(EmailService.class);

    public void sendSimpleEmail(String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
        mailSender.send(message);
    }

    public void sendHtmlEmail(String to, String subject, String htmlBody) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
        helper.setTo(to);
        helper.setSubject(MimeUtility.encodeText(subject, "UTF-8", null));
        helper.setText(htmlBody, true);
        mailSender.send(message);
    }

    public void sendEmailWithAttachment(String to, String subject, String text, File attachment) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
        helper.setTo(to);
        helper.setSubject(MimeUtility.encodeText(subject, "UTF-8", null));
        helper.setText(text);
        FileSystemResource file = new FileSystemResource(attachment);
        helper.addAttachment(attachment.getName(), file);
        mailSender.send(message);
    }

    @Async
    public CompletableFuture<Void> sendSimpleEmailAsync(String to, String subject, String text IMPORTANT: text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(to);
        message.setSubject(MimeUtility.encodeText(subject, "UTF-8", null));
        message.setText(text);
        mailSender.send(message);
        return CompletableFuture.completedFuture(null);
    }

    public void sendTemplatedEmail(String to, String subject, String username) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
        Context context = new Context();
        context.setVariable("username", username);
        String htmlBody = templateEngine.process("email-template", context);
        helper.setTo(to);
        helper.setSubject(MimeUtility.encodeText(subject, "UTF-8", null));
        helper.setText(htmlBody, true);
        mailSender.send(message);
    }
}

Конфигурация асинхронности:

@Configuration
@EnableAsync
public class AsyncConfig {
    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.initialize();
        return executor;
    }
}

#Java #middle #on_request #JavaMailSender

Примеры кода

Простой текст:

SimpleMailMessage message = new SimpleMailMessage();
message.setTo("user@example.com");
message.setSubject("Тестовое письмо");
message.setText("Привет из Spring Boot!");
mailSender.send(message);

HTML-письмо:

MimeMessage message = mailSender.createMimeMessage();
MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
helper.setTo("user@example.com");
helper.setSubject(MimeUtility.encodeText("HTML письмо", "UTF-8", null));
helper.setText("<h1>Привет!</h1><p>Это HTML письмо.</p>", true);
mailSender.send(message);

Вложение:

File file = new File("/path/to/file.pdf");
FileSystemResource resource = new FileSystemResource(file);
MimeMessage message = mailSender.createMimeMessage();
MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
helper.setTo("user@example.com");
helper.setSubject(MimeUtility.encodeText("Письмо с вложением", "UTF-8", null));
helper.setText("Смотри вложение!");
helper.addAttachment("file.pdf", resource);
mailSender.send(message);

Обработка ошибок и логирование

JavaMailSender может выбрасывать исключения, которые нужно обрабатывать.

Основные исключения:

MailAuthenticationException
MailSendException
MessagingException

Пример отлова:

try {
    mailSender.send(message);
} catch (MailException e) {
    logger.error("Ошибка отправки письма", e);
    throw e;
}

Повторные попытки
Используйте @Retryable из Spring Retry:

@Retryable(value = MailException.class, maxAttempts = 3)
public void sendSimpleEmail(String to, String subject, String text) {
    SimpleMailMessage message = new SimpleMailMessage();
    message.setTo(to);
    message.setSubject(subject);
    message.setText(text);
    mailSender.send(message);
}

Зависимость:

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
</dependency>

Мониторинг и метрики

Для продакшен-приложений полезно отслеживать метрики отправки писем с помощью Spring Actuator:

@Service
public class EmailService {

    @Autowired
    private JavaMailSender mailSender;

    @Autowired
    private MeterRegistry meterRegistry;

    public void sendSimpleEmail(String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
        try {
            mailSender.send(message);
            meterRegistry.counter("email.sent.success").increment();
        } catch (MailException e) {
            meterRegistry.counter("email.sent.failure").increment();
            throw e;
        }
    }
}

Зависимость:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

Безопасность и защита данных

Никогда не храните пароли в открытом виде в git-репозиториях.

Рекомендации:
Используйте переменные окружения или секреты (например, Kubernetes Secrets).
Применяйте Spring Cloud Vault или HashiCorp Vault.
Используйте шифрование с Jasypt.
Настройте OAuth2 для Gmail.

Пример с переменными окружения:

spring.config.import=optional:configserver:http://config-server
spring.mail.password=${MAIL_PASSWORD}

#Java #middle #on_request #JavaMailSender

Тестирование отправки почты

Интеграционные тесты с Testcontainers:

@Testcontainers
@SpringBootTest
public class EmailServiceTest {

    @Container
    private static final GreenMailContainer greenMail = new GreenMailContainer();

    @Autowired
    private EmailService emailService;

    @Test
    void shouldSendEmail() {
        emailService.sendSimpleEmail("test@example.com", "Test Subject", "Test Body");
        assertEquals(1, greenMail.getReceivedMessages().length);
    }
}

Зависимость:

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>greenmail</artifactId>
    <version>2.2.0</version>
    <scope>test</scope>
</dependency>

Unit-тестирование:

@MockBean
private JavaMailSender mailSender;

@Test
void shouldSendMail() {
    SimpleMailMessage message = new SimpleMailMessage();
    emailService.sendSimpleEmail("to", "subject", "body");
    verify(mailSender, times(1)).send(any(SimpleMailMessage.class));
}

Интеграция с очередями

Для отложенной отправки используйте RabbitMQ(ну или другой брокер сообщений):

@Service
public class EmailService {

    @Autowired
    private JavaMailSender mailSender;

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendEmailToQueue(String to, String subject, String text) {
        EmailMessage email = new EmailMessage(to, subject, text);
        rabbitTemplate.convertAndSend("emailQueue", email);
    }

    @RabbitListener(queues = "emailQueue")
    public void processEmail(EmailMessage email) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(email.getTo());
        message.setSubject(email.getSubject());
        message.setText(email.getText());
        mailSender.send(message);
    }

    @Data
    static class EmailMessage {
        private String to;
        private String subject;
        private String text;
    }
}

Зависимость:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

Распространенные ошибки и подводные камни

Неверная конфигурация SMTP (порт, шифрование).
Проблемы с двухфакторной авторизацией (особенно Gmail).
Ограничения на массовую рассылку (например, Gmail: ~500 писем/день для бесплатных аккаунтов).
Проблемы с кодировкой (например, кириллица в теме письма).
Отсутствие MIME-типа у вложений.
Блокировка сервером (например, Mail.ru требует DKIM и SPF).

Решение для кодировки:

helper.setSubject(MimeUtility.encodeText("Тема на кириллице", "UTF-8", null));

#Java #middle #on_request #JavaMailSender

Объекты в Java

Объекты являются фундаментальным понятием в Java и лежат в основе всей объектно-ориентированной парадигмы языка. Каждый объект представляет собой экземпляр класса и объединяет в себе состояние (поля) и поведение (методы).

1. Введение

В Java всё, что не является примитивным типом, относится к ссылочным типам, а основные единицы этих типов — это объекты.

Объект-ориентированная модель основана на трёх ключевых принципах:
Инкапсуляция: объединение данных и методов для управления ими.
Наследование: возможность создавать новые классы на основе уже существующих, унаследовав их состояние и поведение.
Полиморфизм: возможность работать с объектами через их общий (абстрактный) тип, подставляя разные конкретные реализации.

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

2. Создание объектов

2.1. Ключевое слово new

Самый распространённый способ создания объекта — использование оператора new, который выполняет два основных действия:
Выделяет память в куче (heap) под новый объект.
Вызывает конструктор соответствующего класса, чтобы инициализировать поля объекта.

Person person1 = new Person("John", 25);

Здесь:
new Person("John", 25) — порождает новый объект класса Person, вызывая конструктор Person(String name, int age).
Полученная ссылка на вновь созданный объект присваивается переменной person1 типа Person.
Переменная person1 не содержит непосредственно самого объекта, а лишь указывает на область памяти, где объект расположен.

2.2. Фабричные методы и другие способы

Кроме new, объекты могут создаваться через:
Фабричные методы (static factory methods), например, List.of(...) или Optional.of(...).
Клонирование (когда класс поддерживает интерфейс Cloneable и реализует метод clone()).
Десериализация (с помощью API сериализации или при работе с JSON/XML).
Рефлексия (пересоздание экземпляра через Class.newInstance() или Constructor.newInstance()).

Однако в подавляющем большинстве случаев для явного создания объекта используется именно new.

2.3. Размещение ссылок и объектов

Объекты всегда размещаются в куче (heap).

Ссылочные переменные (person1 в примере) могут храниться:
В стеке вызовов (если это локальная переменная метода).
В полях других объектов (если объект содержится в качестве поля другого объекта).
В элементах массива (если это массив ссылок).
В статических полях классов (в специальной области памяти, связанной с загрузчиком классов).

3. Существование и удаление объектов

3.1. Существование объектов

Объект продолжает «жить» в памяти до тех пор, пока на него существует хотя бы одна активная ссылка.

Пример:

Person person1 = new Person("John", 25);
Person person2 = person1;   // person2 ссылается на тот же самый объект
person1 = null;            // теперь единственная ссылка на объект — person2

В момент создания объекта через new в куче появляется новый экземпляр Person.
Переменные person1 и person2 указывают на одну и ту же область памяти.
Когда мы присвоили person1 = null;, объект всё ещё существует, поскольку на него ссылается person2.
Как только все ссылки будут убраны (например, person2 = null; или метод, в котором была локальная ссылка, завершится и стек «очистится»), объект становится недостижимым.

Java применяет алгоритм mark-and-sweep для сборки мусора, поэтому даже если два объекта ссылаются друг на друга, но на них никто извне не ссылается, они будут помечены как недостижимые и удалены.

#Java #для_новичков #beginner #reference_types #Object

3.2. Состояние объектов при сборке мусора

Touchable (доступный): объекты, на которые есть хотя бы одна живая ссылка.
Resurrectible (возродимый): объекты, на которые больше нет обычных ссылок, но в методе finalize() ещё есть возможность «оживить» объект (устаревший механизм, не рекомендуется к использованию).
Untouchable (недоступный): объекты, окончательно помеченные для удаления сборщиком мусора.

Иерархия переходов такова:
Пока есть ссылки — объект «доступен» и используется.
Если ссылок нет, но метод finalize() ещё не вызывался — объект попадает в очередь финализации.
После выполнения finalize() (или если он не переопределён) объект окончательно переходит в состояние «недоступен» и убирается сборщиком мусора.

3.3. Удаление объектов

Перечислять и освобождать память вручную, как в C++, в Java не нужно.
Можно лишь рекомендовать запуск сборщика мусора через System.gc(), но вызов этого метода не гарантирует немедленного выполнения GC.
Метод finalize() устаревает (deprecated) и не рекомендуется к использованию, поскольку его выполнение непредсказуемо и может негативно влиять на производительность.
При работе с ресурсами (файлы, сокеты, потоки) рекомендуется применять конструкцию try-with-resources или явно закрывать ресурсы в блоке finally, а не полагаться на GC или finalize().

4. Использование объектов

4.1. Вызов методов и доступ к полям

После того как объект создан и на него есть ссылка, мы можем обращаться к его полям и методам:

person1.sayHello();       // вызов метода объекта
int age = person1.getAge(); // чтение свойства через геттер

Ключевое понимание:
Любой метод вызывается через ссылку на объект.
Внутри метода this указывает на тот же объект, на который указывает переменная, через которую мы вызвали метод.

4.2. Инкапсуляция и модульность

Объекты позволяют:
Инкапсулировать внутреннее состояние (часто делая поля private и предоставляя доступ через геттеры/сеттеры).
Скрыть детали реализации, предоставляя только публичный интерфейс (методы).
Повторно использовать код: один и тот же класс можно инстанцировать в разных местах программы.

4.3. Передача объектов в методы

Когда мы передаём объект в метод, копируется сама ссылка, а не весь объект.

Это значит, что метод получает «копию адреса», указывающую на тот же экземпляр:

void modifyList(List<Integer> list) {
    list.add(10);                    // модифицирует оригинальный список
    list = new ArrayList<>();        // переприсвоение локальной переменной — не влияет на внешний список
    list.add(20);                    // меняет уже новый (локальный) список
}

List<Integer> numbers = new ArrayList<>();
modifyList(numbers);
System.out.println(numbers);         // [10], но не [10, 20]

Вызов list.add(10) изменил тот же объект, что и numbers.
А переприсваивание list = new ArrayList<>() коснулось только локальной копии ссылки внутри метода.

5. Трудности и подводные камни

5.1. NullPointerException

Самая распространённая ошибка при работе с объектами — попытка вызвать метод или обратиться к полю на null-ссылке:

String s = null;
int length = s.length(); // NullPointerException

Рекомендуемые практики:
При инициализации объектов делать явные проверки, либо использовать Objects.requireNonNull(obj).
При наличии неопределённости возвращать Optional<T> вместо потенциально null.
В местах, где возможно получение null, проверять ссылку прежде чем обращаться к её методам или полям.

#Java #для_новичков #beginner #reference_types #Object

5.2. Сравнение ссылок и содержимого

Оператор == сравнивает адреса в памяти, то есть проверяет, совпадают ли ссылки.
Метод equals() (если переопределён) сравнивает логическое содержание объектов.

String a = new String("hello");
String b = new String("hello");

System.out.println(a == b);      // false (разные объекты)
System.out.println(a.equals(b)); // true  (одинаковое содержимое)
Неверное использование == вместо equals() приводит к тому, что два «логически одинаковых» объекта будут считаться разными.

5.3. Изменяемые (mutable) и неизменяемые (immutable) объекты

Изменяемые объекты (например, ArrayList, StringBuilder) позволяют изменять своё внутреннее состояние после создания. Если несколько ссылок указывают на один и тот же экземпляр, то изменение через одну ссылку будет видно через все остальные.
Неизменяемые объекты (например, String, Integer, LocalDate) после создания не меняются; операции, которые «меняют» их, на самом деле возвращают новый экземпляр.

Непонимание этого может привести к неожиданным результатам:

List<String> list = new ArrayList<>();
list.add("A");
List<String> another = list;
another.clear();              // очищает список для обеих ссылок
System.out.println(list);     // []

5.4. Утечки памяти

В Java утечки памяти возникают не из-за отсутствия явного удаления объектов (как в C++), а из-за того, что на объекты остаются неожиданно живые ссылки, и GC не может их убрать:
Хранение объектов в static-полях и неочищаемых коллекциях.
Неправильная работа с кешами или пулом объектов, где ссылки не удаляются вовремя.
Анонимные внутренние классы или лямбда-выражения, сохраняющиеся после использования.

Пример простой утечки:

public class Cache {
    private static final Map<String, Object> CACHE = new HashMap<>();

    public static void put(String key, Object value) {
        CACHE.put(key, value);
    }

    // Если не реализовать метод удаления из CACHE, то объекты будут храниться в памяти постоянно
}

5.5. Производительность и частые аллокации

Частое создание небольших временных объектов может привести к частым запускам GC и общему снижению производительности.
Конкатенация строк в цикле через оператор + создаёт новые объекты String на каждом шаге.

Лучше использовать StringBuilder:

// Плохо:
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i;                  // каждый раз создаётся новый String
}

// Лучше:
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
String result = sb.toString();

5.6. Пограничные случаи при копировании — глубокое vs поверхностное копирование

Поверхностное копирование (shallow copy) копирует только поля-примитивы и ссылки; вложенные объекты не дублируются, а «разделяются» между двумя экземплярами.
Глубокое копирование (deep copy) предполагает создание новых экземпляров для всех вложенных объектов, чтобы изменения в одном объекте не затрагивали другой.

class Address {
    String street;
}

class Person implements Cloneable {
    String name;
    Address address;

    @Override
    protected Person clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();    // поверхностное копирование
        cloned.address = new Address();            // нужно вручную создать новый адрес
        cloned.address.street = this.address.street;
        return cloned;
    }
}
Если не учитывать глубокое копирование, можно случайно разделить внутреннее состояние между двумя объектами, что приведёт к трудноотлавливаемым ошибкам.

5.7. Потокобезопасность (thread-safety)

Когда объекты доступны из нескольких потоков, нужно грамотно синхронизировать доступ к их полям и методам:
Использовать synchronized, ReentrantLock, атомарные типы (AtomicInteger, AtomicReference).
Предпочитать неизменяемые объекты, так как они автоматически безопасны для чтения из разных потоков.
Избегать состояния, зависимого от порядка выполнения, или пользоваться высокоуровневыми абстракциями из java.util.concurrent.

#Java #для_новичков #beginner #reference_types #Object

6. Дополнительные нюансы

6.1. Массивы как объекты

Хотя у массивов особый синтаксис, они всё же являются полноценными объектами:
Имеют поле length.
Могут быть null (если не инициализированы), поэтому доступ к элементам массива без проверки может привести к NullPointerException.
Создаются через new Type[size] или инициализируются через литералы { … }.

int[] nums = new int[5];
System.out.println(nums.length); // 5

String[] names = null;
System.out.println(names.length); // NullPointerException

6.2. Generics и ограничение на примитивы

В обобщённых (generic) классах и методах можно использовать только ссылочные типы. Примитивы (например, int, char) нельзя указать напрямую как параметр типа.
В качестве параметры обобщений применяются соответствующие классы-обёртки: Integer, Character, Double и т. д.

List<Integer> integers = new ArrayList<>();
integers.add(10); // автоупаковка: int → Integer

6.3. Наследование от Object

Все классы в Java неявно наследуются от java.lang.Object.
В классе Object определены методы: toString(), equals(), hashCode(), getClass(), clone(), finalize() и др.

При работе с любыми объектами полезно переопределять toString(), equals() и hashCode() в соответствии с логикой класса:

class Point {
    int x, y;

    @Override
    public String toString() {
        return "Point(" + x + ", " + y + ")";
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Point)) return false;
        Point other = (Point) obj;
        return x == other.x && y == other.y;
    }

    @Override
    public int hashCode() {
        return 31 * x + y;
    }
}

6.4. Расположение в памяти

Объекты — в куче. При создании нового экземпляра сборщик мусора определяет, в какой части кучи разместить объект (young generation, old generation и т. д.).
Ссылочные переменные (локальные) — в стеке вызовов. Когда метод завершается, все локальные ссылки удаляются из стека.
Ссылки в полях — часть объекта в куче. Когда объект удаляется, удаляются и все его поля-ссылки.

Это знание помогает понимать, какие объекты могут быстро «умирать» (локальные объекты, ссылки на которые не передаются дальше) и какие могут «жить» дольше (объекты, ссылки на которые остаются в статических полях или в глобальном контексте).

#Java #для_новичков #beginner #reference_types #Object

Введение в Flyway

Flyway представляет собой специализированный инструмент управления миграциями баз данных, реализующий принцип "Database-as-Code". Его фундаментальная задача заключается в обеспечении контролируемого и воспроизводимого процесса эволюции схемы базы данных через систему версионированных изменений.

Ключевые функциональные аспекты:
Декларативное управление схемой - все изменения БД описываются в виде отдельных скриптов
Детерминированность применения - каждая миграция имеет строгую версионную привязку
Атомарность изменений - миграции применяются как единое целое (транзакционно)
Историчность - полный аудит всех выполненных изменений

Сравнение с Liquibase

Принципиальные различия между Flyway и Liquibase проявляются в нескольких аспектах:

Архитектурный подход
Flyway придерживается парадигмы "SQL-первым", где основным носителем изменений являются нативные SQL-скрипты. Liquibase предлагает абстрактный DSL (XML/YAML/JSON) для описания изменений, который затем транслируется в SQL.

Механизм откатов
В Flyway стратегия откатов реализована через создание новых миграционных скриптов с обратными изменениями. Liquibase предоставляет встроенный механизм описания операций отката непосредственно в changeSet.

Сложность и гибкость
Flyway демонстрирует минималистичный подход с низким порогом вхождения. Liquibase предлагает более богатый функционал за счет усложненной модели конфигурации.

Интеграционные возможности
Оба инструмента имеют глубокую интеграцию с экосистемой Java, но Flyway чаще выбирают для Spring Boot-проектов благодаря более простой автоконфигурации.


Базовые концепции

Модель миграций

Flyway оперирует двумя фундаментальными типами миграций:

Версионные миграции (префикс V)
Линейно упорядоченные изменения схемы
Неизменяемые после применения

Пример именования: V2__Add_email_column.sql

Содержимое SQL-скрипта:

ALTER TABLE users ADD COLUMN email VARCHAR(255);

Повторяемые миграции (префикс R)
Перезаписываемые скрипты
Применяются при изменении контрольной суммы

Пример: R__Update_report_views.sql


Механизм контроля версий

Система использует служебную таблицу flyway_schema_history, содержащую:
Точную версию каждой примененной миграции
Контрольную сумму скрипта
Временные метки выполнения
Статус операции

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

Типичный workflow включает:
Инициализацию схемы (baseline)
Валидацию существующих миграций
Применение новых изменений (migrate)
При необходимости - очистку (clean) и повторное развертывание


Поддерживаемые системы управления базами данных

Flyway обеспечивает совместимость с большинством современных реляционных СУБД:
PostgreSQL (полная поддержка, включая расширения)
MySQL/MariaDB (включая специфичные движки хранения)
Oracle (с учетом особенностей PL/SQL)
SQL Server (включая Azure SQL)
Встраиваемые БД (H2, SQLite)
Для NoSQL-систем (MongoDB) требуется использование коммерческой версии Flyway. Важно отметить, что некоторые специфические функции СУБД могут требовать особого подхода при миграциях.


Типовые сценарии использования

Разработка - синхронизация схемы между средами
Тестирование - подготовка изолированных тестовых БД
Развертывание - автоматизация деплоя в production
Анализ - отслеживание истории изменений схемы

#Java #middle #Flyway

Ссылочные типы в Java — массивы

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

Создание массивов

Массивы в Java создаются с помощью ключевого слова new, аналогично другим объектам. При этом в куче выделяется непрерывный блок памяти под элементы массива.

Например:

int[] numbers = new int[5];

Здесь переменная numbers — это ссылка на объект массива, содержащего 5 элементов типа int. Все элементы автоматически инициализируются значениями по умолчанию — нулями для чисел, false для логических значений, null для ссылок.

Можно также создать и инициализировать массив сразу:

String[] names = {"Alice", "Bob", "Charlie"};

Ключевые моменты:
Массив — это объект, даже если он содержит примитивные типы.
У массива всегда есть поле length, определяющее количество элементов.
После создания размер массива изменить нельзя. Для динамических структур используются коллекции, такие как ArrayList.

Существование и удаление массивов

Как и другие объекты в Java, массивы существуют в памяти до тех пор, пока на них имеются ссылки.

Когда все ссылки теряются, массив становится кандидатом на сборку мусора:

int[] data = new int[100];
data = null; // массив станет доступен для удаления

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

Использование массивов

Массивы позволяют обращаться к элементам по индексу, начиная с нуля:

numbers[0] = 10;
System.out.println(numbers[0]); // выводит 10

При передаче массива в метод метод получает копию ссылки, а не сам массив.

Это означает, что любые изменения внутри метода влияют на оригинальный массив:

void fill(int[] arr) {
    arr[0] = 42;
}
После вызова fill(numbers) значение numbers[0] станет 42.

Также массивы могут быть многомерными, например, двумерный массив int[][] представляет собой массив массивов.

#Java #для_новичков #beginner #reference_types #Arrays

Трудности и подводные камни

Работа с массивами может сопровождаться рядом типичных ошибок:

1. ArrayIndexOutOfBoundsException

Ошибка возникает при попытке обратиться к несуществующему индексу:

int[] a = new int[3];
a[3] = 5; // ошибка: допустимые индексы — 0, 1, 2

2. NullPointerException

Если массив равен null, любая попытка доступа к его элементам вызывает исключение:

int[] a = null;
System.out.println(a.length); // ошибка

3. Фиксированный размер

После создания размер массива не может быть изменён. Чтобы добавить или удалить элементы, необходимо создать новый массив или использовать коллекции.

4. Поверхностное копирование

При копировании массива переменная будет указывать на тот же объект, если используется простое присваивание:

int[] a = {1, 2, 3};
int[] b = a;
b[0] = 99;
System.out.println(a[0]); // выведет 99

Для создания копии используется метод Arrays.copyOf или ручное копирование по элементам.

5. Сравнение массивов

Сравнение массивов через == проверяет ссылки, а не содержимое.

Для сравнения содержимого следует использовать Arrays.equals():

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(a == b); // false
System.out.println(Arrays.equals(a, b)); // true

6. Утечки памяти

Массивы могут стать причиной утечек памяти, если ссылки на них остаются в структурах данных (например, кешах), даже когда они больше не нужны.

7. Потокобезопасность

Если массив используется из нескольких потоков, требуется синхронизация. Иначе возможны ошибки при чтении и записи.

Дополнительные нюансы

Массивы как объекты:
Даже массив примитивных типов — это объект, доступный через ссылку, с полем length.

Обобщения:
Нельзя создавать массивы параметризованных типов, например new List<String>[10], из-за ограничений системы типов Java. Для таких целей используют коллекции.

Массивы и методы класса Object:
Как и другие объекты, массивы наследуют методы класса Object, например toString() и hashCode(), но стандартная реализация toString() для массивов возвращает строку вида [I@1b6d3586. Для корректного вывода содержимого массива используйте Arrays.toString() или Arrays.deepToString().

Массивы и производительность:
Работа с массивами быстрее, чем с коллекциями, за счёт простоты реализации и отсутствия лишнего обёртывания. Однако отсутствие гибкости может потребовать дополнительного кода.

#Java #для_новичков #beginner #reference_types #Arrays

Настройка и базовые команды Flyway

1. Конфигурация Flyway

1.1. Файл flyway.conf
Основной файл конфигурации Flyway. Располагается в корне проекта или в директории conf.

Пример содержимого:

# Подключение к БД
flyway.url=jdbc:postgresql://localhost:5432/mydb
flyway.user=admin
flyway.password=secret

# Директории с миграциями
flyway.locations=classpath:db/migration,filesystem:/opt/migrations

# Дополнительные настройки
flyway.schemas=public
flyway.baselineOnMigrate=true

Ключевые параметры:
flyway.url — JDBC-URL базы данных (формат зависит от СУБД).

flyway.locations — пути к миграциям:
classpath: — поиск в ресурсах проекта (например, src/main/resources/db/migration).
filesystem: — абсолютный путь на диске.
flyway.baselineOnMigrate — инициализация существующей БД (без таблицы flyway_schema_history).

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

Настройки можно переопределять через аргументы:

flyway -url=jdbc:postgresql://localhost:5432/mydb \
       -user=admin \
       -password=secret \
       -locations=classpath:db/migration \
       migrate
Важно: Параметры из командной строки имеют приоритет над flyway.conf.

2. Основные CLI-команды

2.1. flyway migrate

Применяет все невыполненные миграции.

Процесс:
Проверяет таблицу flyway_schema_history.
Находит скрипты, которых нет в истории.
Выполняет их в порядке версий (например, V1__... перед V2__...).

Пример:

flyway migrate

2.2. flyway info

Показывает текущее состояние БД:
Какие миграции применены.
Какие ожидают выполнения.
Статус (Success, Pending, Failed).

Вывод:

+-----------+---------+---------------------+------+---------------------+---------+
| Version   | Description | Installed on       | State | Type    | Checksum |
+-----------+---------+---------------------+------+---------------------+---------+
| 1         | Create users | 2024-03-15 10:00  | Done | SQL     | 1234abcd |
| 2         | Add email   | Pending            |      | SQL     | 5678efgh |
+-----------+---------+---------------------+------+---------------------+---------+

2.3. flyway validate

Проверяет:
Целостность скриптов (не изменены ли уже примененные).
Корректность именования.

Ошибка:

Validation failed: Detected applied migration not resolved locally: 1
Причина: Локальный скрипт V1__... был изменен после применения к БД.

2.4. flyway clean

Удаляет все объекты БД (таблицы, процедуры), включая flyway_schema_history.
Опасность: Необратимая операция. Используется только в dev-среде.

flyway clean

3. Форматы миграций

3.1. SQL-миграции

Стандартный подход. Скрипты с расширением .sql в директории db/migration.

Пример (V1__Create_users.sql):

CREATE TABLE users (
    id INT PRIMARY KEY,
    username VARCHAR(50) NOT NULL
);

INSERT INTO users (id, username) VALUES (1, 'admin');

3.2. Java-миграции

Для сложной логики (например, условные операции).

Шаги:
Создайте класс в проекте:

public class V2__InsertTestData implements JdbcMigration {
    public void migrate(Connection connection) throws Exception {
        try (Statement stmt = connection.createStatement()) {
            stmt.execute("INSERT INTO users (username) VALUES ('test')");
        }
    }
}

Укажите путь к Java-классам в flyway.locations:

flyway.locations=classpath:db/migration,classpath:com/example/migrations

3.3. Callbacks (SQL-хуки)

Скрипты, выполняемые до/после событий Flyway.

Пример (beforeMigrate.sql):

-- Выполняется перед началом миграций
CREATE SCHEMA IF NOT EXISTS audit;

Поддерживаемые события:
beforeMigrate, afterMigrate.
beforeClean, afterClean.

Директория:

db/
  migration/
    V1__...sql
  callback/
    beforeMigrate.sql

4. Важные замечания

Именование файлов:
Регистрозависимо (V1__test.sql ≠ v1__test.sql).
Разделитель — двойное подчеркивание (__).

Порядок выполнения:
Сначала V1__..., затем V2__....
R__... выполняются после всех версионных.

Безопасность:
Никогда не изменяйте уже примененные скрипты.
Для отката создавайте новые миграции (например, V3__Drop_table.sql).

#Java #middle #Flyway

Ссылочные типы в Java — строки (String)

Строки (String) в Java — это особый ссылочный тип данных, играющий ключевую роль практически в любом приложении. Несмотря на кажущуюся простоту, строки обладают рядом особенностей, таких как неизменяемость, пул строк, перегрузка операций и поведение ссылок. Глубокое понимание строк необходимо для написания безопасного, производительного и корректного Java-кода.


Создание строк

В Java строки можно создавать несколькими способами:

String s1 = "Hello";
String s2 = new String("Hello");

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

Также строки можно строить из массивов символов или байтов:

char[] chars = {'J', 'a', 'v', 'a'};
String s3 = new String(chars);

Ключевые особенности:
Строки в Java являются объектами класса java.lang.String.
Объекты String неизменяемы: после создания их содержимое нельзя изменить.
Неизменяемость позволяет безопасно использовать строки в многопоточном окружении и в качестве ключей в Map.


Существование и удаление строк

Как и любые объекты, строки существуют до тех пор, пока на них имеются активные ссылки. Когда все ссылки теряются, строка становится кандидатом на сборку мусора.
Однако строки, созданные как литералы (например, "Hello"), хранятся в строковом пуле, и удаление таких строк происходит только при завершении работы JVM или при агрессивной сборке мусора в редких случаях.

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); // true — обе ссылаются на одну строку из пула

В случае создания строки через new, строки не участвуют в пуле по умолчанию:

String s1 = new String("abc");
String s2 = "abc";
System.out.println(s1 == s2); // false

Метод intern() позволяет вручную добавить строку в пул:

String s1 = new String("abc").intern();
String s2 = "abc";
System.out.println(s1 == s2); // true

Использование строк

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

Java предоставляет множество удобных методов для работы со строками:

String s = "Hello, World!";
int length = s.length();
char ch = s.charAt(0);
String lower = s.toLowerCase();
boolean contains = s.contains("World");

Важно помнить, что методы класса String возвращают новые строки, поскольку String неизменяем:

String original = "Java";
String modified = original.replace("J", "K");
System.out.println(original); // Java
System.out.println(modified); // Kava

Сравнение строк:

String a = "hello";
String b = new String("hello");

System.out.println(a == b);          // false — разные объекты
System.out.println(a.equals(b));     // true — одинаковое содержимое
Оператор == сравнивает ссылки, а метод equals() — содержимое.

#Java #для_новичков #beginner #reference_types #String

Трудности и подводные камни

1. Неизменяемость
Изменение строки всегда приводит к созданию нового объекта. Это важно учитывать при работе в циклах:

String result = "";
for (int i = 0; i < 1000; i++) {
    result += "a"; // создается 1000 новых строк
}

Лучше использовать StringBuilder:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("a");
}
String result = sb.toString();

2. Сравнение с null

Обращение к методам строки без проверки может привести к NullPointerException:

String name = null;
if (name.equals("admin")) { // ошибка
}

Правильнее писать:

if ("admin".equals(name)) { // безопасно
}

3. Пул строк и производительность
Пул строк позволяет уменьшить использование памяти, но злоупотребление вручную созданными строками через new String(...) может привести к увеличению нагрузки на сборщик мусора.

4. Конкатенация и производительность
Строки, объединённые с помощью + в цикле, могут ухудшать производительность. Лучше использовать StringBuilder или StringBuffer (если требуется потокобезопасность).

5. Использование в Map и Set

Поскольку строки неизменяемы, их можно безопасно использовать в качестве ключей в HashMap, HashSet и других коллекциях. Однако важно корректно переопределять equals() и hashCode() для классов, в которых строки используются в качестве полей для сравнения.


Дополнительные нюансы

1. String vs StringBuilder vs StringBuffer
String — неизменяемый, потокобезопасный.
StringBuilder — изменяемый, не потокобезопасный, но самый быстрый.
StringBuffer — изменяемый, потокобезопасный, но медленнее.

2. Методы класса String

Строки обладают большим набором методов:
substring()
trim()
split()
replace()
matches() (регулярные выражения)
format() и другие

3. Регулярные выражения

Методы matches(), replaceAll() и split() поддерживают регулярные выражения, что делает String мощным инструментом для разбора и обработки текста.

4. Юникод и кодировка

Java строки используют UTF-16, где каждый символ — это один или два 16-битных элемента. Это важно при работе с Unicode-символами, особенно при подсчёте длины строки или извлечении символов.

5. Объекты String в коллекциях

Если строка используется как ключ в Map, важно помнить, что разные ссылки на строки с одинаковым содержимым будут считаться одинаковыми, если equals() и hashCode() совпадают — что работает корректно для String.

#Java #для_новичков #beginner #reference_types #String

Типы миграций и версионирование в Flyway

1. Структура SQL-миграций

Flyway классифицирует SQL-миграции по префиксам в именах файлов, определяя их поведение при выполнении.

1.1. Именование файлов

Версионные миграции (Versioned)

Префикс V + версия + описание:

V<Версия>__<Описание>.sql

Пример:

-- V1__Create_users_table.sql
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(50) NOT NULL
);

Повторяемые миграции (Repeatable)

Префикс R + описание:

R__<Описание>.sql

Пример:

-- R__Update_user_view.sql
CREATE OR REPLACE VIEW user_view AS
SELECT id, username FROM users;

2. Java-миграции

Позволяют описывать миграции на Java для сложной логики, недоступной в SQL.

2.1. Реализация интерфейсов

JdbcMigration (устаревший):

public class V2__InsertTestData implements JdbcMigration {
    @Override
    public void migrate(Connection connection) throws Exception {
        try (Statement stmt = connection.createStatement()) {
            stmt.execute("INSERT INTO users (username) VALUES ('admin')");
        }
    }
}

JavaMigration (рекомендуемый):

public class V3__AddAdminUser implements JavaMigration {
    @Override
    public void migrate(Context context) throws Exception {
        try (Statement stmt = context.getConnection().createStatement()) {
            stmt.execute("INSERT INTO users (username) VALUES ('superuser')");
        }
    }
}

2.2. Правила

Классы должны находиться в classpath (обычно src/main/java/db/migration).
Имя класса соответствует имени файла SQL-миграции (например, V2__InsertTestData.java).

3. Правила версионирования

3.1. Семантическое версионирование

Рекомендуемый формат версии:

V<Мажор>.<Минор>.<Патч>__<Описание>.sql

Пример:

-- V1.2.3__Fix_email_constraint.sql
ALTER TABLE users ALTER COLUMN email SET NOT NULL;

Преимущества:
Понятная история изменений.
Совместимость с Semantic Versioning.

3.2. Откат изменений

Flyway не поддерживает автоматический откат. Альтернативы:

Новая миграция для отмены изменений:

-- V3__Drop_users_table.sql
DROP TABLE users;

Callbacks (SQL-хуки):
Скрипты beforeMigrate/afterMigrate для резервного копирования.

Важно: Не изменяйте уже примененные миграции — это нарушит целостность flyway_schema_history.

4. Примеры

4.1. SQL-миграции

-- V1__Initial_schema.sql
CREATE TABLE users (
    id INT PRIMARY KEY,
    name VARCHAR(100)
);

-- R__Update_view.sql
CREATE OR REPLACE VIEW active_users AS 
SELECT * FROM users WHERE deleted_at IS NULL;

4.2. Java-миграция

public class V4__EncryptPasswords implements JavaMigration {
    @Override
    public void migrate(Context context) throws Exception {
        try (PreparedStatement ps = context.getConnection()
            .prepareStatement("UPDATE users SET password = encrypt(password)")) {
            ps.executeUpdate();
        }
    }
}

#Java #middle #Flyway