Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

libraries-data-2/src/main/java/com/baeldung/derive4j/adt/Either.java

@@ -0,0 +1,10 @@
+package com.baeldung.derive4j.adt;
+
+import org.derive4j.Data;
+
+import java.util.function.Function;
+
+@Data
+interface Either<A,B>{
+    <X> X match(Function<A, X> left, Function<B, X> right);
+}

libraries-data-2/src/main/java/com/baeldung/derive4j/lazy/LazyRequest.java

@@ -0,0 +1,21 @@
+package com.baeldung.derive4j.lazy;
+
+import org.derive4j.Data;
+import org.derive4j.Derive;
+import org.derive4j.Make;
+
+@Data(value = @Derive(
+    inClass = "{ClassName}Impl",
+    make = {Make.lazyConstructor, Make.constructors, Make.getters}
+))
+public interface LazyRequest {
+    interface Cases<R>{
+        R GET(String path);
+        R POST(String path, String body);
+        R PUT(String path, String body);
+        R DELETE(String path);
+    }
+
+    <R> R match(Cases<R> method);
+}
+

libraries-data-2/src/main/java/com/baeldung/derive4j/pattern/HTTPRequest.java

@@ -0,0 +1,15 @@
+package com.baeldung.derive4j.pattern;
+
+import org.derive4j.Data;
+
+@Data
+interface HTTPRequest {
+    interface Cases<R>{
+        R GET(String path);
+        R POST(String path, String body);
+        R PUT(String path, String body);
+        R DELETE(String path);
+    }
+
+     <R> R match(Cases<R> method);
+}

libraries-data-2/src/main/java/com/baeldung/derive4j/pattern/HTTPResponse.java

@@ -0,0 +1,19 @@
+package com.baeldung.derive4j.pattern;
+
+public class HTTPResponse {
+    private int  statusCode;
+    private String responseBody;
+
+    public int getStatusCode() {
+        return statusCode;
+    }
+
+    public String getResponseBody() {
+        return responseBody;
+    }
+
+    public HTTPResponse(int statusCode, String responseBody) {
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+    }
+}

libraries-data-2/src/main/java/com/baeldung/derive4j/pattern/HTTPServer.java

@@ -0,0 +1,17 @@
+package com.baeldung.derive4j.pattern;
+
+
+public class HTTPServer {
+    public static String GET_RESPONSE_BODY = "Success!";
+    public static String PUT_RESPONSE_BODY = "Resource Created!";
+    public static String POST_RESPONSE_BODY = "Resource Updated!";
+    public static String DELETE_RESPONSE_BODY = "Resource Deleted!";
+
+    public HTTPResponse acceptRequest(HTTPRequest request) {
+       return HTTPRequests.caseOf(request)
+                .GET((path) -> new HTTPResponse(200, GET_RESPONSE_BODY))
+                .POST((path,body) -> new HTTPResponse(201, POST_RESPONSE_BODY))
+                .PUT((path,body) -> new HTTPResponse(200, PUT_RESPONSE_BODY))
+                .DELETE(path -> new HTTPResponse(200, DELETE_RESPONSE_BODY));
+    }
+}

libraries-data-2/src/main/java/com/baeldung/flink/FlinkDataPipeline.java

@@ -0,0 +1,82 @@
+package com.baeldung.flink;
+
+
+import com.baeldung.flink.model.Backup;
+import com.baeldung.flink.model.InputMessage;
+import com.baeldung.flink.operator.BackupAggregator;
+import com.baeldung.flink.operator.InputMessageTimestampAssigner;
+import com.baeldung.flink.operator.WordsCapitalizer;
+import org.apache.flink.streaming.api.TimeCharacteristic;
+import org.apache.flink.streaming.api.datastream.DataStream;
+import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
+import org.apache.flink.streaming.api.windowing.time.Time;
+import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer011;
+import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer011;
+
+import static com.baeldung.flink.connector.Consumers.*;
+import static com.baeldung.flink.connector.Producers.*;
+
+public class FlinkDataPipeline {
+
+    public static void capitalize() throws Exception {
+        String inputTopic = "flink_input";
+        String outputTopic = "flink_output";
+        String consumerGroup = "baeldung";
+        String address = "localhost:9092";
+
+        StreamExecutionEnvironment environment =
+          StreamExecutionEnvironment.getExecutionEnvironment();
+
+        FlinkKafkaConsumer011<String> flinkKafkaConsumer =
+          createStringConsumerForTopic(inputTopic, address, consumerGroup);
+        flinkKafkaConsumer.setStartFromEarliest();
+
+        DataStream<String> stringInputStream =
+          environment.addSource(flinkKafkaConsumer);
+
+        FlinkKafkaProducer011<String> flinkKafkaProducer =
+        createStringProducer(outputTopic, address);
+
+        stringInputStream
+          .map(new WordsCapitalizer())
+          .addSink(flinkKafkaProducer);
+
+        environment.execute();
+    }
+
+public static void createBackup () throws Exception {
+    String inputTopic = "flink_input";
+    String outputTopic = "flink_output";
+    String consumerGroup = "baeldung";
+    String kafkaAddress = "localhost:9092";
+
+    StreamExecutionEnvironment environment =
+      StreamExecutionEnvironment.getExecutionEnvironment();
+
+    environment.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
+
+    FlinkKafkaConsumer011<InputMessage> flinkKafkaConsumer =
+      createInputMessageConsumer(inputTopic, kafkaAddress, consumerGroup);
+    flinkKafkaConsumer.setStartFromEarliest();
+
+    flinkKafkaConsumer
+      .assignTimestampsAndWatermarks(new InputMessageTimestampAssigner());
+    FlinkKafkaProducer011<Backup> flinkKafkaProducer =
+      createBackupProducer(outputTopic, kafkaAddress);
+
+    DataStream<InputMessage> inputMessagesStream =
+      environment.addSource(flinkKafkaConsumer);
+
+    inputMessagesStream
+      .timeWindowAll(Time.hours(24))
+      .aggregate(new BackupAggregator())
+      .addSink(flinkKafkaProducer);
+
+    environment.execute();
+}
+
+    public static void main(String[] args) throws Exception {
+        createBackup();
+    }
+
+}

