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

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

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

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

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')");
        }
    }
}

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')");
        }
    }
}

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

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

-- V3__Drop_users_table.sql
DROP TABLE users;

-- 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;

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();
        }
    }
}

import java.util.stream.IntStream;

public class Task160625 {
    public static void main(String[] args) {
        IntStream.rangeClosed(1, 5)
                .filter(i -> i % 2 == 0)
                .peek(System.out::print)
                .forEachOrdered(i -> {});
    }
}

public interface Animal {
    void makeSound();
}

public class Dog implements Animal {
    public void makeSound() {
        System.out.println("Woof");
    }
}

public interface Logger {
    default void log(String msg) {
        System.out.println("Log: " + msg);
    }
}

public void processAnimal(Animal animal) {
    animal.makeSound(); // работает с любым классом, реализующим Animal
}

@FunctionalInterface
public interface Converter<F, T> {
    T convert(F from);
}

Animal animal = new Dog();

List<String> list = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();
Здесь List и Map — интерфейсы, а ArrayList и HashMap — конкретные реализации. Это позволяет заменить реализацию без изменения остального кода.

public interface Flyable {
    void fly();
}

public interface Swimmable {
    void swim();
}

public class Duck implements Flyable, Swimmable {
    public void fly() { ... }
    public void swim() { ... }
}
Это решает проблему ограничений одиночного наследования и позволяет композировать поведение.

interface A {
    default void show() { System.out.println("A"); }
}
interface B {
    default void show() { System.out.println("B"); }
}
class C implements A, B {
    public void show() {
        A.super.show(); // Явное разрешение конфликта
    }
}

List<String> list = new LinkedList<>();
list.get(0); // Поведение может отличаться от ArrayList

Runnable r = () -> System.out.println("Run");

public interface Repository<T> {
    void save(T entity);
}

interface A { void a(); }
interface B extends A { void b(); }
Класс, реализующий B, обязан реализовать методы a() и b().

interface A170625 {
    default void show() {
        System.out.println("A");
    }
}

interface B170625 extends A170625 {
    default void show() {
        System.out.println("B");
    }
}

interface C170625 extends A170625 {}

class D170625 implements B170625, C170625 {
    public static void main(String[] args) {
        new D170625().show();
    }
}

<build>
    <plugins>
        <plugin>
            <groupId>org.flywaydb</groupId>
            <artifactId>flyway-maven-plugin</artifactId>
            <version>9.22.0</version>
            <configuration>
                <url>jdbc:postgresql://localhost:5432/mydb</url>
                <user>postgres</user>
                <password>password</password>
                <locations>
                    <location>classpath:db/migration</location>
                </locations>
            </configuration>
            <dependencies>
                <dependency>
                    <groupId>org.postgresql</groupId>
                    <artifactId>postgresql</artifactId>
                    <version>42.6.0</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

mvn flyway:migrate  # Применить миграции
mvn flyway:info     # Показать статус
mvn flyway:clean    # Очистить БД (удалить все объекты)

plugins {
    id "org.flywaydb.flyway" version "9.22.0"
}

flyway {
    url = 'jdbc:postgresql://localhost:5432/mydb'
    user = 'postgres'
    password = 'password'
    locations = ['classpath:db/migration']
}

dependencies {
    flywayRuntime 'org.postgresql:postgresql:42.6.0'
}

gradle flywayMigrate  # Применить миграции
gradle flywayInfo    # Показать статус

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: postgres
    password: password
  flyway:
    enabled: true
    locations: classpath:db/migration
    baseline-on-migrate: true  # Игнорировать существующую БД
    validate-on-migrate: false # Отключить валидацию (для dev)

-- beforeMigrate.sql
CREATE TABLE IF NOT EXISTS _flyway_audit (
    operation VARCHAR(20),
    timestamp TIMESTAMP
);
INSERT INTO _flyway_audit VALUES ('migration_started', NOW());

<!-- Maven -->
<location>filesystem:${project.basedir}/../migrations/src/main/resources/db/migration</location>

// Gradle
locations = ['filesystem:../migrations/src/main/resources/db/migration']

spring:
  flyway:
    enabled: false

spring:
  flyway:
    locations: s3://my-bucket/db/migration

locations: classpath:db/migration, filesystem:/opt/migrations

import java.util.Optional;

public class Task180625 {
    public static void main(String[] args) {
        Optional<String> opt = Optional.ofNullable(null)
                                    .flatMap(s -> Optional.of("value"))
                                    .or(() -> Optional.of("default"));
        
        System.out.println(opt.get());
    }
}