Потребитель (Consumer) описывает, что он ждёт от поставщика (Provider).
Provider подтверждает: «Да, я действительно так отвечаю».

@Pact(consumer = "OrderService")
public RequestResponsePact createPact(PactDslWithProvider builder) {
    return builder
        .given("User exists")
        .uponReceiving("a request for user details")
        .path("/users/123")
        .method("GET")
        .willRespondWith()
        .status(200)
        .body("{\"id\":123,\"name\":\"Alex\"}")
        .toPact();
}

@ExtendWith(PactConsumerTestExt.class)
@PactTestFor(providerName = "UserService", port = "8080")
public void testUserService(MockServer server) {
    Response response = get(server.getUrl() + "/users/123");
    assertEquals(200, response.getStatusCode());
}

@Provider("UserService")
@PactFolder("pacts")
class UserServicePactTest {
    @TestTarget
    final Target target = new HttpTarget(8080);

    @State("User exists")
    public void userExists() {
        // фикстуры для теста
    }
}

docker run -d -p 9292:9292 pactfoundation/pact-broker

Интеграционные тесты требуют запущенные сервисы.
Контрактные тесты — только спецификации.

contract {
    request {
        method 'GET'
        url '/users/123'
    }
    response {
        status 200
        body(id: 123, name: "Alex")
    }
}

➕ Нет неожиданностей при релизах.
➕ CI ломается до продакшена, если кто-то нарушил контракт.
➕ Каждый сервис тестируется изолированно.

➖Нужно поддерживать актуальность контрактов.
➖При множестве сервисов — много файлов.
➖Не ловит ошибки логики (только интерфейсов).

В этом видео автор подробно объясняет концепцию наследования в Java: как один класс может наследовать свойства и методы другого, когда применять `extends`, как переопределять методы и использовать ключевое слово `super`.

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

List<String> lines = Files.readAllLines(Paths.get("data.txt"));
Map<String, Long> counts = lines.stream()
    .flatMap(line -> Arrays.stream(line.split(" ")))
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
System.out.println(counts);

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<String> stream = env.socketTextStream("localhost", 9999);

stream
    .flatMap((String line, Collector<String> out) -> {
        for (String word : line.split(" ")) out.collect(word);
    })
    .keyBy(word -> word)
    .sum(1)
    .print();

env.execute("Flink WordCount");

SparkSession spark = SparkSession.builder().appName("StreamSQL").getOrCreate();

Dataset<Row> lines = spark.readStream()
    .format("socket")
    .option("host", "localhost")
    .option("port", 9999)
    .load();

Dataset<Row> words = lines.as(Encoders.STRING())
    .flatMap((FlatMapFunction<String, String>) x -> Arrays.asList(x.split(" ")).iterator(), Encoders.STRING());

words.groupBy("value").count()
    .writeStream()
    .outputMode("complete")
    .format("console")
    .start()
    .awaitTermination();

Pipeline p = Pipeline.create();
p.apply(TextIO.read().from("input.txt"))
 .apply(ParDo.of(new DoFn<String, String>() {
     @ProcessElement
     public void processElement(ProcessContext c) {
         for (String word : c.element().split(" ")) c.output(word);
     }
 }))
 .apply(Count.perElement())
 .apply(TextIO.write().to("output"));
p.run().waitUntilFinish();

FlinkKafkaConsumer<String> consumer = new FlinkKafkaConsumer<>("logs", new SimpleStringSchema(), props);
env.addSource(consumer)
   .map(line -> line.toUpperCase())
   .addSink(new FlinkKafkaProducer<>("processed", new SimpleStringSchema(), props));

stream.keyBy(value -> value)
      .flatMap(new RichFlatMapFunction<String, Tuple2<String, Integer>>() {
          private transient ValueState<Integer> count;
          public void open(Configuration parameters) {
              count = getRuntimeContext().getState(new ValueStateDescriptor<>("count", Integer.class));
          }
          public void flatMap(String value, Collector<Tuple2<String, Integer>> out) throws Exception {
              Integer current = count.value() == null ? 0 : count.value();
              count.update(current + 1);
              out.collect(Tuple2.of(value, current + 1));
          }
      });

