JDBC--连接池/SpringJDBC

一.  连接池

 

1.  介绍

  数据库连接池：存放数据库连接的容器（集合），系统初始化后，创建容器，容器申请一些连接对象，用户访问时，从容器中获取连接对象，释放后归还到连接池中。
 *                         节约资源，便于用户高效访问。
 * 实现：  接口DataSource，
 *              获取连接 getConnection()
 *              归还连接 连接对象Connection是从连接池中获取，则Connection.close()将连接对象归还到连接池中

 2. 数据连接池技术

 （1）   C3P0：
 *      步骤：1.导入jar包 c3p0-0.9.5.2.jar  ； mchange-commons-java-0.2.12.jar
 *                 2.定义配置文件  c3p0.properties or c3p0-config.xml （src目录下）
 *                 3.创建核心对象 数据库连接池对象 ComboPooledDataSource
 *                 4.获取连接 ：getConnection

Demo

public class Demo2C3P0 {
    public static void main(String[] args) throws SQLException {
        DataSource ds=new ComboPooledDataSource();
//        指定名称配置
//        DataSource ds=new ComboPooledDataSource("otherc3p0");
        Connection conn=ds.getConnection();
        System.out.println(conn);
    }
}

 

（2）    Druid：
 *      步骤：1.导入jar包 druid-1.0.9.jar
 *                 2.定义配置文件 druid.properties 任意目录 手动加载
 *                 3.获取对象，工厂类DruidDataSourceFactory
 *      定义工具类：
 *                1.定义类JDBCUtils
 *                2.提供静态代码块加载配置文件，初始化连接池对象
 *                3.提供方法：获取连接，释放资源，获取连接池

Demo

public class Demo3Druid {
    public static void main(String[] args) throws Exception {
//        加载配置文件
//        创建Properties集合对象
        Properties pro=new Properties();
//        System.out.println(Demo3Druid.class.getClassLoader());
//        查找具有给定名称的资源。 用于搜索与给定类相关联的资源的规则由该类的定义class loader实现。 此方法委托给该对象的类加载器
        InputStream is=Demo3Druid.class.getClassLoader().getResourceAsStream("druid.properties");
//        将文件资源加载进Properties这个持久的属性集中
        pro.load(is);
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
        Connection conn=ds.getConnection();
        System.out.println(conn);
    }
}

Prac--工具类

public class JDBCUtils {
    private static DataSource ds;
//静态代码块，随着类的执行而加载，并且只执行一次。静态代码块>main>非静态代码块>构造函数
    static {
    try {
        Properties pro = new Properties();
        pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
        ds= DruidDataSourceFactory.createDataSource(pro);
    } catch (IOException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
}
    //    获取连接
    public static Connection getConnection () throws SQLException {
        return ds.getConnection();
    }
//    释放资源
    public static void close (ResultSet rs, Statement stat, Connection conn ){
        if(rs!=null)
        {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stat!=null){
            try {
                stat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    //    获取连接池
    public static DataSource getDs(){
        return  ds;
    }
}

Prac--druid.properties

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/jdbcdemo
username=root
password=root
initialSize=5
maxActive=10
maxWait=3000

Prac--Demo

public class Demo4DruidUtils {
    public static void main(String[] args) {
        Connection conn=null;
        PreparedStatement ps=null;
        try {
//            获取连接
            conn=JDBCUtils.getConnection();
//
            String sql="insert into account values(null,?,?)";
//            获取Ps对象
            ps = conn.prepareStatement(sql);
            ps.setString(1,"tom");
            ps.setDouble(2,123);
            int num = ps.executeUpdate();
            System.out.println(num);

        } catch (SQLException e) {
            e.printStackTrace();
        }
        finally{
            JDBCUtils.close(null,ps,conn);

        }
    }
}

 

 

二.  SpringJDBC

1.介绍

  Spring框架对JDBC进行简单封装，提供了JDBCTemplate对象简化JDBC的开发
 * 步骤：
 *      1.导入jar包
 *      2.创建JDBCTemplate对象，依赖于数据源DataSource：
 *              JDBCTemplate tp=new JDBCTemplate(ds)
 *      3.使用JDBCTemplate方法完成CRUD操作
 *          update()
 *          QueryForMap() 查询长度仅为1
 *          QueryForList()
 *          Query()
 *          QueryForObject()

public class JDBCTemplate {
    public static void main(String[] args) {
        JdbcTemplate jt=new JdbcTemplate(JDBCUtils.getDs());
        String sql="update account set balance=1900 where id=? ";
//        更新语句中，sql语句后参数与sql语句中占位符一一对应
        jt.update(sql,3);

    }
}

2.练习

 * 需求:
 *      1.修改一条数据
 *      2.添加一条记录，随后删除
 *      3.查询id为1的记录，将其封装为Map集合
 *      4.查找所有记录，封装为List
 *      5.查询所有记录，将其封装为对象的集合
 *      6.查询总记录数

package SQL.SpringJDBC;

import SQL.ConnectPool.JDBCUtils;
import SQL.JDBC.account;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;
import java.util.Map;


public class Prac {
    public static void main(String[] args) {
        JdbcTemplate jt=new JdbcTemplate(JDBCUtils.getDs());
        String sql1="update account set balance=123 where id=?";
        int i=jt.update(sql1,1);
        System.out.println(i);

        String sql2="insert into account value(?,?,?)";
        int j=jt.update(sql2,null,"jack",3200);
        System.out.println(j);

        String sql3="delete from account where id=? ";
        int k=jt.update(sql3,4);
        System.out.println(k);

        String sql4="select * from account where id=1";
        Map map=jt.queryForMap(sql4);
        System.out.println(map);

        String sql5="select * from account";
        jt.queryForList(sql5);
        List<account> query = jt.query(sql5, new BeanPropertyRowMapper<account>(account.class));
        for (account account:query){
            System.out.println(account);
        }
                     

        String sql6="select count(id) from account";
        System.out.println(jt.queryForMap(sql6));


    }
}