How Diboot’s Spring‑Boot Low‑Code Platform Boosts Development Speed by 10×

Introduction

Hello, I’m Feng. While browsing open‑source communities I discovered Diboot, a low‑code development platform built on the Spring Boot ecosystem that claims “no‑SQL association and 10× performance”.

Architecture Diagram

Main Technology Stack

Backend: Java + relational databases, following the Spring ecosystem (Spring Boot, Spring Cloud)

ORM: MyBatis with MyBatis‑Plus

Permission: Spring Boot version uses Shiro + JWT; Spring Cloud version uses Spring Security + OAuth2

Frontend: Vue with ElementUI or Ant Design Vue Pro (front‑back separation)

Design Philosophy

Provide a universal foundation framework that simplifies complex problems and improves performance.

Programmers should focus on data‑structure design, business logic, and solving difficult problems.

Low‑code is the future; repetitive CRUD work should be handed to tools.

Features

Core components reduce SQL code by over 80 % and lower the development threshold.

Elegant annotations eliminate association‑query SQL, ending repetitive CRUD.

Advanced RBAC with automatic permission extraction, stateless design, and multiple login methods.

Components for scheduled tasks, notifications, Excel import/export, etc.

Supports monolithic apps, mobile, micro‑services, and workflow scenarios.

Advantages

Extremely easy to use – add the JAR via Maven, configure parameters, and the UI starts with the application.

Powerful – data structure and code synchronization, front‑back generation, panel components, one‑click mobile generation.

Standardized code – devtools enforces data‑structure definitions and coding conventions.

Flexible configuration – optional Lombok and Swagger support.

Multi‑database support (MySQL, PostgreSQL, DM, Kingbase, etc.).

Core Components

1. diboot‑core

Key features:

Single‑table CRUD without SQL.

Association binding without SQL (annotation‑driven).

Data dictionary without SQL.

Cross‑table queries without SQL (auto‑generated QueryWrapper).

BaseService extensions for common single‑table and association scenarios.

Additional utilities, status codes, and exception handling.

Using diboot‑core reduces CRUD and association code by more than 80 % while improving performance and maintainability.

Documentation: https://www.diboot.com/guide/diboot-core/introduce.html

2. IAM (Identity & Access Management) and Front‑end Admin UI

Out‑of‑the‑box RBAC role model with organization and position structures.

Stateless token authentication with refresh support.

Simplified BindPermission annotation compatible with Shiro.

Automatic extraction of secured backend APIs for front‑end menu configuration.

Redis integration for Shiro cache.

Annotation‑driven data permission and operation‑log recording.

Extensible login methods and custom user entities.

Documentation: https://www.diboot.com/guide/diboot-iam/introduce.html

3. diboot‑file (File Handling)

Lightweight EasyExcel wrapper with annotation‑based validation and dictionary conversion.

Pluggable storage interface (local, OSS, distributed storage, etc.).

Common upload/download, image compression, watermarking utilities.

Documentation: https://www.diboot.com/guide/diboot-file/introduce.html

4. diboot‑scheduler (Scheduled Tasks)

Quartz‑based unified task management and logging. @CollectThisJob annotation for task definition and front‑end selection.

Documentation: https://www.diboot.com/guide/diboot-scheduler/introduce.html

5. diboot‑message (Message Notification)

Unified message template and variable design.

Multi‑channel notification support.

Documentation: https://www.diboot.com/guide/diboot-message/introduce.html

6. diboot‑mobile (Mobile Component)

Provides diboot-mobile-ui with multiple login methods.

Supports username/password, WeChat Mini‑Program, and WeChat Official Account logins (auto‑registration).

Documentation: https://www.diboot.com/guide/diboot-mobile/introduce.html

Getting Started

1. Clone the Playground Project

In IDEA choose “File → New → Project from Version Control…”. Enter the repository URL and a local path (avoid Chinese characters), then click Clone :

https://gitee.com/dibo_software/playground.git

If you lack a Git environment, download the zip from https://gitee.com/dibo_software/playground and import it.

Note: The master branch is the stable version; use it for evaluation.

After cloning, add the demo/pom.xml to the Maven view so IDEA recognises the project.

2. Prepare an Empty Database

Create a database instance, e.g., playground:

-- mysql example
CREATE DATABASE playground DEFAULT CHARSET utf8mb4 COLLATE utf8mb4_general_ci;

Adjust application.properties with your connection details:

spring.datasource.url=

spring.datasource.username=

spring.datasource.password=

Set the front‑end UI path (default diboot-antd-admin/) and local file storage directory:

diboot.devtools.output-path-admin-ui=diboot-antd-admin/

diboot.component.file.storage-directory=D:/temp/playground

3. Run the Demo Project

Create a Run Configuration for DemoApplication (Spring Boot or Application). Disable the “JMX agent” option to avoid console noise.

When the devtools start, you should see:

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
-- Diboot devtools v2.x.x initialized:
-> URL: http://localhost:8080/api/diboot/index.html
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

If the message does not appear, remove the provided scope from the devtools dependency:

<scope>provided</scope>

Devtools is for development only; exclude it from the final package.

4. Use Devtools to Generate Backend Code

Open the printed URL, log in (first‑time users need to scan the QR code), and click “Generate Code” for each component to create controller, service, and entity classes.

5. Restart the Backend

Restart DemoApplication to apply the newly generated code.

Note: If the login captcha does not appear, ensure step 4 was completed and the backend was restarted.

6. Start the Frontend

Install Node (v14.x recommended). In the front‑end directory run:

# yarn (recommended)
yarn install
yarn run serve
# or npm
npm install
npm run serve

After a successful start, open the URL and log in with admin/123456 to access the admin console.

The basic Diboot project is now set up; you can explore devtools‑generated code.

7. Generate Frontend Code with Devtools

In “Data Table Management” you can create tables, define fields and relationships, and generate or update backend code.

Devtools also offers powerful CRUD, import/export, component composition, and mobile generation capabilities (free 7‑day trial for new users).

Click the devtools URL and choose “PC Frontend Generation”, “Frontend Panel Component Generation”, or “Mobile Frontend Generation” to configure and generate the desired UI code.