JDBC封装工具类

最新推荐文章于 2023-03-21 20:28:30 发布
最新推荐文章于 2023-03-21 20:28:30 发布
阅读量123 收藏
点赞数
文章标签： sql java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58725148/article/details/127720849
版权

配置文件db.properties

db.driver=com.mysql.cj.jdbc.Driver
db.url=jdbc:mysql://localhost:3305/db?useUnicode=true&characterEncoding=utf8&serverTimezone=PRC
db.username=root
db.password=

封装工具类

package com.nnzb;

import java.io.InputStream;
import java.io.StringReader;
import java.sql.*;
import java.util.*;
import java.util.stream.Collectors;

/**
 * author：nnzb
 * email：xymhxxqw@163.com
 * time：17:02
 */

public class DbUtil {
    private String driver;
    private String url;
    private String username;
    private String password;
    private Connection conn = null;
    private int currpage = 1;
    private int pagesize = 10;
    private int recordcount = 0;
    private int pagecount = 1;

    public DbUtil() {
        connect();
    }

    public DbUtil(String url, String username, String password) {
        connect(url, username, password);
    }

    public DbUtil(String host, int port, String dbname, String username, String password) {
        this.url = String.format("jdbc:mysql://%s:%d/%s?useUnicode=true&characterEncoding=utf8&serverTimezone=PRC", host, port, dbname);
        this.username = username;
        this.password = password;
        connect(url, username, password);
    }


