Clean Architecture & Design Patterns in Practice · レッスン

Webフレームワークへの適応

Spring、ASP.NET、Djangoなどの一般的なWebフレームワークに依存せず、Clean Architectureを統合する方法を学びます。

「Webフレームワークへの適応」はCoddyKit上の無料Clean Architecture & Design Patterns in Practiceレッスンです。これはレッスン2/4です。下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。これはClean Architecture & Design Patterns in Practice学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Clean Architecture & Design Patterns in Practiceコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

Frameworks & Clean Architecture

Web frameworks like Spring, Django, or ASP.NET are powerful tools for building applications. But how do they fit into a Clean Architecture?

The challenge is to leverage their features without letting them dictate or couple to our core business logic. This lesson explores strategies to achieve that separation.

Avoiding Framework Coupling

Coupling occurs when one part of your code is highly dependent on another. In Clean Architecture, we want our inner layers (Entities, Use Cases) to be independent.

If your Use Cases directly import Spring annotations or Django models, they are coupled.
This makes it hard to change frameworks, test core logic, or reuse components.

The Dependency Rule Applied

Remember the Dependency Rule? Dependencies can only flow inwards. This is crucial for framework integration.

Your core business logic (Entities, Use Cases) should never know about the web framework.
The web framework (an outer layer) can and should depend on your core logic.

We need a bridge that respects this rule.

Presenters & Adapters Bridge

The 'Frameworks & Drivers' layer is where our web framework lives. To communicate with the inner 'Interface Adapters' layer (which contains Presenters and Controllers), we use specific patterns:

Adapters: Translate incoming framework-specific requests into a format our Use Cases understand.
Presenters: Format the output from Use Cases into a structure suitable for the web framework's views or JSON responses.

The Web Controller as an Adapter

In web applications, the framework's controller often serves as the primary adapter. Its job is to:

Receive HTTP requests (e.g., from a browser or API client).
Extract relevant data from the request.
Convert this data into a simple object (a Request Model) that matches the Use Case's Input Port.
Call the Use Case.
Receive output from the Use Case (a Response Model).
Pass this output to a Presenter to format the final HTTP response.

Defining an Input Port

Our Use Cases expose simple interfaces, called Input Ports. The web controller will depend on this interface, not the concrete Use Case implementation. This keeps the Use Case truly independent.

Here's an example of an Input Port and its corresponding Request object:

interface AddItemInputPort {
    void execute(AddItemRequest request);
}

class AddItemRequest {
    public final String itemName;
    public final double price;

    public AddItemRequest(String itemName, double price) {
        this.itemName = itemName;
        this.price = price;
    }
}

public class Main {
    public static void main(String[] args) {
        // These are just definitions, not runnable logic on their own.
        // We'll see them in action soon!
        System.out.println("InputPort and Request defined.");
    }
}

Implementing a Use Case

The actual business logic resides within the Use Case. It implements the AddItemInputPort and performs the operation, completely unaware of how it was invoked (e.g., by a web request, a CLI, or a message queue).

interface AddItemInputPort {
    void execute(AddItemRequest request);
}

class AddItemRequest {
    public final String itemName;
    public final double price;

    public AddItemRequest(String itemName, double price) {
        this.itemName = itemName;
        this.price = price;
    }
}

class AddItemUseCase implements AddItemInputPort {
    @Override
    public void execute(AddItemRequest request) {
        System.out.println("Use Case: Processing item '" +
                           request.itemName + "' with price $" +
                           request.price + ".");
        // In a real application, this would involve business rules,
        // interacting with entities, and potentially repositories.
    }
}

public class Main {
    public static void main(String[] args) {
        AddItemInputPort useCase = new AddItemUseCase();
        AddItemRequest request = new AddItemRequest("Fancy Pen", 15.75);
        useCase.execute(request);
    }
}

Web Controller Adapter in Action

Now, let's see how a simplified web controller (acting as an adapter) uses our Use Case. Notice it only interacts with the AddItemInputPort interface, not the concrete AddItemUseCase class.

interface AddItemInputPort {
    void execute(AddItemRequest request);
}

class AddItemRequest {
    public final String itemName;
    public final double price;
    public AddItemRequest(String itemName, double price) {
        this.itemName = itemName;
        this.price = price;
    }
}

class AddItemUseCase implements AddItemInputPort {
    @Override
    public void execute(AddItemRequest request) {
        System.out.println("Use Case processed: " + request.itemName);
    }
}

// This class simulates a web framework controller
class WebFrameworkController {
    private final AddItemInputPort addItemInputPort;

    // Controller depends on the Input Port interface
    public WebFrameworkController(AddItemInputPort addItemInputPort) {
        this.addItemInputPort = addItemInputPort;
    }

    // This method simulates handling an HTTP POST request
    public String handleHttpRequest(String name, double cost) {
        System.out.println("Controller received HTTP request for: " + name);
        AddItemRequest request = new AddItemRequest(name, cost);
        addItemInputPort.execute(request); // Delegate to Use Case
        return "HTTP Response: Item '" + name + "' added.";
    }
}

public class Main {
    public static void main(String[] args) {
        // Setup: Inject the Use Case into the Controller
        AddItemInputPort useCase = new AddItemUseCase();
        WebFrameworkController controller = new WebFrameworkController(useCase);

        // Simulate an incoming web request
        String response = controller.handleHttpRequest("Notebook", 8.99);
        System.out.println(response);
    }
}

Benefits of Decoupling Frameworks

This adapter-based approach offers significant advantages:

Testability: Use Cases can be tested in isolation, without needing to boot up the entire web framework.
Maintainability: Changes or upgrades to your web framework have minimal impact on your core business logic.
Flexibility: You could swap out your web framework for another (e.g., from Spring to JAX-RS) with changes only in the outer 'Frameworks & Drivers' layer.
Framework Independence: Your valuable business rules are not tied to a specific technology vendor.

Check Your Understanding

Which of the following best describes the role of a web controller when integrating a Clean Architecture application with a web framework?

Recap: Framework Integration

In this lesson, we explored how to integrate web frameworks into a Clean Architecture application while maintaining crucial separation:

We treat the web framework as an outer layer that depends on our core logic, not the other way around.
Controllers in the web framework act as adapters, translating web requests into Use Case Input Ports and formatting Use Case output.
This approach ensures high testability, maintainability, and framework independence for your core application.

よくある質問

「Webフレームワークへの適応」レッスンは無料ですか？

はい。「Webフレームワークへの適応」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Clean Architecture & Design Patterns in Practiceコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Clean Architecture & Design Patterns in Practiceコースには全4レッスンが含まれています。

「Webフレームワークへの適応」で何を学びますか？

Spring、ASP.NET、Djangoなどの一般的なWebフレームワークに依存せず、Clean Architectureを統合する方法を学びます。ブラウザで直接実行するハンズオンコードでClean Architecture & Design Patterns in Practiceを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Clean Architecture & Design Patterns in Practiceを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのClean Architecture & Design Patterns in Practiceは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。これはレッスン2/4です。

「Webフレームワークへの適応」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このClean Architecture & Design Patterns in Practiceレッスンでコードを書いて実行できますか？

はい。すべてのClean Architecture & Design Patterns in Practiceレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

← Clean Architecture & Design Patterns in Practiceに戻る