How to implement a software layer

How Layers Should Be Realized

The matter of how layers should be realized is determined by the client-server nature of the relationship between an application and its platform/virtual machine. This includes some characteristics of layers discussed previously:

• Asymmetry:
  
  
  
  • Interactions between a virtual machine and its application layer should be initiated exclusively by action of the application.
    
  • (Note, however, that this applies only to steady-state operation, since there may be cases during system start up, shut down, or failure recovery, where the virtual machine may need to initiate the action.)
    
  
  
• Interface-based interactions:
  
  
  
  • All interactions between applications and a layer should occur via the interface of the layer.
    
  • This interface should provide services that are well-suited for implementing applications that encompass its domain.
    
  • Furthermore, the interface should be stable even if the implementation of the virtual machine might be subject to change.
    
  
  
• Domain-specific services grouping:
  
  
  
  • The set of services realized by a virtual machine should be selected based on the domain or domains of the applications it is intended to support.
    
  
  

To illustrate how applications use the interface of a layer to achieve specific goals, let's consider a few examples across different domains. These examples will demonstrate how applications interact with a layer's interface to utilize its services, ensuring that all interactions are encapsulated within the layer's interface.
Example 1: Database Access Layer

Scenario

An application needs to perform CRUD (Create, Read, Update, Delete) operations on a database. The database access layer provides an interface for these operations.
Database Access Layer Interface

1. class IDatabase {
2. public:
3.     virtual ~IDatabase() = default;
4.     virtual void connect(const std::string& connectionString) = 0;
5.     virtual void disconnect() = 0;
6.     virtual void executeQuery(const std::string& query) = 0;
7.     virtual std::vector<std::string> fetchResults() = 0;
8. };

复制代码

Implementation of Database Access Layer

1. class MySQLDatabase : public IDatabase {
2. public:
3.     void connect(const std::string& connectionString) override {
4.         // Implementation for connecting to MySQL database
5.     }
7.     void disconnect() override {
8.         // Implementation for disconnecting from MySQL database
9.     }
11.     void executeQuery(const std::string& query) override {
12.         // Implementation for executing a query on MySQL database
13.     }
15.     std::vector<std::string> fetchResults() override {
16.         // Implementation for fetching results from MySQL database
17.         return {};
18.     }
19. };

复制代码

Application Using the Database Access Layer

[code]class Application {public:    Application(IDatabase* db) : database(db) {}    void run() {        database->connect("connection_string");        database->executeQuery("SELECT * FROM users");        auto results = database->fetchResults();        for (const auto& result : results) {            std::cout