第34次文章：SORM框架（四）

  /**
   * 分页查询
   * @param pageNum 第几页数据
   * @param size 每页显示多少记录
   * @return
   */
  public abstract Object queryPagenate(int pageNum,int size);

  /**
   * 采用模板方法模式将JDBC操作封装成模板，便于重用
   * @param sql sql语句
   * @param params sql的参数
   * @param clazz 记录要封装到的java类
   * @param back CallBack的实现类，实现回调
   * @return
   */
  public Object excueteQueryTemplate(String sql,Object[] params,Class clazz,CallBack back) {

    Connection conn = DBManager.getConn();
    List list = null;    //存储查询结果的容器
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
      ps = (PreparedStatement) conn.prepareStatement(sql);
      //给sql设置参数
      JDBCUtils.handleParams(ps, params);
      System.out.println(ps);
      rs = ps.executeQuery();
      
      return back.doExecute(conn, ps, rs);
    
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    } finally {
      DBManager.close(ps, conn);
    }  
  }

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public interface CallBack {
  public Object doExecute(Connection conn,PreparedStatement ps,ResultSet rs);
}

  /**
   * 查询返回多行记录，并将每行记录封装到clazz指定的类的对象中
   * @param sql 查询语句
   * @param clazz 封装数据的javabean类的class对象
   * @param params sql的参数
   * @return 查询到的结果
   */
  public List queryRows(final String sql,final Class clazz,final Object[] params) {
    return (List)excueteQueryTemplate(sql, params, clazz, new CallBack() {

      @Override
      public Object doExecute(Connection conn, java.sql.PreparedStatement ps, ResultSet rs) {
        List list = null;
        try {
          ResultSetMetaData metaData = rs.getMetaData();
          //多行
          while(rs.next()) {
            if(list==null) {
              list = new ArrayList();
            }
            
            Object rowObj = clazz.newInstance();  //调用Javabean的无参构造器

            //多列 select username,pwd,age from user where id>? and age>18
            for(int i=0;i<metaData.getColumnCount();i++) {
              String columnName = metaData.getColumnLabel(i+1);
              Object columnValue = rs.getObject(i+1);

              //调用rowObject对象的setUsername方法，将ColumnValue的值设置进去
              ReflectUtils.invokeSet(rowObj, columnName, columnValue);
            }
            list.add(rowObj);
          }
        }catch(Exception e) {
          e.printStackTrace();
        }
        return list;
      }
    
    });
  }

  /**
   * 查询返回一个值（一行一列），并将该值返回
   * @param sql 查询语句
   * @param params sql的参数
   * @return 查询到的结果
   */
  public Object queryValue(String sql,Object[] params) {

    return excueteQueryTemplate(sql, params, null, new CallBack() {

      @Override
      public Object doExecute(Connection conn, java.sql.PreparedStatement ps, ResultSet rs) {
        Object value = null;
        try {
          while(rs.next()) {
            value = rs.getObject(1);
          }
        } catch (SQLException e) {
          e.printStackTrace();
        }
        return value;
      }
    });
  }

package com.peng.sorm.pool;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.peng.sorm.core.DBManager;

/**
 * 连接池的类
 */
public class DBConnPool {
  
  /**
   * 连接池对象
   */
  private static List<Connection> pool;
  /**
   * 最大连接数
   */
  private static final int POOL_MAX_SIZE=DBManager.getConf().getPoolMaxSize();
  /**
   * 最小连接数
   */
  private static final int POOL_MIN_SIZE=DBManager.getConf().getPoolMinSize();

  /**
   * 初始化连接池，使池中连接数达到最小值
   */
  public void initPool() {
    if(pool == null) {
      pool = new ArrayList<Connection>();
    }
    while(pool.size()< POOL_MIN_SIZE) {
      pool.add(DBManager.createConn());
      System.out.println("初始化池，池中连接数："+pool.size());
    }
  }
  
  /**
   * 从池中取出一个连接
   * @return
   */
  public synchronized Connection getConnection() {
    int last_index = pool.size()-1;
    Connection conn = pool.get(last_index);
    pool.remove(last_index);
    return conn;
  }

  /**
   * 所谓的关闭连接并不是真的连接，只是将此连接放回到连接池中
   * @param conn
   */
  public synchronized void close(Connection conn) {
    if(pool.size()>=POOL_MAX_SIZE) {
      try {
        conn.close();
      } catch (SQLException e) {
        e.printStackTrace();
      }
    }else {
      pool.add(conn);
    }
  }
  
  public DBConnPool() {
    initPool();
  }
}

import java.util.List;

import com.peng.sorm.core.Query;
import com.peng.sorm.core.QueryFactory;
import com.peng.vo.EmpVO;

/**
 * 测试连接池的效率
 *
 */
public class Test2 {
  public static void test() {
    Query q = QueryFactory.createQuery();
    //复杂查询，将两个表进行关联查询
    String sql2 = "select e.id,e.empname,salary+bonus 'xinshui',age,d.dname 'deptName',d.address 'deptAddr' from emp e "
    +"join dept d on e.deptId=d.id ";
    List<EmpVO> list2 = q.queryRows(sql2,EmpVO.class, null);
    for(EmpVO e:list2) {
      System.out.println(e.getEmpname()+" "+e.getAge()+" "+e.getId()+" "+e.getXinshui()+" "+e.getDeptName()+" "+e.getDeptAddr());
      System.out.println("******************");
    }
  }
  
  public static void main(String[] args) {
    long a = System.currentTimeMillis();
    for(int i=0;i<3000;i++) {
      test();      
    }
    long b = System.currentTimeMillis();
    System.out.println(b-a);//不加连接池：14187毫秒. 增加连接池之后：1957
  }
}