String[] stringRef1 = new String[1];
        ((Runnable) () -> {
            stringRef1[0] = "result";
        }).run();
        System.out.println(stringRef1[0]);

        class ObjectReference<T> {
            T value;
        }

        var stringRef2 = new ObjectReference<String>();
        ((Runnable) () -> {
            stringRef2.value = "result";
        }).run();
        System.out.println(stringRef2.value);

        var thing = new Runnable() {
            int r = -1;
            @Override
            public void run() {
                r = 42;
            }
        };
        thing.run();
        System.out.println(thing.r);

    var employeesRef = new ObjectReference<List<Employee>>();
    var appointmentsRef = new ObjectReference<List<Appointment>>();
    transactionService.executeReadOnly(() -> {
      employeesRef.set(employeeRepository.queryAll());
      appointmentsRef.set(appointmentRepository.queryAll());
    });

    var employees = employeesRef.get();
    var appointments = appointmentsRef.get();

private <T extends Runnable> T executeReadOnly(final T r)
{
    // Do whatever...
    return r;
}
...
...
    var result = transactionService.executeReadOnly(new Runnable()
    {
        List<Employee> employees;
        List<Appointment> appointments;
        public void run() {
            employees = employeeRepository.queryAll();
            appointments = ppointmentRepository.queryAll();
        }
    });
    System.out.println(result.appointments);
    System.out.println(result.employees);

·>private <T extends Runnable> T executeReadOnly(final T r)
·>{
·>    // Do whatever...
·>    return r;
·>}
·>...
·>...
·>    var result = transactionService.executeReadOnly(new Runnable()
·>    {
·>        List<Employee> employees;
·>        List<Appointment> appointments;
·>        public void run() {
·>            employees = employeeRepository.queryAll();
·>            appointments = ppointmentRepository.queryAll();
·>        }
·>    });
·>    System.out.println(result.appointments);
·>    System.out.println(result.employees);

·>

    public static void main(String[] args) {
        var x = exec(() -> new Object() {
            final String a = "a";
            final int b = 2;
        });
        System.out.println(x.a);
        System.out.println(x.b);
    }

    static <T> T exec(Supplier<T> supplier) {
        return supplier.get();
    }

System.out.println(new Object()
{
    final String a = "a";
}.a);

System.out.println(Stream.of("").map( any -> "result").findFirst().get());

public class Test {
    public static <T> T executeReadOnly(Supplier<T> supplier) {
        //do something before
        var result = supplier.get();
        //do something after
        return result
    }

    public static <T> Supplier<T> wrapExecuteReadOnly(Supplier<T> supplier) {
        return () -> {
            //do something before
            var result = supplier.get();
            //do something after
            return result;
        };
    }

    public static void main() {
        var employesToAppoitments = executeReadOnly( () -> new Pair<>("resEmplouees", "retAppoitments"));
        //или так - здесь декорируемую функцию можно где сохранить и уже повторно использовать, а потом дернуть get.
        var employesToAppoitments1 = wrapExecuteReadOnly( () -> new Pair<>("resEmplouees", "retAppoitments")).get();
    }
}

M>Всё равно программист в итоге то же самое делает.

int val;
f(1, x -> val = x);
assert val == 43;
...
private void f(int p, final Consumer<Integer> c) {
    c.accept(42 + p);
}

private void f(int p, final Consumer<Integer> c) {
    if(x > 1) {
        c.accept(42 + p);
        c.accept(666 + p);
    }
}

var result = executeWithTxn(txn -> new Object(){
    final String val1 = "val1 in " + txn;
    final String val2 = "val2 in " + txn;
});
System.out.println(result.val1);
System.out.println(result.val2);

...

private <T> T executeWithTxn(final Function<String, T> action) {
    return action.apply("txnId");
}