# JeeSite: a Spring Boot and Vue3 low-code platform for admin-heavy enterprise systems

> JeeSite pairs a Java backend (Spring Boot, Shiro, MyBatis, Flowable) with a Vue3 front end split into a pnpm and Turborepo monorepo. It suits teams building CRUD-heavy management backends, and it expects you to accept its code generator and permission model rather than assemble your own.

**thinkgem/jeesite** — 👍Java 低代码, 轻量级, Spring Boot, MyBatis, Flowable, TypeScript, Vue, Antdv, 包括核心模块如：组织机构、角色用户、权限授权、数据权限、内容管理、工作流、Spring Cloud 微服务等。

- Repository: https://github.com/thinkgem/jeesite
- Website: http://jeesite.com
- Stars: 8,050 · Forks: 5,544
- Language: Vue
- License: Apache-2.0
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/thinkgem-jeesite

## What JeeSite actually is, and who it is built for

JeeSite describes itself as a rapid development platform and low-code solution rather than a plain admin template. The backend rests on Spring Boot, Shiro and MyBatis; the front end is a separate Vue3 project using Vite, TypeScript, Antdv Next and Vben Admin. The README also mentions a non-separated mode built on Beetl, Bootstrap and AdminLTE, so the same backend service is meant to serve two different front-end stacks.

The stated audience is telling. The README says the platform focuses on supporting junior developers so they can ship complex business features quickly, while freeing senior staff for more strategic work. That is a real positioning choice: JeeSite assumes the hard part is not architecture but repetition. Organisation units, roles, posts, menus, button permissions, data permissions, dictionaries and system parameters are all shipped as core modules, so a team starts from a working permission model instead of building one.

It is a poor fit for a small service that needs three endpoints and a login page. The value here is breadth, and breadth is also weight.

## The monorepo split between web, packages and the Java backend

The repository is a pnpm workspace managed by Turborepo, with a pnpm-workspace.yaml at the root and a turbo.json driving task orchestration. The root package.json is named @jeesite/root and is marked private, version 5.19.0. Its dependencies are workspace links rather than published versions: @jeesite/app, @jeesite/assets, @jeesite/cms, @jeesite/core, @jeesite/dbm, @jeesite/dfm and @jeesite/test.

That layout matters more than it looks. The README lists four reasons for it: faster builds through Turborepo, per-module splitting so teams can manage source separately, loose coupling between modules with shared common code, and a migration path from the older non-monorepo architecture. The package names hint at the seams. dbm and dfm are separate packages rather than folders inside core, which means a team can own one of them without touching the rest.

The root scripts delegate rather than duplicate. build runs turbo build --concurrency 20 across packages, while dev changes directory into web. So the front-end application itself is not a package; it is a consumer of them. If you fork this repository, the packages directory is where your customisation belongs, and web is where you wire it together.

## Data-driven list and form views, and why the project chose them

The front end does not hand you hand-written table and form components per screen. Instead, list and form views are driven by data, with component properties and small behaviours defined centrally. The README points readers to a source-analysis document at jeesite.com/docs/vue-crud-view and asks them to read the comments on the list and form views closely, including for complex and multi-form cases.

The stated reason is upgrade cost. The README argues that backward compatibility on the front end is the biggest problem, and that a shared standard makes framework upgrades cheap because business code changes little. It also says the data-driven approach prepares the ground for a future drag-and-drop form designer and produces a clearer storage structure.

This is a genuine trade-off, not a free win. A data-driven view is fast when your screen matches the shape the platform expects. When it does not, you are extending a component system whose behaviour lives in configuration, and debugging means reading the source rather than your own template. The README itself concedes the point by telling you to read the annotated source.

## Installing the Vue3 front end and running it locally

The README's preparation list names VSCode, Node.js (it links the latest v24.x distribution) and git, plus familiarity with Vite, Vue 3, TypeScript, ES6+, vue-router 4, Vben Admin and Antdv Next. The root package.json adds a hard constraint: a preinstall script runs npx only-allow pnpm, so npm and yarn will be rejected before installation starts.

Install the workspace from the repository root:

```bash
pnpm install
```

The bootstrap script is the same command. Then start the development server, which the root dev script runs from inside the web directory:

```bash
pnpm dev
```

You should see the Vite dev server start and print a local URL. To produce a build, the root script fans out across packages through Turborepo:

```bash
pnpm build
```

There is also a Tomcat-oriented build, pnpm build:tomcat, which runs inside web and implies the front-end assets are meant to be served by a Java container in some deployments. The README's online demo is at vue.jeesite.com, but the text is truncated before it explains what credentials that demo uses.

## The extension model, and where it stops being free

The README makes a pointed argument about framework modification. It notes that many developers use Spring and study its extension mechanisms, then asks how many have actually modified Spring's source, and what happens to those modifications at upgrade time. JeeSite's answer is a stated principle of non-intrusion with extension points: when a feature is not covered, you implement it through documented extension interfaces rather than by editing platform code.

That principle is only as good as the interfaces. The README does not enumerate them in the text available here; it points to jeesite.com/docs/feature for architecture and security details. So the honest position is that the extension story is a design intention backed by a documentation site, and you should read that page before assuming any specific hook exists.

The same caution applies to the AI features. The README says the platform connects to OpenAPI, Ollama and DeepSeek for retrieval-augmented generation over an enterprise knowledge base, and provides local tool calling plus MCP server and client tools. Those are named capabilities, not described mechanisms, and nothing here says which edition ships them.

