#2373 feature add: Vertical Slice Architecture.

pom.xml

@@ -207,6 +207,7 @@
     <module>context-object</module>
     <module>thread-local-storage</module>
     <module>optimistic-offline-lock</module>
+    <module>vertical-slice-architecture</module>
     <module>crtp</module>
     <module>log-aggregation</module>
     <module>health-check</module>

vertical-slice-architecture/README.md

@@ -0,0 +1,62 @@
+---
+title: Vertical Slice Architecture
+aka: Layer By Feature
+category: Architectural
+language: en
+tag:
+- Decoupling
+---
+
+## Intent
+
+Organize the application according to its features.
+Each feature will comprise its distinct set of layers (Models, Services, Repository, and Controllers).
+
+## Explanation
+
+Real-World Examples (Consider E-commerce)
+
+> In the context of an e-commerce application, the concept of vertical slice architecture becomes clear.
+> Imagine you're building a backend service for an online store.
+> Initially, you may organize it with the typical grouping of controllers, models, and other components.
+> As the application grows, the need arises to implement new features.
+
+> For instance, you might have distinct layers for orders, customers, and products. However, as the application
+> evolves, you realize the necessity of integrating additional features like a Cart system and wishlists.
+> At this point, integrating these new features into the existing structure becomes challenging.
+> It demands significant dependency modifications and mocking, which can be time-consuming and error-prone.
+
+> This is where vertical slice architecture proves its value. 
+> By structuring the application based on features,
+> you create self-contained modules that encapsulate all the necessary components
+> (Models, Services, Repository, and Controllers) for a particular feature.
+> When you need to add new features, you can do so in a more isolated and manageable manner.
+
+In Plain Words
+
+> Vertical slice architecture is like organizing your toolbox.
+> Instead of having all your tools mixed together, you group them based on the type of task they perform.
+> This way, when you need a specific tool for a particular job,
+> you can quickly find it without rummaging through a jumble of items.
+
+> Similarly, in software development, vertical slice architecture involves organizing the codebase based on features. 
+> Each feature has its own self-contained set of components, making it easier to add, modify, or remove features without disrupting the entire application.
+
+## Class diagram
+
+![Vertical Slice Architecture](./etc/vertical-slice-architecture.urm.png)
+
+## Applicability
+
+Use Vertical Slice Architecture when
+
+* You want future modification ( new addition of features ).
+* You want to reduce the amount of mocking.
+* You want to make it more modular by feature.
+
+## Resources
+
+* [How to Implement Vertical Slice Architecture by Gary Woodfine](https://garywoodfine.com/implementing-vertical-slice-architecture/)
+* [youtube](https://www.youtube.com/watch?v=B1d95I7-zsw)
+* [medium](https://medium.com/sahibinden-technology/package-by-layer-vs-package-by-feature-7e89cde2ae3a)
+* [A reference application](https://github.com/sugan0tech/Event-Manager)

vertical-slice-architecture/etc/vertical-slice-architecture.urm.puml

@@ -0,0 +1,125 @@
+@startuml
+package com.iluwatar.vertical-slice-architecture {
+
+  !define ENTITY class
+  !define SERVICE class
+  !define REPOSITORY class
+  !define VIEW class
+
+  package Customer {
+    ENTITY Customer {
+      +id: int
+      name: String
+      email: String
+      +getId(): int
+      +getName(): String
+      +getEmail(): String
+      +builder(): Builder
+    }
+
+    SERVICE CustomerService {
+      +createCustomer(name: String, email: String): Customer
+      +getCustomerById(id: int): Customer
+      +getAllCustomers(): List<Customer>
+    }
+
+    REPOSITORY CustomerRepository {
+      +save(customer: Customer): Customer
+      +findById(id: int): Optional<Customer>
+      +findAll(): List<Customer>
+    }
+
+
+    VIEW CustomerView {
+      -customerService: CustomerService
+      -LOGGER: logger
+      +render(): void
+    }
+  }
+
+  package Product {
+    ENTITY Product {
+      +id: int
+      name: String
+      price: double
+      +getId(): int
+      +getName(): String
+      +getPrice(): Double
+      +builder(): Builder
+    }
+
+    SERVICE ProductService {
+      +createProduct(name: String, price: double): Product
+      +getProductById(id: int): Product
+      +getAllProducts(): List<Product>
+    }
+
+    REPOSITORY ProductRepository {
+      +save(product: Product): Product
+      +findById(id: int): Optional<Product>
+      +findAll(): List<Product>
+    }
+
+
+    VIEW ProductView {
+      -productService: ProductService
+      -LOGGER: logger
+      +render(): void
+    }
+  }
+
+  package Order {
+    ENTITY Orders {
+      +id: int
+      customer: Customer
+      product: Product
+      +getId(): int
+      +getCustomer(): Customer
+      +getProduct(): Product
+      +builder(): Builder
+    }
+
+    SERVICE OrderService {
+      +createOrder(customer: Customer, product: Product): void
+      +getOrderById(id: int): Orders
+      +getOrdersByCustomer(customer: Customer): List<Orders>
+    }
+
+    REPOSITORY OrderRepository {
+      +save(order: Orders): Orders
+      +findById(id: int): Optional<Orders>
+      +findByCustomer(customer: Customer): List<Orders>
+    }
+
+
+    VIEW OrderView {
+      -orderService: OrderService
+      -LOGGER: logger
+      +render(customer: Customer): void
+      +showAllOrders(orders: List<Orders>): void
+    }
+  }
+
+  class App {
+    +initializeData(): void
+    +run(): void
+  }
+
+  Customer.Customer --> Customer.CustomerService
+  Customer.CustomerService --> Customer.CustomerRepository
+  Customer.CustomerService --> Customer.CustomerView
+
+  Product.Product --> Product.ProductService
+  Product.ProductService --> Product.ProductRepository
+  Product.ProductService --> Product.ProductView
+
+  Order.Orders --> Order.OrderService
+  Order.OrderService --> Order.OrderRepository
+  Order.OrderService --> Order.OrderView
+
+  App --> Customer.CustomerService
+  App --> Product.ProductService
+  App --> Order.OrderService
+
+}
+@enduml

vertical-slice-architecture/pom.xml

@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    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.
+
+-->
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>vertical-slice-architecture</artifactId>
+    <parent>
+        <groupId>com.iluwatar</groupId>
+        <artifactId>java-design-patterns</artifactId>
+        <version>1.26.0-SNAPSHOT</version>
+    </parent>
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <configuration>
+                            <archive>
+                                <manifest>
+                                    <mainClass>com.iluwatar.vertical.slice.architecture.App</mainClass>
+                                </manifest>
+                            </archive>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

vertical-slice-architecture/src/main/java/com/iluwatar/verticalslicearchitecture/App.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.verticalslicearchitecture;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+/**
+ * This application is designed with a vertical slice architecture, organizing features such as
+ * customer management, order processing, and product catalog in separate modules. Each feature encapsulates
+ * its own set of components (Models, Services, Repository, and Controllers), promoting high cohesion
+ * within each module and low coupling between them. This architecture allows for seamless integration of new
+ * features and functionalities as the application evolves over time.
+ */
+
+@SpringBootApplication
+public class App {
+
+  public static void main(String[] args) {
+    SpringApplication.run(App.class, args);
+  }
+
+}