PipelineOptions options = PipelineOptionsFactory.create();
options.as(DataflowPipelineOptions.class).setRunner(DataflowRunner.class);

Dataset<Row> df = spark.readStream()
    .format("kafka")
    .option("kafka.bootstrap.servers", "localhost:9092")
    .option("subscribe", "topic")
    .load();

public class MyClass {
    private int field;

    public MyClass(int field) {
        this.field = field;
    }

    public void method() {
        // some code
    }
}

public abstract class AbstractClass {
    public abstract void abstractMethod();

    public void concreteMethod() {
        // some code
    }
}

public class OuterClass {
    static class StaticNestedClass {
        // some code
    }
}

public class OuterClass {
    class InnerClass {
        // some code
    }
}

public class OuterClass {
    public void method() {
        class LocalClass {
            // some code
        }
        LocalClass local = new LocalClass();
    }
}

public class OuterClass {
    public void method() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // some code
            }
        };
    }
}

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public interface MyInterface {
    void myMethod();
}

public record Point(int x, int y) {}

implementation 'org.telegram:telegrambots:6.9.7'

public class EchoBot extends TelegramLongPollingBot {
    public String getBotUsername() { return "MyJavaBot"; }
    public String getBotToken() { return "TOKEN"; }

    public void onUpdateReceived(Update u) {
        var chat = u.getMessage().getChatId().toString();
        var text = u.getMessage().getText();
        send(chat, "Ты написал: " + text);
    }

    void send(String chatId, String msg) {
        try { execute(new SendMessage(chatId, msg)); } 
        catch (Exception e) { e.printStackTrace(); }
    }
}

var bots = new TelegramBotsApi(DefaultBotSession.class);
bots.registerBot(new EchoBot());
System.out.println("Бот в деле 🚀");

Ты: ping  
Бот: Ты написал: ping

if (text.equals("/start"))
    send(chat, "Привет! Я Java-бот 💪");
else if (text.equalsIgnoreCase("время"))
    send(chat, LocalTime.now().toString());
else
    send(chat, "Команда не понята 🤖");

var markup = new InlineKeyboardMarkup();
markup.setKeyboard(List.of(List.of(
    new InlineKeyboardButton("Сказать hi").callbackData("hi")
)));
msg.setReplyMarkup(markup);

src/
 ├── Main.java
 └── EchoBot.java
build.gradle

Socket socket = new Socket("api.exchange.com", 4001);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);

out.println("SUBSCRIBE:BTC-USD");
System.out.println("Tick: " + in.readLine());

Selector selector = Selector.open();
SocketChannel channel = SocketChannel.open(new InetSocketAddress("api.exchange.com", 8080));
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_READ);

while (true) {
    selector.select();
    for (SelectionKey key : selector.selectedKeys())
        ((SocketChannel) key.channel()).read(ByteBuffer.allocate(1024));
}

HttpClient client = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build();
HttpRequest req = HttpRequest.newBuilder(URI.create("https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT")).build();
String body = client.send(req, HttpResponse.BodyHandlers.ofString()).body();
System.out.println(body);

Flux.interval(Duration.ofMillis(10))
    .flatMap(i -> fetchTick())
    .subscribe(System.out::println);

ProducerRecord<String, String> tick = new ProducerRecord<>("ticks", "BTC", json);
producer.send(tick);

Disruptor<Event> disruptor = new Disruptor<>(Event::new, 1024, Executors.defaultThreadFactory());
disruptor.handleEventsWith((event, seq, end) -> process(event));
disruptor.start();

double pnl = 0.0;
for (int i = 0; i < prices.length; i++)
    pnl += (prices[i] - avg) * weights[i];

ChronicleQueue queue = ChronicleQueue.single("trades");
ExcerptAppender appender = queue.acquireAppender();
appender.writeText("BUY BTC 1.234 @ 67900");

long t1 = System.nanoTime();
client.send(request, HttpResponse.BodyHandlers.discarding());
System.out.println("Latency: " + (System.nanoTime() - t1) / 1_000_000.0 + " ms");

CompletableFuture.supplyAsync(() -> fetch("exchangeA"))
    .exceptionally(e -> fetch("exchangeB"))
    .thenAccept(this::trade);