## Where JeeSite is the wrong choice

The first limitation is weight. A platform that ships organisation, roles, posts, administrators, permission auditing, menus, button permissions, data permissions, module management, system parameters, dictionaries, system monitoring and data monitoring as core modules is not something you trim to a minimal service. If your application has one user type and no data-scoping rules, you are carrying a permission engine you will never use.

The second is coupling to the platform's opinions. Data permissions, menu and button permissions, and the data-driven list and form views are the framework, not add-ons. Working around them costs more than working with them, and the README's own upgrade argument depends on you staying inside the standard.

The third is edition ambiguity. The README states that the commercial edition is built on top of the community edition from a single maintained codebase, and that the community edition is Apache-2.0 and permanently free. It does not, in the text available, mark which of the named features (workflow, CMS, report designer, data screens, single sign-on, full-text search, unified authentication, the AI integrations) are community and which are commercial. Anyone evaluating JeeSite for a feature on that list should confirm the edition before planning around it.

Finally, security is a configuration surface, not a default. The README lists identity authentication, password policies, security auditing, log collection, access restrictions and support for Chinese classified-protection evaluation. Those are options you configure; the README does not state what the shipped defaults are.

## How it compares with JeecgBoot, eladmin and mall

The related searches around this project repeatedly pair it with JeecgBoot, eladmin and macrozheng/mall, so the comparison is worth stating plainly.

JeecgBoot is the closest neighbour: another Chinese low-code platform aimed at generated CRUD backends. The difference visible here is the front-end split. JeeSite separates its Vue3 front end into its own repository and organises it as a pnpm and Turborepo monorepo with named workspace packages, and the same backend is documented as serving both the separated Vue stack and the older Beetl and Bootstrap stack. If your team wants to own the front end as a set of versioned internal packages, that structure is the differentiator.

eladmin is a smaller admin scaffold. It gives you users, roles and menus without the modelling, code generation, workflow and microservice ambitions, so it is lighter and correspondingly less opinionated. If JeeSite's module list looks like more than you will use, eladmin is the more honest starting point.

macrozheng/mall is not really a competitor. It is an e-commerce system, so its data model is orders, products and carts. Choosing between it and JeeSite is choosing between a business application and a platform for building business applications.

## Licence, maintenance and the cost of upgrading

The community edition is Apache-2.0, which permits commercial use and modification and includes a patent grant. The README states it is permanently free. Note that the repository also contains a terms.md at the root; the text available here does not describe its contents, so read it before distributing anything. This is a description of the licence, not legal advice.

The repository is not archived, and the last push was on 2026-09-18. Releases are frequent and versioned: v5.18.0.vue on 2026-07-26, v5.18.1.vue on 2026-08-05, and v5.19.0.vue on 2026-09-17. The version string in the root package.json, 5.19.0, matches the latest release, so the repository tracks its own tags.

Upgrade cost is the part the README argues hardest about. Its claim is that non-intrusion keeps upgrades cheap, and that a data-driven front end limits business-code churn when the framework moves. The counterweight is that this is a monorepo with workspace dependencies pinned by a pnpm lockfile, and the root scripts include reinstall:force, which deletes the lockfile and node_modules and reinstalls with --force. A project that ships a force-reinstall escape hatch is telling you that dependency resolution occasionally breaks. Budget for that, especially if you have forked the packages.

## Conclusion

Adopt JeeSite when you need organisation, role, menu and data-permission scaffolding plus a code generator, and your team already writes Java and Vue. Do not adopt it if you want a small dependency tree or a framework you can reshape freely, because the platform owns the permission model and the data-driven list and form views. Before committing, verify the Node.js version the front end expects, whether the online modelling and code generation features you need live in the community edition or the commercial one, and how the shipped default credentials are meant to be changed in your deployment.

## FAQ

### Is JeeSite J2EE or JEE?

JeeSite is a Java enterprise platform built on Spring Boot, Shiro and MyBatis, so it runs on the Java EE lineage rather than being a J2EE or JEE specification implementation. The README does not use either term; it describes the backend as the classic Spring Boot, Shiro and MyBatis combination.

### How do I install the JeeSite Vue3 front end?

From the repository root, run pnpm install (the bootstrap script does the same), then pnpm dev to start the Vite development server from the web directory. A preinstall script runs npx only-allow pnpm, so npm and yarn will not work.

### Is JeeSite free to use commercially?

The README states that the community edition is released under Apache License 2.0 and is permanently free, and that the commercial edition is built on top of the community edition from a single maintained codebase. The repository also contains a terms.md file whose contents are not described in the available material.

### Does JeeSite support Spring Boot and Spring Cloud?

Yes. The backend is documented as built on Spring Boot, Shiro and MyBatis, and the README lists Spring Cloud microservice architecture as a supported deployment option alongside cluster deployment, read-write splitting and sharding. It also says the platform can generate microservice module code projects.

## Sources

- [License: Apache-2.0](https://github.com/thinkgem/jeesite/blob/main/LICENSE)
- [Project website](http://jeesite.com)
- [README](https://github.com/thinkgem/jeesite/blob/main/README.md)
- [Releases](https://github.com/thinkgem/jeesite/releases)
- [thinkgem/jeesite on GitHub](https://github.com/thinkgem/jeesite)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/thinkgem-jeesite