集合框架类、JUNIT单元测试、数据库连接池

时间：2022-03-26 19:21:06

讲解知识点：

（1）集合框架类
（2）JUNIT单元测试
（3）数据库连接池

内容记录：

（1）集合框架类

任务：向List、Set、Map内放置数据，并输出。

CollectionTest.java

package cn.sdut.test;
import java.util.*;

public class CollectionTest {
public static void main(String[] args) {
    /*  List list=new ArrayList();
        list.add("abc");
        list.add("def");
        list.add("fgh");
        list.add("abc");
        System.out.println(list.size());


for(int i=0;i<list.size();i++)
        {
            System.out.println(list.get(i));
        }
        System.out.println();
//long t2=System.currentTimeMillis();
//long t2=System.nanaTime();

for(Object obj:list)
        {
            System.out.println(obj);
        }

        System.out.println();
        Iterator it=list.iterator();
while(it.hasNext())
        {
            Object obj=it.next();
            System.out.println(obj);
        }
        */
        /*
        Set set=new HashSet();
        set.add("abc");
        set.add("def");
        set.add("aaa");
        set.add("abc");
        System.out.println(set.size());


// for(int i=0;i<set.size();i++)
// {
// System.out.println(set.get(i));
// }
// System.out.println();


for(Object obj:set)
        {
            System.out.println(obj);
        }

        System.out.println();
        Iterator it=set.iterator();
while(it.hasNext())
        {
            Object obj=it.next();
            System.out.println(obj);
        }*/

        Map map=new HashMap();
        map.put("abc", 123);
        map.put("bcd", 456);
        map.put("def", 789);
        map.put("abc", 999);
        System.out.println(map.size());
        System.out.println(map);
        //第一种输出Map对象
Set keySet=map.keySet();
        Iterator itKey=keySet.iterator();
        while(itKey.hasNext())
        {
            Object key=itKey.next();
            Object value=map.get(key);
            System.out.println(key+"--"+value);
        }

        //第二种输出Map对象
        Collection c=map.values();
        for(Object obj:c)
        {
            System.out.println(obj);
        }

        Iterator itValue=c.iterator();
        while(itValue.hasNext())
        {
            System.out.println(itValue.next());
        }
        //第三种方式输出Map
Set entrySet=map.entrySet();
        Iterator itEntry=entrySet.iterator();
        while(itEntry.hasNext())
        {
            Map.Entry   entry=(Map.Entry)itEntry.next();****
            Object key=entry.getKey();
            Object value=entry.getValue();
            System.out.println(key+"=="+value);
        }       
    }
}

**Iterator itEntry=map.entrySet().iterator();

**Iterator itKey=map.keySet().iterator();

**Iterator itValue=map.values().iterator();

（2）JUNIT单元测试

步骤：加载JUNIT4类库；在项目中新建source folder（test），在test源目录中建立与被测试的类相对应的包，建立测试单元，编写代码，进行测试。

Calculator.java

package cn.sdut.test;

public class Calculator {
int a;
int b;
public Calculator(int a,int b)
   {
this.a=a;
this.b=b;
   }
public int add()
   {
return a+b;
   }
public int sub()
   {
return a-b;
   }
public int mul()
   {
return a*b;
   }
public int div()
   {
return a/b;
   }
}

CalculatorTest.java

package cn.sdut.test;

import static org.junit.Assert.*;

import org.junit.Test;

public class CalculatorTest {

@Test
public void testAdd()
    {
        Calculator cal=new Calculator(10, 2);
        assertEquals( cal.add(),12);
    }



@Test
public void testSub()
    {
        Calculator cal=new Calculator(10, 2);
        assertEquals( cal.sub(),8);
    }

@Test
public void testMul()
    {
        Calculator cal=new Calculator(10, 2);
        assertEquals( cal.mul(),20);
    }


@Test(expected=ArithmeticException.class)
public void testDiv()
    {
        Calculator cal=new Calculator(10,0);
        assertEquals( cal.div(),5);     
    }
}

（3）数据库连接池

(数据库连接池：C3P0、DBCP)

1、数据库连接池技术的优点：

•资源重用：

数据库连接得以重用——避免频繁创建“数据库连接，释放连接”引起的大量性能开销。在减少系统消耗的基础上，另一方面也增加了系统运行环境的平稳性。

