# auto-boot

**Repository Path**: maoshangwei/auto-boot

## Basic Information

- **Project Name**: auto-boot
- **Description**: 这是一个基于SpringBoot和MyBatis-Plus的通用数据操作基础包，封装了domain层、mapper层和service层，使开发者只需传入MySQL数据表名称即可对表进行增删改查操作。
- **Primary Language**: Java
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 2
- **Forks**: 0
- **Created**: 2025-04-08
- **Last Updated**: 2025-04-17

## Categories & Tags

**Categories**: Uncategorized

**Tags**: Java, SpringBoot, MySQL, mybatis-plus

## README

# 通用数据操作基础包

这是一个基于SpringBoot和MyBatis-Plus的通用数据操作基础包，主要目的是简化数据库操作，让开发者可以快速实现对任意数据表的增删改查操作，而无需为每个表编写重复的代码。

## 技术信息

- SpringBoot: 3.1.5
- JDK: 17+
- MyBatis-Plus: 3.5.3.1
- MySQL驱动: mysql-connector-j

## 功能特点

- 通用实体层设计，自动映射数据表结构
- 通用数据访问层，简化SQL操作
- 通用服务层，提供完整的CRUD操作
- 控制器层只需提供表名即可操作对应表
- 支持条件构造器，灵活构建查询条件
- 支持分页查询
- 支持自定义SQL执行
- 支持复杂条件查询（模糊查询、比较查询、区间查询等）
- 支持多字段排序
- 支持表级别访问控制，保护敏感数据
- 支持多表关联查询，灵活构建JOIN查询

## 核心功能

1. **通用数据操作**
   - 支持对任意数据表进行增删改查操作
   - 无需为每个表编写单独的Mapper、Service和Controller
   - 只需提供表名即可操作对应表

2. **灵活的条件查询**
   - 支持等值查询、模糊查询
   - 支持比较查询（大于、小于、大于等于、小于等于）
   - 支持区间查询
   - 支持多字段排序

3. **分页查询**
   - 支持带复杂条件的分页查询
   - 可自定义每页大小和当前页码

4. **多表关联查询**
   - 支持多表JOIN操作（INNER JOIN、LEFT JOIN、RIGHT JOIN）
   - 支持复杂的JOIN条件
   - 支持对关联查询结果进行条件过滤和排序
   - 支持关联查询结果的分页

5. **安全控制**
   - 支持表级别的访问控制
   - 可以配置禁止访问的敏感表
   - 防止对敏感数据的未授权访问

6. **自动填充**
   - 自动处理创建时间
   - 自动处理更新时间
   - 可配置是否启用自动填充

## 项目优势

1. **开发效率高**
   - 减少重复代码
   - 快速实现基础功能
   - 统一的数据操作方式

2. **维护成本低**
   - 代码结构清晰
   - 配置集中管理
   - 易于扩展和修改

3. **安全性好**
   - 支持表级别访问控制
   - 防止敏感数据泄露
   - 统一的异常处理

4. **灵活性高**
   - 支持多种查询条件
   - 支持自定义SQL
   - 可配置性强

## 适用场景

1. **快速开发场景**
   - 需要快速开发一个管理系统
   - 有大量相似的数据表需要操作
   - 不想为每个表编写重复的CRUD代码

2. **数据管理场景**
   - 需要管理多个数据表
   - 需要频繁进行数据查询和修改
   - 需要灵活的条件查询功能

3. **安全敏感场景**
   - 有敏感数据需要保护
   - 需要控制某些表的访问权限
   - 需要防止对敏感表的未授权访问

4. **数据分析场景**
   - 需要执行复杂的查询
   - 需要支持多种查询条件组合
   - 需要分页查询大量数据

## 项目结构

```
├── src/main/java/com/autoboot
│   ├── config        // 配置类
│   ├── domain        // 通用实体层
│   ├── mapper        // 通用数据访问层
│   ├── service       // 通用服务层
│   ├── controller    // 通用控制层示例
│   └── util          // 工具类
```

## 使用方法

### 1. 引入依赖

在你的项目中引入此基础包依赖。

### 2. 创建控制器

创建控制器时，只需注入通用服务并提供表名和主键名即可：

