Using GoldenGate REST API Calls for Mobile Applications

In this collaborative blog, me, and my son Fridtjof, currently pursuing a bachelor’s degree in business information systems/Computer Science at the University of Göttingen, picture a simple Use Case of how you can use GoldenGate in a Mobile App to monitor the heath of your GoldenGate Replication system. The architecture, topology, and the key metrics for monitoring GoldenGate have been discussed in previous blog post. Here, the focus is on embedding GoldenGate functionality into a mobile application.



Mobile applications have become integral to human interaction in the digital age, significantly enhancing our ability to connect, collaborate, and communicate. They serve as essential tools that enable users to perform a multitude of tasks efficiently and effectively.

Mobile app development stands at the forefront of technological innovation, driving the evolution of digital experiences across industries. This dynamic field empowers students and young developers to shape the digital experiences of tomorrow. By leveraging accessible tools and platforms, they can create innovative applications that address real-world problems, fostering creativity and entrepreneurial thinking.

REST API calls are the key for GoldenGate in the Microservice Architecture as services only accepts REST API calls. A significant benefit of the GoldenGate Microservices Architecture is its support for remote connections, enabling users to set up, administer, monitor, and orchestrate replication environments from any location.

Within GoldenGate, there are different approaches to work with the GoldenGate deployment:

• The Web UI offers an intuitive interface for accessing GoldenGate, allowing users to configure replication processes effortlessly through its structured pages. It presents essential information, troubleshooting tools, and monitoring metrics in an organized manner.
• The AdminClient is a command-line utility that provides terminal-based access to GoldenGate with a scripting interface. For those familiar with legacy GoldenGate (GGSCI) scripts, AdminClient offers a similar experience. Its advantages include enhanced automation capabilities, faster execution, improved control, and logging capabilities.

Both the Web UI and AdminClient utilize GoldenGate REST API calls at their core. GoldenGate REST API calls offer the full functionality and maximum flexibility. Additionally, REST API Calls can be integrated into scripting languages (such as shell, Perl, or Python), database programming languages (like PL/SQL), or high-level compiled languages (including C, C++, or Java). An example was provided by colleague Alex in another blog post. 

Previous blogs have demonstrated how to leverage REST API calls in shell scripts (using cURL) or Python to monitor fundamental GoldenGate metrics directly from your desktop. While traditional server and desktop computing have their merits, our focus here is on mobile application development. By integrating GoldenGate REST API calls into programming languages, we are leveraging Dart with the Flutter framework to create a sample mobile application.

This app is designed to monitor key GoldenGate components—Extract, DistPath, and Replicat—providing real-time insights into their health, lag, and throughput. This approach not only demonstrates the versatility of GoldenGate’s REST API but also aligns with modern development practices, enabling efficient and scalable mobile solutions. For a detailed overview and implementation steps, please refer to our previous blog post.
 

GoldenGate Monitor developed for a Mobile Application – Checking the Health of Oracle GoldenGate

This mobile application serves as a prototype designed to demonstrate the utilization of GoldenGate REST API calls within a straightforward app framework. The codebase is organized into distinct modules, each serving a specific purpose:

• API Management Module: This core module functions as a library, handling all interactions with the GoldenGate REST API. It is responsible for making API calls and processing responses, ensuring seamless communication between the application and GoldenGate services.
• Configuration Module: This module manages essential access details such as the GoldenGate deployment URL, communication protocol (HTTP/HTTPS), and user credentials. It centralizes configuration settings, facilitating easier maintenance and updates.
• Presentation Module: Focused on the user interface, this module displays the results of the GoldenGate REST API calls. It presents information regarding the health, lag, and throughput of key components like Extract, DistPath, and Replicat, offering users clear and actionable insights.

This modular architecture embodies a cookie-cutter recipe for mobile application development. By adhering to a standardized structure, it ensures consistency, reusability, and. Each module—API management, configuration, and presentation—functions as a self-contained unit, promoting separation of concerns and facilitating independent development and testing. This approach not only streamlines the development process but also aligns with best practices in software design, enabling efficient adaptation to evolving requirements.

