数据库_jdbc_连接池+框架_改造分页案例

dbcpconfig.properties位于src目录

#连接设置
driverClassName=com.mysql.jdbc.Driver
#url=jdbc:mysql://localhost:3306/day16
url=jdbc:mysql://localhost:3306/day14_customer
username=root
password=root
#<!-- 初始化连接 -->
initialSize=10
#最大连接数量
maxActive=50
#<!-- 最大空闲连接 -->
maxIdle=20
#<!-- 最小空闲连接 -->
minIdle=5
#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 即等1分钟后仍没连接,这时才告诉人家,呆会再来,暂无连接! -->
maxWait=60000
#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;] 
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=utf8
#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true
#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=
#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_COMMITTED

JdbcUtils位于utils包

package cn.itcast.utils;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
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;

import cn.itcast.exception.DaoException;
/**利用开源数据库连接池DBCP,创建自己的JDBC框架!
DBCP内部增强Connection的close方法使用的是装饰模式!
1,导入两个jar包到工程下的lib目录,变成奶瓶
commons-dbcp-1.2.2.jar
commons-pool.jar
2,设置src下的dbcpconfig.properties配置文件信息如库名!
3,定义静态成员DataSource记住DBCP创建出来的数据源(即连接池)
4,静态代码块中用BasicDataSourceFactory创建数据源(即连接池)
5,定义获取连接的方法
6,定义释放连接的方法
7,定义统一的update方法(增删改)
8,定义统一的查询方法(使用策略设计模式)*/
public class JdbcUtils {
	//定义成员记住DBCP创建出来的数据源(即连接池)
  private static DataSource ds;
  static{
		try {
			String pro_name="dbcpconfig.properties";
		    InputStream in=JdbcUtils.class.getClassLoader().getResourceAsStream(pro_name);
		    Properties pro = new Properties();
		    pro.load(in);
		  //DBCP连接池--固定代码:由工厂创建数据源(即连接池)
		    BasicDataSourceFactory factory=new BasicDataSourceFactory();
		    //用类成员记住根据配置文件创建出来的连接池!
		    ds=factory.createDataSource(pro);
		} catch (Exception e) {
			throw new ExceptionInInitializerError(e);
		}
	}
  //方法1:从连接池中获取已装饰过的连接
  public static Connection getConnection() throws SQLException{
	  	//DBCP在生成连接的时候已经装饰过Connection,
		//覆写了close方法,即归还到数据源(即连接池)
		return ds.getConnection();
  }
  //方法2:释放连接标准步骤!
  public static void release(Connection conn,Statement st,ResultSet rs){
    if (conn!=null) {
      try {
        conn.close();
      }catch (Exception e) {
        //只能记录!一旦抛出,后面的2条if代码就无法执行了
        e.printStackTrace();
      }
      conn=null;
    }
    if (st!=null) {
      try {
        st.close();
      }catch (Exception e) {
        //只能记录!一旦抛出,后面的1条if代码就无法执行了
        e.printStackTrace();
      }
      st=null;
    }
    if (rs!=null) {
      try {
        rs.close();
      }catch (Exception e) {
        e.printStackTrace();
      }
      rs=null;
    }
  }
  //方法3:定义统一的update方法(增删改)
  public static void update(String sql,Object[] params) throws SQLException{
	  Connection conn = null;
      PreparedStatement st = null;
      ResultSet rs = null;      
      try{
         conn = JdbcUtils.getConnection();
         st = conn.prepareStatement(sql);       
         //应该分情况讨论:参数数组为null或空,直接执行sql
         if(params==null || params.length==0){
        	 st.executeUpdate();
        	 return;
         }
         //否则用参数数组替换掉sql中的所有问号!
         for(int i=0;i<params.length;i++){
			//第1个参数是1,第2个参数是2,依此类推
        	 System.out.println(i);
			st.setObject(i+1,params[i]);
		 }
		 //替换完毕,执行完整的sql语句(增删改)
         st.executeUpdate();
      }finally{
         JdbcUtils.release(conn, st, rs);
      }
  }
  //方法4:定义统一的query方法(查询)
  public static Object query(String sql,Object[] params,ResultSetHandler rsh) throws SQLException{
	  Connection conn = null;
      PreparedStatement st = null;
      ResultSet rs = null;      
      try{
         conn = JdbcUtils.getConnection();
         st = conn.prepareStatement(sql);       
         //应该分情况讨论:只有参数数组不为null或长度不为0,才进行参数替换!
         if(params!=null || params.length!=0){
        	 //用参数数组替换掉sql中的所有问号!
        	 for(int i=0;i<params.length;i++){
        		 //第1个参数是1,第2个参数是2,依此类推
        		 st.setObject(i+1,params[i]);
        	 }
         }
         //替换完毕,执行完整的sql语句(查询)
         rs=st.executeQuery();
         //我拿到结果不知道怎么处理,于是采用策略模式:
         //对外暴露一个ResultSetHandler接口,由调用该方法的人实现接口,
         //我再对其调用,将人家处理后的结果返回!
         return rsh.handle(rs);
      }finally{
         JdbcUtils.release(conn, st, rs);
      }
  }
}

