I would be overjoyed if you could support me as a referred member. However, the income I've received from my contributions on this platform has not proven sufficient to sustain the frequency of updates I'd hoped for. Facing this reality, I've made a difficult decision — to explore new income avenues. However, this isn't the end; rather, it's an exciting new beginning. I am thrilled to announce my upcoming Substack newsletter, where I'll delve into my investing system, harnessing the immense potential of IT technology and embracing a system-thinking approach to investment strategies. Rest assured, I will still be posting when inspiration strikes.
If you are interested, you can read this.
The system architecture plays an important role in software development, involving contributions from developers, irrespective of their formal architectural roles.
Architectural layering, a key design principle in software engineering, becomes increasingly vital as a system advances beyond its initial stages. This approach entails the division of the overall system into discrete levels, each shouldering independent responsibilities. The layers collaborate seamlessly to provide comprehensive functionality.
This article aims to offer a clear and systematic understanding of software architecture layering, emphasizing its fundamental role in building robust and scalable software systems.
The Importance of Architecture Layering
- Isolation of Concerns — This isolates different aspects of the system, allowing each layer to concentrate on specific tasks.
- Scalability — As the business complexity increases, architectural layering prevents issues like complex logic, module interdependence, and poor code scalability.
Examples of Layering
- MVC Architecture — A common application of layering where the model, view, and controller components are separated.
- Network Models (OSI and TCP/IP) — Extend to network architectures, like the OSI seven-layer model and the TCP/IP protocol's four-layer model.
Benefits of Architectural Layering
- Simplified Design — Each layer has a specific role, simplifying system design and fostering focus within layers.
- High Reuse — Universal functionalities within layers can be independently utilized in other designs, enhancing efficiency and minimizing redundancy.
- Scalability —Layering supports cost-effective horizontal scaling for targeted scalability. For example, if business logic affects performance, independently expanding the logic layer is more efficient than scaling the entire system.
Relationship with High-Concurrency Design
In high-concurrency design, managing multiple concurrent requests is essential for optimal system performance. Horizontal expansion supports this by providing scalability. When concurrent requests increase, adding servers helps distribute the workload. Each server operates independently, effectively handling a portion of the tasks, preventing bottlenecks, and ensuring efficient system operation.
Structuring Layered Architecture
To structure layered architecture effectively, clear hierarchical boundaries must be established. Although three-tier architecture initially offers well-defined boundaries, complexities in business logic can lead to blurred distinctions.
Example
// Presentation Layer
public class UserController {
private final UserService userService;
public UserController(UserService userService) {
this.userService = userService;
}
// Interface-specific behavior
public void handleUserRequest() {
// Handle user interface logic
userService.getUser();
}
}
// Logic Layer
public class UserService {
private final UserDB userDB;
public UserService(UserDB userDB) {
this.userDB = userDB;
}
// Business logic
public User getUser() {
// Logic to interact with User DB
User user = userDB.getUser();
// New requirement: Automatically create user if they don't exist
if (user == null) {
user = createUser();
}
// Additional logic for varied behaviors
return user;
}
private User createUser() {
// Logic to create a new user
return new User();
}
}
// Data Access Layer
public class UserDB {
// Data access logic
public User getUser() {
// Logic to retrieve user from the database
return null; // Placeholder for demonstration
}
}
// Domain Model
public class User {
// User properties and methods
}In this example, the UserController in the presentation layer manages user interface logic and delegates tasks to the UserService in the logic layer. The UserService interacts with the UserDB in the data access layer, demonstrating a layered architecture with distinct boundaries. This structure ensures maintainability and scalability as the system evolves.
Key Components of Architectural Layering
- Presentation Layer (Web UI) — Interfaces with users, displaying data results, and receiving instructions.
- Web Layer (Controller)—Handles UI-related tasks, including access control and parameter verification.
- API Layer — Manages APIs for external systems or client applications.
- Logic Layer (Service) — Implements complex business logic, focusing on specific functionalities and coordinating data flow.
- Data Access Layer (DAO) — Manages interaction between processing and storage, handling data retrieval and storage.
- Manager Layer (General Business Processing) —Orchestrates business processes, encapsulates third-party interfaces and coordinates data and logic flow.
- In API development, a layered architecture, encompassing RPC interfaces, basic platforms, and HTTP interfaces.
- Manager Layer —Provides high-level interfaces, linking the presentation layer to the service layer.
- Service Layer — Acts as an intermediary between the presentation layer and the data store, abstracting complexities.
- Web Layer (Controller) — The Platform Layer manages internal company logic, isolating internal and external usage for enhanced security.
- Data Access Layer (DAO) — Optionally segregated into an RPC service for innovative data retrieval and storage.
Inter-Layer Dependencies
Inter-layer dependencies control the flow of data between architectural layers, ensuring a structured and efficient system design.
In a three-tier architecture,
- Presentation Layer (Controller Layer)
- Receives user requests (input or interactions), processes user requests from the user interface, or interprets actions such as button clicks or form submissions.
- Direct requests to the service layer for core business logic execution.
- Map user actions to specific functionalities.
2. Logic Layer (Application Layer)
- Acts as an intermediary, receiving requests from the controller layer.
- Process requests, perform computations, and interact with the data layer.
- After processing, it returns results to the controller layer for further handling or presentation.
3. Data Access Layer (Data Layer)
- It acts as an adapter interface, facilitating smooth communication between the service and data layers.
- It isolates data-related operations
- It performs bidirectional transformations between physical and logical data representations.
Direct access from the presentation to data access layers may functionally work, but it disrupts the layering concept, causing maintenance challenges. Restricting data flow to adjacent layers simplifies system management, ensuring localized impacts for changes, such as updating a database address.
The challenge in application layering arises from the lack of a clear division of responsibilities between controllers and services. Controllers, at times, handle excessive logic, while services are reduced to data transmission, causing issues like code reuse challenges, confusing hierarchies, and difficult maintenance.
Defects of Architectural Layering
Increased Code Complexity
Architectural layering raises code complexity. Originally, direct database queries were feasible, but adding layers makes even minor changes across all layers necessary. This leads to higher development costs, complex debugging, and increased communication overhead with module leaders.
Performance Loss
When each layer is independently deployed, and inter-layer interactions happen over the network, multi-layer architecture faces inevitable performance losses. Communication overhead between layers can cause delays and reduced efficiency.
Despite these challenges, adopting architectural layering is recommended, recognizing the inherent trade-offs. It's important to acknowledge that every structural solution has pros and cons. While layered architecture may introduce system complexity and potential performance issues, its benefits often outweigh the drawbacks. Careful design considerations and alternative solutions can address and mitigate these challenges. Decisions should be made by weighing trade-offs, aligning with project needs, and ensuring a balance between advantages and disadvantages.
References
https://www.baeldung.com/cs/layered-architecture
If you've found any of my articles helpful or useful then please consider throwing a coffee my way to help support my work or give me patronage😊, by using
Last but not least, if you are not a Medium Member yet and plan to become one, I kindly ask you to do so using the following link. I will receive a portion of your membership fee at no additional cost to you.
It is my first affiliate program, if you like to further enhance your system knowledge, you can click the links and buy the course. Honestly speaking, I will receive 20% of your course fees at no additional cost to you. You will have unlimited access to our courses. There is no time expiry and you will have access to all future updates free of cost.