您的位置: 首页  >  IT文章  >  获取数据库连接（普普通通方式和数据源的方式）

获取数据库连接（普普通通方式和数据源的方式）

分类: IT文章 • 2022-07-30 19:53:22
获取数据库连接（普通方式和数据源的方式）

第一步：创建一个JavaWeb工程，工程名为DBConnPrjTest（此工程名是变量）

第二步：在DBConnPrjTest\WebRoot\WEB-INF\lib下，加入以下包，并加载到工程中：

  1. commons-logging-1.1.1.jar
  2. ojdbc14.jar：oracle数据库的jdbc驱动包
  3. proxool-0.9.1.jar：目前市面上三个主流连接池从性能上排名如下：proxool>c3p0>dbcp，proxool还提供了可视化的连接池实时监控工具，所以既稳定又方便，配置也是非常容易的事情
  4. proxool-cglib.jar
  5. 可以从http://proxool.sourceforge.net/站点上下载我们需要的资源，proxool-0.9.1是最新版本，解压后从lib下copy里面的2个JAR包 proxool-0.9.1.jar和  proxool-cglib.jar至项目中的DBConnPrjTest\WebRoot\WEB-INF\lib目录下。如果不加proxool-cglib.jar的话会报 java.lang.ClassNotFoundException:org.logicalcobwebs.cglib.proxy.Callback异

第三步：在DBConnPrjTest\src\conf下，创建以下两个配置文件：

  1. DBConfig.properties：用于普通方式获取数据库连接
  2. proxool.xml：用于数据源方式获取数据库连接

    DBConfig.properties

driver=oracle.jdbc.driver.OracleDriver
url=jdbc:oracle:thin:@db_ip:db_port:db_sid
user=db_username
password=db_password 

 

    proxool.xml

<?xml version="1.0" encoding="UTF-8"?>
<myPool>
	<proxool>
	    <!--数据源的别名--> 
		<alias>DataSource</alias>
		<!--url连接串--> 
		<driver-url>jdbc:oracle:thin:@192.168.2.36:1521:orcl</driver-url>
		<!--驱动类-->
		<driver-class>oracle.jdbc.driver.OracleDriver</driver-class>
		<!-- 驱动属性 -->
		<driver-properties>
			<!-- 用户名 -->
			<property name="user" value="cms" />
			<!-- 密码 -->
			<property name="password" value="temobi" />
		</driver-properties>
		
		<!-- 允许最大连接数(默认5个),超过了这个连接，再有请求时，就排在队列中等候，最大的等待请求数由maximum-new-connections决定-->
		<maximum-connection-count>60</maximum-connection-count>
		<!-- 最小连接数(默认2个)--> 
		<minimum-connection-count>5</minimum-connection-count>	
		
        <!--proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁 默认30秒-->
		<house-keeping-sleep-time>120000</house-keeping-sleep-time>
		<!--用于保持连接的测试语句 -->
		<house-keeping-test-sql>select 1 from dual</house-keeping-test-sql>
		
		<!--没有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受-->
		<!-- 以下配置已经不推荐使用了，用simultaneous-build-throttle代替 -->  
		<!-- <maximum-new-connections>10</maximum-new-connections> --> 
		
	    <!-- 某一时间点的最大连接数数-->
		<simultaneous-build-throttle>50</simultaneous-build-throttle>   
		
		<!--最少保持的空闲连接数(默认2个)-->
		<prototype-count>0</prototype-count>
		
		<!--在使用之前测试-->  
		<test-before-use>true</test-before-use>
		
		<!-- 连接最大生命时间 默认4小时 单位：秒-->
		<maximum-connection-lifetime>600000</maximum-connection-lifetime>
		<!-- 连接最大时间活动 默认5分钟 单位：秒-->
		<maximum-active-time>600000</maximum-active-time>
	</proxool>
