Merge branch 'Monolithic-Ecommerce'

Author: Mohaned Atef

Monolithic-Ecommerce/README.md renamed to monolithic-architecture/README.md

@@ -8,6 +8,9 @@
 Real-world Example
 > A traditional E-commerce website is the most straightforward example for a monolithic application as it is comprised of a catalogue of products, orders to be made, shopping carts, and payment processes that are all inseperable of each other.
 
+In Plain words
+>The monolithic design pattern structures an application as a single unified unit, where all components are tightly coupled and run within a single process.
+
 GeeksforGeeks states
 > Monolithic architecture, a traditional approach in system design, which contains all application components into a single codebase. This unified structure simplifies development and deployment processes, offering ease of management and tight integration. However, because of its rigidity, it is difficult to scale and maintain, which makes it difficult to adjust to changing needs.
 
@@ -109,7 +112,14 @@ public class EcommerceApp implements CommandLineRunner {
 >* Deployment Risks: A single failure can crash the entire application.
 >* Complex Maintenance: Harder to manage as the codebase grows.
 >* Limited Flexibility: Difficult to adopt new technologies for specific parts.
->
+
+## Real-World Applications of Monolithic architecture Pattern in Java
+>* E-Commerce Platforms
+>* Content Management Systems (CMS)
+>* Banking and Financial Systems
+>* Enterprise Resource Planning (ERP) Systems
+>* Retail Point of Sale (POS) Systems
+
 ## References
 >* [GeeksforGeeks](https://www.geeksforgeeks.org/monolithic-architecture-system-design/)
 >* [Wikipedia](https://en.wikipedia.org/wiki/Monolithic_application)

Monolithic-Ecommerce/etc/Monolithic-Ecommerce.urm.puml renamed to monolithic-architecture/etc/Monolithic-Ecommerce.urm.puml

@@ -0,0 +1,123 @@
+@startuml
+package com.iluwatar.monolithic.model {
+  class Orders {
+    - id : Long
+    - product : Products
+    - quantity : Integer
+    - totalPrice : Double
+    - user : User
+    + Orders()
+    + Orders(id : Long, user : User, product : Products, quantity : Integer, totalPrice : Double)
+    # canEqual(other : Object) : boolean
+    + equals(o : Object) : boolean
+    + getId() : Long
+    + getProduct() : Products
+    + getQuantity() : Integer
+    + getTotalPrice() : Double
+    + getUser() : User
+    + hashCode() : int
+    + setId(id : Long)
+    + setProduct(product : Products)
+    + setQuantity(quantity : Integer)
+    + setTotalPrice(totalPrice : Double)
+    + setUser(user : User)
+    + toString() : String
+  }
+  class Products {
+    - description : String
+    - id : Long
+    - name : String
+    - price : Double
+    - stock : Integer
+    + Products()
+    + Products(id : Long, name : String, description : String, price : Double, stock : Integer)
+    # canEqual(other : Object) : boolean
+    + equals(o : Object) : boolean
+    + getDescription() : String
+    + getId() : Long
+    + getName() : String
+    + getPrice() : Double
+    + getStock() : Integer
+    + hashCode() : int
+    + setDescription(description : String)
+    + setId(id : Long)
+    + setName(name : String)
+    + setPrice(price : Double)
+    + setStock(stock : Integer)
+    + toString() : String
+  }
+  class User {
+    - email : String
+    - id : Long
+    - name : String
+    - password : String
+    + User()
+    + User(id : Long, name : String, email : String, password : String)
+    # canEqual(other : Object) : boolean
+    + equals(o : Object) : boolean
+    + getEmail() : String
+    + getId() : Long
+    + getName() : String
+    + getPassword() : String
+    + hashCode() : int
+    + setEmail(email : String)
+    + setId(id : Long)
+    + setName(name : String)
+    + setPassword(password : String)
+    + toString() : String
+  }
+}
+package com.iluwatar.monolithic.repository {
+  interface OrderRepo {
+  }
+  interface ProductRepo {
+  }
+  interface UserRepo {
+    + findByEmail(String) : User {abstract}
+  }
+}
+package com.iluwatar.monolithic.controller {
+  class OrderCon {
+    - orderRepository : OrderRepo
+    - productRepository : ProductRepo
+    - userRepository : UserRepo
+    + OrderCon(orderRepository : OrderRepo, userRepository : UserRepo, productRepository : ProductRepo)
+    + placeOrder(userId : Long, productId : Long, quantity : Integer) : Orders
+  }
+  class ProductCon {
+    - productRepository : ProductRepo
+    + ProductCon(productRepository : ProductRepo)
+    + addProduct(product : Products) : Products
+    + getAllProducts() : List<Products>
+  }
+  class UserCon {
+    - userRepository : UserRepo
+    + UserCon(userRepository : UserRepo)
+    + registerUser(user : User) : User
+  }
+}
+package com.iluwatar.monolithic {
+  class EcommerceApp {
+    - log : Logger {static}
+    - orderService : OrderCon
+    - productService : ProductCon
+    - userService : UserCon
+    + EcommerceApp(userService : UserCon, productService : ProductCon, orderService : OrderCon)
+    # addProduct(scanner : Scanner)
+    + main(args : String[]) {static}
+    # placeOrder(scanner : Scanner)
+    # registerUser(scanner : Scanner)
+    + run(args : String[])
+  }
+}
+UserCon -->  "-userRepository" UserRepo
+Orders -->  "-user" User
+OrderCon -->  "-productRepository" ProductRepo
+OrderCon -->  "-userRepository" UserRepo
+OrderCon -->  "-orderRepository" OrderRepo
+EcommerceApp -->  "-userService" UserCon
+Orders -->  "-product" Products
+ProductCon -->  "-productRepository" ProductRepo
+EcommerceApp -->  "-productService" ProductCon
+EcommerceApp -->  "-orderService" OrderCon
+@enduml

monolithic-architecture/etc/monolithic-architecture.urm.puml

@@ -27,7 +27,7 @@
 -->
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+         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>
 
   <parent>
@@ -36,8 +36,7 @@
     <version>1.26.0-SNAPSHOT</version>
   </parent>
 
-  <artifactId>Monolithic-Ecommerce</artifactId>
-
+  <artifactId>monolithic-architecture</artifactId>
 
   <dependencies>
     <!-- Spring Boot Starter Web -->
@@ -80,6 +79,29 @@
       <scope>test</scope>
     </dependency>
   </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-assembly-plugin</artifactId>
+        <executions>
+          <execution>
+            <configuration>
+              <archive>
+                <manifest>
+                  <mainClass>com.iluwatar.monolithic.EcommerceApp</mainClass>
+                </manifest>
+              </archive>
+              <descriptorRefs>
+                <descriptorRef>jar-with-dependencies</descriptorRef>
+              </descriptorRefs>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
 </project>
 
 

Monolithic-Ecommerce/pom.xml renamed to monolithic-architecture/pom.xml

@@ -39,7 +39,16 @@
 
 /**
  * Main entry point for the Monolithic E-commerce application.
+ * ------------------------------------------------------------------------
+ * Monolithic architecture is a software design pattern where all components
+ * of the application (presentation, business logic, and data access layers)
+ * are part of a single unified codebase and deployable unit.
+ * ------------------------------------------------------------------------
+ * This example implements a monolithic architecture by integrating
+ * user management, product management, and order placement within
+ * the same application, sharing common resources and a single database.
  */
+
 @SpringBootApplication
 public class EcommerceApp implements CommandLineRunner {
 

Monolithic-Ecommerce/src/main/java/com/iluwatar/monolithic/EcommerceApp.java renamed to monolithic-architecture/src/main/java/com/iluwatar/monolithic/EcommerceApp.java

@@ -53,24 +53,18 @@ public OrderCon(OrderRepo orderRepository, UserRepo userRepository, ProductRepo
    * This function handles placing orders with all of its cases.
    * */
   public Orders placeOrder(Long userId, Long productId, Integer quantity) {
-    User user = userRepository.findById(userId).orElse(null);
-    if (user == null) {
-      throw new NonExistentUserException("User with ID " + userId + " not found");
-    }
-
-    Products product = productRepository.findById(productId).orElse(null);
-    if (product == null) {
-      throw new NonExistentProductException("Product with ID " + productId + " not found");
-    }
+    final User user = userRepository.findById(userId).orElseThrow(() -> new NonExistentUserException("User with ID " + userId + " not found"));
 
+    final Products product = productRepository.findById(productId).orElseThrow(() -> new NonExistentProductException("Product with ID " + productId + " not found"));
+    
     if (product.getStock() < quantity) {
       throw new InsufficientStockException("Not enough stock for product " + productId);
     }
 
     product.setStock(product.getStock() - quantity);
     productRepository.save(product);
 
-    Orders order = new Orders(null, user, product, quantity, product.getPrice() * quantity);
+    final Orders order = new Orders(null, user, product, quantity, product.getPrice() * quantity);
     return orderRepository.save(order);
   }
 }