数据库连接池Spring JDBC JDBETemplate

数据库连接池

概念：其实就是一个容器（集合），存放数据库连接的容器，当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器；
好处：1.节约资源，2.用户访问高效
实现：1.标准接口，这个接口没有实现，谁提供数据库驱动谁去实现，DataSource javax.sql包下的

  1. 方法获取连接：getConnection（）
  2. 归还连接：如果连接对象connection是从连接池获取的，那么调用connection.close()方法则不会关闭连接了，而是归还连接；
  3. 一般我们不去实现它，有数据厂商来实现，
    1. c3p0：数据库连接池技术
    2. Druid：德鲁伊，数据库连接池技术，由阿里巴巴提供的

c3p0 数据库连接池技术

使用步骤

  1. 导入第三方jar包：c3p0-0.9.5.2.jar mchange-commons-java-0.2.15.jar

  2. 定义配置文件：

    1. 名称：c3p0.properties 或者 c3p0-config.xml
    2. 路径：直接将文件放在src目录下即可。

  3. 创建核心对象 数据库连接池对象：ComboPooledDataSource

  4. 获取连接：getConnection
    //1,创建数据库连接池对象

    DataSource ds=new ComboPooledDataSource();

    //2,获取连接对象

    Connection connection = ds.getConnection();

    //3.打印连接对象

    System.out.println(connection);

    // System.out.println("11111111");
    c3p0-config.xml文件内容

<?xml version="1.0" encoding="UTF-8"?>

<c3p0-config>

<!--使用默认的配置读取连接池对象-->

<default-config>

<!--连接参数-->

<property name="driverClass">com.mysql.cj.jdbc.Driver</property>

<property name="jdbcUrl">jdbc:mysql://localhost:3306/db1</property>

<property name="user">root</property>

<property name="password">502900</property>

<!--连接池参数-->

<property name="initialPoolSize">5</property><!--初始化申请的连接数量-->

<property name="maxPoolSize">10</property><!--最大的的连接数量-->

<property name="checkoutTimeout">3000</property><!--申请连接的超时时间-->

 

</default-config>

<named-config name="otherc3p0">

<!--连接参数-->

<property name="driverClass">com.mysql.cj.jdbc.Driver</property>

<property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/db1</property>

<property name="user">root</property>

<property name="password">502900</property>

<!--连接池参数-->

<property name="initialPoolSize">5</property><!--初始化申请的连接数量-->

<property name="maxPoolSize">10</property><!--最大的的连接数量-->

<property name="checkoutTimeout">3000</property><!--申请连接的超时时间-->

 

</named-config>

</c3p0-config>

App.java

import java.sql.Connection;

 

import javax.sql.DataSource;

 

import com.mchange.v2.c3p0.ComboPooledDataSource;

 

public class App {

public static void main(String[] args) throws Exception {

//1,创建数据库连接池对象

DataSource ds=new ComboPooledDataSource();

//2,获取连接对象

Connection connection = ds.getConnection();

//3.打印连接对象

System.out.println(connection);

// System.out.println("11111111");

}

}

测试连接最大池

import java.sql.Connection;

 

import javax.sql.DataSource;

 
 

import com.mchange.v2.c3p0.ComboPooledDataSource;

 

public class App {

public static void main(String[] args) throws Exception {

//什么都没有传使用默认配置

// DataSource comboPooledDataSource = new ComboPooledDataSource();

//指定名称配置

DataSource comboPooledDataSource = new ComboPooledDataSource("otherc3p0");

for (int i = 1; i <=11; i++) {//如果超出设置的最大连接数则会报错：An attempt by a client to checkout a Connection has timed out.

Connection connection = comboPooledDataSource.getConnection();

System.out.println(i+"---"+connection);

if(i==5){//第5个人连接后走了；将连接归还池中；

connection.close();

}

}

}

}

Druid:数据库连接池实现技术，由阿里巴巴提供的

  1. 步骤
    1. 导入jar包
    2. 定义配置文件，特点：1是properties的，2.可以叫任意名称，可以放在任意目录下（需要手动加载）
    3. 加载配置文件Properties
    4. 获取数据库连接池对象：通过一个工厂类获取 DruidDataSourceFortory
    5. 获取连接：getConnection

4

import java.io.FileReader;

import java.io.InputStream;

import java.sql.Connection;

import java.util.Properties;

 

import javax.sql.DataSource;

 

import com.alibaba.druid.pool.DruidDataSourceFactory;

 

