91久久久久久久久久久,精品久久久亚洲,综合欧美国产视频二区

liaojiyong — Fri, 23 Mar 2007 01:33:00 GMT

1. 引言

　　�q�年来，随着Internet/Intranet建网技术的飞速发展和在世界范围内的迅速普及，计算�?/p>

　　应用�E�序已从传统的桌面应用�{到Web应用。基于B/S�Q�Browser/Server�Q�架构的3层开发模式逐渐取代C/S�Q�Client/Server�Q�架构的开发模式，成�ؓ开发企业��应用和电子商务普遍采用的技术。在Web应用开发的早期�Q�主要��用的技术是CGI�H?a target="_blank">ASP�H?a target="_blank">PHP�{�。之后，Sun公司推出了基�?a target="_blank">Java语言的Servlet+Jsp+JavaBean技术。相比传�l�的开发技术，它具有跨�q�_��H?a target="_blank">安全�H�有效﹑可移植等�Ҏ��，�q��其更便于使用和开发�?/p>

　　Java应用�E�序讉K��数据�?/font>的基本原�?/p>

　　在Java语言中，JDBC�Q�Java DataBase Connection�Q�是应用�E�序与数据库沟通的桥梁,

　　即Java语言通过JDBC技术访问数据库。JDBC是一�U�“开�䏀�的�Ҏ��Q�它为数据库应用开发�h员﹑数据库前台工具开发�h员提供了一�U�标准的应用�E�序设计接口�Q��开发�h员可以用�U�Java语言�~�写完整的数据库应用�E�序。JDBC提供两种API�Q�分别是面向开发�h员的API和面向底层的JDBC驱动�E�序API�Q�底层主要通过直接的JDBC驱动和JDBC-ODBC桥驱动实��C��数据库的�q�接�?/p>

　　一般来��_��Java应用�E�序讉K��数据库的�q�程�Q�如�?所�C�）是：

　　①装载数据库驱动�E�序�Q?/p>

　　②通过JDBC建立数据库连接；

　　③访问数据库�Q�执行SQL语句�Q?/p>

　　④断开数据库连接�?/p>

�? Java数据库访问机�?/div>

　　JDBC作�ؓ一�U�数据库讉K��技术，��h��单易用的优点。但使用�q�种模式�q�行Web应用

　　�E�序开发，存在很多问题�Q�首先，每一�ơWeb��h��都要建立一�ơ数据库�q�接。徏立连接是一个费时的�z�d��Q�每�ơ都得花�?.05s�?s的时��_��而且�pȝ��q�要分配内存资源。这个时间对于一�ơ或几次数据库操作，或许感觉不出�pȝ��有多大的开销。可是对于现在的Web应用�Q�尤其是大型电子商务�|�站�Q�同时有几百人甚臛_��千�h在线是很正常的事。在�q�种情况下，频繁的进行数据库�q�接操作势必占用很多的系�l�资源，�|�站的响应速度必定下降�Q�严重的甚至会造成服务器的崩溃。不是危�a�耸听�Q�这��是制约某些电子商务�|�站发展的技术瓶颈问题。其�ơ，对于每一�ơ数据库�q�接�Q��用完后都得断开。否则，如果�E�序出现异常而未能关闭，��会��D��数据库系�l�中的内存泄漏，最�l�将不得不重启数据库。还有，�q�种开发不能控制被创徏的连接对象数�Q�系�l�资源会被毫无顾及的分配出去�Q�如�q�接�q�多�Q�也可能��D��内存泄漏�Q�服务器崩溃�?/div>

　　数据库连接池�Q�connection pool�Q�的工作原理

　　1、基本概念及原理
�׃��面的分析可以看出�Q�问题的�Ҏ��在于对数据�?/font>�q�接资源的低效管理。我们知道，

　　对于�׃�n资源�Q�有一个很著名�?a target="_blank">设计模式�Q�资源池�Q�Resource Pool�Q�。该模式正是��Z��解决资源的频�J�分配﹑释放所造成的问题。�ؓ解决上述问题�Q�可以采用数据库�q�接池技术。数据库�q�接池的基本思想��是为数据库�q�接建立一个“缓冲池”。预先在�~�冲池中攑օ�一定数量的�q�接�Q�当需要徏立数据库�q�接�Ӟ��只需从“缓冲池”中取出一个，使用完毕之后再放回去。我们可以通过讑֮��q�接池最大连接数来防止系�l�无��的与数据库�q�接。更为重要的是我们可以通过�q�接池的��理机制监视数据库的�q�接的数量﹑使用情况�Q��ؓ�pȝ��开发﹑��试及性能调整提供依据。连接池的基本工作原理见下图2�?/div>

�? �q�接池的基本工作原理

　　2、服务器自带的连接池

　　JDBC的API中没有提供连接池的方法。一些大型的WEB应用服务器如BEA的WebLogic和IBM的WebSphere�{�提供了�q�接池的机制�Q�但是必��L��其第三方的专用类�Ҏ��支持�q�接池的用法�?/div>

　　�q�接池关键问题分�?/div>

　　1、�ƈ发问�?/div>

　　��Z��使连接管理服务具有最大的通用性，必须考虑多线�E�环境，卛_ƈ发问题。这个问题相�Ҏ��较好解决�Q�因�?a target="_blank">Java语言自��n提供了对�q�发��理的支持，使用synchronized关键字即可确保线�E�是同步的。��用方法�ؓ直接在类�Ҏ��前面加上synchronized关键字，如：

public synchronized Connection getConnection�Q�）

　　2、多数据库服务器和多用户

　　对于大型的企业��应用�Q�常帔R��要同时连接不同的数据库（如连�?a target="_blank">Oracle�?a target="_blank">Sybase�Q�。如何连接不同的数据库呢�Q�我们采用的�{�略是：设计一个符合单例模式的�q�接池管理类�Q�在�q�接池管理类的唯一实例被创建时��d��一个资源文�Ӟ��其中资源文�g中存攄��多个数据库的url地址�Q?lt;poolName.url>�Q�﹑用户名（�Q�﹑密码�Q?lt;poolName.password>�Q�等信息。如tx.url=192.168.1.123:5000/tx_it�Q�tx.user=cyl�Q�tx.password=123456。根据资源文件提供的信息�Q�创建多个连接池�cȝ��实例�Q�每一个实例都是一个特定数据库的连接池。连接池��理�c�d��例�ؓ每个�q�接池实例取一个名字，通过不同的名字来��理不同的连接池�?/div>

　　对于同一个数据库有多个用户��用不同的名称和密码访问的情况�Q�也可以通过资源文�g处理�Q�即在资源文件中讄��多个��h��相同url地址�Q�但��h��不同用户名和密码的数据库�q�接信息�?/div>

　　3、事务处�?/div>

　　我们知道�Q�事务具有原子性，此时要求�Ҏ��据库的操作符合“ALL-ALL-NOTHING”原�?卛_��于一�l�SQL语句要么全做�Q�要么全不做�?br />�?a target="_blank">Java语言中，Connection�c�L��w�提供了对事务的支持�Q�可以通过讄��Connection的AutoCommit属性�ؓfalse,然后昑ּ�的调用commit或rollback�Ҏ��来实现。但要高效的�q�行Connection复用�Q�就必须提供相应的事务支持机制。可采用每一个事务独占一个连接来实现�Q�这�U�方法可以大大降低事务管理的复杂性�?

　　4、连接池的分配与释放

　　�q�接池的分配与释放，对系�l�的性能有很大的影响。合理的分配与释放，可以提高�q�接的复用度�Q�从而降低徏立新�q�接的开销�Q�同时还可以加快用户的访问速度�?/div>

　　对于�q�接的管理可使用�I�闲池。即把已�l�创��Z��未分配出去的连接按创徏旉��存放��C��个空闲池中。每当用戯��求一个连接时�Q�系�l�首先检查空闲池内有没有�I�闲�q�接。如果有��把建立旉��最长（通过容器的顺序存攑֮�玎ͼ�的那个连接分配给他（实际是先做连接是否有效的判断�Q�如果可用就分配�l�用��P��如不可用��把�q�个�q�接从空闲池删掉�Q�重新检��空闲池是否�q�有�q�接�Q�；如果没有则检查当前所开�q�接池是否达到连接池所允许的最大连接数�Q�maxConn�Q?如果没有辑ֈ��Q�就新徏一个连接，如果已经辑ֈ��Q�就�{�待一定的旉��Q�timeout�Q�。如果在�{�待的时间内有连接被释放出来��可以把�q�个�q�接分配�l�等待的用户�Q�如果等待时间超�q�预定时间timeout,则返回空��|��null�Q�。系�l�对已经分配出去正在使用的连接只做计敎ͼ�当��用完后再�q�还�l�空闲池。对于空闲连接的状态，可开辟专门的�U�程定时��，�q�样会花费一定的�pȝ��开销�Q�但可以保证较快的响应速度。也可采取不开辟专门线�E�，只是在分配前��的�Ҏ��?/div>

　　5、连接池的配�|�与�l�护

　　�q�接池中到底应该攄��多少�q�接�Q�才能�ɾpȝ��的性能最佻I��pȝ��可采取设�|�最��连接数�Q�minConn�Q�和最大连接数�Q�maxConn�Q�来控制�q�接池中的连接。最��连接数是系�l�启动时�q�接池所创徏的连接数。如果创��多，则系�l�启动就慢，但创建后�pȝ��的响应速度会很快；如果创徏�q�少�Q�则�pȝ��启动的很快，响应��h��却慢。这��P��可以在开发时�Q�设�|�较��的最��连接数�Q�开发�v来会快，而在�pȝ��实际使用时设�|�较大的�Q�因��样对讉K��客户来说速度会快些。最大连接数是连接池中允许连接的最大数目，具体讄��多少�Q�要看系�l�的讉K��量，可通过反复��试�Q�找到最佳点�?/div>

　　如何��保�q�接池中的最��连接数呢？有动态和静态两�U�策略。动态即每隔一定时间就对连接池�q�行��，如果发现�q�接数量��于最��连接数�Q�则补充相应数量的新�q�接,以保证连接池的正常运转。静态是发现�I�闲�q�接不够时再��L��查�?br />�q�接池的实现

　　1、连接池模型

　　本文讨论的连接池包括一个连接池�c�（DBConnectionPool�Q�和一个连接池��理�c�（DBConnetionPoolManager�Q�和一个配�|�文件操作类(ParseDSConfig)。连接池�c�L��Ҏ��一数据�?/font>所有连接的“缓冲池”，主要实现以下功能�Q�①从连接池获取或创建可用连接；②��用完毕之后，把连接返�q�给�q�接池；③在�pȝ��关闭前，断开所有连接�ƈ释放�q�接占用的系�l�资源；④还能够处理无效�q�接�Q�原来登��Cؓ可用的连接，�׃��某种原因不再可用�Q�如��时�Q�通讯问题�Q�，�q�能够限制连接池中的�q�接��L��不低于某个预定值和不超�q�某个预定倹{�?5)当多数据库时,且数据库是动态增加的�?��会加到配置文�g中�?/div>

　　�q�接池管理类是连接池�cȝ��外覆�c�（wrapper�Q?�W�合单例模式�Q�即�pȝ��中只能有一个连接池��理�cȝ��实例。其主要用于对多个连接池对象的管理，��h��以下功能�Q�①装蝲�q�注册特定数据库的JDBC驱动�E�序�Q�②�Ҏ��属性文件给定的信息�Q�创��接池对象�Q�③为方便管理多个连接池对象�Q��ؓ每一个连接池对象取一个名字，实现�q�接池名字与其实例之间的映射�Q�④跟踪客户使用�q�接情况�Q�以侉K��要是关闭�q�接释放资源。连接池��理�cȝ��引入主要是�ؓ了方便对多个�q�接池的使用和管理，如系�l�需要连接不同的数据库，或连接相同的数据库但�׃��安全性问题，需要不同的用户使用不同的名�U�和密码�?br />         2、连接池实现(�l�过本�h改版,可以适用多数据库�c�d��的应用以及一�U�数据库�c�d��多个数据库且数据库的数量可以动态增加的应用�E�序)
         1),DBConnectionPool.java   数据库连接池�c?br />         2),DBConnectionManager .java   数据库管理类
         3),DSConfigBean .java                单个数据库连接信息Bean
         4),ParseDSConfig.java                操作�?�q�个'�?包括不同的数据库和同一�U�数据库有多个数据库)
                                                            数据配置文�gxml
         5),ds.config.xml                           数据库配�|�文件xml
         原代码如�?
        DBConnectionPool.java
        ----------------------------------------------------------
      /**
* 数据库连接池�c?br /> */
package com.chunkyo.db;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Timer;

/**
* @author chenyanlin
*
*/
public class DBConnectionPool implements TimerListener {

private Connection con=null;
private int inUsed=0;    //使用的连接数
private ArrayList freeConnections = new ArrayList();//容器�Q�空闲连�?br /> private int minConn;     //最��连接数
private int maxConn;     //最大连�?br /> private String name;     //�q�接池名�?br /> private String password; //密码
private String url;      //数据库连接地址
private String driver;   //驱动
private String user;     //用户�?br /> public Timer timer;      //定时
/**
*
*/
public DBConnectionPool() {
  // TODO Auto-generated constructor stub
}
/**
* 创徏�q�接�?br /> * @param driver
* @param name
* @param URL
* @param user
* @param password
* @param maxConn
*/
public DBConnectionPool(String name, String driver,String URL, String user, String password, int maxConn)
{
  this.name=name;
  this.driver=driver;
  this.url=URL;
  this.user=user;
  this.password=password;
  this.maxConn=maxConn;
}
/**
* 用完�Q�释放连�?br /> * @param con
*/
public synchronized void freeConnection(Connection con)
{
  this.freeConnections.add(con);//��d��到空闲连接的末尾
  this.inUsed--;
}
/**
* timeout �Ҏ��timeout得到�q�接
* @param timeout
* @return
*/
public synchronized Connection getConnection(long timeout)
{
  Connection con=null;
  if(this.freeConnections.size()>0)
  {
   con=(Connection)this.freeConnections.get(0);
   if(con==null)con=getConnection(timeout); //�l�箋获得�q�接
  }
  else
  {
   con=newConnection(); //新徏�q�接
  }
  if(this.maxConn==0||this.maxConn  {
   con=null;//辑ֈ�最大连接数�Q�暂时不能获得连接了�?br />  }
  if(con!=null)
  {
   this.inUsed++;
  }
  return con;
}
/**
*
* 从连接池里得到连�?br /> * @return
*/
public synchronized Connection getConnection()
{
  Connection con=null;
  if(this.freeConnections.size()>0)
  {
   con=(Connection)this.freeConnections.get(0);
   this.freeConnections.remove(0);//如果�q�接分配出去了，��׃��I�闲�q�接里删�?br />   if(con==null)con=getConnection(); //�l�箋获得�q�接
  }
  else
  {
   con=newConnection(); //新徏�q�接
  }
  if(this.maxConn==0||this.maxConn  {
   con=null;//�{�待 ��过最大连接时
  }
  if(con!=null)
  {
   this.inUsed++;
   System.out.println("得到　"+this.name+"　的连接，现有"+inUsed+"个连接在使用!");
  }
  return con;
}
/**
*释放全部�q�接
*
*/
public synchronized void release()
{
  Iterator allConns=this.freeConnections.iterator();
  while(allConns.hasNext())
  {
   Connection con=(Connection)allConns.next();
   try
   {
    con.close();
   }
   catch(SQLException e)
   {
    e.printStackTrace();
   }

  }
  this.freeConnections.clear();

}
/**
* 创徏新连�?br /> * @return
*/
private Connection newConnection()
{
  try {
   Class.forName(driver);
   con=DriverManager.getConnection(url, user, password);
  } catch (ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   System.out.println("sorry can't find db driver!");
  } catch (SQLException e1) {
   // TODO Auto-generated catch block
   e1.printStackTrace();
   System.out.println("sorry can't create Connection!");
  }
  return con;

}
/**
* 定时处理函数
*/
public synchronized void TimerEvent()
{
     //暂时�q�没有实��C��后会加上�?br /> }

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

}
/**
* @return the driver
*/
public String getDriver() {
  return driver;
}
/**
* @param driver the driver to set
*/
public void setDriver(String driver) {
  this.driver = driver;
}
/**
* @return the maxConn
*/
public int getMaxConn() {
  return maxConn;
}
/**
* @param maxConn the maxConn to set
*/
public void setMaxConn(int maxConn) {
  this.maxConn = maxConn;
}
/**
* @return the minConn
*/
public int getMinConn() {
  return minConn;
}
/**
* @param minConn the minConn to set
*/
public void setMinConn(int minConn) {
  this.minConn = minConn;
}
/**
* @return the name
*/
public String getName() {
  return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
  this.name = name;
}
/**
* @return the password
*/
public String getPassword() {
  return password;
}
/**
* @param password the password to set
*/
public void setPassword(String password) {
  this.password = password;
}
/**
* @return the url
*/
public String getUrl() {
  return url;
}
/**
* @param url the url to set
*/
public void setUrl(String url) {
  this.url = url;
}
/**
* @return the user
*/
public String getUser() {
  return user;
}
/**
* @param user the user to set
*/
public void setUser(String user) {
  this.user = user;
}

}

-------------------------------------------
DBConnectionManager .java
------------------------------------------
/**
* 数据库连接池��理�c?br /> */
package com.chunkyo.db;

import java.sql.Connection;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Properties;
import java.util.Vector;

import com.chunkyo.db.ParseDSConfig;
import com.chunkyo.db.DSConfigBean;
import com.chunkyo.db.DBConnectionPool;

/**
* @author chenyanlin
*
*/
public class DBConnectionManager {

static private DBConnectionManager instance;//唯一数据库连接池��理实例�c?br /> static private int clients;                 //客户�q�接�?br /> private Vector drivers = new Vector();//驱动信息
private Hashtable pools=new Hashtable();//�q�接�?br />
/**
* 实例化管理类
*/
public DBConnectionManager() {
  // TODO Auto-generated constructor stub
  this.init();
}
/**
* 得到唯一实例��理�c?br /> * @return
*/
static synchronized public DBConnectionManager getInstance()
{
  if(instance==null)
  {
   instance=new DBConnectionManager();
  }
  return instance;

}
/**
* 释放�q�接
* @param name
* @param con
*/
public void freeConnection(String name, Connection con)
{
  DBConnectionPool pool=(DBConnectionPool)pools.get(name);//�Ҏ��关键名字得到�q�接�?br />  if(pool!=null)
  pool.freeConnection(con);//释放�q�接
}
/**
* 得到一个连接根据连接池的名字name
* @param name
* @return
*/
public Connection getConnection(String name)
{
  DBConnectionPool pool=null;
  Connection con=null;
  pool=(DBConnectionPool)pools.get(name);//从名字中获取�q�接�?br />  con=pool.getConnection();//从选定的连接池中获得连�?br />  if(con!=null)
  System.out.println("得到�q�接。。�?);
  return con;
}
/**
* 得到一个连接，�Ҏ��q�接池的名字和等待时�?br /> * @param name
* @param time
* @return
*/
public Connection getConnection(String name, long timeout)
{
  DBConnectionPool pool=null;
  Connection con=null;
  pool=(DBConnectionPool)pools.get(name);//从名字中获取�q�接�?br />  con=pool.getConnection(timeout);//从选定的连接池中获得连�?br />  System.out.println("得到�q�接。。�?);
  return con;
}
/**
* 释放所有连�?br /> */
public synchronized void release()
{
  Enumeration allpools=pools.elements();
  while(allpools.hasMoreElements())
  {
   DBConnectionPool pool=(DBConnectionPool)allpools.nextElement();
   if(pool!=null)pool.release();
  }
  pools.clear();
}

/**
* 创徏�q�接�?br /> * @param props
*/
private void createPools(DSConfigBean dsb)
{
  DBConnectionPool dbpool=new DBConnectionPool();
  dbpool.setName(dsb.getName());
  dbpool.setDriver(dsb.getDriver());
  dbpool.setUrl(dsb.getUrl());
  dbpool.setUser(dsb.getUsername());
  dbpool.setPassword(dsb.getPassword());
  dbpool.setMaxConn(dsb.getMaxconn());
  System.out.println("ioio:"+dsb.getMaxconn());
  pools.put(dsb.getName(), dbpool);
}
/**
* 初始化连接池的参�?br /> */
private void init()
{
  //加蝲驱动�E�序
  this.loadDrivers();
  //创徏�q�接�?br />  Iterator alldriver=drivers.iterator();
  while(alldriver.hasNext())
  {
   this.createPools((DSConfigBean)alldriver.next());
   System.out.println("创徏�q�接池。。�?);

  }
  System.out.println("创徏�q�接池完毕。。�?);
}

/**
* 加蝲驱动�E�序
* @param props
*/
private void loadDrivers()
{
  ParseDSConfig pd=new ParseDSConfig();
//��d��数据库配�|�文�?br />  drivers=pd.readConfigInfo("ds.config.xml");
  System.out.println("加蝲驱动�E�序。。�?);
}
/**
* @param args
*/
public static void main(String[] args) {
  // TODO Auto-generated method stub

}

}
----------------------------------------
DSConfigBean.java
----------------------------------------
/**
* 配置文�gBean�c?br /> */
package com.chunkyo.db;

/**
* @author chenyanlin
*
*/
public class DSConfigBean {

private String type =""; //数据库类�?br /> private String name =""; //�q�接池名�?br /> private String driver =""; //数据库驱�?br /> private String url =""; //数据库url
private String username =""; //用户�?br /> private String password =""; //密码
private int maxconn =0; //最大连接数
/**
*
*/
public DSConfigBean() {
// TODO Auto-generated constructor stub
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

}

/**
* @return the driver
*/
public String getDriver() {
return driver;
}

/**
* @param driver the driver to set
*/
public void setDriver(String driver) {
this.driver = driver;
}

/**
* @return the maxconn
*/
public int getMaxconn() {
return maxconn;
}

/**
* @param maxconn the maxconn to set
*/
public void setMaxconn(int maxconn) {
this.maxconn = maxconn;
}

/**
* @return the name
*/
public String getName() {
return name;
}

/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}

/**
* @return the password
*/
public String getPassword() {
return password;
}

/**
* @param password the password to set
*/
public void setPassword(String password) {
this.password = password;
}

/**
* @return the type
*/
public String getType() {
return type;
}

/**
* @param type the type to set
*/
public void setType(String type) {
this.type = type;
}

/**
* @return the url
*/
public String getUrl() {
return url;
}

/**
* @param url the url to set
*/
public void setUrl(String url) {
this.url = url;
}

/**
* @return the username
*/
public String getUsername() {
return username;
}

/**
* @param username the username to set
*/
public void setUsername(String username) {
this.username = username;
}

}
-----------------------------------------------------
ParseDSConfig.java
-----------------------------------------------------
/**
* 操作配置文�g�c?读�?�?修改删除�{�操�?
*/
package com.chunkyo.db;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Vector;
import java.util.Iterator;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

/**
* @author chenyanlin
*
*/
public class ParseDSConfig {

/**
* 构造函�?br /> */
public ParseDSConfig() {
  // TODO Auto-generated constructor stub
}
/**
* ��d��xml配置文�g
* @param path
* @return
*/
public Vector readConfigInfo(String path)
{
  String rpath=this.getClass().getResource("").getPath().substring(1)+path;
  Vector dsConfig=null;
  FileInputStream fi = null;
  try
  {
   fi=new FileInputStream(rpath);//��d��路径文�g
   dsConfig=new Vector();
   SAXBuilder sb=new SAXBuilder();
   Document doc=sb.build(fi);
   Element root=doc.getRootElement();
   List pools=root.getChildren();
   Element pool=null;
   Iterator allPool=pools.iterator();
   while(allPool.hasNext())
   {
    pool=(Element)allPool.next();
    DSConfigBean dscBean=new DSConfigBean();
    dscBean.setType(pool.getChild("type").getText());
    dscBean.setName(pool.getChild("name").getText());
    System.out.println(dscBean.getName());
    dscBean.setDriver(pool.getChild("driver").getText());
    dscBean.setUrl(pool.getChild("url").getText());
    dscBean.setUsername(pool.getChild("username").getText());
    dscBean.setPassword(pool.getChild("password").getText());
    dscBean.setMaxconn(Integer.parseInt(pool.getChild("maxconn").getText()));
    dsConfig.add(dscBean);
   }

  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (JDOMException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }

  finally
  {
   try {
    fi.close();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }

  return dsConfig;
}

/**
*修改配置文�g 没时间写 �q�段旉��再脓上去其实一��L��
*/
public void modifyConfigInfo(String path,DSConfigBean dsb) throws Exception
{
  String rpath=this.getClass().getResource("").getPath().substring(1)+path;
  FileInputStream fi=null; //��d��
  FileOutputStream fo=null; //写入

}
/**
*增加配置文�g
*
*/
public void addConfigInfo(String path,DSConfigBean dsb)
{
  String rpath=this.getClass().getResource("").getPath().substring(1)+path;
  FileInputStream fi=null;
  FileOutputStream fo=null;
  try
  {
   fi=new FileInputStream(rpath);//��d��xml��?br />
   SAXBuilder sb=new SAXBuilder();

   Document doc=sb.build(fi); //得到xml
   Element root=doc.getRootElement();
   List pools=root.getChildren();//得到xml子树

   Element newpool=new Element("pool"); //创徏新连接池

   Element pooltype=new Element("type"); //讄��q�接池类�?br />   pooltype.setText(dsb.getType());
   newpool.addContent(pooltype);

   Element poolname=new Element("name");//讄��q�接池名�?br />   poolname.setText(dsb.getName());
   newpool.addContent(poolname);

   Element pooldriver=new Element("driver"); //讄��q�接池驱�?br />   pooldriver.addContent(dsb.getDriver());
   newpool.addContent(pooldriver);

   Element poolurl=new Element("url");//讄��q�接池url
   poolurl.setText(dsb.getUrl());
   newpool.addContent(poolurl);

   Element poolusername=new Element("username");//讄��q�接池用户名
   poolusername.setText(dsb.getUsername());
   newpool.addContent(poolusername);

   Element poolpassword=new Element("password");//讄��q�接池密�?br />   poolpassword.setText(dsb.getPassword());
   newpool.addContent(poolpassword);

   Element poolmaxconn=new Element("maxconn");//讄��q�接池最大连�?br />   poolmaxconn.setText(String.valueOf(dsb.getMaxconn()));
   newpool.addContent(poolmaxconn);
   pools.add(newpool);//��child��d��到root
   Format format = Format.getPrettyFormat();
      format.setIndent("");
      format.setEncoding("utf-8");
      XMLOutputter outp = new XMLOutputter(format);
      fo = new FileOutputStream(rpath);
      outp.output(doc, fo);
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (JDOMException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  finally
  {

  }
}
/**
*删除配置文�g
*/
public void delConfigInfo(String path,String name)
{
  String rpath=this.getClass().getResource("").getPath().substring(1)+path;
  FileInputStream fi = null;
  FileOutputStream fo=null;
  try
  {
   fi=new FileInputStream(rpath);//��d��路径文�g
   SAXBuilder sb=new SAXBuilder();
   Document doc=sb.build(fi);
   Element root=doc.getRootElement();
   List pools=root.getChildren();
   Element pool=null;
   Iterator allPool=pools.iterator();
   while(allPool.hasNext())
   {
    pool=(Element)allPool.next();
    if(pool.getChild("name").getText().equals(name))
    {
     pools.remove(pool);
     break;
    }
   }
   Format format = Format.getPrettyFormat();
      format.setIndent("");
      format.setEncoding("utf-8");
      XMLOutputter outp = new XMLOutputter(format);
      fo = new FileOutputStream(rpath);
      outp.output(doc, fo);

  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (JDOMException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }

  finally
  {
   try {
    fi.close();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
}
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
  // TODO Auto-generated method stub

  ParseDSConfig pd=new ParseDSConfig();
  String path="ds.config.xml";
  pd.readConfigInfo(path);
  //pd.delConfigInfo(path, "tj012006");
  DSConfigBean dsb=new DSConfigBean();
  dsb.setType("oracle");
  dsb.setName("yyy004");
  dsb.setDriver("org.oracle.jdbc");
  dsb.setUrl("jdbc:oracle://localhost");
  dsb.setUsername("sa");
  dsb.setPassword("");
  dsb.setMaxconn(1000);
  pd.addConfigInfo(path, dsb);
  pd.delConfigInfo(path, "yyy001");
}

}

--------------------------------------
ds.config.xml 配置文�g
--------------------------------------

mysql
user
com.mysql.jdbc.driver
jdbc:mysql://localhost:3306/user
sa
123456
100

mysql
user2
com.mysql.jdbc.driver
jdbc:mysql://localhost:3306/user2
sa
1234
10

sql2000
books
com.microsoft.sqlserver.driver
jdbc:sqlserver://localhost:1433/books:databasename=books
sa

100

3. �q�接池的使用
1。Connection的获得和释放
DBConnectionManager   connectionMan=DBConnectionManager .getInstance();//得到唯一实例
   //得到�q�接
   String name="mysql";//从上下文得到你要讉K��的数据库的名�?br />   Connection con=connectionMan.getConnection(name);
//使用
。。。。。。�?br /> // 使用完毕
connectionMan.freeConnection(name,con);//释放�Q�但�q�未断开�q�接
2。数据库�q�接的动态增加和�q�接池的动态增�?br />      1。调用xml操作增加�c?br />
      2。重新实例华�q�接池管理池�c?br />

liaojiyong 2007-03-23 09:33 发表评论

liaojiyong — Fri, 22 Dec 2006 06:16:00 GMT

一、预备知识—程序的内存分配

一个由c/C++�~�译的程序占用的内存分�ؓ以下几个部分
1、栈区（stack�Q��?��q��译器自动分配释放�Q�存攑և�数的参数��|��局部变量的值等。其操作方式�c�M��于数据结构中的栈�?br />2、堆区（heap�Q?�?一般由�E�序员分配释放，若程序员不释放，�E�序�l�束时可能由OS回收。注意它与数据结构中的堆是两回事�Q�分配方式倒是�c�M��于链表，呵呵�?br />3、全局区（静态区�Q�（static�Q�—，全局变量和静态变量的存储是放在一块的�Q�初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在盔R��的另一块区域�?- �E�序�l�束后有�pȝ��释放
4、文字常量区 —常量字�W�串��是攑֜��q�里的。程序结束后��q��l�释�?br />5、程序代码区—存攑և��C��的二�q�制代码�?br />二、例子程�?br />�q�是一个前辈写的，非常详细
//main.cpp
int a = 0; 全局初始化区
char *p1; 全局未初始化�?br />main()
{
int b; �?br />char s[] = "abc"; �?br />char *p2; �?br />char *p3 = "123456"; 123456\0在常量区�Q�p3在栈上�?br />static int c =0�Q?全局�Q�静态）初始化区
p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
分配得来�?0�?0字节的区域就在堆区�?br />strcpy(p1, "123456"); 123456\0攑֜�帔R��区，�~�译器可能会��它与p3所指向�?123456"优化成一个地斏V�?br />}

二、堆和栈的理论知�?/p>

2.1甌��方式
stack:
��q��l�自动分配�?例如�Q�声明在函数中一个局部变�?int b; �pȝ��自动在栈中�ؓb开辟空�?br />heap:
需要程序员自己甌��Q��ƈ指明大小�Q�在c中malloc函数
如p1 = (char *)malloc(10);
在C++中用new�q�算�W?br />如p2 = (char *)malloc(10);
但是注意p1、p2本��n是在栈中的�?/p>

2.2
甌��后系�l�的响应
栈：只要栈的剩余�I�间大于所甌��I�间�Q�系�l�将为程序提供内存，否则��报异常提示栈溢出�?br />堆：首先应该知道操作�pȝ��有一个记录空闲内存地址的链表，当系�l�收到程序的甌��Ӟ��
会遍历该链表�Q�寻扄��一个空间大于所甌��I�间的堆�l�点�Q�然后将该结点从�I�闲�l�点链表中删除，�q�将该结点的�I�间分配�l�程序，另外�Q�对于大多数�pȝ��Q�会在这块内存空间中的首地址处记录本�ơ分配的大小�Q�这��P��代码中的delete语句才能正确的释放本内存�I�间。另外，�׃��扑ֈ�的堆�l�点的大��不一定正好等于申��L��大小�Q�系�l�会自动的将多余的那部分重新攑օ��I�闲链表中�?/p>

2.3甌��大小的限�?br />栈：在Windows�?栈是向低地址扩展的数据结构，是一块连�l�的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是�pȝ��预先规定好的�Q�在WINDOWS下，栈的大小�?M�Q�也有的说是1M�Q��M��是一个编译时��q��定的常数�Q�，如果甌��的空间超�q�栈的剩余空间时�Q�将提示overflow。因此，能从栈获得的�I�间较小�?br />堆：堆是向高地址扩展的数据结构，是不�q�箋的内存区域。这是由于系�l�是用链表来存储的空闲内存地址的，自然是不�q�箋的，而链表的遍历方向是由低地址向高地址。堆的大��受限于计算机系�l�中有效的虚拟内存。由此可见，堆获得的�I�间比较灉|��Q�也比较大�?/p>

2.4甌��效率的比较：
栈由�pȝ��自动分配�Q�速度较快。但�E�序员是无法控制的�?br />堆是由new分配的内存，一般速度比较慢，而且�Ҏ��产生内存��片,不过用�v来最方便.
另外�Q�在WINDOWS下，最好的方式是用VirtualAlloc分配内存�Q�他不是在堆�Q�也不是在栈是直接在�q�程的地址�I�间中保留一快内存，虽然用�v来最不方�ѝ��但是速度快，也最灉|��?/p>

2.5堆和栈中的存储内�?br />栈：在函数调用时�Q�第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句�Q�的地址�Q�然后是函数的各个参敎ͼ�在大多数的C�~�译器中�Q�参数是由右往左入栈的�Q�然后是函数中的局部变量。注意静态变量是不入栈的�?br />当本�ơ函数调用结束后�Q�局部变量先出栈�Q�然后是参数�Q�最后栈��指针指向最开始存的地址�Q�也��是��d��C��的下一条指令，�E�序��p��点��l�运行�?br />堆：一般是在堆的头部用一个字节存攑֠�的大��。堆中的具体内容有程序员安排�?/p>

2.6存取效率的比�?/p>

char s1[] = "aaaaaaaaaaaaaaa";
char *s2 = "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在�q�行时刻赋值的�Q?br />而bbbbbbbbbbb是在�~�译时就��定的；
但是�Q�在以后的存取中�Q�在栈上的数�l�比指针所指向的字�W�串(例如�?快�?br />比如�Q?br />�Q�i nclude
void main()
{
char a = 1;
char c[] = "1234567890";
char *p ="1234567890";
a = c[1];
a = p[1];
return;
}
对应的汇�~�代�?br />10: a = c[1];
00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]
0040106A 88 4D FC mov byte ptr [ebp-4],cl
11: a = p[1];
0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]
00401070 8A 42 01 mov al,byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4],al
�W�一�U�在��d��时直接就把字�W�串中的元素��d��寄存器cl中，而第二种则要先把指针��D��到edx中，在根据edx��d��字符�Q�显然慢了�?/p>

2.7��结�Q?br />堆和栈的区别可以用如下的比喻来看出：
使用栈就象我们去饭馆里吃饭，只管点菜�Q�发出申��P��、付钱、和吃（使用�Q�，吃饱了就赎ͼ�不必理会切菜、洗菜等准备工作和洗��、刷锅等扫尾工作�Q�他的好处是快捷�Q�但是自由度��?br />使用堆就象是自己动手做喜�Ƣ吃的菜��_��比较�ȝ��Q�但是比较符合自��q��口味�Q�而且自由度大

liaojiyong 2006-12-22 14:16 发表评论

得到PrepareStatement最�l�执行的sql语句的方�?�?

liaojiyong — Mon, 24 Jul 2006 08:22:00 GMT

在CSDN的JAVA基础�?常常有�h问及如何得到PreparedStatement最�l�执行的SQL语句;或者如何在控制台输出占位符的真实�?....

原因��是PreparedStatement执行的sql语句有大量的占位�W?....

问题诸如JDBC�?

如何得到 conn.prepareStatement 最�l�执行的sql语句�?br />sql="update table1 set a=?,b=?"
stmt = con.prepareStatement(sql);
stmt.setObjec t(1,"a");
stmt.setObjec t(2,"b");

希望可以通过stmt或者conn 得到�Q?br />update table1 set a='a',b='b'

亦或Hibernate�?br />

如我执行�Q�find("select * from t_table where id = ?",new Integer(5));
在控制台昄��SQL时只昄��Q�select * from t_table where id = ?
如何才能做到��控制台昄��的占位符用其真实的值来替换�Q?br />��x��制台输出时显�C�：select * from t_table where id = 5

无它�Q�无论JDBC�q�是Hiberante都不提供默认解决�Ҏ��Q�但是参数是讄��q�去的，我们在设�|�的�q�程中可以有充分的理由来截取�q�获得自己想要的东西�Q�类��g��AOP理论�?br />
�׃�n我在工程中的使用�Ҏ��Q?br />插入操作�Q?br />

/**
     * 执行插入数据库的语句
     * @param sql
     * @param params
     * @return �q�回生成的主�?br />     */
    public int executeInsert(String sql, Object[] params) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            //1 获得�q�接
            conn = MyDBConnection.getInstance().getConnection();
            //2 讄��提交方式为程序控�?/span>
            conn.setAutoCommit(false);
            //3 获得语句对象
            pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            //4 讄��SQL语句的参�?/span>
            if (null != params && 0 < params.length) {
                setParams(pstmt, params);
            }
            //5 打印SQL语句
            if (MyDBConstants.showSQL) {
                getPreparedSQL(sql, params);
            }
            //6 执行语句
            pstmt.executeUpdate();
            //7 �E�序提交
            conn.commit();
            //8 �q�回生成的主�?/span>
            rs = pstmt.getGeneratedKeys();
            int generatedKey = 0;
            if (rs.next()) {
                generatedKey = rs.getInt(1);
            }
            if (0 < generatedKey)
                throw new MySQLException("插入记录时出�?/span>");
            return generatedKey;
        } catch (SQLException e) {
            //回滚
            MyDBUtil.rollBack(conn);
            throw new MySQLException(e);
        } finally {
            //关闭打开的操�?/span>
            MyDBUtil.close(conn, pstmt, rs);
        }
    }

更新查找操作�Q?br />

/**
     * 执行更新或者删除数据库的语�?br />     * @param sql
     * @param params
     * @return �q�回执行成功与否
     */
    public boolean executeUpdateDel(String sql, Object[] params) {
        boolean isSuccess = false;
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            //1 获得�q�接
            conn = MyDBConnection.getInstance().getConnection();
            //2 讄��提交方式为程序控�?/span>
            conn.setAutoCommit(false);
            //3 获得语句对象
            pstmt = conn.prepareStatement(sql);
            //4 讄��SQL语句的参�?/span>
            if (null != params && 0 < params.length) {
                setParams(pstmt, params);
            }
            //5 打印SQL语句
            if (MyDBConstants.showSQL) {
                getPreparedSQL(sql, params);
            }
            //6 执行语句
            pstmt.executeUpdate();
            //7 �E�序提交
            conn.commit();
            //8 讄��语句执行的标�?/span>
            isSuccess = true;
        } catch (SQLException e) {
            //回滚
            MyDBUtil.rollBack(conn);
            throw new MySQLException(e);
        } finally {
            //关闭打开的操�?/span>
            MyDBUtil.close(conn, pstmt);
        }
        return isSuccess;
    }

执行查询

1 /**
2      * 执行查询数据库的语句;
9      *
10      * @return
11      */
12     public Object executeQuery(String sql, Object[] params) {
13         Connection conn = null;
14         PreparedStatement pstmt = null;
15         ResultSet rs = null;
16         try {
17             //1 获得�q�接
18             conn = MyDBConnection.getInstance().getConnection();
19             //2 讄��提交方式为程序控�?/span>
20             conn.setAutoCommit(false);
21             //3 获得语句对象
22             pstmt = conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
23             //4 讄��SQL语句的参�?/span>
24             if (null != params && 0 < params.length) {
25                 setParams(pstmt, params);
26             }
27             //5 打印SQL语句
28             if (MyDBConstants.showSQL) {
29                 getPreparedSQL(sql, params);
30             }
31             //6 执行语句
32             rs = pstmt.executeQuery();
33
34             //9 �E�序提交
35             conn.commit();
36
37             //10 获得记录
38             Object vo = new Object();
39             if (null != rs && rs.next()) {
40                 vo = rs2vo(rs);
41             }
42 //            return results;
43             return vo;
44         } catch (SQLException e) {
45             //回滚
46             MyDBUtil.rollBack(conn);
47             throw new MySQLException(e);
48         } finally {
49             //关闭打开的操�?/span>
50             MyDBUtil.close(conn, pstmt, rs);
51         }
52     }

看到getPreparedSQL(sql, params)了么�Q?�q�个地方��是要实现我们预期效果的地方�Q?br />

得到PrepareStatement最�l�执行的sql语句的方�?/span>

然后��L��核实你的控制台或者日志文件吧......

liaojiyong 2006-07-24 16:22 发表评论

liaojiyong — Mon, 24 Jul 2006 07:49:00 GMT

��Z��方便大家查找�Q�整理内容如下：
1. MySQL(http://www.mysql.com)mm.mysql-2.0.2-bin.jar
Class.forName( "org.gjt.mm.mysql.Driver" );
cn = DriverManager.getConnection( "jdbc:mysql://MyDbComputerNameOrIP:3306/myDatabaseName", sUsr, sPwd );

2. PostgreSQL(http://www.de.postgresql.org)pgjdbc2.jar
Class.forName( "org.postgresql.Driver" );
cn = DriverManager.getConnection( "jdbc:postgresql://MyDbComputerNameOrIP/myDatabaseName", sUsr, sPwd );

3. Oracle(http://www.oracle.com/ip/deploy/database/oracle9i/)classes12.zip
Class.forName( "oracle.jdbc.driver.OracleDriver" );
cn = DriverManager.getConnection( "jdbc:oracle:thin:@MyDbComputerNameOrIP:1521:ORCL", sUsr, sPwd );
4. Sybase(http://jtds.sourceforge.net)jconn2.jar

Class.forName( "com.sybase.jdbc2.jdbc.SybDriver" );
cn = DriverManager.getConnection( "jdbc:sybase:Tds:MyDbComputerNameOrIP:2638", sUsr, sPwd );
//(Default-Username/Password: "dba"/"sql")

5. Microsoft SQLServer(http://jtds.sourceforge.net)
Class.forName( "net.sourceforge.jtds.jdbc.Driver" );
cn = DriverManager.getConnection( "jdbc:jtds:sqlserver://MyDbComputerNameOrIP:1433/master", sUsr, sPwd );

6. Microsoft SQLServer(http://www.microsoft.com)
Class.forName( "com.microsoft.jdbc.sqlserver.SQLServerDriver" );
cn = DriverManager.getConnection( "jdbc:microsoft:sqlserver://MyDbComputerNameOrIP:1433;databaseName=master", sUsr, sPwd );

7. ODBC
Class.forName( "sun.jdbc.odbc.JdbcOdbcDriver" );
Connection cn = DriverManager.getConnection( "jdbc:odbc:" + sDsn, sUsr, sPwd );

8.DB2(新添�?
Class.forName("com.ibm.db2.jdbc.net.DB2Driver");
String url="jdbc:db2://192.9.200.108:6789/SAMPLE"
cn = DriverManager.getConnection( url, sUsr, sPwd );

9.Microsoft SQL Server series (6.5, 7.x and 2000) and Sybase 10

JDBC Name: jTDS
URL: http://jtds.sourceforge.net/
Version: 0.5.1
Download URL: http://sourceforge.net/project/showfiles.php?group_id=33291

语法:
Class.forName("net.sourceforge.jtds.jdbc.Driver ");
Connection con = DriverManager.getConnection("jdbc:jtds:sqlserver://host:port/database","user","password");
or
Connection con = DriverManager.getConnection("jdbc:jtds:sybase://host:port/database","user","password");

10.Postgresql
JDBC Name: PostgreSQL JDBC
URL: http://jdbc.postgresql.org/
Version: 7.3.3 build 110
Download URL: http://jdbc.postgresql.org/download.html
语法:
Class.forName("org.postgresql.Driver");
Connection con=DriverManager.getConnection("jdbc:postgresql://host:port/database","user","password");

11.IBM AS400��L��在用的JDBC语法
有装V4R4以上版本的Client Access Express
可以在C:\Program Files\IBM\Client Access\jt400\lib
扑ֈ� driver 档案 jt400.zip�Q��ƈ更改扩展名成�?jt400.jar
语法:
java.sql.DriverManager.registerDriver (new com.ibm.as400.access.AS400JDBCDriver ());
Class.forName("com.ibm.as400.access.AS400JDBCConnection");
con = DriverManager.getConnection("jdbc:as400://IP","user","password");

12.informix
Class.forName("com.informix.jdbc.IfxDriver").newInstance();
String url =
"jdbc:informix-sqli://123.45.67.89:1533/testDB:INFORMIXSERVER=myserver;
user=testuser;password=testpassword";
Lib�Q�jdbcdrv.zip

Class.forName( "com.sybase.jdbc.SybDriver" )
url="jdbc:sybase:Tds:127.0.0.1:2638/asademo";
SybConnection connection= (SybConnection)DriverManager.getConnection(url,"dba","sql");

13.SAP DB
Class.forName ("com.sap.dbtech.jdbc.DriverSapDB");
java.sql.Connection connection = java.sql.DriverManager.getConnection ( "jdbc:sapdb://" + host + "/" + database_name,user_name, password)

14.InterBase
String url = "jdbc:interbase://localhost/e:/testbed/database/employee.gdb";
Class.forName("interbase.interclient.Driver");
//Driver d = new interbase.interclient.Driver (); /* this will also work if you do not want the line above */
Connection conn = DriverManager.getConnection( url, "sysdba", "masterkey" );

15.HSqlDB
url: http://hsqldb.sourceforge.net/
driver: org.hsqldb.jdbcDriver
�q�接方式�?�U�，分别为：
con-str�Q�内存）: jdbc:hsqldb.
con-str�Q�本圎ͼ�: jdbc:hsqldb:/path/to/the/db/dir
con-str�Q�http�Q? jdbc:hsqldb:http://dbsrv
con-str�Q�hsql�Q? jdbc:hsqldb:hsql://dbsrv

liaojiyong 2006-07-24 15:49 发表评论

关系数据库设计理论－�Q?gt;3NF

liaojiyong — Tue, 23 May 2006 02:44:00 GMT

摘要: 函数依赖 1.函数依赖定义 A�Q?gt; B�Q�即 �? A函数军_��B �? �Q�A�U�Cؓ军_��因素�? 2�Q�关�pȝ��键码、超键码属性函数决定关�p�R的所有其它属性，�q�且该属性的��M��真子集都不能函数军_��R的所有其它属性，则属性是键码�?键码必须... 阅读全文

liaojiyong 2006-05-23 10:44 发表评论