JsonFactory factory = new JsonFactory();
JsonParser parser = factory.createParser(stream);
while (parser.nextToken() != JsonToken.END_OBJECT)
    process(parser.getCurrentName(), parser.getValueAsString());

NtpV3Packet msg = new NtpV3Impl();
msg.setMode(3);
System.out.println("Offset: " + client.getTime(InetAddress.getByName("pool.ntp.org")).getOffset());

implementation("io.opentelemetry:opentelemetry-api:1.31.0")
implementation("io.opentelemetry:opentelemetry-sdk:1.31.0")
implementation("io.opentelemetry:opentelemetry-exporter-otlp:1.31.0")

SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
    .addSpanProcessor(BatchSpanProcessor.builder(OtlpGrpcSpanExporter.builder().build()).build())
    .build();

OpenTelemetry openTelemetry = OpenTelemetrySdk.builder()
    .setTracerProvider(tracerProvider)
    .build();

Tracer tracer = openTelemetry.getTracer("com.trading.app");
try (Scope scope = tracer.spanBuilder("DB Query").startScopedSpan()) {
    db.execute("SELECT * FROM orders");
}

Meter meter = openTelemetry.getMeter("com.trading.metrics");
LongCounter reqCount = meter.counterBuilder("http.requests.total").build();

reqCount.add(1, Attributes.of(stringKey("endpoint"), "/api/trade"));

OtlpGrpcMetricExporter exporter = OtlpGrpcMetricExporter.builder()
    .setEndpoint("http://localhost:4317")
    .build();

logger.info("order_created", kv("user", userId), kv("amount", amount));

java -javaagent:opentelemetry-javaagent.jar \
  -Dotel.service.name=order-service \
  -Dotel.exporter.otlp.endpoint=http://localhost:4317 \
  -jar app.jar

receivers:
  otlp:
    protocols:
      grpc:
      http:

exporters:
  prometheus:
  logging:
  jaeger:
    endpoint: "localhost:14250"

service:
  pipelines:
    traces: { receivers: [otlp], exporters: [jaeger, logging] }
    metrics: { receivers: [otlp], exporters: [prometheus] }

Traces → Jaeger  
Metrics → Prometheus  
Logs → Loki  

MDC.put("traceId", Span.current().getSpanContext().getTraceId());
logger.info("processing order {}", orderId);

➡️ CPU / Memory / GC Time
➡️ Request latency per endpoint
➡️ Top error spans per service
➡️ Logs correlated by traceId

try (Scope scope = tracer.spanBuilder("match_order").startScopedSpan()) {
    orderService.match(order);
}

В этом видео автор анализирует, насколько Java остаётся актуальной в 2025 году и какие изменения произошли в языке и экосистеме.
Разбираются ключевые области применения Java — от корпоративных систем и Android-разработки до backend-сервисов — и сравнивается её востребованность с другими языками программирования.

public interface MyInterface {
    default void showMessage() {
        print("Default method calling private method");
    }

    static void showStaticMessage() {
        print("Static method calling private method");
    }

    // Private method for reuse
    private static void print(String message) {
        System.out.println(message);
    }
}

class Task implements Comparable<Task> {
    String name;
    Integer priority;

    public Task(String name, Integer priority) {
        this.name = name;
        this.priority = priority;
    }

    @Override
    public int compareTo(@NotNull Task o) {
        return priority - o.priority;
    }
}

public class Test {
    public static void main(String[] args) {
        PriorityQueue<Task> pq = new PriorityQueue<>();

        pq.add(new Task("Task1", 1));
        pq.add(new Task("Task5", 5));
        pq.add(new Task("Task2", 2));
        pq.add(new Task("Task4", 4));
        pq.add(new Task("Task3", 3));

        while (!pq.isEmpty()) {
            System.out.println(pq.poll().name);
            // Выведет: Task1, Task2, Task3, Task4, Task5
        }
    }
}

syntax = "proto3";

message Order {
  string id = 1;
  double amount = 2;
  string status = 3;
}

mvn protobuf:compile

interaction:
  request:
    method: GET
    path: /orders/123
  response:
    status: 200
    body:
      id: "123"
      amount: 50.0