public class DruidDemo {

public static void main(String[] args) throws Exception {

// 1.加载配置文件

Properties properties = new Properties();

InputStream resourceAsStream = DruidDemo.class.getClassLoader().getResourceAsStream("dd.properties");

properties.load(resourceAsStream);

// 2.获取连接池对象

DataSource createDataSource = DruidDataSourceFactory.createDataSource(properties);

// 获取连接

Connection connection = createDataSource.getConnection();

System.out.println(connection);

 

}

 

}

定义工具类
1. 定义一个类JDBCutils
2. 提供静态代码块加载配置文件，初始化连接对象
3. 提供方法：
1. 获取连接方法：通过数据库获取连接
2. 释放资源
3. 获取连接池方法

package utils;

/**

 * Druid连接池的工具类

 */

  

import java.io.IOException;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.Properties;

  

import javax.sql.DataSource;

  

import com.alibaba.druid.pool.DruidDataSourceFactory;

  

public class JDBCUtils{

 // 1定义成员变量DataSource

 private static DataSource ds=null;

 static{

 // 加载配置文件

 Properties properties = new Properties();

 try {

 properties.load(JDBCUtils.class.getClassLoader().getResourceAsStream("dd.properties"));

 // 3获取dataSource

 ds=DruidDataSourceFactory.createDataSource(properties);

 } catch (IOException e) {

 e.printStackTrace();

 }catch (Exception e) {

 e.printStackTrace();

 }

 }

 /**

 * 获取连接

 */

 public static Connection getConnection(){

 try {

 return ds.getConnection();

 } catch (SQLException e) {

 e.printStackTrace();

 }

 return null;

 }

  

/**

 * 获取连接池对象

 */

public static DataSource getDataSource(){

 return ds;

}

 /**

 * 释放资源

 */

 public static void close(Statement Statement,Connection conn){

 // if(Statement!=null){

 //     try {

 //         Statement.close();

 //     } catch (SQLException e) {

 //         // TODO Auto-generated catch block

 //         e.printStackTrace();

 //     }

 // }

 // if(conn!=null){

 //     try {

 //         conn.close();//归还连接

 //     } catch (SQLException e) {

 //         // TODO Auto-generated catch block

 //         e.printStackTrace();

 //     }

 // }

 close(null,Statement,conn);

 }

  

 public static void close( ResultSet res,Statement Statement,Connection conn){

 if(res!=null){

 try {

 res.close();

 } catch (SQLException e) {

 e.printStackTrace();

 }

 }

 if(Statement!=null){

 try {

 Statement.close();

 } catch (SQLException e) {

 // TODO Auto-generated catch block

 e.printStackTrace();

 }

 }

 if(conn!=null){

 try {

 conn.close();

 } catch (SQLException e) {

 // TODO Auto-generated catch block

 e.printStackTrace();

 }

 }

}

}

Spring JDBC JDBETemplate

概述：Spring框架对JDBC的简单封装。提供了JDBETemplate对象来简化JDBC开发
步骤：

  1. 导入jar包：
  2. 创建JdbcTemplate对象。依赖于数据源DataSource：new JdbcTemplate(ds);
  3. 调用方法JdbcTemplate的方法来完成CRUD的操作：
    1. update():执行DML语句，增加删除修改；
    2. queryForMap():查询结果，将结果集封装为map集合
    3. queryForList():查询结果，将结果集封装为List集合
    4. query():查询结果，将结果封装为JavaBean对象
    5. queryForObject():查询结果，将结果封装为基本类型的对象

String sql="select user from login where user=? and password=?";
RootUser queryForObject = template.queryForObject(sql, RootUser.class,user,password);

练习


import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.List;

import java.util.Map;

  

import org.junit.Test;

import org.springframework.jdbc.core.BeanPropertyRowMapper;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.jdbc.core.RowMapper;

import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import org.springframework.transaction.TransactionStatus;

import org.springframework.transaction.support.DefaultTransactionDefinition;

  

import bindata.Accoun;

import utils.JDBCUtils;

  

public class JdbcTemplateDemo2 {

 // 获取JdbcTemplate

