Merge branch 'eugenp:master' into master

2021-10-13 15:27:33 +02:00
parent 3ae4d1ee76 8f79432600
commit d45a721776
378 changed files with 21853 additions and 18934 deletions
@@ -1,10 +1,10 @@
 package com.baeldung.algorithms.prim;

+import org.junit.Test;
+
 import java.util.ArrayList;
 import java.util.List;

-import org.junit.Test;
-
 public class PrimUnitTest {

    @Test
@@ -8,7 +8,9 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 public class SuffixTree {
+
    private static final Logger LOGGER = LoggerFactory.getLogger(SuffixTree.class);
+
    private static final String WORD_TERMINATION = "$";
    private static final int POSITION_UNDEFINED = -1;
    private Node root;
@@ -23,7 +25,7 @@ public class SuffixTree {
    }

    public List<String> searchText(String pattern) {
-        LOGGER.info("Searching for pattern \"{}\"", pattern);
+        LOGGER.debug("Searching for pattern \"{}\"", pattern);
        List<String> result = new ArrayList<>();
        List<Node> nodes = getAllNodesInTraversePath(pattern, root, false);

@@ -41,11 +43,11 @@ public class SuffixTree {
    }

    private void addSuffix(String suffix, int position) {
-        LOGGER.info(">>>>>>>>>>>> Adding new suffix {}", suffix);
+        LOGGER.debug(">>>>>>>>>>>> Adding new suffix {}", suffix);
        List<Node> nodes = getAllNodesInTraversePath(suffix, root, true);
        if (nodes.size() == 0) {
            addChildNode(root, suffix, position);
-            LOGGER.info("{}", printTree());
+            LOGGER.debug("{}", printTree());
        } else {
            Node lastNode = nodes.remove(nodes.size() - 1);
            String newText = suffix;
@@ -58,7 +60,7 @@ public class SuffixTree {
                newText = newText.substring(existingSuffixUptoLastNode.length());
            }
            extendNode(lastNode, newText, position);
-            LOGGER.info("{}", printTree());
+            LOGGER.debug("{}", printTree());
        }
    }

@@ -2,7 +2,6 @@ package com.baeldung.algorithms.dfs;

 import java.util.List;

-import com.baeldung.algorithms.dfs.Graph;
 import org.junit.Test;

 public class GraphUnitTest {
@@ -10,7 +10,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 public class QuadTreeSearchUnitTest {
-    
+
    private static final Logger LOGGER = LoggerFactory.getLogger(QuadTreeSearchUnitTest.class);

    private static QuadTree quadTree;
@@ -20,41 +20,41 @@ public class QuadTreeSearchUnitTest {
        Region area = new Region(0, 0, 400, 400);
        quadTree = new QuadTree(area);

-        float[][] points = new float[][] { { 21, 25 }, { 55, 53 }, { 70, 318 }, { 98, 302 }, 
+        float[][] points = new float[][] { { 21, 25 }, { 55, 53 }, { 70, 318 }, { 98, 302 },
            { 49, 229 }, { 135, 229 }, { 224, 292 }, { 206, 321 }, { 197, 258 }, { 245, 238 } };

        for (int i = 0; i < points.length; i++) {
            Point point = new Point(points[i][0], points[i][1]);
            quadTree.addPoint(point);
        }
-        LOGGER.info("\n" + quadTree.printTree(""));
-        LOGGER.info("==============================================");
+        LOGGER.debug("\n" + quadTree.printTree(""));
+        LOGGER.debug("==============================================");
    }

    @Test
    public void givenQuadTree_whenSearchingForRange_thenReturn1MatchingItem() {
        Region searchArea = new Region(200, 200, 250, 250);
        List<Point> result = quadTree.search(searchArea, null, "");
-        LOGGER.info(result.toString());
-        LOGGER.info(quadTree.printSearchTraversePath());
-       
+        LOGGER.debug(result.toString());
+        LOGGER.debug(quadTree.printSearchTraversePath());
+
        Assert.assertEquals(1, result.size());
-        Assert.assertArrayEquals(new float[] { 245, 238 }, 
+        Assert.assertArrayEquals(new float[] { 245, 238 },
            new float[]{result.get(0).getX(), result.get(0).getY() }, 0);
    }
-    
+
    @Test
    public void givenQuadTree_whenSearchingForRange_thenReturn2MatchingItems() {
        Region searchArea = new Region(0, 0, 100, 100);
        List<Point> result = quadTree.search(searchArea, null, "");
-        LOGGER.info(result.toString());
-        LOGGER.info(quadTree.printSearchTraversePath());
-        
+        LOGGER.debug(result.toString());
+        LOGGER.debug(quadTree.printSearchTraversePath());
+
        Assert.assertEquals(2, result.size());
-        Assert.assertArrayEquals(new float[] { 21, 25 }, 
+        Assert.assertArrayEquals(new float[] { 21, 25 },
            new float[]{result.get(0).getX(), result.get(0).getY() }, 0);
-        Assert.assertArrayEquals(new float[] { 55, 53 }, 
+        Assert.assertArrayEquals(new float[] { 55, 53 },
            new float[]{result.get(1).getX(), result.get(1).getY() }, 0);
-        
+
    }
 }
@@ -10,7 +10,6 @@
        <groupId>com.baeldung</groupId>
        <version>1.0.0-SNAPSHOT</version>
        <artifactId>annotations</artifactId>
-        <relativePath>../</relativePath>
    </parent>

    <dependencies>
@@ -10,7 +10,6 @@
        <groupId>com.baeldung</groupId>
        <artifactId>annotations</artifactId>
        <version>1.0.0-SNAPSHOT</version>
-        <relativePath>../</relativePath>
    </parent>

    <dependencies>
@@ -3,7 +3,7 @@
 This module contains articles about Apache Kafka.

 ### Relevant articles
- [Kafka Streams vs Kafka Consumer](https://www.baeldung.com/java-kafka-streams-vs-kafka-consumer)
+- [Kafka Streams vs. Kafka Consumer](https://www.baeldung.com/java-kafka-streams-vs-kafka-consumer)
 - [Kafka Topic Creation Using Java](https://www.baeldung.com/kafka-topic-creation)
 - [Using Kafka MockConsumer](https://www.baeldung.com/kafka-mockconsumer)
 - [Using Kafka MockProducer](https://www.baeldung.com/kafka-mockproducer)
@@ -161,6 +161,12 @@
            <artifactId>spark-cassandra-connector-java_2.11</artifactId>
            <version>${com.datastax.spark.spark-cassandra-connector-java.version}</version>
        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
    </dependencies>

    <properties>
@@ -175,6 +181,7 @@
        <graphframes.version>0.8.1-spark3.0-s_2.12</graphframes.version>
        <com.datastax.spark.spark-cassandra-connector.version>2.5.2</com.datastax.spark.spark-cassandra-connector.version>
        <com.datastax.spark.spark-cassandra-connector-java.version>1.6.0-M1</com.datastax.spark.spark-cassandra-connector-java.version>
+        <lombok.version>1.18.20</lombok.version>
    </properties>

 </project>
@@ -0,0 +1,15 @@
+package com.baeldung.kafka.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Builder
+public class MessageDto {
+    private String message;
+    private String version;
+}
@@ -0,0 +1,35 @@
+package com.baeldung.kafka.serdes;
+
+import com.baeldung.kafka.dto.MessageDto;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.kafka.common.errors.SerializationException;
+import org.apache.kafka.common.serialization.Deserializer;
+
+import java.util.Map;
+
+public class CustomDeserializer implements Deserializer<MessageDto> {
+
+    private ObjectMapper objectMapper = new ObjectMapper();
+
+    @Override
+    public void configure(Map<String, ?> configs, boolean isKey) {
+    }
+
+    @Override
+    public MessageDto deserialize(String topic, byte[] data) {
+        try {
+            if (data == null){
+                System.out.println("Null received at deserializing");
+                return null;
+            }
+            System.out.println("Deserializing...");
+            return objectMapper.readValue(new String(data, "UTF-8"), MessageDto.class);
+        } catch (Exception e) {
+            throw new SerializationException("Error when deserializing byte[] to MessageDto");
+        }
+    }
+
+    @Override
+    public void close() {
+    }
+}
@@ -0,0 +1,34 @@
+package com.baeldung.kafka.serdes;
+
+import com.baeldung.kafka.dto.MessageDto;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.kafka.common.errors.SerializationException;
+import org.apache.kafka.common.serialization.Serializer;
+
+import java.util.Map;
+
+public class CustomSerializer implements Serializer<MessageDto> {
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    @Override
+    public void configure(Map<String, ?> configs, boolean isKey) {
+    }
+
+    @Override
+    public byte[] serialize(String topic, MessageDto data) {
+        try {
+            if (data == null){
+                System.out.println("Null received at serializing");
+                return null;
+            }
+            System.out.println("Serializing...");
+            return objectMapper.writeValueAsBytes(data);
+        } catch (Exception e) {
+            throw new SerializationException("Error when serializing MessageDto to byte[]");
+        }
+    }
+
+    @Override
+    public void close() {
+    }
+}
@@ -12,8 +12,10 @@ import java.util.Properties;

 import static org.assertj.core.api.Assertions.assertThat;

+// This live test needs a running Docker instance so that a kafka container can be created 
+
@Testcontainers
-class KafkaTopicApplicationIntegrationTest {
+class KafkaTopicApplicationLiveTest {

    @Container
    private static final KafkaContainer KAFKA_CONTAINER = new KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:5.4.3"));
@@ -0,0 +1,94 @@
+package com.baeldung.kafka.serdes;
+
+import com.baeldung.kafka.dto.MessageDto;
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.clients.producer.KafkaProducer;
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.junit.Before;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.testcontainers.containers.KafkaContainer;
+import org.testcontainers.utility.DockerImageName;
+
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.Properties;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.junit.Assert.assertEquals;
+
+// This live test needs a Docker instance running so that kafka container can be created
+
+public class KafkaSerDesLiveTest {
+    private static final String CONSUMER_APP_ID = "consumer_id";
+    private static final String CONSUMER_GROUP_ID = "group_id";
+
+    @ClassRule
+    public static KafkaContainer kafka = new KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:5.4.3"));
+    private final String TOPIC = "mytopic";
+
+    private static KafkaConsumer<String, MessageDto> createKafkaConsumer() {
+
+        Properties props = new Properties();
+        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, kafka.getBootstrapServers());
+        props.put(ConsumerConfig.CLIENT_ID_CONFIG, CONSUMER_APP_ID);
+        props.put(ConsumerConfig.GROUP_ID_CONFIG, CONSUMER_GROUP_ID);
+        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
+        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
+        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "com.baeldung.kafka.serdes.CustomDeserializer");
+
+        return new KafkaConsumer<>(props);
+
+    }
+
+    private static KafkaProducer<String, MessageDto> createKafkaProducer() {
+
+        Properties props = new Properties();
+        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, kafka.getBootstrapServers());
+        props.put(ProducerConfig.CLIENT_ID_CONFIG, CONSUMER_APP_ID);
+        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
+        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "com.baeldung.kafka.serdes.CustomSerializer");
+
+        return new KafkaProducer(props);
+
+    }
+
+    @Before
+    public void setUp() {
+    }
+
+    @Test
+    public void givenKafkaClientShouldSerializeAndDeserialize() throws InterruptedException {
+
+        MessageDto msgProd = MessageDto.builder().message("test").version("1.0").build();
+
+        KafkaProducer<String, MessageDto> producer = createKafkaProducer();
+        producer.send(new ProducerRecord<String, MessageDto>(TOPIC, "1", msgProd));
+        System.out.println("Message sent " + msgProd);
+        producer.close();
+
+        Thread.sleep(2000);
+
+        AtomicReference<MessageDto> msgCons = new AtomicReference<>();
+
+        KafkaConsumer<String, MessageDto> consumer = createKafkaConsumer();
+        consumer.subscribe(Arrays.asList(TOPIC));
+
+        ConsumerRecords<String, MessageDto> records = consumer.poll(Duration.ofSeconds(1));
+        records.forEach(record -> {
+            msgCons.set(record.value());
+            System.out.println("Message received " + record.value());
+        });
+
+        consumer.close();
+
+        assertEquals(msgProd, msgCons.get());
+
+    }
+
+}
+
+
@@ -44,6 +44,8 @@ import static org.apache.kafka.clients.consumer.ConsumerConfig.BOOTSTRAP_SERVERS
 import static org.apache.kafka.clients.producer.ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG;
 import static org.apache.kafka.clients.producer.ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG;

+// This live test needs a Docker instance running so that kafka container can be created
+
 public class KafkaStreamsLiveTest {
    private final String LEFT_TOPIC = "left-stream-topic";
    private final String RIGHT_TOPIC = "right-stream-topic";
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<Configuration status="WARN">
+    <Appenders>
+        <Console name="Console" target="SYSTEM_OUT">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
+        </Console>
+    </Appenders>
+    <Loggers>
+        <Logger name="org.apache.meecrowave" level="warn">
+            <AppenderRef ref="Console"/>
+        </Logger>
+
+        <Root level="info">
+            <AppenderRef ref="Console"/>
+        </Root>
+    </Loggers>
+</Configuration>
@@ -0,0 +1,42 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# Set everything to be logged to the console
+log4j.rootCategory=WARN, console
+log4j.appender.console=org.apache.log4j.ConsoleAppender
+log4j.appender.console.target=System.err
+log4j.appender.console.layout=org.apache.log4j.PatternLayout
+log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n
+
+# Set the default spark-shell log level to WARN. When running the spark-shell, the
+# log level for this class is used to overwrite the root logger's log level, so that
+# the user can have different defaults for the shell and regular Spark apps.
+log4j.logger.org.apache.spark.repl.Main=WARN
+
+# Settings to quiet third party logs that are too verbose
+log4j.logger.org.spark_project.jetty=WARN
+log4j.logger.org.spark_project.jetty.util.component.AbstractLifeCycle=ERROR
+log4j.logger.org.apache.spark.repl.SparkIMain$exprTyper=INFO
+log4j.logger.org.apache.spark.repl.SparkILoop$SparkILoopInterpreter=INFO
+
+# SPARK-9183: Settings to avoid annoying messages when looking up nonexistent UDFs in SparkSQL with Hive support
+log4j.logger.org.apache.hadoop.hive.metastore.RetryingHMSHandler=FATAL
+log4j.logger.org.apache.hadoop.hive.ql.exec.FunctionRegistry=ERROR
+
+# Parquet related logging
+log4j.logger.org.apache.parquet.CorruptStatistics=ERROR
+log4j.logger.parquet.CorruptStatistics=ERROR
@@ -6,7 +6,7 @@ This module contains articles about Amazon Web Services (AWS)

 - [AWS Lambda Using DynamoDB With Java](https://www.baeldung.com/aws-lambda-dynamodb-java)
 - [AWS S3 with Java](https://www.baeldung.com/aws-s3-java)
- [AWS Lambda With Java](https://www.baeldung.com/java-aws-lambda)
+- [A Basic AWS Lambda Example With Java](https://www.baeldung.com/java-aws-lambda)
 - [Managing EC2 Instances in Java](https://www.baeldung.com/ec2-java)
 - [Multipart Uploads in Amazon S3 with Java](https://www.baeldung.com/aws-s3-multipart-upload)
 - [Integration Testing with a Local DynamoDB Instance](https://www.baeldung.com/dynamodb-local-integration-tests)
@@ -6,3 +6,4 @@ This module contains articles about Axon

 - [A Guide to the Axon Framework](https://www.baeldung.com/axon-cqrs-event-sourcing)
 - [Multi-Entity Aggregates in Axon](https://www.baeldung.com/java-axon-multi-entity-aggregates)
+- [Snapshotting Aggregates in Axon](https://www.baeldung.com/axon-snapshotting-aggregates)
@@ -0,0 +1,18 @@
+package com.baeldung.axon;
+
+import org.axonframework.eventsourcing.EventCountSnapshotTriggerDefinition;
+import org.axonframework.eventsourcing.SnapshotTriggerDefinition;
+import org.axonframework.eventsourcing.Snapshotter;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class OrderApplicationConfiguration {
+
+    @Bean
+    public SnapshotTriggerDefinition orderAggregateSnapshotTriggerDefinition(Snapshotter snapshotter,
+                                                                             @Value("${axon.aggregate.order.snapshot-threshold:250}") int threshold) {
+        return new EventCountSnapshotTriggerDefinition(snapshotter, threshold);
+    }
+}
@@ -23,7 +23,7 @@ import java.util.Map;

 import static org.axonframework.modelling.command.AggregateLifecycle.apply;

-@Aggregate
+@Aggregate(snapshotTriggerDefinition = "orderAggregateSnapshotTriggerDefinition")
 public class OrderAggregate {

    @AggregateIdentifier
@@ -8,3 +8,4 @@ This module contains articles about Java 11 core features
 - [Guide to Java 8’s Collectors](https://www.baeldung.com/java-8-collectors)
 - [New Features in Java 11](https://www.baeldung.com/java-11-new-features)
 - [Getting the Java Version at Runtime](https://www.baeldung.com/get-java-version-runtime)
+- [Invoking a SOAP Web Service in Java](https://www.baeldung.com/java-soap-web-service)
@@ -2,3 +2,6 @@

 - [Collect a Java Stream to an Immutable Collection](https://www.baeldung.com/java-stream-immutable-collection)
 - [Guide to mapMulti in Stream API](https://www.baeldung.com/java-mapmulti)
+- [Collecting Stream Elements into a List in Java](https://www.baeldung.com/java-stream-to-list-collecting)
+- [New Features in Java 16](https://www.baeldung.com/java-16-new-features)
+- [Guide to Java 8 groupingBy Collector](https://www.baeldung.com/java-groupingby-collector)
@@ -28,6 +28,18 @@
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>
+		<dependency>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter-engine</artifactId>
+			<version>${junit-jupiter.version}</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter-api</artifactId>
+			<version>${junit-jupiter.version}</version>
+			<scope>test</scope>
+		</dependency>
    </dependencies>

    <build>
@@ -37,17 +49,38 @@
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven-compiler-plugin.version}</version>
                <configuration>
+                    <release>${maven.compiler.release}</release>
+					<compilerArgs>--enable-preview</compilerArgs>
                    <source>${maven.compiler.source.version}</source>
                    <target>${maven.compiler.target.version}</target>
                </configuration>
            </plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>${surefire.plugin.version}</version>
+				<configuration>
+					<argLine>--enable-preview</argLine>
+					<forkCount>1</forkCount>
+				</configuration>
+				<dependencies>
+					<dependency>
+						<groupId>org.apache.maven.surefire</groupId>
+						<artifactId>surefire-api</artifactId>
+						<version>${surefire.plugin.version}</version>
+					</dependency>
+				</dependencies>
+			</plugin>
        </plugins>
    </build>

    <properties>
        <maven.compiler.source.version>16</maven.compiler.source.version>
        <maven.compiler.target.version>16</maven.compiler.target.version>
-        <assertj.version>3.6.1</assertj.version>
+		<maven.compiler.release>16</maven.compiler.release>
+		<maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
+		<surefire.plugin.version>3.0.0-M5</surefire.plugin.version>
+		<assertj.version>3.17.2</assertj.version>
    </properties>

 </project>
@@ -0,0 +1,7 @@
+package com.baeldung.features;
+
+interface HelloWorld {
+    default String hello() {
+        return "world";
+    }
+}
@@ -0,0 +1,9 @@
+package com.baeldung.features;
+
+import com.baeldung.features.record.Book;
+
+public class OuterClass {
+    class InnerClass {
+        Book book = new Book("Title", "author", "isbn");
+    }
+}
@@ -0,0 +1,23 @@
+package com.baeldung.features;
+
+import jdk.incubator.vector.IntVector;
+
+public class VectorExample {
+    public int[] scalarComputation(int[] a, int[] b) {
+        var c = new int[a.length];
+        for (int i = 0; i < a.length; i++) {
+            c[i] = a[i] * b[i];
+        }
+        return c;
+    }
+
+    public int[] vectorComputation(int[] a, int[] b) {
+        var c = new int[a.length];
+
+        var vectorA = IntVector.fromArray(IntVector.SPECIES_128, a, 0);
+        var vectorB = IntVector.fromArray(IntVector.SPECIES_128, b, 0);
+        var vectorC = vectorA.mul(vectorB);
+        vectorC.intoArray(c, 0);
+        return c;
+    }
+}
@@ -0,0 +1,44 @@
+package com.baeldung.features.model;
+
+import java.util.Objects;
+
+public final class Book {
+    private final String title;
+    private final String author;
+    private final String isbn;
+
+    public Book(String title, String author, String isbn) {
+        this.title = title;
+        this.author = author;
+        this.isbn = isbn;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public String getAuthor() {
+        return author;
+    }
+
+    public String getIsbn() {
+        return isbn;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Book book = (Book) o;
+        return Objects.equals(title, book.title) && Objects.equals(author, book.author) && Objects.equals(isbn, book.isbn);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(title, author, isbn);
+    }
+}
@@ -0,0 +1,4 @@
+package com.baeldung.features.record;
+
+public record Book(String title, String author, String isbn) {
+}
@@ -0,0 +1,4 @@
+package com.baeldung.features.sealed;
+
+public sealed interface JungleAnimal permits Monkey, Snake  {
+}
@@ -0,0 +1,4 @@
+package com.baeldung.features.sealed;
+
+public final class Monkey implements JungleAnimal {
+}
--- a/Show More
+++ b/Show More