# Jdbc工具类

**Repository Path**: sjjshs/jdbc-utility-class

## Basic Information

- **Project Name**: Jdbc工具类
- **Description**: 这个工具类是我大学为了简化jdbc操作而写的,也就是过渡用的,因为作业不能用mybatis等成熟的工具
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-01-17
- **Last Updated**: 2025-01-22

## Categories & Tags

**Categories**: Uncategorized

**Tags**: JDBC, Java, MySQL

## README

# 实战案例

    https://gitee.com/sjjshs/chatroom 这个项目的dao层就是用的这个工具类,我大学的其他作业和项目基本都是用这个工具类过渡 ^_^

# 优势

```java
极大简化繁琐的jdbc流程

查询单个
    MyJdbcUtil.getInstance()
                .selectSql_upgrade("SELECT * FROM chat_room WHERE id =?",
                        new Object[]{id},
                        ChatRoom.class);
查询全部
     MyJdbcUtil.getInstance()
                .selectAll_upgrade("SELECT * FROM chat_room", ChatRoom.class);
插入
    MyJdbcUtil.getInstance()
                .insertSql_upgrade(entity);
更新
    MyJdbcUtil.getInstance()
                .updateSql_upgrade(room,
                        "WHERE id = ? AND create_user_id = ?",
                        new Object[]{room.getId(), uid});
删除
    MyJdbcUtil.getInstance()
                .updateSql("DELETE FROM chat_room WHERE id =?", new Object[]{id});
```

# 关于版本

    以MyJdbcUtil类的版本为准,那是核心类

# 实体类要求

```text
    实体类的要求:支持'封装好的实体类'和'不封装的实体类'
    
    定义:
        '封装类'的定义: 封装要求将属性设为 private 或 protected，并通过 public 的 getter 和 setter 方法提供访问
        '不封装类'的定义: 一个类里的属性如果都是 public，则不符合封装的原则
   
   
    基本要求:
        1. 必须要无参构造函数!!!
        2. 2.0及以上版本必须添加ColumnField注解才能对字段进行操作
        3. 必须实现IMyEntity
    
    不同实体类的特殊要求:
     不封装的实体类:
        不封装的实体类必须公开属性,可以不需要get,set方法,
        采用属性字段直接注入和提取的方式,并且只注入和提取公开字段
        MyJdbcUtil类里的'不带_upgrade'的方法就是给'不封装的实体类'用的
     封装的实体类
        封装好的实体类,字段可以为私有,
        但是需要注入实体类内容的字段需要set方法,
        把内容插入到数据库的字段需要get方法,
        MyJdbcUtil类里的'带_upgrade'的方法就是给封装的实体类用的
```

# 实体类命名约定

```text
    3.0(不包含3.0)前老版本{
            命名规则:
                类:
                 类名: Table 对应的表名: table
                 类名: MyTable1 对应的表名: my_table1
                
                字段:
                 字段: username 对应的列名: username
                 字段: myFood 对应的列名: my_food
                以此类推
        }
    
    3.0版本后支持设置表名和字段名
        3.0后新版本{
            类:
                @TableName("table1") //对应表名 table1
                public class Entity

            字段:
                @ColumnField(colName = "username") //对应的列名 username
                private String name
            注意:如果没使用这些特性则默认为3.0版本前的方案
        }
```

# 实战dao层

```java
package com.fdhwws.web.dao.impl;

import com.fdh.myjdbcutil.MyJdbcUtil;
import com.fdhwws.web.dao.UserDao;
import com.fdhwws.web.domain.User;

import java.util.List;

public class UserDaoImpl implements UserDao {
    @Override
    public User selectById(Integer id) {
        return MyJdbcUtil.getInstance()
                .selectSql_upgrade("SELECT * FROM user WHERE id = ?",
                        new Object[]{id},
                        User.class);
    }

    @Override
    public List<User> selectAll() {
        return MyJdbcUtil.getInstance()
                .selectAll_upgrade("SELECT * FROM user", User.class);
    }

    @Override
    public int insert(User entity) {
        return MyJdbcUtil.getInstance()
                .insertSql_upgrade(entity);
    }

    @Override
    public int update(User entity) {
        return MyJdbcUtil.getInstance()
                .updateSql_upgrade(entity);
    }

    @Override
    public int delete(Integer id) {
        return MyJdbcUtil.getInstance()
                .updateSql("DELETE FROM user WHERE id = ?", new Object[]{id});
    }

    @Override
    public User selectByUsername(String username) {
        return MyJdbcUtil.getInstance()
                .selectSql_upgrade("SELECT * FROM user WHERE username = ?",
                        new Object[]{username},
                        User.class);
    }

    @Override
    public User selectByUsernameAndPassword(String username, String password) {
        return MyJdbcUtil.getInstance()
                .selectSql_upgrade("SELECT * FROM user WHERE username = ? AND password = ?",
                        new Object[]{username, password},
                        User.class);
    }
}

```



