高分求解~关于数据库的问题

Question

1、对于数据库连接池，怎么设置最小连接数和最大连接数才合理？查看了很多资料，大家的做法是：如果系统平均并发数是a，最大并发数是b，则最小连接数是a，最大连接数是b，如果有1000个并发，那岂不是得设置1000个连接数？显然，这超出了系统的承受力。
有资料说一个Connection连接可以支持多个Statement并发，那请问像oracle和sqlserver分别可以支持多少个Statement并发呢？
2、假如说一个Connection可以支持100个Statement并发，那么在并发数小于100的系统中，是不是可以理解为只需要一个Connection就可以了？
3、如果一个Connection可以支持100个Statement并发，并且这100个Sstatement都共享一个Connection的话反而会导致效率降低，那么，100个并发设置多少个Connection比较合理？4、关于Statement和PreparedStatement，请看下面代码import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
public class DepartTreeProcessor2{

private DBUtil db = DBUtil.getInstance();

/**
 * 此方法返回某个部门节点下的所有节点模型
 * 
 * @param id  部门节点id
 * @return 包含该部门节点的所有节点模型
 */
public DepartTreeNode getDepartTreeNode(Integer id){
                  //请看此处，输出开始执行时间
System.out.println(System.currentTimeMillis());
DepartTreeNode node = new DepartTreeNode();

String sql ="select d.id, d.name from department d where d.id= "+id;
Statement stm1 = db.getStatement();
ResultSet set1 = null;
try {
            set1  = stm1.executeQuery(sql);
while (set1.next()) {
node.setId("node_" + set1.getInt("id"));
node.setText(set1.getString("name"));
}
set1.close();
stm1.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
                 //请看此处，输出执行结束时间
System.out.println(System.currentTimeMillis());
return getDepartTreeNode(node);

} /**
 * 此方法返回某个部门节点下的所有节点模型
 * 
 * @param node  部门节点
 * @return 包含该部门节点的所有节点模型
 */
public DepartTreeNode getDepartTreeNode(DepartTreeNode node) { Statement stm2 = db.getStatement();
ResultSet set2 = null;
try {
Integer id = Integer.parseInt(node.getId().substring(5));
String sql2 = "select d.id, d.name, d.type from department d where d.parentID= "+id;
set2 = stm2.executeQuery(sql2);
ArrayList<DepartTreeNode> nodeList = new ArrayList<DepartTreeNode>();
while (set2.next()) {

DepartTreeNode n = new DepartTreeNode();
n.setId("node_" +set2.getInt("id"));
n.setText(set2.getString("name"));
n.setChecked(false);
if (set2.getString("type").equals("xlpanel")) {

String sql3 = "select d.id, d.name from observationpoint d where d.belongLine= "+set2.getInt("id");
Statement stm3 = db.getStatement();
ResultSet set3 = null;
ArrayList<DepartTreeNode> list = new ArrayList<DepartTreeNode>();
try {
set3 = stm3.executeQuery(sql3);
while (set3.next()) {
DepartTreeNode leaf = new DepartTreeNode();
leaf.setId("node_" + set3.getInt("id"));
leaf.setText(set3.getString("name"));
leaf.setNodeType("async");
leaf.setLeaf(true);
leaf.setChecked(false);
list.add(leaf);
}
if(list.isEmpty()){
n.setLeaf(true);
}
else{
n.setChildren(list);
n.setLeaf(false);
}
nodeList.add(n);
set3.close();
stm3.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
nodeList.add(getDepartTreeNode(n));
} }
if(nodeList.isEmpty()){
node.setLeaf(true);
}
else{
node.setChildren(nodeList);
node.setLeaf(false);
}

node.setNodeType("async");
node.setChecked(false);
set2.close();
stm2.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} return node;
} /**
 * @param id节点id
 * @return 该节点下包含该节点的JSON格式字符串
 */
public String getDepartTreeNodeJSONData(Integer id) { return JSONObject.fromObject(getDepartTreeNode(id)).toString();
} }
上面代码getDepartTreeNode(Integer id)执行完需要157毫秒，但我将PreparedStatement换成Statement之后执行时间只需要46毫秒，何解？

Answer 1

上面问题4说错了，下面这段代码执行需要157毫秒，上面那段代码执行只需要46毫秒import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
public class DepartTreeProcessor{

private DBUtil pool = DBUtil.getInstance();

/**
 * 此方法返回某个部门节点下的所有节点模型
 * 
 * @param id  部门节点id
 * @return 包含该部门节点的所有节点模型
 */
public DepartTreeNode getDepartTreeNode(Integer id){
System.out.println(System.currentTimeMillis());
DepartTreeNode node = new DepartTreeNode();
DBUtil pool = DBUtil.getInstance();
String sql ="select d.id, d.name from department d where d.id= ?";
PreparedStatement stm1 = pool.getPreparedStatement(sql);
ResultSet set1 = null;
try {
stm1.setInt(1, id);
            set1  = stm1.executeQuery();
while (set1.next()) {
node.setId("node_" + set1.getInt("id"));
node.setText(set1.getString("name"));
}
set1.close();
stm1.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(System.currentTimeMillis());
return getDepartTreeNode(node);

} /**
 * 此方法返回某个部门节点下的所有节点模型
 * 
 * @param node  部门节点
 * @return 包含该部门节点的所有节点模型
 */
public DepartTreeNode getDepartTreeNode(DepartTreeNode node) { DBUtil pool = DBUtil.getInstance();
String sql2 = "select d.id, d.name, d.type from department d where d.parentID= ?";
PreparedStatement stm2 = pool.getPreparedStatement(sql2);
ResultSet set2 = null;
try {
Integer id = Integer.parseInt(node.getId().substring(5));
stm2.setInt(1, id);
set2 = stm2
.executeQuery();
ArrayList<DepartTreeNode> nodeList = new ArrayList<DepartTreeNode>();
while (set2.next()) {

DepartTreeNode n = new DepartTreeNode();
n.setId("node_" +set2.getInt("id"));
n.setText(set2.getString("name"));
n.setChecked(false);
if (set2.getString("type").equals("xlpanel")) {

String sql3 = "select d.id, d.name from observationpoint d where d.belongLine= ?";
PreparedStatement stm3 = pool.getPreparedStatement(sql3);
ResultSet set3 = null;
ArrayList<DepartTreeNode> list = new ArrayList<DepartTreeNode>();
try {
stm3.setInt(1,set2.getInt("id"));
set3 = stm3.executeQuery();
while (set3.next()) {
DepartTreeNode leaf = new DepartTreeNode();
leaf.setId("node_" + set3.getInt("id"));
leaf.setText(set3.getString("name"));
leaf.setNodeType("async");
leaf.setLeaf(true);
leaf.setChecked(false);
list.add(leaf);
}
if(list.isEmpty()){
n.setLeaf(true);
}
else{
n.setChildren(list);
n.setLeaf(false);
}
nodeList.add(n);
set3.close();
stm3.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
nodeList.add(getDepartTreeNode(n));
} }
if(nodeList.isEmpty()){
node.setLeaf(true);
}
else{
node.setChildren(nodeList);
node.setLeaf(false);
}

node.setNodeType("async");
node.setChecked(false);
set2.close();
stm2.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} return node;
} /**
 * @param id节点id
 * @return 该节点下包含该节点的JSON格式字符串
 */
public String getDepartTreeNodeJSONData(Integer id) { return JSONObject.fromObject(getDepartTreeNode(id)).toString();
}}
这段代码执行需要157毫秒，上面那段代码执行只需要46毫秒

Answer 2

1.PreparedStatement是预编译的,对于批量处理可以大大提高效率. 也叫JDBC存储过程
2.使用 Statement 对象。在对数据库只执行一次性存取的时侯，用 Statement 对象进行处理。PreparedStatement 对象的开销比Statement大，对于一次性操作并不会带来额外的好处。
3.statement每次执行sql语句，相关数据库都要执行sql语句的编译，preparedstatement是预编译得,   preparedstatement支持批处理

Answer 3

执行许多SQL语句的JDBC程序产生大量的Statement和PreparedStatement对象。通常认为PreparedStatement对象比Statement对象更有效,特别是如果带有不同参数的同一SQL语句被多次执行的时候。PreparedStatement对象允许数据库预编译SQL语句，这样在随后的运行中可以节省时间并增加代码的可读性。然而，在Oracle环境中，开发人员实际上有更大的灵活性。当使用Statement或PreparedStatement对象时，Oracle数据库会缓存SQL语句以便以后使用。在一些情况下,由于驱动器自身需要额外的处理和在Java应用程序和Oracle服务器间增加的网络活动，执行PreparedStatement对象实际上会花更长的时间。然而，除了缓冲的问题之外，至少还有一个更好的原因使我们在企业应用程序中更喜欢使用PreparedStatement对象,那就是安全性。传递给PreparedStatement对象的参数可以被强制进行类型转换，使开发人员可以确保在插入或查询数据时与底层的数据库格式匹配。

Answer 4

1.PreparedStatement是预编译的,
对于批量处理可以大大提高效率.它是JDBC对Statement的一种封装，它会把下发的到数据库的数据，作为一个类似集合一样，再插入数据库中。
2.使用 Statement 对象。在对数据库只执行一次性存取的时侯，用 Statement 对象进行处理。PreparedStatement 对象的开销比Statement大，对于一次性操作并不会带来额外的好处。
3.statement每次执行sql语句，相关数据库都要执行sql语句的编译，preparedstatement是预编译得, preparedstatement支持批处理

Answer 5

感谢楼上的三位
但请能否仔细看一下我的问题？第4个问题是用PreparedStatement耗时157毫秒，而用Statement只耗时46毫秒，PreparedStatement是预编译的我也知道········

Answer 6

我自己up！
up！up！up！up！up！up！up！up！up！up！