JDBC第四篇【数据库连接池、DbUtils框架、分页】(修订版)

最新推荐文章于 2020-11-29 11:37:29 发布
最新推荐文章于 2020-11-29 11:37:29 发布
阅读量395 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Java_3y/article/details/98867976
版权 
 
 
前言
 
 
 
  
只有光头才能变强。
 
  
文本已收录至我的GitHub仓库，欢迎Star：https://github.com/ZhongFuCheng3y/3y
 
 
 
 
1.数据库连接池
 
 
什么是数据库连接池
 
 
简单来说：数据库连接池就是提供连接的。。。
 
 
为什么我们要使用数据库连接池
 
 
编写连接池
 
 
  1. 编写连接池需实现java.sql.DataSource接口
  2. 创建批量的Connection用LinkedList保存【既然是个池，当然用集合保存、、LinkedList底层是链表，对增删性能较好】
  3. 实现getConnetion()，让getConnection()每次调用，都是在LinkedList中取一个Connection返回给用户
  4. 调用Connection.close()方法，Connction返回给LinkedList
 
 
private static LinkedList<Connection> list = new LinkedList<>();//获取连接只需要一次就够了，所以用static代码块static {    //读取文件配置    InputStream inputStream = Demo1.class.getClassLoader().getResourceAsStream("db.properties");    Properties properties = new Properties();    try {        properties.load(inputStream);        String url = properties.getProperty("url");        String username = properties.getProperty("username");        String driver = properties.getProperty("driver");        String password = properties.getProperty("password");        //加载驱动        Class.forName(driver);        //获取多个连接，保存在LinkedList集合中        for (int i = 0; i < 10; i++) {            Connection connection = DriverManager.getConnection(url, username, password);            list.add(connection);        }    } catch (IOException e) {        e.printStackTrace();    } catch (ClassNotFoundException e) {        e.printStackTrace();    } catch (SQLException e) {        e.printStackTrace();    }}//重写Connection方法，用户获取连接应该从LinkedList中给他@Overridepublic Connection getConnection() throws SQLException {    System.out.println(list.size());    System.out.println(list);   //先判断LinkedList是否存在连接   return list.size() > 0 ? list.removeFirst() : null; }static LinkedList<Connection> list = new LinkedList<>();