With a history of working for more than 25 years in the field of Replication technology, my focus is mainly on the Replication side and the GoldenGate REST API module. Even having enthusiastically worked with Web Applications in my younger years as a student and now and then, I respect the Mobile App development technology and I hand over this exciting topic to the next generation.  Fridtjof will take over from here.

For this project, we chose Flutter—a modern, open-source framework developed by Google—for building cross-platform mobile applications. Flutter allows us to write a single codebase that runs on both iOS and Android, significantly reducing development time and effort.
 

Using Android Studio as an Integrated Development Environment to build the Application with Dart and Flutter.

A key highlight of Flutter is its architecture built entirely around widgets. In Flutter, everything is a widget—from structural elements like buttons and menus to stylistic components like padding, alignment, and themes. Unlike traditional front-end frameworks such as HTML or TypeScript-based ones, where UI and behavior are often separated, Flutter encapsulates both appearance and interactivity within cohesive widget objects. Each widget has its own properties, such as color, size, style, and can respond to user actions like taps, swipes, and gestures. Beyond that, Flutter offers several powerful features—such as hot reload, which allows developers to instantly view code changes without recompiling the entire app. It also delivers high performance through native compilation and ensures a consistent user interface across platforms.

In Flutter, asynchronous operations are handled using the Future data type—a core concept when working with tasks that take time to complete, such as network requests, file I/O, or database queries. A Future represents a value that will be available at some point in the future. Instead of blocking the main thread and freezing the user interface, Flutter allows the app to continue running while it waits for the result. This enables responsive, smooth user experiences even when dealing with potentially slow operations. In the context of our mobile application, we use Future extensively to handle REST API calls from GoldenGate. The API Management Module performs asynchronous HTTP requests to fetch information about the status of key replication components—Extract, DistPath, and Replicat. Each API call returns a Future, which resolves once the server responds.

The Presentation Module then uses Flutter widgets like FutureBuilder to wait for this data and display it as soon as it becomes available. Futures are particularly useful when dealing with REST API calls because they allow you to decouple data fetching from UI rendering. Instead of forcing the app to pause while waiting for a response, you can design your UI to react dynamically—showing loading indicators, error messages, or the final result based on the state of the Future. This not only improves performance but also creates a better user experience by making the interface feel fast, fluid, and modern.

       API Management and Configuration Objectstructure
 

This mobile application follows a clean, modular architecture that separates concerns across distinct components. It is organized into three primary modules: API Management, Configuration and Presentation. At the core is the main.dart file, which acts as the application’s entry point. It manages global UI flow, including navigation, state management, and periodic data updates. The API Management Module, centered around ogg_service.dart, handles all communication with the Oracle GoldenGate REST API. It encapsulates authentication, request construction, and endpoint interaction logic. The generated file ogg_api.g.dart serves as a Hive adapter for local data persistence.

The Configuration Module is mainly in the ogg_config file, the configuration is object oriented, meaning that the configuration as seen in the illustration above is stored in the oggConfig object (it’s subtpyes). These objects are used for local storage and for the Rest API calls.  The Presentation Module, contains multiple widgets found in the widget folder these widgets are used mainly in ogg_monitor to visualize replication data—including Extracts, DistPaths, and Replicats—using FutureBuilder widgets for real-time, asynchronous updates. Configuration data is stored locally using the Hive database, ensuring persistent access across sessions. This modular structure ensures that API interaction, configuration management, and UI rendering remain isolated, reusable, and independently testable making the application a robust and scalable foundation for any real-time monitoring tool built in Flutter.

To collaborate asynchronously and manage version control, we used GitHub, a platform for hosting and sharing code. We made the repository public so others can explore it at:

https://github.com/Fridtjof-Kuhr/ogg-GoldenGate.git

In this blog, you learned the essentials of invoking GoldenGate’s Microservices REST API programmatically—ideal for integrating real-time monitoring directly into your mobile application. We include clear, adaptable sample code that serves as an ideal base, ready for customization and expansion.

Building this app was not only a rewarding technical challenge, but also a meaningful way to bridge generations through code. I’m proud to have worked alongside my father—and to share this cookie-cutter recipe with you.