JDBC(2) : 使用连接池获取连接并封装执行sql及记录慢sql

最新推荐文章于 2022-09-26 15:47:54 发布
最新推荐文章于 2022-09-26 15:47:54 发布
阅读量426 收藏
点赞数
分类专栏： Java 文章标签： 使用连接池获取连接并封装执行sql及记录慢sql dbcp 多数据源 jdbc封装
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lxinccode/article/details/89360008
版权

参考 : https://blog.csdn.net/qq_21137441/article/details/78781239#commentBox

Service


import java.sql.Connection;
import java.util.List;

/**
 * @Auther: liyue
 * @Date: 2019/1/17 14:25
 * @Description:
 */
public interface JdbcService {


    Connection getConn();

    /**
     * 查询
     *
     * @param sql
     * @param T
     * @param params
     * @param <T>
     * @return
     */
    <T> List<T> select(String sql, Class<T> T, Object... params);

    /**
     * 查询一个
     *
     * @param sql
     * @param T
     * @param params
     * @param <T>
     * @return
     */
    <T> T selectOne(String sql, Class<T> T, Object... params);

    /**
     * 查询一行一个字段
     *
     * @param sql
     * @param params
     * @return
     */
    String selectOneField(String sql, Object... params);
    /**
     * 查询一列
     *
     * @param sql
     * @param params
     * @return
     */
    List<String> selectListOneField(String sql, Object... params);

    /**
     * insert 或者 updte
     *
     * @param sql
     * @param params
     * @return
     */
    int execute(String sql, Object... params);

    /**
     * 计算总记录数
     *
     * @param sql
     * @param params
     * @return
     */
    int count(String sql, Object... params);



}

Impl


import com.aliyun.et.industry.pangang.biz.service.JdbcService;
import com.aliyun.et.industry.pangang.common.util.DateUtil;
import com.aliyun.et.industry.pangang.common.util.ResulstToObjectUtil;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Service;

import javax.sql.DataSource;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.URL;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Auther: liyue
 * @Date: 2019/4/17 10:59
 * @Description:
 */
@Service
public class JdbcServiceImpl implements JdbcService {

    private static final Logger LOGGER = LoggerFactory.getLogger(JdbcServiceImpl.class);

    /**
     * sql执行时间上限记录sql
     */
    private Long slow_sql_log_time_consume = 2000L;

    private ExecutorService executorService = new ThreadPoolExecutor(5, 10,
            3000, TimeUnit.MILLISECONDS, new LinkedBlockingDeque<>(10), new ThreadFactoryBuilder()
            .setNameFormat("CoonPoolTuoliuServiceImpl-%d").build());


    private void close(Connection conn) {
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    private static Properties properties = null;
    private static DataSource dataSource = null;
    private static Connection connection = null;

    static {
        try {
            //获取配置文件，转换成流
            String propertiesPath = "db.properties";
            InputStream in = null;
            try {
                URL url = CoonPoolDefectServiceImpl.class.getClassLoader().getResource(propertiesPath);
                File file = new File(url.getFile());
                in = new FileInputStream(file);
            } catch (Exception e) {

            }
            if (in == null) {
                ClassPathResource classPathResource = new ClassPathResource(propertiesPath);
                in = classPathResource.getInputStream();
            }
            //创建properties对象
            properties = new Properties();
            //加载流
            properties.load(in);
            //创建dataSource对象
            dataSource = BasicDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getCoon() {
        try {
            //得到connection对象
            connection = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }


    @Override
    public Connection getConn() {
        return getCoon();
    }

    @Override
    public <T> List<T> select(String sql, Class<T> T, Object... params) {
        ResultSet rs = null;
        PreparedStatement ps = null;
        Connection conn = null;
        try {
            long t1 = System.currentTimeMillis();
            conn = getCoon();
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i, params[i]);
            }
            List<T> list = new LinkedList<>();
            rs = ps.executeQuery();
            while (rs.next()) {
                T t = ResulstToObjectUtil.rsToObject(rs, T);
                list.add(t);
            }
            long t2 = System.currentTimeMillis();
            recordSlowSql(sql, t1, t2);
            return list;
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        } finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    close(conn);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    public <T> T selectOne(String sql, Class<T> T, Object... params) {
        ResultSet rs = null;
        PreparedStatement ps = null;
        Connection conn = null;
        try {
            long t1 = System.currentTimeMillis();
            conn = getCoon();
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i, params[i]);
            }
            rs = ps.executeQuery();
            T t = null;
            while (rs.next()) {
                t = ResulstToObjectUtil.rsToObject(rs, T);
                break;
            }
            long t2 = System.currentTimeMillis();
            recordSlowSql(sql, t1, t2);
            return t;
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        } finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    close(conn);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    public String selectOneField(String sql, Object... params) {
        ResultSet rs = null;
        PreparedStatement ps = null;
        Connection conn = null;
        try {
            conn = getCoon();
            long t1 = System.currentTimeMillis();
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i, params[i]);
            }
            rs = ps.executeQuery();
            String result = rs.getString(1);
            long t2 = System.currentTimeMillis();
            recordSlowSql(sql, t1, t2);
            return result;
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        } finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    close(conn);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    public int count(String sql, Object... params) {
        ResultSet rs = null;
        PreparedStatement ps = null;
        Connection conn = null;
        try {
            conn = getCoon();
            long t1 = System.currentTimeMillis();
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i, params[i]);
            }
            rs = ps.executeQuery();
            int result = rs.getInt(1);
            long t2 = System.currentTimeMillis();
            recordSlowSql(sql, t1, t2);
            return result;
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        } finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    close(conn);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    public List<String> selectListOneField(String sql, Object... params) {
        ResultSet rs = null;
        PreparedStatement ps = null;
        Connection conn = null;
        try {
            conn = getCoon();
            long t1 = System.currentTimeMillis();
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i, params[i]);
            }
            rs = ps.executeQuery();
            List<String> result = new LinkedList<>();
            while (rs.next()) {
                result.add(rs.getString(1));
            }
            long t2 = System.currentTimeMillis();
            recordSlowSql(sql, t1, t2);
            return result;
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        } finally {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    close(conn);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    public int execute(String sql, Object... params) {
        PreparedStatement ps = null;
        Connection conn = null;
        try {
            conn = getCoon();
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                ps.setObject(i, params[i]);
            }
            return ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        } finally {
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    close(conn);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private void recordSlowSql(String sql, long t1, long t2) {
        String date = DateUtil.getNowYmdhms();
        long timeConsume = t2 - t1;
        if (timeConsume > slow_sql_log_time_consume) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    String insert = "\n" +
                            "insert into `cold_slow_sql_log` (`gmt_create`,`gmt_modify`,`sql`,`time_consume`,`db`)\n" +
                            " values('" + date + "','" + date + "','" + sql.replaceAll("'", "\"") + "'," + timeConsume + ",'mysql')\n";
                    execute(insert);
                }
            });
        }
    }

}

