# dbeasy

**Repository Path**: messi_lyx/dbeasy

## Basic Information

- **Project Name**: dbeasy
- **Description**: 简化数据库操作，告别mapper,spring项目使用mybatis-plus进行数据库操作，其他项目使用hutool-db进行数据库操作
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2023-04-18
- **Last Updated**: 2025-08-13

## Categories & Tags

**Categories**: Uncategorized

**Tags**: ORM, SQL, Java

## README

# dbeasy

#### 介绍
简化数据库操作，告别mapper,spring项目使用mybatis-plus进行数据库操作，其他项目使用hutool-db进行数据库操作



#### 开发中

##### 开发进度

###### 2023-04-24

1、完成部分查询数据库方法

2、完成查询sql语句拼接

3、完成一些基础注解（@Column，@DSName，@Table）

4、完成Lambda查询方式接口

###### 2023-04-25

1、完善查询方法接口

2、添加增删改方法接口

3、基本完成1.0.0版本接口，后续继续更新

###### 2023-05-09

1.0.0版本完成。后续使用中发现问题会进行修改。

###### 2023-05-22

修改1.0.0版本sql拼接错误bug，发布1.0.1版本

###### 2023-06-14

修改1.0.1使用中发现的bug，发布1.0.2版本

###### 2024-09-18
1.0.8版本，spring项目使用mybatis-plus，支持多数据源，支持多表联查，支持分页查询，支持批量操作，支持事务操作，支持自定义sql，支持自定义查询，支持自定义增删改，支持自定义查询结果转换，支持自定义查询结果转换，支持自定义查询结果转换，支持自定义查询结果转换，支持自定义查询结果转换，支持自定义查询结果转换

###### 2024-09-18

2.0.0版本，修改使用mybatis-plus测试bug

#### 使用实例

查询实例

