Use Java annotations to quickly develop the Admin management background. Zero front-end code, zero CURD, no code generation, automatic table creation, annotated API, support all mainstream databases, support multiple data sources, provide 23 types of form components, more than a dozen display forms, dynamic timing tasks, separation of front-end and back-end And other characteristics.
update content
Features
Custom function button @RowOperation supports the display and hiding of dynamic control buttons, and comes with security mechanisms such as permission verification
For details, please see: https://www.yuque.com/yuepeng/erupt/gaing7#HaZs4
Destructive update (sorry that there shouldn't be a minor version, pay attention next time)
Change the package name of BaseModel from xyz.erupt.db to xyz.erupt.jpa
Home
What is erupt
erupt is a low-code full-stack class framework. It uses Java annotations to generate pages and add, delete, modify, check, access control and other back-end functions. It only needs a simple basic knowledge of Spring Boot , no need to understand the front end, nor does it need to Write cumbersome CURD, automatically create table structure, controller / service / sao / mapper files do not need to be created, greatly reducing the workload of development, and improving the background development speed to the extreme.
Replace the code generator, develop a better solution for the background management system!
Why do erupt?
No matter what kind of system is developed, a supporting management backend is required for data support, which is an indispensable part of software development, but there are unavoidable pain points in actual development, such as low development efficiency, unsatisfactory UI interface, Interactions, code duplication, and security vulnerabilities lead to extremely high development costs.
Although code generators have become the new favorite of back-end development in recent years , is it really the best solution for back-end development?
The essence of the code generator is to generate cumbersome front-end and back-end code. Once modified, the generated code is difficult to merge. Think about Mybatis-Generator, which is basically a one-time thing. Although it reduces some of the work, the solution is not the best. .
In most cases of developing a back-end management system, I just want to make an ordinary add, delete, modify, and check interface for data management, similar to the following:
@Erupt(
name = "简单的例子",
power = @Power(importable = true, export = true)
)
@Table(name = "t_simple") //数据库表名
@Entity
public class Simple extends BaseModel {
@EruptField(
views = @View(title = "文本"),
edit = @Edit(title = "文本", notNull = true, search = @Search)
)
private String input;
@EruptField(
views = @View(title = "数值", sortable = true),
edit = @Edit(title = "数值", search = @Search)
)
private Float number;
@EruptField(
views = @View(title = "布尔"),
edit = @Edit(title = "布尔")
)
private Boolean bool;
@EruptField(
views = @View(title = "时间"),
edit = @Edit(title = "时间", search = @Search(vague = true))
)
private Date date;
}Although this interface can be approximated with Vue + Ant Design + SSM, a careful observation will reveal that it has a lot of detailed functions such as:
- Can filter data
- There are buttons to refresh, add, and data
- Table has pagination and summary
- Preview a single row of data
- batch deletion
- Hide a column
- Multiple components
- Sort by a column
- Non-empty check
- Support import and export Excel
To implement all of these, only the front-end requires a lot of code, and the back-end interfaces and business logic are not rare.
But you can see that only 30 lines of annotation configuration are needed to use erupt. You don’t need to understand Angular / React / Vue / Jquery, JavaScript / HTML / CSS, or even Spring MVC / JPA / Mybatis / SQL. If you haven't learned erupt, you can guess the role of most of the configurations. You can complete all the background page development with a simple configuration.
This is the original intention of establishing erupt. For most commonly used pages, the simplest method should be used to achieve it. You don’t even need to learn various frameworks and tools, focus on the core business, and save time to do what you like to do. And then, I was devastated by the tedious background development.
characteristic
- Easy to use : You only need to understand the two annotations @Erupt and @EruptField to get started.
- The code is concise : zero code at the front end, no back-end template, controller, service, dao are needed, only one entity class is required.
- Agile development : Only a single
.javafile can realize the background management function, focusing on the research and development of business and core functions. - Fast iteration : Only need to modify or add annotation configuration for requirement changes, and the iteration speed is faster than the requirement discussion speed.
- Powerful functions : dynamic condition processing, support for addition, deletion, modification, and other functional agent interfaces, session storage mechanism selection, behavior logging, etc.
- Automatic table creation: Relying on JPA, it can automatically help you complete database table creation tasks.
- Low invasiveness : Almost all functions are developed around annotations, and do not affect the use of other Spring Boot functions or third-party libraries.
- Multiple data sources : MySQL, Oracle, SQL Server, PostgreSQL, H2, and even MongoDB.
- Multiple components : support 23 types of components such as sliding input, time selection, switch, picture upload, code editor, auto-complete, tree, multiple selection box, map, etc.
- Rich display : ordinary text, QR code, link, picture, HTML, code snippet, iframe, swf, etc.
- Code generation : The erupt code is concise enough, and the code generator can further improve development efficiency.
- Strong scalability : support for custom data source implementation, custom pages, custom templates, custom attachment upload mechanisms, etc.
- Beautiful interface : each interaction is carefully designed, and the product thinking is polished, just for a better operating experience.
- Authority management : user management, role management, organization management, menu management, login log, operation log, etc.
- High security : reliable security mechanism, login whitelist, permission verification, annotation item check, fine-grained permission control, escort your data.
- Front-end separation : the back-end and the front-end can be deployed separately
- Responsive layout : Supports use in devices of various specifications such as PC and mobile phones.
- No need for secondary development : just reference the jar package.