---

# (DD04) Business Logic — Example.asyncGet() [16 LOC]

| Field | Value |
|-------|-------|
| Fully Qualified Name | `io.github.biezhi.java11.http.Example` |
| Layer | Utility |
| Module | `http` (Package: `io.github.biezhi.java11.http`) |

## 1. Role

### Example.asyncGet()

This method is a small asynchronous HTTP client entry point that sends a GET request to the URI supplied by the caller and then waits for the response to complete. It converts the input string into a `URI`, builds an immutable `HttpRequest`, and delegates the network operation to `HttpClient.sendAsync(...)`, which returns immediately with a `CompletableFuture` representing the in-flight request. The method then attaches a completion callback to handle both success and failure outcomes in a single place, which is a classic asynchronous callback/delegation pattern.

In business terms, the method acts as a reusable HTTP invocation utility rather than a domain workflow component. It is responsible for demonstrating or enabling non-blocking request execution, response inspection, and basic error logging for a generic external endpoint. The success branch prints the response body and HTTP status code to standard output, while the failure branch prints the stack trace of the thrown exception. Because the method has no branching on business codes, it is a transport-level helper that supports any downstream caller needing a lightweight async GET call.

## 2. Processing Pattern (Detailed Business Logic)

```mermaid
flowchart TD
    START(["asyncGet(uri)"])
    CLIENT["Create HttpClient via HttpClient.newHttpClient()"]
    REQUEST_BUILDER["Build HttpRequest with HttpRequest.newBuilder()"]
    URI_CREATE["Resolve target URI using URI.create(uri)"]
    REQUEST_BUILD["Finalize request with build()"]
    SEND_ASYNC["Send request asynchronously with client.sendAsync(request, BodyHandlers.ofString())"]
    WHEN_COMPLETE["Attach completion callback with whenComplete((resp, t) -> ...)"]
    ERROR_CHECK{"t != null?"}
    PRINT_STACK["Print exception stack trace with t.printStackTrace()"]
    PRINT_BODY["Print response body with System.out.println(resp.body())"]
    PRINT_STATUS["Print HTTP status code with System.out.println(resp.statusCode())"]
    JOIN["Wait for completion with join()"]
    END_NODE(["End"])

    START --> CLIENT
    CLIENT --> REQUEST_BUILDER
    REQUEST_BUILDER --> URI_CREATE
    URI_CREATE --> REQUEST_BUILD
    REQUEST_BUILD --> SEND_ASYNC
    SEND_ASYNC --> WHEN_COMPLETE
    WHEN_COMPLETE --> ERROR_CHECK
    ERROR_CHECK -->|Yes| PRINT_STACK
    ERROR_CHECK -->|No| PRINT_BODY
    PRINT_BODY --> PRINT_STATUS
    PRINT_STACK --> JOIN
    PRINT_STATUS --> JOIN
    JOIN --> END_NODE
```

**CRITICAL — Constant Resolution:**
No project-specific constants are referenced in this method. The method relies only on JDK APIs and the runtime value passed in through `uri`.

## 3. Parameter Analysis

| No | Parameter Name | Type | Business Description |
|----|---------------|------|----------------------|
| 1 | `uri` | `String` | Target endpoint address for the outbound HTTP GET request. It defines which remote resource the asynchronous call will contact, and invalid or malformed values will cause URI creation or request execution to fail. |

Instance fields or external state read by the method:
- None. The method is self-contained and uses only local variables plus standard output for result reporting.

## 4. CRUD Operations / Called Services

| CRUD | SC / CBS | SC Code | Entity / DB | Operation Description |
|------|----------|---------|-------------|----------------------|
| R | `HttpClient.sendAsync` | N/A | External HTTP endpoint | Executes a non-blocking read-style outbound request to fetch remote content from the URI provided by the caller. |
| R | `HttpResponse.BodyHandlers.ofString` | N/A | Response payload | Converts the HTTP response stream into a String for downstream inspection and console output. |
| R | `whenComplete` | N/A | CompletableFuture pipeline | Observes completion of the asynchronous request and routes the execution path based on success or failure. |
| R | `resp.body` | N/A | Response payload | Reads the response body for console display after the request succeeds. |
| R | `resp.statusCode` | N/A | HTTP status metadata | Reads the HTTP status code so the caller can inspect the remote system’s outcome. |
| R | `t.printStackTrace` | N/A | JVM error output | Reads exception state and writes diagnostic trace information when the async request fails. |

