Mastering API Full Lifecycle: From Object Modeling to Service Orchestration

API Full Lifecycle Overview

The API lifecycle spans development, runtime, and operations. A lightweight API gateway focuses on runtime concerns, while heavy tasks such as protocol conversion, data mapping, and adaptation belong to an API development platform that creates standard HTTP APIs and registers them with the gateway.

Subsystem Decomposition

The lifecycle is divided into four subsystems:

API Development Platform

API Gateway Engine

API Monitoring & Operations Platform

API Full‑Lifecycle Management Portal

Traditional ESB adapters and protocol conversion are shifted to the development platform, which exposes standard API services and registers them with the gateway. The monitoring platform collects logs for performance and error analysis.

Object‑Driven Modeling

The core principle is object‑driven design: objects encapsulate interfaces and underlying database tables, enabling decoupling and multi‑database support. Rather than exposing raw tables as CRUD APIs, reverse‑engineered objects allow richer composition, rule extensions, and lifecycle management.

Defining an object automatically generates standard POST, GET, DELETE endpoints and can produce contract files such as RAML, YAML, or WADL. Like Swagger, the model can export client SDKs and server stubs for various languages and frameworks.

Object‑to‑Database Mapping

Objects may map to multiple tables, requiring mapping of fields and primary/foreign‑key relationships. Once mapping is complete, the generated API endpoints become usable.

API Publishing

Developers choose which operations to expose—e.g., only query endpoints or data‑import POST methods. Publishing respects partial data item selection, allowing fine‑grained control over exposed fields.

Testing and Documentation

An online testing tool enables simulation, execution, and storage of test cases. Documentation can be auto‑generated by integrating open‑source Swagger‑like tools.

Common Object Operations

Typical CRUD operations include creating a record, updating by primary key, querying, and deleting. Additional conditional queries are also supported.

Open‑Source Tool: xmysql

Install with npm install -g xmysql and run:

xmysql -h localhost -u mysqlUsername -p mysqlPassword -d databaseName

Access the generated REST API at http://localhost:3000. Note that the tool lacks built‑in authentication and is intended for testing and reference.

Composite Object Generation

Complex entities (e.g., an order with header and line items) can be modeled as a single object, allowing one API call to insert the entire composite JSON and ensuring transactional consistency.

Pagination Support

Generated query APIs accept pagination parameters such as page size and page number.

Direct API Definition & Publishing

Beyond object‑generated APIs, custom methods can be defined, bound to JAR‑packaged functions, dynamic SQL, or stored procedures. Input validation, output mapping, and rule processing are configurable.

Rule Processing

Input data integrity checks (type, length, range)

Data‑item rule handling (mapping, enrichment, truncation)

Custom scripting for low‑code extensions

Message header and output reservation (e.g., user token, routing, pagination, error codes)

Service Composition & Orchestration

The platform supports visual service composition, allowing atomic services to be combined, chained, or enriched into new services. Scenarios include:

Aggregating three query services (A, B, C) into a single composite service D.

Joining results from separate databases (e.g., material info and purchase order details) into a unified dataset.

Transforming and filtering existing service outputs before re‑exposing them.

Sequencing services where the output of one becomes the input of the next.

Merging multiple import services into a single bulk import operation.

These orchestration patterns aim to enable end‑to‑end business functionality through visual design rather than hand‑coded glue.

Source Code Export

The platform can export compilable source code, allowing developers to extend or modify generated services outside the platform. Extension points can be added before and after core logic (e.g., //BeforeDo(); //ProcessAPI(); //AfterDo();).

Microservice Packaging

Multiple APIs can be packaged into a microservice JAR for deployment, either self‑hosted or managed by the platform, with integration to a microservice runtime.