[BAEL-9555] - Created a core-java-modules folder

core-java-modules/core-java-9/src/main/java/.gitignore

@@ -0,0 +1,13 @@
+*.class
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/aot/JaotCompilation.java

@@ -0,0 +1,12 @@
+package com.baeldung.java9.aot;
+
+public class JaotCompilation {
+
+    public static void main(String[] argv) {
+        System.out.println(message());
+    }
+
+    public static String message() {
+        return "The JAOT compiler says 'Hello'";
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/language/PrivateInterface.java

@@ -0,0 +1,23 @@
+package com.baeldung.java9.language;
+
+public interface PrivateInterface {
+
+    private static String staticPrivate() {
+        return "static private";
+    }
+
+    private String instancePrivate() {
+        return "instance private";
+    }
+
+    public default void check() {
+        String result = staticPrivate();
+        if (!result.equals("static private"))
+            throw new AssertionError("Incorrect result for static private interface method");
+        PrivateInterface pvt = new PrivateInterface() {
+        };
+        result = pvt.instancePrivate();
+        if (!result.equals("instance private"))
+            throw new AssertionError("Incorrect result for instance private interface method");
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/language/stream/StreamsGroupingCollectionFilter.java

@@ -0,0 +1,27 @@
+package com.baeldung.java9.language.stream;
+
+import static java.util.stream.Collectors.filtering;
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.toList;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+public class StreamsGroupingCollectionFilter {
+
+    static public Map<Integer, List<Integer>> findEvenNumbersAfterGroupingByQuantityOfDigits(Collection<Integer> baseCollection) {
+        Function<Integer, Integer> getQuantityOfDigits = item -> (int) Math.log10(item) + 1;
+
+        return baseCollection.stream()
+            .collect(groupingBy(getQuantityOfDigits, filtering(item -> item % 2 == 0, toList())));
+    }
+
+    static public Map<Integer, List<Integer>> findEvenNumbersBeforeGroupingByQuantityOfDigits(Collection<Integer> baseCollection) {
+
+        return baseCollection.stream()
+            .filter(item -> item % 2 == 0)
+            .collect(groupingBy(item -> (int) Math.log10(item) + 1, toList()));
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/maps/initialize/MapsInitializer.java

@@ -0,0 +1,33 @@
+package com.baeldung.java9.maps.initialize;
+
+import java.util.AbstractMap;
+import java.util.HashMap;
+import java.util.Map;
+
+public class MapsInitializer {
+
+    @SuppressWarnings("unused")
+    public void createMapWithMapOf() {
+        Map<String, String> emptyMap = Map.of();
+        Map<String, String> singletonMap = Map.of("key1", "value");
+        Map<String, String> map = Map.of("key1","value1", "key2", "value2");
+    }
+    
+    public void createMapWithMapEntries() {
+        Map<String, String> map = Map.ofEntries(
+            new AbstractMap.SimpleEntry<String, String>("name", "John"),
+            new AbstractMap.SimpleEntry<String, String>("city", "budapest"),
+            new AbstractMap.SimpleEntry<String, String>("zip", "000000"),
+            new AbstractMap.SimpleEntry<String, String>("home", "1231231231")
+            );
+    }
+    
+    @SuppressWarnings("unused")
+    public void createMutableMaps() {
+        Map<String, String> map = new HashMap<String, String> (Map.of("key1","value1", "key2", "value2"));
+        Map<String, String> map2 = new HashMap<String, String> ( Map.ofEntries(
+            new AbstractMap.SimpleEntry<String, String>("name", "John"),
+            new AbstractMap.SimpleEntry<String, String>("city", "budapest")));
+        
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/methodhandles/Book.java

@@ -0,0 +1,17 @@
+package com.baeldung.java9.methodhandles;
+
+public class Book {
+
+    String id;
+    String title;
+
+    public Book(String id, String title) {
+        this.id = id;
+        this.title = title;
+    }
+
+    @SuppressWarnings("unused")
+    private String formatBook() {
+        return id + " > " + title;
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/rangedates/DatesCollectionIteration.java

@@ -0,0 +1,24 @@
+package com.baeldung.java9.rangedates;
+
+import java.util.Collection;
+import java.util.Date;
+
+public class DatesCollectionIteration {
+
+    public void iteratingRangeOfDatesJava7(Collection<Date> dates) {
+
+        for (Date date : dates) {
+            processDate(date);
+        }
+    }
+
+    public void iteratingRangeOfDatesJava8(Collection<Date> dates) {
+        dates.stream()
+            .forEach(this::processDate);
+    }
+
+    private void processDate(Date date) {
+        System.out.println(date);
+    }
+
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/rangedates/RangeDatesIteration.java

@@ -0,0 +1,43 @@
+package com.baeldung.java9.rangedates;
+
+import java.time.LocalDate;
+import java.util.Calendar;
+import java.util.Date;
+
+public class RangeDatesIteration {
+
+    public void iterateBetweenDatesJava9(LocalDate startDate, LocalDate endDate) {
+
+        startDate.datesUntil(endDate)
+            .forEach(this::processDate);
+    }
+
+    public void iterateBetweenDatesJava8(LocalDate start, LocalDate end) {
+        for (LocalDate date = start; date.isBefore(end); date = date.plusDays(1)) {
+            processDate(date);
+        }
+    }
+
+    public void iterateBetweenDatesJava7(Date start, Date end) {
+        Date current = start;
+
+        while (current.before(end)) {
+            processDate(current);
+
+            Calendar calendar = Calendar.getInstance();
+            calendar.setTime(current);
+
+            calendar.add(Calendar.DATE, 1);
+
+            current = calendar.getTime();
+        }
+    }
+
+    private void processDate(LocalDate date) {
+        System.out.println(date);
+    }
+
+    private void processDate(Date date) {
+        System.out.println(date);
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/reactive/BaeldungBatchSubscriberImpl.java

@@ -0,0 +1,82 @@
+package com.baeldung.java9.reactive;
+
+import java.util.ArrayList;
+import java.util.concurrent.Flow.Subscriber;
+import java.util.concurrent.Flow.Subscription;
+
+public class BaeldungBatchSubscriberImpl<T> implements Subscriber<String> {
+    private Subscription subscription;
+    private boolean completed = false;
+    private int counter;
+    private ArrayList<String> buffer;
+    public static final int BUFFER_SIZE = 5;
+
+    public BaeldungBatchSubscriberImpl() {
+        buffer = new ArrayList<String>();
+    }
+
+    public boolean isCompleted() {
+        return completed;
+    }
+
+    public void setCompleted(boolean completed) {
+        this.completed = completed;
+    }
+
+    public int getCounter() {
+        return counter;
+    }
+
+    public void setCounter(int counter) {
+        this.counter = counter;
+    }
+
+    @Override
+    public void onSubscribe(Subscription subscription) {
+        this.subscription = subscription;
+        subscription.request(BUFFER_SIZE);
+    }
+
+    @Override
+    public void onNext(String item) {
+        buffer.add(item);
+        // if buffer is full, process the items.
+        if (buffer.size() >= BUFFER_SIZE) {
+            processBuffer();
+        }
+        //request more items.
+        subscription.request(1);
+    }
+
+    private void processBuffer() {
+        if (buffer.isEmpty())
+            return;
+        // Process all items in the buffer. Here, we just print it and sleep for 1 second.
+        System.out.print("Processed items: ");
+        buffer.stream()
+            .forEach(item -> {
+                System.out.print(" " + item);
+            });
+        System.out.println();
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        counter = counter + buffer.size();
+        buffer.clear();
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        t.printStackTrace();
+    }
+
+    @Override
+    public void onComplete() {
+        completed = true;
+        // process any remaining items in buffer before
+        processBuffer();
+        subscription.cancel();
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/reactive/BaeldungSubscriberImpl.java

@@ -0,0 +1,55 @@
+package com.baeldung.java9.reactive;
+
+import java.util.concurrent.Flow.Subscriber;
+import java.util.concurrent.Flow.Subscription;
+
+public class BaeldungSubscriberImpl<T> implements Subscriber<String> {
+    private Subscription subscription;
+    private boolean completed = false;
+    private int counter;
+
+    public boolean isCompleted() {
+        return completed;
+    }
+
+    public void setCompleted(boolean completed) {
+        this.completed = completed;
+    }
+
+    public int getCounter() {
+        return counter;
+    }
+
+    public void setCounter(int counter) {
+        this.counter = counter;
+    }
+
+    @Override
+    public void onSubscribe(Subscription subscription) {
+        this.subscription = subscription;
+        subscription.request(1);
+    }
+
+    @Override
+    public void onNext(String item) {
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        counter++;
+        System.out.println("Processed item : " + item);
+        subscription.request(1);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        t.printStackTrace();
+    }
+
+    @Override
+    public void onComplete() {
+        completed = true;
+        subscription.cancel();
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/set/UnmodifiableSet.java

@@ -0,0 +1,44 @@
+package com.baeldung.java9.set;
+
+import com.google.common.collect.ImmutableSet;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+public class UnmodifiableSet {
+
+    public static void main(String[] args) {
+
+        Set<String> set = new HashSet<>();
+        set.add("Canada");
+        set.add("USA");
+
+        coreJDK(set);
+        guavaOf();
+        copyOf(set);
+        java9Of();
+    }
+
+    private static void java9Of() {
+        Set<String> immutable = Set.of("Canada", "USA");
+        System.out.println(immutable);
+    }
+
+    private static void guavaOf() {
+        Set<String> immutable = ImmutableSet.of("Canada", "USA");
+        System.out.println(immutable);
+    }
+
+    private static void copyOf(Set<String> set) {
+        Set<String> immutable = ImmutableSet.copyOf(set);
+        set.add("Costa Rica");
+        System.out.println(immutable);
+    }
+
+    private static void coreJDK(Set<String> set) {
+        Set<String> unmodifiableSet = Collections.unmodifiableSet(set);
+        set.add("Costa Rica");
+        System.out.println(unmodifiableSet);
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/stackwalker/StackWalkerDemo.java

@@ -0,0 +1,84 @@
+package com.baeldung.java9.stackwalker;
+
+import java.lang.StackWalker.StackFrame;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class StackWalkerDemo {
+
+    public void methodOne() {
+        this.methodTwo();
+    }
+
+    public void methodTwo() {
+        this.methodThree();
+    }
+
+    public void methodThree() {
+        List<StackFrame> stackTrace = StackWalker.getInstance()
+            .walk(this::walkExample);
+
+        printStackTrace(stackTrace);
+
+        System.out.println("---------------------------------------------");
+
+        stackTrace = StackWalker.getInstance()
+            .walk(this::walkExample2);
+
+        printStackTrace(stackTrace);
+
+        System.out.println("---------------------------------------------");
+
+        String line = StackWalker.getInstance().walk(this::walkExample3);
+        System.out.println(line);
+
+        System.out.println("---------------------------------------------");
+        
+        stackTrace = StackWalker.getInstance(StackWalker.Option.SHOW_REFLECT_FRAMES)
+            .walk(this::walkExample);
+
+        printStackTrace(stackTrace);
+        
+        System.out.println("---------------------------------------------");
+        
+        Runnable r = () -> {
+            List<StackFrame> stackTrace2 = StackWalker.getInstance(StackWalker.Option.SHOW_HIDDEN_FRAMES)
+                .walk(this::walkExample);
+            printStackTrace(stackTrace2);
+        };
+        r.run();
+    }
+
+    public List<StackFrame> walkExample(Stream<StackFrame> stackFrameStream) {
+        return stackFrameStream.collect(Collectors.toList());
+    }
+
+    public List<StackFrame> walkExample2(Stream<StackFrame> stackFrameStream) {
+        return stackFrameStream.filter(frame -> frame.getClassName()
+            .contains("com.baeldung"))
+            .collect(Collectors.toList());
+    }
+
+    public String walkExample3(Stream<StackFrame> stackFrameStream) {
+        return stackFrameStream.filter(frame -> frame.getClassName()
+            .contains("com.baeldung")
+            && frame.getClassName()
+            .endsWith("Test"))
+            .findFirst()
+            .map(frame -> frame.getClassName() + "#" + frame.getMethodName() + ", Line " + frame.getLineNumber())
+            .orElse("Unknown caller");
+    }
+    
+    public void findCaller() {
+        Class<?> caller = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE).getCallerClass();
+        System.out.println(caller.getCanonicalName());
+    }
+
+    public void printStackTrace(List<StackFrame> stackTrace) {
+        for (StackFrame stackFrame : stackTrace) {
+            System.out.println(stackFrame.getClassName()
+                .toString() + "#" + stackFrame.getMethodName() + ", Line " + stackFrame.getLineNumber());
+        }
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/streams.reactive/EndSubscriber.java

@@ -0,0 +1,43 @@
+package com.baeldung.java9.streams.reactive;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.Flow.Subscriber;
+import java.util.concurrent.Flow.Subscription;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class EndSubscriber<T> implements Subscriber<T> {
+    private final AtomicInteger howMuchMessagesToConsume;
+    private Subscription subscription;
+    public List<T> consumedElements = new LinkedList<>();
+
+    public EndSubscriber(Integer howMuchMessagesToConsume) {
+        this.howMuchMessagesToConsume = new AtomicInteger(howMuchMessagesToConsume);
+    }
+
+    @Override
+    public void onSubscribe(Subscription subscription) {
+        this.subscription = subscription;
+        subscription.request(1);
+    }
+
+    @Override
+    public void onNext(T item) {
+        howMuchMessagesToConsume.decrementAndGet();
+        System.out.println("Got : " + item);
+        consumedElements.add(item);
+        if (howMuchMessagesToConsume.get() > 0) {
+            subscription.request(1);
+        }
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        t.printStackTrace();
+    }
+
+    @Override
+    public void onComplete() {
+        System.out.println("Done");
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/streams.reactive/TransformProcessor.java

@@ -0,0 +1,38 @@
+package com.baeldung.java9.streams.reactive;
+
+import java.util.concurrent.Flow;
+import java.util.concurrent.SubmissionPublisher;
+import java.util.function.Function;
+
+public class TransformProcessor<T, R> extends SubmissionPublisher<R> implements Flow.Processor<T, R> {
+
+    private Function<T, R> function;
+    private Flow.Subscription subscription;
+
+    public TransformProcessor(Function<T, R> function) {
+        super();
+        this.function = function;
+    }
+
+    @Override
+    public void onSubscribe(Flow.Subscription subscription) {
+        this.subscription = subscription;
+        subscription.request(1);
+    }
+
+    @Override
+    public void onNext(T item) {
+        submit(function.apply(item));
+        subscription.request(1);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+        t.printStackTrace();
+    }
+
+    @Override
+    public void onComplete() {
+        close();
+    }
+}  

core-java-modules/core-java-9/src/main/java/com/baeldung/multireleaseapp/App.java

@@ -0,0 +1,16 @@
+package com.baeldung.multireleaseapp;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class App {
+
+    private static final Logger logger = LoggerFactory.getLogger(App.class);
+    
+    public static void main(String[] args) throws Exception {
+        String dateToCheck = args[0];
+        boolean isLeapYear = DateHelper.checkIfLeapYear(dateToCheck);
+        logger.info("Date given " + dateToCheck + " is leap year: " + isLeapYear);
+    }
+
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/multireleaseapp/DateHelper.java

@@ -0,0 +1,22 @@
+package com.baeldung.multireleaseapp;
+
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DateHelper {
+
+    private static final Logger logger = LoggerFactory.getLogger(DateHelper.class);
+
+    public static boolean checkIfLeapYear(String dateStr) throws Exception {
+        logger.info("Checking for leap year using Java 1 calendar API");
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(new SimpleDateFormat("yyyy-MM-dd").parse(dateStr));
+        int year = cal.get(Calendar.YEAR);
+        return (new GregorianCalendar()).isLeapYear(year);
+    }
+
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/optionals/Optionals.java

@@ -0,0 +1,26 @@
+package com.baeldung.optionals;
+
+import java.util.Optional;
+
+public class Optionals {
+
+    public static <T> Optional<T> or(Optional<T> optional, Optional<T> fallback) {
+        return optional.isPresent() ? optional : fallback;
+    }
+
+    public static Optional<String> getName(Optional<String> name) {
+        return name.or(() -> getCustomMessage());
+    }
+
+    public static com.google.common.base.Optional<String> getOptionalGuavaName(com.google.common.base.Optional<String> name) {
+        return name.or(getCustomMessageGuava());
+    }
+
+    private static Optional<String> getCustomMessage() {
+        return Optional.of("Name not provided");
+    }
+
+    private static com.google.common.base.Optional<String> getCustomMessageGuava() {
+        return com.google.common.base.Optional.of("Name not provided");
+    }
+} 

core-java-modules/core-java-9/src/main/java9/com/baeldung/multireleaseapp/DateHelper.java

@@ -0,0 +1,18 @@
+package com.baeldung.multireleaseapp;
+
+import java.time.LocalDate;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DateHelper {
+
+    private static final Logger logger = LoggerFactory.getLogger(DateHelper.class);
+
+    public static boolean checkIfLeapYear(String dateStr) throws Exception {
+        logger.info("Checking for leap year using Java 9 Date Api");
+        return LocalDate.parse(dateStr)
+            .isLeapYear();
+    }
+
+}

core-java-modules/core-java-9/src/main/resources/logback.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <logger name="org.springframework" level="WARN" />
+    <logger name="org.springframework.transaction" level="WARN" />
+
+    <!-- in order to debug some marshalling issues, this needs to be TRACE -->
+    <logger name="org.springframework.web.servlet.mvc" level="WARN" />
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

core-java-modules/core-java-9/src/modules/com.baeldung.httpclient/com/baeldung/httpclient/HttpClientExample.java

@@ -0,0 +1,84 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.baeldung.httpclient;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+import jdk.incubator.http.HttpClient;
+import jdk.incubator.http.HttpRequest;
+import jdk.incubator.http.HttpRequest.BodyProcessor;
+import jdk.incubator.http.HttpResponse;
+import jdk.incubator.http.HttpResponse.BodyHandler;
+
+/**
+ *
+ * @author pkaria
+ */
+public class HttpClientExample {
+    
+    public static void main(String[] args) throws Exception {
+        httpGetRequest();
+        httpPostRequest();
+        asynchronousRequest();
+        asynchronousMultipleRequests();
+    }
+
+    public static void httpGetRequest() throws URISyntaxException, IOException, InterruptedException {
+        HttpClient client = HttpClient.newHttpClient();
+        URI httpURI = new URI("http://jsonplaceholder.typicode.com/posts/1");
+        HttpRequest request = HttpRequest.newBuilder(httpURI).GET()
+          .headers("Accept-Enconding", "gzip, deflate").build();
+        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandler.asString());
+        String responseBody = response.body();
+        int responseStatusCode = response.statusCode();
+        System.out.println(responseBody);
+    }
+
+    public static void httpPostRequest() throws URISyntaxException, IOException, InterruptedException {
+        HttpClient client = HttpClient
+                .newBuilder()
+                .build();
+        HttpRequest request = HttpRequest
+                .newBuilder(new URI("http://jsonplaceholder.typicode.com/posts"))
+                .POST(BodyProcessor.fromString("Sample Post Request"))
+                .build();
+        HttpResponse<String> response
+                = client.send(request, HttpResponse.BodyHandler.asString());
+        String responseBody = response.body();
+        System.out.println(responseBody);
+    }
+
+    public static void asynchronousRequest() throws URISyntaxException {
+        HttpClient client = HttpClient.newHttpClient();
+        URI httpURI = new URI("http://jsonplaceholder.typicode.com/posts/1");
+        HttpRequest request = HttpRequest.newBuilder(httpURI).GET().build();
+        CompletableFuture<HttpResponse<String>> futureResponse = client.sendAsync(request,
+                HttpResponse.BodyHandler.asString());
+    }
+
+    public static void asynchronousMultipleRequests() throws URISyntaxException {
+        List<URI> targets = Arrays.asList(new URI("http://jsonplaceholder.typicode.com/posts/1"), new URI("http://jsonplaceholder.typicode.com/posts/2"));
+        HttpClient client = HttpClient.newHttpClient();
+        List<CompletableFuture<File>> futures = targets
+                .stream()
+                .map(target -> client
+                .sendAsync(
+                        HttpRequest.newBuilder(target)
+                                .GET()
+                                .build(),
+                        BodyHandler.asFile(Paths.get("base", target.getPath())))
+                .thenApply(response -> response.body())
+                .thenApply(path -> path.toFile()))
+                .collect(Collectors.toList());
+    }
+}

core-java-modules/core-java-9/src/modules/com.baeldung.httpclient/module-info.java

@@ -0,0 +1,3 @@
+module com.baeldung.httpclient {   
+	requires jdk.incubator.httpclient;
+}

core-java-modules/core-java-9/src/modules/com.baeldung.logging.app/com/baeldung/logging/app/MainApp.java

@@ -0,0 +1,13 @@
+package com.baeldung.logging.app;
+
+import static java.lang.System.Logger.*;
+
+public class MainApp {
+
+    private static System.Logger LOGGER = System.getLogger("MainApp");
+
+    public static void main(String[] args) {
+        LOGGER.log(Level.ERROR, "error test");
+        LOGGER.log(Level.INFO, "info test");
+    }
+}

core-java-modules/core-java-9/src/modules/com.baeldung.logging.app/module-info.java

@@ -0,0 +1,2 @@
+module com.baeldung.logging.app {
+}

core-java-modules/core-java-9/src/modules/com.baeldung.logging.slf4j/com/baeldung/logging/slf4j/Slf4jLogger.java

@@ -0,0 +1,99 @@
+package com.baeldung.logging.slf4j;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ResourceBundle;
+
+public class Slf4jLogger implements System.Logger {
+
+    private final String name;
+    private final Logger logger;
+
+    public Slf4jLogger(String name) {
+        this.name = name;
+        logger = LoggerFactory.getLogger(name);
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public boolean isLoggable(Level level) {
+        switch (level) {
+        case OFF:
+            return false;
+        case TRACE:
+            return logger.isTraceEnabled();
+        case DEBUG:
+            return logger.isDebugEnabled();
+        case INFO:
+            return logger.isInfoEnabled();
+        case WARNING:
+            return logger.isWarnEnabled();
+        case ERROR:
+            return logger.isErrorEnabled();
+        case ALL:
+        default:
+            return true;
+        }
+    }
+
+    @Override
+    public void log(Level level, ResourceBundle bundle, String msg, Throwable thrown) {
+        if (!isLoggable(level)) {
+            return;
+        }
+
+        switch (level) {
+        case TRACE:
+            logger.trace(msg, thrown);
+            break;
+        case DEBUG:
+            logger.debug(msg, thrown);
+            break;
+        case INFO:
+            logger.info(msg, thrown);
+            break;
+        case WARNING:
+            logger.warn(msg, thrown);
+            break;
+        case ERROR:
+            logger.error(msg, thrown);
+            break;
+        case ALL:
+        default:
+            logger.info(msg, thrown);
+        }
+    }
+
+    @Override
+    public void log(Level level, ResourceBundle bundle, String format, Object... params) {
+        if (!isLoggable(level)) {
+            return;
+        }
+
+        switch (level) {
+        case TRACE:
+            logger.trace(format, params);
+            break;
+        case DEBUG:
+            logger.debug(format, params);
+            break;
+        case INFO:
+            logger.info(format, params);
+            break;
+        case WARNING:
+            logger.warn(format, params);
+            break;
+        case ERROR:
+            logger.error(format, params);
+            break;
+        case ALL:
+        default:
+            logger.info(format, params);
+        }
+    }
+}

core-java-modules/core-java-9/src/modules/com.baeldung.logging.slf4j/com/baeldung/logging/slf4j/Slf4jLoggerFinder.java

@@ -0,0 +1,8 @@
+package com.baeldung.logging.slf4j;
+
+public class Slf4jLoggerFinder extends System.LoggerFinder {
+    @Override
+    public System.Logger getLogger(String name, Module module) {
+        return new Slf4jLogger(name);
+    }
+}

core-java-modules/core-java-9/src/modules/com.baeldung.logging.slf4j/module-info.java

@@ -0,0 +1,6 @@
+module com.baeldung.logging.slf4j {
+    requires org.slf4j;
+    provides java.lang.System.LoggerFinder
+      with com.baeldung.logging.slf4j.Slf4jLoggerFinder;
+    exports com.baeldung.logging.slf4j;
+}

core-java-modules/core-java-9/src/modules/com.baeldung.logging/com/baeldung/logging/ConsoleLogger.java

@@ -0,0 +1,27 @@
+package com.baeldung.logging;
+
+import java.text.MessageFormat;
+import java.util.ResourceBundle;
+
+public class ConsoleLogger implements System.Logger {
+
+    @Override
+    public String getName() {
+        return "ConsoleLogger";
+    }
+
+    @Override
+    public boolean isLoggable(Level level) {
+        return true;
+    }
+
+    @Override
+    public void log(Level level, ResourceBundle bundle, String msg, Throwable thrown) {
+        System.out.printf("ConsoleLogger [%s]: %s - %s%n", level, msg, thrown);
+    }
+
+    @Override
+    public void log(Level level, ResourceBundle bundle, String format, Object... params) {
+        System.out.printf("ConsoleLogger [%s]: %s%n", level, MessageFormat.format(format, params));
+    }
+}

core-java-modules/core-java-9/src/modules/com.baeldung.logging/com/baeldung/logging/CustomLoggerFinder.java

@@ -0,0 +1,9 @@
+package com.baeldung.logging;
+
+public class CustomLoggerFinder extends System.LoggerFinder {
+
+    @Override
+    public System.Logger getLogger(String name, Module module) {
+        return new ConsoleLogger();
+    }
+}

core-java-modules/core-java-9/src/modules/com.baeldung.logging/module-info.java

@@ -0,0 +1,5 @@
+module com.baeldung.logging {
+    provides java.lang.System.LoggerFinder
+      with com.baeldung.logging.CustomLoggerFinder;
+    exports com.baeldung.logging;
+}

core-java-modules/core-java-9/src/modules/com.baeldung.student.client/com/baeldung/student/client/StudentClient.java

@@ -0,0 +1,16 @@
+package com.baeldung.student.client;
+
+import com.baeldung.student.service.StudentService;
+import com.baeldung.student.service.dbimpl.StudentDbService;
+import com.baeldung.student.model.Student;
+
+public class StudentClient {
+
+    public static void main(String[] args) {
+        StudentService service = new StudentDbService();
+        service.create(new Student());
+        service.read("17SS0001");
+        service.update(new Student());
+        service.delete("17SS0001");
+    }
+}