How to implement a software layer
How Layers Should Be RealizedThe 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
class IDatabase {
public:
virtual ~IDatabase() = default;
virtual void connect(const std::string& connectionString) = 0;
virtual void disconnect() = 0;
virtual void executeQuery(const std::string& query) = 0;
virtual std::vector<std::string> fetchResults() = 0;
};Implementation of Database Access Layer
class MySQLDatabase : public IDatabase {
public:
void connect(const std::string& connectionString) override {
// Implementation for connecting to MySQL database
}
void disconnect() override {
// Implementation for disconnecting from MySQL database
}
void executeQuery(const std::string& query) override {
// Implementation for executing a query on MySQL database
}
std::vector<std::string> fetchResults() override {
// Implementation for fetching results from MySQL database
return {};
}
};Application Using the Database Access Layer
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
页:
[1]