//获取连接只需要一次就够了，所以用static代码块
static {
    //读取文件配置
    InputStream inputStream = Demo1.class.getClassLoader().getResourceAsStream("db.properties");

    Properties properties = new Properties();
    try {
        properties.load(inputStream);
        String url = properties.getProperty("url");
        String username = properties.getProperty("username");
        String driver = properties.getProperty("driver");
        String password = properties.getProperty("password");

        //加载驱动
        Class.forName(driver);

        //获取多个连接，保存在LinkedList集合中
        for (int i = 0; i < 10; i++) {
            Connection connection = DriverManager.getConnection(url, username, password);
            list.add(connection);
        }

    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (SQLException e) {
        e.printStackTrace();
    }

}

//重写Connection方法，用户获取连接应该从LinkedList中给他
@Override
public Connection getConnection() throws SQLException {
    System.out.println(list.size());
    System.out.println(list);

   //先判断LinkedList是否存在连接
   return list.size() > 0 ? list.removeFirst() : null; 
}
 
 
我们已经完成前三步了，现在问题来了。我们调用Conncetion.close()方法，是把数据库的物理连接关掉，而不是返回给LinkedList的
 
 
解决思路：
 
 
  1. 写一个Connection子类，覆盖close()方法
  2. 写一个Connection包装类，增强close()方法
  3. 用动态代理，返回一个代理对象出去，拦截close()方法的调用，对close()增强
 
 
分析第一个思路：
 
 
分析第二个思路：
 
 
  1. 写一个类，实现与被增强对象的相同接口【Connection接口】
  2. 定义一个变量，指向被增强的对象
  3. 定义构造方法，接收被增强对象
  4. 覆盖想增强的方法
  5. 对于不想增强的方法，直接调用被增强对象的方法
 
 
这个思路本身是没什么毛病的，就是实现接口时，方法太多了！，所以我们也不使用此方法
 
 
分析第三个思路代码实现：
 
 
@Overridepublic Connection getConnection() throws SQLException {    if (list.size() > 0) {        final Connection connection = list.removeFirst();        //看看池的大小        System.out.println(list.size());        //返回一个动态代理对象        return (Connection) Proxy.newProxyInstance(Demo1.class.getClassLoader(), connection.getClass().getInterfaces(), new InvocationHandler() {            @Override            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                //如果不是调用close方法，就按照正常的来调用                if (!method.getName().equals("close")) {                    method.invoke(connection, args);                } else {                    //进到这里来，说明调用的是close方法                    list.add(connection);                    //再看看池的大小                    System.out.println(list.size());                }                return null;            }        });    }    return null;}
public Connection getConnection() throws SQLException {

    if (list.size() > 0) {
        final Connection connection = list.removeFirst();

        //看看池的大小
        System.out.println(list.size());

        //返回一个动态代理对象
        return (Connection) Proxy.newProxyInstance(Demo1.class.getClassLoader(), connection.getClass().getInterfaces(), new InvocationHandler() {

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                //如果不是调用close方法，就按照正常的来调用
                if (!method.getName().equals("close")) {
                    method.invoke(connection, args);
                } else {

                    //进到这里来，说明调用的是close方法
                    list.add(connection);

                    //再看看池的大小
                    System.out.println(list.size());

                }
                return null;
            }

        });
    }
    return null;
}
 
 
 
 
我们上面已经能够简单编写一个线程池了。下面我们来使用一下开源数据库连接池
 
 
DBCP
 
 
使用DBCP数据源的步骤：
 
 
  1. 导入两个jar包【Commons-dbcp.jar和Commons-pool.jar】
  2. 读取配置文件
  3. 获取BasicDataSourceFactory对象
  4. 创建DataSource对象
 
 
private static DataSource dataSource = null;static {    try {        //读取配置文件        InputStream inputStream = Demo3.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");        Properties properties = new Properties();        properties.load(inputStream);        //获取工厂对象        BasicDataSourceFactory basicDataSourceFactory = new BasicDataSourceFactory();        dataSource = basicDataSourceFactory.createDataSource(properties);    } catch (IOException e) {        e.printStackTrace();    } catch (Exception e) {        e.printStackTrace();    }}public static Connection getConnection() throws SQLException {    return dataSource.getConnection();}//这里释放资源不是把数据库的物理连接释放了，是把连接归还给连接池【连接池的Connection内部自己做好了】public static void release(Connection conn, Statement st, ResultSet rs) {    if (rs != null) {        try {            rs.close();        } catch (Exception e) {            e.printStackTrace();        }        rs = null;    }    if (st != null) {        try {            st.close();        } catch (Exception e) {            e.printStackTrace();        }    }    if (conn != null) {        try {            conn.close();        } catch (Exception e) {            e.printStackTrace();        }    }}static DataSource dataSource = null;

static {
    try {
        //读取配置文件
        InputStream inputStream = Demo3.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
        Properties properties = new Properties();
        properties.load(inputStream);

        //获取工厂对象
        BasicDataSourceFactory basicDataSourceFactory = new BasicDataSourceFactory();
        dataSource = basicDataSourceFactory.createDataSource(properties);

    } catch (IOException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public static Connection getConnection() throws SQLException {
    return dataSource.getConnection();

}

//这里释放资源不是把数据库的物理连接释放了，是把连接归还给连接池【连接池的Connection内部自己做好了】
public static void release(Connection conn, Statement st, ResultSet rs) {

    if (rs != null) {
        try {
            rs.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        rs = null;
    }
    if (st != null) {
        try {
            st.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

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

    }
}
 
 
C3P0
 
 
C3P0数据源的性能更胜一筹，并且它可以使用XML配置文件配置信息！
 
 
步骤：
 
 
  1. 导入开发包【c3p0-0.9.2-pre1.jar】和【mchange-commons-0.2.jar】
  2. 导入XML配置文件【可以在程序中自己一个一个配，C3P0的doc中的Configuration有XML文件的事例】
  3. new出ComboPooledDataSource对象
 
 
private static ComboPooledDataSource comboPooledDataSource = null;static {    //如果我什么都不指定，就是使用XML默认的配置，这里我指定的是oracle的    comboPooledDataSource = new ComboPooledDataSource("oracle");}public static Connection getConnection() throws SQLException {    return comboPooledDataSource.getConnection();}static ComboPooledDataSource comboPooledDataSource = null;

static {
    //如果我什么都不指定，就是使用XML默认的配置，这里我指定的是oracle的
    comboPooledDataSource = new ComboPooledDataSource("oracle");
}

public static Connection getConnection() throws SQLException {
    return comboPooledDataSource.getConnection();
}
 
 
 
 
Tomcat数据源
 
 
Tomcat服务器也给我们提供了连接池，内部其实就是DBCP
 
 
步骤：
 
 
  1. 在META-INF目录下配置context.xml文件【文件内容可以在tomcat默认页面的 JNDI Resources下Configure Tomcat's Resource Factory找到】
  2. 导入Mysql或oracle开发包到tomcat的lib目录下
  3. 初始化JNDI->获取JNDI容器->检索以XXX为名字在JNDI容器存放的连接池
 
 
context.xml文件的配置：
 
 
<Context>  <Resource name="jdbc/EmployeeDB"            auth="Container"            type="javax.sql.DataSource"            username="root"            password="root"            driverClassName="com.mysql.jdbc.Driver"            url="jdbc:mysql://localhost:3306/zhongfucheng"            maxActive="8"            maxIdle="4"/></Context>
  <Resource name="jdbc/EmployeeDB"
            auth="Container"
            type="javax.sql.DataSource"

            username="root"
            password="root"
            driverClassName="com.mysql.jdbc.Driver"
            url="jdbc:mysql://localhost:3306/zhongfucheng"
            maxActive="8"
            maxIdle="4"/>
</Context>
 
 
try {    //初始化JNDI容器    Context initCtx = new InitialContext();    //获取到JNDI容器    Context envCtx = (Context) initCtx.lookup("java:comp/env");    //扫描以jdbc/EmployeeDB名字绑定在JNDI容器下的连接池    DataSource ds = (DataSource)            envCtx.lookup("jdbc/EmployeeDB");    Connection conn = ds.getConnection();    System.out.println(conn);} 

    //初始化JNDI容器
    Context initCtx = new InitialContext();

    //获取到JNDI容器
    Context envCtx = (Context) initCtx.lookup("java:comp/env");

    //扫描以jdbc/EmployeeDB名字绑定在JNDI容器下的连接池
    DataSource ds = (DataSource)
            envCtx.lookup("jdbc/EmployeeDB");

    Connection conn = ds.getConnection();
    System.out.println(conn);

} 
 
 
 
 
使用dbutils框架
 
 
dbutils它是对JDBC的简单封装，极大简化jdbc编码的工作量
 
 
DbUtils类
 
 
提供了关闭连接，装载JDBC驱动，回滚提交事务等方法的工具类【比较少使用，因为我们学了连接池，就应该使用连接池连接数据库】
 
 
QueryRunner类
 
 
该类简化了SQL查询，配合ResultSetHandler使用，可以完成大部分的数据库操作，重载了许多的查询，更新，批处理方法。大大减少了代码量
 
 
ResultSetHandler接口
 
 
该接口规范了对ResultSet的操作，要对结果集进行什么操作，传入ResultSetHandler接口的实现类即可。
 
 
 
 
使用DbUtils框架对数据库的CRUD
 
 
/** 使用DbUtils框架对数据库的CRUD* 批处理** */public class Test {    @org.junit.Test    public void add() throws SQLException {        //创建出QueryRunner对象        QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());        String sql = "INSERT INTO student (id,name) VALUES(?,?)";        //我们发现query()方法有的需要传入Connection对象，有的不需要传入        //区别：你传入Connection对象是需要你来销毁该Connection，你不传入，由程序帮你把Connection放回到连接池中        queryRunner.update(sql, new Object[]{"100", "zhongfucheng"});    }    @org.junit.Test    public void query()throws SQLException {        //创建出QueryRunner对象        QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());        String sql = "SELECT * FROM student";        List list = (List) queryRunner.query(sql, new BeanListHandler(Student.class));        System.out.println(list.size());    }    @org.junit.Test    public void delete() throws SQLException {        //创建出QueryRunner对象        QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());        String sql = "DELETE FROM student WHERE id='100'";        queryRunner.update(sql);    }    @org.junit.Test    public void update() throws SQLException {        //创建出QueryRunner对象        QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());        String sql = "UPDATE student SET name=? WHERE id=?";        queryRunner.update(sql, new Object[]{"zhongfuchengaaa", 1});    }    @org.junit.Test    public void batch() throws SQLException {        //创建出QueryRunner对象        QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());        String sql = "INSERT INTO student (name,id) VALUES(?,?)";        Object[][] objects = new Object[10][];        for (int i = 0; i < 10; i++) {            objects[i] = new Object[]{"aaa", i + 300};        }        queryRunner.batch(sql, objects);    }}
public class Test {

    @org.junit.Test
    public void add() throws SQLException {

        //创建出QueryRunner对象
        QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "INSERT INTO student (id,name) VALUES(?,?)";

        //我们发现query()方法有的需要传入Connection对象，有的不需要传入
        //区别：你传入Connection对象是需要你来销毁该Connection，你不传入，由程序帮你把Connection放回到连接池中
        queryRunner.update(sql, new Object[]{"100", "zhongfucheng"});

    }

    @org.junit.Test
    public void query()throws SQLException {

        //创建出QueryRunner对象
        QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "SELECT * FROM student";

        List list = (List) queryRunner.query(sql, new BeanListHandler(Student.class));
        System.out.println(list.size());

    }

    @org.junit.Test
    public void delete() throws SQLException {
        //创建出QueryRunner对象
        QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "DELETE FROM student WHERE id='100'";

        queryRunner.update(sql);
    }

    @org.junit.Test
    public void update() throws SQLException {
        //创建出QueryRunner对象
        QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "UPDATE student SET name=? WHERE id=?";

        queryRunner.update(sql, new Object[]{"zhongfuchengaaa", 1});
    }

    @org.junit.Test
    public void batch() throws SQLException {
        //创建出QueryRunner对象
        QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
        String sql = "INSERT INTO student (name,id) VALUES(?,?)";

        Object[][] objects = new Object[10][];
        for (int i = 0; i < 10; i++) {
            objects[i] = new Object[]{"aaa", i + 300};
        }
        queryRunner.batch(sql, objects);
    }

}
 
 
分页
 
 
分页技术是非常常见的，在搜索引擎下搜索页面，不可能把全部数据都显示在一个页面里边。所以我们用到了分页技术。
 
 
Oracle实现分页
 
 
/*  Oracle分页语法：    @lineSize---每页显示数据行数    @currentPage----当前所在页*/SELECT *FROM (    SELECT 列名,列名,ROWNUM rn    FROM 表名    WHERE ROWNUM<=(currentPage*lineSize)) tempWHERE temp.rn>(currentPage-1)*lineSize;
SELECT *FROM (
    SELECT 列名,列名,ROWNUM rn
    FROM 表名
    WHERE ROWNUM<=(currentPage*lineSize)) temp

WHERE temp.rn>(currentPage-1)*lineSize;
 
 
Oracle分页原理简单解释：
 
 
/*  Oracle分页：    Oracle的分页依赖于ROWNUM这个伪列，ROWNUM主要作用就是产生行号。  分页原理：    1：子查询查出前n行数据，ROWNUM产生前N行的行号    2：使用子查询产生ROWNUM的行号，通过外部的筛选出想要的数据  例子：    我现在规定每页显示5行数据【lineSize=5】，我要查询第2页的数据【currentPage=2】    注：【对照着语法来看】  实现：    1：子查询查出前10条数据【ROWNUM<=10】    2：外部筛选出后面5条数据【ROWNUM>5】    3：这样我们就取到了后面5条的数据*/
 
 
 
 
Mysql实现分页
 
 
/*  Mysql分页语法：  @start---偏移量，不设置就是从0开始【也就是(currentPage-1)*lineSize】  @length---长度，取多少行数据*/SELECT *FROM 表名LIMIT [START], length;/*  例子：    我现在规定每页显示5行数据，我要查询第2页的数据  分析：    1：第2页的数据其实就是从第6条数据开始，取5条  实现：    1：start为5【偏移量从0开始】    2：length为5*/
SELECT *
FROM 表名
LIMIT [START], length;

/*
  例子：
    我现在规定每页显示5行数据，我要查询第2页的数据

  分析：
    1：第2页的数据其实就是从第6条数据开始，取5条

  实现：
    1：start为5【偏移量从0开始】
    2：length为5

*/
 
 
总结：
 
 
 
 
使用JDBC连接数据库实现分页
 
 
下面是常见的分页图片
 
 
 
  640?wx_fmt=png 
 
 
 
 
 
配合图片，看下我们的需求是什么：
 
 
  1. 算出有多少页的数据，显示在页面上
  2. 根据页码，从数据库显示相对应的数据。
 
 
分析：
 
 
  1. 算出有多少页数据这是非常简单的【在数据库中查询有多少条记录，你每页显示多少条记录，就可以算出有多少页数据了】
  2. 使用Mysql或Oracle的分页语法即可
 
 
通过上面分析，我们会发现需要用到4个变量
 
 
    //每页显示3条数据    int lineSize = 3;    //总记录数    int totalRecord = getTotalRecord();    //假设用户指定的是第2页    int currentPage = 2;    //一共有多少页    int pageCount = getPageCount(totalRecord, lineSize);    //使用什么数据库进行分页，记得要在JdbcUtils中改配置    List<Person> list = getPageData2(currentPage, lineSize);    for (Person person : list) {        System.out.println(person);    }//使用JDBC连接Mysql数据库实现分页public static List<Person> getPageData(int currentPage, int lineSize) throws SQLException {    //从哪个位置开始取数据    int start = (currentPage - 1) * lineSize;    QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());    String sql = "SELECT name,address  FROM person LIMIT ?,?";    List<Person> persons = (List<Person>) queryRunner.query(sql, new BeanListHandler(Person.class), new Object[]{start, lineSize});    return persons;}//使用JDBC连接Oracle数据库实现分页public static List<Person> getPageData2(int currentPage, int lineSize) throws SQLException {    //从哪个位置开始取数据    int start = (currentPage - 1) * lineSize;    //读取前N条数据    int end = currentPage * lineSize;    QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());    String sql = "SELECT " +            "  name, " +            "  address " +            "FROM ( " +            "  SELECT " +            "    name, " +            "    address , " +            "    ROWNUM rn " +            "  FROM person " +            "  WHERE ROWNUM <= ? " +            ")temp WHERE temp.rn>?";    List<Person> persons = (List<Person>) queryRunner.query(sql, new BeanListHandler(Person.class), new Object[]{end, start});    return persons;}public static int getPageCount(int totalRecord, int lineSize) {    //简单算法    //return (totalRecord - 1) / lineSize + 1;    //此算法比较好理解，把数据代代进去就知道了。    return totalRecord % lineSize == 0 ? (totalRecord / lineSize) : (totalRecord / lineSize) + 1;}public static int  getTotalRecord() throws SQLException {    //使用DbUtils框架查询数据库表中有多少条数据    QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());    String sql = "SELECT COUNT(*) FROM person";    Object o = queryRunner.query(sql, new ScalarHandler());    String ss = o.toString();    int  s = Integer.parseInt(ss);    return s;}
    int lineSize = 3;

    //总记录数
    int totalRecord = getTotalRecord();

    //假设用户指定的是第2页
    int currentPage = 2;

    //一共有多少页
    int pageCount = getPageCount(totalRecord, lineSize);

    //使用什么数据库进行分页，记得要在JdbcUtils中改配置
    List<Person> list = getPageData2(currentPage, lineSize);
    for (Person person : list) {
        System.out.println(person);
    }


//使用JDBC连接Mysql数据库实现分页
public static List<Person> getPageData(int currentPage, int lineSize) throws SQLException {

    //从哪个位置开始取数据
    int start = (currentPage - 1) * lineSize;

    QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
    String sql = "SELECT name,address  FROM person LIMIT ?,?";

    List<Person> persons = (List<Person>) queryRunner.query(sql, new BeanListHandler(Person.class), new Object[]{start, lineSize});
    return persons;

}

//使用JDBC连接Oracle数据库实现分页
public static List<Person> getPageData2(int currentPage, int lineSize) throws SQLException {

    //从哪个位置开始取数据
    int start = (currentPage - 1) * lineSize;

    //读取前N条数据
    int end = currentPage * lineSize;

    QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
    String sql = "SELECT " +
            "  name, " +
            "  address " +
            "FROM ( " +
            "  SELECT " +
            "    name, " +
            "    address , " +
            "    ROWNUM rn " +
            "  FROM person " +
            "  WHERE ROWNUM <= ? " +
            ")temp WHERE temp.rn>?";

    List<Person> persons = (List<Person>) queryRunner.query(sql, new BeanListHandler(Person.class), new Object[]{end, start});
    return persons;

}

public static int getPageCount(int totalRecord, int lineSize) {

    //简单算法
    //return (totalRecord - 1) / lineSize + 1;

    //此算法比较好理解，把数据代代进去就知道了。
    return totalRecord % lineSize == 0 ? (totalRecord / lineSize) : (totalRecord / lineSize) + 1;

}


public static int  getTotalRecord() throws SQLException {

    //使用DbUtils框架查询数据库表中有多少条数据
    QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
    String sql = "SELECT COUNT(*) FROM person";

    Object o = queryRunner.query(sql, new ScalarHandler());

    String ss = o.toString();
    int  s = Integer.parseInt(ss);
    return s;
}
 
 

 
 
最后
 
 
 
 
 
  
乐于输出干货的Java技术公众号：Java3y。公众号内有200多篇原创技术文章、海量视频资源、精美脑图，不妨来关注一下！
 
 
 
 
640?wx_fmt=jpeg
 
 有帮助？好看！转发！ 
 640 


                

        

    

  



    

      

        

            

              
                
                  Java3y
                
              
            

            

                关注
              
            

        

        

          
      

      










                



	

		

			

				
					
JDBC第四篇--【数据库连接池、DbUtils框架、分页】

				
			

			

				

					zhong_fucheng
				

				

					12-21
					
					2589
					
				

			

		

		

			
				
1.数据库连接池什么是数据库连接池简单来说：数据库连接池就是提供连接的。为什么我们要使用数据库连接池
数据库的连接的建立和关闭是非常消耗资源的
频繁地打开、关闭连接造成系统性能低下
编写连接池
编写连接池需实现java.sql.DataSource接口
创建批量的Connection用LinkedList保存【既然是个池，当然用集合保存、、LinkedList底层是链表，对增删性能较好】
实现get

			
		

	



                

            
              



	

		

			

				
					
JDBC连接mysql数据库

				
			

			

				

					weixin_54236608的博客
				

				

					10-20
					
					1162
					
				

			

		

		

			
				
JDBC

环境



JDK1.8
第三方依赖：mysql-connector-java-8.0.15.jar



将依赖放到lib文件中，右键add as libiary
通过反射机制加载MySQL类驱动器：Class.forName("com.mysql.cj.jdbc.Driver")
创建Java与MySQL的连接通道：DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/数据库名?useUnicode=true&charact

			
		

	



              


  
              

                


	

		

			

				
					
DButil 封装 包括模糊查询 分页Count 普通增删改查方法

				
			

			

				

					06-15
				

			

		

		

			
				
内有部分方法使用说明及完整源码！

			
		

	





	

		

			

				
					
DBCP连接池配置详解

				
			

			

				

					guolong1983811的专栏
				

				

					07-30
					
					933
					
				

			

		

		

			
				
https://blog.youkuaiyun.com/yyyuuueeee/article/details/52268619

Spring DBCP配置

 



 


	&lt;bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"&gt; 
	
	 
	
	&lt;pro...

			
		

	



		

			
		



	

		

			

				
					
dbcp连接池

				
			

			

				

					qingfeng_lxc的专栏
				

				

					06-21
					
					233
					
				

			

		

		

			
				
一:创建连接阶段:服务器起动时,会建立initialSize个数据库连接,放入池中.随着应用程序访问量的增加,需要的数据库连接也在增加. 当需要的连接数大于池中的现有连接数(numActive)时,连接池再创建新的连接.具体一次创建多少,不知在哪设置(c3po连接池是通过acquireIncrement这个参数设置)就这样一直创建一直增加,当达到 maxActive时不在创建. 新来的客户请求如果...

			
		

	





	

		

			

				
					
netbeans java web demo4  jsp页分页查询 --jdbc-DBUtils 案例

				
			

			

				

					08-09
				

			

		

		

			
				
 DBUtils**：DBUtils是Apache的一个开源工具包，简化了JDBC的使用，提供了诸如数据库连接池、事务管理等功能。在这个案例中，DBUtils帮助开发者更方便地执行SQL语句，处理结果集，减轻了手动处理数据库连接的负担，...

			
		

	





	

		

			

				
					
JSP连接数据库实现分页显示

				
			

			

				

					sinat_35010585的博客
				

				

					06-27
					
					1358
					
				

			

		

		

			
				
1.新建数据库和表users
2.Users类
public class Users {
private Integer id;
private String uname;
private String pwd;

public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = i

			
		

	





	

		

			

				
					
NetBeans Java Web示例：JSP分页查询与JDBC-DBUtils集成

				
			

			

				

					
				

			

		

		

			
				
DBUtils中还提供了诸如C3P0、DBCP等连接池技术，提高了数据库连接的使用效率。在这个案例中，DBUtils可能是用来简化JDBC代码的关键组件，使得分页查询的实现更直观和高效。  #### 6. MySQL数据库 MySQL是一个流行的...

			
		

	





	

		

			

				
					
连接池介绍

				
			

			

				

					
				

				

					08-07
					
					1208
					
				

			

		

		

			
				
，c3p0等一些重要的配置如下！

1.JDBC数据库连接池的必要性 
在使用开发基于数据库的web程序时，传统的模式基本是按以下步骤：　　
在主程序（如servlet、beans）中建立数据库连接。 
进行sql操作
断开数据库连接。
这种模式开发，存在的问题:
普通的JDBC数据库连接使用 DriverManager 来获取，每次向数据库建立连接的时候都要将 Connectio

			
		

	





	

		

			

				
					
springboot学习进阶(二)----配置数据源

				
			

			

				

					qq904748592的博客
				

				

					02-22
					
					1504
					
				

			

		

		

			
				
    做Java开发的都知道，后台就是要跟数据库进行打交道的，什么增删改查什么排序分组索引，也不是本文的重点，就不详细述说了，但是怎么连接数据库这个在配置数据库的时候，是必须要清楚的。传统的数据库链接方式就是jdbc创建一个数据库连接，然后执行完sql操作之后再删除，到现在使用了数据库连接池，为什么使用数据库连接池这里也不再阐述，网上有很多文章都有。

    既然说到数据库连接池，那么就列举一...

			
		

	





	

		

			

				
					
DBCP连接池配置详解，参数列表

				
			

			

				

					随风飘扬
				

				

					07-16
					
					9698
					
				

			

		

		

			
				

                    
                        

Spring DBCP配置

&amp;lt;bean id=“dataSource” class=“org.apache.commons.dbcp.BasicDataSource” destroy-method=“close”&amp;gt;      &amp;lt;property name=“driverClassNa...

			
		

	





	

		

			

				
					
springboot hikari连接不释放_Spring Boot 如何整合连接池_java

				
			

			

				

					weixin_39537977的博客
				

				

					11-03
					
					2914
					
				

			

		

		

			
				
Spring Boot 整合连接池在实际开发中应用程序与数据库交互时，“获得连接”或在“释放资源”是非常消耗资源的两个过程，为了解决如此类性能问题，通常这种情况我们采用连接池技术重用连接Connection对象，如图1所示。图-1其实Java为数据库连接池提供了公共的接口：，各个厂商需要让自己的连接池实现这个接口。然后我们的应用程序中耦合这个接口，便可以方便的切换不同厂商的连接池，常见的连接池有D...

			
		

	





	

		

			

				
					
dbcp连接池配置详解_数据库连接池-tomcat-jdbc使用笔记

				
			

			

				

					weixin_39799646的博客
				

				

					11-29
					
					227
					
				

			

		

		

			
				
现在 主流的数据库连接池有：Proxool、C3P0、DBCP、tomcat-jdbc、Druid。其中tomcat-jdbc是tomcat服务器比较可靠的 数据库连接池。Tomcat 在 7.0 以前的版本都是使用commons-dbcp做为连接池的实现，但是DBCP存在一些问题： DBCP 是单线程的，为了保证线程安全会锁整个连接池 DBCP 性能不佳 DBCP 太复杂，超过60个类，发展滞后...

			
		

	





	

		

			

				
					
[Coding Time]-Spring 整合Druid  连接池

				
			

			

				

					qiaoqiao0609的博客
				

				

					03-29
					
					218
					
				

			

		

		

			
				
DRUID是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、PROXOOL等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池(据说是目前最好的连接池,不知道速度有没有BoneCP快)。和其它连接池一样DRUID的DataSource类为：com.alibaba.druid.pool.DruidDataSource，基...

			
		

	





	

		

			

				
					
用了这么久的数据库连接池，你知道原理吗？

				
			

			

				

					weixin_44421461的博客
				

				

					09-26
					
					191
					
				

			

		

		

			
				
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！源码精品专栏原创 | Java 2020超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析...

			
		

	





	

		

			

				
					
dbcp连接池配置详解_spring配置连接池

				
			

			

				

					weixin_39908616的博客
				

				

					11-21
					
					397
					
				

			

		

		

			
				
连接池是什么？数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。个人理解：就是类似于水库，你每次都要跑老远去取水，这样很麻烦，于是人们建立一个水库，你想要水的时候可以直接从里面取，如果水库水少了，你又...

			
		

	





	

		

			

				
					
数据库连接池的好处

				
			

			

				

					shohokuf的专栏
				

				

					02-19
					
					1976
					
				

			

		

		

			
				
    对于一个简单的数据库应用，由于对于数据库的访问不是很频繁。这时可以简单地在需要访问数据库时，就新创建一个连接，用完后就关闭它，这样做也不会带来什么明显的性能上的开销。但是对于一个复杂的数据库应用，情况就完全不同了。频繁的建立、关闭连接，会极大的减低系统的性能，因为对于连接的使用成了系统性能的瓶颈。     连接复用。通过建立一个数据库连接池以及一套连接使用管理策略，使得一个数据库连接可

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值