Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

#2373 feature add: Vertical Slice Architecture. #2828

Closed
wants to merge 17 commits into from
Closed
Show file tree
Hide file tree
Changes from 11 commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions pom.xml
Original file line number Diff line number Diff line change
Expand Up @@ -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>
Expand Down
62 changes: 62 additions & 0 deletions vertical-slice-architecture/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,62 @@
---
title: Vertical Slice Architecture
aka: Layer By Feature
sugan0tech marked this conversation as resolved.
Show resolved Hide resolved
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.

Copy link
Owner

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Would it be possible to add a minimal code example here?

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

instead of code examples, can it be project file structure?

Copy link
Owner

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yeah, I think we can improvise a bit here. Whatever describes the pattern most effectively.

## 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)
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
125 changes: 125 additions & 0 deletions vertical-slice-architecture/etc/vertical-slice-architecture.urm.puml
Original file line number Diff line number Diff line change
@@ -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
90 changes: 90 additions & 0 deletions vertical-slice-architecture/pom.xml
Original file line number Diff line number Diff line change
@@ -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>
Original file line number Diff line number Diff line change
@@ -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);
}

}
Loading
Loading