AJ-Report: self-hosted drag-and-drop BI dashboards

AJ-Report's SQL-to-screen dashboard workflow

AJ-Report solves a specific internal analytics problem: turning database results into a browser-based dashboard without first building a dedicated API and a separate visualization interface. It is aimed at organizations that need a management or operations display from existing business data. The documented workflow is explicit: configure a data source, write SQL to define a dataset, then drag components into place and save and publish the dashboard.

That workflow puts AJ-Report between database access and presentation. A query produces the dataset, and dashboard components consume the resulting records. The project supports built-in drivers for MySQL, Elasticsearch, and Kudu. It also documents custom datasets as a way to avoid separate data interface development. This is useful when the desired display can be derived from relational data or an existing search service, although the README does not define the contract for adding another driver.

The intended users include developers or data administrators who configure databases and SQL, as well as dashboard designers who assemble the final display. The project claims support for more than 30 large-screen components and charts. Its component layer includes wrappers around ECharts, spreadsheet-like editing through Luckysheet, slide presentation support, and drag-and-drop behavior based on Sortable.js. A team should not mistake this for a general notebook or data-cleaning workspace. The documented center of gravity is dashboard composition.

Inside AJ-Report's Java and Vue repository layout

Based on the repository layout, AJ-Report separates backend and frontend responsibilities. `report-core` contains Java source and is built around `aj-gaea`, Spring Boot 2.3.5.RELEASE, MyBatis-plus 3.3.2, and Flyway 5.2.1. `report-ui` contains the Vue frontend. The parent `pom.xml` manages versions, while the build output is packaged under `build`.

The frontend uses Vue CLI, Vue Router, Element UI, Avue, `vue-echarts`, Vue-SuperSlide, `vuedraggable`, and Luckysheet. Avue supplies positioned editor components that can be moved with the keyboard, while `vuedraggable` provides drag-and-drop behavior. ECharts handles chart rendering. This combination is well matched to the stated task of arranging a fixed dashboard canvas, but it also means the project is tied to an older JavaScript and Vue-centered stack.

The packaged layout separates runtime concerns into `bin`, `conf`, `logs`, `cache`, and `lib`. Start and stop scripts sit under `bin`, while `conf/bootstrap.yml` contains settings such as database access, upload and download addresses, and the JWT secret. Flyway handles database migration during initialization. The documentation places migration SQL under `report-core/src/main/resources/db.migration` and states that successful startup creates the `aj_report` database for system data.

One deployment detail deserves attention. The checked-in `Dockerfile` uses an Eclipse Temurin Java 8 runtime, extracts a packaged ZIP, and references `build/aj-report-1.3.0.RELEASE`. Its `COPY` instruction is relative to the Docker build context, while `docker-compose.yml` declares `context: ../..`. The repository root alone does not establish that the required build archive already exists. Container deployment therefore depends on arranging the expected build artifacts and context correctly.

Installing AJ-Report and reaching the first dashboard

For a packaged release, the README directs users to the Gitee releases page. Download and extract a release, enter its directory, and edit `conf/bootstrap.yml`. The documented application port is 9095.

On Linux, the release uses the included startup script:

cd aj-report-xxxx
vim conf/bootstrap.yml
sh bin/start.sh

The configuration must be reviewed before startup because it contains database connection information, upload and download addresses, and JWT-related settings. On Windows, the README says to edit the fourth line of `bin/start.bat` to set `JAVA_HOME`, remove the `rem` comment, and run the file.

For source deployment, the README requires Maven 3.5, an LTS release of Node.js, and JDK 1.8. Its documented Node boundary depends on the report version: versions below 1.5 use Node 14 or earlier, while 1.5 and later use Node 14 or newer. Build the repository with:

git clone https://gitee.com/belief-team/report.git
cd report
sh build.sh

The README states that the archive is placed in the `build` directory as `aj-report-xxxx.zip`. Extract it, edit `conf/bootstrap.yml`, and start the application. In either installation route, open the configured server address:

http://serverip:9095

The first documented login is `admin` with password `123456`. After login, the first real use follows the product workflow: create or connect a data source, define a dataset through SQL, open the dashboard editor, drag one of the supported components onto the canvas, save the layout, and publish it. The README names these modules but does not document exact button labels, so the interface sequence beyond those terms should be verified against the local guide.

Compatibility limits in AJ-Report's documented stack

AJ-Report's clearest limitation is its prescribed runtime environment. The README identifies MySQL 5.7 and JDK 1.8 as dependencies. Its compatibility notes say not to use JDK 1.7 or earlier, or JDK 11 and later, because some JDK 11 versions have problems. They also identify MySQL 8.0 as problematic in general, while noting exceptions around 8.0.23 and 8.0.26 and a problem with 8.0.21. That is a narrower support statement than a modern platform would need.