libraries-data-2/src/main/java/com/baeldung/flink/LineSplitter.java

@@ -0,0 +1,18 @@
+package com.baeldung.flink;
+
+import org.apache.flink.api.common.functions.FlatMapFunction;
+import org.apache.flink.api.java.tuple.Tuple2;
+import org.apache.flink.util.Collector;
+
+import java.util.stream.Stream;
+
+@SuppressWarnings("serial")
+public class LineSplitter implements FlatMapFunction<String, Tuple2<String, Integer>> {
+
+    @Override
+    public void flatMap(String value, Collector<Tuple2<String, Integer>> out) {
+
+        String[] tokens = value.toLowerCase().split("\\W+");
+        Stream.of(tokens).filter(t -> t.length() > 0).forEach(token -> out.collect(new Tuple2<>(token, 1)));
+    }
+}

libraries-data-2/src/main/java/com/baeldung/flink/WordCount.java

@@ -0,0 +1,18 @@
+package com.baeldung.flink;
+
+import org.apache.flink.api.java.DataSet;
+import org.apache.flink.api.java.ExecutionEnvironment;
+import org.apache.flink.api.java.aggregation.Aggregations;
+import org.apache.flink.api.java.tuple.Tuple2;
+
+import java.util.List;
+
+public class WordCount {
+
+    public static DataSet<Tuple2<String, Integer>> startWordCount(ExecutionEnvironment env, List<String> lines) throws Exception {
+        DataSet<String> text = env.fromCollection(lines);
+
+        return text.flatMap(new LineSplitter()).groupBy(0).aggregate(Aggregations.SUM, 1);
+
+    }
+}

libraries-data-2/src/main/java/com/baeldung/flink/connector/Consumers.java

@@ -0,0 +1,32 @@
+package com.baeldung.flink.connector;
+
+import com.baeldung.flink.model.InputMessage;
+import com.baeldung.flink.schema.InputMessageDeserializationSchema;
+import org.apache.flink.api.common.serialization.SimpleStringSchema;
+import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer011;
+
+import java.util.Properties;
+
+public class Consumers {
+
+public static FlinkKafkaConsumer011<String> createStringConsumerForTopic(
+  String topic, String kafkaAddress, String kafkaGroup ) {
+    Properties props = new Properties();
+    props.setProperty("bootstrap.servers", kafkaAddress);
+    props.setProperty("group.id",kafkaGroup);
+    FlinkKafkaConsumer011<String> consumer =
+      new FlinkKafkaConsumer011<>(topic, new SimpleStringSchema(),props);
+
+    return consumer;
+}
+
+    public static FlinkKafkaConsumer011<InputMessage> createInputMessageConsumer(String topic, String kafkaAddress, String kafkaGroup ) {
+        Properties properties = new Properties();
+        properties.setProperty("bootstrap.servers", kafkaAddress);
+        properties.setProperty("group.id",kafkaGroup);
+        FlinkKafkaConsumer011<InputMessage> consumer = new FlinkKafkaConsumer011<InputMessage>(
+                topic, new InputMessageDeserializationSchema(),properties);
+
+        return consumer;
+    }
+}

libraries-data-2/src/main/java/com/baeldung/flink/connector/Producers.java

@@ -0,0 +1,17 @@
+package com.baeldung.flink.connector;
+
+import com.baeldung.flink.model.Backup;
+import com.baeldung.flink.schema.BackupSerializationSchema;
+import org.apache.flink.api.common.serialization.SimpleStringSchema;
+import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer011;
+
+public class Producers {
+
+    public static FlinkKafkaProducer011<String> createStringProducer(String topic, String kafkaAddress) {
+        return new FlinkKafkaProducer011<>(kafkaAddress, topic, new SimpleStringSchema());
+    }
+
+    public static FlinkKafkaProducer011<Backup> createBackupProducer(String topic, String kafkaAddress) {
+        return new FlinkKafkaProducer011<Backup>(kafkaAddress, topic, new BackupSerializationSchema());
+    }
+}

