JAVA连接数据库之ThreadLocal

最新推荐文章于 2023-04-01 18:58:38 发布
最新推荐文章于 2023-04-01 18:58:38 发布
阅读量330 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YYBDESHIJIE/article/details/105480110
版权

1、private static Connection conn=null;//多个线程共享变量，所以线程不安全的：

解决方法：可以做线程同步，但是又会存在线程瓶颈问题（系统运行的很慢）。
应该实现：一个线程有自己的独有的连接，一个线程有一各连接（自己可以复用）。

package util;

import common.RowMapper;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DbUtils {
    private static final String JDBC_DRIVER="com.mysql.jdbc.Driver";
    private static final String JDBC_URL="jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false";
    private static final String JDBC_USERNAME="root";
    private static final String JDBC_PASSWORD="123456";
    //private static Connection conn=null;//多个线程共享变量，所以线程不安全的 HashMap<线程，连接>
    private static ThreadLocal<Connection> local=new ThreadLocal<Connection>();
    //1、加载驱动用静态块来实现，自动调用
    static{
        try {
            Class.forName(JDBC_DRIVER);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            System.out.println("驱动加载失败");
        }
    }
    //2、打开连接
    public static Connection openConnection(){
        Connection conn=local.get();//取连接
        try {
            if(conn==null||conn.isClosed()){
                conn= DriverManager.getConnection(JDBC_URL,JDBC_USERNAME,JDBC_PASSWORD);
                local.set(conn);//，没有连接，就放连接
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }

    /**
     * 执行DML操作
     * @param sql
     * @param params
     * @return
     */
    public  static int update(String sql,Object...params){//Object...params为可变参数
        Connection conn=openConnection();//打开连接
        int row=0;
        PreparedStatement pst=null;
        try {
            pst=conn.prepareStatement(sql);
            if(params!=null&&params.length>0){
                for(int i=0;i<params.length;i++){
                    pst.setObject(i+1,params[i]);
                }
                row=pst.executeUpdate();
            }
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("执行DML异常",e);
        }finally{
            if(pst!=null){
                try {
                    pst.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return row;
    }

    /**
     * 执行查询操作
     * @param sql
     * @param params
     * @return
     */
    public  static List<Map<String,Object>> query(String sql, Object...params){
        Connection conn=openConnection();//打开连接
        ResultSet rs=null;
        PreparedStatement pst=null;
        List<Map<String,Object>> list=new ArrayList<Map<String,Object>>();
        try {
            pst=conn.prepareStatement(sql);
            if(params!=null&&params.length>0){
                for(int i=0;i<params.length;i++){
                    pst.setObject(i+1,params[i]);
                } }
                rs=pst.executeQuery();//查询之后返回一个结果集
                //解析结果集
                //首先获取rs里面的元数据
                ResultSetMetaData rsmd=  rs.getMetaData();
                int count=rsmd.getColumnCount();//得到列的总数
                while(rs.next()){
                    Map<String,Object> row=new HashMap<String,Object>();
                    //具体解析
                    for(int i=0;i<count;i++){
                        String columnLabel=rsmd.getColumnLabel(i+1);//得到列的名字
                        row.put(columnLabel,rs.getObject(columnLabel));
                    }
                    list.add(row);
                }
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("执行查询异常",e);
        }finally{
            if(rs!=null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(pst!=null){
                try {
                    pst.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

        return list;
    }

    /**
     * 执行查询，利用RowMapper
     * @param sql
     * @param rowMapper
     * @param params
     * @param <T>
     * @return
     */
    public  static <T> List<T> query(String sql, RowMapper<T> rowMapper, Object...params){
        Connection conn=openConnection();//打开连接
        ResultSet rs=null;
        PreparedStatement pst=null;
        List<T> list=new ArrayList<T>();
        try {
            pst=conn.prepareStatement(sql);
            if(params!=null&&params.length>0){
                for(int i=0;i<params.length;i++){
                    pst.setObject(i+1,params[i]);
                } }
            rs=pst.executeQuery();//查询之后返回一个结果集
            while(rs.next()){
               T entity= rowMapper.mapping(rs);//解析完以后返回一个实体对象
                list.add(entity);
            }
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("执行查询异常",e);
        }finally{
            if(rs!=null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(pst!=null){
                try {
                    pst.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return list;
    }
    /**
     * 关闭连接
     */
    public  static void close(){
        Connection conn=local.get();
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
           local.remove();
            conn=null;
        }
    }
}


import util.DbUtils;

public class Test3 {
    public static void main(String[] args) {
        DbUtils.update("delete from `order1` where id=?",1);
        DbUtils.close();
    }
}

2、添加事务：

package util;

import common.RowMapper;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DbUtils {
    private static final String JDBC_DRIVER="com.mysql.jdbc.Driver";
    private static final String JDBC_URL="jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false";
    private static final String JDBC_USERNAME="root";
    private static final String JDBC_PASSWORD="123456";
    //private static Connection conn=null;//多个线程共享变量，所以线程不安全的 HashMap<线程，连接>
    private static ThreadLocal<Connection> local=new ThreadLocal<Connection>();
    //1、加载驱动用静态块来实现，自动调用
    static{
        try {
            Class.forName(JDBC_DRIVER);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            System.out.println("驱动加载失败");
        }
    }
    //2、打开连接
    public static Connection openConnection(){
        Connection conn=local.get();//取连接
        try {
            if(conn==null||conn.isClosed()){
                conn= DriverManager.getConnection(JDBC_URL,JDBC_USERNAME,JDBC_PASSWORD);
                local.set(conn);//，没有连接，就放连接
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }
    /*
    * 开启事务
    * */
    public static void beginTransaction(){
        Connection conn=openConnection();//打开连接
        try {
            conn.setAutoCommit(false);//设置为手动提交
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    //提交事务
    public static void commit(){
        Connection conn=local.get();//取出当前连接
        try {
            conn.commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    /*
    * 回滚
    * */
    public static void rollback(){
        Connection conn=local.get();//取出当前连接
        try {
            conn.rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    /**
     * 执行DML操作
     * @param sql
     * @param params
     * @return
     */
    public  static int update(String sql,Object...params){//Object...params为可变参数
        Connection conn=openConnection();//打开连接
        int row=0;
        PreparedStatement pst=null;
        try {
            pst=conn.prepareStatement(sql);
            if(params!=null&&params.length>0){
                for(int i=0;i<params.length;i++){
                    pst.setObject(i+1,params[i]);
                }
                row=pst.executeUpdate();
            }
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("执行DML异常",e);
        }finally{
            if(pst!=null){
                try {
                    pst.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return row;
    }

    /**
     * 执行查询操作
     * @param sql
     * @param params
     * @return
     */
    public  static List<Map<String,Object>> query(String sql, Object...params){
        Connection conn=openConnection();//打开连接
        ResultSet rs=null;
        PreparedStatement pst=null;
        List<Map<String,Object>> list=new ArrayList<Map<String,Object>>();
        try {
            pst=conn.prepareStatement(sql);
            if(params!=null&&params.length>0){
                for(int i=0;i<params.length;i++){
                    pst.setObject(i+1,params[i]);
                } }
                rs=pst.executeQuery();//查询之后返回一个结果集
                //解析结果集
                //首先获取rs里面的元数据
                ResultSetMetaData rsmd=  rs.getMetaData();
                int count=rsmd.getColumnCount();//得到列的总数
                while(rs.next()){
                    Map<String,Object> row=new HashMap<String,Object>();
                    //具体解析
                    for(int i=0;i<count;i++){
                        String columnLabel=rsmd.getColumnLabel(i+1);//得到列的名字
                        row.put(columnLabel,rs.getObject(columnLabel));
                    }
                    list.add(row);
                }
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("执行查询异常",e);
        }finally{
            if(rs!=null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(pst!=null){
                try {
                    pst.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

        return list;
    }

    /**
     * 执行查询，利用RowMapper
     * @param sql
     * @param rowMapper
     * @param params
     * @param <T>
     * @return
     */
    public  static <T> List<T> query(String sql, RowMapper<T> rowMapper, Object...params){
        Connection conn=openConnection();//打开连接
        ResultSet rs=null;
        PreparedStatement pst=null;
        List<T> list=new ArrayList<T>();
        try {
            pst=conn.prepareStatement(sql);
            if(params!=null&&params.length>0){
                for(int i=0;i<params.length;i++){
                    pst.setObject(i+1,params[i]);
                } }
            rs=pst.executeQuery();//查询之后返回一个结果集
            while(rs.next()){
               T entity= rowMapper.mapping(rs);//解析完以后返回一个实体对象
                list.add(entity);
            }
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("执行查询异常",e);
        }finally{
            if(rs!=null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(pst!=null){
                try {
                    pst.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return list;
    }
    /**
     * 关闭连接
     */
    public  static void close(){
        Connection conn=local.get();
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
           local.remove();
            conn=null;
        }
    }
}


import util.DbUtils;

public class Test3 {
    public static void main(String[] args) {
        DbUtils.beginTransaction();//开启事务
        try{
            DbUtils.update("delete from `order1` where id=?",2);
            DbUtils.update("delete from `order1` where id=?",3);//有异常
            DbUtils.commit();//手动提交一下才有数据
        }catch (Exception ex){
            DbUtils.rollback();
        }

        DbUtils.close();
    }
}

在这里插入图片描述

2、不开启事务：

import util.DbUtils;

public class Test3 {
    public static void main(String[] args) {
      /*  DbUtils.beginTransaction();//开启事务
        try{
            DbUtils.update("delete from `order1` where id=?",2);
            DbUtils.update("delete from `order1` where id=?",3);//有异常
            DbUtils.commit();//手动提交一下才有数据
        }catch (Exception ex){
            DbUtils.rollback();
        }

        DbUtils.close();*/
        DbUtils.update("delete from `order1` where id=?",4);
        DbUtils.update("deletes from `order1` where id=?",5);
        DbUtils.close();
    }
}

在这里插入图片描述
在这里插入图片描述

3、连接池优化：

布道师小羊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 简单易用jdbc类
08-26
常用、简单的jdbc 类，使用ThreadLocal实现，线程安全
java(8)--线程ThreadLocal详解
黄规速博客:学如逆水行舟，不进则退
09-29 5429
一. ThreadLocal是什么 1.1、ThreadLocal简介 在JDK 1.2的版本中就提供java.lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。 在JDK5.0以后，ThreadLocal已经支持泛型，ThreadLocal类的类名变为ThreadLocal&lt...
Java中ThreadLocal详解
雪崩时没有一片雪花是无辜的！
11-16 4993
一、ThreadLocal简介 ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。 ThreadLoal 变量，线程局部变量，同一个 ThreadLocal 所包...
ThreadLocal存储数据库Connection的几种模式
qq_20671779的博客
08-20 512
ThreadLocal存储数据库Connection
ThreadLocal详解
Wangfuqiangqiang的博客
11-14 666
起源 ThreadLocal诞生于JDK1.2 ThreadLocal的诞生是用于解决多线程间的数据隔离问题，也就是说ThreadLocal会为每一个线程创建一个单独的变量副本 ThreadLocal的作用 1.ThreadLocal可以用来管理Session，因为每个人的信息都不一样，所以适合用·ThreadLocal来管理 2.数据库连接，为每一个线程分配一个独立的资源，用ThreadLocal来实现 相关面试题 1.ThreadLocal 为什么是线程安全的？ 答：Thre
【数据库连接，线程，ThreadLocal三者之间的关系】
tigerhhzz的博客
04-01 816
不是的，==这时ThreadLocal就派上用场了，在第一次数据持久化操作做完之后，将这个数据库连接暂存在ThreadLocal中，在之后的数据库切换中需要用到时再拿出来用。如果池中没有空闲连接，线程将等待另一个线程将连接对象返回到池中。ThreadLocal的作用是提供线程内的局部变量，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。举个例子，一个线程的生命周期要做这么几件事情：参数校验，业务逻辑1，数据持久化，业务逻辑2，数据库切换，业务逻辑3。
ThreadLocal在数据库连接中的应用
u010386139的博客
01-22 5375
之前一直觉得ThreadLocal没用，后来看到别人在数据库连接中的相关讲解后发现这个类真的很实用。 在数据库连接中为了提高服务器的响应速度，通常都会采用数据库连接池的方式来获取数据库连接。 C3P0Utils实现 public class C3P0Utils { private static DataSource source;//数据源 static{ source = new
数据库连接，线程，ThreadLocal三者之间的关系
m0_57042151的博客
03-30 144
该线程在进行数据持久化时需要申请数据库连接，当做完之后就将连接释放回线程池，但之后进行数据库切换时也需要数据库连接，这时候继续申请吗？不是的，这时ThreadLocal就派上用场了，在第一次数据持久化操作做完之后，将这个数据库连接暂存在ThreadLocal中，在之后的数据库切换中需要用到时再拿出来用。举个例子，一个线程的生命周期要做这么几件事情：参数校验，业务逻辑1，数据持久化，业务逻辑2，数据库切换，业务逻辑3。我们知道，数据库连接是很宝贵的资源，以MySQL为例，一台MySQL服务器。
Spring数据库连接与Threadlocal
chuixue24的博客
01-04 787
目录 关键类： 数据库连接放入Threadlocal： 从ThreadLocal取数据库连接： 关键类： TransactionSynchronizationManager 数据库连接放入Threadlocal： TransactionInterceptor.invoke(MethodInvocation invocation)---》TransactionStatus org.springframework.transaction.support.AbstractPlatformTra.
Java常见面试题208道.docx
05-17
170.mysql 的内连接、左连接、右连接有什么区别？ 171.mysql 索引是怎么实现的？ 172.怎么验证 mysql 的索引是否满足需求？ 173.说一下数据库的事务隔离？ 174.说一下 mysql 常用的引擎？ 175.说一下 mysql 的行锁和...
疯狂JAVA讲义
10-17
学生提问：为什么有栈内存和堆内存之分？ 93 4.6.2 基本类型数组的初始化 95 4.6.3 引用类型数组的初始化 96 4.6.4 没有多维数组 99 学生提问：我是否可以让图4.13中灰色覆盖的数组元素再次指向另一个数组？这样...
Java并发编程（学习笔记）.xmind
06-19
（2）实现资源池，例如数据库连接池 （3）使用信号量将任何一种容器变成有界阻塞容器 栅栏 能够阻塞一组线程直到某个事件发生 栅栏和闭锁的区别 所有线程必须同时到达栅栏位置，...
2024-2030全球及中国PCB接触式探头行业研究及十五五规划分析报告.docx
04-18
2024-2030全球及中国PCB接触式探头行业研究及十五五规划分析报告
网站界面设计mortal0418代码
04-18
网站界面设计mortal0418代码
PHP毕业设计-校园失物招领系统源码+数据库.zip
04-18
PHP毕业设计-校园失物招领系统源码+数据库.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码、该项目可以直接作为毕设使用。项目都经过严格调试，确保可以运行！ PHP毕业设计-校园失物招领系统源码+数据库.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码、该项目可以直接作为毕设使用。项目都经过严格调试，确保可以运行！ PHP毕业设计-校园失物招领系统源码+数据库.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码、该项目可以直接作为毕设使用。项目都经过严格调试，确保可以运行！ PHP毕业设计-校园失物招领系统源码+数据库.zip个人经导师指导并认可通过的高分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可
2024年神经酸行业分析报告.pptx
最新发布
04-18
2024年神经酸行业分析报告.pptx
Java爬虫信息抓取的实现 完整实例（源码）
04-18
【Java爬虫】信息抓取的实现 完整实例（源码）
rain-drop.PNG
04-18
rain-drop.PNG
java.lang.ThreadLocal
10-17
java.lang.ThreadLocal是Java中的一个线程本地变量，它提供了一种线程安全的...例如，我们可以使用ThreadLocal来存储每个线程的数据库连接，这样每个线程都可以独立地获取和释放自己的连接，而不会影响其他线程的连接。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值