implements Serializable {
+ private T id;
+ private String name;
+}
diff --git a/dao-factory/src/main/java/com/iluwatar/daofactory/CustomerDAO.java b/dao-factory/src/main/java/com/iluwatar/daofactory/CustomerDAO.java
new file mode 100644
index 000000000000..34316b4c49af
--- /dev/null
+++ b/dao-factory/src/main/java/com/iluwatar/daofactory/CustomerDAO.java
@@ -0,0 +1,85 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * The Data Access Object (DAO) pattern provides an abstraction layer between the application and
+ * the database. It encapsulates data access logic, allowing the application to work with domain
+ * objects instead of direct database operations.
+ *
+ * Implementations handle specific storage mechanisms (e.g., in-memory, databases) while keeping
+ * client code unchanged.
+ *
+ * @see H2CustomerDAO
+ * @see MongoCustomerDAO
+ * @see FlatFileCustomerDAO
+ */
+public interface CustomerDAO {
+ /**
+ * Persist the given customer
+ *
+ * @param customer the customer to persist
+ */
+ void save(Customer customer);
+
+ /**
+ * Update the given customer
+ *
+ * @param customer the customer to update
+ */
+ void update(Customer customer);
+
+ /**
+ * Delete the customer with the given id
+ *
+ * @param id the id of the customer to delete
+ */
+ void delete(T id);
+
+ /**
+ * Find all customers
+ *
+ * @return a list of customers
+ */
+ List> findAll();
+
+ /**
+ * Find the customer with the given id
+ *
+ * @param id the id of the customer to find
+ * @return the customer with the given id
+ */
+ Optional> findById(T id);
+
+ /**
+ * Delete the customer schema. After executing the statements, this function will be called to
+ * clean up the data and delete the records.
+ */
+ void deleteSchema();
+}
diff --git a/dao-factory/src/main/java/com/iluwatar/daofactory/DAOFactory.java b/dao-factory/src/main/java/com/iluwatar/daofactory/DAOFactory.java
new file mode 100644
index 000000000000..e7d33186bec5
--- /dev/null
+++ b/dao-factory/src/main/java/com/iluwatar/daofactory/DAOFactory.java
@@ -0,0 +1,45 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+/**
+ * An abstract factory class that provides a way to create concrete DAO (Data Access Object)
+ * factories for different data sources types (e.g., H2, Mongo, FlatFile).
+ *
+ * This class follows the Abstract Factory design pattern, allowing applications to retrieve the
+ * approriate DAO implementation without being tightly coupled to a specific data source.
+ *
+ * @see H2DataSourceFactory
+ * @see MongoDataSourceFactory
+ * @see FlatFileDataSourceFactory
+ */
+public abstract class DAOFactory {
+ /**
+ * Retrieves a {@link CustomerDAO} implementation specific to the underlying data source..
+ *
+ * @return A data source-specific implementation of {@link CustomerDAO}
+ */
+ public abstract CustomerDAO createCustomerDAO();
+}
diff --git a/dao-factory/src/main/java/com/iluwatar/daofactory/DAOFactoryProvider.java b/dao-factory/src/main/java/com/iluwatar/daofactory/DAOFactoryProvider.java
new file mode 100644
index 000000000000..08585622d00d
--- /dev/null
+++ b/dao-factory/src/main/java/com/iluwatar/daofactory/DAOFactoryProvider.java
@@ -0,0 +1,62 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+/**
+ * {@code DAOFactoryProvider} is a utility class responsible for providing concrete implementations
+ * of the {@link DAOFactory} interface based on the specified data source type.
+ *
+ *
This class acts as an entry point to obtain DAO factories for different storage mechanisms
+ * such as relational databases (e.g., H2), document stores (e.g., MongoDB), or file-based systems.
+ * It uses the {@link DataSourceType} enumeration to determine which concrete factory to
+ * instantiate.
+ *
+ *
Example usage:
+ *
+ *
{@code
+ * DAOFactory factory = DAOFactoryProvider.getDataSource(DataSourceType.H2);
+ * }
+ */
+public class DAOFactoryProvider {
+
+ private DAOFactoryProvider() {}
+
+ /**
+ * Returns a concrete {@link DAOFactory} intance based on the specified data source type.
+ *
+ * @param dataSourceType The type of data source for which a factory is needed. Supported values:
+ * {@code H2}, {@code Mongo}, {@code FlatFile}
+ * @return A {@link DAOFactory} implementation corresponding to the given data source type.
+ * @throws IllegalArgumentException if the given data source type is not supported.
+ */
+ public static DAOFactory getDataSource(DataSourceType dataSourceType) {
+ return switch (dataSourceType) {
+ case H2 -> new H2DataSourceFactory();
+ case MONGO -> new MongoDataSourceFactory();
+ case FLAT_FILE -> new FlatFileDataSourceFactory();
+ default -> throw new IllegalArgumentException("Unsupported data source type");
+ };
+ }
+}
diff --git a/dao-factory/src/main/java/com/iluwatar/daofactory/DataSourceType.java b/dao-factory/src/main/java/com/iluwatar/daofactory/DataSourceType.java
new file mode 100644
index 000000000000..da01d451f09e
--- /dev/null
+++ b/dao-factory/src/main/java/com/iluwatar/daofactory/DataSourceType.java
@@ -0,0 +1,32 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+/** Enumerates the types of data sources supported by the application. */
+public enum DataSourceType {
+ H2,
+ MONGO,
+ FLAT_FILE
+}
diff --git a/dao-factory/src/main/java/com/iluwatar/daofactory/FlatFileCustomerDAO.java b/dao-factory/src/main/java/com/iluwatar/daofactory/FlatFileCustomerDAO.java
new file mode 100644
index 000000000000..8f1f1f144f77
--- /dev/null
+++ b/dao-factory/src/main/java/com/iluwatar/daofactory/FlatFileCustomerDAO.java
@@ -0,0 +1,175 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+import java.lang.reflect.Type;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Optional;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * A Flat File implementation of {@link CustomerDAO}, which store the customer data in a JSON file
+ * at path {@code ~/Desktop/customer.json}.
+ */
+@Slf4j
+@RequiredArgsConstructor
+public class FlatFileCustomerDAO implements CustomerDAO {
+ private final Path filePath;
+ private final Gson gson;
+ Type customerListType = new TypeToken>>() {}.getType();
+
+ protected Reader createReader(Path filePath) throws IOException {
+ return new FileReader(filePath.toFile());
+ }
+
+ protected Writer createWriter(Path filePath) throws IOException {
+ return new FileWriter(filePath.toFile());
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public void save(Customer customer) {
+ List> customers = new LinkedList<>();
+ if (filePath.toFile().exists()) {
+ try (Reader reader = createReader(filePath)) {
+ customers = gson.fromJson(reader, customerListType);
+ } catch (IOException ex) {
+ throw new CustomException("Failed to read customer data", ex);
+ }
+ }
+ customers.add(customer);
+ try (Writer writer = createWriter(filePath)) {
+ gson.toJson(customers, writer);
+ } catch (IOException ex) {
+ throw new CustomException("Failed to write customer data", ex);
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public void update(Customer customer) {
+ if (!filePath.toFile().exists()) {
+ throw new CustomException("File not found");
+ }
+ List> customers;
+ try (Reader reader = createReader(filePath)) {
+ customers = gson.fromJson(reader, customerListType);
+ } catch (IOException ex) {
+ throw new CustomException("Failed to read customer data", ex);
+ }
+ customers.stream()
+ .filter(c -> c.getId().equals(customer.getId()))
+ .findFirst()
+ .ifPresentOrElse(
+ c -> c.setName(customer.getName()),
+ () -> {
+ throw new CustomException("Customer not found with id: " + customer.getId());
+ });
+ try (Writer writer = createWriter(filePath)) {
+ gson.toJson(customers, writer);
+ } catch (IOException ex) {
+ throw new CustomException("Failed to write customer data", ex);
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public void delete(Long id) {
+ if (!filePath.toFile().exists()) {
+ throw new CustomException("File not found");
+ }
+ List> customers;
+ try (Reader reader = createReader(filePath)) {
+ customers = gson.fromJson(reader, customerListType);
+ } catch (IOException ex) {
+ throw new CustomException("Failed to read customer data", ex);
+ }
+ Customer customerToRemove =
+ customers.stream()
+ .filter(c -> c.getId().equals(id))
+ .findFirst()
+ .orElseThrow(() -> new CustomException("Customer not found with id: " + id));
+ customers.remove(customerToRemove);
+ try (Writer writer = createWriter(filePath)) {
+ gson.toJson(customers, writer);
+ } catch (IOException ex) {
+ throw new CustomException("Failed to write customer data", ex);
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public List> findAll() {
+ if (!filePath.toFile().exists()) {
+ throw new CustomException("File not found");
+ }
+ List> customers;
+ try (Reader reader = createReader(filePath)) {
+ customers = gson.fromJson(reader, customerListType);
+ } catch (IOException ex) {
+ throw new CustomException("Failed to read customer data", ex);
+ }
+ return customers;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public Optional> findById(Long id) {
+ if (!filePath.toFile().exists()) {
+ throw new CustomException("File not found");
+ }
+ List> customers = null;
+ try (Reader reader = createReader(filePath)) {
+ customers = gson.fromJson(reader, customerListType);
+ } catch (IOException ex) {
+ throw new CustomException("Failed to read customer data", ex);
+ }
+ return customers.stream().filter(c -> c.getId().equals(id)).findFirst();
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public void deleteSchema() {
+ if (!filePath.toFile().exists()) {
+ throw new CustomException("File not found");
+ }
+ try {
+ Files.delete(filePath);
+ } catch (IOException ex) {
+ throw new CustomException("Failed to delete customer data");
+ }
+ }
+}
diff --git a/dao-factory/src/main/java/com/iluwatar/daofactory/FlatFileDataSourceFactory.java b/dao-factory/src/main/java/com/iluwatar/daofactory/FlatFileDataSourceFactory.java
new file mode 100644
index 000000000000..f423376703b5
--- /dev/null
+++ b/dao-factory/src/main/java/com/iluwatar/daofactory/FlatFileDataSourceFactory.java
@@ -0,0 +1,43 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+/** FlatFileDataSourceFactory concrete factory. */
+public class FlatFileDataSourceFactory extends DAOFactory {
+ private static final String FILE_PATH =
+ System.getProperty("user.home") + "/Desktop/customer.json";
+
+ @Override
+ public CustomerDAO createCustomerDAO() {
+ Path filePath = Paths.get(FILE_PATH);
+ Gson gson = new GsonBuilder().setPrettyPrinting().serializeNulls().create();
+ return new FlatFileCustomerDAO(filePath, gson);
+ }
+}
diff --git a/dao-factory/src/main/java/com/iluwatar/daofactory/H2CustomerDAO.java b/dao-factory/src/main/java/com/iluwatar/daofactory/H2CustomerDAO.java
new file mode 100644
index 000000000000..fe027426391c
--- /dev/null
+++ b/dao-factory/src/main/java/com/iluwatar/daofactory/H2CustomerDAO.java
@@ -0,0 +1,179 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import javax.sql.DataSource;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * An implementation of {@link CustomerDAO} that uses H2 database (http://www.h2database.com/) which
+ * is an in-memory database and data will lost after application exits.
+ */
+@Slf4j
+@RequiredArgsConstructor
+public class H2CustomerDAO implements CustomerDAO {
+ private final DataSource dataSource;
+ private static final String INSERT_CUSTOMER = "INSERT INTO customer(id, name) VALUES (?, ?)";
+ private static final String UPDATE_CUSTOMER = "UPDATE customer SET name = ? WHERE id = ?";
+ private static final String DELETE_CUSTOMER = "DELETE FROM customer WHERE id = ?";
+ private static final String SELECT_CUSTOMER_BY_ID =
+ "SELECT customer.id, customer.name FROM customer WHERE id= ?";
+ private static final String SELECT_ALL_CUSTOMERS = "SELECT customer.* FROM customer";
+ private static final String CREATE_SCHEMA =
+ "CREATE TABLE IF NOT EXISTS customer (id BIGINT PRIMARY KEY, name VARCHAR(255))";
+ private static final String DROP_SCHEMA = "DROP TABLE IF EXISTS customer";
+
+ /** {@inheritDoc} */
+ @Override
+ public void save(Customer customer) {
+ try (Connection connection = dataSource.getConnection();
+ PreparedStatement saveStatement = connection.prepareStatement(INSERT_CUSTOMER)) {
+ saveStatement.setLong(1, customer.getId());
+ saveStatement.setString(2, customer.getName());
+ saveStatement.execute();
+ } catch (SQLException e) {
+ throw new CustomException(e.getMessage(), e);
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public void update(Customer customer) {
+ if (Objects.isNull(customer) || Objects.isNull(customer.getId())) {
+ throw new CustomException("Custome null or customer id null");
+ }
+ try (Connection connection = dataSource.getConnection();
+ PreparedStatement selectStatement = connection.prepareStatement(SELECT_CUSTOMER_BY_ID);
+ PreparedStatement updateStatement = connection.prepareStatement(UPDATE_CUSTOMER)) {
+ selectStatement.setLong(1, customer.getId());
+ try (ResultSet resultSet = selectStatement.executeQuery()) {
+ if (!resultSet.next()) {
+ throw new CustomException("Customer not found with id: " + customer.getId());
+ }
+ }
+ updateStatement.setString(1, customer.getName());
+ updateStatement.setLong(2, customer.getId());
+ updateStatement.executeUpdate();
+ } catch (SQLException e) {
+ throw new CustomException(e.getMessage(), e);
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public void delete(Long id) {
+ if (Objects.isNull(id)) {
+ throw new CustomException("Customer id null");
+ }
+ try (Connection connection = dataSource.getConnection();
+ PreparedStatement selectStatement = connection.prepareStatement(SELECT_CUSTOMER_BY_ID);
+ PreparedStatement deleteStatement = connection.prepareStatement(DELETE_CUSTOMER)) {
+ selectStatement.setLong(1, id);
+ try (ResultSet resultSet = selectStatement.executeQuery()) {
+ if (!resultSet.next()) {
+ throw new CustomException("Customer not found with id: " + id);
+ }
+ }
+ deleteStatement.setLong(1, id);
+ deleteStatement.execute();
+ } catch (SQLException e) {
+ throw new CustomException(e.getMessage(), e);
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public List> findAll() {
+ List> customers = new LinkedList<>();
+ try (Connection connection = dataSource.getConnection();
+ PreparedStatement selectStatement = connection.prepareStatement(SELECT_ALL_CUSTOMERS)) {
+ try (ResultSet resultSet = selectStatement.executeQuery()) {
+ while (resultSet.next()) {
+ Long idCustomer = resultSet.getLong("id");
+ String nameCustomer = resultSet.getString("name");
+ customers.add(new Customer<>(idCustomer, nameCustomer));
+ }
+ }
+ } catch (SQLException e) {
+ throw new CustomException(e.getMessage(), e);
+ }
+ return customers;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public Optional> findById(Long id) {
+ if (Objects.isNull(id)) {
+ throw new CustomException("Customer id null");
+ }
+ Customer customer = null;
+ try (Connection connection = dataSource.getConnection();
+ PreparedStatement selectByIdStatement =
+ connection.prepareStatement(SELECT_CUSTOMER_BY_ID)) {
+ selectByIdStatement.setLong(1, id);
+ try (ResultSet resultSet = selectByIdStatement.executeQuery()) {
+ while (resultSet.next()) {
+ Long idCustomer = resultSet.getLong("id");
+ String nameCustomer = resultSet.getString("name");
+ customer = new Customer<>(idCustomer, nameCustomer);
+ }
+ }
+ } catch (SQLException e) {
+ throw new CustomException(e.getMessage(), e);
+ }
+ return Optional.ofNullable(customer);
+ }
+
+ /** Create customer schema. */
+ public void createSchema() {
+ try (Connection connection = dataSource.getConnection();
+ Statement statement = connection.createStatement()) {
+ statement.execute(CREATE_SCHEMA);
+ } catch (SQLException e) {
+ throw new CustomException(e.getMessage(), e);
+ }
+ }
+
+ /** {@inheritDoc}} */
+ @Override
+ public void deleteSchema() {
+ try (Connection connection = dataSource.getConnection();
+ Statement statement = connection.createStatement(); ) {
+ statement.execute(DROP_SCHEMA);
+ } catch (SQLException e) {
+ throw new CustomException(e.getMessage(), e);
+ }
+ }
+}
diff --git a/dao-factory/src/main/java/com/iluwatar/daofactory/H2DataSourceFactory.java b/dao-factory/src/main/java/com/iluwatar/daofactory/H2DataSourceFactory.java
new file mode 100644
index 000000000000..dbb39dd98f3b
--- /dev/null
+++ b/dao-factory/src/main/java/com/iluwatar/daofactory/H2DataSourceFactory.java
@@ -0,0 +1,48 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+import javax.sql.DataSource;
+import org.h2.jdbcx.JdbcDataSource;
+
+/** H2DataSourceFactory concrete factory. */
+public class H2DataSourceFactory extends DAOFactory {
+ private static final String DB_URL = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1";
+ private static final String USER = "sa";
+ private static final String PASS = "";
+
+ @Override
+ public CustomerDAO createCustomerDAO() {
+ return new H2CustomerDAO(createDataSource());
+ }
+
+ private DataSource createDataSource() {
+ var dataSource = new JdbcDataSource();
+ dataSource.setURL(DB_URL);
+ dataSource.setUser(USER);
+ dataSource.setPassword(PASS);
+ return dataSource;
+ }
+}
diff --git a/dao-factory/src/main/java/com/iluwatar/daofactory/MongoCustomerDAO.java b/dao-factory/src/main/java/com/iluwatar/daofactory/MongoCustomerDAO.java
new file mode 100644
index 000000000000..1870f61e85fd
--- /dev/null
+++ b/dao-factory/src/main/java/com/iluwatar/daofactory/MongoCustomerDAO.java
@@ -0,0 +1,106 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+import com.mongodb.client.FindIterable;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.model.Filters;
+import com.mongodb.client.model.Updates;
+import com.mongodb.client.result.DeleteResult;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Optional;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.Document;
+import org.bson.conversions.Bson;
+import org.bson.types.ObjectId;
+
+/** An implementation of {@link CustomerDAO} that uses MongoDB (https://www.mongodb.com/) */
+@Slf4j
+@RequiredArgsConstructor
+public class MongoCustomerDAO implements CustomerDAO {
+ private final MongoCollection customerCollection;
+
+ /** {@inheritDoc} */
+ @Override
+ public void save(Customer customer) {
+ Document customerDocument = new Document("_id", customer.getId());
+ customerDocument.append("name", customer.getName());
+ customerCollection.insertOne(customerDocument);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public void update(Customer customer) {
+ Document updateQuery = new Document("_id", customer.getId());
+ Bson update = Updates.set("name", customer.getName());
+ customerCollection.updateOne(updateQuery, update);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public void delete(ObjectId objectId) {
+ Bson deleteQuery = Filters.eq("_id", objectId);
+ DeleteResult deleteResult = customerCollection.deleteOne(deleteQuery);
+ if (deleteResult.getDeletedCount() == 0) {
+ throw new CustomException("Delete failed: No document found with id: " + objectId);
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public List> findAll() {
+ List> customers = new LinkedList<>();
+ FindIterable customerDocuments = customerCollection.find();
+ for (Document customerDocument : customerDocuments) {
+ Customer customer =
+ new Customer<>(
+ (ObjectId) customerDocument.get("_id"), customerDocument.getString("name"));
+ customers.add(customer);
+ }
+ return customers;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public Optional> findById(ObjectId objectId) {
+ Bson filter = Filters.eq("_id", objectId);
+ Document customerDocument = customerCollection.find(filter).first();
+ Customer customerResult = null;
+ if (customerDocument != null) {
+ customerResult =
+ new Customer<>(
+ (ObjectId) customerDocument.get("_id"), customerDocument.getString("name"));
+ }
+ return Optional.ofNullable(customerResult);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public void deleteSchema() {
+ customerCollection.drop();
+ }
+}
diff --git a/dao-factory/src/main/java/com/iluwatar/daofactory/MongoDataSourceFactory.java b/dao-factory/src/main/java/com/iluwatar/daofactory/MongoDataSourceFactory.java
new file mode 100644
index 000000000000..5a7b1f1b1ece
--- /dev/null
+++ b/dao-factory/src/main/java/com/iluwatar/daofactory/MongoDataSourceFactory.java
@@ -0,0 +1,51 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
+import org.bson.Document;
+import org.bson.types.ObjectId;
+
+/** MongoDataSourceFactory concrete factory. */
+public class MongoDataSourceFactory extends DAOFactory {
+ private static final String CONN_STR = "mongodb://localhost:27017/";
+ private static final String DB_NAME = "dao_factory";
+ private static final String COLLECTION_NAME = "customer";
+
+ @Override
+ public CustomerDAO createCustomerDAO() {
+ try {
+ MongoClient mongoClient = MongoClients.create(CONN_STR);
+ MongoDatabase database = mongoClient.getDatabase(DB_NAME);
+ MongoCollection customerCollection = database.getCollection(COLLECTION_NAME);
+ return new MongoCustomerDAO(customerCollection);
+ } catch (CustomException e) {
+ throw new CustomException("Error: " + e);
+ }
+ }
+}
diff --git a/dao-factory/src/main/resources/logback.xml b/dao-factory/src/main/resources/logback.xml
new file mode 100644
index 000000000000..f82341ebb2ab
--- /dev/null
+++ b/dao-factory/src/main/resources/logback.xml
@@ -0,0 +1,12 @@
+
+
+
+ %d{HH:mm:ss.SSS} [%thread] %highlight(%-5level) %cyan(%logger{15}) %logger{36} - %msg%n
+
+
+
+
+
+
\ No newline at end of file
diff --git a/dao-factory/src/test/java/com/iluwatar/daofactory/AppTest.java b/dao-factory/src/test/java/com/iluwatar/daofactory/AppTest.java
new file mode 100644
index 000000000000..12efea42bdc6
--- /dev/null
+++ b/dao-factory/src/test/java/com/iluwatar/daofactory/AppTest.java
@@ -0,0 +1,94 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/** {@link App} */
+class AppTest {
+ /** Test perform CRUD in main class */
+ private CustomerDAO mockLongCustomerDAO;
+
+ private CustomerDAO mockObjectIdCustomerDAO;
+
+ @BeforeEach
+ void setUp() {
+ mockLongCustomerDAO = mock(CustomerDAO.class);
+ mockObjectIdCustomerDAO = mock(CustomerDAO.class);
+ }
+
+ @Test
+ void testPerformCreateCustomerWithLongId() {
+ Customer c1 = new Customer<>(1L, "Test1");
+ Customer c2 = new Customer<>(2L, "Test2");
+
+ when(mockLongCustomerDAO.findAll()).thenReturn(List.of(c1, c2));
+
+ App.performCreateCustomer(mockLongCustomerDAO, List.of(c1, c2));
+
+ verify(mockLongCustomerDAO).save(c1);
+ verify(mockLongCustomerDAO).save(c2);
+ verify(mockLongCustomerDAO).findAll();
+ }
+
+ @Test
+ void testPerformUpdateCustomerWithObjectId() {
+ ObjectId id = new ObjectId();
+ Customer updatedCustomer = new Customer<>(id, "Updated");
+
+ when(mockObjectIdCustomerDAO.findAll()).thenReturn(List.of(updatedCustomer));
+
+ App.performUpdateCustomer(mockObjectIdCustomerDAO, updatedCustomer);
+
+ verify(mockObjectIdCustomerDAO).update(updatedCustomer);
+ verify(mockObjectIdCustomerDAO).findAll();
+ }
+
+ @Test
+ void testPerformDeleteCustomerWithLongId() {
+ Long id = 100L;
+ Customer remainingCustomer = new Customer<>(1L, "Remaining");
+
+ when(mockLongCustomerDAO.findAll()).thenReturn(List.of(remainingCustomer));
+
+ App.performDeleteCustomer(mockLongCustomerDAO, id);
+
+ verify(mockLongCustomerDAO).delete(id);
+ verify(mockLongCustomerDAO).findAll();
+ }
+
+ @Test
+ void testDeleteSchema() {
+ App.deleteSchema(mockLongCustomerDAO);
+ verify(mockLongCustomerDAO).deleteSchema();
+ }
+}
diff --git a/dao-factory/src/test/java/com/iluwatar/daofactory/DAOFactoryTest.java b/dao-factory/src/test/java/com/iluwatar/daofactory/DAOFactoryTest.java
new file mode 100644
index 000000000000..f8aaf199762d
--- /dev/null
+++ b/dao-factory/src/test/java/com/iluwatar/daofactory/DAOFactoryTest.java
@@ -0,0 +1,54 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+
+import org.junit.jupiter.api.Test;
+
+/** {@link DAOFactory} */
+class DAOFactoryTest {
+
+ @Test
+ void verifyH2CustomerDAOCreation() {
+ var daoFactory = DAOFactoryProvider.getDataSource(DataSourceType.H2);
+ var customerDAO = daoFactory.createCustomerDAO();
+ assertInstanceOf(H2CustomerDAO.class, customerDAO);
+ }
+
+ @Test
+ void verifyMongoCustomerDAOCreation() {
+ var daoFactory = DAOFactoryProvider.getDataSource(DataSourceType.MONGO);
+ var customerDAO = daoFactory.createCustomerDAO();
+ assertInstanceOf(MongoCustomerDAO.class, customerDAO);
+ }
+
+ @Test
+ void verifyFlatFileCustomerDAOCreation() {
+ var daoFactory = DAOFactoryProvider.getDataSource(DataSourceType.FLAT_FILE);
+ var customerDAO = daoFactory.createCustomerDAO();
+ assertInstanceOf(FlatFileCustomerDAO.class, customerDAO);
+ }
+}
diff --git a/dao-factory/src/test/java/com/iluwatar/daofactory/FlatFileCustomerDAOTest.java b/dao-factory/src/test/java/com/iluwatar/daofactory/FlatFileCustomerDAOTest.java
new file mode 100644
index 000000000000..470964f4217a
--- /dev/null
+++ b/dao-factory/src/test/java/com/iluwatar/daofactory/FlatFileCustomerDAOTest.java
@@ -0,0 +1,500 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+import java.lang.reflect.Type;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Optional;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+
+/** {@link FlatFileCustomerDAO} */
+class FlatFileCustomerDAOTest {
+ private Path filePath;
+ private File file;
+ private Gson gson;
+
+ private final Type customerListType = new TypeToken>>() {}.getType();
+ private final Customer existingCustomer = new Customer<>(1L, "Thanh");
+ private FlatFileCustomerDAO flatFileCustomerDAO;
+ private FileReader fileReader;
+ private FileWriter fileWriter;
+
+ @BeforeEach
+ void setUp() {
+ filePath = mock(Path.class);
+ file = mock(File.class);
+ gson = mock(Gson.class);
+ fileReader = mock(FileReader.class);
+ fileWriter = mock(FileWriter.class);
+ flatFileCustomerDAO =
+ new FlatFileCustomerDAO(filePath, gson) {
+ @Override
+ protected Reader createReader(Path filePath) throws IOException {
+ return fileReader;
+ }
+
+ @Override
+ protected Writer createWriter(Path filePath) throws IOException {
+ return fileWriter;
+ }
+ };
+ when(filePath.toFile()).thenReturn(file);
+ }
+
+ /** Class test with scenario Save Customer */
+ @Nested
+ class Save {
+ @Test
+ void giveFilePathNotExist_whenSaveCustomer_thenCreateNewFileWithCustomer() {
+ when(file.exists()).thenReturn(false);
+ flatFileCustomerDAO.save(existingCustomer);
+
+ verify(gson)
+ .toJson(
+ argThat(
+ (List> list) ->
+ list.size() == 1 && list.getFirst().equals(existingCustomer)),
+ eq(fileWriter));
+ }
+
+ @Test
+ void givenEmptyFileExist_whenSaveCustomer_thenAddCustomer() {
+ when(file.exists()).thenReturn(true);
+ when(gson.fromJson(any(Reader.class), eq(customerListType))).thenReturn(new LinkedList<>());
+ flatFileCustomerDAO.save(existingCustomer);
+
+ verify(gson).fromJson(fileReader, customerListType);
+ verify(gson)
+ .toJson(
+ argThat(
+ (List> list) ->
+ list.size() == 1 && list.getFirst().equals(existingCustomer)),
+ eq(fileWriter));
+ }
+
+ @Test
+ void givenFileWithCustomerExist_whenSaveCustomer_thenShouldAppendCustomer() {
+ List> customers = new LinkedList<>();
+ customers.add(new Customer<>(2L, "Duc"));
+ customers.add(new Customer<>(3L, "Nguyen"));
+ when(file.exists()).thenReturn(true);
+ when(gson.fromJson(any(Reader.class), eq(customerListType))).thenReturn(customers);
+
+ flatFileCustomerDAO.save(existingCustomer);
+
+ verify(gson).fromJson(fileReader, customerListType);
+ verify(gson).toJson(argThat((List> list) -> list.size() == 3), eq(fileWriter));
+ }
+
+ @Test
+ void whenReadFails_thenThrowException() {
+ flatFileCustomerDAO =
+ new FlatFileCustomerDAO(filePath, gson) {
+ @Override
+ protected Reader createReader(Path filePath) throws IOException {
+ throw new IOException("Failed to read file");
+ }
+
+ @Override
+ protected Writer createWriter(Path filePath) {
+ return fileWriter;
+ }
+ };
+ when(file.exists()).thenReturn(true);
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.save(existingCustomer));
+ }
+
+ @Test
+ void whenWriteFails_thenThrowException() {
+ when(gson.fromJson(any(Reader.class), eq(customerListType))).thenReturn(new LinkedList<>());
+ flatFileCustomerDAO =
+ new FlatFileCustomerDAO(filePath, gson) {
+ @Override
+ protected Reader createReader(Path filePath) {
+ return fileReader;
+ }
+
+ @Override
+ protected Writer createWriter(Path filePath) throws IOException {
+ throw new IOException("Failed to write file");
+ }
+ };
+ when(file.exists()).thenReturn(true);
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.save(existingCustomer));
+ }
+ }
+
+ /** Class test with scenario Update Customer */
+ @Nested
+ class Update {
+ @Test
+ void givenFilePathNotExist_whenUpdateCustomer_thenThrowException() {
+ when(file.exists()).thenReturn(false);
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.update(existingCustomer));
+ }
+
+ @Test
+ void whenReadFails_thenThrowException() {
+ when(file.exists()).thenReturn(true);
+ flatFileCustomerDAO =
+ new FlatFileCustomerDAO(filePath, gson) {
+ @Override
+ protected Reader createReader(Path filePath) throws IOException {
+ throw new IOException("Failed to read file");
+ }
+
+ @Override
+ protected Writer createWriter(Path filePath) throws IOException {
+ return fileWriter;
+ }
+ };
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.update(existingCustomer));
+ }
+
+ @Test
+ void whenWriteFails_thenThrowException() {
+ when(file.exists()).thenReturn(true);
+ when(gson.fromJson(any(Reader.class), eq(customerListType)))
+ .thenReturn(
+ new LinkedList<>() {
+ {
+ add(new Customer<>(1L, "Quang"));
+ }
+ });
+ flatFileCustomerDAO =
+ new FlatFileCustomerDAO(filePath, gson) {
+ @Override
+ protected Reader createReader(Path filePath) {
+ return fileReader;
+ }
+
+ @Override
+ protected Writer createWriter(Path filePath) throws IOException {
+ throw new IOException("Failed to write file");
+ }
+ };
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.update(existingCustomer));
+ }
+
+ @Test
+ void givenValidCustomer_whenUpdateCustomer_thenUpdateSucceed() {
+ when(file.exists()).thenReturn(true);
+ List> existingListCustomer = new LinkedList<>();
+ existingListCustomer.add(new Customer<>(1L, "Quang"));
+ when(gson.fromJson(any(Reader.class), eq(customerListType))).thenReturn(existingListCustomer);
+ flatFileCustomerDAO =
+ new FlatFileCustomerDAO(filePath, gson) {
+ @Override
+ protected Reader createReader(Path filePath) {
+ return fileReader;
+ }
+
+ @Override
+ protected Writer createWriter(Path filePath) throws IOException {
+ return fileWriter;
+ }
+ };
+ flatFileCustomerDAO.update(existingCustomer);
+ verify(gson)
+ .toJson(
+ argThat(
+ (List> customers) ->
+ customers.size() == 1
+ && customers.stream()
+ .anyMatch(c -> c.getId().equals(1L) && c.getName().equals("Thanh"))),
+ eq(fileWriter));
+ }
+
+ @Test
+ void givenIdCustomerNotExist_whenUpdateCustomer_thenThrowException() {
+ when(file.exists()).thenReturn(true);
+ List> existingListCustomer = new LinkedList<>();
+ existingListCustomer.add(new Customer<>(2L, "Quang"));
+ when(gson.fromJson(any(Reader.class), eq(customerListType))).thenReturn(existingListCustomer);
+ flatFileCustomerDAO =
+ new FlatFileCustomerDAO(filePath, gson) {
+ @Override
+ protected Reader createReader(Path filePath) {
+ return fileReader;
+ }
+
+ @Override
+ protected Writer createWriter(Path filePath) {
+ return fileWriter;
+ }
+ };
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.update(existingCustomer));
+ }
+ }
+
+ /** Class test with scenario Delete Customer */
+ @Nested
+ class Delete {
+ @Test
+ void givenFilePathNotExist_whenDeleteCustomer_thenThrowException() {
+ when(file.exists()).thenReturn(false);
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.delete(1L));
+ }
+
+ @Test
+ void whenReadFails_thenThrowException() {
+ when(file.exists()).thenReturn(true);
+ flatFileCustomerDAO =
+ new FlatFileCustomerDAO(filePath, gson) {
+ @Override
+ protected Reader createReader(Path filePath) throws IOException {
+ throw new IOException("Failed to read file");
+ }
+
+ @Override
+ protected Writer createWriter(Path filePath) {
+ return fileWriter;
+ }
+ };
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.delete(1L));
+ }
+
+ @Test
+ void whenWriteFails_thenThrowException() {
+ when(file.exists()).thenReturn(true);
+ List> existingListCustomer = new LinkedList<>();
+ existingListCustomer.add(new Customer<>(1L, "Quang"));
+ when(gson.fromJson(any(Reader.class), eq(customerListType))).thenReturn(existingListCustomer);
+ flatFileCustomerDAO =
+ new FlatFileCustomerDAO(filePath, gson) {
+ @Override
+ protected Reader createReader(Path filePath) {
+ return fileReader;
+ }
+
+ @Override
+ protected Writer createWriter(Path filePath) throws IOException {
+ throw new IOException("Failed to write file");
+ }
+ };
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.delete(1L));
+ }
+
+ @Test
+ void givenValidId_whenDeleteCustomer_thenDeleteSucceed() {
+ when(file.exists()).thenReturn(true);
+ List> existingListCustomer = new LinkedList<>();
+ existingListCustomer.add(new Customer<>(1L, "Quang"));
+ existingListCustomer.add(new Customer<>(2L, "Thanh"));
+ when(gson.fromJson(any(Reader.class), eq(customerListType))).thenReturn(existingListCustomer);
+ flatFileCustomerDAO =
+ new FlatFileCustomerDAO(filePath, gson) {
+ @Override
+ protected Reader createReader(Path filePath) {
+ return fileReader;
+ }
+
+ @Override
+ protected Writer createWriter(Path filePath) {
+ return fileWriter;
+ }
+ };
+
+ flatFileCustomerDAO.delete(1L);
+ assertEquals(1, existingListCustomer.size());
+ verify(gson)
+ .toJson(
+ argThat(
+ (List> customers) ->
+ customers.stream()
+ .noneMatch(c -> c.getId().equals(1L) && c.getName().equals("Quang"))),
+ eq(fileWriter));
+ }
+
+ @Test
+ void givenIdNotExist_whenDeleteCustomer_thenThrowException() {
+ when(file.exists()).thenReturn(true);
+ List> existingListCustomer = new LinkedList<>();
+ existingListCustomer.add(new Customer<>(1L, "Quang"));
+ existingListCustomer.add(new Customer<>(2L, "Thanh"));
+ when(gson.fromJson(any(Reader.class), eq(customerListType))).thenReturn(existingListCustomer);
+ flatFileCustomerDAO =
+ new FlatFileCustomerDAO(filePath, gson) {
+ @Override
+ protected Reader createReader(Path filePath) {
+ return fileReader;
+ }
+
+ @Override
+ protected Writer createWriter(Path filePath) {
+ return fileWriter;
+ }
+ };
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.delete(3L));
+ }
+ }
+
+ /** Class test with scenario Find All Customer */
+ @Nested
+ class FindAll {
+ @Test
+ void givenFileNotExist_thenThrowException() {
+ when(file.exists()).thenReturn(false);
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.findAll());
+ }
+
+ @Test
+ void whenReadFails_thenThrowException() {
+ when(file.exists()).thenReturn(true);
+ flatFileCustomerDAO =
+ new FlatFileCustomerDAO(filePath, gson) {
+ @Override
+ protected Reader createReader(Path filePath) throws IOException {
+ throw new IOException("Failed to read file");
+ }
+
+ @Override
+ protected Writer createWriter(Path filePath) {
+ return fileWriter;
+ }
+ };
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.findAll());
+ }
+
+ @Test
+ void givenEmptyCustomer_thenReturnEmptyList() {
+ when(file.exists()).thenReturn(true);
+ when(gson.fromJson(any(Reader.class), eq(customerListType))).thenReturn(new LinkedList<>());
+ List> customers = flatFileCustomerDAO.findAll();
+ assertEquals(0, customers.size());
+ verify(gson).fromJson(fileReader, customerListType);
+ }
+
+ @Test
+ void givenCustomerExist_thenReturnCustomerList() {
+ when(file.exists()).thenReturn(true);
+ List> existingListCustomer = new LinkedList<>();
+ existingListCustomer.add(new Customer<>(1L, "Quang"));
+ existingListCustomer.add(new Customer<>(2L, "Thanh"));
+ when(gson.fromJson(any(Reader.class), eq(customerListType))).thenReturn(existingListCustomer);
+ List> customers = flatFileCustomerDAO.findAll();
+ assertEquals(2, customers.size());
+ }
+ }
+
+ /** Class test with scenario Find By Id Customer */
+ @Nested
+ class FindById {
+
+ @Test
+ void givenFilePathNotExist_whenFindById_thenThrowException() {
+ when(file.exists()).thenReturn(false);
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.findById(1L));
+ }
+
+ @Test
+ void whenReadFails_thenThrowException() {
+ when(file.exists()).thenReturn(true);
+ flatFileCustomerDAO =
+ new FlatFileCustomerDAO(filePath, gson) {
+ @Override
+ protected Reader createReader(Path filePath) throws IOException {
+ throw new IOException("Failed to read file");
+ }
+
+ @Override
+ protected Writer createWriter(Path filePath) {
+ return fileWriter;
+ }
+ };
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.findById(1L));
+ }
+
+ @Test
+ void givenIdCustomerExist_whenFindById_thenReturnCustomer() {
+ when(file.exists()).thenReturn(true);
+ List> existingListCustomer = new LinkedList<>();
+ existingListCustomer.add(new Customer<>(1L, "Quang"));
+ existingListCustomer.add(new Customer<>(2L, "Thanh"));
+ when(gson.fromJson(any(Reader.class), eq(customerListType))).thenReturn(existingListCustomer);
+ Optional> customer = flatFileCustomerDAO.findById(1L);
+ assertTrue(customer.isPresent());
+ assertEquals("Quang", customer.get().getName());
+ }
+
+ @Test
+ void givenIdCustomerNotExist_whenFindById_thenReturnEmpty() {
+ when(file.exists()).thenReturn(true);
+ when(gson.fromJson(any(Reader.class), eq(customerListType))).thenReturn(new LinkedList<>());
+ Optional> customers = flatFileCustomerDAO.findById(1L);
+ assertTrue(customers.isEmpty());
+ }
+ }
+
+ /** Clas test with scenario Delete schema */
+ @Nested
+ class DeleteSchema {
+ @Test
+ void givenFilePathExist_thenDeleteFile() {
+ when(file.exists()).thenReturn(true);
+
+ try (MockedStatic mockedFiles = mockStatic(Files.class)) {
+ flatFileCustomerDAO.deleteSchema();
+ mockedFiles.verify(() -> Files.delete(filePath), times(1));
+ }
+ }
+
+ @Test
+ void givenFilePathNotExist_thenThrowException() {
+ when(file.exists()).thenReturn(false);
+
+ try (MockedStatic mockedFiles = mockStatic(Files.class)) {
+ assertThrows(CustomException.class, () -> flatFileCustomerDAO.deleteSchema());
+ mockedFiles.verify(() -> Files.delete(filePath), times(0));
+ }
+ }
+ }
+}
diff --git a/dao-factory/src/test/java/com/iluwatar/daofactory/H2CustomerDAOTest.java b/dao-factory/src/test/java/com/iluwatar/daofactory/H2CustomerDAOTest.java
new file mode 100644
index 000000000000..ce7def36e5bc
--- /dev/null
+++ b/dao-factory/src/test/java/com/iluwatar/daofactory/H2CustomerDAOTest.java
@@ -0,0 +1,300 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.List;
+import javax.sql.DataSource;
+import org.h2.jdbcx.JdbcDataSource;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+/** Tests {@link H2CustomerDAO} */
+class H2CustomerDAOTest {
+ private static final String DB_URL = "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1";
+ private static final String USER = "sa";
+ private static final String PASS = "";
+ private static final String CREATE_SCHEMA =
+ "CREATE TABLE IF NOT EXISTS customer (id BIGINT PRIMARY KEY, name VARCHAR(255))";
+ private static final String DROP_SCHEMA = "DROP TABLE IF EXISTS customer";
+ private final Customer existingCustomer = new Customer<>(1L, "Nguyen");
+ private H2CustomerDAO h2CustomerDAO;
+
+ @BeforeEach
+ void createSchema() throws SQLException {
+ try (var connection = DriverManager.getConnection(DB_URL, USER, PASS);
+ var statement = connection.createStatement()) {
+ statement.execute(CREATE_SCHEMA);
+ }
+ }
+
+ @AfterEach
+ void deleteSchema() throws SQLException {
+ try (var connection = DriverManager.getConnection(DB_URL, USER, PASS);
+ var statement = connection.createStatement()) {
+ statement.execute(DROP_SCHEMA);
+ }
+ }
+
+ /** Class test for scenario connect with datasource succeed */
+ @Nested
+ class ConnectionSucceed {
+
+ @BeforeEach
+ void setUp() {
+ var dataSource = new JdbcDataSource();
+ dataSource.setURL(DB_URL);
+ dataSource.setUser(USER);
+ dataSource.setPassword(PASS);
+ h2CustomerDAO = new H2CustomerDAO(dataSource);
+ assertDoesNotThrow(() -> h2CustomerDAO.save(existingCustomer));
+ var customer = h2CustomerDAO.findById(existingCustomer.getId());
+ assertTrue(customer.isPresent());
+ assertEquals(customer.get().getName(), existingCustomer.getName());
+ assertEquals(customer.get().getId(), existingCustomer.getId());
+ }
+
+ @Nested
+ class SaveCustomer {
+ @Test
+ void givenValidCustomer_whenSaveCustomer_thenAddSucceed() {
+ var customer = new Customer<>(2L, "Duc");
+ assertDoesNotThrow(() -> h2CustomerDAO.save(customer));
+ var customerInDb = h2CustomerDAO.findById(customer.getId());
+ assertTrue(customerInDb.isPresent());
+ assertEquals(customerInDb.get().getName(), customer.getName());
+ assertEquals(customerInDb.get().getId(), customer.getId());
+ List> customers = h2CustomerDAO.findAll();
+ assertEquals(2, customers.size());
+ }
+
+ @Test
+ void givenIdCustomerDuplicated_whenSaveCustomer_thenThrowException() {
+ var customer = new Customer<>(existingCustomer.getId(), "Duc");
+ assertThrows(CustomException.class, () -> h2CustomerDAO.save(customer));
+ List> customers = h2CustomerDAO.findAll();
+ assertEquals(1, customers.size());
+ }
+ }
+
+ @Nested
+ class UpdateCustomer {
+ @Test
+ void givenValidCustomer_whenUpdateCustomer_thenUpdateSucceed() {
+ var customerUpdate = new Customer<>(existingCustomer.getId(), "Duc");
+ assertDoesNotThrow(() -> h2CustomerDAO.update(customerUpdate));
+ var customerInDb = h2CustomerDAO.findById(customerUpdate.getId());
+ assertTrue(customerInDb.isPresent());
+ assertEquals(customerInDb.get().getName(), customerUpdate.getName());
+ }
+
+ @Test
+ void givenIdCustomerNotExist_whenUpdateCustomer_thenThrowException() {
+ var customerUpdate = new Customer<>(100L, "Duc");
+ var customerInDb = h2CustomerDAO.findById(customerUpdate.getId());
+ assertTrue(customerInDb.isEmpty());
+ assertThrows(CustomException.class, () -> h2CustomerDAO.update(customerUpdate));
+ }
+
+ @Test
+ void givenNull_whenUpdateCustomer_thenThrowException() {
+ assertThrows(CustomException.class, () -> h2CustomerDAO.update(null));
+ List> customers = h2CustomerDAO.findAll();
+ assertEquals(1, customers.size());
+ }
+ }
+
+ @Nested
+ class DeleteCustomer {
+ @Test
+ void givenValidId_whenDeleteCustomer_thenDeleteSucceed() {
+ assertDoesNotThrow(() -> h2CustomerDAO.delete(existingCustomer.getId()));
+ var customerInDb = h2CustomerDAO.findById(existingCustomer.getId());
+ assertTrue(customerInDb.isEmpty());
+ List> customers = h2CustomerDAO.findAll();
+ assertEquals(0, customers.size());
+ }
+
+ @Test
+ void givenIdCustomerNotExist_whenDeleteCustomer_thenThrowException() {
+ var customerInDb = h2CustomerDAO.findById(100L);
+ assertTrue(customerInDb.isEmpty());
+ assertThrows(CustomException.class, () -> h2CustomerDAO.delete(100L));
+ List> customers = h2CustomerDAO.findAll();
+ assertEquals(1, customers.size());
+ assertEquals(existingCustomer.getName(), customers.get(0).getName());
+ assertEquals(existingCustomer.getId(), customers.get(0).getId());
+ }
+
+ @Test
+ void givenNull_whenDeleteCustomer_thenThrowException() {
+ assertThrows(CustomException.class, () -> h2CustomerDAO.delete(null));
+ List> customers = h2CustomerDAO.findAll();
+ assertEquals(1, customers.size());
+ assertEquals(existingCustomer.getName(), customers.get(0).getName());
+ }
+ }
+
+ @Nested
+ class FindAllCustomers {
+ @Test
+ void givenNonCustomerInDb_whenFindAllCustomer_thenReturnEmptyList() {
+ assertDoesNotThrow(() -> h2CustomerDAO.delete(existingCustomer.getId()));
+ List> customers = h2CustomerDAO.findAll();
+ assertEquals(0, customers.size());
+ }
+
+ @Test
+ void givenCustomerExistInDb_whenFindAllCustomer_thenReturnCustomers() {
+ List> customers = h2CustomerDAO.findAll();
+ assertEquals(1, customers.size());
+ assertEquals(existingCustomer.getName(), customers.get(0).getName());
+ assertEquals(existingCustomer.getId(), customers.get(0).getId());
+ }
+ }
+
+ @Nested
+ class FindCustomerById {
+ @Test
+ void givenValidId_whenFindById_thenReturnCustomer() {
+ var customerInDb = h2CustomerDAO.findById(existingCustomer.getId());
+ assertTrue(customerInDb.isPresent());
+ assertEquals(existingCustomer.getName(), customerInDb.get().getName());
+ assertEquals(existingCustomer.getId(), customerInDb.get().getId());
+ }
+
+ @Test
+ void givenIdCustomerNotExist_whenFindById_thenReturnEmpty() {
+ var customerNotExist = h2CustomerDAO.findById(100L);
+ assertTrue(customerNotExist.isEmpty());
+ }
+
+ @Test
+ void givenNull_whenFindById_thenThrowException() {
+ assertThrows(CustomException.class, () -> h2CustomerDAO.findById(null));
+ }
+ }
+
+ @Nested
+ class CreateSchema {
+ @Test
+ void whenCreateSchema_thenNotThrowException() {
+ assertDoesNotThrow(() -> h2CustomerDAO.createSchema());
+ }
+ }
+
+ @Nested
+ class DeleteSchema {
+ @Test
+ void whenDeleteSchema_thenNotThrowException() {
+ assertDoesNotThrow(() -> h2CustomerDAO.deleteSchema());
+ }
+ }
+ }
+
+ /** Class test with scenario connect with data source failed */
+ @Nested
+ class ConnectionFailed {
+ private static final String EXCEPTION_CAUSE = "Connection not available";
+
+ @BeforeEach
+ void setUp() throws SQLException {
+ h2CustomerDAO = new H2CustomerDAO(mockedDataSource());
+ }
+
+ private DataSource mockedDataSource() throws SQLException {
+ var mockedDataSource = mock(DataSource.class);
+ var mockedConnection = mock(Connection.class);
+ var exception = new SQLException(EXCEPTION_CAUSE);
+ doThrow(exception).when(mockedConnection).prepareStatement(Mockito.anyString());
+ doThrow(exception).when(mockedConnection).createStatement();
+ doReturn(mockedConnection).when(mockedDataSource).getConnection();
+ return mockedDataSource;
+ }
+
+ @Test
+ void givenValidCustomer_whenSaveCustomer_thenThrowException() {
+ var customer = new Customer<>(2L, "Duc");
+ CustomException exception =
+ assertThrows(CustomException.class, () -> h2CustomerDAO.save(customer));
+ assertEquals(EXCEPTION_CAUSE, exception.getMessage());
+ }
+
+ @Test
+ void givenValidCustomer_whenUpdateCustomer_thenThrowException() {
+ var customerUpdate = new Customer<>(existingCustomer.getId(), "Duc");
+ CustomException exception =
+ assertThrows(CustomException.class, () -> h2CustomerDAO.update(customerUpdate));
+ assertEquals(EXCEPTION_CAUSE, exception.getMessage());
+ }
+
+ @Test
+ void givenValidId_whenDeleteCustomer_thenThrowException() {
+ Long idCustomer = existingCustomer.getId();
+ CustomException exception =
+ assertThrows(CustomException.class, () -> h2CustomerDAO.delete(idCustomer));
+ assertEquals(EXCEPTION_CAUSE, exception.getMessage());
+ }
+
+ @Test
+ void whenFindAll_thenThrowException() {
+ CustomException exception = assertThrows(CustomException.class, h2CustomerDAO::findAll);
+ assertEquals(EXCEPTION_CAUSE, exception.getMessage());
+ }
+
+ @Test
+ void whenFindById_thenThrowException() {
+ Long idCustomer = existingCustomer.getId();
+ CustomException exception =
+ assertThrows(CustomException.class, () -> h2CustomerDAO.findById(idCustomer));
+ assertEquals(EXCEPTION_CAUSE, exception.getMessage());
+ }
+
+ @Test
+ void whenCreateSchema_thenThrowException() {
+ CustomException exception = assertThrows(CustomException.class, h2CustomerDAO::createSchema);
+ assertEquals(EXCEPTION_CAUSE, exception.getMessage());
+ }
+
+ @Test
+ void whenDeleteSchema_thenThrowException() {
+ CustomException exception = assertThrows(CustomException.class, h2CustomerDAO::deleteSchema);
+ assertEquals(EXCEPTION_CAUSE, exception.getMessage());
+ }
+ }
+}
diff --git a/dao-factory/src/test/java/com/iluwatar/daofactory/MongoCustomerDAOTest.java b/dao-factory/src/test/java/com/iluwatar/daofactory/MongoCustomerDAOTest.java
new file mode 100644
index 000000000000..c56e72c30389
--- /dev/null
+++ b/dao-factory/src/test/java/com/iluwatar/daofactory/MongoCustomerDAOTest.java
@@ -0,0 +1,163 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.daofactory;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.mongodb.client.FindIterable;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoCursor;
+import com.mongodb.client.model.Filters;
+import com.mongodb.client.result.DeleteResult;
+import com.mongodb.client.result.UpdateResult;
+import java.util.List;
+import java.util.Optional;
+import org.bson.BsonDocument;
+import org.bson.Document;
+import org.bson.conversions.Bson;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.Test;
+
+/** Tests {@link MongoCustomerDAO} */
+class MongoCustomerDAOTest {
+ MongoCollection customerCollection = mock(MongoCollection.class);
+ MongoCustomerDAO mongoCustomerDAO = new MongoCustomerDAO(customerCollection);
+
+ @Test
+ void givenValidCustomer_whenSaveCustomer_thenSaveSucceed() {
+ Customer customer = new Customer<>(new ObjectId(), "John");
+ mongoCustomerDAO.save(customer);
+ verify(customerCollection)
+ .insertOne(
+ argThat(
+ document ->
+ document.get("_id").equals(customer.getId())
+ && document.get("name").equals(customer.getName())));
+ }
+
+ @Test
+ void givenValidCustomer_whenUpdateCustomer_thenUpdateSucceed() {
+ ObjectId customerId = new ObjectId();
+ Customer customerUpdated = new Customer<>(customerId, "John");
+ when(customerCollection.updateOne(any(Bson.class), any(Bson.class)))
+ .thenReturn(UpdateResult.acknowledged(1L, 1L, null));
+ mongoCustomerDAO.update(customerUpdated);
+ verify(customerCollection)
+ .updateOne(
+ argThat(
+ (Bson filter) -> {
+ Document filterDoc = (Document) filter;
+ return filterDoc.getObjectId("_id").equals(customerId);
+ }),
+ argThat(
+ (Bson update) -> {
+ BsonDocument bsonDoc = update.toBsonDocument();
+ BsonDocument setDoc = bsonDoc.getDocument("$set");
+ return setDoc.getString("name").getValue().equals(customerUpdated.getName());
+ }));
+ }
+
+ @Test
+ void givenValidObjectId_whenDeleteCustomer_thenDeleteSucceed() {
+ ObjectId customerId = new ObjectId();
+ when(customerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(1));
+ mongoCustomerDAO.delete(customerId);
+ verify(customerCollection)
+ .deleteOne(
+ argThat(
+ (Bson filter) -> {
+ BsonDocument filterDoc = filter.toBsonDocument();
+ return filterDoc.getObjectId("_id").getValue().equals(customerId);
+ }));
+ }
+
+ @Test
+ void givenIdNotExist_whenDeleteCustomer_thenThrowException() {
+ ObjectId customerId = new ObjectId();
+ when(customerCollection.deleteOne(any(Bson.class))).thenReturn(DeleteResult.acknowledged(0));
+ assertThrows(CustomException.class, () -> mongoCustomerDAO.delete(customerId));
+ verify(customerCollection)
+ .deleteOne(
+ argThat(
+ (Bson filter) -> {
+ BsonDocument filterDoc = filter.toBsonDocument();
+ return filterDoc.getObjectId("_id").getValue().equals(customerId);
+ }));
+ }
+
+ @Test
+ void findAll_thenReturnAllCustomers() {
+ FindIterable findIterable = mock(FindIterable.class);
+ MongoCursor cursor = mock(MongoCursor.class);
+ Document customerDoc1 = new Document("_id", new ObjectId()).append("name", "Duc");
+ Document customerDoc2 = new Document("_id", new ObjectId()).append("name", "Thanh");
+ when(customerCollection.find()).thenReturn(findIterable);
+ when(findIterable.iterator()).thenReturn(cursor);
+ when(cursor.hasNext()).thenReturn(true, true, false);
+ when(cursor.next()).thenReturn(customerDoc1, customerDoc2);
+ List> customerList = mongoCustomerDAO.findAll();
+ assertEquals(2, customerList.size());
+ verify(customerCollection).find();
+ }
+
+ @Test
+ void givenValidId_whenFindById_thenReturnCustomer() {
+ FindIterable findIterable = mock(FindIterable.class);
+ ObjectId customerId = new ObjectId();
+ String customerName = "Duc";
+ Document customerDoc = new Document("_id", customerId).append("name", customerName);
+ when(customerCollection.find(Filters.eq("_id", customerId))).thenReturn(findIterable);
+ when(findIterable.first()).thenReturn(customerDoc);
+
+ Optional> customer = mongoCustomerDAO.findById(customerId);
+ assertTrue(customer.isPresent());
+ assertEquals(customerId, customer.get().getId());
+ assertEquals(customerName, customer.get().getName());
+ }
+
+ @Test
+ void givenNotExistingId_whenFindById_thenReturnEmpty() {
+ FindIterable findIterable = mock(FindIterable.class);
+ ObjectId customerId = new ObjectId();
+ when(customerCollection.find(Filters.eq("_id", customerId))).thenReturn(findIterable);
+ when(findIterable.first()).thenReturn(null);
+ Optional> customer = mongoCustomerDAO.findById(customerId);
+ assertTrue(customer.isEmpty());
+ verify(customerCollection).find(Filters.eq("_id", customerId));
+ }
+
+ @Test
+ void whenDeleteSchema_thenDeleteCollection() {
+ mongoCustomerDAO.deleteSchema();
+ verify(customerCollection).drop();
+ }
+}
diff --git a/localization/fa/abstract-factory/README.md b/localization/fa/abstract-factory/README.md
new file mode 100644
index 000000000000..85dce3437ba4
--- /dev/null
+++ b/localization/fa/abstract-factory/README.md
@@ -0,0 +1,223 @@
+---
+title: "الگوی طراحی Abstract Factory در جاوا: مهارت در ایجاد شیء با ظرافت"
+shortTitle: Abstract Factory
+description: "با مثالهای دنیای واقعی، دیاگرامهای کلاس و آموزشها، الگوی Abstract Factory را در جاوا بیاموزید. منظور، کاربرد، مزایا و نمونههای واقعی آن را درک کنید و دانش طراحی الگوهایتان را افزایش دهید."
+category: Creational
+language: fa
+tag:
+ - Abstraction
+ - Decoupling
+ - Gang of Four
+ - Instantiation
+ - Polymorphism
+---
+
+## همچنین به این عنوان شناخته میشود
+
+* کیت
+
+## هدف از الگوی طراحی Abstract Factory
+
+الگوی Abstract Factory در جاوا یک واسط برای ایجاد خانوادههایی از اشیای مرتبط یا وابسته فراهم میکند بدون آنکه کلاسهای مشخص آنها را تعیین کند، و این کار موجب افزایش مدولاریتی و انعطافپذیری در طراحی نرمافزار میشود.
+
+## توضیح دقیق الگوی Abstract Factory با مثالهای دنیای واقعی
+
+مثال دنیای واقعی
+
+> تصور کنید یک شرکت مبلمان وجود دارد که از الگوی Abstract Factory در جاوا برای تولید سبکهای مختلف مبلمان استفاده میکند: مدرن، ویکتوریایی و روستایی. هر سبک شامل محصولاتی مانند صندلیها، میزها و کاناپهها است. برای اطمینان از یکنواختی در هر سبک، شرکت از یک الگوی Abstract Factory استفاده میکند.
+>
+> در این سناریو، Abstract Factory یک واسط برای ایجاد خانوادههایی از اشیای مبلمان مرتبط (صندلیها، میزها، کاناپهها) است. هر Factory مشخص (کارخانهی مبلمان مدرن، کارخانهی مبلمان ویکتوریایی، کارخانهی مبلمان روستایی) این واسط را پیادهسازی میکند و مجموعهای از محصولات مطابق با سبک خاص ایجاد میکند. به این ترتیب، مشتریان میتوانند یک مجموعه کامل از مبلمان مدرن یا ویکتوریایی ایجاد کنند بدون اینکه نگران جزئیات ساخت آنها باشند. این باعث حفظ یکنواختی سبک میشود و امکان تغییر آسان سبک مبلمان را فراهم میکند.
+
+به زبان ساده
+
+> کارخانهای از کارخانهها؛ یک Factory یا کارخانه که مجموعهای از کارخانههای مرتبط یا وابسته را بدون مشخص کردن کلاسهای concrete آنها گروهبندی میکند.
+
+ویکیپدیا میگوید
+
+> الگوی Abstract Factory راهی برای کپسوله کردن مجموعهای از کارخانههای منحصر به فرد با یک تم مشترک بدون تعیین کلاسهای concrete آنها فراهم میکند.
+
+دیاگرام کلاس
+
+
+
+## مثال برنامهنویسی از Abstract Factory در جاوا
+
+برای ایجاد یک پادشاهی با استفاده از الگوی Abstract Factory در جاوا، ما به اشیایی با یک تم مشترک نیاز داریم. یک پادشاهی اِلف (Elf) به یک پادشاه اِلف، یک قلعهی اِلف، و یک ارتش اِلف نیاز دارد، در حالی که یک پادشاهی اورک (Orc) به یک پادشاه اورک، یک قلعهی اورک، و یک ارتش اورک نیاز دارد. بین اشیای موجود در پادشاهی وابستگی وجود دارد.
+
+ترجمهی مثال پادشاهی بالا. ابتدا ما برخی واسطها و پیادهسازیهایی برای اشیای موجود در پادشاهی داریم:
+
+```java
+public interface Castle {
+ String getDescription();
+}
+
+public interface King {
+ String getDescription();
+}
+
+public interface Army {
+ String getDescription();
+}
+
+// Elven implementations ->
+public class ElfCastle implements Castle {
+ static final String DESCRIPTION = "This is the elven castle!";
+
+ @Override
+ public String getDescription() {
+ return DESCRIPTION;
+ }
+}
+
+public class ElfKing implements King {
+ static final String DESCRIPTION = "This is the elven king!";
+
+ @Override
+ public String getDescription() {
+ return DESCRIPTION;
+ }
+}
+
+public class ElfArmy implements Army {
+ static final String DESCRIPTION = "This is the elven Army!";
+
+ @Override
+ public String getDescription() {
+ return DESCRIPTION;
+ }
+}
+
+// Orcish implementations similarly -> ...
+```
+
+سپس واسط و پیادهسازیهای کارخانهی پادشاهی را داریم:
+
+```java
+public interface KingdomFactory {
+ Castle createCastle();
+ King createKing();
+ Army createArmy();
+}
+
+public class ElfKingdomFactory implements KingdomFactory {
+
+ @Override
+ public Castle createCastle() {
+ return new ElfCastle();
+ }
+
+ @Override
+ public King createKing() {
+ return new ElfKing();
+ }
+
+ @Override
+ public Army createArmy() {
+ return new ElfArmy();
+ }
+}
+
+// Orcish implementations similarly -> ...
+```
+
+اکنون میتوانیم یک کارخانه برای کارخانههای مختلف پادشاهی طراحی کنیم. در این مثال، ما `FactoryMaker` را ایجاد کردیم که مسئول برگرداندن یک نمونه از `ElfKingdomFactory` یا `OrcKingdomFactory` است. مشتری می تواند از `FactoryMaker` برای ایجاد کارخانه concrete مورد نظر استفاده کند که به نوبه خود اشیاء concrete مختلف (مشتق شده از ارتش، پادشاه، قلعه) را تولید میکند. در این مثال، ما همچنین از یک enum برای پارامتری کردن نوع کارخانه پادشاهی که مشتری درخواست خواهد کرد استفاده کردیم.
+
+```java
+public static class FactoryMaker {
+
+ public enum KingdomType {
+ ELF, ORC
+ }
+
+ public static KingdomFactory makeFactory(KingdomType type) {
+ return switch (type) {
+ case ELF -> new ElfKingdomFactory();
+ case ORC -> new OrcKingdomFactory();
+ };
+ }
+}
+```
+
+نمونهای از تابع اصلی برنامه:
+
+```java
+LOGGER.info("elf kingdom");
+createKingdom(Kingdom.FactoryMaker.KingdomType.ELF);
+LOGGER.info(kingdom.getArmy().getDescription());
+LOGGER.info(kingdom.getCastle().getDescription());
+LOGGER.info(kingdom.getKing().getDescription());
+
+LOGGER.info("orc kingdom");
+createKingdom(Kingdom.FactoryMaker.KingdomType.ORC);
+LOGGER.info(kingdom.getArmy().getDescription());
+LOGGER.info(kingdom.getCastle().getDescription());
+LOGGER.info(kingdom.getKing().getDescription());
+```
+
+خروجی برنامه:
+
+```
+07:35:46.340 [main] INFO com.iluwatar.abstractfactory.App -- elf kingdom
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- This is the elven army!
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- This is the elven castle!
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- This is the elven king!
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- orc kingdom
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- This is the orc army!
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- This is the orc castle!
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- This is the orc king!
+```
+
+## چه زمانی باید از الگوی Abstract Factory در جاوا استفاده کرد؟
+
+* زمانی که سیستم باید مستقل از نحوهی ایجاد، ترکیب و نمایش محصولاتش باشد.
+* زمانی که نیاز به پیکربندی سیستم با یکی از چند خانواده محصول دارید.
+* زمانی که باید خانوادهای از اشیای مرتبط با هم استفاده شوند، برای اطمینان از یکنواختی.
+* زمانی که میخواهید کتابخانهای از محصولات را فراهم کنید و فقط واسطهای آنها را نمایان کنید، نه پیادهسازیها را.
+* زمانی که طول عمر وابستگیها کوتاهتر از مصرفکننده باشد.
+* زمانی که نیاز به ساخت وابستگیها با مقادیر یا پارامترهای زمان اجرا باشد.
+* زمانی که باید در زمان اجرا انتخاب کنید که کدام خانواده از محصول را استفاده کنید.
+* زمانی که افزودن محصولات یا خانواده های جدید نباید نیاز به تغییر در کد موجود داشته باشد.
+
+## آموزشهای الگوی Abstract Factory در جاوا
+
+* [Abstract Factory Design Pattern in Java (DigitalOcean)](https://www.digitalocean.com/community/tutorials/abstract-factory-design-pattern-in-java)
+* [Abstract Factory (Refactoring Guru)](https://refactoring.guru/design-patterns/abstract-factory)
+
+## مزایا و معایب الگوی Abstract Factory
+
+مزایا:
+
+> * انعطافپذیری: به راحتی میتوان خانوادههای محصول را تعویض کرد بدون تغییر کد.
+
+> * جداسازی (Decoupling): کد مشتری فقط با واسطهای انتزاعی کار میکند که باعث قابلیت حمل و نگهداری میشود.
+
+> * قابلیت استفاده مجدد: کارخانههای انتزاعی و محصولات امکان استفاده مجدد از مؤلفهها را فراهم میکنند.
+
+> * قابلیت نگهداری: تغییرات در خانوادههای محصول محلی شده و بهروزرسانی را سادهتر میکند.
+
+معایب:
+
+> * پیچیدگی: تعریف واسطهای انتزاعی و کارخانههای مشخص سربار اولیه ایجاد میکند.
+
+> * غیرمستقیم بودن: کد مشتری از طریق کارخانهها با محصولات کار میکند که ممکن است شفافیت را کاهش دهد.
+
+## نمونههای واقعی استفاده از الگوی Abstract Factory در جاوا
+
+* کلاسهای `LookAndFeel` در Java Swing برای ارائه گزینه های مختلف look-and-feel
+* پیادهسازیهای مختلف در Java AWT برای ایجاد اجزای مختلف GUI
+* [javax.xml.parsers.DocumentBuilderFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/parsers/DocumentBuilderFactory.html)
+* [javax.xml.transform.TransformerFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/transform/TransformerFactory.html#newInstance--)
+* [javax.xml.xpath.XPathFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/xpath/XPathFactory.html#newInstance--)
+
+## الگوهای طراحی مرتبط با جاوا
+
+* الگوی [Factory Method](https://java-design-patterns.com/patterns/factory-method/): الگوی کارخانهی انتزاعی از روشهای کارخانهای برای ایجاد محصولات استفاده میکند.
+* الگوی [Singleton](https://java-design-patterns.com/patterns/singleton/): کلاسهای کارخانهی انتزاعی اغلب به صورت Singleton پیادهسازی میشوند.
+* الگوی [Factory Kit](https://java-design-patterns.com/patterns/factory-kit/): مشابه کارخانهی انتزاعی اما بر پیکربندی و مدیریت مجموعهای از اشیای مرتبط تمرکز دارد.
+
+## منابع و ارجاعات
+
+* [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI)
+* [Design Patterns in Java](https://amzn.to/3Syw0vC)
+* [Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software](https://amzn.to/49NGldq)
+* [Java Design Patterns: A Hands-On Experience with Real-World Examples](https://amzn.to/3HWNf4U)
diff --git a/localization/fa/abstract-factory/etc/abstract-factory.urm.png b/localization/fa/abstract-factory/etc/abstract-factory.urm.png
new file mode 100644
index 000000000000..836858a2c652
Binary files /dev/null and b/localization/fa/abstract-factory/etc/abstract-factory.urm.png differ
diff --git a/microservices-self-registration/README.md b/microservices-self-registration/README.md
new file mode 100644
index 000000000000..bfc837817c57
--- /dev/null
+++ b/microservices-self-registration/README.md
@@ -0,0 +1,236 @@
+---
+title: "Microservices Self-Registration Pattern in Java with Spring Boot and Eureka"
+shortTitle: Microservices Pattern - Self-Registration
+description: "Dynamically register and discover Java microservices using Spring Boot and Eureka for resilient, scalable communication."
+category: Service Discovery
+language: en
+tag:
+ - Microservices
+ - Self-Registration
+ - Service Discovery
+ - Eureka
+ - Spring Boot
+ - Spring Cloud
+ - Java
+ - Dynamic Configuration
+ - Resilience
+---
+
+## Intent of Microservices Self-Registration Pattern
+
+The intent of the Self-Registration pattern is to enable microservices to automatically announce their presence and location to a central registry (like Eureka) upon startup, simplifying service discovery and allowing other services to find and communicate with them without manual configuration or hardcoded addresses. This promotes dynamic and resilient microservices architectures.
+
+## What's in the Project
+
+This project demonstrates the Microservices Self-Registration pattern using Java, Spring Boot (version 3.4.4), and Eureka for service discovery. It consists of three main components: a Eureka Server and two simple microservices, a Greeting Service and a Context Service, which discover and communicate with each other.
+
+### Project Structure
+* **`eureka-server`:** The central service registry where microservices register themselves.
+* **`greeting-service`:** A simple microservice that provides a greeting.
+* **`context-service`:** A microservice that consumes the greeting from the Greeting Service and adds context.
+
+ The **Eureka Server** acts as the discovery service. Microservices register themselves with the Eureka Server, providing their network location.
+
+ package com.example.eurekaserver;
+
+ import org.springframework.boot.SpringApplication;
+ import org.springframework.boot.autoconfigure.SpringBootApplication;
+ import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
+
+ @SpringBootApplication
+ @EnableEurekaServer
+ public class EurekaServerApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(EurekaServerApplication.class, args);
+ }
+ }
+
+ The **Greeting Service** is a simple microservice that exposes an endpoint to retrieve a greeting.
+
+ package com.example.greetingservice;
+
+ import org.springframework.boot.SpringApplication;
+ import org.springframework.boot.autoconfigure.SpringBootApplication;
+ import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
+
+ @SpringBootApplication
+ @EnableDiscoveryClient
+ public class GreetingServiceApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(GreetingServiceApplication.class, args);
+ }
+ }
+
+ Greeting Controller
+
+ package com.example.greetingservice.controller;
+
+ import org.springframework.web.bind.annotation.GetMapping;
+ import org.springframework.web.bind.annotation.RestController;
+
+ @RestController
+ public class GreetingController {
+
+ @GetMapping("/greeting")
+ public String getGreeting() {
+ return "Hello";
+ }
+ }
+
+The **Context Service** consumes the greeting from the Greeting Service using OpenFeign and adds contextual information.
+
+ package com.example.contextservice;
+
+ import org.springframework.boot.SpringApplication;
+ import org.springframework.boot.autoconfigure.SpringBootApplication;
+ import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
+ import org.springframework.cloud.openfeign.EnableFeignClients;
+
+ @SpringBootApplication
+ @EnableDiscoveryClient
+ @EnableFeignClients
+ public class ContextServiceApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(ContextServiceApplication.class, args);
+ }
+ }
+
+ Feign Client : Spring Cloud OpenFeign is a declarative HTTP client that makes it easier to consume RESTful web services in your Spring Cloud applications. Instead of writing the boilerplate code for making HTTP requests, you simply declare interface with annotations that describe the web service you want to consume.
+
+ package com.example.contextservice.client;
+
+ import org.springframework.cloud.openfeign.FeignClient;
+ import org.springframework.web.bind.annotation.GetMapping;
+
+ @FeignClient(name = "greeting-service")
+ public interface GreetingServiceClient {
+
+ @GetMapping("/greeting")
+ String getGreeting();
+ }
+
+ Context Controller
+
+ package com.example.contextservice.controller;
+
+ import com.example.contextservice.client.GreetingServiceClient;
+ import org.springframework.beans.factory.annotation.Autowired;
+ import org.springframework.beans.factory.annotation.Value;
+ import org.springframework.web.bind.annotation.GetMapping;
+ import org.springframework.web.bind.annotation.RestController;
+
+ @RestController
+ public class ContextController {
+
+ @Autowired
+ private GreetingServiceClient greetingServiceClient;
+
+ @Value("${user.region}")
+ private String userRegion;
+
+ @GetMapping("/context")
+ public String getContext() {
+ String greeting = greetingServiceClient.getGreeting();
+ return "The Greeting Service says: " + greeting + " from " + userRegion + "!";
+ }
+ }
+
+ 1. Both the Greeting Service and the Context Service register themselves with the Eureka Server upon startup using the _@EnableDiscoveryClient_ annotation.
+ 2. The Context Service, annotated with _@EnableFeignClients_, uses the GreetingServiceClient interface with _@FeignClient(name = "greeting-service")_ to declare its intent to communicate with the service named "greeting-service" in Eureka.
+ 3. When the /context endpoint of the Context Service is accessed, it calls the _getGreeting()_ method of the GreetingServiceClient.
+ 4. OpenFeign, leveraging the service discovery information from Eureka, resolves the network location of an available instance of the Greeting Service and makes an HTTP GET request to its /greeting endpoint.
+ 5. The Greeting Service responds with "Hello", and the Context Service then adds the configured user.region to the response.
+
+ This project utilizes Spring Boot Actuator, which is included as a dependency, to provide health check endpoints for each microservice. These endpoints (e.g., /actuator/health) can be used by Eureka Server to monitor the health of the registered instances.
+
+## Steps to use for this Project
+
+Prerequisites:
+ - Java Development Kit (JDK): Make sure you have a compatible JDK installed (ideally Java 17 or later, as Spring Boot 3.x requires it).
+ - Maven or Gradle: You'll need either Maven (if you chose Maven during Spring Initializr setup) or Gradle (if you chose Gradle) installed on your system.
+ - An IDE (Optional but Recommended): IntelliJ IDEA, Eclipse, or Spring Tool Suite (STS) can make it easier to work with the project.
+ - Web Browser: You'll need a web browser to access the Eureka dashboard and the microservice endpoints.
+
+Step :
+ - You'll need to build each microservice individually. Navigate to the root directory of each project in your terminal or command prompt and run the appropriate build command:
+ _cd eurekaserver
+ mvn clean install
+ cd ../greetingservice
+ mvn clean install
+ cd ../contextservice
+ mvn clean install_
+Step :
+ - Navigate to the root directory of your eurekaserver project in your terminal or command prompt
+ _mvn spring-boot:run_
+ - Wait for the Eureka Server application to start. You should see logs in the console indicating that it has started on port 8761 (as configured).
+ - Open your web browser and go to http://localhost:8761/. You should see the Eureka Server dashboard. Initially, the list of registered instances will be empty.
+Step :
+ - Run the Greeting Service
+ - Open a new terminal or command prompt.
+ - Navigate to the root directory of your greetingservice project.
+ - Run the Spring Boot application: _mvn spring-boot:run_
+ - Wait for the Greeting Service to start. You should see logs indicating that it has registered with the Eureka Server.
+ - Go back to your Eureka Server dashboard in the browser (http://localhost:8761/). You should now see GREETINGSERVICE listed under the "Instances currently registered with Eureka". Its status should be "UP".
+Step :
+ - Run the Context Service
+ - Open a new terminal or command prompt.
+ - Navigate to the root directory of your contextservice project.
+ - Run the Spring Boot application: _mvn spring-boot:run_
+ - Wait for the Context Service to start. You should see logs indicating that it has registered with the Eureka Server.
+ - Go back to your Eureka Server dashboard in the browser (http://localhost:8761/). You should now see CONTEXTSERVICE listed under the "Instances currently registered with Eureka". Its status should be "UP".
+STEP :
+ - Test the Greeting Service Directly: Open your web browser and go to http://localhost:8081/greeting. You should see the output: Hello.
+ - Test the Context Service (which calls the Greeting Service): Open your web browser and go to http://localhost:8082/context. You should see the output: The Greeting Service says: Hello from Chennai, Tamil Nadu, India!. This confirms that the Context Service successfully discovered and called the Greeting Service through Eureka.
+
+Optional: Check Health Endpoints
+
+You can also verify the health status of each service using Spring Boot Actuator:
+ - Greeting Service Health: http://localhost:8081/actuator/health (should return {"status":"UP"})
+ - Context Service Health: http://localhost:8082/actuator/health (should return {"status":"UP"})
+ - Eureka Server Health: http://localhost:8761/actuator/health (should return {"status":"UP"})
+
+## When to use Microservices Self-Registration Pattern
+
+ - **Dynamic Environments:** When your microservices are frequently deployed, scaled up or down, or their network locations (IP addresses and ports) change often. This is common in cloud-based or containerized environments (like Docker and Kubernetes).
+ - **Large Number of Services:** As the number of microservices in your system grows, manually managing their configurations and dependencies becomes complex and error-prone. Self-registration automates this process.
+ - **Need for Automatic Service** Discovery: When services need to find and communicate with each other without hardcoding network locations. This allows for greater flexibility and reduces coupling.
+ - **Implementing Load Balancing:** Service registries like Eureka often integrate with load balancers, enabling them to automatically distribute traffic across available instances of a service that have registered themselves.
+ - **Improving System Resilience:** If a service instance fails, the registry will eventually be updated (through heartbeats or health checks), and other services can discover and communicate with the remaining healthy instances.
+ - **DevOps Automation:** This pattern aligns well with DevOps practices, allowing for more automated deployment and management of microservices.
+
+## Real-World Applications of Self-Registration pattern
+
+ - E-Commerce platforms have numerous independent services for product catalogs, order processing, payments, shipping, etc. Self-registration allows these services to dynamically discover and communicate with each other as the system scales during peak loads or as new features are deployed.
+ - Streaming services rely on many microservices for user authentication, content delivery networks (CDNs), recommendation engines, billing systems, etc. Self-registration helps these services adapt to varying user demands and infrastructure changes.
+ - Social media These platforms use microservices for managing user profiles, timelines, messaging, advertising, and more. Self-registration enables these services to scale independently and handle the massive traffic they experience.
+
+## Advantages
+
+ - Microservices can dynamically locate and communicate with each other without needing to know their specific network addresses beforehand. This is crucial in dynamic environments where IP addresses and ports can change frequently.
+ - Reduces the need for manual configuration of service locations in each microservice. Services don't need to be updated every time another service's location changes.
+ - Scaling microservices up or down becomes easier. New instances automatically register themselves with the service registry, making them immediately discoverable by other services without manual intervention.
+ - If a service instance fails, it will eventually stop sending heartbeats to the registry and will be removed. Consumers can then discover and connect to other healthy instances, improving the system's overall resilience.
+ - Services are less tightly coupled as they don't have direct dependencies on the physical locations of other services. This makes deployments and updates more flexible.
+ - Service registries often integrate with load balancers. When a new service instance registers, the load balancer can automatically include it in the pool of available instances, distributing traffic effectively.
+ - Microservices can be deployed across different environments (development, testing, production) without significant changes to their discovery mechanism, as long as they are configured to connect to the appropriate service registry for that environment.
+
+## Trade-offs
+
+ - Introducing a service registry adds another component to your system that needs to be set up, managed, and monitored. This increases the overall complexity of the infrastructure.
+ - The service registry itself becomes a critical component. If the service registry becomes unavailable, it can disrupt communication between microservices. High availability for the service registry is therefore essential.
+ - Microservices need to communicate with the service registry for registration, sending heartbeats, and querying for other services. This can lead to increased network traffic.
+ - There might be a slight delay between when a microservice instance starts and when it becomes fully registered and discoverable in the service registry. This needs to be considered, especially during scaling events.
+ - You need to consider how your microservices will behave if they fail to register with the service registry upon startup. Robust error handling and retry mechanisms are often necessary.
+ - Microservices need to include and configure client libraries (like the Eureka Discovery Client) to interact with the service registry. This adds a dependency to your application code.
+ - In distributed service registries, ensuring consistency of the registry data across all nodes can be a challenge. Different registries might have different consistency models (e.g., eventual consistency).
+
+## References
+
+ - Microservices Patterns: https://microservices.io/
+ - Eureka Documentation: https://github.com/Netflix/eureka | https://spring.io/projects/spring-cloud-netflix
+ - Spring Boot Documentation: https://spring.io/projects/spring-boot
+ - Spring Cloud OpenFeignDocumentation: https://spring.io/projects/spring-cloud-openfeign
+ - Spring Boot Actuator Documentation: https://www.baeldung.com/spring-boot-actuators
\ No newline at end of file
diff --git a/microservices-self-registration/application.log.2025-04-09.0.gz b/microservices-self-registration/application.log.2025-04-09.0.gz
new file mode 100644
index 000000000000..d51965d73d7a
Binary files /dev/null and b/microservices-self-registration/application.log.2025-04-09.0.gz differ
diff --git a/microservices-self-registration/contextservice/.gitattributes b/microservices-self-registration/contextservice/.gitattributes
new file mode 100644
index 000000000000..3b41682ac579
--- /dev/null
+++ b/microservices-self-registration/contextservice/.gitattributes
@@ -0,0 +1,2 @@
+/mvnw text eol=lf
+*.cmd text eol=crlf
diff --git a/microservices-self-registration/contextservice/.gitignore b/microservices-self-registration/contextservice/.gitignore
new file mode 100644
index 000000000000..549e00a2a96f
--- /dev/null
+++ b/microservices-self-registration/contextservice/.gitignore
@@ -0,0 +1,33 @@
+HELP.md
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
diff --git a/microservices-self-registration/contextservice/application.log.2025-04-05.0.gz b/microservices-self-registration/contextservice/application.log.2025-04-05.0.gz
new file mode 100644
index 000000000000..6ceb03b833a7
Binary files /dev/null and b/microservices-self-registration/contextservice/application.log.2025-04-05.0.gz differ
diff --git a/microservices-self-registration/contextservice/application.log.2025-04-07.0.gz b/microservices-self-registration/contextservice/application.log.2025-04-07.0.gz
new file mode 100644
index 000000000000..eb2a63ce194e
Binary files /dev/null and b/microservices-self-registration/contextservice/application.log.2025-04-07.0.gz differ
diff --git a/microservices-self-registration/contextservice/application.log.2025-04-09.0.gz b/microservices-self-registration/contextservice/application.log.2025-04-09.0.gz
new file mode 100644
index 000000000000..bd773dc8ba59
Binary files /dev/null and b/microservices-self-registration/contextservice/application.log.2025-04-09.0.gz differ
diff --git a/microservices-self-registration/contextservice/pom.xml b/microservices-self-registration/contextservice/pom.xml
new file mode 100644
index 000000000000..ea6d105bd06f
--- /dev/null
+++ b/microservices-self-registration/contextservice/pom.xml
@@ -0,0 +1,73 @@
+
+
+ 4.0.0
+
+ org.springframework.boot
+ spring-boot-starter-parent
+ 3.4.4
+
+ com.learning
+ contextservice
+ 0.0.1-SNAPSHOT
+ contextservice
+ contextservice
+
+
+ 2024.0.1
+
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+
+ org.projectlombok
+ lombok
+ 1.18.38
+ provided
+
+
+ org.springframework.cloud
+ spring-cloud-starter-netflix-eureka-client
+
+
+ org.springframework.boot
+ spring-boot-starter-actuator
+
+
+ org.springframework.cloud
+ spring-cloud-starter-openfeign
+
+
+ org.springframework.boot
+ spring-boot-starter-test
+ test
+
+
+
+
+
+ org.springframework.cloud
+ spring-cloud-dependencies
+ ${spring-cloud.version}
+ pom
+ import
+
+
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+
+
+
+
+
\ No newline at end of file
diff --git a/microservices-self-registration/contextservice/src/main/java/com/learning/contextservice/ContextserviceApplication.java b/microservices-self-registration/contextservice/src/main/java/com/learning/contextservice/ContextserviceApplication.java
new file mode 100644
index 000000000000..eb22d094ffce
--- /dev/null
+++ b/microservices-self-registration/contextservice/src/main/java/com/learning/contextservice/ContextserviceApplication.java
@@ -0,0 +1,17 @@
+package com.learning.contextservice;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+
+@SpringBootApplication
+@EnableDiscoveryClient
+@EnableFeignClients
+public class ContextserviceApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(ContextserviceApplication.class, args);
+ }
+
+}
diff --git a/microservices-self-registration/contextservice/src/main/java/com/learning/contextservice/MyCustomHealthCheck.java b/microservices-self-registration/contextservice/src/main/java/com/learning/contextservice/MyCustomHealthCheck.java
new file mode 100644
index 000000000000..0226fc50e803
--- /dev/null
+++ b/microservices-self-registration/contextservice/src/main/java/com/learning/contextservice/MyCustomHealthCheck.java
@@ -0,0 +1,42 @@
+package com.learning.contextservice;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.actuate.health.Health;
+import org.springframework.boot.actuate.health.HealthIndicator;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+
+@Component("myCustomHealthCheck")
+public class MyCustomHealthCheck implements HealthIndicator {
+
+ private static final Logger log = LoggerFactory.getLogger(MyCustomHealthCheck.class);
+
+ private volatile boolean isHealthy = true;
+
+ @Scheduled(fixedRate = 5000) // Run every 5 seconds
+ public void updateHealthStatus() {
+ // Perform checks here to determine the current health
+ // For example, check database connectivity, external service availability, etc.
+ isHealthy = performHealthCheck();
+ log.info("Update health status : {}", isHealthy);
+ }
+
+ boolean performHealthCheck() {
+ boolean current = System.currentTimeMillis() % 10000 < 5000; // Simulate fluctuating health
+ log.debug("Performing health check, current status: {}", current);
+ return current; // Simulate fluctuating health
+ }
+
+ @Override
+ public Health health() {
+ if (isHealthy) {
+ log.info("Health check successful, service is UP");
+ return Health.up().withDetail("message", "Service is running and scheduled checks are OK").build();
+ } else {
+ log.warn("Health check failed, service is DOWN");
+ return Health.down().withDetail("error", "Scheduled health checks failed").build();
+ }
+ }
+}
diff --git a/microservices-self-registration/contextservice/src/main/java/com/learning/contextservice/client/GreetingServiceClient.java b/microservices-self-registration/contextservice/src/main/java/com/learning/contextservice/client/GreetingServiceClient.java
new file mode 100644
index 000000000000..367a3bdd496c
--- /dev/null
+++ b/microservices-self-registration/contextservice/src/main/java/com/learning/contextservice/client/GreetingServiceClient.java
@@ -0,0 +1,11 @@
+package com.learning.contextservice.client;
+
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.GetMapping;
+
+@FeignClient(name = "greetingservice")
+public interface GreetingServiceClient {
+
+ @GetMapping("/greeting")
+ String getGreeting();
+}
diff --git a/microservices-self-registration/contextservice/src/main/java/com/learning/contextservice/controller/ContextController.java b/microservices-self-registration/contextservice/src/main/java/com/learning/contextservice/controller/ContextController.java
new file mode 100644
index 000000000000..5ad8969e0871
--- /dev/null
+++ b/microservices-self-registration/contextservice/src/main/java/com/learning/contextservice/controller/ContextController.java
@@ -0,0 +1,26 @@
+package com.learning.contextservice.controller;
+
+import com.learning.contextservice.client.GreetingServiceClient;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class ContextController {
+
+ private final GreetingServiceClient greetingServiceClient;
+ private final String userRegion;
+
+ @Autowired
+ public ContextController(GreetingServiceClient greetingServiceClient, @Value("${user.region}") String userRegion) {
+ this.greetingServiceClient = greetingServiceClient;
+ this.userRegion = userRegion;
+ }
+
+ @GetMapping("/context")
+ public String getContext() {
+ String greeting = greetingServiceClient.getGreeting();
+ return "The Greeting Service says: "+greeting+" from "+userRegion;
+ }
+}
diff --git a/microservices-self-registration/contextservice/src/main/resources/application.yml b/microservices-self-registration/contextservice/src/main/resources/application.yml
new file mode 100644
index 000000000000..dfef73bbbeec
--- /dev/null
+++ b/microservices-self-registration/contextservice/src/main/resources/application.yml
@@ -0,0 +1,25 @@
+server:
+ port: 8082
+
+spring:
+ application:
+ name: contextservice
+
+eureka:
+ client:
+ service-url.defaultZone: http://localhost:8761/eureka
+
+user:
+ region: Chennai, Tamil Nadu, India
+
+management:
+ endpoint:
+ health:
+ show-details: always
+ web:
+ exposure:
+ include: health
+
+logging:
+ file:
+ name: application.log
diff --git a/microservices-self-registration/contextservice/src/test/java/com/learning/contextservice/ContextControllerTest.java b/microservices-self-registration/contextservice/src/test/java/com/learning/contextservice/ContextControllerTest.java
new file mode 100644
index 000000000000..f11da867cda0
--- /dev/null
+++ b/microservices-self-registration/contextservice/src/test/java/com/learning/contextservice/ContextControllerTest.java
@@ -0,0 +1,49 @@
+package com.learning.contextservice;
+
+import com.learning.contextservice.client.GreetingServiceClient;
+import org.hamcrest.Matchers;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.http.MediaType;
+import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
+
+@SpringBootTest(classes = ContextserviceApplication.class)
+@AutoConfigureMockMvc
+@Import(TestConfig.class)
+class ContextControllerTest {
+
+ @Autowired
+ private MockMvc mockMvc;
+
+ @MockitoBean
+ private GreetingServiceClient greetingServiceClient;
+
+ @Value("${user.region}")
+ private String userRegion;
+
+ @Test
+ void shouldReturnContextGreeting() throws Exception{
+ Mockito.when(greetingServiceClient.getGreeting()).thenReturn("Mocked Hello");
+
+ mockMvc.perform(MockMvcRequestBuilders.get("/context")
+ .accept(MediaType.TEXT_PLAIN))
+ .andExpect(MockMvcResultMatchers.status().isOk())
+ .andExpect(MockMvcResultMatchers.content().string("The Greeting Service says: Mocked Hello from Chennai, Tamil Nadu, India"));
+ }
+
+ @Test
+ void shouldReturnContextServiceHealthStatusUp() throws Exception {
+ mockMvc.perform(MockMvcRequestBuilders.get("/actuator/health"))
+ .andExpect(MockMvcResultMatchers.status().isOk())
+ .andExpect(MockMvcResultMatchers.content().string(Matchers.containsString("\"status\":\"UP\"")));
+ }
+}
diff --git a/microservices-self-registration/contextservice/src/test/java/com/learning/contextservice/ContextserviceApplicationTests.java b/microservices-self-registration/contextservice/src/test/java/com/learning/contextservice/ContextserviceApplicationTests.java
new file mode 100644
index 000000000000..a5d5c869c664
--- /dev/null
+++ b/microservices-self-registration/contextservice/src/test/java/com/learning/contextservice/ContextserviceApplicationTests.java
@@ -0,0 +1,17 @@
+package com.learning.contextservice;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class ContextserviceApplicationTests {
+
+ @Test
+ void contextLoads() {
+ // This is a basic integration test that checks if the Spring Application Context loads successfully.
+ // If the context loads without any exceptions, the test is considered passing.
+ // It is often left empty as the act of loading the context is the primary verification.
+ // You can add specific assertions here if you want to verify the presence or state of certain beans.
+ }
+
+}
diff --git a/microservices-self-registration/contextservice/src/test/java/com/learning/contextservice/TestConfig.java b/microservices-self-registration/contextservice/src/test/java/com/learning/contextservice/TestConfig.java
new file mode 100644
index 000000000000..f378f46f59df
--- /dev/null
+++ b/microservices-self-registration/contextservice/src/test/java/com/learning/contextservice/TestConfig.java
@@ -0,0 +1,17 @@
+package com.learning.contextservice;
+
+import com.learning.contextservice.client.GreetingServiceClient;
+import org.mockito.Mockito;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class TestConfig {
+
+ @Bean
+ public GreetingServiceClient greetingServiceClient() {
+ GreetingServiceClient mockClient = Mockito.mock(GreetingServiceClient.class);
+ Mockito.when(mockClient.getGreeting()).thenReturn("Mocked Hello");
+ return mockClient;
+ }
+}
diff --git a/microservices-self-registration/contextservice/src/test/java/com/learning/contextservice/myCustomHealthCheckTest.java b/microservices-self-registration/contextservice/src/test/java/com/learning/contextservice/myCustomHealthCheckTest.java
new file mode 100644
index 000000000000..129209469827
--- /dev/null
+++ b/microservices-self-registration/contextservice/src/test/java/com/learning/contextservice/myCustomHealthCheckTest.java
@@ -0,0 +1,33 @@
+package com.learning.contextservice;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.actuate.health.Health;
+import org.springframework.test.util.ReflectionTestUtils;
+import org.springframework.boot.actuate.health.Status;
+import static org.junit.jupiter.api.Assertions.*;
+
+class MyCustomHealthCheckTest {
+
+ @Test
+ void testHealthUp() {
+ MyCustomHealthCheck healthCheck = new MyCustomHealthCheck();
+ // Simulate a healthy state
+ ReflectionTestUtils.setField(healthCheck, "isHealthy", true);
+ Health health = healthCheck.health();
+ assertEquals(Status.UP, health.getStatus());
+ assertTrue(health.getDetails().containsKey("message"));
+ assertEquals("Service is running and scheduled checks are OK", health.getDetails().get("message"));
+ }
+
+ @Test
+ void testHealthDown() {
+ MyCustomHealthCheck healthCheck = new MyCustomHealthCheck();
+ // Simulate an unhealthy state
+ ReflectionTestUtils.setField(healthCheck, "isHealthy", false);
+ Health health = healthCheck.health();
+ assertEquals(Status.DOWN, health.getStatus());
+ assertTrue(health.getDetails().containsKey("error"));
+ assertEquals("Scheduled health checks failed", health.getDetails().get("error"));
+ }
+
+}
\ No newline at end of file
diff --git a/microservices-self-registration/eurekaserver/.gitattributes b/microservices-self-registration/eurekaserver/.gitattributes
new file mode 100644
index 000000000000..3b41682ac579
--- /dev/null
+++ b/microservices-self-registration/eurekaserver/.gitattributes
@@ -0,0 +1,2 @@
+/mvnw text eol=lf
+*.cmd text eol=crlf
diff --git a/microservices-self-registration/eurekaserver/.gitignore b/microservices-self-registration/eurekaserver/.gitignore
new file mode 100644
index 000000000000..549e00a2a96f
--- /dev/null
+++ b/microservices-self-registration/eurekaserver/.gitignore
@@ -0,0 +1,33 @@
+HELP.md
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
diff --git a/microservices-self-registration/eurekaserver/pom.xml b/microservices-self-registration/eurekaserver/pom.xml
new file mode 100644
index 000000000000..b1a4b26cf4f4
--- /dev/null
+++ b/microservices-self-registration/eurekaserver/pom.xml
@@ -0,0 +1,55 @@
+
+
+ 4.0.0
+
+ org.springframework.boot
+ spring-boot-starter-parent
+ 3.4.4
+
+ com.learning
+ eurekaserver
+ 0.0.1-SNAPSHOT
+ eurekaserver
+ eurekaserver
+
+
+ 2024.0.1
+
+
+
+ org.springframework.cloud
+ spring-cloud-starter-netflix-eureka-server
+
+
+ org.springframework.boot
+ spring-boot-starter-test
+ test
+
+
+
+
+
+ org.springframework.cloud
+ spring-cloud-dependencies
+ ${spring-cloud.version}
+ pom
+ import
+
+
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+
+
+
+
+
\ No newline at end of file
diff --git a/microservices-self-registration/eurekaserver/src/main/java/com/learning/eurekaserver/EurekaserverApplication.java b/microservices-self-registration/eurekaserver/src/main/java/com/learning/eurekaserver/EurekaserverApplication.java
new file mode 100644
index 000000000000..80b3d904ff4c
--- /dev/null
+++ b/microservices-self-registration/eurekaserver/src/main/java/com/learning/eurekaserver/EurekaserverApplication.java
@@ -0,0 +1,15 @@
+package com.learning.eurekaserver;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
+
+@SpringBootApplication
+@EnableEurekaServer
+public class EurekaserverApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(EurekaserverApplication.class, args);
+ }
+
+}
diff --git a/microservices-self-registration/eurekaserver/src/main/resources/application.yml b/microservices-self-registration/eurekaserver/src/main/resources/application.yml
new file mode 100644
index 000000000000..51f8a815d251
--- /dev/null
+++ b/microservices-self-registration/eurekaserver/src/main/resources/application.yml
@@ -0,0 +1,10 @@
+server:
+ port: 8761
+
+eureka:
+ client:
+ register-with-eureka: false
+ fetch-registry: false
+ server:
+ enable-self-preservation: true
+
diff --git a/microservices-self-registration/eurekaserver/src/test/java/com/learning/eurekaserver/EurekaserverApplicationTests.java b/microservices-self-registration/eurekaserver/src/test/java/com/learning/eurekaserver/EurekaserverApplicationTests.java
new file mode 100644
index 000000000000..b5150fefa940
--- /dev/null
+++ b/microservices-self-registration/eurekaserver/src/test/java/com/learning/eurekaserver/EurekaserverApplicationTests.java
@@ -0,0 +1,17 @@
+package com.learning.eurekaserver;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class EurekaserverApplicationTests {
+
+ @Test
+ void contextLoads() {
+ // This is a basic integration test that checks if the Spring Application Context loads successfully.
+ // If the context loads without any exceptions, the test is considered passing.
+ // It is often left empty as the act of loading the context is the primary verification.
+ // You can add specific assertions here if you want to verify the presence or state of certain beans.
+ }
+
+}
diff --git a/microservices-self-registration/greetingservice/.gitattributes b/microservices-self-registration/greetingservice/.gitattributes
new file mode 100644
index 000000000000..3b41682ac579
--- /dev/null
+++ b/microservices-self-registration/greetingservice/.gitattributes
@@ -0,0 +1,2 @@
+/mvnw text eol=lf
+*.cmd text eol=crlf
diff --git a/microservices-self-registration/greetingservice/.gitignore b/microservices-self-registration/greetingservice/.gitignore
new file mode 100644
index 000000000000..549e00a2a96f
--- /dev/null
+++ b/microservices-self-registration/greetingservice/.gitignore
@@ -0,0 +1,33 @@
+HELP.md
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
diff --git a/microservices-self-registration/greetingservice/application.log.2025-04-05.0.gz b/microservices-self-registration/greetingservice/application.log.2025-04-05.0.gz
new file mode 100644
index 000000000000..93d6a2e62ac1
Binary files /dev/null and b/microservices-self-registration/greetingservice/application.log.2025-04-05.0.gz differ
diff --git a/microservices-self-registration/greetingservice/application.log.2025-04-07.0.gz b/microservices-self-registration/greetingservice/application.log.2025-04-07.0.gz
new file mode 100644
index 000000000000..40c96f702853
Binary files /dev/null and b/microservices-self-registration/greetingservice/application.log.2025-04-07.0.gz differ
diff --git a/microservices-self-registration/greetingservice/application.log.2025-04-09.0.gz b/microservices-self-registration/greetingservice/application.log.2025-04-09.0.gz
new file mode 100644
index 000000000000..59f2cbc3c8df
Binary files /dev/null and b/microservices-self-registration/greetingservice/application.log.2025-04-09.0.gz differ
diff --git a/microservices-self-registration/greetingservice/application.log.2025-04-11.0.gz b/microservices-self-registration/greetingservice/application.log.2025-04-11.0.gz
new file mode 100644
index 000000000000..62d73c3020c1
Binary files /dev/null and b/microservices-self-registration/greetingservice/application.log.2025-04-11.0.gz differ
diff --git a/microservices-self-registration/greetingservice/pom.xml b/microservices-self-registration/greetingservice/pom.xml
new file mode 100644
index 000000000000..45988a145866
--- /dev/null
+++ b/microservices-self-registration/greetingservice/pom.xml
@@ -0,0 +1,69 @@
+
+
+ 4.0.0
+
+ org.springframework.boot
+ spring-boot-starter-parent
+ 3.4.4
+
+ com.learning
+ greetingservice
+ 0.0.1-SNAPSHOT
+ greetingservice
+ greetingservice
+
+
+ 2024.0.1
+
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+
+ org.projectlombok
+ lombok
+ 1.18.38
+ provided
+
+
+ org.springframework.cloud
+ spring-cloud-starter-netflix-eureka-client
+
+
+ org.springframework.boot
+ spring-boot-starter-test
+ test
+
+
+ org.springframework.boot
+ spring-boot-starter-actuator
+
+
+
+
+
+ org.springframework.cloud
+ spring-cloud-dependencies
+ ${spring-cloud.version}
+ pom
+ import
+
+
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+
+
+
+
+
\ No newline at end of file
diff --git a/microservices-self-registration/greetingservice/src/main/java/com/learning/greetingservice/GreetingserviceApplication.java b/microservices-self-registration/greetingservice/src/main/java/com/learning/greetingservice/GreetingserviceApplication.java
new file mode 100644
index 000000000000..7a549a084284
--- /dev/null
+++ b/microservices-self-registration/greetingservice/src/main/java/com/learning/greetingservice/GreetingserviceApplication.java
@@ -0,0 +1,17 @@
+package com.learning.greetingservice;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
+import org.springframework.context.annotation.ComponentScan;
+
+@SpringBootApplication
+@EnableDiscoveryClient
+@ComponentScan("com.learning.greetingservice.controller")
+public class GreetingserviceApplication {
+
+ public static void main(String[] args) {
+ SpringApplication.run(GreetingserviceApplication.class, args);
+ }
+
+}
diff --git a/microservices-self-registration/greetingservice/src/main/java/com/learning/greetingservice/MyCustomHealthCheck.java b/microservices-self-registration/greetingservice/src/main/java/com/learning/greetingservice/MyCustomHealthCheck.java
new file mode 100644
index 000000000000..218a4ad002d4
--- /dev/null
+++ b/microservices-self-registration/greetingservice/src/main/java/com/learning/greetingservice/MyCustomHealthCheck.java
@@ -0,0 +1,41 @@
+package com.learning.greetingservice;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.actuate.health.Health;
+import org.springframework.boot.actuate.health.HealthIndicator;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+@Component("myCustomHealthCheck")
+public class MyCustomHealthCheck implements HealthIndicator {
+
+ private static final Logger log = LoggerFactory.getLogger(MyCustomHealthCheck.class);
+
+ private volatile boolean isHealthy = true;
+
+ @Scheduled(fixedRate = 5000) // Run every 5 seconds
+ public void updateHealthStatus() {
+ // Perform checks here to determine the current health
+ // For example, check database connectivity, external service availability, etc.
+ isHealthy = performHealthCheck();
+ log.info("Update health status : {}", isHealthy);
+ }
+
+ boolean performHealthCheck() {
+ boolean current = System.currentTimeMillis() % 10000 < 5000; // Simulate fluctuating health
+ log.debug("Performing health check, current status: {}", current);
+ return current; // Simulate fluctuating health
+ }
+
+ @Override
+ public Health health() {
+ if (isHealthy) {
+ log.info("Health check successful, service is UP");
+ return Health.up().withDetail("message", "Service is running and scheduled checks are OK").build();
+ } else {
+ log.warn("Health check failed, service is DOWN");
+ return Health.down().withDetail("error", "Scheduled health checks failed").build();
+ }
+ }
+}
diff --git a/microservices-self-registration/greetingservice/src/main/java/com/learning/greetingservice/controller/GreetingsController.java b/microservices-self-registration/greetingservice/src/main/java/com/learning/greetingservice/controller/GreetingsController.java
new file mode 100644
index 000000000000..ea385beb1abe
--- /dev/null
+++ b/microservices-self-registration/greetingservice/src/main/java/com/learning/greetingservice/controller/GreetingsController.java
@@ -0,0 +1,13 @@
+package com.learning.greetingservice.controller;
+
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class GreetingsController {
+
+ @GetMapping("/greeting")
+ public String getGreeting() {
+ return "Hello";
+ }
+}
diff --git a/microservices-self-registration/greetingservice/src/main/resources/application.yml b/microservices-self-registration/greetingservice/src/main/resources/application.yml
new file mode 100644
index 000000000000..adcfac884c2b
--- /dev/null
+++ b/microservices-self-registration/greetingservice/src/main/resources/application.yml
@@ -0,0 +1,22 @@
+server:
+ port: 8081
+
+spring:
+ application:
+ name: greetingservice
+eureka:
+ client:
+ service-url.defaultZone: http://localhost:8761/eureka
+
+management:
+ endpoint:
+ health:
+ show-details: always
+ web:
+ exposure:
+ include: health
+
+logging:
+ file:
+ name: application.log
+
diff --git a/microservices-self-registration/greetingservice/src/test/java/com/learning/greetingservice/GreetingserviceApplicationTests.java b/microservices-self-registration/greetingservice/src/test/java/com/learning/greetingservice/GreetingserviceApplicationTests.java
new file mode 100644
index 000000000000..945898278aa9
--- /dev/null
+++ b/microservices-self-registration/greetingservice/src/test/java/com/learning/greetingservice/GreetingserviceApplicationTests.java
@@ -0,0 +1,17 @@
+package com.learning.greetingservice;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class GreetingserviceApplicationTests {
+
+ @Test
+ void contextLoads() {
+ // This is a basic integration test that checks if the Spring Application Context loads successfully.
+ // If the context loads without any exceptions, the test is considered passing.
+ // It is often left empty as the act of loading the context is the primary verification.
+ // You can add specific assertions here if you want to verify the presence or state of certain beans.
+ }
+
+}
diff --git a/microservices-self-registration/greetingservice/src/test/java/com/learning/greetingservice/MyCustomHealthCheckTest.java b/microservices-self-registration/greetingservice/src/test/java/com/learning/greetingservice/MyCustomHealthCheckTest.java
new file mode 100644
index 000000000000..8ba8b2a30f93
--- /dev/null
+++ b/microservices-self-registration/greetingservice/src/test/java/com/learning/greetingservice/MyCustomHealthCheckTest.java
@@ -0,0 +1,22 @@
+package com.learning.greetingservice;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.actuate.health.Health;
+import org.springframework.test.util.ReflectionTestUtils;
+import org.springframework.boot.actuate.health.Status;
+import static org.junit.jupiter.api.Assertions.*;
+
+class MyCustomHealthCheckTest {
+
+ @Test
+ void testHealthUp() {
+ MyCustomHealthCheck healthCheck = new MyCustomHealthCheck();
+ // Simulate a healthy state
+ ReflectionTestUtils.setField(healthCheck, "isHealthy", true);
+ Health health = healthCheck.health();
+ assertEquals(Status.UP, health.getStatus());
+ assertTrue(health.getDetails().containsKey("message"));
+ assertEquals("Service is running and scheduled checks are OK", health.getDetails().get("message"));
+ }
+
+}
\ No newline at end of file
diff --git a/microservices-self-registration/greetingservice/src/test/java/com/learning/greetingservice/controller/GreetingControllerTest.java b/microservices-self-registration/greetingservice/src/test/java/com/learning/greetingservice/controller/GreetingControllerTest.java
new file mode 100644
index 000000000000..5ae98c8b6aeb
--- /dev/null
+++ b/microservices-self-registration/greetingservice/src/test/java/com/learning/greetingservice/controller/GreetingControllerTest.java
@@ -0,0 +1,36 @@
+package com.learning.greetingservice.controller;
+
+import com.learning.greetingservice.GreetingserviceApplication;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.http.MediaType;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
+
+@SpringBootTest(classes = GreetingserviceApplication.class)
+@AutoConfigureMockMvc
+@ActiveProfiles("test")
+class GreetingControllerTest {
+
+ @Autowired
+ private MockMvc mockMvc;
+
+ @Test
+ void shouldReturnGreeting() throws Exception{
+ mockMvc.perform(MockMvcRequestBuilders.get("/greeting")
+ .accept(MediaType.TEXT_PLAIN))
+ .andExpect(MockMvcResultMatchers.status().isOk())
+ .andExpect(MockMvcResultMatchers.content().string("Hello"));
+ }
+
+ @Test
+ void shouldReturnHealthStatusUp() throws Exception{
+ mockMvc.perform(MockMvcRequestBuilders.get("/actuator/health"))
+ .andExpect(MockMvcResultMatchers.status().isOk())
+ .andExpect(MockMvcResultMatchers.content().string(org.hamcrest.Matchers.containsString("\"status\":\"UP\"")));
+ }
+}
diff --git a/microservices-self-registration/pom.xml b/microservices-self-registration/pom.xml
new file mode 100644
index 000000000000..4b708cb0eb12
--- /dev/null
+++ b/microservices-self-registration/pom.xml
@@ -0,0 +1,63 @@
+
+
+
+
+ java-design-patterns
+ com.iluwatar
+ 1.26.0-SNAPSHOT
+
+ 4.0.0
+ microservices-self-registration
+ pom
+
+ eurekaserver
+ greetingservice
+ contextservice
+
+
+
+ 21
+ ${java.version}
+ ${java.version}
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+ 3.8.1
+ ${maven.compiler.source}
+ ${maven.compiler.target}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index e91832d03358..5926820b7fb4 100644
--- a/pom.xml
+++ b/pom.xml
@@ -48,7 +48,7 @@
0.8.13
1.4
- 4.7.0
+ 4.17.0
2.11.0
6.0.0
1.1.0
@@ -71,7 +71,6 @@
Java Design Patterns
-
abstract-document
abstract-factory
active-object
@@ -107,6 +106,7 @@
converter
curiously-recurring-template-pattern
currying
+ dao-factory
data-access-object
data-bus
data-locality
@@ -167,6 +167,7 @@
microservices-distributed-tracing
microservices-idempotent-consumer
microservices-log-aggregation
+ microservices-self-registration
model-view-controller
model-view-intent
model-view-presenter
@@ -242,11 +243,11 @@
update-method
value-object
version-number
+ view-helper
virtual-proxy
visitor
backpressure
actor-model
-
diff --git a/view-helper/README.md b/view-helper/README.md
new file mode 100644
index 000000000000..fbc93acba6fd
--- /dev/null
+++ b/view-helper/README.md
@@ -0,0 +1,98 @@
+---
+title: "View Helper Pattern in Java: Simplifying Presentation Logic in MVC Applications"
+shortTitle: View Helper
+description: "Discover the View Helper Design Pattern in Java, a powerful technique for separating view-related logic from business logic in MVC-based web applications. This pattern enhances maintainability, reusability, and testability by delegating complex UI operations to reusable helper components. Ideal for developers aiming to keep views clean and focused on presentation."
+category: Architectural
+language: en
+tag:
+ - Architecture
+ - Presentation
+ - Decoupling
+ - Code reuse
+---
+
+## Intent of View Helper Design Pattern
+The View Helper Design Pattern separates presentation logic from the view by delegating complex UI tasks — like formatting or conditional display — to reusable helper components. This keeps views clean, promotes reuse, and aligns with the MVC principle of separating concerns between the view and the business logic.
+
+## Detailed Explanation with Real‑World Analogy
+Real‑world example
+> Imagine you're putting together a slideshow for a business presentation. You focus on arranging the slides, choosing the layout, and telling the story. But for tasks like resizing images, formatting charts, or converting data into visual form, you use tools or templates that automate those parts.
+>
+> In this analogy, you are the view, and the tools/templates are the helpers. They handle the heavy lifting behind the scenes so you can concentrate on the presentation. Similarly, in the View Helper pattern, the view delegates logic-heavy tasks—such as formatting or conditionally displaying data—to helper classes, keeping the view layer clean and presentation-focused.
+
+### In plain words
+> The View Helper pattern is about keeping your UI code clean by moving any logic—like formatting, calculations, or decision-making—into separate helper classes. Instead of stuffing all the logic into the HTML or template files, you delegate it to helpers, so the view just focuses on showing the final result.
+
+### Sequence diagram
+
+
+## Programmatic Example of View Helper Pattern in Java
+Raw domain object
+```java
+public record Product(String name, BigDecimal price, LocalDate releaseDate, boolean discounted) {}
+```
+
+View model object for display
+```java
+public record ProductViewModel(String name, String price, String releasedDate) {}
+```
+
+View Helper formats data for display
+```java
+class ProductViewHelper implements ViewHelper {
+
+ private static final String DISCOUNT_TAG = " (ON SALE)";
+
+ public ProductViewModel prepare(Product product) {
+ var displayName = product.name() + (product.discounted() ? DISCOUNT_TAG : "");
+ var priceWithCurrency = NumberFormat.getCurrencyInstance(US).format(product.price());
+ var formattedDate = product.releaseDate().format(ISO_DATE);
+
+ return new ProductViewModel(displayName, priceWithCurrency, formattedDate);
+ }
+}
+```
+
+View renders the formatted data
+```java
+public class ConsoleProductView implements View {
+
+ @Override
+ public void render(ProductViewModel productViewModel) {
+ LOGGER.info(productViewModel.toString());
+ }
+}
+```
+The `App.java` class simulates how the View Helper pattern works in a real application. It starts with a raw `Product` object containing unformatted data.
+Then it:
+1. Initializes a helper (`ProductViewHelper`) to format the product data for display.
+1. Creates a view (`ConsoleProductView`) to render the formatted data.
+1. Uses a controller (`ProductController`) to coordinate the flow between raw data, helper logic, and view rendering.
+
+Finally, it simulates a user request by passing the product to the controller, which prepares the view model using the helper and displays it using the view. This demonstrates a clean separation between data, presentation logic, and rendering.
+
+## When to Use the View Helper Pattern in Java
+Use the View Helper pattern when your view layer starts containing logic such as formatting data, applying conditional styles, or transforming domain objects for display. It's especially useful in MVC architectures where you want to keep views clean and focused on rendering, while delegating non-trivial presentation logic to reusable helper classes. This pattern helps improve maintainability, testability, and separation of concerns in your application's UI layer.
+
+## Real‑World Uses of View Helper Pattern in Java
+The View Helper pattern is widely used in web frameworks that follow the MVC architecture. In Java-based web applications (e.g., JSP, Spring MVC), it's common to use helper classes or utility methods to format dates, currencies, or apply conditional logic before rendering views. Technologies like Thymeleaf or JSF often rely on custom tags or expression helpers to achieve the same effect.
+
+## Benefits and Trade‑offs
+Benefits:
+* Separation of concerns: Keeps view templates clean by moving logic into dedicated helpers.
+* Reusability: Common formatting and display logic can be reused across multiple views.
+* Improved maintainability: Easier to update presentation logic without touching the view.
+* Testability: Helpers can be unit tested independently from the UI layer.
+
+Trade‑offs:
+* Added complexity: Introduces extra classes, which may feel unnecessary for very simple views.
+* Overuse risk: Excessive use of helpers can spread logic thinly across many files, making it harder to trace behavior.
+* Tight coupling risk: If not designed carefully, helpers can become tightly coupled to specific views or data formats.
+
+## Related Java Design Patterns
+* [Model-View-Controller (MVC)](https://java-design-patterns.com/patterns/model-view-controller/): View Helper supports the View layer in MVC by offloading logic from the view to helper classes.
+* [Template Method](https://java-design-patterns.com/patterns/template-method/): Can structure the steps of rendering or data transformation, with helpers handling specific formatting tasks.
+* [Data Transfer Object (DTO)](https://java-design-patterns.com/patterns/data-transfer-object/): Often used alongside View Helper when transferring raw data that needs formatting before being displayed.
+
+## References & Credits
+* [Core J2EE Patterns: View Helper.](https://www.oracle.com/java/technologies/viewhelper.html)
diff --git a/view-helper/etc/view-helper-sequence-diagram.png b/view-helper/etc/view-helper-sequence-diagram.png
new file mode 100644
index 000000000000..22e53c6b8afe
Binary files /dev/null and b/view-helper/etc/view-helper-sequence-diagram.png differ
diff --git a/view-helper/etc/view-helper-sequence-diagram.puml b/view-helper/etc/view-helper-sequence-diagram.puml
new file mode 100644
index 000000000000..d5be27e51510
--- /dev/null
+++ b/view-helper/etc/view-helper-sequence-diagram.puml
@@ -0,0 +1,15 @@
+@startuml
+actor Client
+participant Controller
+participant ViewHelper
+participant View
+participant Product
+participant ProductViewModel
+
+Client -> Controller : handle(product)
+Controller -> ViewHelper : prepare(product)
+ViewHelper -> Product : access data
+ViewHelper -> ProductViewModel : return formatted view model
+Controller -> View : render(viewModel)
+View -> Console : display output
+@enduml
\ No newline at end of file
diff --git a/view-helper/etc/view-helper.png b/view-helper/etc/view-helper.png
new file mode 100644
index 000000000000..9550b80d7acb
Binary files /dev/null and b/view-helper/etc/view-helper.png differ
diff --git a/view-helper/etc/view-helper.puml b/view-helper/etc/view-helper.puml
new file mode 100644
index 000000000000..cbc4a57d31ff
--- /dev/null
+++ b/view-helper/etc/view-helper.puml
@@ -0,0 +1,45 @@
+@startuml
+package com.iluwatar.viewhelper {
+ interface View {
+ +render(T model)
+ }
+
+ interface ViewHelper {
+ +prepare(S source): T
+ }
+
+ class Product {
+ -name: String
+ -price: BigDecimal
+ -releaseDate: LocalDate
+ -discounted: boolean
+ }
+
+ class ProductViewModel {
+ -name: String
+ -price: String
+ -releasedDate: String
+ }
+
+ class ProductViewHelper {
+ +prepare(Product): ProductViewModel
+ }
+
+ class ConsoleProductView {
+ +render(ProductViewModel)
+ }
+
+ class ProductController {
+ -helper: ViewHelper
+ -view: View
+ +handle(Product)
+ }
+}
+Product --> ProductViewHelper
+ProductViewHelper ..|> ViewHelper
+ConsoleProductView ..|> View
+ProductViewHelper --> ProductViewModel
+ProductController --> ProductViewHelper
+ProductController --> ConsoleProductView
+
+@enduml
\ No newline at end of file
diff --git a/view-helper/pom.xml b/view-helper/pom.xml
new file mode 100644
index 000000000000..e2f3afca3a08
--- /dev/null
+++ b/view-helper/pom.xml
@@ -0,0 +1,70 @@
+
+
+
+ 4.0.0
+
+ com.iluwatar
+ java-design-patterns
+ 1.26.0-SNAPSHOT
+
+ view-helper
+
+
+ org.slf4j
+ slf4j-api
+
+
+ ch.qos.logback
+ logback-classic
+
+
+ org.junit.jupiter
+ junit-jupiter-engine
+ test
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-assembly-plugin
+
+
+
+
+
+ com.iluwatar.value.object.App
+
+
+
+
+
+
+
+
+
diff --git a/view-helper/src/main/java/com/iluwatar/viewhelper/App.java b/view-helper/src/main/java/com/iluwatar/viewhelper/App.java
new file mode 100644
index 000000000000..e427bc8f5e9b
--- /dev/null
+++ b/view-helper/src/main/java/com/iluwatar/viewhelper/App.java
@@ -0,0 +1,52 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.iluwatar.viewhelper;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+
+/** The main application class that sets up and runs the View Helper pattern demo. */
+public class App {
+ /**
+ * The entry point of the application.
+ *
+ * @param args the command line arguments
+ */
+ public static void main(String[] args) {
+ // Raw Product data (no formatting, no UI tags)
+ var product =
+ new Product(
+ "Design patterns book", new BigDecimal("18.90"), LocalDate.of(2025, 4, 19), true);
+
+ // Create view, viewHelper and viewHelper
+ var helper = new ProductViewHelper();
+ var view = new ConsoleProductView();
+ var controller = new ProductController(helper, view);
+
+ // Handle “request”
+ controller.handle(product);
+ }
+}
diff --git a/view-helper/src/main/java/com/iluwatar/viewhelper/ConsoleProductView.java b/view-helper/src/main/java/com/iluwatar/viewhelper/ConsoleProductView.java
new file mode 100644
index 000000000000..7f215a7514f6
--- /dev/null
+++ b/view-helper/src/main/java/com/iluwatar/viewhelper/ConsoleProductView.java
@@ -0,0 +1,36 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.viewhelper;
+
+import lombok.extern.slf4j.Slf4j;
+
+/** Renders {@link ProductViewModel} to the console. */
+@Slf4j
+public class ConsoleProductView implements View {
+ @Override
+ public void render(ProductViewModel productViewModel) {
+ LOGGER.info(productViewModel.toString());
+ }
+}
diff --git a/view-helper/src/main/java/com/iluwatar/viewhelper/Product.java b/view-helper/src/main/java/com/iluwatar/viewhelper/Product.java
new file mode 100644
index 000000000000..a0a75cf24188
--- /dev/null
+++ b/view-helper/src/main/java/com/iluwatar/viewhelper/Product.java
@@ -0,0 +1,31 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.viewhelper;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+
+/** Definition of product. */
+public record Product(String name, BigDecimal price, LocalDate releaseDate, boolean discounted) {}
diff --git a/view-helper/src/main/java/com/iluwatar/viewhelper/ProductController.java b/view-helper/src/main/java/com/iluwatar/viewhelper/ProductController.java
new file mode 100644
index 000000000000..836f34a33167
--- /dev/null
+++ b/view-helper/src/main/java/com/iluwatar/viewhelper/ProductController.java
@@ -0,0 +1,49 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.viewhelper;
+
+/**
+ * Controller delegates a {@link Product} to {@link ProductViewHelper} and then to {@link
+ * ConsoleProductView}.
+ */
+public class ProductController {
+
+ private final ViewHelper viewHelper;
+ private final View view;
+
+ public ProductController(
+ ViewHelper viewHelper, View view) {
+ this.viewHelper = viewHelper;
+ this.view = view;
+ }
+
+ /**
+ * Passes the product to the helper for formatting and then forwards formatted product to the
+ * view.
+ */
+ public void handle(Product product) {
+ view.render(viewHelper.prepare(product));
+ }
+}
diff --git a/view-helper/src/main/java/com/iluwatar/viewhelper/ProductViewHelper.java b/view-helper/src/main/java/com/iluwatar/viewhelper/ProductViewHelper.java
new file mode 100644
index 000000000000..4c739e9f14a8
--- /dev/null
+++ b/view-helper/src/main/java/com/iluwatar/viewhelper/ProductViewHelper.java
@@ -0,0 +1,45 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.viewhelper;
+
+import static java.time.format.DateTimeFormatter.ISO_DATE;
+import static java.util.Locale.US;
+
+import java.text.NumberFormat;
+
+/** Formats a {@link Product} into a {@link ProductViewModel}. */
+public class ProductViewHelper implements ViewHelper {
+
+ private static final String DISCOUNT_TAG = " ON SALE";
+
+ @Override
+ public ProductViewModel prepare(Product product) {
+ var displayName = product.name() + (product.discounted() ? DISCOUNT_TAG : "");
+ var priceWithCurrency = NumberFormat.getCurrencyInstance(US).format(product.price());
+ var formattedDate = product.releaseDate().format(ISO_DATE);
+
+ return new ProductViewModel(displayName, priceWithCurrency, formattedDate);
+ }
+}
diff --git a/view-helper/src/main/java/com/iluwatar/viewhelper/ProductViewModel.java b/view-helper/src/main/java/com/iluwatar/viewhelper/ProductViewModel.java
new file mode 100644
index 000000000000..b133fc071da1
--- /dev/null
+++ b/view-helper/src/main/java/com/iluwatar/viewhelper/ProductViewModel.java
@@ -0,0 +1,28 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.viewhelper;
+
+/** Class defining formatted display data of a {@link Product}. */
+public record ProductViewModel(String name, String price, String releasedDate) {}
diff --git a/view-helper/src/main/java/com/iluwatar/viewhelper/View.java b/view-helper/src/main/java/com/iluwatar/viewhelper/View.java
new file mode 100644
index 000000000000..7bc822166885
--- /dev/null
+++ b/view-helper/src/main/java/com/iluwatar/viewhelper/View.java
@@ -0,0 +1,30 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.viewhelper;
+
+public interface View {
+
+ void render(V data);
+}
diff --git a/view-helper/src/main/java/com/iluwatar/viewhelper/ViewHelper.java b/view-helper/src/main/java/com/iluwatar/viewhelper/ViewHelper.java
new file mode 100644
index 000000000000..68756f46585d
--- /dev/null
+++ b/view-helper/src/main/java/com/iluwatar/viewhelper/ViewHelper.java
@@ -0,0 +1,29 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.viewhelper;
+
+public interface ViewHelper {
+ V prepare(M source);
+}
diff --git a/view-helper/src/test/java/com/iluwatar/viewhelper/AppTest.java b/view-helper/src/test/java/com/iluwatar/viewhelper/AppTest.java
new file mode 100644
index 000000000000..bc4a31cc43a8
--- /dev/null
+++ b/view-helper/src/test/java/com/iluwatar/viewhelper/AppTest.java
@@ -0,0 +1,39 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.iluwatar.viewhelper;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+import org.junit.jupiter.api.Test;
+
+/** Application test */
+class AppTest {
+
+ @Test
+ void shouldExecuteApplicationWithoutException() {
+ assertDoesNotThrow(() -> App.main(new String[] {}));
+ }
+}
diff --git a/view-helper/src/test/java/com/iluwatar/viewhelper/ProductViewHelperTest.java b/view-helper/src/test/java/com/iluwatar/viewhelper/ProductViewHelperTest.java
new file mode 100644
index 000000000000..49cc48556f47
--- /dev/null
+++ b/view-helper/src/test/java/com/iluwatar/viewhelper/ProductViewHelperTest.java
@@ -0,0 +1,60 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package com.iluwatar.viewhelper;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class ProductViewHelperTest {
+
+ private ProductViewHelper helper;
+
+ @BeforeEach
+ void setUp() {
+ helper = new ProductViewHelper();
+ }
+
+ @Test
+ void shouldFormatProductWithoutDiscount() {
+ var product = new Product("X", new BigDecimal("10.00"), LocalDate.of(2025, 1, 1), false);
+ ProductViewModel viewModel = helper.prepare(product);
+
+ assertEquals("X", viewModel.name());
+ assertEquals("$10.00", viewModel.price());
+ assertEquals("2025-01-01", viewModel.releasedDate());
+ }
+
+ @Test
+ void shouldFormatProductWithDiscount() {
+ var product = new Product("X", new BigDecimal("10.00"), LocalDate.of(2025, 1, 1), true);
+ ProductViewModel viewModel = helper.prepare(product);
+
+ assertEquals("X ON SALE", viewModel.name()); // locale follows JVM default
+ }
+}