## 5. Dependency Trace

| # | Caller (Screen/Batch) | Call Chain (Full Path to this Method) | Terminal (SC / CRUD / Entity) |
|---|----------------------|--------------------------------------|-------------------------------|
| 1 | Example.java comment call site | `Example.main` -> `Example.asyncGet` | `HttpClient.sendAsync [R] External HTTP endpoint` |

**Notes:**
- The only discovered reference in the repository is a commented invocation inside `Example.java` itself.
- No screen, batch, controller, or CBS caller class is present in the available source set for this method.

## 6. Per-Branch Detail Blocks

**Block 1** — `TRY` / straight-line execution `(async request setup and completion)` (L43-L50)

> This block prepares the request, submits it asynchronously, and attaches the completion handler.

| # | Type | Code |
|---|------|------|
| 1 | SET | `HttpClient client = HttpClient.newHttpClient();` |
| 2 | SET | `HttpRequest request = HttpRequest.newBuilder()` |
| 3 | EXEC | `.uri(URI.create(uri))` |
| 4 | EXEC | `.build();` |
| 5 | SET | `CompletableFuture<HttpResponse<String>> responseCompletableFuture = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());` |
| 6 | CALL | `client.sendAsync(request, HttpResponse.BodyHandlers.ofString())` |
| 7 | CALL | `HttpResponse.BodyHandlers.ofString()` |
| 8 | CALL | `responseCompletableFuture.whenComplete((resp, t) -> { ... })` |
| 9 | CALL | `.join();` |
| 10 | RETURN | `void` completion after join |

**Block 1.1** — `IF` `(t != null)` (L47)

> Handles asynchronous failure by emitting a stack trace for diagnostic purposes.

| # | Type | Code |
|---|------|------|
| 1 | CALL | `t.printStackTrace();` |

**Block 1.2** — `ELSE` `(t == null)` (L49-L50)

> Handles successful HTTP completion by printing the response payload and status code.

| # | Type | Code |
|---|------|------|
| 1 | EXEC | `System.out.println(resp.body());` |
| 2 | CALL | `resp.body()` |
| 3 | EXEC | `System.out.println(resp.statusCode());` |
| 4 | CALL | `resp.statusCode()` |

## 7. Glossary

| Term | Type | Business Meaning |
|------|------|------------------|
| `uri` | Field/Parameter | Target endpoint address used to identify the remote resource for the HTTP GET request. |
| HTTP | Acronym | Hypertext Transfer Protocol — standard application protocol for network requests and responses. |
| URI | Acronym | Uniform Resource Identifier — textual identifier used to locate the remote endpoint. |
| GET | Business term | Read-oriented HTTP method used to retrieve resource content from a server. |
| async | Acronym/Term | Asynchronous execution — the request is submitted without blocking the caller until completion. |
| `HttpClient` | Technical term | JDK client used to create and send HTTP requests. |
| `HttpRequest` | Technical term | JDK request object that stores the target URI and request configuration. |
| `CompletableFuture` | Technical term | Promise-like container representing the eventual completion of the asynchronous request. |
| `HttpResponse` | Technical term | JDK response object containing status metadata and the response body. |
| `BodyHandlers.ofString` | Technical term | Response handler that converts the response body into a string. |
| `resp` | Variable | Completed HTTP response received from the remote endpoint. |
| `t` | Variable | Throwable captured when asynchronous request execution fails. |
| `statusCode` | Field/Method concept | Numeric HTTP result code returned by the remote server. |
| `body` | Field/Method concept | Response payload returned by the remote server. |
| `printStackTrace` | Technical term | JVM diagnostic output used to display exception details. |
| `join` | Technical term | Blocking wait that ensures the asynchronous pipeline finishes before the method exits. |