    public List<Map<String, Object>> page(String sql, Object... params) {
        List<Map<String, Object>> list = new ArrayList<>();
        // 统计并计算
        String sc = "select count(*) ".concat(sql.substring(sql.indexOf("from")));

        try {
            PreparedStatement psc = conn.prepareStatement(sc);
            for (int i = 0; i < params.length; i++) {
                psc.setObject(i + 1, params[i]);
            }
            ResultSet rsc = psc.executeQuery();
            rsc.next();
            this.recordcount = rsc.getInt(1);
            this.pagecount = this.recordcount % this.pagesize == 0 ? this.recordcount / this.pagesize : this.recordcount / this.pagesize + 1;
            if (this.currpage < 1) this.currpage = 1;
            if (this.currpage > this.pagecount) this.currpage = this.pagecount;
            rsc.close();
            psc.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 查询当前页的数据结果，并返回
        String sok = sql.concat(" limit ?,?");
        try {
            PreparedStatement pst = conn.prepareStatement(sok);
            for (int i = 0; i < params.length; i++) {
                pst.setObject(i + 1, params[i]);
            }
            pst.setInt(params.length + 1, this.currpage * this.pagesize - this.pagesize);
            pst.setInt(params.length + 2, this.pagesize);

            ResultSet rs = pst.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();
            while (rs.next()) {
                Map<String, Object> map = new HashMap<>();
                for (int i = 1; i <= rsmd.getColumnCount(); i++) {
                    String cn = rsmd.getColumnLabel(i);
                    map.put(cn, rs.getObject(cn));
                }
                list.add(map);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

        // 将分页信息保存到list
        StringBuilder sbu = new StringBuilder();
        sbu.append(String.format("第%d页/共%d页 每页%d条/共%d条",this.currpage,this.pagecount,this.pagesize,this.recordcount));

        Map<String,Object> pinfo = new HashMap<>();
        pinfo.put("currpage",this.currpage);
        pinfo.put("pagesize",this.pagesize);
        pinfo.put("pagecount",this.pagecount);
        pinfo.put("recordcount",this.recordcount);
        pinfo.put("info",sbu.toString());
        list.add(pinfo);


        return list;
    }


    public List<Map<String, Object>> query(String sql, Object... params) {
        List<Map<String, Object>> list = new ArrayList<>();
        try {
            PreparedStatement pst = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                pst.setObject(i + 1, params[i]);
            }
            ResultSet rs = pst.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();
            while (rs.next()) {
                Map<String, Object> map = new HashMap<>();
                for (int i = 1; i <= rsmd.getColumnCount(); i++) {
                    String cn = rsmd.getColumnLabel(i);
                    map.put(cn, rs.getObject(cn));
                }
                list.add(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }


    // 执行sql语句 insert update delete 相关的语句，有响应行
    public int update(String sql, Object... params) {
        int rows = 0;
        try {
            PreparedStatement pst = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                pst.setObject(i + 1, params[i]);
            }
            rows = pst.executeUpdate();

        } catch (Exception e) {
            e.printStackTrace();
        }
        return rows;
    }


    public int deleteAll(String tn) {
        return deleteByWhere(tn, "1=1");
    }


    public int count(String tn, String wh, Object... param) {
        int rows = 0;
        try {
            String sql = String.format("select count(*) from %s where %s", tn, wh);
            PreparedStatement pst = conn.prepareStatement(sql);
            for (int i = 0; i < param.length; i++) {
                pst.setObject(i + 1, param[i]);

            }
            ResultSet rs = pst.executeQuery();
            rs.next();
            rows = rs.getInt(1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return rows;
    }


    public int count(String tn) {
        int rows = 0;
        try {
            String sql = String.format("select count(*) from %s", tn);
            PreparedStatement pst = conn.prepareStatement(sql);

            ResultSet rs = pst.executeQuery();
            rs.next();
            rows = rs.getInt(1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return rows;
    }


    public int deleteByWhere(String tn, String wh) {
        int rows = 0;
        String sql = String.format("delete from %s where %s", tn, wh);
        try {
            PreparedStatement pst = conn.prepareStatement(sql);
            rows = pst.executeUpdate();

        } catch (Exception e) {
            e.printStackTrace();
        }
        return rows;
    }


    public int insert(String tn, Map<String, Object> values) {
        int rows = 0;
        List<String> ks = new ArrayList<>();
        List<Object> vs = new ArrayList<>();
        values.forEach((k, v) -> {
            ks.add(k);
            vs.add(v);
        });

        String[] ww = new String[ks.size()];
        Arrays.fill(ww, "?");
        System.out.println();
        System.out.println();

        String sql = String.format("insert into %s(%s) value(%s)", tn, ks.stream().collect(Collectors.joining(",")), Arrays.stream(ww).collect(Collectors.joining(",")));

        try {
            PreparedStatement pst = conn.prepareStatement(sql);
            for (int i = 0; i < vs.size(); i++) {
                pst.setObject(i + 1, vs.get(i));
            }
            rows = pst.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return rows;
    }


    public Set<String> dbs() {
        Set<String> set = new HashSet<>();
        try {
            PreparedStatement pst = this.conn.prepareStatement("show databases");
            ResultSet rs = pst.executeQuery();
            while (rs.next()) {
                set.add(rs.getString(1));
            }
            rs.close();
            pst.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return set;
    }

    public Set<String> tbs() {
        Set<String> set = new HashSet<>();
        List<Map<String, Object>> list = query("show tables");
        for (Map<String, Object> mm : list) {
            for (String k : mm.keySet()) {
                set.add(mm.get(k).toString());
            }
        }

        return set;
    }

    public Set<String> tbs(String dbname) {
        Set<String> set = new HashSet<>();
        List<Map<String, Object>> list = query("show tables from " + dbname);
        for (Map<String, Object> mm : list) {
            for (String k : mm.keySet()) {
                set.add(mm.get(k).toString());
            }
        }
        return set;
    }

    public void connect() {
        // 加载src/main/resources/db.properties
        try {
            InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties");
            Properties prop = new Properties();
            prop.load(is);
            this.driver = prop.getProperty("db.driver", "com.mysql.cj.jdbc.Driver");
            this.url = prop.getProperty("db.url", "jdbc:mysql://localhost:3306/");
            this.username = prop.getProperty("db.username", "root");
            this.password = prop.getProperty("db.password", "");
            Class.forName(this.driver);
            connect(this.url, this.username, this.password);

        } catch (Exception e) {
            System.out.println("数据库连接失败：" + e.getMessage());
        }
    }

    public void connect(String url, String username, String password) {
        try {
            this.conn = DriverManager.getConnection(url, username, password);
        } catch (Exception e) {
            System.out.println("数据库连接失败：" + e.getMessage());
        }
    }

    public void close() {
        try {
            if (this.conn != null) {
                this.conn.close();
            }
        } catch (Exception e) {
            System.out.println("数据库连接关闭失败：" + e.getMessage());
        }
    }


    public Connection getConn() {
        return conn;
    }

    public void setConn(Connection conn) {
        this.conn = conn;
    }

    public String getDriver() {
        return driver;
    }

    public void setDriver(String driver) {
        this.driver = driver;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    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 int getCurrpage() {
        return currpage;
    }

    public void setCurrpage(int currpage) {
        this.currpage = currpage;
    }

    public int getPagesize() {
        return pagesize;
    }

    public void setPagesize(int pagesize) {
        this.pagesize = pagesize;
    }

    public int getRecordcount() {
        return recordcount;
    }

    public void setRecordcount(int recordcount) {
        this.recordcount = recordcount;
    }

    public int getPagecount() {
        return pagecount;
    }

    public void setPagecount(int pagecount) {
        this.pagecount = pagecount;
    }
}

测试代码

package com.nnzb;

import org.junit.jupiter.api.Test;

import javax.management.Query;
import javax.swing.*;
import java.time.LocalDate;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * author：nnzb
 * email：xymhxxqw@163.com
 * time：20:29
 */

public class DbUtilDemo {



    @Test
    void t2(){
        DbUtil du = new DbUtil();

        //int rows = du.update("insert into t_student(name,birth,gender,score) values(?,?,?,?)","张三丽", LocalDate.now(),"女",80);
        //System.out.println(rows);

        // Map<String,Object> map = new HashMap<>();
        // map.put("name","张磊");
        // map.put("score",88);
        // int rows = du.insert("t_student",map);
        // System.out.println(rows);

        // int rows = du.deleteByWhere("t_student","name like '张%'");
        // System.out.println(rows);

        // System.out.println(du.count("t_student","name like '周%'"));

        // List<Map<String, Object>> list = du.query("select * from t_student order by id desc");
        // System.out.println(list);



        // 测试分页效果
        // t_student 6条记录

        du.setPagesize(4);
        du.setCurrpage(2);
        List<Map<String,Object>> list = du.page("select id,name,score from t_student order by id desc");
        // System.out.println(du.getPagecount());
        // System.out.println(list);

        Map<String,Object> info = list.remove(list.size() - 1);

        System.out.println(info.get("info"));

        System.out.println(list);
    }



    @Test
    public void t1(){
        DbUtil du = new DbUtil("localhost",3306,"dbshop","root","");
        System.out.println(du.dbs());
        System.out.println(du.tbs());
        System.out.println(du.tbs("db"));

        System.out.println("********************************");
        du.connect();
        System.out.println(du.dbs());
        System.out.println(du.tbs());
        System.out.println(du.tbs("db"));
        du.close();

    }
}
_自有天意
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JDBC工具类的封装
m0_48895748的博客
09-12 1460
JDBC工具类的封装，封装获取数据库连接方法，获取preparedStatement对象的方法，解析ResultSet集合，关闭资源等方法
JDBC的初级和进阶
weixin_41588536的博客
10-13 246
JDBC的初级和进阶对JDBC的快速入门1.快速入门查询整表操作2.常用的对象2.1DriverManager：驱动管理对象2.2 Connection：数据库连接对象2.3 Statement：执行sql的对象2.4 ResultSet：结果集对象,封装查询结果2.5 PreparedStatement：执行sql的对象JDBCUtils工具类练习JDBC控制事务数据库连接池Spring JDB...
JDBC - （05）工具类封装
chenyouchang的博客
03-15 329
JDBC：Java Database Connectivity（Java连接数据库技术） 通俗点说：在Java代码中，使用JDBC提供的方法，可以发送字符串类型的`SQL语句`到`数据库管理软件`（MySQL、Oracle等），并且获取语句`执行结果`，进而实现数据库数据`CURD操作`的技术。
JDBC工具类封装
qq_42732184的博客
04-18 1146
jdbc工具类的封装： package com.hyc.study02.utils; import java.io.InputStream; import java.sql.*; import java.util.Properties; public class JDBCUtils { private static String driver = null; private static String url = null; private static String userna
对JDBC进行封装，封装成工具类，封装成几行简单的代码就可以从数据库中获取指定的数据~
最新发布
hariya的博客
03-21 1117
我们将自己数据库对应的URL写到工具类中的static代码块中，但是在项目中我们写的工具类有好多，java文件也有好多。别人看或者在他电脑上想运行我们的项目的时候，需要修改他自身的用户名和密码 所以将这些写到static中也并不是非常合适的，这时候我们就需要想到我们可以将这些数据写到一个资源文件中，在static中通过读取资源文件中的数据来加载数据库。 在集合中，有一个键值对集合Properties，这个我们没怎么说当时，但是这个集合是map集合。我们可以写一个 properties文件专门存放我们
jdbc封装工具类
06-25
jdbc封装工具类，此类事封装成list,Object>>格式，可直接把转换为jsonArray格式传输数据。
JDBC封装的工具类
01-01
JDBC封装的工具类，将所有共同的代码提取过来，形成工具类
SpringBoot中封装jdbc工具类
04-08
现在的数据层的开发，大多会使用如MyBatis或...由于部分场景下MyBatis或JPA之类无法满足我的需求，所以我打算自己封装一套查数据库的工具类。 文章地址： https://blog.csdn.net/lxyoucan/article/details/124042295
自己封装的jdbc工具类
07-16
给学生讲课课上写的jdbc封装类，对基本的增删改查和事务做了封装。例子中用的是oracle 11g数据库，如果换其他数据库直接改连库字符串就行，其他的不用动，适合初学者学习。查询的时候会省掉很多工作量，不需要一个一个的从rs中获取字段，PreparedStatement这块也是动态赋值的。
JDBC封装.rar
06-23
用于封装数据库的各项增删改查功能等
SpringJdbcTemplate封装工具类
06-13
SpringJdbcTemplate封装工具包，包括规范model格式接口，封装SpringJdbcTemplate，实现分页，自适应多种数据库
【mysql】jdbc工具类封装
九离的博客
04-03 440
一、回顾 1.jdbc基本使用步骤！（代码表示） 1.定义静态数据库链接信息 2.加载驱动（mysql） 3.创建链接对象 4.创建执行sql的对象 书写sql 执行 5.处理结果（结果集） int reslutset 6.释放资源 2.写出jdbc设计的核心类和接口、并简单描述作用！ 1.driver 2.connection 3.statement 4.resulteset 3.实现一个控制台登陆方式： - 创建一张用户表 User - id ，主键、自动增
JDBC超详细封装教程
weixin_48991399的博客
03-18 1875
​ JDBC（Java Database Connectivity）是什么？它是一种规范，SUN公司要求数据库公司必须按照JDBC规范实现对应数据库Java代码，提供数据库的相关资源给java程序。在JDBC出来之前，各种数据库提供给java程序数据的方法各式各样，可以说，JDBC极大地方便了我们java开发程序员，目前和java配合最好的数据库是Oracle和MySQL数据库。
封装JDBC通用的工具类
wk3510的博客
08-26 353
使用jdbc的步骤：加载JDBC驱动程序 → 建立数据库连接Connection → 创建执行SQL的语句Statement → 处理执行结果ResultSet → 释放资源；
2021-11-18 迈向程序猿的第三十一步
qq_48654729的博客
11-18 591
目录 一.工具类的封装 二.ORM 三.Dao层的抽取 四.DateUtils 五.Service业务层 一.工具类的封装 //问题： 每次进行CRUD操作，都要写一套JDBC，很繁琐 //解决方案：将重复的操作，抽取到工具类中封装 //1.加载驱动只需要一次---放到静态代码块 //问题2： 直接在工具类中将数据库驱动，数据库名，用户名，密码写死了，不方便后续变更---硬编码 //解决方案：需要变为软编码形式，使程序更灵活，维护性更强 public class LoginTest { .
JDBC工具类的三种封装方法
wqg_code的博客
04-13 1437
JDBC封装工具类的三种方法1、JDBCUtilsV1package cn.itsust.Util; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLExceptio...
JDBC工具类封装与优化实践
【资源摘要信息】: "JDBC专题讲解，包括封装工具类的原因、代码实现、测试以及优化，强调了通过封装减少重复代码，提高开发效率。" 在JDBC编程中，经常遇到的问题是代码重复性高，比如创建和关闭数据库连接、预编译...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值