JdbcUtils_Old位于utils包

package cn.itcast.utils;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class JdbcUtils_Old {
  private static Properties pro=new Properties();
  /*
   * 静态成员Properties
   * 静态代码块:加载配置文件,注册驱动
   * 静态方法1:获取连接
   * 静态方法2:释放连接
   * 工具类的异常只管抛,也可以转型后抛
   * db.properties文件位于类目录下即src
   */
  static{
    String pro_name="db.properties";
    InputStream in=JdbcUtils_Old.class.getClassLoader().getResourceAsStream(pro_name);
    try {
      pro.load(in);
      Class.forName(pro.getProperty("driver"));
    } catch (Exception e) {
      // 静态代码块的异常只能转型后抛出
      throw new ExceptionInInitializerError(e);
    }
  }
  //方法1:获取连接
  public static Connection getConnection() throws SQLException{
    String url=pro.getProperty("url");
    String user=pro.getProperty("user");
    String password=pro.getProperty("password");
    Connection conn=DriverManager.getConnection(url, user, password);
    return conn;
  }
  //方法2:释放连接
  public static void release(Connection conn,Statement st,ResultSet rs){
    if (conn!=null) {
      try {
        conn.close();
      }catch (Exception e) {
        //只能记录!一旦抛出,后面的2条if代码就无法执行了
        e.printStackTrace();
      }
      conn=null;
    }
    if (st!=null) {
      try {
        st.close();
      }catch (Exception e) {
        //只能记录!一旦抛出,后面的1条if代码就无法执行了
        e.printStackTrace();
      }
      st=null;
    }
    if (rs!=null) {
      try {
        rs.close();
      }catch (Exception e) {
        e.printStackTrace();
      }
      rs=null;
    }
  }
}

创建库和表

mysql -uroot -proot
set character_set_client=gb2312;
set character_set_results=gb2312;
create database day14_customer character set utf8 collate utf8_general_ci;
use day14_customer;
create table customer(
	id varchar(40) primary key,
	name varchar(40) not null,
	gender varchar(4) not null,
	birthday date,
	cellphone varchar(20),
	email varchar(40),
	preference varchar(255),
	type varchar(100) not null,
	description varchar(255)
);
select * from customer;

ResultSetHandler位于utils包

package cn.itcast.utils;
import java.sql.ResultSet;
//由于拿到了结果集,不知如何处理,即不知道封装到哪儿去!
//所以对外暴露一个接口,由调用该方法的人实现该接口,我再对其调用!策略模式!
public interface ResultSetHandler {
	public Object handle(ResultSet rs);
}

BeanHandler位于utils包

package cn.itcast.utils;
import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
public class BeanHandler implements ResultSetHandler {
	//该类是将结果集封装到bean里面!
	//为了知道该结果集处理器是将结果封装到哪个bean里面,
	//所以需要一个构造函数接收该bean的字节码文件对象,并赋值给成员!
	private Class clazz;
	public BeanHandler(Class clazz) {
		super();
		this.clazz = clazz;
	}
	public Object handle(ResultSet rs) {
		try {
			//首先分析结果集中有无数据
			if (!rs.next()) {
				return null;
			}
			//然后就准备一个bean实例接收!
			Object bean=clazz.newInstance();
			//获得结果集的元数据
			ResultSetMetaData  meta=rs.getMetaData();
			//从元数据中获得字段的数目
			int count=meta.getColumnCount();
			//循环每个字段,将值赋予给bean对应的成员
			for (int i = 0; i < count; i++) {
				//从元数据中获得字段的名称
				String columnName=meta.getColumnName(i+1);
				//从结果集获得该字段的值
				Object columnValue=rs.getObject(columnName);
				//通过反射,获取所有的类成员
				Field  field=bean.getClass().getDeclaredField(columnName);
				//打开类成员的暴力访问
				field.setAccessible(true);
				//为bean对象的成员赋值
				field.set(bean, columnValue);
			}
			//循环完毕即为bean对象的每个成员赋值!
			return bean;
		} catch (Exception e) {
			throw new RuntimeException();
		}
	}
}