```java
@Test
    public void queryList(){
        List<SystemRoleMenuPO> list = DB.getDb("mysql").createForPO(SystemRoleMenuPO.class)
                .select(EyLambdaSelects.property(SystemRoleMenuPO::getRoleId),EyLambdaSelects.property(SystemRoleMenuPO::getType))
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getMenuId, 0))
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getRoleId,13))
                .orderBy(EyOrder.desc(SystemRoleMenuPO::getCreateTime))
                .resultToClass(SystemRoleMenuPO.class)
                .toList();
        System.out.println(list);
    }

    @Test
    public void queryListMap(){
        List<Map<String,Object>> list = DB.getDb("mysql").createForPO(SystemRoleMenuPO.class)
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getMenuId, 0))
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getRoleId,13))
                .orderBy(EyOrder.desc(SystemRoleMenuPO::getCreateTime))
                .resultToClass(SystemRoleMenuPO.class)
                .queryForMapList();
        Object o = list.get(0).get("id");
        System.out.println(o);
        System.out.println(list);
    }

    @Test
    public void queryMap(){
        Map<String,Object> map = DB.getDb("mysql").createForPO(SystemRoleMenuPO.class)
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getMenuId, 0))
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getRoleId,13))
                .orderBy(EyOrder.desc(SystemRoleMenuPO::getCreateTime))
                .resultToClass(SystemRoleMenuPO.class)
                .limit(1)
                .queryForMap();
        Object o = map.get("id");
        System.out.println(o);
        System.out.println(map);
    }

    @Test
    public void queryMap2(){
        Map<String,Object> map = DB.getDb("mysql").createForPO(SystemRoleMenuPO.class)
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getRoleId,13))
                .where(EyWheres.or(EyLambdaWheres.eq(SystemRoleMenuPO::getRoleId,13),EyLambdaWheres.eq(SystemRoleMenuPO::getMenuId, 0)))
                .orderBy(EyOrder.desc(SystemRoleMenuPO::getCreateTime))
                .resultToClass(SystemRoleMenuPO.class)
                .limit(1)
                .queryForMap();
        Object o = map.get("id");
        System.out.println(o);
        System.out.println(map);
    }

    @Test
    public void queryJoin(){
        List<SystemRoleMenuPO> list = DB.getDb("mysql").createForPO(SystemRoleMenuPO.class,"tba")
                .leftJoin(TestUserPO.class,"tbb",EyLambdaWheres.columnEQ("tba",SystemRoleMenuPO::getId,"tbb",TestUserPO::getId))
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getMenuId, 0))
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getRoleId,13))
                .orderBy(EyOrder.desc(SystemRoleMenuPO::getCreateTime))
                .resultToClass(SystemRoleMenuPO.class)
                .toList();
        System.out.println(list);
    }

    @Test
    public void queryStringList(){
        List<String> list = DB.getDb("mysql").createForPO(SystemRoleMenuPO.class)
                .select(EyLambdaSelects.property(SystemRoleMenuPO::getMenuId))
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getMenuId, 0))
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getRoleId,13))
                .toStringList();
        System.out.println(list);
    }

    @Test
    public void queryLimitList(){
        List<SystemRoleMenuPO> list = DB.getDb("mysql").createForPO(SystemRoleMenuPO.class)
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getMenuId, 0))
                .resultToClass(SystemRoleMenuPO.class)
                .limit(1)
                .toList();
        System.out.println(list);
    }

    @Test
    public void queryPage(){
        Page<SystemRoleMenuPO> page = DB.getDb("mysql").createForPO(SystemRoleMenuPO.class)
                .resultToClass(SystemRoleMenuPO.class)
                .pageNum(2)
                .size(10)
                .countTotal()
                .toPage();
        System.out.println(page);
    }

    @Test
    public void delete() throws SQLException {
        DB.getDb("mysql").create(TestUserPO.class)
                .where(EyLambdaWheres.eq(TestUserPO::getId,1))
                .execute();
    }

    @Test
    public void save() throws SQLException {
        TestUserPO po = new TestUserPO();
        po.setAccount("2");
        po.setPass("2");
        DB.getDb("mysql").create().save(po);
        System.out.println(po);
    }

    @Test
    public void saveList() throws SQLException {
        List<TestUserPO> list = new ArrayList<>();
        TestUserPO po = new TestUserPO();
        po.setId(LongIdUtils.nextId());
        po.setAccount("4");
        po.setPass("4");
        list.add(po);
        TestUserPO po2 = new TestUserPO();
        po2.setId(LongIdUtils.nextId());
        po2.setAccount("3");
        po2.setPass("3");
        list.add(po2);
        DB.getDb("mysql").create().batchSave(list);
        System.out.println(list);
    }

    @Test
    public void update() throws SQLException {
        DB.getDb("mysql").createPO(SystemRoleMenuPO.class)
                .set(SystemRoleMenuPO::getMenuId,7645)
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getId,"1650770637398876160")).execute();
    }

    @Test
    public void update01() throws SQLException {
        TestUserPO po = new TestUserPO();
        po.setId(1650770637398876160L);
        po.setPass("443322");
        DB.getDb("mysql").createPO(TestUserPO.class).update(po).execute();
    }

    @Test
    public void update02() throws SQLException {
        TestUserPO po = new TestUserPO();
        po.setId(1650770637398876160L);
        po.setPass("4433221100");
        DB.getDb("mysql").createPO(TestUserPO.class).updateByEmtity(po);
    }

    @Test
    public void selectSql(){
        List<SystemRoleMenuPO> list = DB.getDb("mysql").createSelect("SELECT * FROM system_role_menu AS _root WHERE _root.menu_id = 0 AND _root.role_id = 13 ORDER BY create_time DESC")
                .resultToClass(SystemRoleMenuPO.class)
                .toList();
        System.out.println(list.toString());
    }

    @Test
    public void selectCase(){
        List<String> list = DB.getDb("mysql").createForPO(TestUserPO.class)
                        .select(EyLambdaSelects.caseField(TestUserPO::getPass).when("'2'").then("'测试2'")
                                .when("'3'").then("'测试3'").elseData("'测试4'")).toStringList();
        System.out.println(list.toString());
    }

    @Test
    public void selectDataSource(){
        EasyCriteriaSubclass.URL = "jdbc:mysql://localhost:3306/jia?useUnicode=true&characterEncoding=UTF-8";
        EasyCriteriaSubclass.USERNAME = "root";
        EasyCriteriaSubclass.PASSWORD = "123456";
        List<SystemRoleMenuPO> list = EasyCriteriaSubclass.createForPO(SystemRoleMenuPO.class, "tba")
                .leftJoin(TestUserPO.class, "tbb", EyLambdaWheres.columnEQ("tba", SystemRoleMenuPO::getId, "tbb", TestUserPO::getId))
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getMenuId, 0))
                .where(EyLambdaWheres.eq(SystemRoleMenuPO::getRoleId, 13))
                .orderBy(EyOrder.desc(SystemRoleMenuPO::getCreateTime))
                .resultToClass(SystemRoleMenuPO.class)
                .toList();
        System.out.println(list);
    }
```