@Pact(consumer = "billing-service")
public RequestResponsePact pact(PactDslWithProvider builder) {
    return builder
      .given("Order exists")
      .uponReceiving("Get order by ID")
      .path("/orders/123").method("GET")
      .willRespondWith()
      .status(200)
      .body("{\"id\":\"123\",\"amount\":50.0}")
      .toPact();
}

@Provider("order-service")
@PactFolder("pacts")
public class ProviderVerificationTest {
    @TestTemplate
    @ExtendWith(PactVerificationInvocationContextProvider.class)
    void verifyPacts(PactVerificationContext context) {
        context.verifyInteraction();
    }
}

docker run -d -p 9292:9292 pactfoundation/pact-broker

mvn verify -Pcontract-tests

body:
  amount: 50.0
  currency: "USD" # новое поле, не ломает старый контракт

@SpringBootTest
@AutoConfigureStubRunner(ids = "com.demo:order-service:+:stubs:8080")
class BillingTest { ... }

implementation("org.wasmtime:wasmtime:17.0.0")

Engine engine = new Engine();
Store store = new Store(engine);
byte[] wasm = Files.readAllBytes(Paths.get("add.wasm"));
Module module = Module.fromBinary(engine, wasm);
Instance instance = new Instance(store, module, new Extern[]{});
Func add = instance.getExport(store, "add").func();
System.out.println(add.call(store, 5L, 3L));

#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

rustup target add wasm32-unknown-unknown
cargo build --target wasm32-unknown-unknown --release

WasiCtx wasiCtx = WasiCtx.builder()
    .inheritStdout()
    .inheritStderr()
    .build();
wasiCtx.define(store);

Linker linker = new Linker(engine);
Instance instance = linker.instantiate(store, module);
Func main = instance.getExport(store, "_start").func();
main.call(store);

Memory memory = instance.getExport(store, "memory").memory();
byte[] data = "Hello WASM".getBytes();
memory.write(store, 0, data);

Func process = instance.getExport(store, "process").func();
process.call(store, 0L, (long) data.length);

byte[] result = new byte[100];
memory.read(store, 100, result);
System.out.println(new String(result).trim());

#[no_mangle]
pub extern "C" fn matrix_mul(a: *const f64, b: *const f64, 
    c: *mut f64, n: usize) {
    unsafe {
        for i in 0..n {
            for j in 0..n {
                let mut sum = 0.0;
                for k in 0..n {
                    sum += (*a.add(i*n+k)) * (*b.add(k*n+j));
                }
                *c.add(i*n+j) = sum;
            }
        }
    }
}

try (Context context = Context.create("wasm")) {
    Source source = Source.newBuilder("wasm", 
        Files.readAllBytes(Paths.get("calc.wasm")), 
        "module").build();
    Value wasm = context.eval(source);
    System.out.println(wasm.getMember("add").execute(10, 20).asInt());
}

Map<String, Instance> plugins = new HashMap<>();

void loadPlugin(String name, String path) throws Exception {
    byte[] wasm = Files.readAllBytes(Paths.get(path));
    Instance instance = new Instance(new Store(new Engine()), 
        Module.fromBinary(new Engine(), wasm), new Extern[]{});
    plugins.put(name, instance);
}

String executePlugin(String name, String input) {
    Func process = plugins.get(name)
        .getExport(null, "process").func();
    return process.call(null, input).toString();
}

// Java: 2000ms на fib(40)
public static long fib(long n) {
    return n <= 1 ? n : fib(n-1) + fib(n-2);
}

// WASM: 380ms на fib(40)
#[no_mangle]
pub extern "C" fn fib(n: u64) -> u64 {
    match n { 0|1 => n, _ => fib(n-1) + fib(n-2) }
}

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

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

sdk install java 23-graal
gu install native-image

mvn -Pnative native:compile

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, native world!");
    }
}

native-image -jar app.jar
./app

Java: ~1.5s, 150MB  
Native: 0.05s, 30MB

mvn -Pnative spring-boot:build-image

[
  { "name": "com.demo.User", "allDeclaredConstructors": true }
]

mvn package -Dpackaging=native-image

FROM scratch
COPY app /
ENTRYPOINT ["/app"]

native-image --verbose --diagnostics-mode ...