•更快的系统反应速度：

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

•新的资源分配手段：

对于多应用共享同一数据库的系统，可在应用层通过数据库连接池的配置，实现某一应用最大可用数据库连接数的限制，避免其独占所有的数据库资源。

•统一的连接管理，避免数据库连接泄露：

在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露。

1）两种开源的数据库连接池：

• JDBC 的数据库连接池使用 javax.sql.DataSource 来表示，DataSource 只是一个接口，

该接口通常由服务器(Weblogic, WebSphere, Tomcat)提供实现，也有一些开源组织提供实现：
–DBCP 数据库连接池（Apache 软件基金组织）
–C3P0 数据库连接池

• DataSource被称为数据源，它包含连接池和连接池管理两个部分，习惯上也经常把 DataSource 称为连接池。

A:DBCP 数据源 ：

• DBCP 是 Apache 软件基金组织下的开源连接池实现，该连接池依赖该组织下的另一个开源系统：Common-pool。因此，实现连接池，应在系统中增加如下两个 jar 文件：

–commons-dbcp.jar：连接池的实现。
–commons-pool.jar：连接池实现的依赖库。

• Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。

DBCP 数据源使用范例：

• 数据源和数据库连接不同——数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。

• 当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close(); 但它并没有关闭数据库的物理连接，仅仅把数据库连接释放，归还给了数据库连接池。

dbcp.properties
username=root
password=usbw
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/school

initialSize=10
maxActive=50
minIdle=5
maxWait=5000

DBCPUtils.java

package cn.sdut.util;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;
public class DBCPUtils {
    static DataSource datasource;