BeanListHandler位于utils包

package cn.itcast.utils;
import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;
public class BeanListHandler implements ResultSetHandler {
	//该类是将结果集封装到bean里面,然后把所有的bean加到list集合里面!
	//为了知道该结果集处理器是将结果封装到哪个bean里面,
	//所以需要一个构造函数接收该bean的字节码文件对象,并赋值给成员!
	private Class clazz;
	public BeanListHandler(Class clazz) {
		this.clazz = clazz;
	}
	public Object handle(ResultSet rs) {
		//先准备一个集合
		List list=new ArrayList();
		try {
			//然后遍历每一条记录,将每一条记录封装到一个bean里面,并且bean添加到list
			while (rs.next()) {
				//准备一个bean实例接收一条记录!
				Object bean=clazz.newInstance();
				//获得结果集的元数据
				ResultSetMetaData  meta=rs.getMetaData();
				//从元数据中获得字段的数目
				int count=meta.getColumnCount();
				//循环每个字段,将值赋予给bean对应的成员
				for (int i = 0; i < count; i++) {
					//从元数据中获得字段的名称
					String columnName=meta.getColumnName(i+1);
					//从结果集获得该字段的值
					Object columnValue=rs.getObject(columnName);
					//通过反射,获取所有的类成员
					Field  field=bean.getClass().getDeclaredField(columnName);
					//打开类成员的暴力访问
					field.setAccessible(true);
					//为bean对象的成员赋值
					field.set(bean, columnValue);
				}
				//循环完毕即为bean对象的每个成员赋值!
				//将封装好了一条记录的bean加到list中!
				list.add(bean);
			}
			//最后,遍历完所有记录后,返回list
			return list;
		} catch (Exception e) {
			throw new RuntimeException();
		}
	}
}

IntegerHandler位于 utils 包

package cn.itcast.utils;
import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
public class IntegerHandler implements ResultSetHandler {
	//该类是将结果集封装到Integer里面!
	public Object handle(ResultSet rs) {
		try {
			//首先分析结果集中有无数据
			if (!rs.next()) {
				return 0;
			}
			//然后才返回统计数目:如select count(*) from 表名
			return rs.getInt(1);
		} catch (Exception e) {
			throw new RuntimeException();
		}
	}
}

CustomerDaoImpl位于 dao.impl 包

package cn.itcast.dao.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import cn.itcast.dao.CustomerDao;
import cn.itcast.domain.Customer;
import cn.itcast.domain.QueryResult;
import cn.itcast.exception.DaoException;
import cn.itcast.utils.BeanHandler;
import cn.itcast.utils.BeanListHandler;
import cn.itcast.utils.IntegerHandler;
import cn.itcast.utils.JdbcUtils;
public class CustomerDaoImpl implements CustomerDao {
  //方法1:添加一个Customer到数据库,返回值为void
  public void add(Customer c){
      try {
        //先准备String sql和参数数组,因为结果集是setObject无需转换new java.sql.Date(c.getBirthday().getTime())
        String fields="id,name,gender,birthday,cellphone,email,preference,type,description";
        String sql="insert into customer("+fields+") values(?,?,?,?,?,?,?,?,?)";
        Object[] params={
              c.getId(),c.getName(),c.getGender(),
              c.getBirthday(),
              c.getCellphone(),c.getEmail(),
              c.getPreference(),c.getType(),c.getDescription()
              };
        JdbcUtils.update(sql, params);
      }catch (Exception e) {
        //自定义Dao异常,是为了方便定义错误出在哪一层!
        throw new DaoException(e);
    }
  }
  //方法2:更新一个Customer到数据库,返回值为void
  public void update(Customer c){
      try {
       //先准备String sql和参数数组,因为结果集是setObject无需转换new java.sql.Date(c.getBirthday().getTime())
        String fields="name=?,gender=?,birthday=?,cellphone=?,email=?,preference=?,type=?,description=?";
        String sql="update customer set "+fields+" where id=?";
        Object[] params={c.getName(),c.getGender(),
              c.getBirthday(),
              c.getCellphone(),c.getEmail(),
              c.getPreference(),c.getType(),c.getDescription(),
              c.getId()};
        JdbcUtils.update(sql, params);
      }catch (Exception e) {
        throw new DaoException(e);
      }
  }
  //方法3:删除一个Customer从数据库,返回值为void
  public void delete(Customer c){
      try {
       //先准备String sql和参数数组
        String sql="delete from customer where id=?";
        Object[] params={c.getId()};
        JdbcUtils.update(sql, params);
      }catch (Exception e) {
        throw new DaoException(e);
    }
  }
  //方法4:通过id查询并返回一个封装好数据的Customer
  public Customer find(String id){
      try {
       //先准备String sql和参数数组
        String sql="select * from customer where id=?";
        Object[] params={id};
        return (Customer) JdbcUtils.query(sql, params, new BeanHandler(Customer.class));
      }catch (Exception e) {
        throw new DaoException(e);
    }
  }
  //方法5:返回一个封装了所有Customer的集合
  public List<Customer> getAll(){
      try {
       //先准备String sql和参数数组
        String sql="select * from customer";
        Object[] params={};
        return (List<Customer>) JdbcUtils.query(sql, params, new BeanListHandler(Customer.class));
      }catch (Exception e) {
        throw new DaoException(e);
    }  
}
  //方法6:两条SQL,先从数据库第N条开始查询M条记录,参数(N,M),先装list
  //再统计总的记录数,两个SQL语句的结果都封装到QueryResult对象并返回!
  public QueryResult pageQuery(int startIndex,int pageSize){
    QueryResult qr = new QueryResult();
    List<Customer> list=new ArrayList<Customer>();
    try {
      //第1个?索引从条记录开始,第2个?代表取多少条记录
     //并且将第1句SQL查询结果封装到list,再将集合添加到QueryResult(结果对象)
      String sql = "select * from customer limit ?,?";
      Object[] params={startIndex,pageSize};
      list=(List) JdbcUtils.query(sql, params,new BeanListHandler(Customer.class));
      //再将list添加到QueryResult(结果对象)
      qr.setList(list);  
      
      //执行第2条sql,将总记录数,封装到QueryResult
      sql="select count(*) from customer";
      params=new Object[]{};
      //因只有一列(总记录数),所以用IntegerHandler
      int totalRecord=(Integer) JdbcUtils.query(sql, params, new IntegerHandler());
        //总记录数 封装到QueryResult(结果对象)
        qr.setTotalRecord(totalRecord);
      //返回封装好所有数据(list,总记录数目)的QueryResult(结果对象)
      return qr;      
    } catch (Exception e) {
      throw new DaoException(e);
    }
  }
}

CustomerDaoImpl_Old位于 dao.impl 包

