浅入JDBC(事务，连接池dbcp，c3p0)

最新推荐文章于 2023-08-13 09:53:11 发布
最新推荐文章于 2023-08-13 09:53:11 发布
阅读量2.2k 收藏
点赞数 1
分类专栏： javaee

衔接 初学JDBC

http://blog.csdn.net/u010542146/article/details/50782684

内容概要：

一、JDBC常用的API深入详解及存储过程的调用
二、JDBC的事务管理
三、数据库连接池 （1.dbcp / 2.c3p0）
四、JDBC的替代产品（1.hibernate / 2.mybiatis）

存储过程

1.创建存储过程（无参） 和 使用
创建

create PROCEDURE sp_select_man_nofilter()
BEGIN
select * from man ; 
END

使用

CALL sp_select_man_nofilter()

2.创建存储过程（有参） 和 使用

BEGIN
IF sp_name is null or sp_name = '' THEN
  select * from man ;
ELSE
  IF LENGTH(sp_name) = 2 AND SUBSTRING(sp_name,1,1) = 2 then
    SELECT * from man where age = sp_name ;
  ELSE
    SELECT * from man where name = sp_name ;
  end IF ;
 end IF ;
END

使用

call sp_select_man_filter("KiKi")

3.创建带输出的存储过程

CREATE PROCEDURE sp_select_man_count(out count int(10)
BEGIN
 SELECT count(*) INTO count FROM man ;
END

ProcedureDao 封装了使用存储过程访问数据库的方法

package com.example.dao;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.ArrayList;
import java.util.List;

import com.example.db.DButil;
import com.example.model.Man;
import com.mysql.jdbc.CallableStatement;

public class ProcedureDao {

    //查
    public List<Man> select_man_nofilter() {
        List<Man> list = new ArrayList<Man>();
        Man man = null;
        //1.获得连接
        Connection conn = DButil.getConnection();
        String sql = "call sp_select_man_nofilter()";
        try {
            //2.获得CallableStatement
            CallableStatement cs = (CallableStatement) conn.prepareCall(sql);
            //3.执行存储过程
            cs.execute();
            //4.处理返回结果；结果集，出参
            ResultSet rs = cs.getResultSet();

            while (rs.next()) {
                man = new Man();
                man.setName(rs.getString("name"));
                man.setAge(rs.getInt("age"));
                list.add(man);
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
        return list;
    }

    //带输入参数的查
        public List<Man> select_man_filter(String params) {
            List<Man> list = new ArrayList<Man>();
            Man man = null;
            Connection conn = DButil.getConnection();
            String sql = "call sp_select_man_filter(?)";
            try {
                CallableStatement cs = (CallableStatement) conn.prepareCall(sql);
                cs.setString(1, params);
                cs.execute();
                ResultSet rs = cs.getResultSet();

                while (rs.next()) {
                    man = new Man();
                    man.setName(rs.getString("name"));
                    man.setAge(rs.getInt("age"));
                    list.add(man);
                }

            } catch (SQLException e) {
                e.printStackTrace();
            }
            return list;
        }

        //带输出参数的查
                public int select_man_count() {
                    List<Man> list = new ArrayList<Man>();
                    int count = -1;
                    Man man = null;
                    Connection conn = DButil.getConnection();
                    String sql = "call sp_select_man_count(?)";
                    try {
                        CallableStatement cs = (CallableStatement) conn.prepareCall(sql);
                        cs.registerOutParameter(1, Types.INTEGER);
                        cs.execute();
                        count = cs.getInt(1);
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                    return count;
                }

}

事务

事务的概念：事务（TRANSACTION）是作为单个逻辑工作单元执行的一系列操作。
这些操作为一个整体一起向系统提交，要么都执行，要么都不执行。

事务的特点:
1.原子性（Atomicity） : 事务是一个完整的操作
2.一致性（Consistency）: 当事务完成时，数据必须处于一致状态。
3.隔离性（Isolation） ： 对数据进行修改的所有并发事务都是彼此隔离的。
4.永久性（Durability）： 事务完成后，它对数据库的修改是永久的。

JDBC对事务管理的支持
1、我们通过提交commit（）或是回退rollback（）来管理事务的操作
2、事务操作时默认自动提交的
3、可以同通过调用setAutoCommit（false）来禁止自动提交

买东西例子
account_info 表
这里写图片描述

trans_info 表
这里写图片描述

架构
这里写图片描述

TransAction

package com.example.action;

import com.example.dao.AccountInfoDao;
import com.example.model.AccountInfo;
import com.example.service.TransService;

public class TransAction {
    public static void main(String[] args) {
        String result = trans();
        System.out.println(result);

    }

    public static String trans() {
        AccountInfoDao dao = new AccountInfoDao();
        AccountInfo from = null;
        AccountInfo to = null;

        from = dao.get(1);
        to = dao.get(2);

        double amount = 20;

        TransService transService = new TransService();
        String result = "transFail";
        result =  transService.transAction(from, to, amount);
        return result;
    }

}

AccountInfoDao

package com.example.dao;

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

import com.example.db.DButil;
import com.example.model.AccountInfo;
import com.mysql.jdbc.PreparedStatement;

public class AccountInfoDao {

    public void updateAmount(int id, double d) {
        Connection conn = DButil.getConnection();
        String sql = "UPDATE account_info set amount = ? where id = ?";
        try {
         PreparedStatement ptmt = (PreparedStatement) conn.prepareStatement(sql);
         ptmt.setDouble(1, d);
         ptmt.setInt(2, id);
         ptmt.execute();
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    public AccountInfo get(int id) {
        Connection conn = DButil.getConnection();
        String sql = "select * from account_info where id = ?";
        AccountInfo info = null;
        try {
         PreparedStatement ptmt = (PreparedStatement) conn.prepareStatement(sql);
         ptmt.setInt(1, id);
        ResultSet rs = ptmt.executeQuery();
        if (rs.next()) {
            info = new AccountInfo();
            info.setId(rs.getInt("id"));
            info.setAccount(rs.getString("account"));
            info.setAmount(rs.getDouble("amount"));
            info.setCreateAt(rs.getDate("create_at"));
        }
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return info;
    }

}

TransInfoDao

package com.example.dao;

import java.sql.Connection;
import java.sql.SQLException;

import com.example.db.DButil;
import com.example.model.TransInfo;
import com.mysql.jdbc.PreparedStatement;

public class TransInfoDao {

    public void addTrans(TransInfo transInfo) {
        Connection conn = DButil.getConnection();
        String sql = "Insert into trans_info (source_id,source_account,destination_id,destination_account,amount) value (?,?,?,?,?)";
        try {
         PreparedStatement ptmt = (PreparedStatement) conn.prepareStatement(sql);
         ptmt.setInt(1, transInfo.getSourceId());
         ptmt.setString(2, transInfo.getSourceAccount());
         ptmt.setInt(3, transInfo.getDestinationId());
         ptmt.setString(4, transInfo.getDestinationAccount());
         ptmt.setDouble(5, transInfo.getAmount());
         ptmt.execute();
        } catch (SQLException e) {
            e.printStackTrace();
        }       
    }

}

TransService（核心）

package com.example.service;

import java.sql.Connection;
import java.sql.SQLException;

import com.example.dao.AccountInfoDao;
import com.example.dao.TransInfoDao;
import com.example.db.DButil;
import com.example.model.AccountInfo;
import com.example.model.TransInfo;

public class TransService {

    //无事务,导致买家减钱，卖家没加钱
    public String trans(AccountInfo from, AccountInfo to, double amount) {
        AccountInfoDao accountInfoDao = new AccountInfoDao();
        //买东西,减钱
        accountInfoDao.updateAmount(from.getId(),from.getAmount()-amount);


        //模拟报错,导致只减钱没加钱
        String a = null;
        a.split(",");


        //卖东西,加钱
        accountInfoDao.updateAmount(to.getId(),to.getAmount()+amount);
        //记录单
        TransInfo transInfo = new TransInfo();
        transInfo.setSourceId(from.getId());
        transInfo.setSourceAccount(from.getAccount());
        transInfo.setDestinationId(to.getId());
        transInfo.setDestinationAccount(to.getAccount());
        transInfo.setAmount(amount);
        TransInfoDao transInfoDao = new TransInfoDao();
        transInfoDao.addTrans(transInfo);

        return "success";
    }

      //有事务,保证有加减,一致性
    public String transAction(AccountInfo from, AccountInfo to, double amount) {
            Connection conn = DButil.getConnection();
        try {
            //禁止自动提交
            conn.setAutoCommit(false);
            AccountInfoDao accountInfoDao = new AccountInfoDao();
            //买东西,减钱
            accountInfoDao.updateAmount(from.getId(),from.getAmount()-amount);


            //模拟报错,被catch然后rollback（）无影响
//          String a = null;
//          a.split(",");


            //卖东西,加钱
            accountInfoDao.updateAmount(to.getId(),to.getAmount()+amount);
            //记录单
            TransInfo transInfo = new TransInfo();
            transInfo.setSourceId(from.getId());
            transInfo.setSourceAccount(from.getAccount());
            transInfo.setDestinationId(to.getId());
            transInfo.setDestinationAccount(to.getAccount());
            transInfo.setAmount(amount);
            TransInfoDao transInfoDao = new TransInfoDao();
            transInfoDao.addTrans(transInfo);

            //手动提交
            conn.commit();

            return "success";
        } catch (Exception e) {
            e.printStackTrace();
            try {
                conn.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            return "fail";
        }

    }

}

连接池

连接池的作用是当访问量巨大时，会让新的用户等待，当连接可用时，再把这个连接给等待的用户。这样可以减小服务器的压力。

dbcp连接池配置

common-dbcp.jar
common-pool.jar
common-logging.jar
mysql-connector-java.jar

配置文件 dbcp.properties -> 放置在src目录下

这里写图片描述

dbcp.properties

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://192.168.191.1:3306/jdbctest?useUnicode=true&characterEncoding=utf-8
username=root
password=root
maxActive=30
maxIdle=10
maxWait=1000
initialSize=5
minIdle=1

DBCPUtil

package com.example.db;

import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import javax.sql.DataSource;


import org.apache.commons.dbcp.BasicDataSourceFactory;
import org.omg.CORBA_2_3.portable.InputStream;


public class DBCPUtil {
    //数据源
    private static DataSource DS;

    private static final String configFile = "/dbcp.properties";

    public DBCPUtil() {
        initDbcp();
    }

    private void initDbcp() {
        Properties pops = new Properties();
        try {
            pops.load(Object.class.getResourceAsStream(configFile));

            DS = (DataSource) BasicDataSourceFactory.createDataSource(pops);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public Connection getConnection() {
        Connection conn = null;
        if (DS != null) {
            try {
                conn = (Connection) DS.getConnection();
            } catch (SQLException e) {
                e.printStackTrace();
            }

            try {
                conn.setAutoCommit(false);
            } catch (SQLException e) {
                e.printStackTrace();
            }

            return conn;
        }
        return conn;

    }

}

ManDao

package com.example.dao;

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

import com.example.db.DBCPUtil;
import com.example.model.Man;

public class ManDao {

    //增
    public void AddMan(Man man)  {
        //获得连接
        DBCPUtil dbcpUtil = new DBCPUtil();
        Connection conn = dbcpUtil.getConnection();

        try {
            String sql = "INSERT INTO man (name,age) values (?,?)";
            PreparedStatement ptmt =  (PreparedStatement) conn.prepareStatement(sql);
            ptmt.setString(1, man.getName());
            ptmt.setInt(2, man.getAge());
            ptmt.execute();
            //手动提交
            conn.commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

}

使用（和直连一样）

ManDao dao = new ManDao();
        Man man = new Man();
        man.setName("Ni");
        man.setAge(12);
        dao.AddMan(man);

c3p0连接池配置

c3p0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3和JDBC2的标准拓展

1.导入相关jar
c3p0-0.9.2-pre4.jar
mchange-commons-java-0.2.2.jar

2.在项目根目录下增加配置文件
c3p0.properties -> 放置src目录下

c3p0.properties

c3p0.driverClass=com.mysql.jdbc.Driver
c3p0.jdbcUrl=jdbc:mysql://192.168.191.1:3306/jdbctest?useUnicode=true&characterEncoding=utf-8
c3p0.user=root
c3po.password=root

C3P0Util

package com.example.db;

import java.sql.Connection;
import java.sql.SQLException;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Util {
    private static ComboPooledDataSource ds = new ComboPooledDataSource();
    public static Connection getConnection() {

        try {
            return (Connection) ds.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

}

使用
得到连接的方式

    Connection conn = C3P0Util.getConnection();

dbcp 和 c3p0比较

相同点：
这里写图片描述

不同点
这里写图片描述

转载于：http://www.imooc.com/learn/421

javaee中jar放置
这里写图片描述

u010542146
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【事务】C3P0
codeDonald的博客
05-17 290
1不使用配置方式 首先导入依赖： 我的mysql版本是8.0的： <dependency> <groupId>com.mchange</groupId> <artifactId>c3p0</artifactId> <version>0.9.5.2</version> </depende...
学习笔记-JDBC
AiTer的博客
07-09 143
概念：java DataBase Connectivity Java数据库连接（java语言操作数据库） 本质：其实就是sun公司定义的一套操作所有关系型数据库的规则（接口），各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口编程，真正执行的代码是驱动jar包中的实现类。 快速入门： 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar...
连接池dbcp跟c3p0
weixin_40161708的博客
01-01 253
使用连接池的目的：重复利用Connection资源连接池概述：在Java中，我们使用javax.sql.DataSource来表示连接池对象。DataSource:数据源，其实就是连接池，Connection Pool. 为什么要使用连接池：普通的JDBC数据库连接使用 DriverManager来获取，每次向数据库建立连接的时候都要将Connection加载到内存中，再验证用户和密码（得花费0.0...
DBCP、c3p0、Druid三大连接池区别
as619649246的博客
02-01 719
DBCP、c3p0、Druid三大连接池区别
jdbc常见数据库连接池C3P0、DBCP、Druid
最新发布
互联网知识分享
08-13 153
C3P0是一个开源的JDBC连接池库，它提供了高效的管理和复用数据库连接的功能。它使用了一些优化技术，如连接池、缓存预处理语句、自动回收超时连接等，以提高数据库连接的性能和效率。1.1参数介绍initialPoolSize: 连接池初始化时创建的连接数minPoolSize: 连接池中保留的最小连接数maxPoolSize: 连接池中允许的最大连接数acquireIncrement: 连接池自动增长的大小maxIdleTime: 连接池中连接的最大空闲时间。
连接池详解，c3p0与dbcp的区别！
IT_laobai的博客
06-14 4306
连接池：    连接池是创建和管理一个连接的缓冲池的技术，这些连接准备好被任何需要它们的线程使用。  连接池的好处：（1）对于大多数应用程序，当它们正在处理事务时，仅需要能够访问JDBC连接的 1 个线程。当不处理事务时，这个连接就会闲置（造成资源的浪费）。相反，连接池允许闲置的连接被其它需要的线程使用。（2）当一个线程需要用 JDBC 对一个 数据库操作时，它从池中请求一个连接。当这个线程使用完...
数据库连接池资源包（c3p0 , dbcp,druid连接池）
12-04
数据库连接池的资源包（c3p0 , dbcp,druid连接池）
JdBC的访问方式DBCP连接池和C3P0
10-13
DBCP也是一个开源的连接池，是Apache Common成员之一，在企业开发中也比较常见，tomcat内置的连接池。C3P0访问数据库技术,方便快捷,牵扯到的jar包可去网上下载!
JDBC常用连接池 c3p0 BDCP Druid
12-19
C3P0是一个开放源代码的JDBC连接池，它在lib目录中与Hibernate一起发布,包括了实现jdbc3和jdbc2扩展规范说明的Connection 和Statement 池的DataSources 对象 DBCP （Database Connection Pool）是一个依赖Jakarta ...
JDBC连接数据库，包含DBCP、C3P0连接池，慕课网实例的源码
05-02
Java JDBC基本入门知识，带增删改查例子，支持MySql数据库，包含事务管理，返回数据格式有类对象和List集合格式。有利于初学者理解Java是怎么连接和操作数据库的，也是慕课网中 JDBC之对面女孩走过来的实例源码，亲...
baseDAO及其实现案例、jdbcUtil工具类、数据池c3p0、dbcp、druid驱动及实现方式
05-03
本资源提供了jdbcUtil工具类及普通、c3p0、dbcp和druid获得连接的方法。提供了java对数据库增删改查的baseDAO，结合customer类进行实例操作。
JDBC事务管理(添加dbcp和c3p0测试.zip
10-08
在 java客户端对数据库增删改查的基础上，实现事务管理，并增加连接流，dbcp和c3p0.
DBCP-C3P0数据库连接池
weixin_45746783的博客
10-10 163
1.创建新的Project
dbcp连接池配置详解_重学MySQL：事务与连接池，一文详解带你搞懂
weixin_39606396的博客
11-28 143
拼多多三面惨败，java中间件、数据库与spring框架，答不上...吊打MySQL：21性能优化实践+学习导图+55面试+笔记+20高频知识点Mysql事务事务：事务指逻辑上的一组操作，组成这组操作的各个单元，要么全部成功，要么全部不成功。1.1 Mysql中的事务a、mysql引擎是支持事务的b、mysql默认自动提交事务。每条语句都处在单独的事务中。c、手动控制事务开启事务：start tr...
【数据库连接池】DBCP
qq_65168354的博客
02-22 807
【数据库连接池】------DBCP
idea dbcp配置文件
qq_44801321的博客
08-23 349
#连接设置 driverClassName=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true username=root password=123456 #<!-- 初始化连接 --> initialSize=10 #最大连接数量 maxActive=50 #<!-- 最大空闲连接 --&g
13.JDBC事务、DBCP、C3P0
weixin_46048220的博客
01-05 649
代码实现： 1.开启事务 conn.setAutoCommit(false); 2.一组业务执行完毕，提交事务 conn.commit(); 3.可以在catch语句中显式定义回滚语句，但是默认失败就回滚 conn.rollback(); 完整代码： public class JdbcUtils { private static final String DRIVER="com.mysql.jdbc.Driver"; private static final String URL="j
c3p0和dbcp的使用和区别
热门推荐
retry000的博客
03-09 1万+
数据库连接现在常用的开源数据连接池主要有c3p0、dbcp和proxool三种：一、spring配置文件引入     &lt;!-- 配置dbcp数据源 --&gt; &lt;bean id="dataSource2" destroy-method="close" class="org.apache.commons.dbcp.BasicDataSource"&gt; ...
常用数据库连接池 (DBCP、c3p0、Druid) 配置说明
06-01
好的，我会回答你的问题，以下是常用数据库连接池 DBCP、c3p0、Druid 的配置说明： 1. DBCP (Apache Commons DBCP) DBCP 是 Apache Commons 项目中的一个子项目，它是一个纯 Java 实现的数据库连接池。DBCP 的使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值