精华内容
下载资源
问答
  • Tomcat与数据库连接

    2017-05-07 20:18:11
    一个数据库连接对象均对应一个物理数据库连接,每次操作都打开一个物理连接,使用完后立即关闭连接频繁地打开,关闭连接将造成系统的性能低下。解决方案是:当应用程序启动时,系统主动建立足够的数据库连接,并将...

    一个数据库连接对象均对应一个物理数据库连接,每次操作都打开一个物理连接,使用完后立即关闭连接,频繁地打开,关闭连接将造成系统的性能低下。解决方案是:当应用程序启动时,系统主动建立足够的数据库连接,并将这写连接组成一个连接池,每次应用程序请求数据库连接时,无需重新建立连接,而是连接池去除已有的连接使用,使用完后不再关闭连接,而是将连接归还给连接池。

    JDBC 2.0引入数据库连接池技术。数据库连接池是Connection对象的工厂。使用javax.sql.DataSource来表示,Source只是一个接口,通常用商用服务器提供实现,也有一些开源组织(DBCP和C3P0等)

    下面以DBCP为例,解释如何使用数据库连接池的

    因为Tomcat和 dbcp 都是Apache公司项目,所以Tomcat内部连接池就是dbcp。

    若想使用Tomcat内置连接池,必须要在Context元素中添加Resource标签(用来定义数据源),具体代码如下:(连接的是MySQL数据库)

    <Context>
    <Resource name="jdbc/mysql"  //JNDI
          auth="Container" 
          type="javax.sql.DataSource" 
          maxActive="50"
          maxIdle="10"
          maxWait="5000" 
          username="root"
          password="19960722w" 
          driverClassName="com.mysql.jdbc.Driver"
    url="jdbc:mysql://localhost/market?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull"/>
    </Context>
    • driverClassName - JDBC 所用到的数据库驱动的类全名.
    • maxActive - 连接池在活动状态内所提供的最大活动连接数。
    • maxIdle - 连接池在空闲时刻保持的最大连接数.
    • maxWait - 当发生异常时数据库等待的最大毫秒数 (当没有可用的连接时).
    • password - 连接数据库的密码.
    • url - 连接至驱动的URL.
    • username - 数据库用户名
    • name 指定Resource的JNDI名字
    • auth 指定管理Resource的Manager,有两个可选值:Container和Application。Container表示由容器创建和管理Resource,Application表示由Web应用来创建和管理Resource
    • type 指定Resource所属的Java类名

       配置这个元素,一共有三个位置可以选择:
         1.tomcat安装目录/conf/context.xml --------- 对当前Tomcat内部所有虚拟主机中任何工程都有效
         2.tomcat安装目录/conf/Catalina/虚拟主机目录/context.xml -------- 对当前虚拟主机任何工程都有效
         3.在web工程根目录/META-INF/context.xml ------- 对当前工程有效 (常用!)
            具体做法:MyEclipse中,在项目根目录的WebRoot/META-INF中,新建context.xml文件,配置元素。

    配置元素完后,使用JNDI访问Tomcat内置的数据库池

    (JNDI(Java Naming and Directory Interface),Java命名和目录接口,它对应于J2SE中的javax.naming包,主要作用在于:它可以把Java对象放在一个容器中(支持JNDI容器 Tomcat),并为容器中的java对象取一个名称,以后程序想获得Java对象,只需通过名称检索即可。
    其核心API为Context,它代表JNDI容器,其lookup方法为检索容器中对应名称的对象。)

    1.将数据库的驱动jar包复制粘贴到Tomcat的lib包下(或当前工程下的WEB-INF/lib目录下)

    2.在当前工程的web.xml也要进行配置(声明对这个JNDI资源的引用),添加如下的代码:

     <resource-ref> 
           <description>DB Connection</description> 
           <res-ref-name>jdbc/mysql</res-ref-name> //name也要与context.xml的Resource的name相同
           <res-type>javax.sql.DataSource</res-type> 
           <res-auth>Container</res-auth> 
        </resource-ref>

    •  description:对所用资源的说明
    • res-ref-name:指定所引用资源的JNDI名字,与<Resource>元素中的name属性对应
    • res-type:指定所引用资源的类名字,与<Resource>元素中的type属性对应
    • res-auth:制定管理所引用资源的Manager,与<Resource>元素中的auth属性对应

    2.编写访问JNDI程序,运行在Tomcat内部,所以通常是运行在Servlet、JSP中。

    JSP测试代码如下:

    <%@ page language="java" pageEncoding="UTF-8"%>
    <%@ page import="java.sql.*"%> 
    <%@ page import="javax.sql.*"%> 
    <%@ page import="javax.naming.*"%>
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
     <head>
          <title>mysql连接池测试</title>
            <meta http-equiv="pragma" content="no-cache">
            <meta http-equiv="cache-control" content="no-cache">
            <meta http-equiv="expires" content="0"> 
            <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
            <meta http-equiv="description" content="This is my page">
       </head>
      
    <body> 
       <%  
           out.print("我的测试开始<br>"); 
           DataSource ds = null; 
           Connection conn=null;
         try{  
                  InitialContext ctx=new InitialContext(); 
                  ds=(DataSource)ctx.lookup("java:comp/env/jdbc/mysql"); //Context接口里的方法:lookup(String name) 返回指定的名字绑定的对象
                  conn = ds.getConnection();  
        }catch(Exception ex){
         ex.printStackTrace();
        } 
            %>  
        <%   
        if(conn!=null){ 
        %> 
         <%= conn %>;  
       <% 
        } 
       %> 
       </body>
    </html>>

    注意:

       对于DataSource接口的多数实现类,它的getConnection()方法返回的是Connection代理对象,它也实现java.sql.Connection接口。Connection代理对象的close()方法并不断开数据库的连接,而是把代理的代表数据库连接的Connection对象放回数据库连接池,使它处于空闲状态


    这样就可以建立数据库连接池,由Tomcat管理。



    展开全文
  • 数据库连接

    2021-03-08 19:05:33
    这是因为在Java程序中与数据库之间建立连接时,加上数据库端要验证用户名和密码并为该连接分配资源,而程序则要把代表连接Connection对象加载到内存中,所以建立数据库连接的开销很大。尤其是在大量的并发访问时,...

    数据库连接池概述

    在JDBC编程中,每次创建和断开Connection对象都会消耗一定的时间和IO资源。这是因为在Java程序中与数据库之间建立连接时,加上数据库端要验证用户名和密码并为该连接分配资源,而程序则要把代表连接Connection对象加载到内存中,所以建立数据库连接的开销很大。尤其是在大量的并发访问时,频繁地创建、断开数据库连接势必会影响数据库的访问效率,甚至导致数据库崩溃。
    为了解决该类问题的发生诞生了数据库连接池技术。数据库连接池负责分配、管理和释放数据库连接,它允许在应用程序重复使用现有的数据库连接,而不是每次都重新建立连接。
    两种常见的连接池:DBCP 和 C3P0

    DBCP

    DBCP(DataBase Connection Pool)由Apache研发,而且Tomcat的连接池也正是采用DBCP实现的,该数据库连接池既可与应用服务器整合使用,也可由应用程序独立使用。
    配置文件:

    #<!-- 连接设置 -->
    driverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/mydb
    username=root
    password=root
    
    #<!-- 初始化连接 -->
    initialSize=10
    
    #<!-- 最大连接数量 -->
    maxActive=50
    
    #<!-- 最大空闲连接 -->
    maxIdle=20
    
    #<!-- 最小空闲连接 -->
    minIdle=5
    
    #<!-- 超时等待时间(单位毫秒) -->
    maxWait=50000
    
    #<!-- 编码方式 -->
    connectionProperties=useUnicode=true;characterEncoding=utf8
    
    ##<!-- 指定由连接池所创建的连接自动提交 -->
    defaultAutoCommit=true
    
    #<!-- 指定由连接池所创建的连接的事务级别 -->
    defaultTransactionIsolation=REPEATABLE_READ
    

    编写操作DBCP的工具类

    package com.util;
    
    import java.io.IOException;
    import java.io.InputStream;
    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 org.apache.commons.dbcp.BasicDataSourceFactory;
    
    public class DBCPUtil {
    	private static DataSource dataSource = null;
    	// 创建数据库连接池
    	static {
    		Properties properties = new Properties();
    
    		try {
    			ClassLoader classLoader = DBCPUtil.class.getClassLoader();
    			InputStream resourceAsStream = classLoader.getResourceAsStream("dbcpconfig.properties");
    			properties.load(resourceAsStream);
    			dataSource = BasicDataSourceFactory.createDataSource(properties);
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    	}
    
    	// 创建连接
    	public static Connection getConnection() {
    		try {
    			return dataSource.getConnection();
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	// 释放连接
    	public static void release(Connection connection, Statement statement, ResultSet resultSet) {
    		if (connection != null) {
    			try {
    				connection.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		if (statement != null) {
    			try {
    				statement.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		if (resultSet != null) {
    			try {
    				resultSet.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    }
    
    

    使用DBPC

    package com.ycy1;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    import com.util.DBCPUtil;
    
    public class Test02 {
    	public static void main(String[] args) {
    		Connection connection = null;
    		PreparedStatement preparedStatement = null;
    		ResultSet resultSet = null;
    		try {
    			connection = DBCPUtil.getConnection();
    			String sql = "select * from student";
    			preparedStatement = connection.prepareStatement(sql);
    			resultSet = preparedStatement.executeQuery();
    			while (resultSet.next()) {
    				int sid = resultSet.getInt("studentid");
    				String sname = resultSet.getString("studentname");
    				Student student = new Student(sid, sname);
    				System.out.println(student);
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			DBCPUtil.release(connection, preparedStatement, resultSet);
    		}
    	}
    }
    
    

    测试结果
    在这里插入图片描述

    C3P0

    C3P0是目前最流行的开源数据库连接池之一,它支持 JDBC2和JDBC3的标准规范,易于扩展并且性能优越,著名的开源框架Hibernate和 Spring使用的数据源正是C3P0。
    配置文件c3p0-config.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <c3p0-config>
      <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/mydb</property>
        <property name="user">root</property>
        <property name="password">root</property>
        <property name="initialPoolSize">15</property>
        <property name="maxIdleTime">40</property>
        <property name="maxPoolSize">150</property>
        <property name="minPoolSize">20</property>
      </default-config>
    </c3p0-config>
    

    编写操作C3P0的操作类

    package com.util;
    
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    import javax.sql.DataSource;
    
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    
    public class C3P0Util {
    	// 创建数据库连接池
    	private static DataSource dataSource = new ComboPooledDataSource();
    
    	// 创建连接
    	public static Connection getConnection() {
    		try {
    			return dataSource.getConnection();
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	// 释放资源
    	public static void release(Connection connection, Statement statement, ResultSet resultSet) {
    		if (connection != null) {
    			try {
    				connection.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		if (statement != null) {
    			try {
    				statement.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		if (resultSet != null) {
    			try {
    				resultSet.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    }
    
    

    使用C3P0

    package com.ycy1;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    import com.mchange.v2.c3p0.cfg.C3P0Config;
    import com.util.C3P0Util;
    
    public class Test03 {
    	public static void main(String[] args) {
    		Connection connection = null;
    		PreparedStatement preparedStatement = null;
    		ResultSet resultSet = null;
    		
    		try {
    			connection = C3P0Util.getConnection();
    			String sql = "select * from student";
    			preparedStatement = connection.prepareStatement(sql);
    			resultSet = preparedStatement.executeQuery();
    			while(resultSet.next()) {
    				int sid = resultSet.getInt("studentid");
    				String sname = resultSet.getString("studentname");
    				Student student = new Student(sid, sname);
    				System.out.println(student);
    			}
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally {
    			C3P0Util.release(connection, preparedStatement, resultSet);
    			
    		}
    	}
    }
    
    

    测试结果:
    在这里插入图片描述

    展开全文
  • 第一次Java程序要在MySQL中执行一条语句,那么就必须建立一个Connection对象,代表了与MySQL数据库的连接通过直接发送你要执行的SQL语句之后,就会调用Connection.close()来关闭和销毁与数据库连接。为什么要立即...

    第一次Java程序要在MySQL中执行一条语句,那么就必须建立一个Connection对象,代表了与MySQL数据库的连接通过直接发送你要执行的SQL语句之后,就会调用Connection.close()来关闭和销毁与数据库的连接。为什么要立即关闭呢?因为数据库的连接是一种很重的资源,代表了网络连接、IO等资源。所以如果不是用的话就需要尽早关闭,以避免资源浪费。

    JDBC的劣势与不足:如果要频繁地操作MySQL的话,那么就势必会频繁地创建Connection对象,底层建立起连接与MySQL的占用了网络资源、IO资源的连接。每次使用完Connection对象之后,都必须将Connection连接关闭,又涉及到频繁的网络资源、IO资源的关闭和释放。

    如上所述,如果频繁的开关Connection连接,那么会造成大量的对网络、IO资源的申请和释放的无谓的时间耗费,对于特别频繁的数据库操作,比如100次/s,那么就可能会导致性能急剧下降。

    数据库连接池,会自己在内部持有一定数量的数据库连接,比如通常可能是100~1000个左右,然后每次Java程序要通过数据库连接往MySQL发送语句的时候,都会从数据库连接池中获取一个连接,然后通过它发送SQL语句。SQL语句执行完之后,不会调用Connection.close(),而是将连接还回数据库连接池里面。下一次,Java程序再需要操作数据库的时间,就还是重复以上步骤,获取连接,发送SQ,还回连接。

    数据库连接池的好处:

    1.Java程序不用自己去管理Connection的创建和销毁,代码上更加方便。

    2.程序中只有固定数量的数据库连接,不会一下子变得很多,而且也不会进行销毁。那么对于段时间频繁进行数据库操作的业务来说。就有很大的意义和很高的价值。也就是说,如果短时间内,频繁操作10000次,不需要对数据连接创建和销毁10000次。这样的话,可以大幅度节省我们的数据可连接的创建和销毁的资源开销以及时间开销。

    3.最终可以提升整个应用程序的性能。

    在Spark的作业中,通常来说,都需要使用数据库连接池。当然,也可以使用开源的数据库连接池,功能非常强大,比如说C3P0、DBCP等等。但是呢,对于某些简单的情况下,我们也可以自己编写一个简单的数据库连接池即可。

    而且在spark作业中,是非常适合使用数据库连接池的。为什么?因为spark计算出来的结果,可能数据量还是比较大的。比如说

    展开全文
  • 为什么要用数据库连接池? 对于一个简单的数据库应用...频繁建立、关闭连接,会极大的减低系统的性能,因为对于连接的使用成了系统性能的瓶颈。 此时便有了数据库连接池的用武之地、 什么是数据库连接池? 官...

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

    什么是数据库连接池?

    官方:数据库连接池(Connection pooling)是程序启动时建立足够的数据库连接,并将这些连接组成一个连接池,由程序动态地对池中的连接进行申请,使用,释放。
    个人理解:创建数据库连接是一个很耗时的操作,也容易对数据库造成安全隐患。所以,在程序初始化的时候,集中创建多个数据库连接,并把他们集中管理,供程序使用,可以保证较快的数据库读写速度,还更加安全可靠。

    外部使用者可通过getConnection 方法获取连接,使用完毕后再通过releaseConnection 方法将连接返回,注意此时连接并没有关闭,而是由连接池管理器回收,并为下一次使用做好准备。

    数据库连接池技术带来的优势:

    1. 资源重用

    由于数据库连接得到重用,避免了频繁创建、释放连接引起的大量性能开销。在减少系统消耗的基础上,另一方面也增进了系统运行环境的平稳性(减少内存碎片以及数据库临时进程/线程的数量)。

    2. 更快的系统响应速度

    数据库连接池在初始化过程中,往往已经创建了若干数据库连接置于池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言,直接利用现有可用连接,避免了数据库连接初始化和释放过程的时间开销,从而缩减了系统整体响应时间。

    3. 新的资源分配手段

    对于多应用共享同一数据库的系统而言,可在应用层通过数据库连接的配置,实现数据库连接池技术,几年钱也许还是个新鲜话题,对于目前的业务系统而言,如果设计中还没有考虑到连接池的应用,那么…….快在设计文档中加上这部分的内容吧。某一应用最大可用数据库连接数的限制,避免某一应用独占所有数据库资源。

    4. 统一的连接管理,避免数据库连接泄漏

    在较为完备的数据库连接池实现中,可根据预先的连接占用超时设定,强制收回被占用连接。从而避免了常规数据库连接操作中可能出现的资源泄漏。一个最小化的数据库连接池实现.

    连接池类是对某一数据库所有连接的“缓冲池”,主要实现以下功能:①从连接池获取或创建可用连接;②使用完毕之后,把连接返还给连接池;③在系统关闭前,断开所有连接并释放连接占用的系统资源;④还能够处理无效连接(原来登记为可用的连接,由于某种原因不再可用,如超时,通讯问题),并能够限制连接池中的连接总数不低于某个预定值和不超过某个预定值。

    数据库连接池实现

    c3p0是一个优秀的连接池,性能也十分可靠。本文就以c3p0连接池为例、

    首先到http://sourceforge.net/projects/c3p0/下载相应的jar包,总共三个,如下图所示。
    本例子连接mysql数据库,所以还有连接mysql要用的jar包,相信大家都不陌生、
    这里写图片描述

    为了更直观的理解使用连接池和不使用的区别:以下例子大家可以参考、
    别忘了引入jar包哦、、、(共四个jar包,三个类)

    1.测试类:

    package c3p0;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class ConnectionDemo {  
        public static void main(String[] args) throws SQLException {  
            long totleTime1 = 0;
            long totleTime2 = 0;
    
            System.out.println("使用连接池................................");  
            for (int i = 0; i < 20; i++) {  
                long beginTime = System.currentTimeMillis();  
                Connection conn = ConnectionManager.getInstance().getConnection();  
                try {  
                    PreparedStatement pstmt = conn.prepareStatement("select * from customer");  
                    ResultSet rs = pstmt.executeQuery();  
                    while (rs.next()) {  
                         // do nothing...  
                    }  
                } catch (SQLException e) {  
                    e.printStackTrace();  
                } finally {  
                    try {  
                        conn.close();  
                    } catch (SQLException e) {  
                        e.printStackTrace();  
                    }  
                }  
    
                long endTime = System.currentTimeMillis();  
                long countTime = endTime - beginTime ;
    
                totleTime1 += countTime;
                System.out.println("第" + (i + 1) + "次执行花费时间为:" + (countTime)+"  总时间:"+totleTime1);  
    
            }  
    
            System.out.println("不使用连接池................................");  
    
            for (int i = 0; i < 20; i++) {  
                long beginTime = System.currentTimeMillis();  
                MysqlDataSource mds = new MysqlDataSource();  
                mds.setURL("jdbc:mysql://localhost:3306/crm?useSSL=false");  
                mds.setUser("root");  
                mds.setPassword("123456");  
                Connection conn = mds.getConnection();  
                try {  
                    PreparedStatement pstmt = conn.prepareStatement("select * from customer");  
                    ResultSet rs = pstmt.executeQuery();  
                    while (rs.next()) {  
                                        // do nothing...  
                    }  
                } catch (SQLException e) {  
                    e.printStackTrace();  
                } finally {  
                    try {  
                        conn.close();  
                    } catch (SQLException e) {  
                        e.printStackTrace();  
                    }  
                }  
                long endTime = System.currentTimeMillis(); 
                long countTime = endTime - beginTime ;
    
                totleTime2 += countTime;
                System.out.println("第" + (i + 1) + "次执行花费时间为:"  
                                    + (countTime)+"  总时间:"+totleTime2);  
    
    
    
            }  
    
        }
    } 

    2.使用数据库连接池的类:

    package c3p0;
    
    import java.beans.PropertyVetoException;
    import java.sql.Connection;
    import java.sql.SQLException;
    
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    
    public final class ConnectionManager {  
        //使用单例模式创建数据库连接池  
        private static ConnectionManager instance;  
        private static ComboPooledDataSource dataSource;  
    
        private ConnectionManager() throws SQLException, PropertyVetoException {  
            dataSource = new ComboPooledDataSource();  
    
            dataSource.setUser("root");     //用户名  
            dataSource.setPassword("123456"); //密码  
            dataSource.setJdbcUrl("jdbc:mysql://127.0.0.1:3306/crm?useSSL=false");//数据库地址  
            dataSource.setDriverClass("com.mysql.jdbc.Driver");  
            dataSource.setInitialPoolSize(5); //初始化连接数  
            dataSource.setMinPoolSize(1);//最小连接数  
            dataSource.setMaxPoolSize(10);//最大连接数  
            dataSource.setMaxStatements(50);//最长等待时间  
            dataSource.setMaxIdleTime(60);//最大空闲时间,单位毫秒  
        }  
    
        public static final ConnectionManager getInstance() {  
            if (instance == null) {  
                try {  
                    instance = new ConnectionManager();  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
            }  
            return instance;  
        }  
    
        public synchronized final Connection getConnection() {  
            Connection conn = null;  
            try {  
                conn = dataSource.getConnection();  
            } catch (SQLException e) {  
                e.printStackTrace();  
            }  
            return conn;  
        }  
    }  

    3.不使用数据库连接池的类:

    package c3p0;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    public class MysqlDataSource 
    {
        String url = "";
        String user = "";
        String password = "";
        //连接
        private  Connection conn = null;
    
        //静态块
        static
        {
            //实例化驱动类
            try {
                Class.forName("com.mysql.jdbc.Driver");
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                System.out.println("mysql驱动装载失败");
                e.printStackTrace();
            }
        }
    
        //取得数据库连接
        public Connection getConnection()
        {
    
    
            try {
                conn = DriverManager.getConnection(url, user, password);
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                System.out.println("无法取得数据库连接");
                e.printStackTrace();
            }
    
            return conn;
        }
    
        //关闭连接
        public void closeConnection()
        {
            try 
            {
                conn.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                System.out.println("无法关闭数据库联接");
                e.printStackTrace();
            }
        }
    
        public void setURL(String url) {
            this.url = url;
    
        }
    
        public void setUser(String user) {
            this.user = user;
    
        }
    
        public void setPassword(String password) {
            this.password = password;
    
        }
    }
    

    控制台结果:
    这里写图片描述

    这里写图片描述

    使用连接池首次创建连接加载时间较长,但之后响应速度明显较快;
    与不使用连接池有明显不同、
    如果对您有所帮助,请点赞,谢谢、、、

    展开全文
  • 使用Java做过商业应用开发的人想必一定用到过数据库。 不论具体方案是使用JDBC...更不能在建立连接(或从连接池中取出)并使用之后就简单结束,而不做资源回收。即使这种资源有超时空闲的自动回收机制,这种做...
  • 这是因为在Java程序与数据库之间建立连接时,数据库端要验证用户名和密码并为该连接分配资源,而程序则要把代表连接Connection对象等加载到内存中,所以建立数据库连接的开销很大。尤其是在大量的并发访问时,频繁...
  • 然后在通过连接发送了你要执行的SQL语句之后,就会调用Connection.close()来关闭和销毁与数据库连接。为什么要立即关闭呢?因为数据库的连接是一种很重的资源,代表了网络连接、IO等资源。所以如果不使用的话,就...
  • PHP访问MySQL数据库

    2019-10-04 23:56:51
    因为连接数据库需要较长的时间和较大的资源开销,所以如果在多个网页中都要频繁地访问数据库,则可以建立与数据库的持续连接。即调用mysql_pconnect()代替mysql_connect()。 基本步骤:1.连接服务器:mysql_connect...
  • PHP访问MySQL数据库因为连接数据库需要较长的时间和较大的资源开销,所以如果在多个网页中都要频繁地访问数据库,则可以建立与数据库的持续连接。即调用mysql_pconnect()代替mysql_connect()。基本步骤:1.连接...
  • 可使用连接池将数据库连接预先建立好,使用的时候获取一个链接,不需要频繁地创建及释放连接数据库连接池有两个重要的配置:最小连接数和最大连接数,这两个参数控制着连接池的获取,如下: 当前连接数小于最小...
  • PHP访问MySQL数据库因为连接数据库需要较长的时间和较大的资源开销,所以如果在多个网页中都要频繁地访问数据库,则可以建立与数据库的持续连接。即调用mysql_pconnect()代替mysql_connect()。基本步骤:1.连接...
  • PHP访问MySQL数据库: 因为连接数据库需要较长的时间和较大的资源开销,所以如果在多个网页中都要频繁地访问数据库,则可以建立与数据库的持续连接。即调用mysql_pconnect()代替mysql_connect()。 基本步骤: 1.连接...
  • 数据库设计细节

    2018-07-16 19:38:54
    原因:这样不仅避免了主键唯一且不为null的问题,还最大化利用了主键索引,避免了B+树频繁的拆分合并。 2、表之间的关系:只有一对一的时候不用建立连接表,只要是一对多(多对一)或多对多就要建连接表。 ...
  • 目开发过程中应用程序与数据库交互时,“获得连接”或“释放连接”是非常消耗系统资源的两个过程,频繁地进行数据库连接建立和关闭会极大影响系统的性能,若多线程并发量很大,这样耗时的数据库连接就可能让系统变...
  •  本书由多位工作在数据库维护一线的工程师合著而成,包含了精心挑选的数据库诊断案例性能优化实践经验,内容涉及oracle典型错误的分析和诊断,各种sql优化方法(包括调整索引,处理表碎片,优化分页查询,改善...
  • 机制,它能够对用户访问SQL Server服务器系统和数据库的安全进行全面管理。按照本文介绍的步骤,你 可以为SQL Server 7.0(或2000)构造出一个灵活的、可管理的安全策略,而且它的安全性经得起考验。 一、验证...
  • 连接池原理(MySQL Connection Pool)

    千次阅读 2019-01-27 16:29:23
    这时可以简单在需要访问数据库时,就新创建一个连接,用完后就关闭它,这样做也不会带来什么明显的性能上的开销。但是对于一个复杂的数据库应用,情况就完全不同了。频繁建立、关闭连接,会极大的减低系统的性能...
  • python笔记-mysql

    2018-05-09 21:56:35
    程序和数据库建立连接的过程要占用硬件资源,如果是程序直接和数据库进行通信会频繁与数据库进行建立连接,过程中会占用大量系统资源不利于资源的合理分配利用,数据库连接池可以解决这一问题,程序通过访问连接池...
  • Oracle 10g RAC public IP private IP 详解

    千次阅读 2015-01-21 16:08:51
    公有网络:对外提供服务,用于客户端、应用系统和数据库之间的连接。一般除了维护数据库外,用户很少直接连接数据库, ...重用相同的数据库连接,这样可以避免频繁地建立和释放数据库连接,减少系统资源的消耗。
  • 在Oracle公司,Kyte专门负责Oracle数据库,他的任务是帮助使用Oracle数据库的客户,并他们共同设计和构建系统,或者对系统进行重构和调优。在进入Oracle公司之前,Kyte是一名系统集成人员,主要为美国军方和政府...
  • 说明:断开当前数据库连接并会退出 用法:exit 6. 编辑脚本(edit/ed) 说明:编辑指定或缓冲区的sql脚本 用法:edit [文件名] 列子: 7. 运行脚本 (start/@) 说明:运行指定的sql脚本 用法:start/@ 文件名 ...
  • 声明:以下只是个人的一些理解,并非正确,仅供借鉴参考。 ...下面下介绍下连接池,连接池的目的主要是为了解决重复、频繁地创建数据库连接,解决一些资源效果方面的问题。建立数据库连接就好...
  • 当我们需要连接使用数据库时,我们需要建立数据库连接数据库连接是一项高额的开销,频繁的创建销毁会造成巨大的性能问题,因而诞生了数据库连接池技术。 主流的ORM框架都配备了连接池,如hibernate,mybatis等,...

空空如也

空空如也

1 2 3 4
收藏数 61
精华内容 24
关键字:

频繁地与数据库建立连接