package cn.itcast.dao.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import cn.itcast.dao.CustomerDao;
import cn.itcast.domain.Customer;
import cn.itcast.domain.QueryResult;
import cn.itcast.exception.DaoException;
import cn.itcast.utils.JdbcUtils;
public class CustomerDaoImpl_Old implements CustomerDao {
  //方法1:添加一个Customer到数据库,返回值为void
  public void add(Customer c){
      Connection conn=null;
      PreparedStatement st=null;
      ResultSet rs=null;
      try {
        conn=JdbcUtils.getConnection();
        //先准备String sql,再通过连接准备PreparedStatement
        String fields="id,name,gender,birthday,cellphone,email,preference,type,description";
        String sql="insert into customer("+fields+") values(?,?,?,?,?,?,?,?,?)";
        st=conn.prepareStatement(sql);
        st.setString(1, c.getId());
        st.setString(2, c.getName());
        st.setString(3, c.getGender());
        //特别注意,setDate需要一个子类sql.Date
        st.setDate(4, new java.sql.Date(c.getBirthday().getTime()));
        st.setString(5, c.getCellphone());
        st.setString(6, c.getEmail());
        st.setString(7, c.getPreference());
        st.setString(8, c.getType());
        st.setString(9, c.getDescription());
        st.executeUpdate();
      }catch (Exception e) {
        //自定义Dao异常,是为了方便定义错误出在哪一层!
        throw new DaoException();
    }finally{
      JdbcUtils.release(conn, st, rs);
    }
  }
  //方法2:更新一个Customer到数据库,返回值为void
  public void update(Customer c){
    Connection conn=null;
      PreparedStatement st=null;
      ResultSet rs=null;
      try {
        conn=JdbcUtils.getConnection();
        //先准备String sql,再通过连接准备PreparedStatement
        String fields="name=?,gender=?,birthday=?,cellphone=?,email=?,preference=?,type=?,description=?";
        String sql="update customer set "+fields+" where id=?";
        st=conn.prepareStatement(sql);
        st.setString(1, c.getName());
        st.setString(2, c.getGender());
        //特别注意,setDate需要一个子类sql.Date
        st.setDate(3, new java.sql.Date(c.getBirthday().getTime()));
        st.setString(4, c.getCellphone());
        st.setString(5, c.getEmail());
        st.setString(6, c.getPreference());
        st.setString(7, c.getType());
        st.setString(8, c.getDescription());
        st.setString(9, c.getId());
        st.executeUpdate();
      }catch (Exception e) {
        throw new DaoException();
    }finally{
      JdbcUtils.release(conn, st, rs);
    }
  }
  //方法3:删除一个Customer从数据库,返回值为void
  public void delete(Customer c){
    Connection conn=null;
      PreparedStatement st=null;
      ResultSet rs=null;
      try {
        conn=JdbcUtils.getConnection();
        //先准备String sql,再通过连接准备PreparedStatement
        String sql="delete from customer where id=?";
        st=conn.prepareStatement(sql);
        st.setString(1, c.getId());
        st.executeUpdate();
      }catch (Exception e) {
        throw new DaoException();
    }finally{
      JdbcUtils.release(conn, st, rs);
    }
  }
  //方法4:通过id查询并返回一个封装好数据的Customer
  public Customer find(String id){
    Connection conn=null;
      PreparedStatement st=null;
      ResultSet rs=null;
      try {
        conn=JdbcUtils.getConnection();
        //先准备String sql,再通过连接准备PreparedStatement
        String sql="select * from customer where id=?";
        st=conn.prepareStatement(sql);
        st.setString(1, id);
        rs=st.executeQuery();
        if (rs.next()) {
        Customer c=new Customer();
        c.setId(rs.getString("id"));
        c.setName(rs.getString("name"));
        c.setGender(rs.getString("gender"));
        //形参是个父类util.Date,传参是个子类sql.Date,多态!
        c.setBirthday(rs.getDate("birthday"));
        c.setCellphone(rs.getString("cellphone"));
        c.setEmail(rs.getString("email"));
        c.setPreference(rs.getString("preference"));
        c.setType(rs.getString("type"));
        c.setDescription(rs.getString("description"));
        return c;
        }
        return null;
      }catch (Exception e) {
        throw new DaoException();
    }finally{
      JdbcUtils.release(conn, st, rs);
    }
  }
  //方法5:返回一个封装了所有Customer的集合
  public List<Customer> getAll(){
      Connection conn=null;
      PreparedStatement st=null;
      ResultSet rs=null;
      try {
        conn=JdbcUtils.getConnection();
        //先准备String sql,再通过连接准备PreparedStatement
        String sql="select * from customer";
        st=conn.prepareStatement(sql);
        rs=st.executeQuery();
        List<Customer> list=new ArrayList<Customer>();
        while (rs.next()) {
        Customer c=new Customer();
        c.setId(rs.getString("id"));
        c.setName(rs.getString("name"));
        c.setGender(rs.getString("gender"));
        //形参是个父类util.Date,传参是个子类sql.Date,多态!
        c.setBirthday(rs.getDate("birthday"));
        c.setCellphone(rs.getString("cellphone"));
        c.setEmail(rs.getString("email"));
        c.setPreference(rs.getString("preference"));
        c.setType(rs.getString("type"));
        c.setDescription(rs.getString("description"));
        list.add(c);
       }
        return list;
      }catch (Exception e) {
        throw new DaoException();
    }finally{
      JdbcUtils.release(conn, st, rs);
    }
  }
  //方法6:两条SQL,先从数据库第N条开始查询M条记录,参数(N,M),先装list
  //再统计总的记录数,两个SQL语句的结果都封装到QueryResult对象并返回!
  public QueryResult pageQuery(int startIndex,int pageSize){
    //SQL查询模板代码(sql_s)
    Connection conn = null;
    PreparedStatement st = null;
    ResultSet rs = null;
    QueryResult qr = null;
    try {
      conn = JdbcUtils.getConnection();
      //第1个?索引从条记录开始,第2个?代表取多少条记录
      String sql = "select * from customer limit ?,?";
      st = conn.prepareStatement(sql);
      st.setInt(1, startIndex);
      st.setInt(2, pageSize);
      rs = st.executeQuery();
      //将第1句SQL查询结果封装到list,再将集合添加到QueryResult(结果对象)
       List<Customer> list=new ArrayList<Customer>();
      while (rs.next()) {
        Customer c=new Customer();
        c.setId(rs.getString("id"));
        c.setName(rs.getString("name"));
        c.setGender(rs.getString("gender"));
        //形参是个父类util.Date,传参是个子类sql.Date,多态!
        c.setBirthday(rs.getDate("birthday"));
        c.setCellphone(rs.getString("cellphone"));
        c.setEmail(rs.getString("email"));
        c.setPreference(rs.getString("preference"));
        c.setType(rs.getString("type"));
        c.setDescription(rs.getString("description"));
        list.add(c);
      }
      //再将list添加到QueryResult(结果对象)
      qr=new QueryResult();
      qr.setList(list);  
      //执行第2条sql,将总记录数,封装到QueryResult
      sql="select count(*) from customer";
      st=conn.prepareStatement(sql);
      rs=st.executeQuery();
      //因只有一列,所以用if
      if (rs.next()) {
        //总记录数 封装到QueryResult(结果对象)
        qr.setTotalRecord(rs.getInt(1));//注意是int类型
        //也可以使用列名rs.getInt("count(*)");
        //qr.setTotalRecord(rs.getInt("count(*)"));
      }
      //返回封装好所有数据(list,总记录数目)的QueryResult(结果对象)
      return qr;      
    } catch (Exception e) {
      throw new DaoException(e);
    } finally {
      JdbcUtils.release(conn, st, rs);
    }
  }
}
/*JDBCIMPL模板代码!
      Connection conn=null;
      PreparedStatement st=null;
      ResultSet rs=null;
      try {
        conn=JdbcUtils.getConnection();
        //先准备String sql,再通过连接准备PreparedStatement
        String sql="?";
        st=conn.prepareStatement(sql);
        st.setString(1, "");
        int num=st.executeUpdate();
        rs=st.executeQuery();
      }catch (Exception e) {
        throw new DaoException();
    }finally{
      JdbcUtils.release(conn, st, rs);
    }
*/

