Putting it together

Combine all advanced topics into a working app.

Putting it together

In the final lesson you combine all layers. In main you will run this flow:

Apply a stream filter on log and print the count.
Compute the total severity with ExecutorService and print it.
Call describe via reflection and print the result.

These steps are all deterministic, so the output is the same every time. This shows how an advanced app is built layer by layer.

Exercise Combine the whole flow

Use the previous lesson's solution. In main add: compute log.stream().filter(e -> e.severity > 2).count() and print it. Compute the total severity with ExecutorService, get it with pool.submit(task).get() and print it. Call describe via reflection and print the result.

Show example solution

import java.util.ArrayList;
import java.util.concurrent.*;
import java.lang.reflect.*;
import java.util.stream.Collectors;

class Event {
    String type;
    int severity;
    Event(String type, int severity) {
        this.type = type;
        this.severity = severity;
    }
}

@interface Logged {
    String value();
}

class EventService {
    @Logged("audit")
    public String describe() {
        return "event-service";
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        ArrayList<Event> log = new ArrayList<>();
        log.add(new Event("info", 1));
        log.add(new Event("error", 5));
        log.add(new Event("warn", 3));
        long count = log.stream().filter(e -> e.severity > 2).count();
        ExecutorService pool = Executors.newSingleThreadExecutor();
        Callable<Integer> task = () -> {
            int sum = 0;
            for (Event e : log) sum += e.severity;
            return sum;
        };
        int total = pool.submit(task).get();
        pool.shutdown();
        EventService service = new EventService();
        Method m = EventService.class.getMethod("describe");
        String result = (String) m.invoke(service);
        System.out.println(count);
        System.out.println(total);
        System.out.println(result);
    }
}

Exercise Summary: a mini integration

Define a new Summary class. Give it a void run() method that builds an ArrayList<Event> with three events and prints stream().filter(e -> e.severity > 2).count() and the for-each total severity on separate lines. In main, call new Summary().run().

Show example solution

import java.util.ArrayList;

class Event {
    String type;
    int severity;
    Event(String type, int severity) {
        this.type = type;
        this.severity = severity;
    }
}

class Summary {
    void run() {
        ArrayList<Event> log = new ArrayList<>();
        log.add(new Event("info", 1));
        log.add(new Event("error", 5));
        log.add(new Event("warn", 3));
        long count = log.stream().filter(e -> e.severity > 2).count();
        int total = 0;
        for (Event e : log) total += e.severity;
        System.out.println(count);
        System.out.println(total);
    }
}

public class Main {
    public static void main(String[] args) {
        new Summary().run();
    }
}

Test yourself

Which layers run together in the combining lesson?
- Only Stream
- Stream, Concurrent and Reflection
- Only Concurrent
- Only Reflection
Show answer

Stream, Concurrent and Reflection — Stream, Concurrent and Reflection layers run in the same main.

Complete the Future.get call

ExecutorService pool = Executors.newSingleThreadExecutor();
Callable<Integer> task = () -> { /* toplam */ return 9; };
int total = pool.submit(task).____();

Show answer

ExecutorService pool = Executors.newSingleThreadExecutor();
Callable<Integer> task = () -> { /* toplam */ return 9; };
int total = pool.submit(task).get();

Match the project summary

Event

Model class
Stream filter

High severity events
ExecutorService

Concurrent total
@Logged

Reflection marker

Next lesson: Advanced section exam

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies