AgileBoot Back End Download - AgileBoot Back End Source code download

AgileBoot Back End

Other categories

1.0.0

Download

AgileBoot v2.0.0

Java rapid development scaffolding based on SpringBoot+Vue3 separation of front-end and back-end

⚡Platform Introduction⚡

AgileBoot is an open source full-stack streamlined and rapid development platform that is free for individuals and enterprises to use without reservation. The goal of this project is to create a small development scaffolding that is streamlined, reliable, has excellent coding style, and has project specifications. Suitable for individual developers' small projects or internal company projects. It can also be used as a learning case for beginners.

The front-end is developed based on the excellent open source project Pure-Admin. Thanks to the author of Pure-Admin.
The front end uses Vue3, Element Plus, TypeScript, and Pinia. Corresponds to the front-end warehouse AgileBoot-Front-End and keeps updated synchronously.
The backend uses Spring Boot, Spring Security & Jwt, Redis & MySql, Mybatis Plus, and Hutool toolkits.
Jwt is used for authority authentication and supports multi-terminal authentication system.
Supports annotation-based master-slave database switching, annotation-based request current limiting, and annotation-based repeated request interception.
Supports annotated menu permission interception and annotated data permission interception.
Support loading dynamic permission menu and real-time permission control.
There are a large number of unit tests, and integration test coverage ensures that the business logic is correct .

The V1.0.0 version is developed using JS, and the V2.0.0 version is developed using TS .
V1.0.0 address: Backend (AgileBoot-Back-End-Basic) - Frontend (AgileBoot-Front-End-Basic)

If you have any questions or suggestions, you can submit them to the author in Issues .
Your Issue is more important than Star
If you think the project is helpful to you, you can give it a Star

? Online experience?

Demo address:

www.agileboot.vip
www.agileboot.cc

Account password: admin/admin123

?Project background?

I wanted to do some small personal projects in my spare time. At first I looked for many open source projects such as Ruoyi / Jeecg / ElAdmin / RenRen-Fast / Guns / EAdmin
Finally, this project chose to completely reconstruct and transform based on the Ruoyi project.
First of all, thank you very much to the author Ruoyi. But the Ruoyi project has too many flaws.

The naming is quite messy (a lot of bad naming, including random use of machine-translated English)
Project subcontracting and modules are messy
Compare the original development model of Controller > Service > DAO. Too process-oriented.
A bunch of home-made wheels, and no UT coverage.
A lot of logic is nested in if else blocks
The values are inconsistent. For example, in some places, 1 represents yes, and in other places, 1 represents no.
There are a lot of weird code writing methods (such as return result > 0? true:false.. It’s hard to describe in a word)
The business logic is not centralized and the code is less readable.

So I did a lot of refactoring work.

Refactor content

specification:
- Split startup files for different environments
- Unified design of exception classes
- Unify the design of error codes and centrally handle exceptions
- Unify variables within the system and centrally manage them
- Unified return model
- Introducing Google code formatting templates
- The naming of the back-end code has basically been rectified.
- The naming of the front-end code is also very confusing and has been rectified.
- Standardizing constants within the system
Rectification:
- Introducing the hutool package and the guava package to remove a large number of self-made wheels and use ready-made wheels as much as possible
- Remove a large number of warnings in the code
- Introduce lombok to remove a lot of getter setter code
- Adjust log level
- Dictionary type data is completely replaced by Enum
- Remove the SQL injection Filter, because migrating to Mybatis Plus will not have this injection problem
- XSS is escaped directly through JSON serialization.
- Replace many Deprecated classes and configurations
- Replace fastJson with Jackson
- The overall reconstruction design of the database was reduced to 10 tables.
- Redesign asynchronous code
- Encrypted transmission of front-end and back-end passwords (if more stringent, HTTPS is still required)
- Reconstruct permission verification and data permission verification (directly in the form of annotations)
optimization:
- Optimize asynchronous services
- Optimize the Redis cache class, encapsulate each business cache, and provide multi-level cache implementation (Redis+Guava)
- Provides three levels of cache for users to call (Map, Guava, Redis users can choose which cache class to use according to the situation)
- Permission judgment uses multi-level caching
- IP address query introduces offline package
- Front-end optimization dictionary data cache
- Start optimization
- i18n support
- Optimize the excel tool class and make the code more concise
- Concentrate all logic in the Domain module
- Aspect records modifiers and creators
- Unified transaction setting