batchinsert位于 junit.test 包

package junit.test;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import cn.itcast.exception.DaoException;
import cn.itcast.utils.JdbcUtils;
import cn.itcast.utils.WebUtils;
public class batchinsert {
	//批量插入!
  public static void main(String[] args) {
     Connection conn=null;
      PreparedStatement st=null;
      ResultSet rs=null;
    try {
      conn=JdbcUtils.getConnection();
        //先准备String sql,再通过连接准备PreparedStatement
        String fields="id,name,gender,preference,type";
        String sql="insert into customer("+fields+") values(?,?,?,?,?)";
        st=conn.prepareStatement(sql);
       //批量插入
        for(int i=0;i<200;i++){
            st.setString(1, WebUtils.generateId() + i);
            st.setString(2, "妙玉" + i);
            st.setString(3, "女");
            st.setString(4, "诗词");
            st.setString(5, "尼姑");
            st.addBatch();
            if(i%50==0){
              //避免内存溢出,每50条执行一次后清空!
                st.executeBatch();
                st.clearBatch();
            }
        }
        st.executeBatch();
    } catch (Exception e) {
        //自定义Dao异常,是为了方便定义错误出在哪一层!
        throw new DaoException();
    }finally{
      JdbcUtils.release(conn, st, rs);
    }
  }
}

test_find位于 junit.test 包

package junit.test;
import java.util.List;
import org.junit.Test;
import cn.itcast.dao.impl.CustomerDaoImpl;
import cn.itcast.domain.Customer;
public class test_find {
	@Test
	public void find(){
		String id="fff42f0c-b3bc-43e0-b496-56a08abe3de866";
		CustomerDaoImpl dao=new CustomerDaoImpl();
		Customer c=dao.find(id);
		System.out.println(c.getName());//妙玉667
	}
	@Test
	public void update(){
		String id="fff42f0c-b3bc-43e0-b496-56a08abe3de866";
		CustomerDaoImpl dao=new CustomerDaoImpl();
		Customer c=new Customer();
		c.setId(id);
		c.setName("妙玉667");
		c.setGender("女");
		c.setType("VIP");
		dao.update(c);
	}
	@Test
	public void getAll(){
		CustomerDaoImpl dao=new CustomerDaoImpl();
		List list=dao.getAll();
		System.out.println(list.size());
	}
}