</myPool>

 第四步：创建java类：

  1. 在DBConnPrjTest\src\com\jdbc下，创建ConnectionUtil.java
  2. 在DBConnPrjTest\src\com\proxool下，创建ConnectionManager.java，ConnectionTool.java，DBResourceHelper.java

    ConnectionUtil.java

/*
 * 文 件 名:  ConnectionUtil.java
 * 描    述:  普通方式的数据库连接工具类
 * 修 改 人:  Administrator
 */
package com.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Properties;

/**
 * 数据库连接工具类
 * @author  Administrator
 */
public class ConnectionUtil
{
    /**
     * 写死数据库连接的相关信息，从而获取连接
     */
    public Connection getConnection()
    {
        Connection conn = null;
        try
        {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager
                    .getConnection("jdbc:mysql://localhost:3306/jdbc_db",
                            "root", "mysqladmin");
            return conn;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 通过传参的方式获取数据库连接
     * @param driver 数据库驱动类型
     * @param url 数据库连接字符串
     * @param user 数据库用户
     * @param password 数据库密码
     */
    public Connection getConnection(String driver, String url, String user,
            String password)
    {
        Connection conn = null;
        try
        {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, user, password);
            return conn;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 通过读取properties文件配置信息，来获取数据库连接
     */
    public Connection openConnection()
    {
        String driver = "";
        String url = "";
        String user = "";
        String password = "";
        //Properties 类表示了一个持久的属性集。
        //Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
        Properties prop = new Properties();
        Connection conn = null;
        try
        {
            //将DBConfig.properties文件的属性列表输出到指定的输出流
            prop.load(this.getClass().getClassLoader().getResourceAsStream(
                    "conf/DBConfig.properties"));
            driver = prop.getProperty("driver");
            url = prop.getProperty("url");
            user = prop.getProperty("user");
            password = prop.getProperty("password");
            Class.forName(driver);
            conn = DriverManager.getConnection(url, user, password);
            return conn;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }

    public static void main(String[] args)
    {
        ConnectionUtil cu = new ConnectionUtil();
        System.out.println("数据库连接：  "+ cu.openConnection());
    }
}

 

   ConnectionManager.java

/*
 * 文 件 名:  ConnectionManager.java
 * 描    述:  连接池方式的数据库连接管理类
 * 修 改 人:  Administrator
 */
package com.proxool;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

import org.logicalcobwebs.proxool.ProxoolDataSource;
import org.logicalcobwebs.proxool.ProxoolException;
import org.logicalcobwebs.proxool.configuration.JAXPConfigurator;

/**
 * 数据库连接管理类
 * 
 * @author Administrator
 */
public class ConnectionManager
{
    private static final String ALIAS = "DataSource";

    private static ProxoolDataSource cmsds = null;
    static
    {
        initDataSource();
    }

    /**
     * 初始化数据源
     */
    private static boolean initDataSource()
    {
        InputStreamReader reader = null;
        try
        {
            // 实例化一个File对象
            File proxoolFile = new File(
                    "E:/workspace/DBConnPrjTest/src/conf/proxool.xml");
            if (proxoolFile.exists())
            {
                reader = new InputStreamReader(new FileInputStream(proxoolFile));
            }
            else
            {
                reader = new InputStreamReader(
                        Thread
                                .currentThread()
                                .getContextClassLoader()
                                .getResourceAsStream(
                                        "E:/workspace/DBConnPrjTest/src/conf/proxool.xml"));
            }

            // Java应用中先要加载配置文件，否则谁知道你配置给谁用的
            JAXPConfigurator.configure(reader, false);
            // 要据proxool中的数据源别名，实例化一个数据源对象
            cmsds = new ProxoolDataSource(ALIAS);
            return true;
        }
        catch (Exception e)
        {
            e.printStackTrace();
            return false;
        }
        finally
        {
            if (reader != null)
            {
                try
                {
                    reader.close();
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 取连接
     */
    public static Connection getConnection1()
    {
        if (cmsds == null)
        {
            return null;
        }
        try
        {
            return cmsds.getConnection();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }

    public static Connection getConnection2()
    {
        Connection conn = null;

        try
        {
            // Java应用中先要加载配置文件，否则谁知道你配置给谁用的
            JAXPConfigurator.configure(
                    "E:/workspace/DBConnPrjTest/src/conf/proxool.xml", false);

            // 1：注册驱动类，这次这个驱动已经不是Oracle的驱动了，是Proxool专用的驱动
            Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");
            // 2：创建数据库连接，这个参数是一个字符串，是数据源的别名，在配置文件中配置的DataSource，参数格式为：proxool.数据源的别名
            conn = DriverManager.getConnection("proxool.DataSource");
        }
        catch (ProxoolException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (ClassNotFoundException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (SQLException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return conn;
    }

    public static void main(String[] args)
    {
        try
        {
            // System.out.println(cmsds);
            // System.out.println("连接：" + cmsds.getConnection());
            // System.out.println(ConnectionManager.getConnection1());
            // ProxoolFacade.shutdown();
            System.out.println(ConnectionManager.getConnection2());
            // ProxoolFacade.shutdown();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

 

   ConnectionTool.java

/*
 * 文 件 名:  ConnectionTool.java
 * 描    述:  连接池方式的数据库连接工具类
 * 修 改 人:  Administrator
 */
package com.proxool;

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

import org.logicalcobwebs.proxool.ProxoolException;
import org.logicalcobwebs.proxool.configuration.JAXPConfigurator;

/**
 * 数据库连接工具类
 * @author Administrator
 */
public class ConnectionTool
{
    public static Connection getConnection()
    {
        Connection conn = null;

        try
        {
            // Java应用中先要加载配置文件，否则谁知道你配置给谁用的
            JAXPConfigurator.configure(
                    "E:/workspace/DBConnPrjTest/src/conf/proxool.xml", false);

            // 1：注册驱动类，这次这个驱动已经不是Oracle的驱动了，是Proxool专用的驱动
            Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");
            // 2：创建数据库连接，这个参数是一个字符串，是数据源的别名，在配置文件中配置的DataSource，参数格式为：proxool.数据源的别名
            conn = DriverManager.getConnection("proxool.DataSource");
        }
        catch (ProxoolException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (ClassNotFoundException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (SQLException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return conn;
    }

    public static void main(String[] args)
    {
        System.out.println(ConnectionTool.getConnection());
    }
}

 

 

    DBResourceHelper.java

/*
 * 文 件 名:  DBResourceHelper.java
 * 描    述:  数据库资源的帮助类
 * 修 改 人:  Administrator
 */
package com.proxool;

import java.sql.*;

/**
 * 关闭数据库资源
 * 
 * @author Administrator
 */
public class DBResourceHelper
{
    private DBResourceHelper()
    {
    }

    /**
     * 关闭连接
     */
    static public void closeConnection(Connection conn)
    {
        if (conn != null)
        {
            try
            {
                conn.close();
            }
            catch (Exception e)
            {
            }
        }
    }

    /**
     * 关闭执行静态 SQL 语句所生成的结果对象
     */
    static public void closeStatement(Statement stat)
    {
        if (stat != null)
        {
            try
            {
                stat.close();
            }
            catch (Exception e)
            {
            }
        }
    }

    /**
     * 关闭结果集对象
     */
    static public void closeResultSet(ResultSet rs)
    {
        if (rs != null)
        {
            try
            {
                rs.close();
            }
            catch (Exception e)
            {
            }
        }
    }

    /**
     * 回滚
     */
    static public void rollbackConnection(Connection conn)
    {
        if (conn != null)
        {
            try
            {
                conn.rollback();
            }
            catch (Exception e)
            {
            }
        }
    }

    /**
     * 自动提交
     */
    static public void setConnectionAutoCommit(Connection conn,
            boolean autoCommit)
    {
        if (conn != null)
        {
            try
            {
                conn.setAutoCommit(autoCommit);
            }
            catch (Exception e)
            {
            }
        }
    }
}

 

相关推荐