 private JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());

  

 /**

 * 修改1号数据的金额

 */

 @Test

 public void test1() {

 // 定义sql

 String sql = "update accoun set  balance=15000 where id=1";

 // 执行sql

 int update = jdbcTemplate.update(sql);

 System.out.println(update);

 }

  

 /**

 * 添加记录

 */

 @Test

 public void test2() {

 // 定义sql

 String sql = "insert into accoun values(?,?,?)";

 // 执行sql

 int update = jdbcTemplate.update(sql, null, "王五", 10);

 System.out.println(update);

 }

  

 // /**

 // * 删除记录

 // */

 // @Test

 // public void test3() {

 // // 定义sql

 // String sql = "delete from accoun where id=?";

 // // 执行sql

 // try {

 // jdbcTemplate.getDataSource().getConnection().setAutoCommit(false);//获取了也没有用因为update执行时会再获取一次新的连接

  

 // int update = jdbcTemplate.update(sql, 4);

 // // 中间出现异常

 // int a=3/0;

 // int update2 = jdbcTemplate.update(sql, 5);

 // System.out.println(update);

 // } catch (Exception e) {

 // e.printStackTrace();

 // try {

 // jdbcTemplate.getDataSource().getConnection().rollback();

 // } catch (SQLException e1) {

 //

 // e1.printStackTrace();

 // }

 // }

 // }

 /**

 * 删除记录

 */

 @Test

 public void test3() {

 // 定义sql

 String sql = "delete from accoun where id=?";

 // 执行sql

 //开启事务，也可以通过配置文件的形式进行

 DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();

 DataSourceTransactionManager dm = new DataSourceTransactionManager(jdbcTemplate.getDataSource());

 TransactionStatus tmp = dm.getTransaction(transactionDefinition);

 try {

 int update = jdbcTemplate.update(sql, 1);

 int a = 3 / 0;//出现问题

 int update2 = jdbcTemplate.update(sql, 5);

 dm.commit(tmp);//提交事务

 } catch (Exception e) {

 e.printStackTrace();

 }finally{

 dm.rollback(tmp);//回滚事务

 }

  

 }

  

 /**

 * 查询id为5的记录将其封装为map集合

 * //注意如果是多条记录则会出现报错，期望是一条记录

 * 将名作为key，值作为value封装为map集合；

 */

 @Test

 public void test4() {

 // 定义sql

 String sql = "select * from accoun where id=5";

 // 执行sql

 Map<String, Object> queryForMap = jdbcTemplate.queryForMap(sql);

 System.out.println(queryForMap);

 // {id=5, name=王五, balance=10}

  

 }

  

 /**

 * 查询所有记录将其封装为list集合

 * 注意将每一条记录封装为map再将map集合装在list集合中；

 */

 @Test

 public void test5() {

 // 定义sql

 String sql = "select * from accoun";

 // 执行sql

 List<Map<String, Object>> queryForList = jdbcTemplate.queryForList(sql);

 System.out.println(queryForList);

 // [{id=1, name=zhangsan, balance=15000}, {id=4, name=王五, balance=10}, {id=5,

 // name=王五, balance=10}]

 }

  

 /**

 * 查询所有记录，将其封装为EMP对象的list集合

 * query的参数RowMapper一般我们使用BeanPropertyRowMapper它可以完成数据到javaBean的自动封装；

 * new

 * BeanPropertyRowMapper<javaBean>(javaBean.class)，他会拿到你这个类中定义的字段和数据库进行对比如果一样则拿到数据库中的值进行赋值；

 */

 @Test

 public void test6() {

 // 定义sql

 String sql = "select * from accoun";

 // 执行sql

 List<Accoun> query = jdbcTemplate.query(sql, new RowMapper<Accoun>() {

  

 @Override

 public Accoun mapRow(ResultSet rs, int rowNum) throws SQLException {

  

 Accoun accoun = new Accoun(rs.getInt("id"), rs.getString("name"), rs.getInt("balance"));

 return accoun;

 }

  

 });

 System.out.println(query);

 // [1zhangsan15000796667727, 4王五101794717576, 5王五10251210093]

 }

  

 /**

 * 查询所有记录，将其封装为EMP对象的list集合

 * //该ben中需要有无参构造方法和set方法这样BeanPropertyRowMapper使用反射时可以调用；

 */

 @Test

 public void test7() {

 // 定义sql

 String sql = "select * from accoun";

 // 执行sql

 List<Accoun> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Accoun>(Accoun.class));

 System.out.println(query);

  

 }

  

 /**

 * 查询所有记录的条数

 * queryForObject一般用于聚合函数的查询

 */

 @Test

 public void test8() {

 // 定义sql

 String sql = "select count(id) from accoun";

 // 执行sql

 Long queryForObject = jdbcTemplate.queryForObject(sql, Long.class);

 System.out.println(queryForObject);

 }

}

Accoun.java(javaBean)


package bindata;

  

public class Accoun {

 Integer id;

 public Accoun() {

 }

  

 public Accoun(int id, String name, int balance) {

 this.id = id;

 this.name = name;

 this.balance = balance;

 }

 String name;

  

 public void setName(String name){

 this.name=name;

 }

 public void setId(int id){

 this.id=id;

}

public void setBalance(int balance){

 this.balance=balance;

}

 int balance;

 @Override

 public String toString() {

 return id+name+balance;

 }

}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容