    public static Connection getConn(){
        Connection con=null;
        Properties props=new Properties();
        try {
            props.load(DBCPUtils.class.getResourceAsStream("/dbcp.properties"));
            datasource=BasicDataSourceFactory.createDataSource(props);
            con= datasource.getConnection();

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return con;
    }

    public static Connection getConn2(){
        Connection con=null;
        BasicDataSource datasource=new BasicDataSource();
        datasource.setUsername("root");
        datasource.setPassword("usbw");
        datasource.setUrl("jdbc:mysql://localhost:3306/school");
        datasource.setDriverClassName("com.mysql.jdbc.Driver");
        datasource.setInitialSize(5);
        datasource.setMaxActive(20);
        datasource.setMinIdle(3);
        datasource.setMaxWait(5000);
        try {
            con=datasource.getConnection();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return con;
    }
public static void main(String[] args) {
    Connection con1=getConn();
    System.out.println(con1);
    Connection con2=getConn2();
    System.out.println(con2);
}
}
B：C3P0 数据源
c3p0.properties
c3p0.user=root
c3p0.password=usbw
c3p0.driverClass=com.mysql.jdbc.Driver
c3p0.jdbcUrl=jdbc\:mysql\://localhost\:3306/school

C3P0Utils.java

package cn.sdut.util;

import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.SQLException;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Utils {
public static Connection getConn1() {
        Connection con = null;
        ComboPooledDataSource ds = new ComboPooledDataSource();
try {
            con = ds.getConnection();
        } catch (SQLException e) {
// TODO Auto-generated catch block
            e.printStackTrace();
        }
return con;
    }

public static Connection getConn2() {
        Connection con = null;
        ComboPooledDataSource ds = new ComboPooledDataSource();
try {
            ds.setUser("root");
            ds.setPassword("usbw");
            ds.setDriverClass("com.mysql.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/school");
            ;
            con = ds.getConnection();
        } catch (PropertyVetoException e) {
// TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
// TODO Auto-generated catch block
            e.printStackTrace();
        }

return con;
    }

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

参考阅读：http://liuzhijun.iteye.com/blog/1286395
C3p0源码探索（一）之配置篇

C3p0源码探索（一）之配置篇

所需文件：
1、 c3p0-0.9.1.2.jar http://sourceforge.net/projects/c3p0/
2、 mysql.jar http://dev.mysql.com/downloads/connector/j/5.0.html
3、 c3p0-0.9.1.2http://nchc.dl.sourceforge.net/sourceforge/c3p0/c3p0-0.9.1.2.src.zip(可选)
拥有以上三样东西就可以开始c3p0之旅了,把mysql.jar和c3p0-0.9.1.2.jar放到classpath中就可以开始编写我们的代码了。

C3p0最简单的使用方式就如其官网下所说的一样，只需提供driverName,url,user,password,程序就可以跑起来。

第一种获取数据源的方式：

Java代码 

ComboPooledDataSource cpds = new ComboPooledDataSource(); 
      String driverClass = "com.mysql.jdbc.Driver"; 
      String jdbcURL = "jdbc:mysql://localhost:3306/test"; 
      String user = "root"; 
      String password = ""; 
      cpds.setDriverClass(driverClass); 
      cpds.setJdbcUrl(jdbcURL); 
      cpds.setUser(user); 
      cpds.setPassword(password); 
      cpds.setMaxStatements(100); 
      Connection conn = cpds.getConnection();

正如简单的jdbc连接数据库一样仅仅只需要这些参数而已。

对于这种配置，如果classpath中有c3p0.properties的配置文件，代码中不需要设置连接信息，直接new ComboPooledDataSource(),它会自动读取配置文件中的配置。当然也可以使用c3p0-config.xml文件配置连接信息，使用xml作为配置信息的话，comboPoolDataSource还可以接受一个String参数，这个参数的名称是在c3p0-config.xml文件中配置，这就意味着我们可以在xml文件中可有都多个数据库源连接信息，比如可以是mysql，oracle的。

Java代码 

ComboPooledDataSource cpds = new ComboPooledDataSource(“test”);  
<named-config name="test">  
<property name="maxStatements">200</property> 
<propertyname="jdbcUrl">jdbc:mysql://localhost:3306/test</property>  
<property name="user">root</property>  
<property name="password"></property>  
</named-config>

使用配置文件的方式连接时，c3p0默认在classpath根目录读取配置文件，如果想把配置文件放在自己想放的地方只需设置系统属性。

Java代码 

System.setProperties(“com.mchange.v2.c3p0.cfg.xml”,”config/c3p0-config.xml”);

程序就在指定的目录下读取该配置文件。

第二种方式获取数据源,使用数据源工厂类DataSources

Java代码 

DataSource ds = DataSources.unpooledDataSource(jdbcURL, user, password); 
DataSource pooledDateSource = DataSources.pooledDataSource(ds); 
      System.out.println(pooledDateSource.getConnection());

第三种获取数据源的方式：

Java代码

PoolBackedDataSource backedDataSource = new PoolBackedDataSource();  
backedDataSource.setConnectionPoolDataSource(new ConnectionPoolDataSource() );  
//实现自己的connectionpooldatasource即可

参数配置：
除了以上连接数据库必要的参数外，提供以下最基本的参数配置信息才能形成数据库连接池
1、 acquireIncrement 每次连接增加数量
2、 initalPoolSize 初始连接数
3、 maxPoolSize 最大连接数
4、 maxIdleTime 最大空闲数
5、 minPoolSize 池中连接最小数量

Tomcat中配置c3p0的方法：

1、server.xml中配置

Xml代码 

<GlobalNamingResources>  
<!-- Editable user database that can also be used by 
 UserDatabaseRealm to authenticate users 
 -->  
<Resource name="jdbc/test" 
auth="Container" 
description="User database that can be updated and saved" 
factory="org.apache.naming.factory.BeanFactory" 
driverClass="com.mysql.jdbc.Driver" 
maxPoolSize="4" 
minPoolSize="2" 
acquireIncrement="1" 
user="root" 
password="" 
type="com.mchange.v2.c3p0.ComboPooledDataSource" 
jdbcUrl="jdbc:mysql://localhost:3306/test" />  
</GlobalNamingResources>

2、 conf目录下Context.xml

 <ResourceLink name="jdbc/test" global="jdbc/test" type="javax.sql.DataSource"/>

3、 web.xml

Xml代码 

<resource-ref>  
<res-ref-name>jdbc/ test</res-ref-name>  
<res-type>javax.sql.DataSource</res-type>  
<res-auth>Container</res-auth>  
</resource-ref>

测试：

Java代码 

InitialContext context = new InitialContext();  
return (DataSource) context.lookup("java:comp/env/jdbc/test");
标签：

相关文章