```java
@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @Autowired
    private DynamicTableService tableService;
    
    // 设置要操作数据库的表名
    private final String tableName = "sys_user";

    //设置数据库表主键ID字段名称
    private static final String ID_FIELD = "id";
    
    // 查询列表
    @GetMapping
    public Object list() {
        return tableService.listFromTable(tableName);
    }
    
    // 根据ID查询
    @GetMapping("/{id}")
    public Object getById(@PathVariable String id) {
        return tableService.getByIdFromTable(tableName, id);
    }
    
    // 新增数据
    @PostMapping
    public Object save(@RequestBody Map<String, Object> data) {
        return tableService.saveToTable(tableName, data);
    }
    
    // 更新数据
    @PutMapping("/{id}")
    public Object update(@PathVariable String id, @RequestBody Map<String, Object> data) {
        data.put("id", id);
        return tableService.updateToTable(tableName, data);
    }
    
    // 删除数据
    @DeleteMapping("/{id}")
    public Object delete(@PathVariable String id) {
        return tableService.removeFromTable(tableName, id);
    }
}
```

### 3. 高级用法

#### 复杂条件查询

支持多种查询条件组合，包括等值查询、模糊查询、比较查询和区间查询：

```java
// 构建查询条件
queryBo queryBo = new queryBo();
queryBo.setTableName("sys_user");

// 等值查询条件
Map<String, Object> params = new HashMap<>();
params.put("status", 1);
queryBo.setParams(params);

// 模糊查询条件
List<Map<String, String>> likes = new ArrayList<>();
Map<String, String> like = new HashMap<>();
like.put("field", "name");
like.put("value", "张");
likes.add(like);
queryBo.setLikes(likes);

// 比较查询条件
List<Map<String, Object>> ge = new ArrayList<>();
Map<String, Object> geCondition = new HashMap<>();
geCondition.put("field", "age");
geCondition.put("value", 18);
ge.add(geCondition);
queryBo.setGe(ge);

// 区间查询条件
List<Map<String, Object>> between = new ArrayList<>();
Map<String, Object> betweenCondition = new HashMap<>();
betweenCondition.put("field", "create_time");
betweenCondition.put("start", "2023-01-01 00:00:00");
betweenCondition.put("end", "2023-12-31 23:59:59");
between.add(betweenCondition);
queryBo.setBetween(between);

// 排序条件
List<Map<String, String>> orders = new ArrayList<>();
Map<String, String> order = new HashMap<>();
order.put("field", "create_time");
order.put("order", "DESC");
orders.add(order);
queryBo.setOrders(orders);

// 执行查询
List<Map<String, Object>> result = tableService.listByConditionFromTable(
    queryBo.getTableName(),
    queryBo.getParams(),
    queryBo.getLikes(),
    queryBo.getGt(),
    queryBo.getGe(),
    queryBo.getLt(),
    queryBo.getLe(),
    queryBo.getBetween(),
    queryBo.getOrders()
);
```

#### 分页查询

支持带复杂条件的分页查询：

```java
// 分页参数
queryBo.setPageIndex("1");
queryBo.setPageSize("10");

// 执行分页查询
Page<Map<String, Object>> page = tableService.pageFromTable(
    queryBo.getTableName(),
    Long.parseLong(queryBo.getPageIndex()),
    Long.parseLong(queryBo.getPageSize()),
    queryBo.getParams(),
    queryBo.getLikes(),
    queryBo.getGt(),
    queryBo.getGe(),
    queryBo.getLt(),
    queryBo.getLe(),
    queryBo.getBetween(),
    queryBo.getOrders()
);
```

#### 多表关联查询

支持多表JOIN操作，可以轻松构建复杂的多表关联查询：

```java
// 创建多表查询对象
QueryMultiBo queryMultiBo = new QueryMultiBo();

// 设置主表
queryMultiBo.setMainTable("order");

// 设置要查询的字段
List<String> selectFields = new ArrayList<>();
selectFields.add("order.id");
selectFields.add("order.order_no");
selectFields.add("order.create_time");
selectFields.add("user.name as user_name");
selectFields.add("product.name as product_name");
selectFields.add("product.price");
queryMultiBo.setSelectFields(selectFields);

// 设置关联表
List<JoinTable> joinTables = new ArrayList<>();

// 用户表关联
JoinTable userJoin = new JoinTable();
userJoin.setTableName("user");
userJoin.setJoinType("LEFT");
userJoin.setJoinCondition("order.user_id = user.id");
joinTables.add(userJoin);

// 产品表关联
JoinTable productJoin = new JoinTable();
productJoin.setTableName("product");
productJoin.setJoinType("INNER");
productJoin.setJoinCondition("order.product_id = product.id");
joinTables.add(productJoin);

queryMultiBo.setJoinTables(joinTables);

// 设置等值查询条件
Map<String, Object> conditions = new HashMap<>();
conditions.put("order.status", 1);
queryMultiBo.setConditions(conditions);

// 设置模糊查询条件
Map<String, String> likes = new HashMap<>();
likes.put("user.name", "张");
queryMultiBo.setLikes(likes);

// 设置比较条件
Map<String, Object> gt = new HashMap<>();
gt.put("product.price", 100);
queryMultiBo.setGt(gt);

// 设置区间条件
Map<String, List<Object>> between = new HashMap<>();
List<Object> dateRange = new ArrayList<>();
dateRange.add("2023-01-01 00:00:00");
dateRange.add("2023-12-31 23:59:59");
between.put("order.create_time", dateRange);
queryMultiBo.setBetween(between);

// 设置排序条件
Map<String, String> orders = new HashMap<>();
orders.put("order.create_time", "DESC");
queryMultiBo.setOrders(orders);

// 设置分页参数
queryMultiBo.setCurrent(1L);
queryMultiBo.setSize(10L);

// 执行多表关联查询
Page<Map<String, Object>> result = tableService.pageMultiFromTable(queryMultiBo);
```