The frontend has a second compatibility boundary. Node.js must match the AJ-Report version, using Node 14 or earlier below version 1.5 and Node 14 or newer from 1.5 onward. The README does not identify an upper Node.js bound. This omission matters for source builds because a current LTS runtime may contain assumptions that the documented command was not written to address.

IE is listed under known issues as producing a blank screen. No workaround is provided there. That does not prevent use in modern browsers, but it does mean the project explicitly does not cover a legacy client path.

Security configuration is another boundary. The README supplies default administrator credentials and recommends changing them before startup. It also instructs administrators to replace the default 32-character key used by `spring.gaea.Security.jwtSecret` to prevent forged attacks. Its deployment recommendation is an internal network rather than public exposure. For an authentication-bearing application with database access, retaining documented defaults would be an avoidable risk.

Docker deployment and database initialization constraints

The repository includes container definitions, but they do not amount to a fully documented zero-to-running installation. `docker-compose.yml` defines `aj-report` on port 9095 and a `mysql:5.7` service. The database service publishes port 3306, stores data under `./build/aj-report-mysql`, sets `MYSQL_ROOT_PASSWORD` to `123456`, and uses UTF-8 settings. The application service mounts logs under `/opt/aj-report/logs` and depends on the database service.

The Dockerfile expects a Java 8 runtime and an AJ-Report package copied to `/opt/aj-report`. Since it does not compile the repository itself, the build must already have created the referenced archive and directory. The README does not provide a standalone container command or explain how its relative volume paths align with a particular checkout location. A failed container build is therefore more likely to be a build-context or artifact-layout issue than an unsupported Docker feature.

Flyway reduces manual database setup for normal initialization. According to the README, SQL under `report-core/src/main/resources/db.migration` runs automatically and creates `aj_report`. If initialization fails, the documented recovery path is to set `flyway` to `false` in `bootstrap.yml` and execute the SQL manually. Example data is separate: the files under `doc/example` are optional and must be run manually.

This arrangement favors repeatable server deployment, but it also introduces persistence and configuration decisions. MySQL data and application logs are bind-mounted in Compose, while the application container runs with `restart: always`. Operators need to decide where those host directories live and protect the published database port. The supplied configuration is a starting point, not a production-hardening guide.

AJ-Report's maintenance, licensing, and alternative path

The repository is not archived, and its last push was on 2026-08-13. However, there are no GitHub releases associated with the repository. The README points to a Gitee releases page for packaged downloads and to `doc/docs/guide` for documentation. That distinction matters when evaluating upgrade work: source activity and artifact availability are separate concerns.

AJ-Report uses the Apache-2.0 license. It also contains a `NOTICE` file, while the README documents that `lib` can hold custom extension packages as well as the `report-core` core package. Organizations should review those files and any separately distributed components when deciding how internal modifications and extensions will be handled. The Apache-2.0 designation does not remove the need to check dependency licenses or the provenance of custom extension packages.

A real alternative is to keep SQL datasets in an existing database or analytics service, build a small API that exposes approved query results, and use a general-purpose chart or dashboard frontend for rendering. This approach adds an application layer, but it provides narrower database privileges, explicit API contracts, and more freedom to use a current frontend stack. AJ-Report instead combines connection configuration, SQL dataset definition, and screen composition in one self-hosted product. Teams that want one editable dashboard tool may prefer that integrated path. Teams requiring strict service boundaries, current runtime support, or independently versioned APIs should evaluate the alternative architecture more seriously.

AJ-Report also differs from a hosted BI service because it is deployed by the adopter and relies on its MySQL instance and Java server. That shifts hosting, credentials, database migration, backups, and upgrade verification into the adopting organization.

Editorial conclusion

AJ-Report fits teams that already operate MySQL-backed internal systems and want a self-hosted dashboard editor for management or operations displays. It is less suitable for public internet exposure, modern Java or MySQL estates, or users who need current release artifacts through GitHub, because the documentation centers on JDK 1.8 and MySQL 5.7, lists a blank-screen issue in IE, provides no GitHub releases, and directs users to Gitee for downloads. Before adoption, inspect `conf/bootstrap.yml`, replace the documented default credentials and `spring.gaea.Security.jwtSecret`, confirm compatibility with the required Java, Node.js, and database versions, and verify that `flyway` initializes `aj_report` correctly.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. raodv/report on GitHub
4. README