use

development environment

JDK
Mysql
Redis
Node.js

technology stack

technology	illustrate	Version
`springboot`	Essential framework for Java projects	2.7
`druid`	alibaba database connection pool	1.2.8
`springdoc`	Document generation	3.0.0
`mybatis-plus`	database framework	3.5.2
`hutool`	Domestic tool kit (simple and easy to use)	3.5.2
`mockito`	Unit test simulation	1.10.19
`guava`	Google toolkit (providing simple cache implementation)	31.0.1-jre
`junit`	Unit testing	1.10.19
`h2`	In-memory database	1.10.19
`jackson`	A safer Json framework	follow springboot
`knife4j`	Interface documentation framework	3.0.3
`Spring Task`	Timed task framework (suitable for small projects)	follow springboot

Startup instructions

Preparation: Download the front-end and back-end code

 git clone https://github.com/valarchie/AgileBoot-Back-End
git clone https://github.com/valarchie/AgileBoot-Front-End

Install Mysql and Redis

Backend startup

 1. 生成所需的数据库表
找到后端项目根目录下的sql目录中的agileboot_xxxxx.sql脚本文件(取最新的sql文件)。 导入到你新建的数据库中。

2. 在admin模块底下，找到resource目录下的application-dev.yml文件
配置数据库以及Redis的 地址、端口、账号密码

3. 在根目录执行mvn install

4. 找到agileboot-admin模块中的AgileBootAdminApplication启动类，直接启动即可

5. 当出现以下字样即为启动成功
  ____   _                _                                                           __         _  _ 
 / ___| | |_  __ _  _ __ | |_   _   _  _ __    ___  _   _   ___  ___  ___  ___  ___  / _| _   _ | || |
 ___  | __|/ _` || '__|| __| | | | || '_   / __|| | | | / __|/ __|/ _ / __|/ __|| |_ | | | || || |
  ___) || |_| (_| || |   | |_  | |_| || |_) | __ | |_| || (__| (__|  __/__ \__ |  _|| |_| || ||_|
 |____/  __|__,_||_|    __|  __,_|| .__/  |___/ __,_| ___|___|___||___/|___/|_|   __,_||_|(_)
                                      |_|

Front end startup

For detailed steps, please see the corresponding front-end section.

 1. pnpm install

2. pnpm run dev

3. 当出现以下字样时即为启动成功

vite v2.6.14 dev server running at:

> Local: http://127.0.0.1:80/

ready in 4376ms.

The detailed process is in this article: AgileBoot - Step by step guide you to run a full-stack project (SpringBoot+Vue3)

For front-end personnel who want to try full-stack projects, here is a simpler way to start the back-end without configuring Mysql and Redis.

No Mysql/Redis backend startup

 1. 找到agilboot-admin模块下的resource文件中的application.yml文件

2. 配置以下两个值
spring.profiles.active: basic,dev
改为
spring.profiles.active: basic,test

agileboot.embedded.mysql: false
agileboot.embedded.redis: false
改为
agileboot.embedded.mysql: true
agileboot.embedded.redis: true

请注意:高版本的MacOS系统，无法启动内置的Redis


3. 找到agileboot-admin模块中的AgileBootAdminApplication启动类，直接启动即可

? System built-in functions?

? Most functions have passed unit testing and integration testing to ensure quality.

	Function	describe
	User management	The user is the system operator. This function mainly completes the system user configuration.
	Department management	Configure system organization (company, department, group), tree structure display supports data permissions
	Position management	Configure system users’ positions
	Menu management	Configure system menus, operation permissions, button permission identifiers, etc., and local cache provides performance
	role management	Role menu permission allocation, setting roles, dividing data range permissions by organization
	Parameter management	Dynamically configure common parameters for the system
	Notices and Announcements	System notification announcement information release and maintenance
	Operation log	System normal operation log recording and query; system abnormal information log recording and query
	Login log	System login log query contains login exception
	Online users	Active user status monitoring in the current system
	System interface	Automatically generate relevant API interface documents based on business code
	Service monitoring	Monitor the current system CPU, memory, disk, stack and other related information
	Cache monitoring	Query system cache information, command statistics, etc.
	Connection pool monitoring	Monitor the current system database connection pool status and analyze SQL to find system performance bottlenecks

? Engineering structures?

 agileboot
├── agileboot-admin -- 管理后台接口模块（供后台调用）
│
├── agileboot-api -- 开放接口模块（供客户端调用）
│
├── agileboot-common -- 精简基础工具模块
│
├── agileboot-infrastructure -- 基础设施模块（主要是配置和集成，不包含业务逻辑）
│
├── agileboot-domain -- 业务模块
├    ├── user -- 用户模块（举例）
├         ├── command -- 命令参数接收模型（命令）
├         ├── dto -- 返回数据类
├         ├── db -- DB操作类
├              ├── entity -- 实体类
├              ├── service -- DB Service
├              ├── mapper -- DB Dao
├         ├── model -- 领域模型类
├         ├── query -- 查询参数模型（查询）
│         ├────── UserApplicationService -- 应用服务（事务层，操作领域模型类完成业务逻辑）

Code flow

Requests are divided into two categories: one is query, and the other is operation (that is, updating the data).

Query : Controller > xxxQuery > xxxApplicationService > xxxService(Db) > xxxMapper
Operation : Controller > xxxCommand > xxxApplicationService > xxxModel (processing logic) > save or update (this project directly uses JPA to insert updated data)

This is based on the development concept of CQRS, which separates queries and operations. The business implementation of operation classes draws on the concept of DDD tactical design, using domain classes and factory classes for more object-oriented implementation logic. If you are not comfortable with this development model. You can develop in the domain module according to the pattern you used before from Controller->Service->DAO. it is up to you.

Secondary Development Guide

Suppose you want to add a new member business, you can add corresponding packages in the following three modules to implement your business

 agileboot
├── agileboot-admin -- 
│                ├── member -- 会员模块
│
├── agileboot-domain -- 
├                ├── member -- 会员模块（举例）
├                     ├── command -- 命令参数接收模型（命令）
├                     ├── dto -- 返回数据类
├                     ├── db -- DB操作类
├                          ├── entity -- 实体类
├                          ├── service -- DB Service
├                          ├── mapper -- DB Dao
├                     ├── model -- 领域模型类
├                     ├── query -- 查询参数模型（查询）
│                     ├────── MemberApplicationService -- 应用服务（事务层，操作领域模型类完成业务逻辑）
└─

?Technical documentation?

AgileBoot - Front-end and back-end rapid development scaffolding based on SpringBoot + Vue3
AgileBoot - Takes you step by step to run a full-stack project (SpringBoot+Vue3)
AgileBoot - unified error code design within the project
AgileBoot - How to integrate the built-in database H2 and the built-in Redis
AgileBoot - Mybatis Plus framework project implementation summary
AgileBoot - SpringBoot project multi-level and multi-environment yml design
AgileBoot - Summary of multi-level cache design practices in projects
Continuously outputting

? Things to note?

IDEA will automatically set the encoding of the .properties file to ISO-8859-1. Please set it to UTF-8 in Settings > Editor > File Encodings > Properties Files >
Please import the unified code formatting template (Google): Settings > Editor > Code Style > Java > Settings button > import schema > Select the GoogleStyle.xml file in the project root directory
If you need to generate a new table, please use the CodeGenerator class to generate it.
- Fill in the database address, account password, and database name. Then fill in the required table name and execute the code. (You will probably know how to fill it out after looking at the code)
- The generated classes are in the target/classes directory under the infrastructure module.
- For different database keywordsHandler methods, please fill in the corresponding database handlers. (Search keywordsHandler keyword)
To build the basic environment of the project, please refer to the guide in the docker directory. Nanny level startup instructions:
- AgileBoot - Takes you step by step to run a full-stack project (SpringBoot+Vue3)
Note: The backend startup class of the management background is AgileBoot Admin Application
Swagger's API address is http://localhost:8080/v3/api-docs