dbcp配置 ,db.properties


driverClassName=com.mysql.jdbc.Driver

url=jdbc:mysql://localhost:3306/defect

username=root

password=root

initialSize=30

maxTotal=30

maxIdle=10

minIdle=5

maxWaitMillis=1000

testOnBorrow=true

validationQuery=select 1

慢sql日志表

CREATE TABLE `cold_slow_sql_log` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `gmt_create` datetime NOT NULL COMMENT '创建时间',
  `gmt_modify` datetime DEFAULT NULL COMMENT '修改时间',
  `sql` varchar(2000) DEFAULT NULL COMMENT 'SQL',
  `time_consume` bigint(20) DEFAULT NULL COMMENT '耗时(单位:毫秒)',
  `db` varchar(32) DEFAULT NULL COMMENT '数据库',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=466 DEFAULT CHARSET=utf8

dbcp依赖


            <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-dbcp2</artifactId>
                <version>2.6.0</version>
            </dependency>

线程池依赖

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>18.0</version>
</dependency>

工具类 ResulstToObjectUtil

    https://blog.csdn.net/Lxinccode/article/details/84881943

dbcp连接池详细

    https://blog.csdn.net/Lxinccode/article/details/89637178

END。

Lxinccode
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDBC更新+数据库连接池–详解–初学者必看
12-14
JDBC+连接池–值得一看JDBC的使用增删改查操作JDBC工具类的封装JDBC实现新增数据-插入-insertJDBC实现修改数据-更新–updateJDBC实现删除数据-删除—deleteJDBC实现查询数据-查询—select案例：实现用户登录案例：...
java连接sql执行删除_SQLUtil，java JDBC 实现sql语句execute执行插入、更新、删除dml操作，查询queryList数据库单列List数据，查询queryObject单记...
weixin_35712223的博客
02-26 447
本文摘自http://www.xwood.net/_site_domain_/_root/5870/5874/t_c277906.htmlimportjava.sql.Connection;importjava.sql.PreparedStatement;importjava.sql.ResultSet;importjava.sql.SQLException;importjava.sql...
tomcat自带连接池dbcp配置以及优化说明
acoolper的专栏
03-10 2万+
转自:http://www.totcms.com/html/201602-29/20160229114145.htm 一个网站每天大概有20万的访问量，使用的tomcat自带dbcp连接池，一般网站访问很好，速度也很快，但是过一段时间后，总是报timeout waiting for idle object的异常信息，最后查了apache tomcat的官方文档，终于找到解决方法：
防止连接Mysql超时，JDBC探活配置
MYSQL轻松学的专栏
01-16 5521
我们知道Mysql有两个关于连接超时的参数，默认为8小时： MySQL > show global variables like '%timeout%'; wait_timeout  = 28800  非交互连接等待时间 interactive_timeout = 28800 交互连接等待时间 MySQL > show pro
1：开启慢查询日志 与 找到慢SQL
邱健的博客
07-26 1027
找到要优化的sql，慢查询日志是mysql自带的一项功能，可以记录执行超过指定时间的sql语句。
JDBC连接池的testQuery/validationQuery设置
热门推荐
hupoling的专栏
12-24 9万+
在《Tomcat中使用Connector/J连接MySQL的超时问题》帖子中想要增加对连接池中连接的测试/验证，防止数据库认为连接已死而Web应用服务器认为连接还有效的问题，Mysql文档中提到Tomcat文档中的例子中用的是validationQuery，但是网上还有很多帖子写的是testQuery，到底用哪一个呢？ 原来这跟连接池的实现有关： 连接池实现 该功能属性名
java jdbc原生连接+连接池.zip
04-26
JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种...通过pool连接池提高性能，并将数据库数据直接转成json对象，且封装了几种取值方式。比传统的ojdbc性能更快更高效
bonecp数据库连接池使用Demo
10-18
采用bonecp数据库连接池封装了Jdbc，当时也是网上下载了一份代码，发现不能用，只好自己修改代码，现在这个代码是可以直接运行的，测试用的Sql Server 2008，表很简单，就四个字段
SQLite sql jdbc基于java的封装类
06-11
关于java对SQLite和sql的封装类，可以实现增删改，查，事务操作
通用JDBC基本操作封装源代码
11-25
简单易用的数据库封装操作，包含数据库连接池的基本实现，数据库连接可重用，所有的操作都脱离源生JDBC操作，开发人员只需要熟悉Java集合的用法，会写Sql即可轻松的使用该封装好的JDBC API写出合理的代码。...
java中执行sql很慢_JavaEE后台开发过程中，为什么会有慢SQL问题？如何解决？
weixin_42501688的博客
02-26 1568
我昨天刚好碰到一个问题，应用服务器隔一小段时间就自动重启，最后才定位到是慢查询的问题，生产环境停摆了半天！慢查询:超过指定时间的SQL查询。慢查询的危害:轻者影响整个系统性能，重者直接导致服务重启或死机。开始慢查询记录日志:使用set global slow_query_log=on;开启慢查询日志记录。然后使用show variables like 'slow%';查找慢查询相关情况，除了能看到...
记录一个问题：jdbc连接数据库很慢【能连上，但很慢】、同理，任何应用连接慢也可以尝试用该方法
崔崇鑫的博客，你linux/云运维工作中的百科全书。
03-31 4815
文章目录说明解决方案总结 说明 前置条件：我们云上有一批同网段虚拟机，其中一台是数据库服务器，剩下的是客户端，需要去连接这个数据库服务器。 本地安装了一个centos7.6的测试系统，连接数据库一切正常，且很快。 下面为云上的centos虚拟机客户端连接数据库的问题： 1、最小化安装的系统，selinux没关之前直接无法连接上数据库，关了selinux可以连上，很慢； 2、最小化安装后，安装桌面基础包并进入桌面，selinux关了能连上数据库，很慢。 3、更换了其他版本的centos系统，一样
手写简单的web分页功能（非插件）
菜鸟_zhengke的博客
04-01 333
1.建立一个简单的数据库 sql脚本 SET FOREIGN_KEY_CHECKS=0; -- ---------------------------- -- Table structure for tbluser -- ---------------------------- DROP TABLE IF EXISTS `tbluser`; CREATE TABLE `tbluser`...
通过java代码连接数据库，利用HikariDataSource动态连接池的方式连接数据库且执行sql语句。
鹏神丶明月天
09-26 3482
配置类3：连接池管理类。
Java中DriverManager跟DataSource获取getConnection有什么不同（Java中数据源和连接池的区别）
林海静的博客
11-20 1万+
一、理解什么是数据源和连接池 数据源：数据的源头，需要设置数据库url,用户名和密码，此时就相当于一个代理数据库；它包含连接池和连接池管理两个部分； Java中的数据源就是javax.sql.DataSource。DataSource是Java定义的接口，可以有不同的实现。 连接池：一个连接相当于数据源和dao层的管道，那连接池就相当于存放了很多管道的池子；我们获...
Spring中配置数据源的4种形式
orclight的专栏
02-27 5万+
不管采用何种持久化技术，都需要定义数据源。Spring中提供了4种不同形式的数据源配置方式： spring自带的数据源(DriverManagerDataSource)，DBCP数据源，C3P0数据源,JNDI数据源。 1.spring自带的数据源 DriverManagerDataSource XML代码： <bean id="dataSource" cla
java使用JDBC连接数据库，提高查询大量数据速度
u013726746的博客
03-20 7188
一、java使用JDBC连接数据库基本知识1.JDBC的框架结构：    java通过JDBC API接口，经由JDBC驱动程序管理器、JDBC Driver API 和 JDBC驱动程序访问下层的数据库。2.JDBC连接数据库基本步骤：    1.加载JDBC驱动程序            a.加载Oracle JDBC驱动程序：                   使用DriverManage...
jdbc数据库封装连接池Druid
最新发布
06-03
好的，我可以为您讲解一下jdbc数据库封装连接池Druid。 Druid是一种基于Java语言的数据库连接池技术，它可以有效地管理和维护数据库连接，提高数据库操作的性能，同时也具备了许多其他的特性，比如监控、统计、防止...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值