jdbc数据持久化

最新推荐文章于 2024-02-02 13:46:35 发布

night_du

最新推荐文章于 2024-02-02 13:46:35 发布

阅读量499

点赞数

分类专栏： JavaWeb 文章标签： mysql 数据库 sql

本文链接：https://blog.csdn.net/weixin_44119864/article/details/125262988

版权

JavaWeb 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

概述

定义

一种公共接口，提供了访问数据库并操作数据库的API，可以为多种关系数据库提供统一的访问。

在这里插入图片描述

流程

与数据库建立连接
发送操作数据库的语句
返回处理结果

JDBC使用

访问数据库步骤

a.加载驱动，建立连接
    Class.forName(类路径);//DriverManger.registerDiver(new Driver())
    Connection:DriverManger.getConnection(url,username,password);
    url：jdbc:mysql://ip:端口号/库名
b.获取statement对象
    Statement:con.createStatment();
c.执行sql，获取结果集
    ResultSet:statement.executeQuery();//查询操作
    int:statment.executeUpdate();//DML操作
d.关闭连接(rs.close(),stament.close(),con.close())
ResultSet接口:
    rs.next();判断有没有下一跳记录，如果有，游标下移
    rs.get***(下标/列名);比如:rs.getInt(1)等价于rs.getString("id")

流程实现

 	    //加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //建立连接
        Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/db05?characterEncoding=UTF-8",
                "root", "123456");
        //获取statement对象
        Statement statement = con.createStatement();

        //创建添加sql语句
        String addSql = "insert into emp(ename,salary) values(\"jack\",200)";
        //创建修改的sql语句
        String updateSql = "update emp set ename=\"josn\" where id=28";
        //创建删除的语句
        String delSql = "delete from emp where id=27";
        //创建查询sql语句
        String querySql = "select ename,salary from emp";

        //执行sql语句
        int addRow = statement.executeUpdate(addSql);
        int updateRow = statement.executeUpdate(updateSql);
        int delRow = statement.executeUpdate(delSql);
        ResultSet resultSet = statement.executeQuery(querySql);

        System.out.println("新增：" + addRow);
        System.out.println("修改：" + updateRow);
        System.out.println("删除：" + delRow);
        //遍历查询出来的数据
        while (resultSet.next()) {
            String ename = resultSet.getString("ename");
            double salary = resultSet.getDouble("salary");
            System.out.println(ename + "\t" + salary);
        }
        
        //关闭资源
        resultSet.close();
        statement.close();
        con.close();

核心接口详解

DriverManager

主要作用就是创建一个数据库连接，使用反射的方式去加载注册驱动，不同的驱动写法不一样
获取Connection的时候，调用了DriverManager的getConnection方法，它有四个方法，主要使用下面这个方法
```
public static Connection getConnection(String url,String user, String password)
```
该方法的就是为了获取数据库的连接，最终调用java.util.Properties类，和配置文件相关，继承了HashTable，通过下面的方式将用户名和密码封装到Properties
```
 java.util.Properties info = new java.util.Properties();
 return (getConnection(url, info, Reflection.getCallerClass()));

 class Properties extends Hashtable<Object,Object>
```

Statement

是一个接口，主要操作sql，并且返回相应结果的对象。

ResultSet executeQuery(String sql) ：根据查询语句返回结果集，但是只能执行select语句

int executeUpdate(String sql) ：执行DML语句，返回影响的行数

ResultSet

是一个接口，主要封装结果集

Object getObject(String columnLabel)：根据列表取值

Object getObject(int columnIndex)：根据序号取值，索引从1开始，但是可读性不强。

连接管理

编写一个访问数据的工具类(DBUtil),此后所有访问数据库的操作，都从工具类获取连接，关闭连接。
目的:统一访问，减少代码的重复率，并提升了代码的可维护性。

获取连接所需要的参数两种写法:

直接把连接参数写在DBUtil中，后期修改参数时，需要更新class文件
将连接参数写在properties配置文件中，当参数需要修改时，直接操作文件，不需要修改java类–推荐

连接池

概念