libraries-data-2/src/main/java/com/baeldung/flink/model/Backup.java

@@ -0,0 +1,27 @@
+package com.baeldung.flink.model;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+
+public class Backup {
+
+    @JsonProperty("inputMessages")
+    List<InputMessage> inputMessages;
+    @JsonProperty("backupTimestamp")
+    LocalDateTime backupTimestamp;
+    @JsonProperty("uuid")
+    UUID uuid;
+
+    public Backup(List<InputMessage> inputMessages, LocalDateTime backupTimestamp) {
+        this.inputMessages = inputMessages;
+        this.backupTimestamp = backupTimestamp;
+        this.uuid = UUID.randomUUID();
+    }
+
+    public List<InputMessage> getInputMessages() {
+        return inputMessages;
+    }
+}

libraries-data-2/src/main/java/com/baeldung/flink/model/InputMessage.java

@@ -0,0 +1,71 @@
+package com.baeldung.flink.model;
+
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.google.common.base.Objects;
+
+import java.time.LocalDateTime;
+
+@JsonSerialize
+public class InputMessage {
+    String sender;
+    String recipient;
+    LocalDateTime sentAt;
+    String message;
+
+    public InputMessage() {
+    }
+
+    public String getSender() {
+        return sender;
+    }
+    public void setSender(String sender) {
+        this.sender = sender;
+    }
+
+    public String getRecipient() {
+        return recipient;
+    }
+
+    public void setRecipient(String recipient) {
+        this.recipient = recipient;
+    }
+
+    public LocalDateTime getSentAt() {
+        return sentAt;
+    }
+
+    public void setSentAt(LocalDateTime sentAt) {
+        this.sentAt = sentAt;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public InputMessage(String sender, String recipient, LocalDateTime sentAt, String message) {
+        this.sender = sender;
+        this.recipient = recipient;
+        this.sentAt = sentAt;
+        this.message = message;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        InputMessage message1 = (InputMessage) o;
+        return Objects.equal(sender, message1.sender) &&
+                Objects.equal(recipient, message1.recipient) &&
+                Objects.equal(sentAt, message1.sentAt) &&
+                Objects.equal(message, message1.message);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(sender, recipient, sentAt, message);
+    }
+}

libraries-data-2/src/main/java/com/baeldung/flink/operator/BackupAggregator.java

@@ -0,0 +1,34 @@
+package com.baeldung.flink.operator;
+
+import com.baeldung.flink.model.Backup;
+import com.baeldung.flink.model.InputMessage;
+import org.apache.flink.api.common.functions.AggregateFunction;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+    public class BackupAggregator implements AggregateFunction<InputMessage, List<InputMessage>, Backup> {
+        @Override
+        public List<InputMessage> createAccumulator() {
+            return new ArrayList<>();
+        }
+
+        @Override
+        public List<InputMessage> add(InputMessage inputMessage, List<InputMessage> inputMessages) {
+            inputMessages.add(inputMessage);
+            return inputMessages;
+        }
+
+        @Override
+        public Backup getResult(List<InputMessage> inputMessages) {
+            Backup backup = new Backup(inputMessages, LocalDateTime.now());
+                return backup;
+        }
+
+        @Override
+        public List<InputMessage> merge(List<InputMessage> inputMessages, List<InputMessage> acc1) {
+            inputMessages.addAll(acc1);
+            return inputMessages;
+        }
+    }

libraries-data-2/src/main/java/com/baeldung/flink/operator/InputMessageTimestampAssigner.java

@@ -0,0 +1,23 @@
+package com.baeldung.flink.operator;
+
+import com.baeldung.flink.model.InputMessage;
+import org.apache.flink.streaming.api.functions.AssignerWithPunctuatedWatermarks;
+import org.apache.flink.streaming.api.watermark.Watermark;
+
+import javax.annotation.Nullable;
+import java.time.ZoneId;
+
+public class InputMessageTimestampAssigner implements AssignerWithPunctuatedWatermarks<InputMessage> {
+
+    @Override
+    public long extractTimestamp(InputMessage element, long previousElementTimestamp) {
+        ZoneId zoneId = ZoneId.systemDefault();
+        return element.getSentAt().atZone(zoneId).toEpochSecond() * 1000;
+    }
+
+    @Nullable
+    @Override
+    public Watermark checkAndGetNextWatermark(InputMessage lastElement, long extractedTimestamp) {
+        return new Watermark(extractedTimestamp - 15);
+    }
+}

libraries-data-2/src/main/java/com/baeldung/flink/operator/WordsCapitalizer.java

@@ -0,0 +1,11 @@
+package com.baeldung.flink.operator;
+
+import org.apache.flink.api.common.functions.MapFunction;
+
+public class WordsCapitalizer implements MapFunction<String, String> {
+
+    @Override
+    public String map(String s) {
+        return s.toUpperCase();
+    }
+}

libraries-data-2/src/main/java/com/baeldung/flink/schema/BackupSerializationSchema.java

@@ -0,0 +1,33 @@
+package com.baeldung.flink.schema;
+
+import com.baeldung.flink.model.Backup;
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import org.apache.flink.api.common.serialization.SerializationSchema;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class BackupSerializationSchema
+  implements SerializationSchema<Backup> {
+
+    static ObjectMapper objectMapper = new ObjectMapper().registerModule(new JavaTimeModule());
+
+    Logger logger = LoggerFactory.getLogger(BackupSerializationSchema.class);
+
+    @Override
+    public byte[] serialize(Backup backupMessage) {
+        if(objectMapper == null) {
+            objectMapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
+            objectMapper = new ObjectMapper().registerModule(new JavaTimeModule());
+        }
+        try {
+            String json = objectMapper.writeValueAsString(backupMessage);
+            return json.getBytes();
+        } catch (com.fasterxml.jackson.core.JsonProcessingException e) {
+            logger.error("Failed to parse JSON", e);
+        }
+        return new byte[0];
+    }
+}

libraries-data-2/src/main/java/com/baeldung/flink/schema/InputMessageDeserializationSchema.java

@@ -0,0 +1,32 @@
+package com.baeldung.flink.schema;
+
+import com.baeldung.flink.model.InputMessage;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import org.apache.flink.api.common.serialization.DeserializationSchema;
+import org.apache.flink.api.common.typeinfo.TypeInformation;
+
+import java.io.IOException;
+
+public class InputMessageDeserializationSchema implements
+      DeserializationSchema<InputMessage> {
+
+    static ObjectMapper objectMapper = new ObjectMapper().registerModule(new JavaTimeModule());
+
+
+    @Override
+    public InputMessage deserialize(byte[] bytes) throws IOException {
+
+        return objectMapper.readValue(bytes, InputMessage.class);
+    }
+
+    @Override
+    public boolean isEndOfStream(InputMessage inputMessage) {
+        return false;
+    }
+
+    @Override
+    public TypeInformation<InputMessage> getProducedType() {
+        return TypeInformation.of(InputMessage.class);
+    }
+}

libraries-data-2/src/main/java/com/baeldung/infinispan/CacheConfiguration.java

@@ -0,0 +1,70 @@
+package com.baeldung.infinispan;
+
+import com.baeldung.infinispan.listener.CacheListener;
+import org.infinispan.Cache;
+import org.infinispan.configuration.cache.Configuration;
+import org.infinispan.configuration.cache.ConfigurationBuilder;
+import org.infinispan.eviction.EvictionType;
+import org.infinispan.manager.DefaultCacheManager;
+import org.infinispan.transaction.LockingMode;
+import org.infinispan.transaction.TransactionMode;
+
+import java.util.concurrent.TimeUnit;
+
+public class CacheConfiguration {
+
+    public static final String SIMPLE_HELLO_WORLD_CACHE = "simple-hello-world-cache";
+    public static final String EXPIRING_HELLO_WORLD_CACHE = "expiring-hello-world-cache";
+    public static final String EVICTING_HELLO_WORLD_CACHE = "evicting-hello-world-cache";
+    public static final String PASSIVATING_HELLO_WORLD_CACHE = "passivating-hello-world-cache";
+    public static final String TRANSACTIONAL_CACHE = "transactional-cache";
+
+    public DefaultCacheManager cacheManager() {
+        return new DefaultCacheManager();
+    }
+
+    public Cache<String, Integer> transactionalCache(DefaultCacheManager cacheManager, CacheListener listener) {
+        return this.buildCache(TRANSACTIONAL_CACHE, cacheManager, listener, transactionalConfiguration());
+    }
+
+    public Cache<String, String> simpleHelloWorldCache(DefaultCacheManager cacheManager, CacheListener listener) {
+        return this.buildCache(SIMPLE_HELLO_WORLD_CACHE, cacheManager, listener, new ConfigurationBuilder().build());
+    }
+
+    public Cache<String, String> expiringHelloWorldCache(DefaultCacheManager cacheManager, CacheListener listener) {
+        return this.buildCache(EXPIRING_HELLO_WORLD_CACHE, cacheManager, listener, expiringConfiguration());
+    }
+
+    public Cache<String, String> evictingHelloWorldCache(DefaultCacheManager cacheManager, CacheListener listener) {
+        return this.buildCache(EVICTING_HELLO_WORLD_CACHE, cacheManager, listener, evictingConfiguration());
+    }
+
+    public Cache<String, String> passivatingHelloWorldCache(DefaultCacheManager cacheManager, CacheListener listener) {
+        return this.buildCache(PASSIVATING_HELLO_WORLD_CACHE, cacheManager, listener, passivatingConfiguration());
+    }
+
+    private <K, V> Cache<K, V> buildCache(String cacheName, DefaultCacheManager cacheManager, CacheListener listener, Configuration configuration) {
+
+        cacheManager.defineConfiguration(cacheName, configuration);
+        Cache<K, V> cache = cacheManager.getCache(cacheName);
+        cache.addListener(listener);
+        return cache;
+    }
+
+    private Configuration expiringConfiguration() {
+        return new ConfigurationBuilder().expiration().lifespan(1, TimeUnit.SECONDS).build();
+    }
+
+    private Configuration evictingConfiguration() {
+        return new ConfigurationBuilder().memory().evictionType(EvictionType.COUNT).size(1).build();
+    }
+
+    private Configuration passivatingConfiguration() {
+        return new ConfigurationBuilder().memory().evictionType(EvictionType.COUNT).size(1).persistence().passivation(true).addSingleFileStore().purgeOnStartup(true).location(System.getProperty("java.io.tmpdir")).build();
+    }
+
+    private Configuration transactionalConfiguration() {
+        return new ConfigurationBuilder().transaction().transactionMode(TransactionMode.TRANSACTIONAL).lockingMode(LockingMode.PESSIMISTIC).build();
+    }
+
+}

libraries-data-2/src/main/java/com/baeldung/infinispan/listener/CacheListener.java

@@ -0,0 +1,53 @@
+package com.baeldung.infinispan.listener;
+
+import org.infinispan.notifications.Listener;
+import org.infinispan.notifications.cachelistener.annotation.*;
+import org.infinispan.notifications.cachelistener.event.*;
+
+@Listener
+public class CacheListener {
+
+    @CacheEntryCreated
+    public void entryCreated(CacheEntryCreatedEvent<String, String> event) {
+        this.printLog("Adding key '" + event.getKey() + "' to cache", event);
+    }
+
+    @CacheEntryExpired
+    public void entryExpired(CacheEntryExpiredEvent<String, String> event) {
+        this.printLog("Expiring key '" + event.getKey() + "' from cache", event);
+    }
+
+    @CacheEntryVisited
+    public void entryVisited(CacheEntryVisitedEvent<String, String> event) {
+        this.printLog("Key '" + event.getKey() + "' was visited", event);
+    }
+
+    @CacheEntryActivated
+    public void entryActivated(CacheEntryActivatedEvent<String, String> event) {
+        this.printLog("Activating key '" + event.getKey() + "' on cache", event);
+    }
+
+    @CacheEntryPassivated
+    public void entryPassivated(CacheEntryPassivatedEvent<String, String> event) {
+        this.printLog("Passivating key '" + event.getKey() + "' from cache", event);
+    }
+
+    @CacheEntryLoaded
+    public void entryLoaded(CacheEntryLoadedEvent<String, String> event) {
+        this.printLog("Loading key '" + event.getKey() + "' to cache", event);
+    }
+
+    @CacheEntriesEvicted
+    public void entriesEvicted(CacheEntriesEvictedEvent<String, String> event) {
+        final StringBuilder builder = new StringBuilder();
+        event.getEntries().forEach((key, value) -> builder.append(key).append(", "));
+        System.out.println("Evicting following entries from cache: " + builder.toString());
+    }
+
+    private void printLog(String log, CacheEntryEvent event) {
+        if (!event.isPre()) {
+            System.out.println(log);
+        }
+    }
+
+}

libraries-data-2/src/main/java/com/baeldung/infinispan/repository/HelloWorldRepository.java

@@ -0,0 +1,15 @@
+package com.baeldung.infinispan.repository;
+
+public class HelloWorldRepository {
+
+    public String getHelloWorld() {
+        try {
+            System.out.println("Executing some heavy query");
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        return "Hello World!";
+    }
+
+}

libraries-data-2/src/main/java/com/baeldung/infinispan/service/HelloWorldService.java

@@ -0,0 +1,77 @@
+package com.baeldung.infinispan.service;
+
+import com.baeldung.infinispan.listener.CacheListener;
+import com.baeldung.infinispan.repository.HelloWorldRepository;
+import org.infinispan.Cache;
+
+import java.util.concurrent.TimeUnit;
+
+public class HelloWorldService {
+
+    private final HelloWorldRepository repository;
+
+    private final Cache<String, String> simpleHelloWorldCache;
+    private final Cache<String, String> expiringHelloWorldCache;
+    private final Cache<String, String> evictingHelloWorldCache;
+    private final Cache<String, String> passivatingHelloWorldCache;
+
+    public HelloWorldService(HelloWorldRepository repository, CacheListener listener, Cache<String, String> simpleHelloWorldCache, Cache<String, String> expiringHelloWorldCache, Cache<String, String> evictingHelloWorldCache,
+            Cache<String, String> passivatingHelloWorldCache) {
+
+        this.repository = repository;
+
+        this.simpleHelloWorldCache = simpleHelloWorldCache;
+        this.expiringHelloWorldCache = expiringHelloWorldCache;
+        this.evictingHelloWorldCache = evictingHelloWorldCache;
+        this.passivatingHelloWorldCache = passivatingHelloWorldCache;
+    }
+
+    public String findSimpleHelloWorld() {
+        String cacheKey = "simple-hello";
+        return simpleHelloWorldCache.computeIfAbsent(cacheKey, k -> repository.getHelloWorld());
+    }
+
+    public String findExpiringHelloWorld() {
+        String cacheKey = "expiring-hello";
+        String helloWorld = simpleHelloWorldCache.get(cacheKey);
+        if (helloWorld == null) {
+            helloWorld = repository.getHelloWorld();
+            simpleHelloWorldCache.put(cacheKey, helloWorld, 1, TimeUnit.SECONDS);
+        }
+        return helloWorld;
+    }
+
+    public String findIdleHelloWorld() {
+        String cacheKey = "idle-hello";
+        String helloWorld = simpleHelloWorldCache.get(cacheKey);
+        if (helloWorld == null) {
+            helloWorld = repository.getHelloWorld();
+            simpleHelloWorldCache.put(cacheKey, helloWorld, -1, TimeUnit.SECONDS, 10, TimeUnit.SECONDS);
+        }
+        return helloWorld;
+    }
+
+    public String findSimpleHelloWorldInExpiringCache() {
+        String cacheKey = "simple-hello";
+        String helloWorld = expiringHelloWorldCache.get(cacheKey);
+        if (helloWorld == null) {
+            helloWorld = repository.getHelloWorld();
+            expiringHelloWorldCache.put(cacheKey, helloWorld);
+        }
+        return helloWorld;
+    }
+
+    public String findEvictingHelloWorld(String key) {
+        String value = evictingHelloWorldCache.get(key);
+        if (value == null) {
+            value = repository.getHelloWorld();
+            evictingHelloWorldCache.put(key, value);
+        }
+        return value;
+    }
+
+    public String findPassivatingHelloWorld(String key) {
+        return passivatingHelloWorldCache.computeIfAbsent(key, k -> repository.getHelloWorld());
+    }
+
+}

libraries-data-2/src/main/java/com/baeldung/infinispan/service/TransactionalService.java

@@ -0,0 +1,55 @@
+package com.baeldung.infinispan.service;
+
+import org.infinispan.Cache;
+import org.springframework.util.StopWatch;
+
+import javax.transaction.TransactionManager;
+
+public class TransactionalService {
+
+    private final Cache<String, Integer> transactionalCache;
+
+    private static final String KEY = "key";
+
+    public TransactionalService(Cache<String, Integer> transactionalCache) {
+        this.transactionalCache = transactionalCache;
+
+        transactionalCache.put(KEY, 0);
+    }
+
+    public Integer getQuickHowManyVisits() {
+        try {
+            TransactionManager tm = transactionalCache.getAdvancedCache().getTransactionManager();
+            tm.begin();
+            Integer howManyVisits = transactionalCache.get(KEY);
+            howManyVisits++;
+            System.out.println("Ill try to set HowManyVisits to " + howManyVisits);
+            StopWatch watch = new StopWatch();
+            watch.start();
+            transactionalCache.put(KEY, howManyVisits);
+            watch.stop();
+            System.out.println("I was able to set HowManyVisits to " + howManyVisits + " after waiting " + watch.getTotalTimeSeconds() + " seconds");
+
+            tm.commit();
+            return howManyVisits;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return 0;
+        }
+    }
+
+    public void startBackgroundBatch() {
+        try {
+            TransactionManager tm = transactionalCache.getAdvancedCache().getTransactionManager();
+            tm.begin();
+            transactionalCache.put(KEY, 1000);
+            System.out.println("HowManyVisits should now be 1000, " + "but we are holding the transaction");
+            Thread.sleep(1000L);
+            tm.rollback();
+            System.out.println("The slow batch suffered a rollback");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}

libraries-data-2/src/main/java/com/baeldung/jmapper/User.java

@@ -0,0 +1,56 @@
+package com.baeldung.jmapper;
+
+import java.time.LocalDate;
+
+
+public class User {
+    
+    private long id;    
+    private String email;
+    private LocalDate birthDate;
+    
+    // constructors
+    
+    public User() {
+        super();
+    }
+    
+    public User(long id, String email, LocalDate birthDate) {
+        super();
+        this.id = id;
+        this.email = email;
+        this.birthDate = birthDate;
+    }
+
+    // getters and setters
+    
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public LocalDate getBirthDate() {
+        return birthDate;
+    }
+
+    public void setBirthDate(LocalDate birthDate) {
+        this.birthDate = birthDate;
+    }
+
+    @Override
+    public String toString() {
+        return "User [id=" + id + ", email=" + email + ", birthDate=" + birthDate + "]";
+    }
+    
+}

libraries-data-2/src/main/java/com/baeldung/jmapper/UserDto.java

@@ -0,0 +1,69 @@
+package com.baeldung.jmapper;
+
+import com.googlecode.jmapper.annotations.JMap;
+import com.googlecode.jmapper.annotations.JMapConversion;
+
+import java.time.LocalDate;
+import java.time.Period;
+
+public class UserDto {
+    
+    @JMap
+    private long id;
+
+    @JMap("email")
+    private String username;
+    
+    @JMap("birthDate")
+    private int age;
+
+    @JMapConversion(from={"birthDate"}, to={"age"})
+    public int conversion(LocalDate birthDate){
+        return Period.between(birthDate, LocalDate.now()).getYears();
+    }
+    
+    // constructors
+    
+    public UserDto() {
+        super();
+    }
+
+    public UserDto(long id, String username, int age) {
+        super();
+        this.id = id;
+        this.username = username;
+        this.age = age;
+    }
+
+   // getters and setters
+    
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    @Override
+    public String toString() {
+        return "UserDto [id=" + id + ", username=" + username + ", age=" + age + "]";
+    }
+    
+}

libraries-data-2/src/main/java/com/baeldung/jmapper/UserDto1.java

@@ -0,0 +1,47 @@
+package com.baeldung.jmapper;
+
+import com.googlecode.jmapper.annotations.JGlobalMap;
+
+@JGlobalMap
+public class UserDto1 {
+    
+    private long id;
+    private String email;
+    
+    
+    // constructors
+    
+    public UserDto1() {
+        super();
+    }
+
+    public UserDto1(long id, String email) {
+        super();
+        this.id = id;
+        this.email = email;
+    }
+
+   // getters and setters
+    
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    @Override
+    public String toString() {
+        return "UserDto [id=" + id + ", email=" + email + "]";
+    }
+    
+}

libraries-data-2/src/main/java/com/baeldung/jmapper/relational/User.java

@@ -0,0 +1,49 @@
+package com.baeldung.jmapper.relational;
+
+import com.googlecode.jmapper.annotations.JMap;
+
+
+public class User {
+    
+    @JMap(classes = {UserDto1.class, UserDto2.class})
+    private long id;    
+    
+    @JMap(attributes = {"username", "email"}, classes = {UserDto1.class, UserDto2.class})
+    private String email;
+    
+    // constructors
+    
+    public User() {
+        super();
+    }
+    
+    public User(long id, String email) {
+        super();
+        this.id = id;
+        this.email = email;
+    }
+
+    // getters and setters
+    
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    @Override
+    public String toString() {
+        return "User [id=" + id + ", email=" + email + "]";
+    }
+    
+}

libraries-data-2/src/main/java/com/baeldung/jmapper/relational/UserDto1.java

@@ -0,0 +1,44 @@
+package com.baeldung.jmapper.relational;
+
+
+public class UserDto1 {
+    
+    private long id;
+    private String username;
+    
+    // constructors
+    
+    public UserDto1() {
+        super();
+    }
+
+    public UserDto1(long id, String username) {
+        super();
+        this.id = id;
+        this.username = username;
+    }
+
+   // getters and setters
+    
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    @Override
+    public String toString() {
+        return "UserDto [id=" + id + ", username=" + username + "]";
+    }
+    
+}

libraries-data-2/src/main/java/com/baeldung/jmapper/relational/UserDto2.java

@@ -0,0 +1,44 @@
+package com.baeldung.jmapper.relational;
+
+
+public class UserDto2 {
+    
+    private long id;
+    private String email;
+    
+    // constructors
+    
+    public UserDto2() {
+        super();
+    }
+
+    public UserDto2(long id, String email) {
+        super();
+        this.id = id;
+        this.email = email;
+    }
+
+   // getters and setters
+    
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    @Override
+    public String toString() {
+        return "UserDto2 [id=" + id + ", email=" + email + "]";
+    }
+    
+}

libraries-data-2/src/main/java/com/baeldung/measurement/WaterTank.java

@@ -0,0 +1,26 @@
+package com.baeldung.measurement;
+
+import javax.measure.Quantity;
+import javax.measure.quantity.Volume;
+
+public class WaterTank {
+
+    private Quantity<Volume> capacityMeasure;
+    private double capacityDouble;
+
+    public void setCapacityMeasure(Quantity<Volume> capacityMeasure) {
+        this.capacityMeasure = capacityMeasure;
+    }
+
+    public void setCapacityDouble(double capacityDouble) {
+        this.capacityDouble = capacityDouble;
+    }
+
+    public Quantity<Volume> getCapacityMeasure() {
+        return capacityMeasure;
+    }
+
+    public double getCapacityDouble() {
+        return capacityDouble;
+    }
+}

libraries-data-2/src/main/java/com/baeldung/suanshu/SuanShuMath.java

@@ -0,0 +1,141 @@
+package com.baeldung.suanshu;
+
+import com.numericalmethod.suanshu.algebra.linear.matrix.doubles.Matrix;
+import com.numericalmethod.suanshu.algebra.linear.matrix.doubles.matrixtype.dense.DenseMatrix;
+import com.numericalmethod.suanshu.algebra.linear.matrix.doubles.operation.Inverse;
+import com.numericalmethod.suanshu.algebra.linear.vector.doubles.Vector;
+import com.numericalmethod.suanshu.algebra.linear.vector.doubles.dense.DenseVector;
+import com.numericalmethod.suanshu.analysis.function.polynomial.Polynomial;
+import com.numericalmethod.suanshu.analysis.function.polynomial.root.PolyRoot;
+import com.numericalmethod.suanshu.analysis.function.polynomial.root.PolyRootSolver;
+import com.numericalmethod.suanshu.number.complex.Complex;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+
+class SuanShuMath {
+
+    private static final Logger log = LoggerFactory.getLogger(SuanShuMath.class);
+
+    public static void main(String[] args) throws Exception {
+        SuanShuMath math = new SuanShuMath();
+
+        math.addingVectors();
+        math.scaleVector();
+        math.innerProductVectors();
+        math.addingIncorrectVectors();
+
+        math.addingMatrices();
+        math.multiplyMatrices();
+        math.multiplyIncorrectMatrices();
+        math.inverseMatrix();
+
+        Polynomial p = math.createPolynomial();
+        math.evaluatePolynomial(p);
+        math.solvePolynomial();
+    }
+
+    public void addingVectors() throws Exception {
+        Vector v1 = new DenseVector(new double[]{1, 2, 3, 4, 5});
+        Vector v2 = new DenseVector(new double[]{5, 4, 3, 2, 1});
+        Vector v3 = v1.add(v2);
+        log.info("Adding vectors: {}", v3);
+    }
+
+    public void scaleVector() throws Exception {
+        Vector v1 = new DenseVector(new double[]{1, 2, 3, 4, 5});
+        Vector v2 = v1.scaled(2.0);
+        log.info("Scaling a vector: {}", v2);
+    }
+
+    public void innerProductVectors() throws Exception {
+        Vector v1 = new DenseVector(new double[]{1, 2, 3, 4, 5});
+        Vector v2 = new DenseVector(new double[]{5, 4, 3, 2, 1});
+        double inner = v1.innerProduct(v2);
+        log.info("Vector inner product: {}", inner);
+    }
+
+    public void addingIncorrectVectors() throws Exception {
+        Vector v1 = new DenseVector(new double[]{1, 2, 3});
+        Vector v2 = new DenseVector(new double[]{5, 4});
+        Vector v3 = v1.add(v2);
+        log.info("Adding vectors: {}", v3);
+    }
+
+    public void addingMatrices() throws Exception {
+        Matrix m1 = new DenseMatrix(new double[][]{
+            {1, 2, 3},
+            {4, 5, 6}
+        });
+
+        Matrix m2 = new DenseMatrix(new double[][]{
+            {3, 2, 1},
+            {6, 5, 4}
+        });
+
+        Matrix m3 = m1.add(m2);
+        log.info("Adding matrices: {}", m3);
+    }
+
+    public void multiplyMatrices() throws Exception {
+        Matrix m1 = new DenseMatrix(new double[][]{
+            {1, 2, 3},
+            {4, 5, 6}
+        });
+
+        Matrix m2 = new DenseMatrix(new double[][]{
+            {1, 4},
+            {2, 5},
+            {3, 6}
+        });
+
+        Matrix m3 = m1.multiply(m2);
+        log.info("Multiplying matrices: {}", m3);
+    }
+
+    public void multiplyIncorrectMatrices() throws Exception {
+        Matrix m1 = new DenseMatrix(new double[][]{
+            {1, 2, 3},
+            {4, 5, 6}
+        });
+
+        Matrix m2 = new DenseMatrix(new double[][]{
+            {3, 2, 1},
+            {6, 5, 4}
+        });
+
+        Matrix m3 = m1.multiply(m2);
+        log.info("Multiplying matrices: {}", m3);
+    }
+
+    public void inverseMatrix() {
+        Matrix m1 = new DenseMatrix(new double[][]{
+            {1, 2},
+            {3, 4}
+        });
+
+        Inverse m2 = new Inverse(m1);
+        log.info("Inverting a matrix: {}", m2);
+        log.info("Verifying a matrix inverse: {}", m1.multiply(m2));
+    }
+
+    public Polynomial createPolynomial() {
+        return new Polynomial(new double[]{3, -5, 1});
+    }
+
+    public void evaluatePolynomial(Polynomial p) {
+        // Evaluate using a real number
+        log.info("Evaluating a polynomial using a real number: {}", p.evaluate(5));
+        // Evaluate using a complex number
+        log.info("Evaluating a polynomial using a complex number: {}", p.evaluate(new Complex(1, 2)));
+    }
+
+    public void solvePolynomial() {
+        Polynomial p = new Polynomial(new double[]{2, 2, -4});
+        PolyRootSolver solver = new PolyRoot();
+        List<? extends Number> roots = solver.solve(p);
+        log.info("Finding polynomial roots: {}", roots);
+    }
+
+}