# 实体类示例

## 封装类

### 2.0 - 3.0(不包含3.0)版本
```java
//2.0 ~ 3.0(不包含3.0)版本

//类名对应的表名my_table
public class MyTable implements IMyEntity {
    //表示只注入,一般用于自增字段,不会保存到数据库,只会获取数据
    @ColumnField(type = ColumnField.Type.SET)
    private Integer id; //对应的列名 id

    @ColumnField //标注为列字段
    private String username; //对应的列名 username

    @ColumnField
    private String password; //对应的列名 password

    @ColumnField
    @JSONField //表示进行json化处理的字段
    private Content myContent; //对应的列名 my_content

    public MyTable() {

    }

    public MyTable(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Content getMyContent() {
        return myContent;
    }

    public void setMyContent(Content myContent) {
        this.myContent = myContent;
    }

    @Override
    public String toString() {
        return "MyTable{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", myContent=" + myContent +
                '}';
    }
}


```

### 3.0版本后
```java
//3.0版本后

//类名对应的表名 my_new_table
@TableName("my_new_table")
public class MyTable implements IMyEntity {
    //表示只注入,一般用于自增字段,不会保存到数据库,只会获取数据
    @ColumnField(type = ColumnField.Type.SET,colName = "my_new_id")
    private Integer id; //对应的列名 my_new_id

    @ColumnField(colName = "name")
    private String username; //对应的列名 name

    @ColumnField
    private String password; //对应的列名 password

    @ColumnField
    @JSONField //表示进行json化处理的字段
    private Content myContent; //对应的列名 my_content

    public MyTable() {

    }

    public MyTable(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Content getMyContent() {
        return myContent;
    }

    public void setMyContent(Content myContent) {
        this.myContent = myContent;
    }

    @Override
    public String toString() {
        return "MyTable{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", myContent=" + myContent +
                '}';
    }
}

```

## 非封装类
### 2.0 - 3.0(不包含3.0)版本
```java
//2.0 ~ 3.0(不包含3.0)版本

//类名对应的表名 my_table
public class MyTable implements IMyEntity {
    //表示只注入,一般用于自增字段,不会保存到数据库,只会获取数据
    @ColumnField(type = ColumnField.Type.SET)
    public Integer id; //对应的列名 id

    @ColumnField
    public String username; //对应的列名 username

    @ColumnField
    public String password; //对应的列名 password

    @ColumnField
    @JSONField //表示进行json化处理的字段
    public Content myContent; //对应的列名 my_content

    public MyTable() {

    }

    public MyTable(String username, String password) {
        this.username = username;
        this.password = password;
    }

    @Override
    public String toString() {
        return "MyTable{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", myContent=" + myContent +
                '}';
    }
}
```

### 3.0版本后

```java
//3.0版本后

//类名对应的表名 my_new_table
@TableName("my_new_table")
public class MyTable implements IMyEntity {
    //表示只注入,一般用于自增字段,不会保存到数据库,只会获取数据
    @ColumnField(type = ColumnField.Type.SET,colName = "my_new_id")
    public Integer id; //对应的列名 my_new_id

    @ColumnField(colName = "name")
    public String username; //对应的列名 name

    @ColumnField
    public String password; //对应的列名 password

    @ColumnField
    @JSONField //表示进行json化处理的字段
    public Content myContent; //对应的列名 my_content

    public MyTable() {

    }

    public MyTable(String username, String password) {
        this.username = username;
        this.password = password;
    }

    @Override
    public String toString() {
        return "MyTable{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", myContent=" + myContent +
                '}';
    }
}
```
# 使用案例
## 数据库创建

