How jetlinks/jetlinks-community works
The JetLinks project is a full‐featured, enterprise‐grade IoT platform built with modern Java technologies (Java 8, Spring Boot 2.x, WebFlux, Reactor, Netty, Vert.x) that supports a wide range of device protocols and management functionalities. In other words, you are looking at a full-stack IoT platform that consists of several main modules for device gateway management, rule engine processing, data visualization, authentication and authorization, and more.
High-Level Components
• Components Module ("jetlinks-components"): Contains common libraries, shared utilities and integrations (e.g. common-component, configuration-component, dashboard-component, elasticsearch integration, gateway, IO, logging, network, notify, protocol, relation, rule-engine, script, timeseries, tdengine, and things). Each of these submodules addresses a specific capability.
• Manager Module ("jetlinks-manager"): Provides business-level management functions such as authentication, device management, logging management, network management, notify management, visualization, and rule-engine management.
• Standalone Module ("jetlinks-standalone"): Represents the service startup layer (entry point) of the platform.
• Simulator Module ("simulator"): Supports simulation of devices and histories (e.g., benchmark simulators for MQTT, device simulation jars and scripts for starting simulated workloads).
• Auxiliary Modules: The repository also includes Docker files, Maven wrapper scripts and build configurations that support CI/CD and deployment.
Relationships & Data Flow
• Device Connectivity: The network-component submodule (including gateway, TCP, MQTT, etc.) handles device protocol integration and message passing. It “talks to” the device-manager (in module jetlinks-manager) to register, update, and manage device status.
• Data Processing: Once messages are received from devices, the rule-engine-component processes the data through configurable rules (e.g., alarm thresholds, scene triggers). The timeseries-component and tdengine-component manage high-volume data storage and time-series analysis.
• User & Data Management: The authentication-manager manages users and roles, while device-manager, logging-manager, and notify-manager provide interfaces for device operations, logs, notifications (SMS, email, voice, webhook, etc.).
• External Integration: Components integrate with external systems like ElasticSearch (for logging and search) and PostgreSQL via R2DBC for reactive database access.
Architectural Patterns
• Modular/Microkernel Architecture: The source tree separates core components (like common libraries and network components) from management modules; they plug together into the overall platform.
• Reactive & Event Driven: With Spring WebFlux, Reactor, Netty, and Vert.x, the system design follows a non-blocking, event–driven pattern for high-concurrency device communication.
• Decoupling via Interfaces: Most modules expose service interfaces (e.g., protocol-component for device protocol supports, notify-component to handle various alert channels) that promote plug–in, extensibility, and testing.
• Clear labels for each component and submodule (e.g., “Device Gateway (MQTT/TCP/HTTP)”, “Rule Engine”, “Authentication & Authorization”, “Device Management”, “Notify Service”, “Data Storage & Time Series”, “Integration (ElasticSearch, PostgreSQL)”).
– Data flowing from Device Manager into the Rule Engine.
– Rules triggering notifications via the Notify Service.
– Data being archived into time-series databases.
– Interactions between external systems like ElasticSearch and the logging components.
– For instance, use rectangles for microservices or modules.
• With technologies and key design concepts (Reactive Streams, WebFlux, etc.) where relevant.
Summary
• A multi-module layout where each module has a defined responsibility.
• Communication channels between device layer (network) and management/business logic.
• Integration points for notifications, logging, and data persistence.
• Deployment views indicating Docker-based environments and the standalone service layer for startup.