删除实例

```java
DB.getDb("mysql").create(TestUserPO.class)
                .where(EyLambdaWheres.eq(TestUserPO::getId,1))
                .execute();
```

新增实例

```java
  @Test
    public void save() throws SQLException {
        TestUserPO po = new TestUserPO();
        po.setAccount("2");
        po.setPass("2");
        DB.getDb("mysql").create().save(po);
        System.out.println(po);
    }

    @Test
    public void saveList() throws SQLException {
        List<TestUserPO> list = new ArrayList<>();
        TestUserPO po = new TestUserPO();
        po.setId(LongIdUtils.nextId());
        po.setAccount("4");
        po.setPass("4");
        list.add(po);
        TestUserPO po2 = new TestUserPO();
        po2.setId(LongIdUtils.nextId());
        po2.setAccount("3");
        po2.setPass("3");
        list.add(po2);
        DB.getDb("mysql").create().batchSave(list);
        System.out.println(list);
    }
```

修改实例

```java
@Test
    public void update() throws SQLException {
        DB.getDb("mysql").createPO(TestUserPO.class)
                .set(TestUserPO::getPass,7645)
                .where(EyLambdaWheres.eq(TestUserPO::getId,"1650770637398876160")).execute();
    }
```

spring引入依赖后可直接使用设置文件数据库，使用方法

```java
		//查询
		EasyCriteria.createForPO(TestUserPO.class)
		//修改
        EasyUpdate.create(TestUserPO.class)
		//删除
        EasyDelete.create(TestUserPO.class)
		//新增
        TestUserPO po = new TestUserPO();
        EasyInsert.create().save(po);
```

实体类实例：

```java
@Data
@Table(value = "testuser")
public class TestUserPO {
    @Column(name = "id",primary = true)
    private Long id ;

    @Column(name = "account")
    private String account;

    @Column(name = "pass")
    private String pass;
}
```

```java
@Table(value = "system_role_menu")
public class SystemRoleMenuPO {
    private Long id;

    private String roleId;

    private String menuId;

    private String type;

    private String createUser;

    private String createTime;

    @Column(name = "id",primary = true)
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    @Column(name = "role_id")
    public String getRoleId() {
        return roleId;
    }

    public void setRoleId(String roleId) {
        this.roleId = roleId;
    }

    @Column(name = "menu_id")
    public String getMenuId() {
        return menuId;
    }

    public void setMenuId(String menuId) {
        this.menuId = menuId;
    }

    @Column(name = "type")
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Column(name = "create_user")
    public String getCreateUser() {
        return createUser;
    }

    public void setCreateUser(String createUser) {
        this.createUser = createUser;
    }

    @Column(name = "create_time")
    public String getCreateTime() {
        return createTime;
    }

    public void setCreateTime(String createTime) {
        this.createTime = createTime;
    }
}
```

####  新查询构造器

添加Structure文件

```java
public class TestUserStructure extends TableStructure<TestUserPO> {

    public final ColumnStructure<TestUserPO,Long> id = new ColumnStructure<>(this,TestUserPO::getId);
    public final ColumnStructure<TestUserPO,String> account = new ColumnStructure<>(this,TestUserPO::getAccount);
    public final ColumnStructure<TestUserPO,String> pass = new ColumnStructure<>(this,TestUserPO::getPass);

    public TestUserStructure(String alias) {
        super(alias);
    }

    public TestUserStructure() {
        super(null);
    }

    @Override
    public TestUserStructure as(String alias) {
        return new TestUserStructure(alias);
    }

    @Override
    public TableStructure<TestUserPO> deleteTable() {
        return new TestUserStructure();
    }
}
```