```sql
create table t1
(
    id       int auto_increment
        primary key,
    username varchar(20) not null,
    friends  json        not null,
    my_food  varchar(10) not null
);
```
## 封装类
### 实体类(3.0版本后)
```java
import com.fdh.myjdbcutil.ColumnField;
import com.fdh.myjdbcutil.IMyEntity;
import com.fdh.myjdbcutil.JSONField;
import com.fdh.myjdbcutil.TableName;

@TableName("t1")
public class Table1 implements IMyEntity {
    // isPrimaryKey表示该字段为主键,在更新的时候会用到
    @ColumnField(type = ColumnField.Type.SET, isPrimaryKey = true) 
    private Integer id;

    @ColumnField(colName = "username")
    private String name;

    @ColumnField
    @JSONField
    private Table1 friends;

    @ColumnField
    private String myFood;

    public Table1() {

    }

    public Table1(Integer id, String name, Table1 friends, String myFood) {
        this.id = id;
        this.name = name;
        this.friends = friends;
        this.myFood = myFood;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Table1 getFriends() {
        return friends;
    }

    public void setFriends(Table1 friends) {
        this.friends = friends;
    }

    public String getMyFood() {
        return myFood;
    }

    public void setMyFood(String myFood) {
        this.myFood = myFood;
    }

    @Override
    public String toString() {
        return "Table1{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", friends=" + friends +
                ", myFood='" + myFood + '\'' +
                '}';
    }
}
```
### 数据库操作
```java
import com.fdh.myjdbcutil.*;

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class JdbcTest {
    public static void main(String[] args) throws Exception {
        //连接MYSQL,单例模式,推荐在项目的最开始初始化一次该项目
        MyJdbcUtil.getNewInstance("jdbc:mysql://localhost:3306/test", "username", "password")
                .connectMySQL();
        //设置执行数据库操作时输出sql语句
        MyJdbcUtil.getInstance().setIsPrintSql(true);

        //*************基本操作*************
        //查询数据
        // 方式1 查询数据获取行列数组
        ArrayList<Object[]> table6 = MyJdbcUtil.getInstance()
                .selectSql("SELECT * FROM t1")
                .analyseResultSet(new String[]{"id", "friends", "my_food"}); //注意这里friends字段返回的是json字符串
        //方式2 查询数据返回ResultSet自己处理
        ResultSet resultSet = MyJdbcUtil.getInstance().selectSql("SELECT * FROM t1").getResultSet();
        while (resultSet.next()) {
            //处理结果
        }

        //更新数据
        int i5 = MyJdbcUtil.getInstance().updateSql("更新/插入/删除sql", new Object[]{"参数1"});
        //案例更新数据
        int i = MyJdbcUtil.getInstance().updateSql("UPDATE t1 SET username=? WHERE id=?", new Object[]{"new_name1", 1});
        //案例删除数据
        int i3 = MyJdbcUtil.getInstance().updateSql("DELETE FROM t1 WHERE id = ?", new Object[]{1});





        //*************实体类操作*************
        // 方式1 使用selectSql_upgrade相关方法,直接注入实体类,适合简单查询
        Table1 table1 = MyJdbcUtil.getInstance()
                .selectSql_upgrade("SELECT id,username,friends,my_food FROM t1 WHERE id = ?", new Object[]{1}, Table1.class);
        // 方式2 使用selectSql方法,链式调用,获取指定字段数据,适合复杂查询
        Table1 table2 = MyJdbcUtil.getInstance()
                .selectSql("SELECT * FROM t1 WHERE id = ?", new Object[]{1})
                .analyseResultSet_upgrade(new String[]{"id", "username", "my_food"}, Table1.class);
        // 方式3 查询全部数据
        List<Table1> table3 = MyJdbcUtil.getInstance()
                .selectAll_upgrade("SELECT * FROM t1", Table1.class);
        List<Table1> table4 = MyJdbcUtil.getInstance()
                .selectAll_upgrade("SELECT username,friends,my_food FROM t1", Table1.class); //会自动解析列名,但是有可能解析错误,所以不推荐复杂查询使用
        // 方式4 查询全部数据的第二种方法,指定字段查询全部,适合复杂查询
        List<Table1> table5 = MyJdbcUtil.getInstance()
                .selectSql("SELECT * FROM t1")
                .analyseResultSetReturnList_upgrade(new String[]{"id", "my_food"}, Table1.class);

        //更新操作,以下方式等效
        // 方式1 使用updateSql_upgrade方法,直接通过实体类更新,注意实体类必须标注主键,通过主键更新
        int i1 = MyJdbcUtil.getInstance()
                .updateSql_upgrade(new Table1(1, "new_name2", null, null));
        // 方式2 使用updateSql_upgrade方法,通过自定义条件更新
        int i2 = MyJdbcUtil.getInstance()
                .updateSql_upgrade(new Table1(null, "new_name3", null, null), "WHERE id = ?", new Object[]{1});


        //插入操作
        int i4 = MyJdbcUtil.getInstance()
                .insertSql_upgrade(new Table1(null, "name", new Table1(null, "friend1", null, null), "food1"));

        //关闭连接,单例模式,推荐在项目的结束时关闭连接
        MyJdbcUtil.getInstance().close();
    }
}

```
## 非封装类
### 实体类(3.0版本后)
```java
import com.fdh.myjdbcutil.ColumnField;
import com.fdh.myjdbcutil.IMyEntity;
import com.fdh.myjdbcutil.JSONField;
import com.fdh.myjdbcutil.TableName;

@TableName("t1")
public class Table1 implements IMyEntity {
    @ColumnField(type = ColumnField.Type.SET, isPrimaryKey = true)
    public Integer id;

    @ColumnField(colName = "username")
    public String name;

    @ColumnField
    @JSONField
    public Table1 friends;

    @ColumnField
    public String myFood;

    public Table1() {

    }

    public Table1(Integer id, String name, Table1 friends, String myFood) {
        this.id = id;
        this.name = name;
        this.friends = friends;
        this.myFood = myFood;
    }

    @Override
    public String toString() {
        return "Table1{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", friends=" + friends +
                ", myFood='" + myFood + '\'' +
                '}';
    }
}
```
### 数据库操作
```java
import com.fdh.myjdbcutil.*;

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class JdbcTest {
    public static void main(String[] args) throws Exception {
        //连接MYSQL,单例模式,推荐在项目的最开始初始化一次该项目
        MyJdbcUtil.getNewInstance("jdbc:mysql://localhost:3306/test", "username", "password")
                .connectMySQL();
        //设置执行数据库操作时输出sql语句
        MyJdbcUtil.getInstance().setIsPrintSql(true);

        //*************基本操作*************
        //查询数据
        // 方式1 查询数据获取行列数组
        ArrayList<Object[]> table6 = MyJdbcUtil.getInstance()
                .selectSql("SELECT * FROM t1")
                .analyseResultSet(new String[]{"id", "friends", "my_food"}); //注意这里friends字段返回的是json字符串
        //方式2 查询数据返回ResultSet自己处理
        ResultSet resultSet = MyJdbcUtil.getInstance().selectSql("SELECT * FROM t1").getResultSet();
        while (resultSet.next()) {
            //处理结果
        }

        //更新数据
        int i5 = MyJdbcUtil.getInstance().updateSql("更新/插入/删除sql", new Object[]{"参数1"});
        //案例更新数据
        int i = MyJdbcUtil.getInstance().updateSql("UPDATE t1 SET username=? WHERE id=?", new Object[]{"new_name1", 1});
        //案例删除数据
        int i3 = MyJdbcUtil.getInstance().updateSql("DELETE FROM t1 WHERE id = ?", new Object[]{1});


        //*************实体类操作*************
        // 方式1 使用selectSql相关方法,直接注入实体类,适合简单查询
        Table1 table1 = MyJdbcUtil.getInstance()
                .selectSql("SELECT id,username,friends,my_food FROM t1 WHERE id = ?", new Object[]{1}, Table1.class);
        // 方式2 使用selectSql方法,链式调用,获取指定字段数据,适合复杂查询
        Table1 table2 = MyJdbcUtil.getInstance()
                .selectSql("SELECT * FROM t1 WHERE id = ?", new Object[]{1})
                .analyseResultSet(new String[]{"id", "username", "my_food"}, Table1.class);
        // 方式3 查询全部数据
        List<Table1> table3 = MyJdbcUtil.getInstance()
                .selectAll("SELECT * FROM t1", Table1.class);
        List<Table1> table4 = MyJdbcUtil.getInstance()
                .selectAll("SELECT username,friends,my_food FROM t1", Table1.class); //会自动解析列名,但是有可能解析错误,所以不推荐复杂查询使用
        // 方式4 查询全部数据的第二种方法,指定字段查询全部,适合复杂查询
        List<Table1> table5 = MyJdbcUtil.getInstance()
                .selectSql("SELECT * FROM t1")
                .analyseResultSetReturnList(new String[]{"id", "my_food"}, Table1.class);

        //更新操作,以下方式等效
        // 方式1 使用updateSql方法,直接通过实体类更新,注意实体类必须标注主键,通过主键更新
        int i1 = MyJdbcUtil.getInstance()
                .updateSql(new Table1(1, "new_name2", null, null));
        // 方式2 使用updateSql方法,通过自定义条件更新
        int i2 = MyJdbcUtil.getInstance()
                .updateSql(new Table1(null, "new_name3", null, null), "WHERE id = ?", new Object[]{1});


        //插入操作
        int i4 = MyJdbcUtil.getInstance()
                .insertSql(new Table1(null, "name", new Table1(null, "friend1", null, null), "food1"));

        //关闭连接,单例模式,推荐在项目的结束时关闭连接
        MyJdbcUtil.getInstance().close();
    }
}
```