以上示例展示了如何构建一个包含用户表和产品表的订单查询，查询结果包含了订单信息、用户名和产品信息。

#### 自定义SQL执行

```java
String sql = "SELECT * FROM " + tableName + " WHERE create_time > #{params.createTime}";
Map<String, Object> params = new HashMap<>();
params.put("createTime", "2023-01-01 00:00:00");
List<Map<String, Object>> result = tableService.executeQuery(sql, params);
```

#### 获取表结构

支持获取数据表的结构信息，包括字段名、数据类型、长度、是否可空、默认值、注释等信息：

字段说明：
- `columnName`: 字段名
- `dataType`: 数据类型
- `maxLength`: 最大长度（仅适用于字符串类型）
- `nullable`: 是否可空（"YES"/"NO"）
- `defaultValue`: 默认值
- `comment`: 字段注释
- `columnKey`: 键类型（"PRI"表示主键，"UNI"表示唯一键）

## 配置说明

在application.yml中可进行以下配置：

```yaml
# MyBatis-Plus配置
mybatis-plus:
  mapper-locations: classpath*:/mapper/**/*.xml
  type-aliases-package: com.autoboot.domain
  configuration:
    map-underscore-to-camel-case: true
    cache-enabled: false
  global-config:
    db-config:
      id-type: auto
      logic-delete-value: 1
      logic-not-delete-value: 0

# 自定义配置
auto-boot:
  # 默认表名
  default-table: sys_user
  db:
    # 指定默认主键名（默认为id）
    id-field: id
    # 创建时间字段名（默认为create_time）
    create-time-field: create_time
    # 更新时间字段名（默认为update_time）
    update-time-field: update_time
    # 是否自动处理创建和更新时间（默认为true）
    auto-fill-time: true
    # SQL日志配置
    sql-log:
      # 是否开启SQL日志打印（默认为false）
      enabled: true
      # SQL日志级别（可选值：DEBUG, INFO, WARN, ERROR）
      level: DEBUG
      # 是否显示SQL参数（默认为true）
      show-params: true
      # 是否显示SQL执行时间（默认为true）
      show-execution-time: true
    # 排除表配置
    excluded-tables:
      # 被排除的表名列表，这些表将无法通过此项目访问
      - sys_config

# 日志配置
logging:
  level:
    # MyBatis SQL日志级别
    com.autoboot.mapper: ${auto-boot.db.sql-log.level}
    # Druid SQL日志级别
    com.alibaba.druid: ${auto-boot.db.sql-log.level}
```

## 安全特性

### 表访问控制

为了保护敏感数据和系统配置，本框架提供了表级别的访问控制机制：

1. **表排除功能**：通过在配置文件中设置`auto-boot.db.excluded-tables`，可以指定哪些表不允许通过此项目访问
2. **使用场景**：
   - 保护包含敏感信息的表（如用户密码、身份证号等）
   - 保护系统配置表，防止误操作
   - 保护核心业务数据，只允许通过特定接口访问

3. **配置示例**：
```yaml
auto-boot:
  db:
    excluded-tables:
      - sys_config         # 系统配置表
```

当尝试访问被排除的表时，系统将返回错误信息，提示该表被禁止访问。

## 注意事项

1. 默认使用Map接收和返回数据，也支持强类型实体
2. 插入和更新操作会自动处理创建时间和更新时间，默认字段名为"create_time"和"update_time"
3. 复杂条件查询时，所有条件都是可选的，不需要的条件可以传null
4. 排序条件支持多个字段，按添加顺序排序
5. 区间查询支持时间和数值类型
6. 多表关联查询中，需要明确指定关联条件和查询字段，字段名最好带上表名前缀避免歧义

## 鸣谢

本项目基于以下优秀开源项目构建：

- [Spring Boot](https://spring.io/projects/spring-boot) - 一个用于构建生产级别的Spring应用程序的框架
- [MyBatis-Plus](https://baomidou.com/) - MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变

感谢这些优秀的开源项目为我们的开发工作提供了强大的支持！