```java
public class SystemRoleMenuStructure extends TableStructure<SystemRoleMenuPO> {

    public final ColumnStructure<SystemRoleMenuPO,Long> id = new ColumnStructure<>(this,SystemRoleMenuPO::getId);
    public final ColumnStructure<SystemRoleMenuPO,String> roleId = new ColumnStructure<>(this,SystemRoleMenuPO::getRoleId);
    public final ColumnStructure<SystemRoleMenuPO,String> menuId = new ColumnStructure<>(this,SystemRoleMenuPO::getMenuId);
    public final ColumnStructure<SystemRoleMenuPO,String> type = new ColumnStructure<>(this,SystemRoleMenuPO::getType);
    public final ColumnStructure<SystemRoleMenuPO,String> createUser = new ColumnStructure<>(this,SystemRoleMenuPO::getCreateUser);
    public final ColumnStructure<SystemRoleMenuPO,String> createTime = new ColumnStructure<>(this,SystemRoleMenuPO::getCreateTime);

    public SystemRoleMenuStructure(String alias) {
        super(alias);
    }

    public SystemRoleMenuStructure() {
        super("");
    }

    @Override
    public TableStructure<SystemRoleMenuPO> as(String alias) {
        return new SystemRoleMenuStructure(alias);
    }

    @Override
    public TableStructure<SystemRoleMenuPO> deleteTable() {
        return new SystemRoleMenuStructure();
    }
}
```

使用示例

```java
    @Test
    public void selectFrom2(){
        TestUserStructure testUser = new TestUserStructure("u");
        SelectTemplate selectTamplate = (SelectTemplate) DB.getDb("mysql","select");
        String max = selectTamplate.from(testUser)
                .select(testUser.min(testUser.id).as("min"))
                .queryForString();
        System.out.println(max);
    }

    @Test
    public void selectFrom3(){
        TestUserStructure testUser = new TestUserStructure("u");
        SystemRoleMenuStructure systemRoleMenu = new SystemRoleMenuStructure("s");
        SelectTemplate selectTamplate = (SelectTemplate) DB.getDb("mysql","select");
        Map<String,Object> list = selectTamplate.from(testUser)
                .select(testUser.propertyAll(),systemRoleMenu.countRow().as("num"))
                .rightJoin(systemRoleMenu).on(testUser.id.columnEQ(systemRoleMenu.id))
                .whereIf(!EmptyUtil.isEmpty(""),systemRoleMenu.menuId.eq(0))
                .where(systemRoleMenu.roleId.eq(13))
                .resultToClass(SystemRoleMenuPO.class)
                .queryForMap();
        System.out.println(JSONUtil.toJsonStr(list));
    }

    @Test
    public void selectFrom4(){
        TestUserStructure testUser = new TestUserStructure("u");
        SelectTemplate selectTamplate = (SelectTemplate) DB.getDb("mysql","select");
        List<TestUserPO> list = selectTamplate.from(testUser)
                .select(testUser.id,testUser.pass)
                .where(testUser.pass.eq("2"))
                .resultToClass(TestUserPO.class)
                .toList();
        System.out.println(JSONUtil.toJsonStr(list));
    }

    @Test
    public void selectFrom5(){
        TestUserStructure testUser = new TestUserStructure("u");
        SelectTemplate selectTamplate = (SelectTemplate) DB.getDb("mysql","select");
        List<TestUserPO> list = selectTamplate.from(testUser)
                .select(testUser.propertyAll())
                .resultToClass(TestUserPO.class)
                        .toList();
        System.out.println(JSONUtil.toJsonStr(list));
    }
```





目前本项目已发布至中央仓库，可直接引用依赖

```xml
<dependency>
  <groupId>top.remliyx.dbeasy</groupId>
  <artifactId>dbeasy</artifactId>
  <version>2.0.1-RELEASE</version>
</dependency>
```



#### 参与贡献

1.  Fork 本仓库
2.  新建 Feat_xxx 分支
3.  提交代码
4.  新建 Pull Request


#### 特技

1.  使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md
2.  Gitee 官方博客 [blog.gitee.com](https://blog.gitee.com)
3.  你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解 Gitee 上的优秀开源项目
4.  [GVP](https://gitee.com/gvp) 全称是 Gitee 最有价值开源项目，是综合评定出的优秀开源项目
5.  Gitee 官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help)
6.  Gitee 封面人物是一档用来展示 Gitee 会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/)