数据库连接池是一些网络代理服务或者应用服务器实现的特性。实现一个持久连接的“池”，允许其他程序、客户端连接，被所有连接的客户端共享使用，连接池也可以加速连接，减少数据库连接，降低数据库服务的负载

基本实现

//jdbc连接池工具类：连接（读取配置信息内容）、关闭资源
public class DruidPoolUtil {
    private static DataSource dataSource = null;	//创建连接池对象
    private static Properties properties = new Properties();	//创建Properties读取配置文件

    //获取配置信息
    static {
        try {	//读取配置文件信息：数据库地址、密码等等
            InputStream resource = PropertiesUtil.class.getClassLoader().getResourceAsStream("Properties.properties");
            properties.load(resource);
            dataSource = DruidDataSourceFactory.createDataSource(properties); //获取连接池对象
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //获取连接
    public static Connection getConnection() {
        Connection connection = null;
        try {
            connection = dataSource.getConnection();	//获取连接
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }

    //关闭资源：DQL操作
    public static void close(ResultSet rs, Statement st, Connection con) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    //关闭资源：DML操作
    public static void close(Statement st, Connection con) {
        close(null, st, con);
    }
}

    public static void main(String[] args) {
        Connection connection = DruidPoolUtil.getConnection();	//获取连接
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            statement = connection.createStatement();	//获取Statement
            String querySql = "select ename,salary from emp";
            resultSet = statement.executeQuery(querySql);	//执行sql
            while (resultSet.next()) {	//遍历数据
                String ename = resultSet.getString("ename");
                double salary = resultSet.getDouble("salary");
                System.out.println(ename + "\t" + salary);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DruidPoolUtil.close(resultSet, statement, connection); //关闭资源
        }
    }

连接池与持久连接

长连接是一些驱动、驱动框架、ORM工具的特性，由驱动来保持连接句柄的打开，以便后续的数据库操作可以重用连接，从而减少数据库的连接开销
连接池是应用服务器的组件，它可以通过参数来配置连接数、连接检测、连接的生命周期等等
如果连接池或长连接的连接数很多，可能会出现超过数据库实例的限制，那就需要留意相关的设置比如连接池的最小、最大连接数设置，以及php-fpm的进程个数，否则程序将不能申请新的连接

连接数

最小连接数和最大连接数的设置

最小连接数：连接池一直保持的数据库连接，如果应用程序对数据库连接的使用量不大，将会有大量的数据库资源被浪费
最大连接数：连接池能申请的最大连接数，如果数据库连接请求超过次数，后面的数据库连接请求将被加入等待队列中，会影响到数据库操作
如果最小连接数与最大连接数相差很大，那么最先连接请求将会获利，之后超过最小连接数的连接请求等价于建立一个新的数据库连接。当大于最小连接数的数据库连接在使用完不会马上释放，将被放到连接池中等待重复使用或是空间超时后被释放

常用参数配置

initialSize：初始化连接数
maxActive：最大连接数。假设是20，表示同时最多有20个连接
maxIdle：最大可空闲的连接数。假设取值10，即使没有数据库连接，依旧可以保持10个空闲连接且不被清除，处于待命状态
minidle：最小空闲的连接数，当连接数小于此值，连接池会创建连接来补充到该值的数量
maxWait：毫秒，-1是无限等待。例如5000，表示等待5秒，之后超时抛出错误信息

PrearedStatement

package com.qf.demo;

import com.qf.util.DruidPoolUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class QueryDept {
    public static void main(String[] args) {
        //queryDeptById(1);
        insertEmpt(12, 70, "后勤部", "杭州");
    }

    public static void queryDeptById(int id) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            connection = DruidPoolUtil.getConnection();
            String sql = "select * from dept where id=?";
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1, id);
            resultSet = preparedStatement.executeQuery();
            System.out.println("ID" + "\t" + "部门编号" + "\t" + "部门名" + "\t" + "部门地址");
            if (resultSet.next()) {
                int i = resultSet.getInt("id");
                String deptno = resultSet.getString("deptno");
                String dname = resultSet.getString("dname");
                String localtion = resultSet.getString("location");
                System.out.println(i + "\t" + deptno + "\t\t" + dname + "\t" + localtion);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DruidPoolUtil.close(resultSet, preparedStatement, connection);
        }
    }

    public static void insertEmpt(int id, int deptno, String dname, String location) {
        Connection con = null;
        PreparedStatement ps = null;
        try {
            con = DruidPoolUtil.getConnection();
            String sql = "insert into dept (id,deptno,dname,location) values(?,?,?,?)";
            ps = con.prepareStatement(sql);
            ps.setInt(1, id);
            ps.setInt(2, deptno);
            ps.setString(3, dname);
            ps.setString(4, location);
            int i = ps.executeUpdate();
            System.out.println("操作成功：" + i + "行");
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
}

useServerPrepStmts=true&cachePrepStmts=true默认关闭，内存增加，性能提升不大

        Connection con = null;
        PreparedStatement ps = null;
        try {
            con = DruidPoolUtil.getConnection();
            //将事务设置为手动提交，默认是自动提交
            con.setAutoCommit(false);
            String sql = "insert into logs  values(null,?,now())";
            ps = con.prepareStatement(sql);
            ps.setInt(1, 1001);
            int row1 = ps.executeUpdate();

            //模拟异常
            Integer.parseInt(null);
            ps.setInt(1, 1002);
            int row2 = ps.executeUpdate();
            System.out.println("新增成功");
            //根据返回值判断是否成功，如果成功提交事务，不成功回滚事务
            if (row1 == 1 && row1 == row2) {
                con.commit();   
            } else {
                con.rollback();
            }
        } catch (SQLException e) {
            e.printStackTrace();
            try {   //事务中有异常，让事务回滚
                con.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally { //关闭资源
            DruidPoolUtil.close(ps, con);
        }

批处理

        Connection con = null;
        PreparedStatement ps = null;
        try {
            con = DruidPoolUtil.getConnection();
            String sql = "insert into logs values (null,?,null)";
            ps = con.prepareStatement(sql);
            for (int i = 0; i < 1600; i++) {
                ps.setInt(1, i);
                ps.addBatch();
                if (i % 500 == 0) { //当缓存列表有500个sql，批量执行sql
                    ps.executeBatch();
                    ps.clearBatch();
                }
            }
            ps.executeBatch();
            ps.clearBatch();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DruidPoolUtil.close(ps, con);
        }

分页

        Connection con = null;
        PreparedStatement ps = null;
        try {
            con = DruidPoolUtil.getConnection();
            String sql = "insert into logs values (null,?,null)";
            ps = con.prepareStatement(sql);
            for (int i = 0; i < 1600; i++) {
                ps.setInt(1, i);
                ps.addBatch();
                if (i % 500 == 0) { //当缓存列表有500个sql，批量执行sql
                    ps.executeBatch();
                    ps.clearBatch();
                }
            }
            ps.executeBatch();
            ps.clearBatch();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DruidPoolUtil.close(ps, con);
        }

封装ResultSet

package com.qf.util;

import com.google.common.collect.Lists;

import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.List;

/**
 * @Author:night_du
 * @Date:2021/11/2 14:23
 *
 * 封装ResultSet结果集
 */
public class BeanUtil {
    /**
     * @param rs     查询之后返回的结果集
     * @param classz 待封装的Bean对象的实例
     * @param <T>
     * @return
     */
    public static <T> List<T> resultToBeanmany(ResultSet rs, Class<T> classz) {
        //判断是否为空
        if (rs == null) {
            return null;
        }

        List<T> list = Lists.newArrayList();
        try {
            //元数据
            ResultSetMetaData metaData = rs.getMetaData();
            //返回ResultSet对象中的列数
            int colums = metaData.getColumnCount();
            while (rs.next()) {
                //创建对象
                T t = classz.newInstance();	//反射：类对象实例
                //给对象的属性复制
                for (int i = 1; i <= colums; i++) {
                    String fieldName = metaData.getColumnLabel(i);   //获取列名
                    Object val = rs.getObject(fieldName);//获取列值
                    Field field = classz.getDeclaredField(fieldName);   //获取属性
                    field.setAccessible(true);  //设置访问权限放开：私有的无法访问
                    field.set(t, val);
                }
                list.add(t);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

    public static <T> T resultToBeanOne(ResultSet rs, Class<T> claszz) {
        List<T> list = resultToBeanmany(rs, claszz);
        if (list == null) {
            return null;
        }
        T t = null;
        if (list.size() > 0) {
            t = list.get(0);
        }
        return t;
    }
}

//使用
Dept dept = BeanUtil.resultToBeanOne(resultSet, Dept.class);
System.out.println(dept);
List<Dept> list = BeanUtil.resultToBeanmany(resultSet, Dept.class);
System.out.println(list);

工厂模式

实体类entity ：Dept

public class Dept {
    private Integer id;
    private Integer deptno;
    private String dname;
    private String location;

    public Dept() {
    }

    public Dept(Integer id, Integer deptno, String dname, String location) {
        this.id = id;
        this.deptno = deptno;
        this.dname = dname;
        this.location = location;
    }
    //toString	get	set

接口类Dao : DeptDao

public interface DeptDao {
    void insert(Dept dept);	//添加

    void del(int id);	//删除

    void update(Dept dept);	//更新

    List<Dept> findAll();	//查询所有

    Dept findById(int id);	//根据id查询
}

接口实现类DaoImpl : DeptDaoImpl

public class DeptDaoImpl implements DeptDao {
    @Override
    public void insert(Dept dept) {
        Connection con = null;
        PreparedStatement ps = null;
        try {
            con = DruidPoolUtil.getConnection();
            String sql = "insert into dept values(?,?,?,?)";
            ps = con.prepareStatement(sql);
            ps.setInt(1, dept.getId());
            ps.setInt(2, dept.getDeptno());
            ps.setString(3, dept.getDname());
            ps.setString(4, dept.getLocation());
            ps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DruidPoolUtil.close(ps, con);
        }
    }

    @Override
    public void del(int id) {
        Connection con = null;
        PreparedStatement ps = null;
        try {
            con = DruidPoolUtil.getConnection();
            String sql = "delete from dept where id=?";
            ps = con.prepareStatement(sql);
            ps.setInt(1, id);
            ps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DruidPoolUtil.close(ps, con);
        }
    }

    @Override
    public void update(Dept dept) {
        Connection con = null;
        PreparedStatement ps = null;
        try {
            con = DruidPoolUtil.getConnection();
            String sql = "update dept set deptno=?,dname=?,location=? where id=?";
            ps = con.prepareStatement(sql);
            ps.setInt(1, dept.getDeptno());
            ps.setString(2, dept.getDname());
            ps.setString(3, dept.getLocation());
            ps.setInt(4, dept.getId());
            ps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DruidPoolUtil.close(ps, con);
        }
    }

    @Override
    public List<Dept> findAll() {
        List<Dept> list = new ArrayList<>();
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet resultSet = null;
        try {
            con = DruidPoolUtil.getConnection();
            String sql = "select * from  dept";
            ps = con.prepareStatement(sql);
            resultSet = ps.executeQuery();
            Dept dept = null;
            while (resultSet.next()) {
                dept = new Dept();
                dept.setId(resultSet.getInt("id"));
                dept.setDeptno(resultSet.getInt("deptno"));
                dept.setDname(resultSet.getString("dname"));
                dept.setLocation(resultSet.getString("location"));
                list.add(dept);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DruidPoolUtil.close(resultSet, ps, con);
        }
        return list;
    }

    @Override
    public Dept findById(int id) {
        Dept dept = new Dept();
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            con = DruidPoolUtil.getConnection();
            String sql = "select * from dept where id=?";
            ps = con.prepareStatement(sql);
            ps.setInt(1, id);
            rs = ps.executeQuery();
            if (rs.next()) {
                dept.setId(rs.getInt("id"));
                dept.setDeptno(rs.getInt("deptno"));
                dept.setDname(rs.getString("dname"));
                dept.setLocation(rs.getString("location"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DruidPoolUtil.close(rs, ps, con);
        }
        return dept;
    }
}

工厂类 Factory ： DeptFactory

public class DeptFactory {
    /**
     * 返回符合type接口要求的对象
     *
     * @param type 接口类型
     * @return
     */
    public static <T> T getInstance(String type) {
        T obj = null;
        try {
            String className = PropertiesUtil.getVal(type);
            obj = (T) Class.forName(className).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }

业务类 Service : DeptService

public class DeptService {
    static DeptDao deptDao;

    static {
        try {
            deptDao = DeptFactory.getInstance("DeptDao");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        insert();
        del();
        update();
        findAll();
        findById();
    }

    public static void insert() {

        Dept dept = new Dept(5, 5, "运维", "北京");
        deptDao.insert(dept);
    }

    public static void del() {
        deptDao.del(5);
    }

    public static void update() {
        Dept dept = new Dept(12, 40, "后勤部", "广州");
        deptDao.update(dept);
    }

    public static void findAll() {
        List<Dept> all = deptDao.findAll();
        System.out.println(all);
    }

    public static void findById() {
        System.out.println(deptDao.findById(12));
    }
}

配置文件 Properties.properties

#接口类型=实现类的完整路径
DeptDao=com.qf.dao.impl.DeptDaoImpl

实例

需求

注册与登录

设计表

create table user(
    id int primary key auto_increment,
    username varchar(30) unique,
    name varchar(30) not null,
    pwd varchar(30) not null,
    sex char(1)
);

处理注册数据
- 校验用户名是否唯一
- 如果用户名唯一，将数据入库

导入：

druid-1.1.10.jar

mysql-connector-java-5.1.30-bin.jar

User

package Bean;

import java.util.Date;

/**
 * 实体类
 */
public class User {

    private Integer id;
    private String username;
    private String gender;
    private Date birthday;
    private double salary;
    private String introduce;

    public User() {
    }

    public User(String username, String gender, double salary, String introduce) {
        this.id = id;
        this.username = username;
        this.gender = gender;
        this.salary = salary;
        this.introduce = introduce;
    }
	//get set toString
}

UserDao

package dao;

import Bean.User;

/**
 *
 * 数据访问层
 */
public interface UserDao {
    /**
     * 添加数据
     * @param user  用户信息
     */
    void Insert(User user);

    /**
     * 根据用户名查询信息
     * @param str   用户名
     * @return
     */
    User findByName(String str);
}

UserDaoImpl

package dao.impl;

import Bean.User;
import dao.UserDao;
import util.PropertiesUtil;
import util.UserUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

/**
 * 实现数据访问层
 */
public class UserDaoImpl implements UserDao {
    /**
     * 添加信息
     *
     * @param user 用户信息
     */
    @Override
    public void Insert(User user) {
        Connection con = PropertiesUtil.getConnection();
        PreparedStatement ps = null;
        try {
            String sql = "insert into user values(null,?,?,now(),?,?)";
            ps = con.prepareStatement(sql);
            ps.setString(1, user.getUsername());
            ps.setString(2, user.getGender());
            ps.setDouble(3, user.getSalary());
            ps.setString(4, user.getIntroduce());
            ps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            PropertiesUtil.close(ps, con);
        }
    }

    /**
     * 根据用户名查询信息
     *
     * @param str 用户名
     * @return  返回用户的所有信息
     */
    @Override
    public User findByName(String str) {
        Connection con = PropertiesUtil.getConnection();
        PreparedStatement ps = null;
        User user = null;
        try {
            String sql = "select * from user where username =?";
            ps = con.prepareStatement(sql);
            ps.setString(1, str);
            ResultSet rs = ps.executeQuery();
            //使用工具类（封装了结果集信息）
            user = UserUtil.resultToBeanOne(rs, User.class);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            PropertiesUtil.close(ps, con);
        }
        return user;
    }
}

UserService

package Service;

import Bean.User;

/**
 * 业务层
 */
public interface UserService {
    /**
     * 添加用户信息
     *
     * @param user 用户对象（包含用户的信息）
     */
    void insert(User user);

    /**
     * 查看根据指定的用户名查询，使用有数据
     *
     * @param str 指定的用户名
     * @return true或者false
     */
    Boolean judge(String str);
}

UserFactory

package Factory;

import util.PropertiesUtil;

/**
 * 工厂类：使用工厂设计模式根据配置文件创建类对象
 */
public class UserFactory {
    /**
     * 返回符合type类型的对象
     *
     * @param type
     * @param <T>
     * @return
     */
    public static <T> T getInstance(String type) {
        T obj = null;
        try {   //获取配置文件中key为“type”的数据
            String className = PropertiesUtil.getVal(type);
            //实例化类对象
            obj = (T) Class.forName(className).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }
}

UserServiceImpl

package Service.impl;

import Bean.User;
import Factory.UserFactory;
import Service.UserService;
import dao.UserDao;

/**
 * 业务实现层
 */
public class UserServiceImpl implements UserService {
    static UserDao userDao;

    static {
        //根据工厂累获取对应的类对象
        userDao = UserFactory.getInstance("User");
    }

    /**
     * 添加数据
     *
     * @param user 用户对象（包含用户的信息）
     */
    @Override
    public void insert(User user) {
        userDao.Insert(user);
    }

    /**
     * 看根据指定的用户名查询，使用有数据
     *
     * @param str 指定的用户名
     * @return false代表数据库无该数据，未重复
     */
    public Boolean judge(String str) {
        User user = userDao.findByName(str);
        //如果有数据，id不可能为null,如果为空，声明数据库没有这条数据
        if (user.getId() == null) {
            return false;
        }
        return true;
    }
}

PropertiesUtil

package util;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * 读取配置文件,获取连接池对象，创建连接
 * 资源关闭
 */
public class PropertiesUtil {
    public static Properties properties = new Properties(); //创建Properties对象读取配置文件
    private static DataSource dataSource = null;    //创建连接池对象


    static {
        try {   //使用properties读取配置文件
            InputStream resource = PropertiesUtil.class.getResourceAsStream("/Properties.properties");
            properties.load(resource);
            //获取连接池对象
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取连接
     *
     * @return 返回连接的对象
     */
    public static Connection getConnection() {
        Connection con = null;
        try {
            con = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return con;
    }

    /**
     * 关闭资源
     *
     * @param st  Statement对象
     * @param con Connection对象
     */
    public static void close(ResultSet rs, Statement st, Connection con) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static void close(Statement st, Connection con) {
        close(null, st, con);
    }

    public static String getVal(String key) {
        return properties.getProperty(key);
    }
}

UserUtil

package util;

import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;

/**
 * @Author:night_du
 * @Date:2021/11/2 19:26
 */
public class UserUtil {
    public static <T> T resultToBeanOne(ResultSet rs, Class<T> tClass) {
        if (rs == null) {
            return null;
        }
        T t = null;
        try {
            t = tClass.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            ResultSetMetaData metaData = rs.getMetaData();
            int column = metaData.getColumnCount();
            if (rs.next()) {
                for (int i = 1; i <= column; i++) {
                    String filedName = metaData.getColumnLabel(i);
                    Object val = rs.getObject(filedName);
                    Field field = tClass.getDeclaredField(filedName);
                    field.setAccessible(true);
                    field.set(t, val);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return t;
    }
}

Properties

url=jdbc:mysql://localhost:3306/db05?characterEncoding=UTF-8
username=root
password=123456
driver=com.mysql.jdbc.Driver
#接口类型=实现类的完整路径
User=dao.impl.UserDaoImpl

Run

import Bean.User;
import Service.UserService;
import Service.impl.UserServiceImpl;

public class RunApplication {
    public static void main(String[] args) {
        User user = new User("duca22", "T", 10000.22, "工程师");
        UserService userService = new UserServiceImpl();
        if (userService.judge(user.getUsername()) == false) {
            userService.insert(user);
            System.out.println("数据添加成功");
        } else {
            System.out.println("用户名被占用");
        }
    }
}